lizardfs-v.3.9.4/ 0000775 0000000 0000000 00000000000 12631772427 0013624 5 ustar 00root root 0000000 0000000 lizardfs-v.3.9.4/.gitignore 0000664 0000000 0000000 00000001454 12631772427 0015620 0 ustar 00root root 0000000 0000000 *~
.DS_Store
# External libraries #
######################
/external/gtest-1.7.0
# Vim files #
#############
.clang_complete
tags
*.taghl
compile_commands.json
.ycm_extra_conf.py
# Commonly used build directory #
#################################
/build*
# Eclipse project files #
#########################
/.project
/.cproject
/.settings
# KDevelop4 project file #
##########################
*.kdev4
# QtCreator user profiles #
###########################
*.user
# Debian builds #
#################
/Makefile
/debian/files
/debian/*.debhelper
/debian/*.substvars
/debian/*.debhelper.log
/debian/lizardfs-adm/
/debian/lizardfs-cgi/
/debian/lizardfs-cgiserv/
/debian/lizardfs-chunkserver/
/debian/lizardfs-client/
/debian/lizardfs-common/
/debian/lizardfs-master/
/debian/lizardfs-metalogger/
/debian/tmp/
lizardfs-v.3.9.4/CMakeLists.txt 0000664 0000000 0000000 00000025305 12631772427 0016371 0 ustar 00root root 0000000 0000000 cmake_minimum_required(VERSION 2.8)
set(CMAKE_LEGACY_CYGWIN_WIN32 0) # Remove when CMake >= 2.8.4 is required
set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_MODULE_PATH})
if(CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR)
message(FATAL_ERROR
"In-source builds are disabled for this project. This is for your "
"safety. To build the project, please create a build tree in "
"a separate directory, for example:\n"
" mkdir ${CMAKE_SOURCE_DIR}/build\n"
" cd ${CMAKE_SOURCE_DIR}/build\n"
" cmake ..\n"
"Before doing that you may need to clean up after this try by removing "
"CMakeCache.txt file and CMakeFiles/ directory.\n"
"If you REALLY need an in-source build, remove this check from "
"${CMAKE_CURRENT_LIST_FILE} and try again."
)
endif()
project(lizardfs)
set(PACKAGE_VERSION_MAJOR 3)
set(PACKAGE_VERSION_MINOR 9)
set(PACKAGE_VERSION_MICRO 4)
set(PACKAGE_VERSION
"${PACKAGE_VERSION_MAJOR}.${PACKAGE_VERSION_MINOR}.${PACKAGE_VERSION_MICRO}")
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE Debug)
endif()
set(CXX_STD c++0x)
if(CYGWIN)
set(CXX_STD gnu++11)
endif()
if(CMAKE_SYSTEM_NAME STREQUAL "SunOS")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -m64" )
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -m64")
endif()
if(MINGW)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wformat=0")
endif()
string(REPLACE "-DNDEBUG" "" CMAKE_CXX_FLAGS_RELWITHDEBINFO ${CMAKE_CXX_FLAGS_RELWITHDEBINFO})
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pipe -std=${CXX_STD} -pthread -Wall -Wextra -fwrapv")
set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g")
set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3 -DNDEBUG -g")
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} -O2 -ftree-vectorize -g -fno-omit-frame-pointer")
set(CMAKE_CXX_FLAGS_COVERAGE "-O0 -g --coverage")
set(CMAKE_CXX_FLAGS_CLANG_ANALYZE "--analyze -Xanalyzer -analyzer-output=text")
set(CMAKE_CXX_FLAGS_CLANG_SANITIZE_THREAD "-g -O0 -fsanitize=thread")
add_definitions(-D_LARGEFILE_SOURCE)
add_definitions(-D_FILE_OFFSET_BITS=64)
add_definitions(-DLIZARDFS_HAVE_CONFIG_H)
add_definitions(-D__STDC_LIMIT_MACROS)
add_definitions(-D__STDC_CONSTANT_MACROS)
add_definitions(-D__STDC_FORMAT_MACROS)
if(MINGW)
add_definitions(-DWINVER=0x0602)
add_definitions(-D_WIN32_WINNT=0x0602)
add_definitions(-DFD_SETSIZE=1024)
set(MINGW_MSVCRT "msvcr110")
endif()
# XXX(lamvak): what about OS X?
set(DEFAULT_USER "mfs" CACHE STRING "Default user to run daemons as")
set(DEFAULT_GROUP "mfs" CACHE STRING "Default group to run daemons as")
set(LIZARDFS_BLOCKS_IN_CHUNK 1024 CACHE INT "Number of blocks in one chunk")
set(LIZARDFS_BLOCK_SIZE 65536 CACHE INT "Number of bytes in one block")
option(ENABLE_WERROR "Enable treating compilation warnings as errors" OFF)
option(ENABLE_LIGHTMFS "Enable light version of LizardFS" OFF)
option(ENABLE_DEBIAN_PATHS "Enable Debian-style install paths" OFF)
option(ENABLE_UTILS "Enable building additional binaries used e.g. in tests" OFF)
option(ENABLE_TESTS "Enable building unit and functional tests" OFF)
option(ENABLE_DOCS "Enable building the documentation" ON)
option(ENABLE_EXIT_ON_USR1 "Enable handler for SIGUSR1 which calls exit()" OFF)
option(THROW_INSTEAD_OF_ABORT "Throw std::exception instead of calling abort" OFF)
option(ENABLE_DEBUG_LOG "Enable prefix based debug logs" OFF)
option(ENABLE_VERBOSE_ASCIIDOC "Enable verbose output of asciidoc" OFF)
option(ENABLE_TCMALLOC "Enable use of tcmalloc-minimal library" OFF)
# end of LizardFS options
option(ENABLE_TRACES "Enable traces" OFF)
option(ENABLE_CRC "Enable checksums" ON)
option(ENABLE_REQUEST_LOG "Enable logging request times" OFF)
option(USE_LEGACY_READ_MESSAGES "Enable sending old type of messages by mount" OFF)
message(STATUS "CMAKE_BUILD_TYPE: ${CMAKE_BUILD_TYPE}")
message(STATUS "CMAKE_INSTALL_PREFIX: ${CMAKE_INSTALL_PREFIX}")
message(STATUS "DEFAULT_USER: ${DEFAULT_USER}")
message(STATUS "DEFAULT_GROUP: ${DEFAULT_GROUP}")
message(STATUS "LIZARDFS_BLOCKS_IN_CHUNK: ${LIZARDFS_BLOCKS_IN_CHUNK}")
message(STATUS "LIZARDFS_BLOCK_SIZE: ${LIZARDFS_BLOCK_SIZE}")
message(STATUS "ENABLE_WERROR: ${ENABLE_WERROR}")
message(STATUS "ENABLE_LIGHTMFS: ${ENABLE_LIGHTMFS}")
message(STATUS "ENABLE_DEBIAN_PATHS: ${ENABLE_DEBIAN_PATHS}")
message(STATUS "ENABLE_UTILS: ${ENABLE_UTILS}")
message(STATUS "ENABLE_TESTS: ${ENABLE_TESTS}")
message(STATUS "ENABLE_DOCS: ${ENABLE_DOCS}")
message(STATUS "ENABLE_EXIT_ON_USR1: ${ENABLE_EXIT_ON_USR1}")
message(STATUS "THROW_INSTEAD_OF_ABORT: ${THROW_INSTEAD_OF_ABORT}")
message(STATUS "ENABLE_DEBUG_LOG: ${ENABLE_DEBUG_LOG}")
message(STATUS "ENABLE_VERBOSE_ASCIIDOC: ${ENABLE_VERBOSE_ASCIIDOC}")
message(STATUS "ENABLE_TCMALLOC: ${ENABLE_TCMALLOC}")
# end of LizardFS options values
message(STATUS "ENABLE_TRACES: ${ENABLE_TRACES}")
message(STATUS "ENABLE_CRC: ${ENABLE_CRC}")
message(STATUS "ENABLE_REQUEST_LOG: ${ENABLE_REQUEST_LOG}")
message(STATUS "USE_LEGACY_READ_MESSAGES: ${USE_LEGACY_READ_MESSAGES}")
# All the environment tests (libs, includes, etc.) live here:
include(EnvTests.cmake)
include(Libraries)
include(GNUInstallDirs)
check_includes("${INCLUDES}")
# Disable -pedantic for old gcc because of unfounded
# "no comma at end of enumerator list" warning during crcutil compilation
execute_process(COMMAND ${CMAKE_CXX_COMPILER} -dumpversion OUTPUT_VARIABLE COMPILER_VERSION)
if(ENABLE_WERROR AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND COMPILER_VERSION VERSION_LESS 4.7)
message(STATUS "Flag '-pedantic' disabled for GCC < 4.7")
else()
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic")
endif()
if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Qunused-arguments")
endif()
if(CXX_HAS_WNOGNU)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-gnu")
endif()
if(ENABLE_WERROR)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror")
endif()
if(ENABLE_TESTS AND NOT THROW_INSTEAD_OF_ABORT)
message(STATUS "Tests require THROW_INSTEAD_OF_ABORT to be set to YES, changing passed value:")
set(THROW_INSTEAD_OF_ABORT YES)
message(STATUS "THROW_INSTEAD_OF_ABORT: ${THROW_INSTEAD_OF_ABORT}")
endif()
if(ENABLE_DEBIAN_PATHS)
if (NOT CMAKE_INSTALL_PREFIX STREQUAL "/")
message(WARNING "Debian paths enabled, but CMAKE_INSTALL_PREFIX is different than /")
endif()
set(BIN_SUBDIR "usr/bin")
set(SBIN_SUBDIR "usr/sbin")
set(LIB_SUBDIR "usr/lib")
set(ETC_SUBDIR "etc/mfs")
set(RUN_SUBDIR "var/run/mfs")
set(DATA_SUBDIR "var/lib/mfs")
set(MAN_SUBDIR "usr/share/man")
set(CGI_SUBDIR "usr/share/mfscgi")
else()
set(BIN_SUBDIR "bin")
set(SBIN_SUBDIR "sbin")
set(LIB_SUBDIR "lib")
set(ETC_SUBDIR "etc/mfs")
set(RUN_SUBDIR "var/run/mfs")
set(DATA_SUBDIR "var/lib/mfs")
set(MAN_SUBDIR "share/man")
set(CGI_SUBDIR "share/mfscgi")
endif()
string(REGEX REPLACE "/$" "" INSTALL_PREFIX_NO_SLASH ${CMAKE_INSTALL_PREFIX})
set(BIN_PATH ${INSTALL_PREFIX_NO_SLASH}/${BIN_SUBDIR})
set(SBIN_PATH ${INSTALL_PREFIX_NO_SLASH}/${SBIN_SUBDIR})
set(LIB_PATH ${INSTALL_PREFIX_NO_SLASH}/${LIB_SUBDIR})
set(ETC_PATH ${INSTALL_PREFIX_NO_SLASH}/${ETC_SUBDIR})
set(RUN_PATH ${INSTALL_PREFIX_NO_SLASH}/${RUN_SUBDIR})
set(DATA_PATH ${INSTALL_PREFIX_NO_SLASH}/${DATA_SUBDIR})
set(MAN_PATH ${INSTALL_PREFIX_NO_SLASH}/${MAN_SUBDIR})
set(CGI_PATH ${INSTALL_PREFIX_NO_SLASH}/${CGI_SUBDIR})
if(ENABLE_LIGHTMFS)
set(PROTO_BASE 65536)
set(LIGHT_MFS 1)
else()
set(PROTO_BASE 0)
set(LIGHT_MFS 0)
endif()
if(ENABLE_UTILS)
set(BUILD_UTILS ON)
endif()
if(ENABLE_TESTS)
set(BUILD_TESTS ON)
set(BUILD_UTILS ON)
set(LIZARDFS_ENABLE_DEBUG_LOG ON)
endif()
if(ENABLE_DEBUG_LOG)
set(LIZARDFS_ENABLE_DEBUG_LOG ON)
endif()
if(ENABLE_TRACES)
if(NOT Boost_INCLUDE_DIRS)
message(FATAL_ERROR "Boost headers are required if traces are enabled")
endif()
add_definitions(-DENABLE_TRACES)
endif()
if(ENABLE_REQUEST_LOG)
if(NOT Boost_IOSTREAMS_FOUND)
message(FATAL_ERROR "Boost iostreams is required if request time logging is enabled")
endif()
set(ADDITIONAL_LIBS ${Boost_IOSTREAMS_LIBRARY})
add_definitions(-DENABLE_REQUEST_LOG)
endif()
set(CHARTS_CSV_CHARTID_BASE 90000)
if(THROW_INSTEAD_OF_ABORT)
add_definitions(-DTHROW_INSTEAD_OF_ABORT)
endif()
if(USE_LEGACY_READ_MESSAGES)
add_definitions(-DUSE_LEGACY_READ_MESSAGES)
endif()
if(ENABLE_CRC)
message(STATUS "CRC checksums enabled")
add_definitions(-DENABLE_CRC)
else()
message(STATUS "CRC checksums disabled")
endif()
set(CHARTS_CSV_CHARTID_BASE 90000)
# Create config.h file
configure_file(config.h.in config.h)
include_directories(${CMAKE_BINARY_DIR}) # Here we have generated config.h
# main.cc shared by some LizardFS applications
set(MAIN_SRC ${CMAKE_SOURCE_DIR}/src/main/main.cc)
# functions & macros
macro(collect_sources VAR_PREFIX)
file(GLOB ${VAR_PREFIX}_TESTS *_unittest.cc)
file(GLOB ${VAR_PREFIX}_SOURCES *.cc *.h)
file(GLOB ${VAR_PREFIX}_MAIN main.cc)
if(${VAR_PREFIX}_MAIN OR ${VAR_PREFIX}_TESTS)
list(REMOVE_ITEM ${VAR_PREFIX}_SOURCES ${${VAR_PREFIX}_TESTS} ${${VAR_PREFIX}_MAIN})
endif()
endmacro(collect_sources)
function(add_tests TESTED_LIBRARY)
if(NOT BUILD_TESTS OR ARGC EQUAL 1)
return()
endif()
list(REMOVE_AT ARGV 0)
set(TEST_LIBRARY_NAME ${TESTED_LIBRARY}_tests)
include_directories(${GTEST_INCLUDE_DIRS})
add_library(${TEST_LIBRARY_NAME} ${ARGV})
target_link_libraries(${TEST_LIBRARY_NAME} ${TESTED_LIBRARY})
set(TMP ${TEST_LIBRARIES})
list(APPEND TMP ${TEST_LIBRARY_NAME})
set(TEST_LIBRARIES ${TMP} CACHE INTERNAL "" FORCE)
endfunction(add_tests)
if(ZLIB_FOUND)
include_directories(${ZLIB_INCLUDE_DIRS})
endif()
include_directories(src) # Allow paths relative to src, eg. #include common/crc.h
link_directories( ${LINK_DIRECTORIES} ${PC_FUSE_LIBRARY_DIRS} )
add_subdirectory(external)
add_subdirectory(src/admin)
add_subdirectory(src/common)
add_subdirectory(src/protocol)
add_subdirectory(src/mount)
add_subdirectory(src/mount/polonaise)
if(NOT MINGW)
if(BUILD_DEVTOOLS)
add_subdirectory(src/devtools)
endif()
add_subdirectory(src/chunkserver)
add_subdirectory(src/master)
add_subdirectory(src/metadump)
add_subdirectory(src/metalogger)
add_subdirectory(src/metarestore)
add_subdirectory(src/tools)
if (FUSE_LIBRARY)
add_subdirectory(src/mount/fuse)
endif()
add_subdirectory(src/data)
add_subdirectory(src/cgi)
if(BUILD_UTILS)
add_subdirectory(utils)
endif()
if(BUILD_TESTS)
add_subdirectory(src/unittests)
add_subdirectory(tests)
endif()
if(ENABLE_DOCS)
add_subdirectory(doc)
endif()
endif()
lizardfs-v.3.9.4/COPYING 0000664 0000000 0000000 00000104374 12631772427 0014670 0 ustar 00root root 0000000 0000000
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
.
lizardfs-v.3.9.4/CheckCXXExpression.cmake 0000664 0000000 0000000 00000001072 12631772427 0020306 0 ustar 00root root 0000000 0000000 include(CheckCXXSourceRuns)
function(check_cxx_expression _EXPR _HEADER _RESULT)
set(_INCLUDE_FILES)
foreach (it ${_HEADER})
set(_INCLUDE_FILES "${_INCLUDE_FILES}#include <${it}>\n")
endforeach ()
set(_CHECK_CXX_EXPRESSION_SOURCE_CODE "
${_INCLUDE_FILES}
template
struct bool_value {
};
template<>
struct bool_value {
typedef int value_type;
};
int main() {
typename bool_value<(bool)(${_EXPR})>::value_type r = 0;
return r;
}
")
CHECK_CXX_SOURCE_COMPILES("${_CHECK_CXX_EXPRESSION_SOURCE_CODE}" ${_RESULT})
endfunction()
lizardfs-v.3.9.4/CheckFunctions.cmake 0000664 0000000 0000000 00000001141 12631772427 0017531 0 ustar 00root root 0000000 0000000 function(check_functions FUNCTIONS REQUIRED)
foreach(FUNC ${FUNCTIONS})
string(TOUPPER "LIZARDFS_HAVE_${FUNC}" VAR)
CHECK_FUNCTION_EXISTS(${FUNC} ${VAR})
if(${REQUIRED})
if("${${VAR}}" STREQUAL "" OR NOT ${${VAR}} EQUAL 1)
message(SEND_ERROR "function ${FUNC} is required")
endif()
endif()
endforeach()
endfunction()
function(check_template_function_exists HEADER CALL OUTPUT_VARIABLE)
if (NOT DEFINED ${OUTPUT_VARIABLE})
check_cxx_source_compiles("
#include <${HEADER}>
int main(int, char**) {
${CALL};
return 0;
}" ${OUTPUT_VARIABLE})
endif()
endfunction()
lizardfs-v.3.9.4/CheckIncludes.cmake 0000664 0000000 0000000 00000001323 12631772427 0017331 0 ustar 00root root 0000000 0000000 function(check_includes INCLUDES)
set(INCLUDE_MISSING FALSE)
foreach(INCLUDE_FILE ${INCLUDES})
check_include_files(${INCLUDE_FILE} ${INCLUDE_FILE}_FOUND)
if(NOT ${INCLUDE_FILE}_FOUND)
set(INCLUDE_MISSING TRUE)
set(MISSING_INCLUDES ${MISSING_INCLUDES} ${INCLUDE_FILE})
else()
# Auto '#cmakedefine' variable generation
string(REPLACE "/" "_" INCLUDE_FILE_STR ${INCLUDE_FILE})
string(REPLACE "." "_" INCLUDE_FILE_STR ${INCLUDE_FILE_STR})
string(TOUPPER "LIZARDFS_HAVE_${INCLUDE_FILE_STR}" VAR)
set(${VAR} TRUE PARENT_SCOPE)
endif()
endforeach()
if(INCLUDE_MISSING)
message("Some include files were not found: ${MISSING_INCLUDES}")
endif()
endfunction()
lizardfs-v.3.9.4/CheckMembers.cmake 0000664 0000000 0000000 00000000642 12631772427 0017160 0 ustar 00root root 0000000 0000000 function(check_members STRUCT MEMBERS HEADER)
foreach(MEMBER ${MEMBERS})
string(REPLACE " " "_" STRUCT_STR ${STRUCT})
string(TOUPPER "LIZARDFS_HAVE_${STRUCT_STR}_${MEMBER}" VAR)
CHECK_STRUCT_HAS_MEMBER(${STRUCT} ${MEMBER} ${HEADER} ${VAR})
if(NOT ${${VAR}} EQUAL 1)
set(${VAR} 0)
message(WARNING "${STRUCT} has no member ${MEMBER}")
endif()
endforeach()
endfunction(check_members)
lizardfs-v.3.9.4/EnvTests.cmake 0000664 0000000 0000000 00000005574 12631772427 0016414 0 ustar 00root root 0000000 0000000 # comparing build config with (old) autotools build,
# refer to ced2e72776fd01e71f1c7eece9c4414b1fe23c54 / configure.ac
# discarded tests:
# keywords tests for inline, volatile and const
# functions marked here as required, that don't appear in the code: atexit strchr
# checking for fork and vfork, but vfork unused
# XXX(lamvak): didn't add check for strerror_r function compatible with
# AC_FUNC_STRERROR_R
include(CheckCXXCompilerFlag)
include(CheckCXXExpression.cmake)
include(CheckCXXSourceCompiles)
include(CheckFunctionExists)
include(CheckFunctions)
include(CheckIncludes)
include(CheckLibraryExists)
include(CheckMembers)
include(CheckStructHasMember)
include(CheckTypeSize)
include(TestBigEndian)
set(INCLUDES arpa/inet.h endian.h fcntl.h inttypes.h limits.h netdb.h
netinet/in.h stddef.h stdlib.h string.h sys/mman.h
sys/resource.h sys/rusage.h sys/socket.h sys/statvfs.h sys/time.h
syslog.h unistd.h stdbool.h Judy.h
)
TEST_BIG_ENDIAN(BIG_ENDIAN)
if(BIG_ENDIAN)
set(WORDS_BIGENDIAN 1)
endif()
set(TYPES_CHECKED int8_t uint8_t int16_t uint16_t int32_t uint32_t int64_t
uint64_t uid_t mode_t off_t pid_t size_t)
set(CMAKE_EXTRA_INCLUDE_FILES stdint.h)
foreach(TYPE ${TYPES_CHECKED})
string(TOUPPER ${TYPE} TYPE_SIZE_VAR)
CHECK_TYPE_SIZE(${TYPE} ${TYPE_SIZE_VAR})
endforeach()
set(CMAKE_EXTRA_INCLUDE_FILES)
#XXX(lamvak): now handle possible missing types or different type sizes
set(ST_MEMBERS_CHECKED st_blocks st_rdev st_birthtime st_blksize st_flags)
check_members("struct stat" "${ST_MEMBERS_CHECKED}" "sys/stat.h")
check_members("struct tm" "tm_gmtoff" "time.h")
check_members("struct rusage" "ru_maxrss" "sys/resource.h")
CHECK_FUNCTION_EXISTS(fork LIZARDFS_HAVE_WORKING_FORK)
CHECK_FUNCTION_EXISTS(vfork LIZARDFS_HAVE_WORKING_VFORK)
CHECK_TEMPLATE_FUNCTION_EXISTS("string" "std::to_string(0)" LIZARDFS_HAVE_STD_TO_STRING)
CHECK_TEMPLATE_FUNCTION_EXISTS("string" "std::stoull(\"0\")" LIZARDFS_HAVE_STD_STOULL)
set(REQUIRED_FUNCTIONS atexit ftruncate gettimeofday memmove memset mkdir strchr strdup strtol
strtoul ftello fseeko)
if(NOT MINGW)
list(APPEND REQUIRED_FUNCTIONS getpass poll realpath)
endif()
check_functions("${REQUIRED_FUNCTIONS}" TRUE)
set(OPTIONAL_FUNCTIONS strerror perror pread pwrite readv writev getrusage
setitimer posix_fadvise splice)
check_functions("${OPTIONAL_FUNCTIONS}" false)
CHECK_LIBRARY_EXISTS(rt clock_gettime "time.h" LIZARDFS_HAVE_CLOCK_GETTIME)
set(CMAKE_REQUIRED_INCLUDES "sys/mman.h")
set(OPTIONAL_FUNCTIONS2 dup2 mlockall getcwd)
check_functions("${OPTIONAL_FUNCTIONS2}" false)
set(CMAKE_REQUIRED_FLAGS "-std=c++11")
check_cxx_expression(::std::chrono::steady_clock::is_steady chrono LIZARDFS_HAVE_STD_CHRONO_STEADY_CLOCK)
check_cxx_expression("sizeof(::std::allocator_traits>::pointer)" memory LIZARDFS_HAVE_STD_ALLOCATOR_TRAITS)
unset(CMAKE_REQUIRED_FLAGS)
check_cxx_compiler_flag(-mcrc32 CXX_HAS_MCRC32)
lizardfs-v.3.9.4/FindFUSE.cmake 0000664 0000000 0000000 00000000270 12631772427 0016170 0 ustar 00root root 0000000 0000000
find_package(PkgConfig REQUIRED)
if(PKG_CONFIG_FOUND)
pkg_check_modules(PC_FUSE REQUIRED fuse)
message(STATUS "FUSE version ${PC_FUSE_VERSION} found")
endif(PKG_CONFIG_FOUND)
lizardfs-v.3.9.4/FindPAM.cmake 0000664 0000000 0000000 00000001037 12631772427 0016045 0 ustar 00root root 0000000 0000000 # - Try to find the PAM libraries
#
# PAM_FOUND - system has pam
# PAM_INCLUDE_DIR - the pam include directory
# PAM_LIBRARIES - pam libraries
find_path(PAM_INCLUDE_DIR NAMES pam_appl.h PATH_SUFFIXES security pam)
find_library(PAM_LIBRARY pam)
find_library(PAM_MISC_LIBRARY pam_misc)
if(PAM_LIBRARY AND PAM_MISC_LIBRARY)
set(PAM_LIBRARIES ${PAM_LIBRARY} ${PAM_MISC_LIBRARY})
endif()
find_package_handle_standard_args(PAM FOUND_VAR PAM_FOUND
REQUIRED_VARS PAM_LIBRARY PAM_MISC_LIBRARY PAM_INCLUDE_DIR)
lizardfs-v.3.9.4/FindSocket.cmake 0000664 0000000 0000000 00000003144 12631772427 0016661 0 ustar 00root root 0000000 0000000 # You may redistribute this program and/or modify it under the terms of
# the GNU General Public License as published by the Free Software Foundation,
# either version 3 of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .
# This is for finding berkley socket functions
# it specifically looks for socket()
# brought from: https://raw.github.com/cjdelisle/cjdns/master/cmake/modules/FindSocket.cmake
include(CheckFunctionExists)
if(NOT SOCKET_FOUND AND NOT NO_SOCKET)
check_function_exists(socket LIZARDFS_HAVE_SOCKET)
if(LIZARDFS_HAVE_SOCKET)
set(SOCKET_FOUND TRUE)
set(SOCKET_LIBRARIES "")
else()
message("socket() not found, searching for library")
endif()
# mingw32 uses ws2_32
# illumos uses socket
if(NOT SOCKET_FOUND)
find_library(SOCKET_LIBRARIES
NAMES
ws2_32
socket
PATHS
${SOCKET_PREFIX}/
/lib/
)
if(SOCKET_LIBRARIES)
message("Socket library was found at [${SOCKET_LIBRARIES}]")
set(SOCKET_FOUND TRUE)
set(LIZARDFS_HAVE_SOCKET)
elseif(Socket_FIND_REQUIRED)
message(FATAL_ERROR "Could not find socket library, try to setup SOCKET_PREFIX accordingly")
else()
message("Could not find socket library, skipping because Socket_FIND_REQUIRED is not set")
endif()
endif()
endif()
lizardfs-v.3.9.4/FindThrift.cmake 0000664 0000000 0000000 00000003447 12631772427 0016677 0 ustar 00root root 0000000 0000000 # Finds Thrift
# Input:
# THRIFT_ROOT -- Thrift installation prefix (optional)
# Output:
# THRIFT_FOUND
# THRIFT_INCLUDE_DIRS
# THRIFT_LIBRARIES
# THRIFT_COMPILER
# Dependencies:
if (NOT Boost_INCLUDE_DIRS)
if(Thrift_FIND_REQUIRED)
message(FATAL_ERROR "Thrift requires Boost headers")
elseif(NOT Thrift_FIND_QUIETLY)
message(STATUS "Thrift requires Boost headers")
endif()
return()
endif()
# Find all possible components, ie. library and compiler
find_path(THRIFT_INCLUDE_DIR thrift/Thrift.h HINTS
$ENV{THRIFT_ROOT}/include
${THRIFT_ROOT}/include
/opt/thrift-0.9.1/include
/opt/thrift-0.9.0/include)
mark_as_advanced(THRIFT_INCLUDE_DIR)
find_library(THRIFT_LIBRARY thrift HINTS ${THRIFT_INCLUDE_DIR}/../lib)
mark_as_advanced(THRIFT_LIBRARY)
find_program(THRIFT_COMPILER thrift HINTS
${THRIFT_INCLUDE_DIR}/../bin
$ENV{THRIFT_ROOT}/bin
${THRIFT_ROOT}/bin
/opt/thrift-0.9.1/bin
/opt/thrift-0.9.0/bin)
mark_as_advanced(THRIFT_COMPILER)
# Call find_package_handle_standard_args for components required in find_package(Thrift)
set(REQUIRED_ITEMS "")
foreach(COMPONENT ${Thrift_FIND_COMPONENTS})
if (COMPONENT STREQUAL "library")
set(REQUIRED_ITEMS ${REQUIRED_ITEMS} "THRIFT_INCLUDE_DIR" "THRIFT_LIBRARY")
elseif(COMPONENT STREQUAL "compiler")
set(REQUIRED_ITEMS ${REQUIRED_ITEMS} "THRIFT_COMPILER")
else()
message(FATAL_ERROR "Requested an unknown Thrift component '${COMPONENT}'")
endif()
endforeach()
if (REQUIRED_ITEMS STREQUAL "")
set(REQUIRED_ITEMS "THRIFT_INCLUDE_DIR" "THRIFT_LIBRARY")
endif()
include(FindPackageHandleStandardArgs)
find_package_handle_standard_args(Thrift DEFAULT_MSG ${REQUIRED_ITEMS})
if (THRIFT_INCLUDE_DIR)
set(THRIFT_INCLUDE_DIRS ${THRIFT_INCLUDE_DIR} ${Boost_INCLUDE_DIRS})
endif()
if (THRIFT_LIBRARY)
set(THRIFT_LIBRARIES ${THRIFT_LIBRARY})
endif()
lizardfs-v.3.9.4/INSTALL 0000664 0000000 0000000 00000001446 12631772427 0014662 0 ustar 00root root 0000000 0000000 Installing LizardFS from source.
Current LizardFS source code can be obtained at:
http://lizardfs.com/download/
LizardFS uses cmake as its build system. To compile the sources, follow
the directions outlined below.
1. Create a build directory inside the source directory.
cd lizardfs-source
mkdir build
2. Run 'cmake ..' inside the build directory. Useful options include
'-DCMAKE_INSTALL_PREFIX', '-DCMAKE_BUILD_TYPE' as well as various
LizardFS-specific '-DENABLE_...' options. Options are listed when
cmake is ran and can be changed by re-running cmake.
cd build
cmake .. -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/opt/lizardfs
3. Run make in the build directory.
make
4. Run make install to install files (you may need to be root).
make install
lizardfs-v.3.9.4/Libraries.cmake 0000664 0000000 0000000 00000011373 12631772427 0016547 0 ustar 00root root 0000000 0000000 # Download GoogleTest
if(ENABLE_TESTS)
set(GTEST_VERSION 1.7.0)
set(GTEST_NAME gtest-${GTEST_VERSION})
if(NOT IS_DIRECTORY ${CMAKE_SOURCE_DIR}/external/${GTEST_NAME})
set(GTEST_ARCHIVE ${GTEST_NAME}.zip)
set(GTEST_URL http://googletest.googlecode.com/files/${GTEST_ARCHIVE})
set(GTEST_ARCHIVE_MD5 2d6ec8ccdf5c46b05ba54a9fd1d130d7)
message(STATUS "Downloading ${GTEST_URL}...")
file(DOWNLOAD
${GTEST_URL}
${CMAKE_BINARY_DIR}/${GTEST_ARCHIVE}
INACTIVITY_TIMEOUT 15
SHOW_PROGRESS
STATUS DOWNLOAD_STATUS
EXPECTED_MD5 ${GTEST_ARCHIVE_MD5})
list(GET DOWNLOAD_STATUS 0 DOWNLOAD_CODE)
if(NOT DOWNLOAD_CODE EQUAL 0)
list(GET DOWNLOAD_STATUS 1 DOWNLOAD_MESSAGE)
message(FATAL_ERROR "Download ${GTEST_URL} error ${DOWNLOAD_CODE}: ${DOWNLOAD_MESSAGE}")
endif()
message(STATUS "Unpacking ${GTEST_ARCHIVE}...")
execute_process(COMMAND unzip -q ${CMAKE_BINARY_DIR}/${GTEST_ARCHIVE}
WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/external
RESULT_VARIABLE UNZIP_ERROR
ERROR_VARIABLE UNZIP_ERROR_MESSAGE)
if(NOT UNZIP_ERROR STREQUAL 0)
message(FATAL_ERROR "unzip ${GTEST_ARCHIVE} failed: ${UNZIP_ERROR} ${UNZIP_ERROR_MESSAGE}")
endif()
if(NOT IS_DIRECTORY ${CMAKE_SOURCE_DIR}/external/${GTEST_NAME})
message(FATAL_ERROR "Extracting ${GTEST_ARCHIVE} didn't produce directory '${GTEST_NAME}'")
endif()
message(STATUS "Downloading ${GTEST_NAME} finished successfully")
else()
message(STATUS "Found ${GTEST_NAME}")
endif()
endif()
# Find standard libraries
find_package(Socket REQUIRED)
find_package(Threads REQUIRED)
if(APPLE)
find_package(FUSE REQUIRED)
find_path(FUSE_INCLUDE_DIRS "fuse/fuse.h" PATHS ${PC_FUSE_INCLUDE_DIRS} ${PC_FUSE_INCLUDE_DIRS}/..)
set(FUSE_LIBRARY ${PC_FUSE_LIBRARIES})
else()
find_library(FUSE_LIBRARY fuse)
endif()
message(STATUS "FUSE_LIBRARY: ${FUSE_LIBRARY}")
find_library(RT_LIBRARY rt)
message(STATUS "RT_LIBRARY: ${RT_LIBRARY}")
if(ENABLE_TCMALLOC)
find_library(TCMALLOC_LIBRARY NAMES tcmalloc_minimal)
message(STATUS "TCMALLOC_LIBRARY: ${TCMALLOC_LIBRARY}")
endif()
# Find extra binaries
find_program(A2X_BINARY a2x)
message(STATUS "a2x: ${A2X_BINARY}")
# Find Zlib
find_package(ZLIB)
if(ZLIB_FOUND)
message(STATUS "Found Zlib ${ZLIB_VERSION_STRING}")
set(LIZARDFS_HAVE_ZLIB_H 1)
else()
message(STATUS "Could not find Zlib")
message(STATUS " This dependency is optional.")
message(STATUS " If it's installed in a non-standard path, set ZLIB_ROOT variable")
message(STATUS " to point this path (cmake -DZLIB_ROOT=...)")
endif()
# Find Boost
set(BOOST_MIN_VERSION "1.48.0")
find_package(Boost ${BOOST_MIN_VERSION} COMPONENTS filesystem iostreams program_options system)
# Find Thrift
find_package(Thrift COMPONENTS library)
if(THRIFT_FOUND)
message(STATUS "Found Thrift")
else()
message(STATUS "Could NOT find Thrift (but it's not required)")
message(STATUS " If it's installed in a non-standard path, set THRIFT_ROOT variable")
message(STATUS " to point this path (cmake -DTHRIFT_ROOT=...)")
endif()
# Find Polonaise
set(POLONAISE_REQUIRED_VERSION 0.3.1)
find_package(Polonaise ${POLONAISE_REQUIRED_VERSION} EXACT QUIET NO_MODULE NO_CMAKE_BUILDS_PATH)
if(POLONAISE_FOUND)
message(STATUS "Found Polonaise")
else()
message(STATUS "Could NOT find Polonaise v${POLONAISE_REQUIRED_VERSION} (but it's not required)")
if(Polonaise_CONSIDERED_VERSIONS)
message(STATUS " Incompatible versions ${Polonaise_CONSIDERED_VERSIONS} "
"found in ${Polonaise_CONSIDERED_CONFIGS}")
endif()
message(STATUS " If it's installed in a non-standard path, set Polonaise_DIR variable")
message(STATUS " to point this path (cmake -DPolonaise_DIR=...)")
endif()
# Find crcutil
if(NOT BIG_ENDIAN)
INCLUDE(FindPkgConfig)
pkg_check_modules(CRCUTIL libcrcutil)
if(CRCUTIL_FOUND)
message(STATUS "Found libcrcutil")
set(HAVE_CRCUTIL 1)
else()
message(STATUS "Could NOT find system libcrcutil (but it's not required)")
set(CRCUTIL_VERSION crcutil-1.0)
message(STATUS "Using bundled ${CRCUTIL_VERSION}")
set(HAVE_CRCUTIL 1)
set(CRCUTIL_LIBRARIES "crcutil")
set(CRCUTIL_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/external/${CRCUTIL_VERSION}/code)
set(CRCUTIL_SOURCE_DIR ${CMAKE_SOURCE_DIR}/external/${CRCUTIL_VERSION}/code)
if(CXX_HAS_MCRC32)
set(CRCUTIL_CXX_FLAGS "-mcrc32")
else()
set(CRCUTIL_CXX_FLAGS "")
endif()
endif()
endif()
# Find GoogleTest
if(ENABLE_TESTS)
set(GTEST_INCLUDE_DIRS ${CMAKE_SOURCE_DIR}/external/${GTEST_NAME}/include)
set(TEST_LIBRARIES "" CACHE INTERNAL "" FORCE)
endif()
# Find Judy
find_library(JUDY_LIBRARY Judy)
message(STATUS "JUDY_LIBRARY: ${JUDY_LIBRARY}")
# Find PAM libraries
find_package(PAM)
if(PAM_FOUND)
set(LIZARDFS_HAVE_PAM YES)
endif()
lizardfs-v.3.9.4/NEWS 0000664 0000000 0000000 00000050032 12631772427 0014323 0 ustar 00root root 0000000 0000000 This file lists noteworthy changes in LizardFS.
* Lizardfs (3.9.4) (2015-12-02)
- (master) Removed master server overload on restarting chunkservers
- (master) Improved global file locks engine
- (chunkserver) Fixed leaking descriptors problem
- (chunkserver) Improved mechanism of moving chunks to new directory layout
- (chunkserver) Fixed issues related to scanning directories with new chunk format present
- (mount) Removed hang in mount when chunkserver reported no valid copies of a file
- (master) Changed handling of legacy (pre-3.9.2) chunkservers in new installations
- (cgi) Added XOR replication to statistics
- (all) Removed default linking to tcmalloc library due to performance drop
* Lizardfs (3.9.2) (2015-10-23)
- (all) Introduced XOR goal types
- (all) Added file locks (flock & fcntl)
- (all) Increased max number of files from 500 million to over 4 billion
- (all) Introduced managing open file limits by PAM
- (master) Improved consistency of applying changelogs by shadow masters
- (master) Redesigned snapshot execution in master
- (master) Redesigned chunk loop logic
- (master) Removed hard coded connection limit
- (master) Added option to limit chunk loop's CPU usage
- (chunkserver) Added new network threads responsible for handling requests sent by chunkserver's clients
- (chunkserver) Introduced new more efficient directory layout
- (chunkserver) Added option to choose if fsync should be performed after each write for increased safety
- (chunkserver) Removed hard coded connection limit
- (chunkserver) Added replication network bandwidth limiting
- (mount) Improved symlink cache and added configurable timeout value
- (all) Minor bug fixes and improvements
* Lizardfs (2.6.0) (2015-02-09)
- (all) Added comments in all config files
- (all) Improve messages printed by daemons when starting
- (cgi) A new chunkserver's chart: number of chunk tests
- (cgi) Fixed paths to static content
- (cgi) New implementation of the CGI server; mfscgiserv is now deprecated.
- (cgi) New table: 'Metadata Servers' in the 'Servers' tab
- (chunkserver) Allowed starts with damaged disks
- (chunkserver) A new option: HDD_ADVISE_NO_CACHE
- (chunkserver) Improved handling of disk read errors
- (chunkserver) Removed 'testing chunk: xxxxxx' log messages
- (master) A new feature: disabling atime updates (globally)
- (master) Added possibility to set priority on handling endangered chunks
- (master) Fixed rotating changelogs and downloading files in shadow mode
- (master) Fixed handling replication delay on chunkserver disconnection
- (probe) New commands
- (probe) Renamed to lizardfs-admin
- (all) Minor bug fixes and improvements
* Lizardfs (2.5.4) (2014-11-07)
- (all) Boost is no longer required to build the source code of LizardFS or use the binary version
- (all) Added tiering (aka 'custom goal') feature, which allows users to label chunkservers and to request chunks to be stored on specific groups of servers
- (cgi) "Exports" tabs renamed to "Config", now it also shows goal definitions
- (cgi) Added new tab "Chunks"
- (probe) New command "chunks-health" makes it possible to get number of missing or endangered chunks
- (master) Fixed reporting memory usage in CGI
- (mount) Fixed caching contents of open directories
- (mount) Add a .lizardfs_tweaks file
- (all) Other minor fixes and improvements
* Lizardfs (2.5.2) (2014-09-15)
- (master, shadow) Metadata checksum mechanism, allowing to find and fix possible metadata inconsistencies between master and shadow
- (mount, master) ACL cache in mount, reducing the load of the master server
- (packaging) Support packaging for RedHat based systems
- (master) Improved chunkserver deregistration mechanism in order to avoid temporary master unresponsiveness
- (polonaise) Add filesystem API for developers allowing to use the filesystem without FUSE (and thus working also on Windows)
- (all) Minor fixes and improvements
* LizardFS 2.5.0 (2014-07-15)
- (master) High availability provided by shadow master servers
- (mount, chunkserver) CRC algorithm replaced with a 3 times faster implementation
- (mount, master) Support for quotas (for users and groups)
- (mount, master) Support for posix access contol lists (requires additional OS support)
- (mount, master) Support for global I/O limiting (bandwidth limiting)
- (mount) Support for per-mountpoint I/O limiting (bandwidth limiting)
- (adm) New package lizardfs-adm with a lizardfs-probe command-line tool which can be used to query the installation for variuos parameteres
- (master) New mechanism of storing metadata backup files which improves performance of the hourly metadata dumps
- (all) A comprehensive test suite added
- (all) Multiple bugfixes
* LizardFS 1.6.28 (2013-10-16)
- (all) compile with g++ by default
- (deb) fix init scripts for debian packages
- (all) fix build on Mac OS X
- (cgi) introducing LizardFS logo
* MooseFS 1.6.27 (2012-08-09)
- (mfsrestore) fixed bug - freeing filenames memory too early
- (all) added initial support for extra attributes (xattr), which will be introduced in upcoming version 1.7
- (master+metalogger) better change log synchronization (storage in master memory and sending expected version in metalogger - inspired by Davies Liu)
- (master) acceptable difference of percent of hdd usage added to configuration (up to this version this parameter was constantly set to 0.01% - patch contributed by Davies Liu)
- (master) added emergency store metadata to some other places on errors during standard hourly store (inspired by Davies Liu)
- (cs) default space to be left (256MB) moved to config file (inspired by Davies Liu)
- (cs) added extra limits in mfshdd.cfg (minimum space to be left, maximum space to be used)
- (cs) fixed charts overflow issue (overflow in net transfer on about 575Mbps and hdd transfer on about 77MBps)
- (metalogger) fixed issue: file variable was not clear after close (on rare occasions might cause segfault after disconnecting from master)
- (all) cfg files moved form PREFIX/etc/ to PREFIX/etc/mfs/
- (cgiserv) improved CGI handle (added support for custom http responses, such as "302 Found")
- (master+cgi) showing disconnected chunkservers in "Servers" tab.
- (deb+rpm) mfscgiserv moved from mfscgi to separate package, changes in init scripts
- (mount) added option 'mfsdelayedinit' - for being run from fstab/init scripts
- (master) optimized goal management in chunks
- (master) fixed rare race-condition on clear/preserve cache during open in mount
- (mount) fixed compiling problems on Mac OS X
- (all) changed code to be more compatible with new gcc 4.7 (gcc 4.7 has too strong optimizations - it can generate unpredictable code)
- (master) sustain session time could be defined in mfsmaster.cfg
* MooseFS 1.6.26 (2012-02-01)
- (all) fixed signal handling in multithreaded modules
- (master) added goal and trashtime limits to mfsexports.cfg
- (metalogger) added simple check for downloaded metadata file (inspired by Davies Liu)
- (master) better handle disk full (inspired by Davies Liu)
- (master+metalogger) added keeping previous copies of metadata (inspired by Davies Liu)
- (all) reload all settings on "reload" (SIGHUP)
- (cs) disk scanning in background
- (cs) fixed long termination issue (found by Davies Liu)
- (master) fixed modify/open cache race
* MooseFS 1.6.25 (2011-12-30)
- (metadump) fixed dumping big files (>2TiB)
- (metarestore) fixed bug: nonexisting changelog file caused segv
- (master+mount) added 'sugidclearmode' and 'mkdircopysgid' compatibility options
- (master) improved chunk deletion algorithm (soft/hard limits per server)
- (all) ready for new metadata file format, which will be introduced in upcomoing version 1.7
- (all) ready for quota handling, which will be introduced in upcoming version 1.7
* MooseFS 1.6.24 (2011-12-06)
- (master+mount) proxy in mount for mfstools (fixes problems with frequent connect to master)
* MooseFS 1.6.23 (2011-11-08)
- (master+mount) removed directory cache (didn't increase performance as expected and caused many troubles)
- (metarestore) added option (-i) - ignore some structure inconsistencies
- (metarestore) added option (-b) - in case of errors save the best metadata file
- (mount) more dynamic write cache management (changed condition ib&2; exit 1;;
esac
done
cd "$(dirname "$0")"
mkdir -p build-pack
cd build-pack
rm -f CMakeCache.txt
cmake .. \
-DCMAKE_BUILD_TYPE=Release \
-DENABLE_TESTS=NO \
-DCMAKE_INSTALL_PREFIX=/ \
-DENABLE_DEBIAN_PATHS=YES \
-DENABLE_DOCS=$doc \
cat >../Makefile < "$working_dir/SOURCES/$release.tar.gz"
git show HEAD:rpm/lizardfs.spec | sed -e "s/@DISTRO@/$distro/" > "$working_dir/SPECS/lizardfs.spec"
# Build packages
cd "$working_dir/SPECS"
rpmbuild --define "_topdir $working_dir" -ba lizardfs.spec
# Copy all the created files and clean up
cp "$working_dir"/{RPMS/x86_64,SRPMS}/* "$output_dir"
rm -rf "$working_dir"
lizardfs-v.3.9.4/debian/ 0000775 0000000 0000000 00000000000 12631772427 0015046 5 ustar 00root root 0000000 0000000 lizardfs-v.3.9.4/debian/README 0000664 0000000 0000000 00000000071 12631772427 0015724 0 ustar 00root root 0000000 0000000 The Debian Package lizardfs
----------------------------
lizardfs-v.3.9.4/debian/changelog 0000664 0000000 0000000 00000053225 12631772427 0016727 0 ustar 00root root 0000000 0000000 lizardfs (3.9.4) stable; urgency=high
* (master) Removed master server overload on restarting chunkservers
* (master) Improved global file locks engine
* (chunkserver) Fixed leaking descriptors problem
* (chunkserver) Improved mechanism of moving chunks to new directory layout
* (chunkserver) Fixed issues related to scanning directories with new chunk format present
* (mount) Removed hang in mount when chunkserver reported no valid copies of a file
* (master) Changed handling of legacy (pre-3.9.2) chunkservers in new installations
* (cgi) Added XOR replication to statistics
* (all) Removed default linking to tcmalloc library due to performance drop
-- Piotr Sarna Wed, 2 Dec 2015 15:00:00 +0200
lizardfs (3.9.2) stable; urgency=medium
* (all) Introduced XOR goal types
* (all) Added file locks (flock & fcntl)
* (all) Increased max number of files from 500 million to over 4 billion
* (all) Introduced managing open file limits by PAM
* (master) Improved consistency of applying changelogs by shadow masters
* (master) Redesigned snapshot execution in master
* (master) Redesigned chunk loop logic
* (master) Added option to limit chunk loop's CPU usage
* (master) Removed hard coded connection limit
* (chunkserver) Added new network threads responsible for handling requests
sent by chunkserver's clients
* (chunkserver) Introduced new more efficient directory layout
* (chunkserver) Added option to choose if fsync should be performed after each write
for increased safety
* (chunkserver) Removed hard coded connection limit
* (chunkserver) Added replication network bandwidth limiting
* (mount) Improved symlink cache and added configurable timeout value
* (all) Minor bug fixes and improvements
-- Piotr Sarna Fri, 23 Oct 2015 15:00:00 +0200
lizardfs (2.6.0) stable; urgency=medium
* (all) Added comments in all config files
* (all) Improve messages printed by daemons when starting
* (cgi) A new chunkserver's chart: number of chunk tests
* (cgi) Fixed paths to static content
* (cgi) New implementation of the CGI server; mfscgiserv is now deprecated.
* (cgi) New table: 'Metadata Servers' in the 'Servers' tab
* (chunkserver) Allowed starts with damaged disks
* (chunkserver) A new option: HDD_ADVISE_NO_CACHE
* (chunkserver) Improved handling of disk read errors
* (chunkserver) Removed 'testing chunk: xxxxxx' log messages
* (deb) Make init scripts for lizardfs-master service safer
* (master) A new feature: disabling atime updates (globally)
* (master) Added possibility to set priority on handling endangered chunks
* (master) Fixed rotating changelogs and downloading files in shadow mode
* (master) Fixed handling replication delay on chunkserver disconnection
* (probe) New commands
* (probe) Renamed to lizardfs-admin
* (all) Minor bug fixes and improvements
-- Marcin Sulikowski Mon, 09 Feb 2015 12:00:00 +0200
lizardfs (2.5.4) stable; urgency=medium
* (all) Boost is no longer required to build the source code of LizardFS
or use the binary version
* (all) Added tiering (aka 'custom goal') feature, which allows users to
label chunkservers and to request chunks to be stored on specific groups
of servers
* (cgi) "Exports" tabs renamed to "Config", now it also shows goal
definitions
* (cgi) Added new tab "Chunks"
* (probe) New command "chunks-health" makes it possible to get number of
missing or endangered chunks
* (master) Fixed reporting memory usage in CGI
* (mount) Fixed caching contents of open directories
* (mount) Add a .lizardfs_tweaks file
* (all) Other minor fixes and improvements
-- Alek Lewandowski Fri, 07 Nov 2014 14:00:00 +0200
lizardfs (2.5.2) stable; urgency=low
* (master, shadow) Metadata checksum mechanism, allowing to find and
fix possible metadata inconsistencies between master and shadow
* (mount, master) ACL cache in mount, reducing the load of the master
server
* (packaging) Support packaging for RedHat based systems
* (master) Improved chunkserver deregistration mechanism in order to
avoid temporary master unresponsiveness
* (polonaise) Add filesystem API for developers allowing to use the
filesystem without FUSE (and thus working also on Windows)
* (all) Minor fixes and improvements
-- Alek Lewandowski Mon, 15 Sep 2014 14:00:00 +0200
lizardfs (2.5.0) stable; urgency=medium
* (master) High availability provided by shadow master servers
* (mount, chunkserver) CRC algorithm replaced with a 3 times faster
implementation
* (mount, master) Support for quotas (for users and groups)
* (mount, master) Support for posix access contol lists (requires additional
OS support)
* (mount, master) Support for global I/O limiting (bandwidth limiting)
* (mount) Support for per-mountpoint I/O limiting (bandwidth limiting)
* (adm) New package lizardfs-adm with a lizardfs-probe command-line tool
which can be used to query the installation for variuos parameteres
* (master) New mechanism of storing metadata backup files which improves
performance of the hourly metadata dumps
* (all) A comprehensive test suite added
* (all) Multiple bugfixes
-- Marcin Sulikowski Tue, 15 Jul 2014 17:28:51 +0200
mfs (1.6.28) unstable; urgency=medium
* (all) compile with g++ by default
* (deb) fix init scripts for debian packages
* (all) fix build on Mac OS X
* (cgi) introducing LizardFS logo
-- Peter aNeutrino Wed, 16 Oct 2013 12:00:00 +0200
mfs (1.6.27) unstable; urgency=medium
* (mfsrestore) fixed bug - freeing filenames memory too early
* (all) added initial support for extra attributes (xattr), which will be
introduced in upcoming version 1.7
* (master+metalogger) better change log synchronization (storage in master
memory and sending expected version in metalogger - inspired by Davies
Liu)
* (master) acceptable difference of percent of hdd usage added to
configuration (up to this version this parameter was constantly set to
0.01% - patch contributed by Davies Liu)
* (master) added emergency store metadata to some other places on errors
during standard hourly store (inspired by Davies Liu)
* (cs) default space to be left (256MB) moved to config file (inspired by
Davies Liu)
* (cs) added extra limits in mfshdd.cfg (minimum space to be left, maximum
space to be used)
* (cs) fixed charts overflow issue (overflow in net transfer on about
575Mbps and hdd transfer on about 77MBps)
* (metalogger) fixed issue: file variable was not clear after close (on rare
occasions might cause segfault after disconnecting from master)
* (all) cfg files moved form PREFIX/etc/ to PREFIX/etc/mfs/
* (cgiserv) improved CGI handle (added support for custom http responses,
such as "302 Found")
* (master+cgi) showing disconnected chunkservers in "Servers" tab.
* (deb+rpm) mfscgiserv moved from mfscgi to separate package, changes in
init scripts
* (mount) added option 'mfsdelayedinit' - for being run from fstab/init
scripts
* (master) optimized goal management in chunks
* (master) fixed rare race-condition on clear/preserve cache during open in
mount
* (mount) fixed compiling problems on Mac OS X
* (all) changed code to be more compatible with new gcc 4.7 (gcc 4.7 has too
strong optimizations - it can generate unpredictable code)
* (master) sustain session time could be defined in mfsmaster.cfg
* (debian) separated -cgiserv subpackage from -cgi (-cgi can be used
with any CGI-capable HTTP server); added init script for mfscgiserv
-- Jakub Bogusz Thu, 09 Aug 2012 12:00:00 +0200
mfs (1.6.26) unstable; urgency=medium
* (all) fixed signal handling in multithreaded modules
* (master) added goal and trashtime limits to mfsexports.cfg
* (metalogger) added simple check for downloaded metadata file
(inspired by Davies Liu)
* (master) better handle disk full (inspired by Davies Liu)
* (master+metalogger) added keeping previous copies of metadata
(inspired by Davies Liu)
* (all) reload all settings on "reload" (SIGHUP)
* (cs) disk scanning in background
* (cs) fixed long termination issue (found by Davies Liu)
* (master) fixed modify/open cache race
-- Jakub Bogusz Thu, 02 Feb 2012 12:00:00 +0100
mfs (1.6.25) unstable; urgency=medium
* (metadump) fixed dumping big files (>2TiB)
* (metarestore) fixed bug: nonexisting changelog file caused segv
* (master+mount) added 'sugidclearmode' and 'mkdircopysgid' compatibility
options
* (master) improved chunk deletion algorithm (soft/hard limits per server)
* (all) ready for new metadata file format, which will be introduced in
upcomoing version 1.7
* (all) ready for quota handling, which will be introduced in upcoming
version 1.7
-- Jakub Bogusz Fri, 30 Dec 2011 14:30:00 +0100
mfs (1.6.24) unstable; urgency=low
* (master+mount) proxy in mount for mfstools (fixes problems with frequent
connect to master)
-- Jakub Bogusz Tue, 06 Dec 2011 13:30:00 +0100
mfs (1.6.23) unstable; urgency=medium
* (master+mount) removed directory cache (didn't increase performance as
expected and caused many troubles)
* (metarestore) added option (-i) - ignore some structure inconsistencies
* (metarestore) added option (-b) - in case of errors save the best metadata
file
* (mount) more dynamic write cache management (changed condition ib Tue, 29 Nov 2011 09:00:00 +0100
mfs (1.6.22) unstable; urgency=low
* (mount) added resolving master hostname whenever connection has failed
* (cs) removed getting attributes of every chunk during initualization -
speeds up starting of chunkserver
* (cs) changed calculating of total/used space. Superuser space now is
subtracted from total space instead of adding it to used space
* (master+mount) fixed directory cache.
* (debian) rewritten init scripts to use mfscommon commands
(start/stop/restart/reload) instead of start-stop-daemon (where stop
caused killing all instances of daemon)
* (debian) changed init scripts to bail out early if MFS*_ENABLE is not true
(i.e. given daemon is not scripts-controlled)
-- Jakub Bogusz Mon, 09 May 2011 12:00:00 +0200
mfs (1.6.21) unstable; urgency=low
* (mount) added support of default config file (mfsmount.cfg)
* (metarestore) fixed snapshot bug
* (metarestore) improved tolerance for damaged changelog files
* (master,mount) added full directory (with attributes) cache on
client (mfsmount) side
* (mount) added symlink cache on client (mfsmount) side
* (mount) added hidden files '.oplog' and '.ophistory' with detailed info
about current/historical operations performed by mfsmount
* (master) added simple net topology support
* (all) added -D_POSIX_PTHREAD_SEMANTICS to CFLAGS - needed by Solaris-like
OSes
* (cs) fixed detection of 'damaged disk' condition
* (mount) fixed error caused segfaults during umount on certain conditions
* (daemon) added 'test' command - checks if process is running and returns
its PID
-- Jakub Bogusz Thu, 14 Apr 2011 12:00:00 +0200
mfs (1.6.20-3) unstable; urgency=low
* (debian) changed rules to configure with default user/group mfs/mfs
* (debian) enhanced init scripts: configurable .cfg paths and data dir;
dropped obsolete /var/run dir
-- Jakub Bogusz Tue, 01 Mar 2011 12:00:00 +0100
mfs (1.6.20-2) unstable; urgency=low
* (debian) added server dirs to mfs-common; package CGI Monitor as mfs-cgi
-- Jakub Bogusz Wed, 19 Jan 2011 08:20:00 +0100
mfs (1.6.20) unstable; urgency=low
* (cs) fixed "packet too big" issue during register to master (split big
register packet with all chunks info into small packets)
* (cs,metalogger,master) added minimum socket timeout (ten seconds)
* (mount) accepting nop packets during write (for future use)
-- Jakub Bogusz Fri, 14 Jan 2011 11:00:00 +0100
mfs (1.6.19) unstable; urgency=low
* (debian) separated mfs-common and mfs-metalogger subpackages,
added init scripts (contributed by Christopher Lewis)
* (daemon) fixed return values (return non zero on error)
* (cs) fixed chunk testing bug (any error during chunk opening caused
assigning whole disk as damaged)
* (cs,metalogger) added resolving master name when connection failed (patch
contributed by Davies Liu)
* (mount) added creating new session when prevoius is lost (inspired by
Davies Liu)
* (cs) added for unused chunks week delay before deletion (inspired by
Davies Liu)
* (cgi) added switching between name and IP in 'path' column in 'Disks'
table (inspired by Davies Liu)
* (master) do not update ctime when goal, trashtime or extra attributes are
not changing
-- Jakub Bogusz Tue, 15 Dec 2010 08:00:00 +0100
mfs (1.6.18) unstable; urgency=medium
* (metalogger) added sending metadata after metalogger startup
* (master,metalogger) added sending two change logs together with metadata
* (metarestore) imporved merging change logs
* (all) added a lot of assertions (mainly NULL pointers, and unsuccessful
thread functions)
* (all) fixed some minor bugs and potential race conditions (makes valgrind
happy)
* (cs) added ability to use read-only disks in "marked for removal" mode (to
retrieve missing chunks from damaged disks)
* (cs) added showing scanning progress during startup
* (all/master) added releasing used resources at the end
* (all) changed some malloc/free allocations into mmap/munmap
* (all) new error messages routines
* (daemons) added proper handling SIGINT in "foreground" mode
* (cgiserv) fixed small bug (malformed request could crash cgiserv)
-- Jakub Bogusz Mon, 08 Nov 2010 12:40:00 +0100
mfs (1.6.17) unstable; urgency=low
* (master,tools) added automatic data cache management
* (master,tools) new flag "nodatacache"
-- Jakub Bogusz Tue, 20 Jul 2010 10:30:00 +0200
mfs (1.6.16) unstable; urgency=low
* (master) added clearing suid/sgid bits
* (master) added check for "sticky" flag during rename and unlink operations
* (master) fixed posix compatibility (removing empty directory on rename)
* (master) fixed posix compatibility (proper changing ctime)
* (master) fixed some constants (better support for larger systems - with
millions of files and chunks)
* (master) fixed error logging (logging is turning off when there are too
many messages)
* (all) fixed some OpenSolaris compile issues (mainly added -D__EXTENSIONS__
to compile flags)
* (all) fixed OpenSolaris pthreads issue (errno doesn't work correctly
without proper compiler flags)
* (man) added mfscgiserv man page, added "BIND" options descriptions to man
pages
* (cs) fixed hdd stats (overflow on negative time difference)
-- Jakub Bogusz Mon, 19 Jul 2010 12:00:00 +0200
mfs (1.6.15) unstable; urgency=medium
* (daemons) fixed "double free" error
* (metarestore) fixed bugs in "REPAIR" and "SNAPSHOT" entries
* (master) fixed bug in "snapshot" command ("mfsmakesnapshot dir dir/"
caused master to hung-up)
* (master) preserving atime and mtime during "snapshot" operation (makes
"snapshot" to work more like "cp -Rp" than "cp -R")
* (cs) ommit "marked for removal" disks during chunk test loop
-- Jakub Bogusz Fri, 09 Apr 2010 12:00:00 +0200
mfs (1.6.14) unstable; urgency=low
* (all) improved messages
* (cs) prevent from using localhost as a master IP address
* (all) remove some BSDisms from code
* (metalogger) added BIND_HOST option (as in mount and cs)
-- Jakub Bogusz Fri, 19 Mar 2010 12:00:00 +0100
mfs (1.6.13) unstable; urgency=low
* (master) fixed poll events bug
* (autotools) added m4 module for posix threads detection
* (master) added exporting "meta" to default mfsexports.cfg
* (master,tools) removed "allowdatacache" flag (will be managed
automatically in the future)
* (master,cs) added support for not compressed PNG images in chart module
(when build without zlib)
-- Jakub Bogusz Mon, 08 Feb 2010 07:15:00 +0100
mfs (1.6.12) unstable; urgency=medium
* (mount) fixed locking in read module
* (mount,cs) added ability to bind outgoing sockets to specific IP
-- Jakub Bogusz Mon, 25 Jan 2010 13:00:00 +0100
mfs (1.6.11) unstable; urgency=medium
* (cs) removed dirent.d_type test
* (cs) fixed some memory leaks
* (mount) improved attribute cache
-- Jakub Bogusz Thu, 31 Dec 2009 12:00:00 +0100
mfs (1.6.10) unstable; urgency=high
* fixed errors introduced in 1.6.9
* added 'reload' command to master
* split chunk counters into 'all' and 'regular' (new approach to disks
removal - since this version chunks on 'marked for removal' disks are not
deleted)
-- Jakub Bogusz Wed, 09 Dec 2009 08:10:00 +0100
mfs (1.6.9) unstable; urgency=medium
* updated manpages
* added support for mlockall (prevent from swapping)
* redesigned charts module
* redesigned locking mechanizm (daemons)
* added HDD I/O stats
* removing unfinished jobs from queue on socket close
* added 'cache file' flag
* added simple application "mfsmetadump"
-- Jakub Bogusz Tue, 24 Nov 2009 14:00:00 +0100
mfs (1.6.8) unstable; urgency=low
* added options to set nice level and number of I/O retries in mfsmount
-- Jakub Bogusz Mon, 26 Oct 2009 07:20:00 +0200
mfs (1.6.7) unstable; urgency=low
* damaged disk caused SIGSEGV in mfschunkserver
-- Jakub Bogusz Mon, 05 Oct 2009 12:50:00 +0200
mfs (1.6.6) unstable; urgency=high
* fixed errors introduced in 1.6.5, changed directory structure in CS (from
16 subfolders to 256 subfolders)
-- Jakub Bogusz Fri, 02 Oct 2009 11:20:00 +0200
mfs (1.6.5) unstable; urgency=medium
* fixed some performance issues, added new module "mfsmetalogger"
-- Jakub Bogusz Wed, 23 Sep 2009 12:30:00 +0200
mfs (1.6.4) unstable; urgency=medium
* rewrite mfs to use poll instead of select, fixed some errors
in new write module, limit cache usage by inode in write module
-- Jakub Bogusz Tue, 25 Aug 2009 19:25:00 +0200
mfs (1.6.3) unstable; urgency=low
* reduced version increasing, increased open files limit in
chunkserver, decreased time window in damage disk detection
-- Jakub Bogusz Mon, 24 Aug 2009 12:20:00 +0200
mfs (1.6.2) unstable; urgency=medium
* Fixed "race" in writedata in mfsmount module, increased session
timeout in mfsmaster for new sessions
-- Jakub Bogusz Wed, 19 Aug 2009 07:35:00 +0200
mfs (1.6.1-6) unstable; urgency=low
* Fixed small error in mfschunkserver and little compatibility
issue in mfs.cgi
-- Jakub Bogusz Tue, 18 Aug 2009 08:00:00 +0200
mfs (1.6.1-5) unstable; urgency=low
* Fixed replication algorithm, security issues in mfs.cgi,
added mfssnapshot (simple script for backward compatibility),
some typos, etc.
-- Jakub Bogusz Thu, 13 Aug 2009 13:50:00 +0200
mfs (1.6.1-4) unstable; urgency=low
* New MooseFS version (added 'mapall' to exports and new object
attributes - 'noattrcache' and 'noentrycache')
-- Jakub Bogusz Fri, 31 Jul 2009 06:40:00 +0200
mfs (1.6.0) unstable; urgency=medium
* New MooseFS version (1.6.0; refer to NEWS file).
-- Jakub Bogusz Wed, 01 Jul 2009 14:01:00 +0200
mfs (1.5.12) unstable; urgency=high
* New MooseFS version (fixes CRC cache bug introduced in 1.5.11).
-- Jakub Bogusz Wed, 28 Jan 2009 10:03:00 +0100
mfs (1.5.11) unstable; urgency=low
* New MooseFS version (refer to NEWS file).
-- Jakub Bogusz Tue, 27 Jan 2009 13:52:00 +0100
mfs (1.5.10) unstable; urgency=medium
* New MooseFS version (refer to NEWS file).
-- Jakub Bogusz Wed, 03 Dec 2008 08:01:00 +0100
mfs (1.5.9-2) unstable; urgency=low
* Man links compatible with Debian man-db.
-- Jakub Bogusz Thu, 20 Nov 2008 10:03:00 +0100
mfs (1.5.9) unstable; urgency=medium
* New MooseFS version (refer to NEWS file).
-- Jakub Bogusz Wed, 19 Nov 2008 11:42:00 +0100
mfs (1.5.8) unstable; urgency=low
* New MooseFS version (better memory allocation in master, lower syslog
verbosity).
-- Jakub Bogusz Thu, 26 Aug 2008 09:49:00 +0200
mfs (1.5.7-2) unstable; urgency=low
* Packaging fix: dpkg doesn't allow the same file in several subpackages,
so include moosefs(7) and mfs(7) in client subpackage only.
-- Jakub Bogusz Thu, 21 Aug 2008 08:18:00 +0200
mfs (1.5.7) unstable; urgency=medium
* New MooseFS version (memory allocation fixes).
-- Jakub Bogusz Thu, 31 Jul 2008 15:26:00 +0200
mfs (1.5.5) unstable; urgency=low
* Initial Release.
-- Jakub Bogusz Fri, 11 Jul 2008 13:05:21 +0200
lizardfs-v.3.9.4/debian/compat 0000664 0000000 0000000 00000000002 12631772427 0016244 0 ustar 00root root 0000000 0000000 9
lizardfs-v.3.9.4/debian/control 0000664 0000000 0000000 00000004703 12631772427 0016455 0 ustar 00root root 0000000 0000000 Source: lizardfs
Section: admin
Priority: extra
Maintainer: Adam Ochmanski
Build-Depends: asciidoc (>= 8.6.6),
debhelper (>= 9),
cmake (>= 2.8),
libfuse-dev,
pkg-config,
zlib1g-dev,
python,
Standards-Version: 3.9.3
Homepage: http://lizardfs.org/
Package: lizardfs-dbg
Architecture: any
Section: debug
Priority: extra
Depends: ${misc:Depends}
Description: Debugging symbols for LizardFS
Debugging symbols for all LizardFS binaries
Package: lizardfs-common
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends},
adduser
Conflicts: mfs-common
Replaces: mfs-common
Provides: mfs-common
Description: LizardFS common files
Files and services common for all LizardFS daemons.
Package: lizardfs-master
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}, lizardfs-common
Conflicts: mfs-master
Replaces: mfs-master
Provides: mfs-master
Description: LizardFS master server
LizardFS master (metadata) server.
Package: lizardfs-metalogger
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}, lizardfs-common
Conflicts: mfs-metalogger
Replaces: mfs-metalogger
Provides: mfs-metalogger
Description: LizardFS metalogger server
LizardFS metalogger (metadata replication) server.
Package: lizardfs-chunkserver
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}, lizardfs-common
Conflicts: mfs-chunkserver
Replaces: mfs-chunkserver
Provides: mfs-chunkserver
Description: LizardFS data server
LizardFS data server.
Package: lizardfs-client
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
Conflicts: mfs-client
Replaces: mfs-client
Provides: mfs-client
Description: LizardFS client
LizardFS clients: mfsmount and mfstools.
Package: lizardfs-adm
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}
Description: LizardFS administration tools
LizardFS administration tools: lizardfs-admin
Package: lizardfs-cgi
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends},
python
Conflicts: mfs-cgi
Replaces: mfs-cgi
Provides: mfs-cgi
Description: LizardFS CGI Monitor
LizardFS CGI Monitor.
Package: lizardfs-cgiserv
Architecture: any
Depends: ${shlibs:Depends}, ${misc:Depends}, lizardfs-cgi,
python
Conflicts: mfs-cgiserv
Replaces: mfs-cgiserv
Provides: mfs-cgiserv
Description: Simple CGI-capable HTTP server to run LizardFS CGI Monitor
Simple CGI-capable HTTP server to run LizardFS CGI Monitor.
lizardfs-v.3.9.4/debian/copyright 0000664 0000000 0000000 00000002772 12631772427 0017011 0 ustar 00root root 0000000 0000000 This package was debianized by Peter aNeutrino after Fri, 15 Nov 2013 13:05:21 +0200.
Sources are available for download at .
Author(s):
Peter aNeutrino
Stanislaw Findeisen
Janusz Gralak
Paweł Janicki
Michał Kaźmierowski
Marcin Konarski
Jakub Kruszona-Zawadzki
Marcin lamvak Grabowski
Alek Lewandowski
Marcin Malich
Jakub Milewski
Adam Nieżurawski
Kamil Pachulski
Michał Pecio
Wojciech Sidor
Kamil Skalski
Marcin Sulikowski
Copyright:
Copyright (C) 2001-2008 Gemius S.A., 2013 Skytechnology sp. z o.o.
Contact:
License:
This package is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3.
This package is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this package; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
On Debian systems, the complete text of the GNU General
Public License can be found in `/usr/share/common-licenses/GPL-3'.
The Debian packaging is (C) 2008 Gemius S.A. and is licensed under the GPL v3,
see above.
lizardfs-v.3.9.4/debian/docs 0000664 0000000 0000000 00000000024 12631772427 0015715 0 ustar 00root root 0000000 0000000 NEWS
README
UPGRADE
lizardfs-v.3.9.4/debian/lizardfs-adm.install 0000664 0000000 0000000 00000000122 12631772427 0021006 0 ustar 00root root 0000000 0000000 usr/bin/lizardfs-admin
usr/bin/lizardfs-probe
usr/share/man/man8/lizardfs-admin.8
lizardfs-v.3.9.4/debian/lizardfs-cgi.install 0000664 0000000 0000000 00000000021 12631772427 0021005 0 ustar 00root root 0000000 0000000 usr/share/mfscgi
lizardfs-v.3.9.4/debian/lizardfs-cgiserv.default 0000664 0000000 0000000 00000000726 12631772427 0021677 0 ustar 00root root 0000000 0000000 # Defaults for lizardfs-cgiserv
# lizardfs-cgiserver(8)
#
# This is a POSIX shell fragment
#
## user to run daemon as (default: nobody)
# LIZARDFSCGISERV_USER=nobody
## group to run daemon as (default: nogroup)
# LIZARDFSCGISERV_GROUP=nogroup
## local address to listen on (default: any)
# BIND_HOST=localhost
## port to listen on (default: 9425)
# BIND_PORT=9425
## local path to use as HTTP document root (default: /usr/share/mfscgi)
# ROOT_PATH=/usr/share/mfscgi lizardfs-v.3.9.4/debian/lizardfs-cgiserv.init 0000664 0000000 0000000 00000004413 12631772427 0021213 0 ustar 00root root 0000000 0000000 #!/bin/sh
#
### BEGIN INIT INFO
# Provides: lizardfs-cgiserv
# Required-Start: $local_fs $network $syslog $remote_fs
# Required-Stop: $local_fs $syslog $remote_fs
# Should-Start: $syslog
# Should-Stop: $network $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Start up the lizardfs-cgiserv server daemon
# Description: LizardFS is a distributed, scalable, fault-tolerant and highly available file system.
# This service starts up the LizardFS cgiserv server daemon.
### END INIT INFO
NAME=lizardfs-cgiserv
EXEC=/usr/bin/python
DAEMON=/usr/sbin/lizardfs-cgiserver
LIZARDFSCGISERV_USER=nobody
LIZARDFSCGISERV_GROUP=nogroup
BIND_HOST=0.0.0.0
BIND_PORT=9425
ROOT_PATH=/usr/share/mfscgi
# Exit if executable is not installed
[ -x $DAEMON ] || exit 0
# Read configuration variable file if it is present
DEFAULTS_FILE=/etc/default/${NAME}
[ -r "$DEFAULTS_FILE" ] && . $DEFAULTS_FILE
PIDF=/var/run/${NAME}.pid
RETRY=TERM/30/KILL/5
# Load the VERBOSE setting and other rcS variables
[ -f /etc/default/rcS ] && . /etc/default/rcS
# define LSB log_* functions.
. /lib/lsb/init-functions
case "$1" in
start)
if $0 status >>/dev/null; then
log_action_msg "$NAME is already running"
exit 0
fi
log_action_begin_msg "$NAME starting"
if R=$(start-stop-daemon --start --exec ${EXEC} --oknodo --pidfile ${PIDF} --make-pidfile \
--background --chuid ${LIZARDFSCGISERV_USER}:${LIZARDFSCGISERV_GROUP} \
-- $DAEMON -H ${BIND_HOST} -P ${BIND_PORT} -R ${ROOT_PATH} 2>&1);
then
log_action_end_msg 0 "$R"
else
log_action_end_msg 1 "$R"
fi
;;
stop)
log_action_begin_msg "$NAME stopping"
if R=$(start-stop-daemon --stop --exec $EXEC --pidfile $PIDF --retry=$RETRY --quiet);
then
log_action_end_msg 0 "$R"
else
log_action_end_msg 1 "not running"
fi
rm -f "$PIDF"
;;
force-reload|restart)
$0 stop
$0 start
;;
status)
## return status 0 if process is running.
status_of_proc -p "$PIDF" "$DAEMON" "$NAME"
;;
*)
N=/etc/init.d/$NAME
echo "Usage: $N {start|stop|restart|force-reload|status}" >&2
;;
esac
lizardfs-v.3.9.4/debian/lizardfs-cgiserv.install 0000664 0000000 0000000 00000000170 12631772427 0021712 0 ustar 00root root 0000000 0000000 usr/sbin/lizardfs-cgiserver
usr/sbin/mfscgiserv
usr/share/man/man8/lizardfs-cgiserver.8
usr/share/man/man8/mfscgiserv.8
lizardfs-v.3.9.4/debian/lizardfs-chunkserver.default 0000664 0000000 0000000 00000000350 12631772427 0022565 0 ustar 00root root 0000000 0000000 # /etc/default/lizardfs-chunkserver
# Start lizardfs-chunkserver from init.d script on boot.
# Only allowed values are "true" and "false".
# Undefined values default to "false".
LIZARDFSCHUNKSERVER_ENABLE=false
DAEMON_OPTS=""
lizardfs-v.3.9.4/debian/lizardfs-chunkserver.init 0000664 0000000 0000000 00000005654 12631772427 0022120 0 ustar 00root root 0000000 0000000 #!/bin/sh
### BEGIN INIT INFO
# Provides: lizardfs-chunkserver
# Required-Start: $network $remote_fs
# Required-Stop: $remote_fs
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Start lizardfs-chunkserver at boot time
# Description: lizardfs-chunkservers provide storage space for LizardFS.
### END INIT INFO
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DAEMON=/usr/sbin/mfschunkserver
NAME=mfschunkserver
DESC=lizardfs-chunkserver
DEFAULT_WORKING_USER=mfs
DEFAULT_WORKING_GROUP=mfs
DEFAULT_DATA_PATH=/var/lib/mfs
DEFAULT_CFG=/etc/mfs/mfschunkserver.cfg
test -e $DAEMON || exit 0
# Include lizardfs-chunkserver defaults if available
. /lib/lsb/init-functions
LIZARDFSCHUNKSERVER_ENABLE=false
LIZARDFSCHUNKSERVER_CONFIG_FILE=
LIZARDFSCHUNKSERVER_DEFAULTS_FILE=/etc/default/lizardfs-chunkserver
if [ -s "$LIZARDFSCHUNKSERVER_DEFAULTS_FILE" ]; then
. "$LIZARDFSCHUNKSERVER_DEFAULTS_FILE"
case "x$LIZARDFSCHUNKSERVER_ENABLE" in
xtrue) ;;
xfalse)
log_warning_msg "lizardfs-chunkserver not enabled in \"$LIZARDFSCHUNKSERVER_DEFAULTS_FILE\", exiting..."
exit 0
;;
*)
log_failure_msg "value of LIZARDFSCHUNKSERVER_ENABLE must be either 'true' or 'false';"
log_failure_msg "not starting lizardfs-chunkserver."
exit 1
;;
esac
fi
set -e
if [ -n "$LIZARDFSCHUNKSERVER_CONFIG_FILE" ]; then
CFGFILE="$LIZARDFSCHUNKSERVER_CONFIG_FILE"
else
CFGFILE="$DEFAULT_CFG"
fi
get_config_value_from_CFGFILE()
{
# parsing the value of config options from CFGFILE
echo $(sed -e 's/[[:blank:]]*#.*$//' -n -e 's/^[[:blank:]]*'$1'[[:blank:]]*=[[:blank:]]*\(.*\)$/\1/p' $CFGFILE)
}
if [ -s "$CFGFILE" ]; then
DATA_PATH=$(get_config_value_from_CFGFILE "DATA_PATH")
WORKING_USER=$(get_config_value_from_CFGFILE "WORKING_USER")
WORKING_GROUP=$(get_config_value_from_CFGFILE "WORKING_GROUP")
fi
: ${DATA_PATH:=$DEFAULT_DATA_PATH}
: ${WORKING_USER:=$DEFAULT_WORKING_USER}
: ${WORKING_GROUP:=$DEFAULT_WORKING_GROUP}
check_dirs()
{
# check that the metadata dir exists
if [ ! -d "$DATA_PATH" ]; then
mkdir -p "$DATA_PATH"
fi
chmod 0755 "$DATA_PATH"
chown -R $WORKING_USER:$WORKING_GROUP "$DATA_PATH"
}
case "$1" in
start)
check_dirs
echo "Starting $DESC:"
$DAEMON ${LIZARDFSCHUNKSERVER_CONFIG_FILE:+-c $LIZARDFSCHUNKSERVER_CONFIG_FILE} $DAEMON_OPTS start
;;
stop)
echo "Stopping $DESC:"
$DAEMON ${LIZARDFSCHUNKSERVER_CONFIG_FILE:+-c $LIZARDFSCHUNKSERVER_CONFIG_FILE} stop
;;
reload|force-reload)
check_dirs
echo "Reloading $DESC:"
$DAEMON ${LIZARDFSCHUNKSERVER_CONFIG_FILE:+-c $LIZARDFSCHUNKSERVER_CONFIG_FILE} reload
;;
restart)
check_dirs
echo "Restarting $DESC:"
$DAEMON ${LIZARDFSCHUNKSERVER_CONFIG_FILE:+-c $LIZARDFSCHUNKSERVER_CONFIG_FILE} $DAEMON_OPTS restart
;;
*)
N=/etc/init.d/$NAME
echo "Usage: $N {start|stop|restart|reload|force-reload}" >&2
exit 1
;;
esac
exit 0
lizardfs-v.3.9.4/debian/lizardfs-chunkserver.install 0000664 0000000 0000000 00000000274 12631772427 0022614 0 ustar 00root root 0000000 0000000 etc/mfs/mfschunkserver.cfg.dist
etc/mfs/mfshdd.cfg.dist
usr/sbin/mfschunkserver
usr/share/man/man5/mfschunkserver.cfg.5
usr/share/man/man5/mfshdd.cfg.5
usr/share/man/man8/mfschunkserver.8
lizardfs-v.3.9.4/debian/lizardfs-client.install 0000664 0000000 0000000 00000002345 12631772427 0021534 0 ustar 00root root 0000000 0000000 etc/mfs/mfsmount.cfg.dist
usr/bin/mfsappendchunks
usr/bin/mfscheckfile
usr/bin/mfsdeleattr
usr/bin/mfsdirinfo
usr/bin/mfsfileinfo
usr/bin/mfsfilerepair
usr/bin/mfsgetgoal
usr/bin/mfsgeteattr
usr/bin/mfsgettrashtime
usr/bin/mfsmakesnapshot
usr/bin/mfsmount
usr/bin/mfsrepquota
usr/bin/mfsrgetgoal
usr/bin/mfsrgettrashtime
usr/bin/mfsrsetgoal
usr/bin/mfsrsettrashtime
usr/bin/mfssetgoal
usr/bin/mfsseteattr
usr/bin/mfssetquota
usr/bin/mfssettrashtime
usr/bin/mfstools
usr/bin/mfssnapshot
usr/share/man/man1/mfsappendchunks.1
usr/share/man/man1/mfscheckfile.1
usr/share/man/man1/mfsdeleattr.1
usr/share/man/man1/mfsdirinfo.1
usr/share/man/man1/mfsfileinfo.1
usr/share/man/man1/mfsfilerepair.1
usr/share/man/man1/mfsgetgoal.1
usr/share/man/man1/mfsgeteattr.1
usr/share/man/man1/mfsgettrashtime.1
usr/share/man/man1/mfsmakesnapshot.1
usr/share/man/man1/mfsrepquota.1
usr/share/man/man1/mfsrgetgoal.1
usr/share/man/man1/mfsrgettrashtime.1
usr/share/man/man1/mfsrsetgoal.1
usr/share/man/man1/mfsrsettrashtime.1
usr/share/man/man1/mfssetgoal.1
usr/share/man/man1/mfsseteattr.1
usr/share/man/man1/mfssetquota.1
usr/share/man/man1/mfssettrashtime.1
usr/share/man/man1/mfstools.1
usr/share/man/man7/mfs.7
usr/share/man/man7/moosefs.7
usr/share/man/man1/mfsmount.1
lizardfs-v.3.9.4/debian/lizardfs-common.dirs 0000664 0000000 0000000 00000000014 12631772427 0021030 0 ustar 00root root 0000000 0000000 var/lib/mfs
lizardfs-v.3.9.4/debian/lizardfs-common.install 0000664 0000000 0000000 00000000000 12631772427 0021530 0 ustar 00root root 0000000 0000000 lizardfs-v.3.9.4/debian/lizardfs-common.postinst 0000664 0000000 0000000 00000001271 12631772427 0021760 0 ustar 00root root 0000000 0000000 #!/bin/sh
set -e
liz_limits_conf="/etc/security/limits.d/10-lizardfs.conf"
liz_pam_d="/etc/pam.d/lizardfs"
case "${1}" in
configure)
if ! getent passwd mfs > /dev/null 2>&1
then
adduser --quiet --system --group --no-create-home --home /var/lib/mfs mfs
fi
if [ ! -f $liz_limits_conf ]; then
echo "mfs soft nofile 10000" > $liz_limits_conf
echo "mfs hard nofile 10000" >> $liz_limits_conf
chmod 0644 $liz_limits_conf
fi
if [ ! -f $liz_pam_d ]; then
echo "session required pam_limits.so" > $liz_pam_d
fi
;;
abort-upgrade|abort-remove|abort-deconfigure)
;;
*)
echo "postinst called with unknown argument \`${1}'" >&2
exit 1
;;
esac
#DEBHELPER#
exit 0
lizardfs-v.3.9.4/debian/lizardfs-common.postrm 0000664 0000000 0000000 00000001005 12631772427 0021414 0 ustar 00root root 0000000 0000000 #!/bin/sh
set -e
liz_limits_conf="/etc/security/limits.d/10-lizardfs.conf"
liz_pam_d="/etc/pam.d/lizardfs"
case "${1}" in
purge)
if [ -x /usr/sbin/deluser ]
then
deluser --quiet mfs > /dev/null || true
fi
if [ -f $liz_limits_conf ]; then
rm -f $liz_limits_conf
fi
if [ -f $liz_pam_d ]; then
rm -f $liz_pam_d
fi
;;
remove|upgrade|failed-upgrade|abort-install|abort-upgrade|disappear)
;;
*)
echo "postrm called with unknown argument \`${1}'" >&2
exit 1
esac
#DEBHELPER#
exit 0
lizardfs-v.3.9.4/debian/lizardfs-master.default 0000664 0000000 0000000 00000000331 12631772427 0021520 0 ustar 00root root 0000000 0000000 # /etc/default/lizardfs-master
# Start lizardfs-master from init.d script on boot.
# Only allowed values are "true" and "false".
# Undefined values default to "false".
LIZARDFSMASTER_ENABLE=false
DAEMON_OPTS=""
lizardfs-v.3.9.4/debian/lizardfs-master.init 0000664 0000000 0000000 00000005252 12631772427 0021046 0 ustar 00root root 0000000 0000000 #!/bin/sh
### BEGIN INIT INFO
# Provides: lizardfs-master
# Required-Start: $network $remote_fs
# Required-Stop: $remote_fs
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Start lizardfs-master at boot time
# Description: lizardfs-master provides metadata management for LizardFS.
### END INIT INFO
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DAEMON=/usr/sbin/mfsmaster
NAME=mfsmaster
DESC=lizardfs-master
DEFAULT_WORKING_USER=mfs
DEFAULT_WORKING_GROUP=mfs
DEFAULT_DATA_PATH=/var/lib/mfs
DEFAULT_CFG=/etc/mfs/mfsmaster.cfg
test -e $DAEMON || exit 0
# Include lizardfs-master defaults if available
. /lib/lsb/init-functions
LIZARDFSMASTER_ENABLE=false
LIZARDFSMASTER_CONFIG_FILE=
LIZARDFSMASTER_DEFAULTS_FILE=/etc/default/lizardfs-master
if [ -s "$LIZARDFSMASTER_DEFAULTS_FILE" ]; then
. "$LIZARDFSMASTER_DEFAULTS_FILE"
case "x$LIZARDFSMASTER_ENABLE" in
xtrue) ;;
xfalse)
log_warning_msg "lizardfs-master not enabled in \"$LIZARDFSMASTER_DEFAULTS_FILE\", exiting..."
exit 0
;;
*)
log_failure_msg "value of LIZARDFSMASTER_ENABLE must be either 'true' or 'false';"
log_failure_msg "not starting lizardfs-master."
exit 1
;;
esac
fi
set -e
if [ -n "$LIZARDFSMASTER_CONFIG_FILE" ]; then
CFGFILE="$LIZARDFSMASTER_CONFIG_FILE"
else
CFGFILE="$DEFAULT_CFG"
fi
get_config_value_from_CFGFILE()
{
echo $(sed -e 's/[[:blank:]]*#.*$//' -n -e 's/^[[:blank:]]*'$1'[[:blank:]]*=[[:blank:]]*\(.*\)$/\1/p' $CFGFILE)
}
if [ -s "$CFGFILE" ]; then
DATA_PATH=$(get_config_value_from_CFGFILE "DATA_PATH")
WORKING_USER=$(get_config_value_from_CFGFILE "WORKING_USER")
WORKING_GROUP=$(get_config_value_from_CFGFILE "WORKING_GROUP")
fi
: ${DATA_PATH:=$DEFAULT_DATA_PATH}
: ${WORKING_USER:=$DEFAULT_WORKING_USER}
: ${WORKING_GROUP:=$DEFAULT_WORKING_GROUP}
check_dirs()
{
# check that the metadata dir exists
if [ ! -d "$DATA_PATH" ]; then
mkdir -p "$DATA_PATH"
fi
chmod 0755 "$DATA_PATH"
chown -R $WORKING_USER:$WORKING_GROUP "$DATA_PATH"
}
case "$1" in
start)
check_dirs
echo "Starting $DESC:"
$DAEMON ${LIZARDFSMASTER_CONFIG_FILE:+-c $LIZARDFSMASTER_CONFIG_FILE} $DAEMON_OPTS start
;;
stop)
echo "Stopping $DESC:"
$DAEMON ${LIZARDFSMASTER_CONFIG_FILE:+-c $LIZARDFSMASTER_CONFIG_FILE} stop
;;
reload|force-reload)
echo "Reloading $DESC:"
$DAEMON ${LIZARDFSMASTER_CONFIG_FILE:+-c $LIZARDFSMASTER_CONFIG_FILE} reload
;;
restart)
check_dirs
echo "Restarting $DESC:"
$DAEMON ${LIZARDFSMASTER_CONFIG_FILE:+-c $LIZARDFSMASTER_CONFIG_FILE} restart
;;
*)
N=/etc/init.d/$NAME
echo "Usage: $N {start|stop|restart|force-reload}" >&2
exit 1
;;
esac
exit 0
lizardfs-v.3.9.4/debian/lizardfs-master.install 0000664 0000000 0000000 00000000670 12631772427 0021550 0 ustar 00root root 0000000 0000000 etc/mfs/mfsexports.cfg.dist
etc/mfs/mfstopology.cfg.dist
etc/mfs/mfsgoals.cfg.dist
etc/mfs/mfsmaster.cfg.dist
usr/sbin/mfsmaster
usr/sbin/mfsrestoremaster
usr/sbin/mfsmetarestore
usr/sbin/mfsmetadump
usr/share/man/man5/mfsexports.cfg.5
usr/share/man/man5/mfstopology.cfg.5
usr/share/man/man5/mfsgoals.cfg.5
usr/share/man/man5/mfsmaster.cfg.5
usr/share/man/man8/mfsmaster.8
usr/share/man/man8/mfsmetarestore.8
var/lib/mfs/metadata.mfs.empty
lizardfs-v.3.9.4/debian/lizardfs-master.postinst 0000664 0000000 0000000 00000000632 12631772427 0021763 0 ustar 00root root 0000000 0000000 #! /bin/sh
# Ensure proper permissions on data dir and run dir.
LIZARDFS_USER="mfs"
LIZARDFS_GROUP="mfs"
LIZARDFS_DATA_PATH="/var/lib/mfs"
check_dirs() {
# check that the metadata dir exists
if [ ! -d "$LIZARDFS_DATA_PATH" ]; then
mkdir -p "$LIZARDFS_DATA_PATH"
fi
chmod 0755 "$LIZARDFS_DATA_PATH"
chown -R $LIZARDFS_USER:$LIZARDFS_GROUP "$LIZARDFS_DATA_PATH"
}
check_dirs
#DEBHELPER#
# vim: ft=sh
lizardfs-v.3.9.4/debian/lizardfs-metalogger.default 0000664 0000000 0000000 00000000345 12631772427 0022360 0 ustar 00root root 0000000 0000000 # /etc/default/lizardfs-metalogger
# Start lizardfs-metalogger from init.d script on boot.
# Only allowed values are "true" and "false".
# Undefined values default to "false".
LIZARDFSMETALOGGER_ENABLE=false
DAEMON_OPTS=""
lizardfs-v.3.9.4/debian/lizardfs-metalogger.init 0000664 0000000 0000000 00000005602 12631772427 0021700 0 ustar 00root root 0000000 0000000 #!/bin/sh
### BEGIN INIT INFO
# Provides: lizardfs-metalogger
# Required-Start: $network $remote_fs
# Required-Stop: $remote_fs
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Start lizardfs-metalogger at boot time
# Description: lizardfs-metaloggers provide metadata replication for LizardFS.
### END INIT INFO
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DAEMON=/usr/sbin/mfsmetalogger
NAME=mfsmetalogger
DESC=lizardfs-metalogger
DEFAULT_WORKING_USER=mfs
DEFAULT_WORKING_GROUP=mfs
DEFAULT_DATA_PATH=/var/lib/mfs
DEFAULT_CFG=/etc/mfs/mfsmetalogger.cfg
test -e $DAEMON || exit 0
# Include lizardfs-metalogger defaults if available
. /lib/lsb/init-functions
LIZARDFSMETALOGGER_ENABLE=false
LIZARDFSMETALOGGER_CONFIG_FILE=
LIZARDFSMETALOGGER_DEFAULTS_FILE=/etc/default/lizardfs-metalogger
if [ -s "$LIZARDFSMETALOGGER_DEFAULTS_FILE" ]; then
. "$LIZARDFSMETALOGGER_DEFAULTS_FILE"
case "x$LIZARDFSMETALOGGER_ENABLE" in
xtrue) ;;
xfalse)
log_warning_msg "lizardfs-metalogger not enabled in \"$LIZARDFSMETALOGGER_DEFAULTS_FILE\", exiting..."
exit 0
;;
*)
log_failure_msg "value of LIZARDFSMETALOGGER_ENABLE must be either 'true' or 'false';"
log_failure_msg "not starting lizardfs-metalogger."
exit 1
;;
esac
fi
set -e
if [ -n "$LIZARDFSMETALOGGER_CONFIG_FILE" ]; then
CFGFILE="$LIZARDFSMETALOGGER_CONFIG_FILE"
else
CFGFILE="$DEFAULT_CFG"
fi
get_config_value_from_CFGFILE()
{
# parsing the value of config options from CFGFILE
echo $(sed -e 's/[[:blank:]]*#.*$//' -n -e 's/^[[:blank:]]*'$1'[[:blank:]]*=[[:blank:]]*\(.*\)$/\1/p' $CFGFILE)
}
if [ -s "$CFGFILE" ]; then
DATA_PATH=$(get_config_value_from_CFGFILE "DATA_PATH")
WORKING_USER=$(get_config_value_from_CFGFILE "WORKING_USER")
WORKING_GROUP=$(get_config_value_from_CFGFILE "WORKING_GROUP")
fi
: ${DATA_PATH:=$DEFAULT_DATA_PATH}
: ${WORKING_USER:=$DEFAULT_WORKING_USER}
: ${WORKING_GROUP:=$DEFAULT_WORKING_GROUP}
check_dirs()
{
# check that the metadata dir exists
if [ ! -d "$DATA_PATH" ]; then
mkdir -p "$DATA_PATH"
fi
chmod 0755 "$DATA_PATH"
chown -R $WORKING_USER:$WORKING_GROUP "$DATA_PATH"
}
case "$1" in
start)
check_dirs
echo "Starting $DESC:"
$DAEMON ${LIZARDFSMETALOGGER_CONFIG_FILE:+-c $LIZARDFSMETALOGGER_CONFIG_FILE} $DAEMON_OPTS start
;;
stop)
echo "Stopping $DESC:"
$DAEMON ${LIZARDFSMETALOGGER_CONFIG_FILE:+-c $LIZARDFSMETALOGGER_CONFIG_FILE} stop
echo "$NAME."
;;
reload|force-reload)
check_dirs
echo "Reloading $DESC:"
$DAEMON ${LIZARDFSMETALOGGER_CONFIG_FILE:+-c $LIZARDFSMETALOGGER_CONFIG_FILE} reload
;;
restart)
check_dirs
echo "Restarting $DESC:"
$DAEMON ${LIZARDFSMETALOGGER_CONFIG_FILE:+-c $LIZARDFSMETALOGGER_CONFIG_FILE} $DAEMON_OPTS restart
;;
*)
N=/etc/init.d/$NAME
echo "Usage: $N {start|stop|restart|reload|force-reload}" >&2
exit 1
;;
esac
exit 0
lizardfs-v.3.9.4/debian/lizardfs-metalogger.install 0000664 0000000 0000000 00000000200 12631772427 0022370 0 ustar 00root root 0000000 0000000 etc/mfs/mfsmetalogger.cfg.dist
usr/sbin/mfsmetalogger
usr/share/man/man5/mfsmetalogger.cfg.5
usr/share/man/man8/mfsmetalogger.8
lizardfs-v.3.9.4/debian/rules 0000775 0000000 0000000 00000000425 12631772427 0016127 0 ustar 00root root 0000000 0000000 #!/usr/bin/make -f
# -*- makefile -*-
# Uncomment this to turn on verbose mode.
#export DH_VERBOSE=1
.PHONY: override_dh_strip override_dh_auto_configure
override_dh_auto_configure:
./configure --with-doc
override_dh_strip:
dh_strip --dbg-package=lizardfs-dbg
%:
dh $@
lizardfs-v.3.9.4/debian/source/ 0000775 0000000 0000000 00000000000 12631772427 0016346 5 ustar 00root root 0000000 0000000 lizardfs-v.3.9.4/debian/source/format 0000664 0000000 0000000 00000000015 12631772427 0017555 0 ustar 00root root 0000000 0000000 3.0 (native)
lizardfs-v.3.9.4/doc/ 0000775 0000000 0000000 00000000000 12631772427 0014371 5 ustar 00root root 0000000 0000000 lizardfs-v.3.9.4/doc/CMakeLists.txt 0000664 0000000 0000000 00000004441 12631772427 0017134 0 ustar 00root root 0000000 0000000 if(NOT A2X_BINARY)
message(WARNING "Program 'a2x' not found, manpages won't be generated")
return()
endif()
# These manpages should be generated
set(MANPAGES
lizardfs.7 # not a source
lizardfs-admin.8
lizardfs-cgiserver.8
lizardfs-probe.8 # not a source
mfsappendchunks.1
mfscheckfile.1
mfsdirinfo.1
mfsfileinfo.1
mfsfilerepair.1
mfsgeteattr.1
mfsseteattr.1 # not a source
mfsdeleattr.1 # not a source
mfsgetgoal.1
mfssetgoal.1 # not a source
mfsrgetgoal.1 # not a source
mfsrsetgoal.1 # not a source
mfsgettrashtime.1
mfssettrashtime.1 # not a source
mfsrgettrashtime.1 # not a source
mfsrsettrashtime.1 # not a source
mfsmakesnapshot.1
mfsmount.1
mfsrepquota.1
mfssetquota.1 # not a source
mfstools.1
globaliolimits.cfg.5
iolimits.cfg.5
mfschunkserver.cfg.5
mfsexports.cfg.5
mfsgoals.cfg.5
mfshdd.cfg.5
mfsmaster.cfg.5
mfsmetalogger.cfg.5
mfstopology.cfg.5
mfsmetadump.8
mfsrestoremaster.8
moosefs.7
mfs.7 # not a source
mfscgiserv.8
mfschunkserver.8
mfsmaster.8
mfsmetalogger.8
mfsmetarestore.8
)
set(INSTALLED_MANPAGES)
foreach(MANPAGE ${MANPAGES})
get_filename_component(MANPAGE_SRC ${CMAKE_CURRENT_SOURCE_DIR}/${MANPAGE}.txt ABSOLUTE)
string(REGEX MATCH "[0-9]$" SECTION_NUMBER ${MANPAGE})
set(GENERATED_MANPAGE_PATH ${CMAKE_CURRENT_BINARY_DIR}/${MANPAGE})
if(ENABLE_VERBOSE_ASCIIDOC)
set(ASCIIDOC_VERBOSE --verbose --keep-artifacts)
else()
set(ASCIIDOC_VERBOSE)
endif()
if(EXISTS ${MANPAGE_SRC})
# Generate from the source...
set(MANPAGE_SRC_SYMLINK ${CMAKE_CURRENT_BINARY_DIR}/${MANPAGE}.txt)
add_custom_command(OUTPUT ${GENERATED_MANPAGE_PATH}
COMMAND ln -s -f ${MANPAGE_SRC} ${MANPAGE_SRC_SYMLINK}
COMMAND a2x ${ASCIIDOC_VERBOSE} -f manpage ${MANPAGE_SRC_SYMLINK}
DEPENDS ${MANPAGE_SRC})
# Add this file to the main target's dependencies
set(GENERATED_MANPAGES ${GENERATED_MANPAGES} ${GENERATED_MANPAGE_PATH})
endif()
# Install the generated file
install(FILES ${GENERATED_MANPAGE_PATH} DESTINATION ${MAN_SUBDIR}/man${SECTION_NUMBER})
endforeach()
add_custom_target(manpages ALL SOURCES ${GENERATED_MANPAGES})
lizardfs-v.3.9.4/doc/globaliolimits.cfg.5.txt 0000664 0000000 0000000 00000006303 12631772427 0021047 0 ustar 00root root 0000000 0000000 globaliolimits.cfg(5)
=====================
== NAME
globaliolimits.cfg - global I/O limiting configuration
== DESCRIPTION
The file *globaliolimits.cfg* contains configuration of the global I/O limiter.
== SYNTAX
Syntax is:
'option' 'value'
Lines starting with *#* character are ignored.
== OPTIONS
Configuration options:
*subsystem *::
The cgroups subsystem by which clients are classified.
If left unspecified, all clients are considered 'unclassified' (see below).
*limit unclassified *::
This is a special entry for clients that don't match any group specified in
configuration file or for all clients if *subsystem* is unspecified.
If this entry is unspecified and subsystem is unspecified as well, I/O limiting
is disabled entirely. If this entry is unspecified but subsystem is specified,
unclassified clients are not allowed to perform I/O.
*limit *::
Set limit for clients belonging to the cgroups group **.
In LizardFS, subgroups of ** constitute independent groups; they are not
allowed to use *'s* bandwidth reservation and they don't count against
*'s* usage.
== EXAMPLES
# empty file
I/O limiting is disabled, no limits are enforced.
limit unclassified 1024
All clients are 'unclassified' and share 1MiB/s of bandwidth.
subsystem blkio
limit /a 1024
Clients in the *blkio* */a* group are limited to 1MiB/s, no other clients can
perform any I/O.
subsystem blkio
limit unclassified 256
limit /a 1024
limit /b/a 2048
The *blkio* group */a* is allowed to transfer 1MiB/s, while */b/a* gets 2MiB/s.
Clients from other groups (e.g. */b*, */z*, */a/a*, */b/z*) are considered
'unclassified' and share 256KiB/s of bandwidth.
== TUNING NOTES
Global I/O limiting is managed by the master server. Mount instances reserve
bandwidth allocations from master when they want to perform I/O to
chunkservers.
To avoid overloading the master under heavy traffic, mounts try to predict their
future usage and reserve at once all the bandwidth they will for the next
renegotiation period (see mfsmaster.cfg(5)).
Such reservation are wasted if the traffic at given mount instance suddenly
drops.
The ratio of bandwidth being wasted due to this phenomenon shouldn't exceed
*fsp/b*, where:
f is the frequency of sudden traffic drops in the whole installation (in 1/s)
s is the average size of such drop (in KiB/s)
p is the renegotiation period (in s)
b is the bandwidth limit (in KiB/s)
This applies to each group separately, because groups reserve their bandwidth
independently from each other.
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfsmaster.cfg(5)
lizardfs-v.3.9.4/doc/iolimits.cfg.5.txt 0000664 0000000 0000000 00000001620 12631772427 0017663 0 ustar 00root root 0000000 0000000 iolimits.cfg(5)
===============
== NAME
iolimits.cfg - local I/O limiting configuration
== DESCRIPTION
The file *iolimits.cfg* contains configuration of the local I/O limiter.
== SYNTAX, OPTIONS
The same as in globaliolimits.cfg(5).
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfsmount.cfg(5), globaliolimits.cfg(5)
lizardfs-v.3.9.4/doc/lizardfs-admin.8.txt 0000664 0000000 0000000 00000007466 12631772427 0020221 0 ustar 00root root 0000000 0000000 lizardfs-admin(8)
=================
== NAME
lizardfs-admin, lizardfs-probe - LizardFS monitoring and administration tool
== SYNOPSIS
**lizardfs-admin** __COMMAND__ [OPTIONS...] [ARGUMENTS...]
== Available COMMANDs
*chunks-health* __ __::
Returns chunks health reports in the installation.
By default (if no report is specified) all reports will be shown.
In replication and deletion states, the column means the number of chunks
with number of copies specified in the label to replicate/delete. +
Possible command-line options: +
--availability +
Print report about availability of chunks. +
--replication +
Print report about about number of chunks that need replication. +
--deletion +
Print report about about number of chunks that need deletion. +
*info* __ __::
Prints statistics concerning the LizardFS installation.
*iolimits-status* __ __::
Prints current configuration of global I/O limiting
*list-chunkservers* __ __::
Prints information about all connected chunkservers.
*list-disks* __ __::
Prints information about all connected chunkservers. +
Possible command-line options: +
--verbose +
Be a little more verbose and show operations statistics.
*list-goals* __ __::
List goal definitions. +
Possible command-line options: +
--pretty +
Print nice table
*list-mounts* __ __::
Prints information about all connected mounts. +
Possible command-line options +
--verbose +
Be a little more verbose and show goal and trash time limits.
*metadataserver-status* __ __::
Prints status of a master or shadow master server
*list-metadataservers* __ __::
Prints status of active metadata servers.
*ready-chunkservers-count* __ __::
Prints number of chunkservers ready to be written to.
*promote-shadow* __ __::
Promotes metadata server. Works only if personality 'ha-cluster-managed' is used.
Authentication with the admin password is required.
*stop-master-without-saving-metadata* __ __::
Stop the master server without saving metadata in the metadata.mfs file.
Used to quickly migrate a metadata server (works for all personalities).
Authentication with the admin password is required.
*reload-config* __ __::
Requests reloading configuration from the config file.
This is synchronous (waits for reload to finish).
Authentication with the admin password is required.
*save-metadata* __ __::
Requests saving the current state of metadata into the metadata.mfs file.
With --async fail if the process cannot be started, e.g. because the process
is already in progress. Without --async, fails if either the process cannot be
started or if it finishes with an error (i.e., no metadata file is created).
Authentication with the admin password is required. +
Possible command-line options: +
--async +
Don't wait for the task to finish.
== COMMON COMMAND OPTIONS
*--porcelain*::
Make the output parsing-friendly.
== COPYRIGHT
2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
lizardfs-v.3.9.4/doc/lizardfs-cgiserver.8.txt 0000664 0000000 0000000 00000002613 12631772427 0021107 0 ustar 00root root 0000000 0000000 mfscgiserv(8)
=============
== NAME
lizardfs-cgiserver - simple HTTP/CGI server for Lizard File System monitoring
== SYNOPSIS
[verse]
*lizardfs-cgiserver* [*-H* 'BIND-HOST'] [*-P* 'BIND-PORT'] [*-R* 'ROOT-PATH'] [*-v*]
[verse]
*lizardfs-cgiserver* *-h*
== DESCRIPTION
*lizardfs-cgiserver* is a very simple HTTP server capable of running CGI scripts for Lizard File System
monitoring. It just runs in foreground and works until killed with e.g. SIGINT or SIGTERM.
== OPTIONS
*-h*::
print usage information and exit
*-H* 'BIND_HOST'::
local address to listen on (default: any)
*-P* 'BIND_PORT'::
port to listen on (default: 9425)
*-R* 'ROOT_PATH'::
local path to use as HTTP document root (default is CGIDIR set up at configure time)
*-v*::
log requests on stderr
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
moosefs(7)
lizardfs-v.3.9.4/doc/mfsappendchunks.1.txt 0000664 0000000 0000000 00000002252 12631772427 0020463 0 ustar 00root root 0000000 0000000 mfsappendchunks(1)
==================
== NAME
mfsappendchunks - lazy append chunks
== SYNOPSIS
[verse]
*mfsappendchunks* 'SNAPSHOT_FILE' 'OBJECT'...
== DESCRIPTION
*mfsappendchunks* (equivalent of *mfssnapshot* from MooseFS 1.5) appends a lazy copy of specified
file(s) to specified snapshot file ("lazy" means that creation of new chunks is delayed to the
moment one copy is modified). If multiple files are given, they are merged into one target file in
the way that each file begins at 'chunk' (64MB) boundary; padding space is left empty.
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfstools(1)
lizardfs-v.3.9.4/doc/mfscgiserv.8.txt 0000664 0000000 0000000 00000004153 12631772427 0017453 0 ustar 00root root 0000000 0000000 mfscgiserv(8)
=============
== NAME
mfscgiserv - start HTTP/CGI server for Lizard File System monitoring
== SYNOPSIS
[verse]
*mfscgiserv* [*-H* 'BIND-HOST'] [*-P* 'BIND-PORT'] [*-R* 'ROOT-PATH']
[*-D* 'DATA-PATH'] [*-t* 'LOCKTIMEOUT'] [*-f* [*-v*]] ['ACTION']
[verse]
*mfscgiserv* *-h*
== DESCRIPTION
######################## ! DEPRECATION WARNING ! #########################
# #
# mfscgiserv service is deprecated, please use lizardfs-cgiserv instead. #
# See manual entry lizardfs-cgiserver(8) for details. #
# #
######################## ! DEPRECATION WARNING ! #########################
*mfscgiserv* is a very simple HTTP server capable of running CGI scripts for Lizard File System
monitoring.
== OPTIONS
*-h*::
print usage information and exit
*-H* 'BIND_HOST'::
local address to listen on (default: any)
*-P* 'BIND_PORT'::
port to listen on (default: 9425)
*-R* 'ROOT_PATH'::
local path to use as HTTP document root (default is CGIDIR set up at configure time)
*-D* 'DATA_PATH'::
local path to store data, e.g. a lockfile (default is DATA_PATH set up at configure time)
*-f*::
run in foreground, don't daemonize
*-v*::
log requests on stderr
*-t* 'LOCKTIMEOUT'::
how long to wait for lockfile (default is 60 seconds)
'ACTION'
is the one of *start*, *stop*, *restart* or *test*. Default action is *restart*.
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
moosefs(7)
lizardfs-v.3.9.4/doc/mfscheckfile.1.txt 0000664 0000000 0000000 00000001702 12631772427 0017714 0 ustar 00root root 0000000 0000000 mfscheckfile(1)
===============
== NAME
mfscheckfile - print information about chunks
== SYNOPSIS
[verse]
*mfscheckfile* 'FILE'...
== DESCRIPTION
*mfscheckfile*
checks and prints number of chunks and number of chunk copies belonging to specified
file(s). It can be used on any file, included deleted ('trash').
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfstools(1)
lizardfs-v.3.9.4/doc/mfschunkserver.8.txt 0000664 0000000 0000000 00000006124 12631772427 0020350 0 ustar 00root root 0000000 0000000 mfschunkserver(8)
=================
== NAME
mfschunkserver - start, restart or stop Lizard File System chunkserver process
== SYNOPSIS
[verse]
*mfschunkserver* [*-f*] [*-c* 'CFGFILE'] [*-u*] [*-d*] [*-t* 'LOCKTIMEOUT'] ['ACTION']
[verse]
*mfschunkserver -s* [*-c* 'CFGFILE']
[verse]
*mfschunkserver -v*
[verse]
*mfschunkserver -h*
== DESCRIPTION
*mfschunkserver* is the data server of Lizard File System. Depending on parameters it can start,
restart or stop LizardFS chunkserver process. Without any options it starts LizardFS chunkserver,
killing previously run process if lock file exists.
SIGHUP (or *reload* 'ACTION') forces *mfschunkserver* to reload all configuration files.
Chunkserver periodically tests stored chunks (see *HDD_TEST_FREQ* option
in *mfschunkserver.cfg* manual).
LizardFS master doesn't send metadata change logs to chunkserver and
expect at least one *mfsmetalogger* daemon to connect.
Chunkserver scans attached disks in background.
== OPTIONS
*-v*::
print version information and exit
*-h*::
print usage information and exit
*-f*::
(deprecated, use *start* action instead)
forcily run LizardFS chunkserver process, without trying to kill previous instance (this option
allows to run LizardFS chunkserver if stale PID file exists)
*-s*::
(deprecated, use *stop* action instead)
stop LizardFS chunkserver process
*-c* 'CFGFILE'::
specify alternative path of configuration file (default is *mfschunkserver.cfg* in system
configuration directory)
*-u*::
log undefined configuration values (when default is assumed)
*-d*::
run in foreground, don't daemonize
*-t* 'LOCKTIMEOUT'::
how long to wait for lockfile (default is 60 seconds)
'ACTION'
is the one of *start*, *stop*, *restart*, *reload*, *test*, *isalive* or *kill*. Default action is
*restart*.
== FILES
*mfschunkserver.cfg*::
configuration file for LizardFS chunkserver process; refer to *mfschunkserver.cfg*(5) manual for
defails
*mfshdd.cfg*::
list of directories (mountpoints) used for LizardFS storage (one per line; directory prefixed by ***
character causes given directory to be freed by replicating all data already stored there to another
locations)
*mfschunkserver.lock*::
PID file of running LizardFS chunkserver process
*.mfschunkserver.lock*::
lock file of running LizardFS chunkserver process
(created in data directory)
*data.csstats*::
Chunkserver charts state
== REPORTING BUGS
Report bugs to .
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfsmaster(8), mfsmount(1), mfschunkserver.cfg(5), mfshdd.cfg(5), moosefs(7)
lizardfs-v.3.9.4/doc/mfschunkserver.cfg.5.txt 0000664 0000000 0000000 00000010726 12631772427 0021106 0 ustar 00root root 0000000 0000000 mfschunkserver.cfg(5)
=====================
== NAME
mfschunkserver.cfg - main configuration file for *mfschunkserver*
== DESCRIPTION
The file *mfschunkserver.cfg* contains configuration of LizardFS chunkserver process.
== SYNTAX
Syntax is:
'OPTION' *=* 'VALUE'::
Lines starting with *#* character are ignored.
== OPTIONS
Configuration options:
*DATA_PATH*::
where to store files with usage statistics and daemon lock file
*LABEL*::
the label of this chunkserver (for tiering)
*WORKING_USER*::
user to run daemon as
*WORKING_GROUP*::
group to run daemon as (optional - if empty then default user group will be used)
*SYSLOG_IDENT*::
name of process to place in syslog messages (default is mfschunkserver)
*LOCK_MEMORY*::
whether to perform mlockall() to avoid swapping out mfschunkserver process (default is 0, i.e. no)
*NICE_LEVEL*::
nice level to run daemon with (default is -19 if possible; note: process must be started as root to
increase priority)
*MASTER_HOST*::
address of LizardFS master host to connect with (default is mfsmaster)
*MASTER_PORT*::
number of LizardFS master port to connect with (default is 9420)
*MASTER_RECONNECTION_DELAY*::
delay in seconds before trying to reconnect to the master server after disconnection (default is 5)
*MASTER_TIMEOUT*::
timeout (in seconds) for the master server connection (default is 60, minimum is 0.01)
*BIND_HOST*::
local address to use for connecting with the master server (default is ***,
i.e. default local address)
*CSSERV_LISTEN_HOST*::
IP address to listen on for client (mount) connections (*** means any)
*CSSERV_LISTEN_PORT*::
port to listen on for client (mount) connections (default is 9422)
*CSSERV_TIMEOUT*::
timeout (in seconds) for client (mount) connections (default is 5)
*HDD_CONF_FILENAME*::
alternative name of *mfshdd.cfg* file
*HDD_LEAVE_SPACE_DEFAULT*::
free space threshold to set volume as 100% utilized when there is less than given amount of free
space left (default is "4GiB"). This number is always added to the used disk space reported by
chunkserver.
*HDD_TEST_FREQ*::
chunk test period in seconds (default is 10)
*HDD_ADVISE_NO_CACHE*::
whether to remove each chunk from page when closing it to reduce cache pressure
generated by chunkserver (default is 0, i.e. no)
*REPLICATION_BANDWIDTH_LIMIT_KBPS*::
limit how many kilobytes can be replicated from other chunkservers to this chunkserver in every
second (by default undefined, i.e. no limits)
*NR_OF_NETWORK_WORKERS*::
number of threads which handle (in a round-robin manner) connections with clients (default is 1);
these threads are responsible for reading from sockets and coping data from internal buffers to
sockets
*NR_OF_HDD_WORKERS_PER_NETWORK_WORKER*::
number of threads that each network worker may use to do disk operations like opening chunks,
reading or writing them (default is 2)
*READ_AHEAD_KB*::
additional number of kilobytes which should be passed to posix_fadvise(POSIX_FADV_WILLNEED)
before reading data from a chunk (default is 0, i.e. use posix_fadvise only with the amount
of data that is really needed; the value is aligned down to 64 KiB)
*MAX_READ_BEHIND_KB*::
try to fix out-of-order read requests; the value tells how much of skipped data to read if an
offset of some read operation is greater than the offset where the previos operation finished
(default is 0, i.e. don't read any skipped data; the value is aligned down to 64 KiB)
*USE_SPLICE*::
whether to use splice syscall when doing disk operations on data blocks (default is 1, i.e. enabled)
*CREATE_NEW_CHUNKS_IN_MOOSEFS_FORMAT*::
whether to create new chunks in the MooseFS format (signature + * + *) or in
the newer interleaved format ([ ]*). (Default is 1, i.e. new chunks are created
in MooseFS format)
*PERFORM_FSYNC*::
call fsync() after a chunk is modified (default is 1, i.e. enabled)
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfschunkserver(8), mfshdd.cfg(5)
lizardfs-v.3.9.4/doc/mfsdirinfo.1.txt 0000664 0000000 0000000 00000002004 12631772427 0017425 0 ustar 00root root 0000000 0000000 mfsdirinfo(1)
=============
== NAME
mfsdirinfo - show directories stats
== SYNOPSIS
[verse]
*mfsdirinfo* [*-n*|*-h*|*-H*] 'OBJECT'...
== DESCRIPTION
*mfsdirinfo* is extended, LizardFS-specific equivalent of *du -s* command. It prints summary for each
specified object (single file or directory tree).
== OPTIONS
*-n*, *-h*, *-H*::
These options are described in mfstools(1).
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfstools(1)
lizardfs-v.3.9.4/doc/mfsexports.cfg.5.txt 0000664 0000000 0000000 00000010143 12631772427 0020244 0 ustar 00root root 0000000 0000000 mfsexports.cfg(5)
=================
== NAME
mfsexports.cfg - LizardFS access control for mfsmounts
== DESCRIPTION
The file *mfsexports.cfg* contains LizardFS access list for *mfsmount*
clients.
== SYNTAX
Syntax is:
'ADDRESS' 'DIRECTORY' ['OPTIONS']
Lines starting with *#* character are ignored.
'ADDRESS' can be specified in several forms:
- *** all addresses
- *n.n.n.n* single IP address
- *n.n.n.n/b* IP class specified by network address and bits number
- *n.n.n.n/m.m.m.m* IP class specified by network address and mask
- *f.f.f.f-t.t.t.t* IP range specified by from-to addresses (inclusive)
'DIRECTORY' could be */* or path relative to LizardFS root; special value *.* means MFSMETA companion
filesystem.
== OPTIONS
*ro*, *readonly*::
export tree in read-only mode (default)
*rw*, *readwrite*::
export tree in read-write mode
*ignoregid*::
disable testing of group access at *mfsmaster* level (it's still done at *mfsmount* level) - in this
case "group" and "other" permissions are logically added; needed for supplementary groups to work
(*mfsmaster* receives only user primary group information)
*dynamicip*::
allows reconnecting of already authenticated client from any IP address (the default is to check IP
address on reconnect)
*maproot=*'USER'[*:*'GROUP']::
maps root (uid=0) accesses to given user and group (similarly to maproot option in NFS mounts);
'USER' and 'GROUP' can be given either as name or number; if no group is specified, 'USER''s primary
group is used. Names are resolved on *mfsmaster* side (see note below).
*mapall=*'USER'[*:*'GROUP']::
like above but maps all non privileged users (uid!=0) accesses to given user and group (see notes
below).
*minversion=*'VER'::
rejects access from clients older than specified
*mingoal=*'N', *maxgoal=*'N'::
specify range in which goal can be set by users
*mintrashtime=*'TDUR', *maxtrashtime=*'TDUR'::
specify range in which trashtime can be set by users
*password=*'PASS', *md5pass=*'MD5'::
requires password authentication in order to access specified resource
*alldirs*::
allows to mount any subdirectory of specified directory (similarly to NFS)
*nonrootmeta*::
allows non-root users to use filesystem mounted in the meta mode (option available only in this mode)
Default options are: *ro,maproot=999:999*.
== NOTES
'USER' and 'GROUP' names (if not specified by explicit uid/gid number) are resolved on *mfsmaster*
host.
TDUR can be specified as number without time unit (number of seconds) or combination of numbers with
time units. Time units are: *W*,*D*,*H*,*M*,*S*. Order is important - less significant time units
can't be defined before more significant time units.
Option *mapall* works in LizardFS in different way than in NFS, because of using FUSE's
"default_permissions" option. When mapall option is used, users see all objects with uid equal to
mapped uid as their own and all other as root's objects. Similarly objects with gid equal to mapped
gid are seen as objects with current user's primary group and all other objects as objects with
group 0 (usually wheel). With *mapall* option set attribute cache in kernel is always turned off.
== EXAMPLES
- ** / ro*
- *192.168.1.0/24 / rw*
- *192.168.1.0/24 / rw,alldirs,maproot=0,password=passcode*
- *10.0.0.0-10.0.0.5 /test rw,maproot=nobody,password=test*
- *10.1.0.0/255.255.0.0 /public rw,mapall=1000:1000*
- *10.2.0.0/16 / rw,alldirs,maproot=0,mintrashtime=2h30m,maxtrashtime=2w*
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfsmaster(8), mfsmaster.cfg(5)
lizardfs-v.3.9.4/doc/mfsfileinfo.1.txt 0000664 0000000 0000000 00000001657 12631772427 0017603 0 ustar 00root root 0000000 0000000 mfsfileinfo(1)
==============
== NAME
mfsfileinfo - locate chunks
== SYNOPSIS
[verse]
*mfsfileinfo* 'FILE'...
== DESCRIPTION
*mfsfileinfo* prints location ('chunkserver' host and port) of each chunk copy belonging to
specified file(s). It can be used on any file, included deleted ('trash').
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfstools(1)
lizardfs-v.3.9.4/doc/mfsfilerepair.1.txt 0000664 0000000 0000000 00000002535 12631772427 0020126 0 ustar 00root root 0000000 0000000 mfsfilerepair(1)
================
== NAME
mfsfilerepair - repair broken files
== SYNOPSIS
[verse]
*mfsfilerepair* [*-n*|*-h*|*-H*] 'FILE'...
== DESCRIPTION
*mfsfilerepair* deals with broken files (those which cause I/O errors on read operations) to make
them partially readable. In case of missing chunk it fills missing parts of file with zeros; in case
of chunk version mismatch it sets chunk version known to *mfsmaster* to highest one found on
chunkservers.
NOTE: Because in the second case content mismatch can occur in chunks with the same version, it's
advised to make a copy (not a snapshot!) and delete original file after "repairing".
== OPTIONS
*-n*, *-h*, *-H*::
These options are described in mfstools(1).
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfstools(1)
lizardfs-v.3.9.4/doc/mfsgeteattr.1.txt 0000664 0000000 0000000 00000003357 12631772427 0017626 0 ustar 00root root 0000000 0000000 mfsgeteattr(1)
==============
== NAME
mfsgeteattr, mfsseteattr, mfsdeleattr - get, set or delete extra attributes
== SYNOPSIS
[verse]
*mfsgeteattr* [*-r*] [*-n*|*-h*|*-H*] 'OBJECT'...
[verse]
*mfsseteattr* [*-r*] [*-n*|*-h*|*-H*] *-f* 'ATTRNAME' [*-f* 'ATTRNAME' ...] 'OBJECT'...
[verse]
*mfsdeleattr* [*-r*] [*-n*|*-h*|*-H*] *-f* 'ATTRNAME' [*-f* 'ATTRNAME' ...] 'OBJECT'...
== DESCRIPTION
*mfsgeteattr*, *mfsseteattr* and *mfsdeleattr*
tools are used to get, set or delete some extra attributes. Attributes are described below.
== OPTIONS
*-r*::
This option enables recursive mode.
*-n*, *-h*, *-H*::
These options are described in mfstools(1).
== EXTRA ATTRIBUTES
*noowner*::
This flag means, that particular object belongs to current user ('uid' and 'gid' are equal to 'uid'
and 'gid' values of accessing process). Only root ('uid'=0) sees the real 'uid' and 'gid'.
*noattrcache*::
This flag means, that standard file attributes such as uid, gid, mode, length and so on won't be
stored in kernel cache.
*noentrycache*::
This flag is similar to above. It prevents directory entries from being cached in kernel.
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfstools(1)
lizardfs-v.3.9.4/doc/mfsgetgoal.1.txt 0000664 0000000 0000000 00000003126 12631772427 0017423 0 ustar 00root root 0000000 0000000 mfsgetgoal(1)
===========
== NAME
mfsgetgoal, mfssetgoal, mfsrgetgoal, mfsrsetgoal - change or retrieve goal
== SYNOPSIS
[verse]
*mfsgetgoal* [*-r*] [*-n*|*-h*|*-H*] 'OBJECT'...
[verse]
*mfsrgetgoal* [*-n*|*-h*|*-H*] 'OBJECT'...
[verse]
*mfssetgoal* [*-r*] [*-n*|*-h*|*-H*] GOAL_NAME 'OBJECT'...
[verse]
*mfsrsetgoal* [*-n*|*-h*|*-H*] GOAL_NAME 'OBJECT'...
== DESCRIPTION
*mfsgetgoal* and *mfssetgoal* operate on object's 'goal' value.
*mfsgetgoal* prints current 'goal' value of given object(s). These tools can be used on any file,
directory or deleted ('trash') file.
== OPTIONS
*-r*::
This option enables recursive mode, which works as usual for every given file, but for every given
directory additionally prints current value of all contained objects (files and directories).
*-n*, *-h*, *-H*::
These options are described in mfstools(1).
== NOTE
*mfsrgetgoal* and *mfsrsetgoal* are deprecated aliases for
*mfsgetgoal -r* and *mfssetgoal -r* respectively.
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfstools(1)
lizardfs-v.3.9.4/doc/mfsgettrashtime.1.txt 0000664 0000000 0000000 00000004274 12631772427 0020506 0 ustar 00root root 0000000 0000000 mfsgettrashtime(1)
==================
== NAME
mfsgettrashtime, mfssettrashtime, mfsrgettrashtime, mfsrsettrashtime - get or set trash time
== SYNOPSIS
[verse]
*mfsgettrashtime* [*-r*] [*-n*|*-h*|*-H*] 'OBJECT'...
[verse]
*mfsrgettrashtime* [*-n*|*-h*|*-H*] 'OBJECT'...
[verse]
*mfssettrashtime* [*-r*] [*-n*|*-h*|*-H*] SECONDS[*+*|*-*] 'OBJECT'...
[verse]
*mfsrsettrashtime* [*-n*|*-h*|*-H*] SECONDS[*+*|*-*] 'OBJECT'...
== DESCRIPTION
*mfsgettrashtime* and *mfssettrashtime* operate on object's 'trashtime' value, i.e. the number of
seconds the file is preserved in special 'trash' directory before it's finally removed from
filesystem. 'Trashtime' must be non-negative integer value. *mfsgettrashtime* prints current
'trashtime' value of given object(s).
== OPTIONS
*-r*::
This option enables recursive mode, which works as usual for every given file, but for every given
directory additionally prints current 'trashtime' value of all contained objects (files and
directories).
'N'\[*+*|*-*]::
If new value is specified in 'N'*+* form, 'trashtime' value is increased to 'N' for objects with
lower 'trashtime' value and unchanged for the rest. Similarly, if new value is specified as 'N'*-*,
'trashtime' value is decreased to 'N' for objects with higher 'trashtime' value and unchanged for
the rest. These tools can be used on any file, directory or deleted ('trash') file.
*-n*, *-h*, *-H*::
These options are described in mfstools(1).
== NOTE
*mfsrgettrashtime* and *mfsrsettrashtime* are deprecated aliases for
*mfsgettrashtime -r* and *mfssettrashtime -r* respectively.
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfstools(1)
lizardfs-v.3.9.4/doc/mfsgoals.cfg.5.txt 0000664 0000000 0000000 00000007055 12631772427 0017655 0 ustar 00root root 0000000 0000000 mfsgoals.cfg(5)
===============
== NAME
mfsgoals.cfg - replication goals configuration file
== DESCRIPTION
The file *mfsgoals.cfg* contains definitions of the replication goals.
== SYNTAX
Syntax is:
'id' 'name' : $'type' { 'label' ... }
'id' 'name' : 'label' ...
The *#* character starts comments.
== DETAILS
There are 40 replication goals, with 'ids' between 1 and 40, inclusive.
Each file stored on the filesystem refers to some goal id and is
replicated according to the goal currently associated with this id.
By default, goal 1 means one copy on any chunkserver, goal 2 means two
copies on any two chunkservers and so on, until 5 - which is the maximal
default number of copies. The purpose of mfsgoals.cfg is to override this
behavior, when desired. The file is a list of goal definitions, each
consisting of 'id', 'name' and a list of 'labels'. The maximal length
of this list is 40 labels.
'id' indicates the goal id to be redefined. If some files are already
assigned this goal id, their effective goal will change.
'name' is a human readable name used by the user interface tools
(mfssetgoal(1), mfsgetgoal(1)). 'name' can consist of up to 32 alphanumeric
characters: a-z, A-Z, 0-9, _.
'type' specifies goal type - currently supported types are:
- *std* - for each file using this goal and for each label, the system
will try to maintain a copy of the file on some chunkserver
with this label.
- **xor**N - for each file using this goal, the system will split the file
into N+1 parts (N ordinary + 1 parity). For reading, any N of
the parts are necessary. If labels are specified, parts will
be kept on chunkservers with this labels. Otherwise default wildcard
labels will be used.
If the type is unspecified is is assumed to be *std*.
The list of 'labels' is a list of chunkserver labels as defined in
mfschunkserver.cfg(5). 'label' can consist of up to 32 alphanumeric
characters: a-z, A-Z, 0-9, _.
One label may occur multiple times - in such case the system will create
one copy per each occurrence.
The special label _ means "a copy on any chunkserver".
Note that changing the definition of a goal in mfsgoals.cfg affects all
files which currently use given goal id.
== EXAMPLES
Some example goal definitions:
3 3 : _ _ _ # one of the default goals (three copies anywhere)
8 not_important_file : _ # only one copy
11 important_file : _ _
12 local_copy_on_mars : mars _ # at least one copy in the Martian datacenter
13 cached_on_ssd : ssd _
14 very_important_file : _ _ _ _
15 default_xor3 : $xor3
16 fast_read : $xor2 { ssd ssd hdd }
17 xor5 : $xor5 { hdd } # at least one part on hdd
== SNAPSHOT FILES
Snapshot shares data with the original file until the file receives
modification and diverges from the snapshotted version.
If some snapshot has different goal than its original file, any shared
data are stored according to the goal with higher 'id' of the two.
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfsmaster.cfg(5)
lizardfs-v.3.9.4/doc/mfshdd.cfg.5.txt 0000664 0000000 0000000 00000002102 12631772427 0017273 0 ustar 00root root 0000000 0000000 mfshdd.cfg(5)
=============
== NAME
mfshdd.cfg - list of LizardFS storage directories for mfschunkserver
== DESCRIPTION
The file *mfshdd.cfg* contains list of directories (mountpoints) used for LizardFS storage (one per
line). Directory prefixed by *** character causes given directory to be freed by replicating all
data already stored there to another locations. Lines starting with *#* character are ignored.
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfschunkserver(8), mfschunkserver.cfg(5)
lizardfs-v.3.9.4/doc/mfsmakesnapshot.1.txt 0000664 0000000 0000000 00000002465 12631772427 0020503 0 ustar 00root root 0000000 0000000 mfsmakesnapshot(1)
==================
== NAME
mfsmakesnapshot - make lazy copies
== SYNOPSIS
[verse]
*mfsmakesnapshot* [*-o*] [*-f*] 'SOURCE'... 'DESTINATION'
== DESCRIPTION
*mfsmakesnapshot* makes a "real" snapshot (lazy copy, like in case of *mfsappendchunks*) of some
object(s) or subtree (similarly to *cp -r* command). It's atomic with respect to each 'SOURCE'
argument separately. If 'DESTINATION' points to already existing file, error will be reported unless
*-f* (force) or it's alias *-o* (overwrite) option is given.
NOTE: if 'SOURCE' is a directory, it's copied as a whole; but if it's followed by trailing slash,
only directory content is copied.
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfstools(1), mfsappendchunks(1)
lizardfs-v.3.9.4/doc/mfsmaster.8.txt 0000664 0000000 0000000 00000010442 12631772427 0017302 0 ustar 00root root 0000000 0000000 mfsmaster(8)
============
== NAME
mfsmaster - start, restart or stop Lizard File System metadata server process
== SYNOPSIS
[verse]
mfsmaster [*-f*] [*-c* 'CFGFILE'] [*-u*] [*-d*] [*-t* 'LOCKTIMEOUT'] ['ACTION']
[verse]
*mfsmaster -s* [*-c* 'CFGFILE']
[verse]
*mfsmaster -v*
[verse]
*mfsmaster -h*
== DESCRIPTION
*mfsmaster* is the metadata server program of Lizard File System. Depending on parameters it can
start, restart or stop LizardFS metadata server process. Without any options it starts LizardFS
metadata server, killing previously run process if lock file exists.
Metadata server can work in one of two modes (personalities):
. master
. shadow
If metadata server works with 'master' personality it acts as main metadata server
govering all file system metadata modifications.
If metadata server works with 'shadow' personality it acts as backup metadata server
ready for immediate deployment as new 'master' in case of current 'master' failure.
Shadow only accepts connections from lizardfs-admin, i.e. mfschunkserver, mfsmetalogger
and mfsmount (the client) are not allowed to connect to 'shadow' instance.
Current metadata server personality is defined in metadata server configuration file
and can be changed on the fly from 'shadow' to 'master' by proper modification and reloading
of its configuration file.
'Master' and 'shadow' are designed to run simultaneously in sync forever. It is very unlikely
but still (due to a memory corruption or a bug) possible that after some time their metadata
will somehow differ. Since version 2.5.2 metadata checksum is maintained both by 'master'
and 'shadow', in order to detect and fix possible metadata corruptions. In case mismatch is
detected 'shadow' asks 'master' to double check its metadata and dump its current snapshot.
After the metadata is dumped and the checksum in 'master' is recalculated shadow downloads
the new metadata snapshot, which should ensure that master and all shadows have exactly the
same metadata.
SIGHUP (or 'reload' 'ACTION') forces *mfsmaster* to reload all configuration files.
*-v*::
print version information and exit
*-h*::
print usage information and exit
*-f*::
(deprecated, use *start* action instead)
forcily run LizardFS master process, without trying to kill
previous instance (this option allows to run LizardFS master if stale PID file exists)
*-s*::
(deprecated, use *stop* action instead)
stop LizardFS master process
*-c* 'CFGFILE'::
specify alternative path of configuration file (default is *mfsmaster.cfg* in system configuration
directory)
*-u*::
log undefined configuration values (when default is assumed)
*-d*::
run in foreground, don't daemonize
*-t* 'LOCKTIMEOUT'::
how long to wait for lockfile (default is 60 seconds)
'ACTION'::
is the one of *start*, *stop*, *restart*, *reload*, *test*, *isalive* or *kill*. Default action is
*restart*.
== FILES
*mfsmaster.cfg*::
configuration file for LizardFS master process (see *mfsmaster.cfg*(5) manual)
*mfsexports.cfg*::
LizardFS access control file (used with *mfsmount*`s` 1.6.0 or later, see
*mfsexports.cfg*(5) manual)
*mfstopology.cfg*::
Network topology definitions (see *mfstopology.cfg*(5) manual)
*mfsmaster.lock*::
PID file of running LizardFS master process
*.mfsmaster.lock*::
lock file of running LizardFS master process
(created in data directory)
*metadata.mfs*, *metadata.mfs.back*::
LizardFS filesystem metadata image
*`changelog.*.mfs`*::
LizardFS filesystem metadata change logs (merged into *metadata.mfs* once per hour)
*data.stats*::
LizardFS master charts state
== REPORTING BUGS
Report bugs to .
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfsmetarestore(8), mfschunkserver(8), mfsmount(1),
mfsmaster.cfg(5), mfsexports.cfg(5), mfstopology.cfg(5),
moosefs(7)
lizardfs-v.3.9.4/doc/mfsmaster.cfg.5.txt 0000664 0000000 0000000 00000022110 12631772427 0020030 0 ustar 00root root 0000000 0000000 mfsmaster.cfg(5)
================
== NAME
mfsmaster.cfg - main configuration file for mfsmaster
== DESCRIPTION
The file *mfsmaster.cfg* contains configuration of LizardFS metadata server process.
== SYNTAX
Syntax is:
'OPTION' *=* 'VALUE'
Lines starting with *#* character are ignored.
== OPTIONS
Configuration options:
*PERSONALITY*::
Current 'personality' of this instance of metadata server. Valid values are 'master', 'shadow'
and 'ha-cluster-managed'. If installation is managed by an HA cluster the only valid value is
'ha-cluster-managed', otherwise the only valid values are 'master' and 'shadow', in which case
only one metadata server in LizardFS shall have 'master' personality. +
PERSONALITY = 'master' +
means that this instance of metadata server acts as main metadata server
govering all file system metadata modifications. +
PERSONALITY = 'shadow' +
means that this instance of metadata server acts as backup metadata server
ready for immediate deployment as new 'master' in case of current 'master' failure. +
Metadata server personality can be changed at any moment as long as one changes personality from
'shadow' to 'master', changing personality the other way around is forbidden. +
PERSONALITY = 'ha-cluster-managed' +
means that this instance is managed by HA cluster, server runs in 'shadow' mode as long as its not remotly promoted to 'master'.
*DATA_PATH*::
where to store metadata files and lock file
*WORKING_USER*::
user to run daemon as
*WORKING_GROUP*::
group to run daemon as (optional - if empty then default user group will be used)
*SYSLOG_IDENT*::
name of process to place in syslog messages (default is mfsmaster)
*LOCK_MEMORY*::
whether to perform mlockall() to avoid swapping out mfsmaster process (default is 0, i.e. no)
*NICE_LEVEL*::
nice level to run daemon with (default is -19 if possible; note: process must be started as root to
increase priority)
*EXPORTS_FILENAME*::
alternative name of *mfsexports.cfg* file
*TOPOLOGY_FILENAME*::
alternative name of *mfstopology.cfg* file
*CUSTOM_GOALS_FILENAME*::
alternative name of *mfsgoals.cfg* file
*BACK_LOGS*::
number of metadata change log files (default is 50)
*BACK_META_KEEP_PREVIOUS*::
number of previous metadata files to be kept (default is 1)
*AUTO_RECOVERY*::
when this option is set (equals 1) master will try to recover metadata from changelog when it
is being started after a crash; otherwise it will refuse to start and 'mfsmetarestore' should be
used to recover the metadata (default is 0)
*REPLICATIONS_DELAY_INIT*::
initial delay in seconds before starting replications (default is 300)
*REPLICATIONS_DELAY_DISCONNECT*::
replication delay in seconds after chunkserver disconnection (default is 3600)
*MATOML_LISTEN_HOST*::
IP address to listen on for metalogger connections (*** means any)
*MATOML_LISTEN_PORT*::
port to listen on for metalogger connections (default is 9419)
*MATOML_LOG_PRESERVE_SECONDS*::
how many seconds of change logs have to be preserved in memory (default is 600; note: logs are
stored in blocks of 5k lines, so sometimes real number of seconds may be little bigger; zero
disables extra logs storage)
*MATOCS_LISTEN_HOST*::
IP address to listen on for chunkserver connections (*** means any)
*MATOCS_LISTEN_PORT*::
port to listen on for chunkserver connections (default is 9420)
*MATOCL_LISTEN_HOST*::
IP address to listen on for client (mount) connections (*** means any)
*MATOCL_LISTEN_PORT*::
port to listen on for client (mount) connections (default is 9421)
*MATOTS_LISTEN_HOST*::
IP address to listen on for tapeserver connections (*** means any)
*MATOTS_LISTEN_PORT*::
Port to listen on for tapeserver connections (default is 9424)
*CHUNKS_LOOP_MAX_CPS*::
Chunks loop shouldn't check more chunks per seconds than given number (default is 100000)
*CHUNKS_LOOP_MIN_TIME*::
Chunks loop will check all chunks in specified time (default is 300) unless *CHUNKS_LOOP_MAX_CPS*
will force slower execution.
*CHUNKS_LOOP_PERIOD*::
Time in milliseconds between chunks loop execution (default is 1000).
*CHUNKS_LOOP_MAX_CPU*::
Hard limit on CPU usage by chunks loop (percentage value, default is 60).
*CHUNKS_SOFT_DEL_LIMIT*::
Soft maximum number of chunks to delete on one chunkserver (default is 10)
*CHUNKS_HARD_DEL_LIMIT*::
Hard maximum number of chunks to delete on one chunkserver (default is 25)
*CHUNKS_WRITE_REP_LIMIT*::
Maximum number of chunks to replicate to one chunkserver (default is 2)
*CHUNKS_READ_REP_LIMIT*::
Maximum number of chunks to replicate from one chunkserver (default is 10)
*ENDANGERED_CHUNKS_PRIORITY*::
Percentage of endangered chunks that should be replicated with high priority.
Example: when set to 0.2, up to 20% of chunks served in one turn would be extracted
from endangered priority queue.
When set to 1 (max), no other chunks would be processed as long as there are
any endangered chunks in the queue (not advised)
(default is 0, i.e. there is no overhead for prioritizing endangered chunks).
*ENDANGERED_CHUNKS_MAX_CAPACITY*::
Max capacity of endangered chunks queue. This value can limit memory usage of master server
if there are lots of endangered chunks in the system.
This value is ignored if ENDANGERED_CHUNKS_PRIORITY is set to 0.
(default is 1Mi, i.e. no more than 1Mi chunks will be kept in a queue).
*ACCEPTABLE_DIFFERENCE*::
A maximum difference between disk usage on chunkservers that doesn't trigger chunk rebalancing
(default is 0.1, i.e. 10%).
*CHUNKS_REBALANCING_BETWEEN_LABELS*::
When balancing disk usage, allow moving chunks between servers with different labels
(default is 0, i.e. chunks will be moved only between servers with the same label).
*EMPTY_TRASH_PERIOD*::
Interval of removing files from trash in seconds (default is 300)
*EMPTY_RESERVED_INODES_PERIOD*::
Interval of removing reserved files in seconds (default is 60)
*REJECT_OLD_CLIENTS*::
Reject **mfsmount**s older than 1.6.0 (0 or 1, default is 0). Note that *mfsexports* access control
is NOT used for those old clients.
*GLOBALIOLIMITS_FILENAME*::
Configuration of global I/O limits (default is no I/O limiting)
*GLOBALIOLIMITS_RENEGOTIATION_PERIOD_SECONDS*::
How often mountpoints will request bandwidth allocations under constant, predictable load
(default is 0.1)
*GLOBALIOLIMITS_ACCUMULATE_MS*::
After inactivity, no waiting is required to transfer the amount of data equivalent to normal
data flow over the period of that many milliseconds (default is 250)
*METADATA_CHECKSUM_INTERVAL*::
how often metadata checksum shall be sent to backup servers (default is: every 50 metadata updates)
*METADATA_CHECKSUM_RECALCULATION_SPEED*::
how fast should metadata be recalculated in background (default : 100 objects per function call)
*DISABLE_METADATA_CHECKSUM_VERIFICATION*::
should checksum verification be disabled while applying changelog
*NO_ATIME*::
when this option is set to 1 inode access time is not updated on every access, otherwise
(when set to 0) it is updated (default is 0)
*METADATA_SAVE_REQUEST_MIN_PERIOD*::
minimal time in seconds between metadata dumps caused by requests from shadow masters
(default is 1800)
*SESSION_SUSTAIN_TIME*::
Time in seconds for which client session data (e.g. list of open files) should be sustained
in the master server after connection with the client was lost.
Values between 60 and 604800 (one week) are accepted. (default is 86400)
Options below are mandatory for all Shadow instances:
*MASTER_HOST*::
address of the host running LizardFS metadata server that currently acts as 'master'
*MASTER_PORT*::
port number where LizardFS metadata server currently running as 'master' listens for connections
from 'shadow's and metaloggers (default is 9420)
*MASTER_RECONNECTION_DELAY*::
delay in seconds before trying to reconnect to metadata server after disconnection (default is 1)
*MASTER_TIMEOUT*::
timeout (in seconds) for metadata server connections (default is 60)
== NOTES
Chunks in master are tested in loop. Speed (or frequency) is regulated by two options
*CHUNKS_LOOP_MIN_TIME* and *CHUNKS_LOOP_MAX_CPS*. First defines minimal time of the loop and second
maximal number of chunk tests per second. Typically at the beginning, when number of chunks is
small, time is constant, regulated by *CHUNK_LOOP_MIN_TIME*, but when number of chunks became bigger
then time of loop can increase according to *CHUNKS_LOOP_MAX_CPS*.
Deletion limits are defined as 'soft' and 'hard' limit. When number of chunks to delete increases
from loop to loop then current limit can be temporary increased above soft limit, but never above
hard limit.
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfsmaster(8), mfsexports.cfg(5), mfstopology.cfg(5)
lizardfs-v.3.9.4/doc/mfsmetadump.8.txt 0000664 0000000 0000000 00000000416 12631772427 0017623 0 ustar 00root root 0000000 0000000 mfsmetadump(8)
==============
== NAME
mfsmetadump - a networking, distributed, highly available file system
== SYNOPSIS
[verse]
*mfsmetadump* 'metadata_file'...
== DESCRIPTION
*mfsmetadump*
dumps file system metadata into specified file.
== SEE ALSO
mfstools(1)
lizardfs-v.3.9.4/doc/mfsmetalogger.8.txt 0000664 0000000 0000000 00000004757 12631772427 0020151 0 ustar 00root root 0000000 0000000 mfsmetalogger(8)
================
== NAME
mfsmetalogger - start, restart or stop Lizard File System metalogger process
== SYNOPSIS
[verse]
*mfsmetalogger* [*-f*] [*-c* 'CFGFILE'] [*-u*] [*-d*] [*-t* 'LOCKTIMEOUT'] ['ACTION']
[verse]
*mfsmetalogger -s* [*-c* 'CFGFILE']
[verse]
*mfsmetalogger -v*
[verse]
*mfsmetalogger -h*
== DESCRIPTION
*mfsmetalogger* is the metadata replication server of Lizard File System. Depending on parameters it
can start, restart or stop LizardFS metalogger process. Without any options it starts LizardFS
metalogger, killing previously run process if lock file exists.
SIGHUP (or 'reload' 'ACTION') forces *mfsmetalogger* to reload all configuration files.
*-v*::
print version information and exit
*-h*::
print usage information and exit
*-c* 'CFGFILE'::
specify alternative path of configuration file (default is *mfsmetalogger.cfg* in system
configuration directory)
*-u*::
log undefined configuration values (when default is assumed)
*-d*::
run in foreground, don't daemonize
*-t* 'LOCKTIMEOUT'::
how long to wait for lockfile (default is 60 seconds)
'ACTION'
is the one of *start*, *stop*, *restart*, *reload*, *test*, *isalive* or *kill*. Default action is
*restart*.
== FILES
*mfsmetalogger.cfg*::
configuration file for LizardFS metalogger process; refer to *mfsmetalogger.cfg*(5) manual for
defails
*mfsmetalogger.lock*::
PID file of running LizardFS metalogger process
*.mfsmetalogger.lock*::
lock file of running LizardFS metalogger process
(created in data directory)
*changelog_ml.***.mfs*::
LizardFS filesystem metadata change logs (backup of master change log files)
*metadata.ml.mfs.back*::
Latest copy of complete metadata.mfs.back file from LizardFS master.
*sessions.ml.mfs*::
Latest copy of sessions.mfs file from LizardFS master.
== REPORTING BUGS
Report bugs to .
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfsmaster(8), mfsmetalogger.cfg(5), moosefs(7)
lizardfs-v.3.9.4/doc/mfsmetalogger.cfg.5.txt 0000664 0000000 0000000 00000004134 12631772427 0020671 0 ustar 00root root 0000000 0000000 mfsmetalogger.cfg(5)
====================
== NAME
mfsmetalogger.cfg - configuration file for mfsmetalogger
== DESCRIPTION
The file *mfsmetalogger.cfg* contains configuration of LizardFS metalogger process.
== SYNTAX
Syntax is:
'OPTION' *=* 'VALUE'
Lines starting with *#* character are ignored.
== OPTIONS
Configuration options:
*DATA_PATH*::
where to store metadata files
*WORKING_USER*::
user to run daemon as
*WORKING_GROUP*::
group to run daemon as (optional - if empty then default user group will be used)
*SYSLOG_IDENT*::
name of process to place in syslog messages (default is mfsmetalogger)
*LOCK_MEMORY*::
whether to perform mlockall() to avoid swapping out mfsmetalogger process (default is 0, i.e. no)
*NICE_LEVEL*::
nice level to run daemon with (default is -19 if possible; note: process must be started as root to
increase priority)
*BACK_LOGS*::
number of metadata change log files (default is 50)
*BACK_META_KEEP_PREVIOUS*::
number of previous metadata files to be kept (default is 3)
*META_DOWNLOAD_FREQ*::
metadata download frequency in hours (default is 24, at most *BACK_LOGS*/2)
*MASTER_HOST*::
address of LizardFS master host to connect with (default is mfsmaster)
*MASTER_PORT*::
number of LizardFS master port to connect with (default is 9419)
*MASTER_RECONNECTION_DELAY*::
delay in seconds before trying to reconnect to master after disconnection (default is 30)
*MASTER_TIMEOUT*::
timeout (in seconds) for master connections (default is 60)
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfsmetalogger(8)
lizardfs-v.3.9.4/doc/mfsmetarestore.8.txt 0000664 0000000 0000000 00000004655 12631772427 0020352 0 ustar 00root root 0000000 0000000 mfsmetarestore(8)
=================
== NAME
mfsmetarestore - replay LizardFS metadata change logs or dump LizardFS metadata image
== SYNOPSIS
[verse]
*mfsmetarestore* [*-z*] *-m* 'OLDMETADATAFILE' *-o* 'NEWMETADATAFILE' ['CHANGELOGFILE'...]
[verse]
*mfsmetarestore* *-m* 'METADATAFILE'
[verse]
*mfsmetarestore* [*-z*] *-a* [*-d* 'DIRECTORY']
[verse]
*mfsmetarestore* *-g* *-d* 'DIRECTORY'
[verse]
*mfsmetarestore -v*
[verse]
*mfsmetarestore -?*
== DESCRIPTION
When *mfsmetarestore* is called with both *-m* and *-o* options, it replays given 'CHANGELOGFILEs'
on 'OLDMETADATAFILE' and writes result to 'NEWMETADATAFILE'. Multiple change log files can be given.
*mfsmetarestore* with just *-m* 'METADATAFILE' option dumps LizardFS metadata image file in human
readable form.
*mfsmetarestore* called with -a option automatically performs all operations needed to merge change
log files. Master data directory can be specified using -d 'DIRECTORY' option.
*mfsmetarestore* -g with path to metadata files, prints latest metadata version that can be restored from disk.
Prints 0 if metadata files are corrupted.
*-v*::
print version information and exit
*-?*::
print version information and exit
*-a*::
autorestore mode (see above)
*-d* 'DATAPATH'::
master data directory (for autorestore mode)
*-m* 'METADATAFILE'::
specify input metadata image file
*-o* 'NEWMETADATAFILE'::
specify output metadata image file
*-z*::
ignore metadata checksum inconsistency while applying changelogs
== FILES
*metadata.mfs*::
Lizard File System metadata image as read by *mfsmaster* process
*metadata.mfs.back*::
Lizard File System metadata image as left by killed or crashed *mfsmaster* process
*changelog.***.mfs*::
Lizard File System metadata change logs
== REPORTING BUGS
Report bugs to .
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfsmaster(8), moosefs(7)
lizardfs-v.3.9.4/doc/mfsmount.1.txt 0000664 0000000 0000000 00000017122 12631772427 0017144 0 ustar 00root root 0000000 0000000 mfsmount(1)
===========
== NAME
mfsmount - mount Lizard File System
== SYNOPSIS
[verse]
*mfsmount* 'mountpoint' [*-d*] [*-f*] [*-s*] [*-m*] [*-n*] [*-p*]
[*-H* 'HOST'] [*-P* 'PORT'] [*-S* 'PATH'] [*-o* 'opt'[,'opt']...]
[verse]
*mfsmount* *-h*|*--help*
[verse]
*mfsmount* *-V*|*--version*
== DESCRIPTION
Mount Lizard File System.
General options:
*-h*, *--help*::
display help and exit
*-V*::
display version information and exit
FUSE options:
*-d*, *-o debug*::
enable debug mode (implies *-f*)
*-f*::
foreground operation
*-s*::
disable multi-threaded operation
LizardFS options:
*-c* 'CFGFILE', *-o mfscfgfile=*'CFGFILE'::
loads file with additional mount options
*-m*, *--meta*, *-o mfsmeta*::
mount MFSMETA companion filesystem instead of primary LizardFS
*-n*::
omit default mount options (*-o allow_other,default_permissions*)
*-p*::
prompt for password (interactive version of *-o mfspassword=*'PASS')
*-H* 'HOST', *-o mfsmaster=*'HOST'::
connect with LizardFS master on 'HOST' (default is mfsmaster)
*-P* 'PORT', *-o mfsport=*'PORT'::
connect with LizardFS master on 'PORT' (default is 9421)
*-B* 'HOST', *-o mfsbind=*'HOST'::
local address to use for connecting with master instead of default one
*-S* 'PATH', *-o mfssubfolder=*'PATH'::
mount specified LizardFS directory (default is /, i.e. whole filesystem)
*-o enablefilelocks=*[0,1]::
enables/disables global file locking (enabled by default)
*-o mfspassword=*'PASSWORD'::
authenticate to LizardFS master with 'PASSWORD'
*-o mfsmd5pass=*'MD5'::
authenticate to LizardFS master using directly given 'MD5' (only if *mfspassword* option is not
specified)
*-o mfsdelayedinit*::
connection with master is done in background - with this option mount can be run without network
(good for being run from fstab / init scripts etc.)
*-o mfsacl*::
enable ACL support (disabled by default)
*-o mfsaclcacheto=*'SEC'::
set ACL cache timeout in seconds (default: 1.0)
*-o mfsaclcachesize=*'N'::
define ACL cache size in number of entries (0: no cache; default: 1000)
*-o mfsrwlock=*'0|1'::
when set to 1, parallel reads from the same descriptor are performed (default: 1)
*-o mfsmkdircopysgid=*'N'::
sgid bit should be copied during mkdir operation (on linux default: 1, otherwise: 0)
*-o mfssugidclearmode=*'SMODE'::
set sugid clear mode (see below)
*-o mfsdebug*::
print some LizardFS-specific debugging information
*-o mfscachemode=*'CACHEMODE'::
set cache mode (see *DATA CACHE MODES*; default is AUTO)
*-o mfscachefiles*::
(deprecated) preserve file data in cache (equivalent to *-o mfscachemode=*'YES')
*-o mfsattrcacheto=*'SEC'::
set attributes cache timeout in seconds (default: 1.0)
*-o mfsentrycacheto=*'SEC'::
set file entry cache timeout in seconds (default: 0.0, i.e. no cache)
*-o mfsdirentrycacheto=*'SEC'::
set directory entry cache timeout in seconds (default: 1.0)
*-o mfswritecachesize=*'N'::
specify write cache size in MiB (in range: 16..2048 - default: 128)
*-o mfscacheperinodepercentage=*'N'::
specify what part of the write cache non occupied by other inodes can a single inode occupy
(measured in %).
E.g. When N=75 and the inode X uses 10 MiB, and all other inodes use 20 MiB out of 100 MiB cache,
X can use 50 MiB more (since 75% of 80 MiB is 60 MiB).
Default: 25.
*-o mfschunkserverreadto=*'MSEC'::
set timeout for whole communication with a chunkserver during read operation in milliseconds (default: 2000)
*-o mfschunkserverwriteto=*'MSEC'::
set chunkserver response timeout during write operation in milliseconds (default: 5000)
*-o mfschunkserverrtt=*'MSEC'::
set timeout after which SYN packet is considered lost during the first retry of connecting a chunkserver
(default: 200)
*-o mfschunkserverconnectreadto=*'MSEC'::
set timeout for connecting with chunkservers during read operation in milliseconds (default: 2000)
*-o mfschunkserverbasicreadto=*'MSEC'::
set timeout for executing the basic variant of a read operation in milliseconds (default: 2000)
*-o mfschunkservertotalreadto=*'MSEC'::
set timeout for the whole communication with chunkservers during a read operation in milliseconds (default: 2000)
*-o mfsrlimitnofile=*'N'::
try to change limit of simultaneously opened file descriptors on startup
(default: 100000)
*-o mfsnice=*'LEVEL'::
try to change nice level to specified value on startup (default: -19)
*-o mfswriteworkers=*'N'::
define number of write workers (default: 10)
*-o mfswritewindowsize=*'N'::
define write window size (in blocks) for each chunk (default: 15)
*-o mfsmemlock*::
try to lock memory (must be enabled at build time)
*-o mfsdonotrememberpassword*::
do not remember password in memory - more secure, but when session is lost then new session is
created without password
*-o mfsioretries=*'N'::
specify number of retries before I/O error is returned (default: 30)
*-o mfsreportreservedperiod=*'N'::
specify interval of reporting reserved inodes in seconds (default: 60)
*-o mfsiolimits=*'PATH'::
specify local I/O limiting configuration file (default: no I/O limiting)
General mount options (see *mount*(8) manual):
*-o rw*|*-o ro*::
Mount file-system in read-write (default) or read-only mode respectively.
*-o suid*|*-o nosuid*::
Enable or disable suid/sgid attributes to work.
*-o dev*|*-o nodev*::
Enable or disable character or block special device files interpretation.
*-o exec*|*-o noexec*::
Allow or disallow execution of binaries.
*-o symlinkcachetimeout=*'N'::
Set timeout value for symlink cache timeout in seconds. Default value is 3600.
== DATA CACHE MODES
There are three cache modes: *NO*, *YES* and *AUTO*. Default option is *AUTO* and you shuldn't
change it unless you really know what you are doing. In *AUTO* mode data cache is managed
automatically by mfsmaster.
*NO*,*NONE* or *NEVER*::
never allow files data to be kept in cache (safest but can reduce efficiency)
*YES* or *ALWAYS*::
always allow files data to be kept in cache (dangerous)
*AUTO*::
file cache is managed by mfsmaster automatically (should be very safe and efficient)
== SUGID CLEAR MODE
SMODE can be set to:
- *NEVER* - MFS will not change suid and sgid bit on chown
- *ALWAYS* - clear suid and sgid on every chown - safest operation
- *OSX* - standard behavior in OS X and Solaris (chown made by unprivileged user clear suid
and sgid)
- *BSD* - standard behavior in BSD systems (like in OSX, but only when something is really
changed)
- *EXT* - standard behavior in most file systems on Linux (directories not changed,
others: suid cleared always, sgid only when group exec bit is set)
- *XFS* - standard behavior in XFS on Linux (like EXT but directories are changed
by unprivileged users)
SMODE extra info:
btrfs,ext2,ext3,ext4,hfs[+],jfs,ntfs and reiserfs on Linux work as 'EXT'.
Only xfs on Linux works a little different. Beware that there is a strange
operation - chown(-1,-1) which is usually converted by a kernel into something
like 'chmod ug-s', and therefore can't be controlled by MFS as 'chown'
== REPORTING BUGS
Report bugs to .
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfsmaster(8), mfstools(1), moosefs(7), mount(8)
lizardfs-v.3.9.4/doc/mfsrepquota.1.txt 0000664 0000000 0000000 00000005151 12631772427 0017641 0 ustar 00root root 0000000 0000000 mfsrepquota(1)
==============
== NAME
mfsrepquota, mfssetquota - retrieves and sets quotas for specified users and groups
== SYNOPSIS
[verse]
*mfsrepquota* [*-nhH*] (*-u* 'UID' | *-g* 'GID')+ 'MOUNTPOINT-ROOT-PATH'
[verse]
*mfsrepquota* [*-nhH*] -a 'MOUNTPOINT-ROOT-PATH'
[verse]
*mfssetquota* (*-u* 'UID' | *-g* 'GID') 'SOFT-LIMIT-SIZE' 'HARD-LIMIT-SIZE'
'SOFT-LIMIT-INODES' 'HARD-LIMIT-INODES' 'MOUNTPOINT-ROOT-PATH'
== OPTIONS
*-u* 'UID'::
Quota for the user with uid 'UID'.
*-g* 'GID'::
Quota for the group with gid 'GID'.
*-a*::
Quota for all users and groups.
== DESCRIPTION
Quota mechanism can be used to limit inodes usage and space usage for users and groups. Once hard
limit for inodes or space is reached, no new files can be created for specified user (or group) as
long as the quota is not raised or some data is deleted. Also, if hard limit for size is reached,
user cannot extend existing files by adding new chunks to them.
In general quotas can be set only by a superuser, but there is a workaround available - one can set
SESFLAG_ALLCANCHANGEQUOTA in mfsexports.cfg file. A user can only retrieve a quota of his own (and
of his primary group).
*mfsrepquota* prints a summary of the limits that were set and inode/space usage for specified
user/group (or all of them) in the following format:
[verse]
# User/Group ID; Bytes: current usage, soft limit, hard limit; Inodes: current usage, soft limit, hard limit;
'User/Group' 'ID' '(`+`/-)(`+`/-)' 'USED-BYTES' 'SOFT-LIMIT-BYTES' 'HARD-LIMIT-BYTES' 'USED-INODES' 'SOFT-LIMIT-INODES' 'HARD-LIMIT-INODES'
'`+`' indicates that the soft was exceeded or the hard limit was reached. '-' indicates otherwise.
The first '`+`' or '-' corresponds to bytes limit, while the second one to inodes.
*mfssetquota* sets quotas for a user or a group on LizardFS. The quotas are not strict, i.e. it is
possible to exceed hard limits a bit, mostly by appending data to existing files, but only to
certain level (new chunks cannot be created).
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfstools(1)
lizardfs-v.3.9.4/doc/mfsrestoremaster.8.txt 0000664 0000000 0000000 00000001261 12631772427 0020705 0 ustar 00root root 0000000 0000000 mfsrestoremaster(8)
===================
== NAME
mfsrestoremaster - a networking, distributed, highly available file system
== SYNOPSIS
[verse]
*mfsrestoremaster* '' '[]'
** - network interface to reconfigure.
** - mfs configuration directory to use (default: /etc/mfs).
== DESCRIPTION
*mfsmetadump*
This scripts automates starting spare master server on a metalogger machine.
It performs the following steps:
* verify basic sanity of configuration files
* update metadata image with data from metalogger changelogs
* set master's IP address on given network interface
* start the master server
== SEE ALSO
mfstools(1)
lizardfs-v.3.9.4/doc/mfstools.1 0000664 0000000 0000000 00000020274 12631772427 0016326 0 ustar 00root root 0000000 0000000 .TH MFSTOOLS "1" "July 2009" "MooseFS 1.6.0"
.SH NAME
mfstools \- perform MooseFS\-specific operations
.SH SYNOPSIS
.B mfsgetgoal
[\fB-r\fP] [\fB-n\fP|\fB-h\fP|\fB-H\fP] \fIOBJECT\fP...
.PP
.B mfsrgetgoal
[\fB-n\fP|\fB-h\fP|\fB-H\fP] \fIOBJECT\fP...
.PP
.B mfssetgoal
[\fB-r\fP] [\fB-n\fP|\fB-h\fP|\fB-H\fP] \fBName\fP \fIOBJECT\fP...
.PP
.B mfssetquota
[\fB-r\fP] [\fB-n\fP|\fB-h\fP|\fB-H\fP] [\fB+\fP|\fB-\fP]N \fITODO(alek)\fP...
.PP
.B mfsrepquota
[\fB-r\fP] [\fB-n\fP|\fB-h\fP|\fB-H\fP] [\fB+\fP|\fB-\fP]N \fITODO(alek)\fP...
.PP
.B mfsrsetgoal
[\fB-n\fP|\fB-h\fP|\fB-H\fP] [\fB+\fP|\fB-\fP]N \fIOBJECT\fP...
.PP
.B mfsgettrashtime
[\fB-r\fP] [\fB-n\fP|\fB-h\fP|\fB-H\fP] \fIOBJECT\fP...
.PP
.B mfsrgettrashtime
[\fB-n\fP|\fB-h\fP|\fB-H\fP] \fIOBJECT\fP...
.PP
.B mfssettrashtime
[\fB-r\fP] [\fB-n\fP|\fB-h\fP|\fB-H\fP] [\fB+\fP|\fB-\fP]SECONDS \fIOBJECT\fP...
.PP
.B mfsrsettrashtime
[\fB-n\fP|\fB-h\fP|\fB-H\fP] [\fB+\fP|\fB-\fP]SECONDS \fIOBJECT\fP...
.PP
.B mfsgeteattr
[\fB-r\fP] [\fB-n\fP|\fB-h\fP|\fB-H\fP] \fIOBJECT\fP...
.PP
.B mfsseteattr
[\fB-r\fP] [\fB-n\fP|\fB-h\fP|\fB-H\fP] \fB-f\fP \fIATTRNAME\fP [\fB-f\fP \fIATTRNAME\fP ...] \fIOBJECT\fP...
.PP
.B mfsdeleattr
[\fB-r\fP] [\fB-n\fP|\fB-h\fP|\fB-H\fP] \fB-f\fP \fIATTRNAME\fP [\fB-f\fP \fIATTRNAME\fP ...] \fIOBJECT\fP...
.PP
.B mfscheckfile
\fIFILE\fP...
.PP
.B mfsfileinfo
\fIFILE\fP...
.PP
.B mfsdirinfo
[\fB-n\fP|\fB-h\fP|\fB-H\fP] \fIOBJECT\fP...
.PP
.B mfsfilerepair
[\fB-n\fP|\fB-h\fP|\fB-H\fP] \fIFILE\fP...
.PP
.B mfsappendchunks
\fISNAPSHOT_FILE\fP \fIOBJECT\fP...
.PP
.B mfsmakesnapshot
[\fB-o\fP] \fISOURCE\fP... \fIDESTINATION\fP
.PP
.SH DESCRIPTION
\fBmfsgetgoal\fP and \fBmfssetgoal\fP operate on object's \fIgoal\fP value.
\fBmfsgetgoal\fP prints current \fIgoal\fP value of given object(s).
\fB-r\fP option enables recursive mode, which works as usual for every
given file, but for every given directory additionally prints current
\fIgoal\fP value of all contained objects (files and directories).
\fBmfssetgoal\fP changes current \fIgoal\fP value of given object(s).
\fB-r\fP option enables recursive mode.
These tools can be used on any file, directory or deleted (\fItrash\fP) file.
.PP
\fBmfsrgetgoal\fP and \fBmfsrsetgoal\fP are deprecated aliases for
\fBmfsgetgoal -r\fP and \fBmfssetgoal -r\fP respectively.
.PP
\fBmfsgettrashtime\fP and \fBmfssettrashtime\fP operate on object's
\fItrashtime\fP value, i.e. the number of seconds the file is preserved in
special \fItrash\fP directory before it's finally removed from filesystem.
\fITrashtime\fP must be non\-negative integer value.
\fBmfsgettrashtime\fP prints current \fItrashtime\fP value of given object(s).
\fB-r\fP option enables recursive mode, which works as usual for every given
file, but for every given directory additionally prints current \fItrashtime\fP
value of all contained objects (files and directories).
\fBmfssettrashtime\fP changes current \fItrashtime\fP value of given object(s).
If new value is specified in \fB+\fP\fIN\fP form, \fItrashtime\fP value is
increased to \fIN\fP for objects with lower \fItrashtime\fP value and unchanged
for the rest. Similarly, if new value is specified as \fB\-\fP\fIN\fP,
\fItrashtime\fP value is decreased to \fIN\fP for objects with higher
\fItrashtime\fP value and unchanged for the rest. \fB-r\fP option enables
recursive mode.
These tools can be used on any file, directory or deleted (\fItrash\fP) file.
.PP
\fBmfsrgettrashtime\fP and \fBmfsrsettrashtime\fP are deprecated aliases for
\fBmfsgettrashtime -r\fP and \fBmfssettrashtime -r\fP respectively.
.PP
\fBmfsgeteattr\fP, \fBmfsseteattr\fP and \fBmfsdeleattr\fP
tools are used to get, set or delete some extra attributes. Attributes are
described below.
.PP
\fBmfscheckfile\fP checks and prints number of chunks and number of chunk
copies belonging to specified file(s).
It can be used on any file, included deleted (\fItrash\fP).
.PP
\fBmfsfileinfo\fP prints location (\fIchunkserver\fP host and port) of each
chunk copy belonging to specified file(s).
It can be used on any file, included deleted (\fItrash\fP).
.PP
\fBmfsdirinfo\fP is extended, MooseFS-specific equivalent of \fBdu -s\fP
command. It prints summary for each specified object (single file or
directory tree).
.PP
\fBmfsfilerepair\fP deals with broken files (those which cause I/O errors on
read operations) to make them partially readable. In case of missing chunk
it fills missing parts of file with zeros; in case of chunk version mismatch
it sets chunk version known to \fBmfsmaster\fP to highest one found on
chunkservers. Note: because in the second case content mismatch can occur in
chunks with the same version, it's advised to make a copy (not a snapshot!)
and delete original file after "repairing".
.PP
\fBmfsappendchunks\fP (equivalent of \fBmfssnapshot\fP from MooseFS 1.5)
appends a lazy copy of specified file(s) to specified snapshot file ("lazy"
means that creation of new chunks is delayed to the moment one copy is
modified).
If multiple files are given, they are merged into one target file in the way
that each file begins at \fIchunk\fP (64MB) boundary; padding space is left
empty.
.PP
\fBmfsmakesnapshots\fP makes a "real" snapshot (lazy copy, like in case of
\fBmfsappendchunks\fP) of some object(s) or subtree (similarly to \fBcp -r\fP
command). It's atomic with respect to each \fISOURCE\fP argument separately.
If \fIDESTINATION\fP points to already existing file, error will be reported
unless \fB-o\fP (overwrite) option is given. Note: if \fISOURCE\fP is
a directory, it's copied as a whole; but if it's followed by trailing slash,
only directory content is copied.
.SH GENERAL OPTIONS
Most of \fBmfstools\fP use \fB-n\fP, \fB-h\fP and \fB-H\fP options to select
format of printed numbers. \fB-n\fP causes to print exact numbers, \fB-h\fP
uses binary prefixes (Ki, Mi, Gi as 2^10, 2^20 etc.) while \fB-H\fP uses SI
prefixes (k, M, G as 10^3, 10^6 etc.).
The same can be achieved by setting
\fBMFSHRFORMAT\fP environment variable to: \fB0\fP (exact numbers), \fB1\fP
or \fBh\fP (binary prefixes), \fB2\fP or \fBH\fP (SI prefixes), \fB3\fP or
\fBh+\fP (exact numbers and binary prefixes), \fB4\fP or \fBH+\fP (exact
numbers and SI prefixes). The default is to print just exact numbers.
.SH EXTRA ATTRIBUTES
\fBnoowner\fP This flag means,
that particular object belongs to current user (\fIuid\fP and \fIgid\fP are equal
to \fIuid\fP and \fIgid\fP values of accessing process). Only root (\fIuid\fP=0)
sees the real \fIuid\fP and \fIgid\fP.
.PP
\fBnoattrcache\fP This flag means, that standard file attributes such as uid, gid,
mode, length and so on won't be stored in kernel cache. In MooseFS 1.5 this was the
only behaviour, and mfsmount always prevented attributes from being stored in
kernel cache, but in MooseFS 1.6 attributes can be cached, so in very rare ocassions
it could be useful to turn it off.
.PP
\fBnoentrycache\fP This flag is similar to above. It prevents directory entries
from being cached in kernel.
.SH INHERITANCE
When new object is created in MooseFS, attributes such as goal, trashtime and extra
attributes are inherited from parent directory. So if you set i.e. "noowner"
attribute and goal to 3 in a directory then every new object created in
this directory will have goal set to 3 and "noowner" flag set. A newly created
object inherits always the current set of its parent's attributes. Changing a
directory attribute does not affect its already created children. To change
an attribute for a directory and all of its children use "-r" option.
.SH NOTES
\fBmfstools\fP require MooseFS (\fBmfsmaster\fP and \fBmfsmount\fP) >= 1.6.0 to
work on read-only filesystem.
.SH "REPORTING BUGS"
Report bugs to .
.SH COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013 Skytechnology sp. z o.o..
LizardFS is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with LizardFS If not, see .
.SH "SEE ALSO"
.BR mfsmount (8),
.BR moosefs (7)
lizardfs-v.3.9.4/doc/mfstools.1.txt 0000664 0000000 0000000 00000007217 12631772427 0017146 0 ustar 00root root 0000000 0000000 mfstools(1)
===========
== NAME
mfstools - perform LizardFS-specific operations
== SYNOPSIS
[verse]
*mfsgetgoal* [*-r*] [*-n*|*-h*|*-H*] 'OBJECT'...
[verse]
*mfsrgetgoal* [*-n*|*-h*|*-H*] 'OBJECT'...
[verse]
*mfssetgoal* [*-r*] [*-n*|*-h*|*-H*] 'NAME' 'OBJECT'...
[verse]
*mfsrsetgoal* [*-n*|*-h*|*-H*] [*+*|*-*]N 'OBJECT'...
[verse]
*mfssetquota* (*-u* 'UID' | *-g* 'GID') 'SOFT-LIMIT-SIZE' 'HARD-LIMIT-SIZE'
'SOFT-LIMIT-INODES' 'HARD-LIMIT-INODES' 'MOUNTPOINT-ROOT-PATH'
[verse]
*mfsrepquota* [*-nhH*] (*-u* 'UID' | *-g* 'GID')+ 'MOUNTPOINT-ROOT-PATH'
*mfsrepquota* [*-nhH*] -a 'MOUNTPOINT-ROOT-PATH'
[verse]
*mfsgettrashtime* [*-r*] [*-n*|*-h*|*-H*] 'OBJECT'...
[verse]
*mfsrgettrashtime* [*-n*|*-h*|*-H*] 'OBJECT'...
[verse]
*mfssettrashtime* [*-r*] [*-n*|*-h*|*-H*] [*+*|*-*]SECONDS 'OBJECT'...
[verse]
*mfsrsettrashtime* [*-n*|*-h*|*-H*] [*+*|*-*]SECONDS 'OBJECT'...
[verse]
*mfsgeteattr* [*-r*] [*-n*|*-h*|*-H*] 'OBJECT'...
[verse]
*mfsseteattr* [*-r*] [*-n*|*-h*|*-H*] *-f* 'ATTRNAME' [*-f* 'ATTRNAME' ...] 'OBJECT'...
[verse]
*mfsdeleattr* [*-r*] [*-n*|*-h*|*-H*] *-f* 'ATTRNAME' [*-f* 'ATTRNAME' ...] 'OBJECT'...
[verse]
*mfscheckfile* 'FILE'...
[verse]
*mfsfileinfo* 'FILE'...
[verse]
*mfsdirinfo* [*-n*|*-h*|*-H*] 'OBJECT'...
[verse]
*mfsfilerepair* [*-n*|*-h*|*-H*] 'FILE'...
[verse]
*mfsappendchunks* 'SNAPSHOT_FILE' 'OBJECT'...
[verse]
*mfsmakesnapshot* [*-o*] 'SOURCE'... 'DESTINATION'
== DESCRIPTION
See respective documents.
== GENERAL OPTIONS
Most of *mfstools* use following options to select format of printed numbers:
*-n*::
Print exact numbers (e.g. 1024).
*-h*::
Print numbers with binary prefixes (Ki, Mi, Gi as `2^10`, `2^20` etc.).
*-H*::
Print numbers with SI prefixes (k, M, G as `10^3`, `10^6` etc.).
The same can be achieved by setting *MFSHRFORMAT* environment variable to: *0* (exact numbers),
*1* or *h* (binary prefixes), *2* or *H* (SI prefixes), *3* or *h+* (exact numbers and binary
prefixes), *4* or *H+* (exact numbers and SI prefixes). The default is to print just exact numbers.
Other options:
*-r*::
This option enables recursive mode.
== INHERITANCE
When new object is created in LizardFS, attributes such as goal, trashtime and extra attributes are
inherited from parent directory. So if you set i.e. "noowner" attribute and goal to 3 in a directory
then every new object created in this directory will have goal set to 3 and "noowner" flag set. A
newly created object inherits always the current set of its parent's attributes. Changing a
directory attribute does not affect its already created children. To change an attribute for a
directory and all of its children use `'-r'` option.
== REPORTING BUGS
Report bugs to .
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfsmount(1), mfsappendchunks(1), mfscheckfile(1), mfsdeleattr(1), mfsdirinfo(1), mfsfileinfo(1),
mfsfilerepair(1), mfsgeteattr(1), mfsgetgoal(1), mfsgettrashtime(1), mfsmakesnapshot(1),
mfsrgetgoal(1), mfsrgettrashtime(1), mfsrsetgoal(1), mfsrsettrashtime(1), mfsseteattr(1),
mfssetgoal(1), mfssettrashtime(1), mfsrepquota(1), mfssetquota(1), moosefs(7)
lizardfs-v.3.9.4/doc/mfstopology.cfg.5.txt 0000664 0000000 0000000 00000003736 12631772427 0020426 0 ustar 00root root 0000000 0000000 mfstopology.cfg(5)
==================
== NAME
mfstopology.cfg - LizardFS network topology definitions
== DESCRIPTION
The file *mfstopology.cfg* contains assignments of IP addresses into network locations (usually
switch numbers). This file is optional. If your network has one switch or decreasing traffic between
switches is not necessary then leave this file empty.
== SYNTAX
Syntax is:
'ADDRESS' 'SWITCH-NUMBER'
Lines starting with *#* character are ignored.
'ADDRESS' can be specified in several forms:
- *** all addresses
- *n.n.n.n* single IP address
- *n.n.n.n/b* IP class specified by network address and bits number
- *n.n.n.n/m.m.m.m* IP class specified by network address and mask
- *f.f.f.f-t.t.t.t* IP range specified by from-to addresses (inclusive)
'SWITCH-NUMBER' can be specified as any positive 32-bit numer.
== NOTES
If one IP belongs to more than one definition then last definition is used.
As for now distance between switches is constant. So distance between machines is calculated as: *0*
when IP numbers are the same, *1* when IP numbers are different, but switch numbers are the same and
*2* when switch numbers are different
Distances are used only to sort chunkservers during read and write operations. New chunks are still
created randomly. Also rebalance routines do not take distances into account.
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfsmaster(8), mfsmaster.cfg(5)
lizardfs-v.3.9.4/doc/moosefs.7.txt 0000664 0000000 0000000 00000007521 12631772427 0016757 0 ustar 00root root 0000000 0000000 lizardfs(7)
==========
== NAME
lizardfs, moosefs, mfs - a networking, distributed, highly available file system
== DESCRIPTION
LizardFS is a networking, highly available, distributed
file system. It spreads data over several physical
localisations (servers), which are visible to a user as one resource. For standard file operations
LizardFS acts as other Unix-alike file systems. It has hierarchical structure (directory tree),
stores files' attributes (permissions, last access and modification times) as well as makes it
possible to create special files (block and character devices, pipes and sockets), symbolic links
(file names pointing to another files accessible locally, not necessarily on LizardFS) and hard links
(different names of files which refer to the same data on LizardFS). Access to the file system can be
limited basing on IP address and/or password.
Distinctive features of LizardFS are:
- higher reliability (data can be stored in several copies on separate computers)
- dynamically expanding disk space by attaching new computers/disks
- possibility of storing deleted files for a defined period of time ("trash bin" service on a file
system level)
- possibility of creating snapshot of a file, which means coherent copy of them whole file, even
while the file is being written.
== ARCHITECTURE
LizardFS installation consists of five types of machines:
- master metadata server (or `the master') a managing server - single computer managing the whole
filesystem, storing metadata for every file (information on size, attributes and file
localisation(s), including all information about non-regular files, i.e. directories,
sockets, pipes and devices.
- metadata server shadows (or `the shadow') - almost identical to the master,
there can be any number of those, they work as master metadata server backup and they are ready
for immediate deployment as new master in case of current master failure.
- data servers (any number of commodity servers storing files data and replicating it among
themselves (if a certain file is supposed to exist in more than one copy).
- metadata backup servers - any number of servers, all of which store metadata changelogs and
periodically downloading base metadata file; it's easy to run mfsmaster process on such machine when
primary master stops working.
- client computers referring to LizardFS stored files - any number of machines with working mfsmount
process that communicates with the managing server to receive and modify file information and with
chunkservers to exchange actual file data.
Metadata is stored in memory of the managing server and simultaneously is being saved on disk (as a
periodically updated binary file and immediately updated incremental logs). The main binary file as
well as the logs are replicated to metaloggers (if present).
File data is divided to fragments (chunks) of maximum size 64MB each which are stored as files on
selected disks on data servers (chunkservers). Each chunk is saved on different computers in a
number of copies equal to a "goal" for the given file.
== REPORTING BUGS
Report bugs to .
== COPYRIGHT
Copyright 2008-2009 Gemius SA, 2013-2015 Skytechnology sp. z o.o.
LizardFS is free software: you can redistribute it and/or modify it under the terms of the GNU
General Public License as published by the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
Public License for more details.
You should have received a copy of the GNU General Public License along with LizardFS. If not, see
.
== SEE ALSO
mfschunkserver(8), mfsmaster(8), mfsmetalogger(8), mfsmount(1), mfstools(1), lizardfs-admin(8)
lizardfs-v.3.9.4/external/ 0000775 0000000 0000000 00000000000 12631772427 0015446 5 ustar 00root root 0000000 0000000 lizardfs-v.3.9.4/external/CMakeLists.txt 0000664 0000000 0000000 00000000625 12631772427 0020211 0 ustar 00root root 0000000 0000000 # crcutil
if(NOT CRCUTIL_FOUND)
if(HAVE_CRCUTIL)
include_directories(${CRCUTIL_INCLUDE_DIRS})
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CRCUTIL_CXX_FLAGS}")
file(GLOB CRCUTIL_SOURCES ${CRCUTIL_SOURCE_DIR}/*.cc)
add_library(crcutil ${CRCUTIL_SOURCES})
endif()
endif()
# GoogleTest
if(BUILD_TESTS)
include_directories(${GTEST_INCLUDE_DIRS})
add_subdirectory(${GTEST_NAME})
endif()
lizardfs-v.3.9.4/mingw32-toolchain.cmake 0000664 0000000 0000000 00000000752 12631772427 0020076 0 ustar 00root root 0000000 0000000 set(CMAKE_SYSTEM_NAME Windows)
set(CMAKE_SYSTEM_VERSION 8)
set(CMAKE_C_COMPILER i686-w64-mingw32-gcc)
set(CMAKE_CXX_COMPILER i686-w64-mingw32-g++)
set(CMAKE_RC_COMPILER i686-w64-mingw32-windres)
set(CMAKE_FIND_ROOT_PATH /usr/i686-w64-mingw32/ /usr/local/i686-w64-mingw32/)
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS)
set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS)
lizardfs-v.3.9.4/mingw32-w64-toolchain.cmake 0000664 0000000 0000000 00000000764 12631772427 0020517 0 ustar 00root root 0000000 0000000 set(CMAKE_SYSTEM_NAME Windows)
set(CMAKE_SYSTEM_VERSION 8)
set(CMAKE_C_COMPILER x86_64-w64-mingw32-gcc)
set(CMAKE_CXX_COMPILER x86_64-w64-mingw32-g++)
set(CMAKE_RC_COMPILER x86_64-w64-mingw32-windres)
set(CMAKE_FIND_ROOT_PATH /usr/x86_64-w64-mingw32/ /usr/local/x86_64-w64-mingw32/)
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
set(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS)
set(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS)
lizardfs-v.3.9.4/rpm/ 0000775 0000000 0000000 00000000000 12631772427 0014422 5 ustar 00root root 0000000 0000000 lizardfs-v.3.9.4/rpm/init-scripts/ 0000775 0000000 0000000 00000000000 12631772427 0017052 5 ustar 00root root 0000000 0000000 lizardfs-v.3.9.4/rpm/init-scripts/lizardfs-cgiserv.init 0000664 0000000 0000000 00000003054 12631772427 0023217 0 ustar 00root root 0000000 0000000 #!/bin/sh
#
### BEGIN INIT INFO
# Provides: lizardfs-cgiserv
# Required-Start: $local_fs $network $syslog
# Required-Stop: $local_fs $syslog
# Should-Start: $syslog
# Should-Stop: $network $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Start up the lizardfs-cgiserv server daemon
# Description: LizardFS is a distributed, scalable, fault-tolerant and highly available file system.
# This service starts up the LizardFS cgiserv server daemon.
### END INIT INFO
# Source function library.
. @initddir@/functions
# Source networking configuration.
. /etc/sysconfig/network
LZFS_USER=nobody
PID_FILE=/var/run/lizardfs-cgiserv.pid
# Check that networking is up.
[ "${NETWORKING}" == "no" ] && exit 0
[ -x "/usr/sbin/lizardfs-cgiserver" ] || exit 1
RETVAL=0
prog="lizardfs-cgiserver"
start () {
echo -n $"Starting $prog: "
daemon --pidfile $PID_FILE $prog -p $PID_FILE -u $LZFS_USER
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && touch /var/lock/subsys/$prog
return $RETVAL
}
stop () {
echo -n $"Stopping $prog: "
killproc -p $PID_FILE $prog
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/$prog
return $RETVAL
}
restart () {
stop
start
}
case "$1" in
start)
start
;;
stop)
stop
;;
restart|reload)
restart
;;
condrestart)
[ -e /var/lock/subsys/$prog ] && restart
RETVAL=$?
;;
status)
status $prog
RETVAL=$?
;;
*)
echo $"Usage: $0 {start|stop|restart|condrestart|status}"
RETVAL=1
esac
exit $RETVAL
lizardfs-v.3.9.4/rpm/init-scripts/lizardfs-chunkserver.init 0000664 0000000 0000000 00000003252 12631772427 0024114 0 ustar 00root root 0000000 0000000 #!/bin/sh
#
### BEGIN INIT INFO
# Provides: lizardfs-chunkserver
# Required-Start: $local_fs $network $syslog
# Required-Stop: $local_fs $syslog
# Should-Start: $syslog
# Should-Stop: $network $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Start up the lizardfs-chunkserver server daemon
# Description: LizardFS is a distributed, scalable, fault-tolerant and highly available file system.
# This service starts up the LizardFS chunkserver server daemon.
### END INIT INFO
# Source function library.
. @initddir@/functions
# Source networking configuration.
. /etc/sysconfig/network
# Source initialization configuration.
[ -r "/etc/sysconfig/mfschunkserver" ] && . /etc/sysconfig/mfschunkserver
# Check that networking is up.
[ "${NETWORKING}" == "no" ] && exit 0
[ -x "@sbindir@/mfschunkserver" ] || exit 1
[ -r "@sysconfdir@/mfs/mfshdd.cfg" -o -r "@sysconfdir@/mfshdd.cfg" ] || exit 1
RETVAL=0
prog="mfschunkserver"
start () {
echo -n $"Starting $prog: "
daemon $prog
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && touch /var/lock/subsys/$prog
return $RETVAL
}
stop () {
echo -n $"Stopping $prog: "
$prog stop >/dev/null 2>&1 || killproc $prog >/dev/null 2>&1
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/$prog
return $RETVAL
}
restart () {
stop
start
}
case "$1" in
start)
start
;;
stop)
stop
;;
restart|reload)
restart
;;
condrestart)
[ -e /var/lock/subsys/$prog ] && restart
RETVAL=$?
;;
status)
status $prog
RETVAL=$?
;;
*)
echo $"Usage: $0 {start|stop|restart|condrestart|status}"
RETVAL=1
esac
exit $RETVAL
lizardfs-v.3.9.4/rpm/init-scripts/lizardfs-master.init 0000664 0000000 0000000 00000003217 12631772427 0023051 0 ustar 00root root 0000000 0000000 #!/bin/sh
#
### BEGIN INIT INFO
# Provides: lizardfs-master
# Required-Start: $local_fs $network $syslog
# Required-Stop: $local_fs $syslog
# Should-Start: $syslog
# Should-Stop: $network $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Start up the lizardfs-master server daemon
# Description: LizardFS is a distributed, scalable, fault-tolerant and highly available file system.
# This service starts up the LizardFS master server daemon.
### END INIT INFO
# Source function library.
. @initddir@/functions
# Source networking configuration.
. /etc/sysconfig/network
# Source initialization configuration.
[ -r "/etc/sysconfig/mfsmaster" ] && . /etc/sysconfig/mfsmaster
# Check that networking is up.
[ "${NETWORKING}" == "no" ] && exit 0
[ -x "@sbindir@/mfsmaster" ] || exit 1
RETVAL=0
prog="mfsmaster"
start () {
echo -n $"Starting $prog: "
daemon $prog
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && touch /var/lock/subsys/$prog
return $RETVAL
}
stop () {
echo -n $"Stopping $prog: "
$prog stop || killproc $prog
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/$prog
return $RETVAL
}
restart () {
stop
start
}
reload () {
echo -n $"Reloading $prog: "
$prog reload
RETVAL=$?
return $RETVAL
}
case "$1" in
start)
start
;;
stop)
stop
;;
restart)
restart
;;
reload)
reload
;;
condrestart)
[ -e /var/lock/subsys/$prog ] && restart
RETVAL=$?
;;
status)
status $prog
RETVAL=$?
;;
*)
echo $"Usage: $0 {start|stop|restart|condrestart|status}"
RETVAL=1
esac
exit $RETVAL
lizardfs-v.3.9.4/rpm/init-scripts/lizardfs-metalogger.init 0000664 0000000 0000000 00000003064 12631772427 0023704 0 ustar 00root root 0000000 0000000 #!/bin/sh
#
### BEGIN INIT INFO
# Provides: lizardfs-metalogger
# Required-Start: $local_fs $network $syslog
# Required-Stop: $local_fs $syslog
# Should-Start: $syslog
# Should-Stop: $network $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Start up the lizardfs-metalogger server daemon
# Description: LizardFS is a distributed, scalable, fault-tolerant and highly available file system.
# This service starts up the LizardFS metalogger server daemon.
### END INIT INFO
# Source function library.
. @initddir@/functions
# Source networking configuration.
. /etc/sysconfig/network
# Source initialization configuration.
[ -r "/etc/sysconfig/mfsmetalogger" ] && . /etc/sysconfig/mfsmetalogger
# Check that networking is up.
[ "${NETWORKING}" == "no" ] && exit 0
[ -x "@sbindir@/mfsmetalogger" ] || exit 1
RETVAL=0
prog="mfsmetalogger"
start () {
echo -n $"Starting $prog: "
daemon $prog
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && touch /var/lock/subsys/$prog
return $RETVAL
}
stop () {
echo -n $"Stopping $prog: "
$prog stop || killproc $prog
RETVAL=$?
echo
[ $RETVAL -eq 0 ] && rm -f /var/lock/subsys/$prog
return $RETVAL
}
restart () {
stop
start
}
case "$1" in
start)
start
;;
stop)
stop
;;
restart|reload)
restart
;;
condrestart)
[ -e /var/lock/subsys/$prog ] && restart
RETVAL=$?
;;
status)
status $prog
RETVAL=$?
;;
*)
echo $"Usage: $0 {start|stop|restart|condrestart|status}"
RETVAL=1
esac
exit $RETVAL
lizardfs-v.3.9.4/rpm/lizardfs.spec 0000664 0000000 0000000 00000043701 12631772427 0017121 0 ustar 00root root 0000000 0000000 %define distro @DISTRO@
Summary: LizardFS - distributed, fault tolerant file system
Name: lizardfs
Version: 3.9.4
Release: 0%{?distro}
License: GPL v3
Group: System Environment/Daemons
URL: http://www.lizardfs.org/
Source: lizardfs-%{version}.tar.gz
BuildRequires: fuse-devel
BuildRequires: cmake
BuildRequires: pkgconfig
BuildRequires: zlib-devel
BuildRequires: asciidoc
%if "%{distro}" == "el7"
BuildRequires: systemd
%endif
BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
%define liz_project mfs
%define liz_group %{liz_project}
%define liz_user %{liz_project}
%define liz_datadir %{_localstatedir}/lib/%{liz_project}
%define liz_confdir %{_sysconfdir}/%{liz_project}
%define liz_limits_conf /etc/security/limits.d/10-lizardfs.conf
%define liz_pam_d /etc/pam.d/lizardfs
%description
LizardFS is an Open Source, easy to deploy and maintain, distributed,
fault tolerant file system for POSIX compliant OSes.
LizardFS is a fork of MooseFS. For more information please visit
http://lizardfs.com
# Packages
############################################################
%package master
Summary: LizardFS master server
Group: System Environment/Daemons
%if "%{distro}" == "el7"
Requires(post): systemd-units
Requires(preun): systemd-units
Requires(postun): systemd-units
%endif
%description master
LizardFS master (metadata) server together with metarestore utility.
%package metalogger
Summary: LizardFS metalogger server
Group: System Environment/Daemons
%if "%{distro}" == "el7"
Requires(post): systemd-units
Requires(preun): systemd-units
Requires(postun): systemd-units
%endif
%description metalogger
LizardFS metalogger (metadata replication) server.
%package chunkserver
Summary: LizardFS data server
Group: System Environment/Daemons
%if "%{distro}" == "el7"
Requires(post): systemd-units
Requires(preun): systemd-units
Requires(postun): systemd-units
%endif
%description chunkserver
LizardFS data server.
%package client
Summary: LizardFS client
Group: System Environment/Daemons
Requires: fuse
Requires: fuse-libs
%description client
LizardFS client: mfsmount and mfstools.
%package cgi
Summary: LizardFS CGI Monitor
Group: System Environment/Daemons
Requires: python
%description cgi
LizardFS CGI Monitor.
%package cgiserv
Summary: Simple CGI-capable HTTP server to run LizardFS CGI Monitor
Group: System Environment/Daemons
Requires: %{name}-cgi = %{version}-%{release}
%if "%{distro}" == "el7"
Requires(post): systemd-units
Requires(preun): systemd-units
Requires(postun): systemd-units
%endif
%description cgiserv
Simple CGI-capable HTTP server to run LizardFS CGI Monitor.
%package adm
Summary: LizardFS administration utility
Group: System Environment/Daemons
%description adm
LizardFS command line administration utility.
# Scriptlets - master
############################################################
%pre master
if ! getent group %{liz_group} > /dev/null 2>&1 ; then
groupadd --system %{liz_group}
fi
if ! getent passwd %{liz_user} > /dev/null 2>&1 ; then
adduser --system -g %{liz_group} --no-create-home --home-dir %{liz_datadir} %{liz_user}
fi
if [ ! -f %{liz_limits_conf} ]; then
echo "%{liz_user} soft nofile 10000" > %{liz_limits_conf}
echo "%{liz_user} hard nofile 10000" >> %{liz_limits_conf}
chmod 0644 %{liz_limits_conf}
fi
if [ ! -f %{liz_pam_d} ]; then
echo "session required pam_limits.so" > %{liz_pam_d}
fi
exit 0
%post master
%if "%{distro}" == "el6"
/sbin/chkconfig --add lizardfs-master
%endif
%if "%{distro}" == "el7"
%systemd_post lizardfs-master.service
%endif
%preun master
%if "%{distro}" == "el6"
if [ "$1" = 0 ] ; then
/sbin/service lizardfs-master stop > /dev/null 2>&1 || :
/sbin/chkconfig --del lizardfs-master
fi
%endif
%if "%{distro}" == "el7"
%systemd_preun lizardfs-master.service
%endif
%postun master
%if "%{distro}" == "el6"
/sbin/service lizardfs-master condrestart > /dev/null 2>&1 || :
%endif
%if "%{distro}" == "el7"
%systemd_postun_with_restart lizardfs-master.service
%endif
# Scriptlets - metalogger
############################################################
%pre metalogger
if ! getent group %{liz_group} > /dev/null 2>&1 ; then
groupadd --system %{liz_group}
fi
if ! getent passwd %{liz_user} > /dev/null 2>&1 ; then
adduser --system -g %{liz_group} --no-create-home --home-dir %{liz_datadir} %{liz_user}
fi
exit 0
%post metalogger
%if "%{distro}" == "el6"
/sbin/chkconfig --add lizardfs-metalogger
%endif
%if "%{distro}" == "el7"
%systemd_post lizardfs-metalogger.service
%endif
%preun metalogger
%if "%{distro}" == "el6"
if [ "$1" = 0 ] ; then
/sbin/service lizardfs-metalogger stop > /dev/null 2>&1 || :
/sbin/chkconfig --del lizardfs-metalogger
fi
%endif
%if "%{distro}" == "el7"
%systemd_preun lizardfs-metalogger.service
%endif
%postun metalogger
%if "%{distro}" == "el6"
/sbin/service lizardfs-metalogger condrestart > /dev/null 2>&1 || :
%endif
%if "%{distro}" == "el7"
%systemd_postun_with_restart lizardfs-metalogger.service
%endif
# Scriptlets - chunkserver
############################################################
%pre chunkserver
if ! getent group %{liz_group} > /dev/null 2>&1 ; then
groupadd --system %{liz_group}
fi
if ! getent passwd %{liz_user} > /dev/null 2>&1 ; then
adduser --system -g %{liz_group} --no-create-home --home-dir %{liz_datadir} %{liz_user}
fi
if [ ! -f %{liz_limits_conf} ]; then
echo "%{liz_user} soft nofile 10000" > %{liz_limits_conf}
echo "%{liz_user} hard nofile 10000" >> %{liz_limits_conf}
chmod 0644 %{liz_limits_conf}
fi
exit 0
%post chunkserver
%if "%{distro}" == "el6"
/sbin/chkconfig --add lizardfs-chunkserver
%endif
%if "%{distro}" == "el7"
%systemd_post lizardfs-chunkserver.service
%endif
%preun chunkserver
%if "%{distro}" == "el6"
if [ "$1" = 0 ] ; then
/sbin/service lizardfs-chunkserver stop > /dev/null 2>&1 || :
/sbin/chkconfig --del lizardfs-chunkserver
fi
%endif
%if "%{distro}" == "el7"
%systemd_preun lizardfs-chunkserver.service
%endif
%postun chunkserver
%if "%{distro}" == "el6"
/sbin/service lizardfs-chunkserver condrestart > /dev/null 2>&1 || :
%endif
%if "%{distro}" == "el7"
%systemd_postun_with_restart lizardfs-chunkserver.service
%endif
# Scriptlets - CGI server
############################################################
%post cgiserv
%if "%{distro}" == "el6"
/sbin/chkconfig --add lizardfs-cgiserv
%endif
%if "%{distro}" == "el7"
%systemd_post lizardfs-cgiserv.service
%endif
%preun cgiserv
%if "%{distro}" == "el6"
if [ "$1" = 0 ] ; then
/sbin/service lizardfs-cgiserv stop > /dev/null 2>&1 || :
/sbin/chkconfig --del lizardfs-cgiserv
fi
%endif
%if "%{distro}" == "el7"
%systemd_preun lizardfs-cgiserv.service
%endif
%postun cgiserv
%if "%{distro}" == "el6"
/sbin/service lizardfs-cgiserv condrestart > /dev/null 2>&1 || :
%endif
%if "%{distro}" == "el7"
%systemd_postun_with_restart lizardfs-cgiserv.service
%endif
# Prep, build, install, files...
############################################################
%prep
%setup
%build
./configure --with-doc
make %{?_smp_mflags}
%install
rm -rf $RPM_BUILD_ROOT
make install DESTDIR=$RPM_BUILD_ROOT
%if "%{distro}" == "el6"
install -d $RPM_BUILD_ROOT%{_initrddir}
for f in rpm/init-scripts/*.init ; do
sed -e 's,@sysconfdir@,%{_sysconfdir},;
s,@sbindir@,%{_sbindir},;
s,@initddir@,%{_initrddir},' $f > $RPM_BUILD_ROOT%{_initrddir}/$(basename $f .init)
done
%endif
%if "%{distro}" == "el7"
install -d -m755 $RPM_BUILD_ROOT/%{_unitdir}
for f in rpm/service-files/*.service ; do
install -m644 "$f" $RPM_BUILD_ROOT/%{_unitdir}/$(basename "$f")
done
%endif
%clean
rm -rf $RPM_BUILD_ROOT
%files master
%defattr(644,root,root,755)
%doc NEWS README UPGRADE
%attr(755,root,root) %{_sbindir}/mfsmaster
%attr(755,root,root) %{_sbindir}/mfsrestoremaster
%attr(755,root,root) %{_sbindir}/mfsmetadump
%attr(755,root,root) %{_sbindir}/mfsmetarestore
%attr(755,%{liz_user},%{liz_group}) %dir %{liz_datadir}
%{_mandir}/man5/mfsexports.cfg.5*
%{_mandir}/man5/mfstopology.cfg.5*
%{_mandir}/man5/mfsgoals.cfg.5*
%{_mandir}/man5/mfsmaster.cfg.5*
%{_mandir}/man5/globaliolimits.cfg.5*
%{_mandir}/man7/mfs.7*
%{_mandir}/man7/moosefs.7*
%{_mandir}/man7/lizardfs.7*
%{_mandir}/man8/mfsmaster.8*
%{_mandir}/man8/mfsmetadump.8*
%{_mandir}/man8/mfsmetarestore.8*
%{_mandir}/man8/mfsrestoremaster.8*
%{liz_confdir}/mfsexports.cfg.dist
%{liz_confdir}/mfstopology.cfg.dist
%{liz_confdir}/mfsgoals.cfg.dist
%{liz_confdir}/mfsmaster.cfg.dist
%{liz_confdir}/globaliolimits.cfg.dist
%attr(644,root,root) %{liz_datadir}/metadata.mfs.empty
%if "%{distro}" == "el6"
%attr(754,root,root) %{_initrddir}/lizardfs-master
%endif
%if "%{distro}" == "el7"
%attr(644,root,root) %{_unitdir}/lizardfs-master.service
%endif
%files metalogger
%defattr(644,root,root,755)
%doc NEWS README UPGRADE
%attr(755,root,root) %{_sbindir}/mfsmetalogger
%attr(755,%{liz_user},%{liz_group}) %dir %{liz_datadir}
%{_mandir}/man5/mfsmetalogger.cfg.5*
%{_mandir}/man8/mfsmetalogger.8*
%{liz_confdir}/mfsmetalogger.cfg.dist
%if "%{distro}" == "el6"
%attr(754,root,root) %{_initrddir}/lizardfs-metalogger
%endif
%if "%{distro}" == "el7"
%attr(644,root,root) %{_unitdir}/lizardfs-metalogger.service
%endif
%files chunkserver
%defattr(644,root,root,755)
%doc NEWS README UPGRADE
%attr(755,root,root) %{_sbindir}/mfschunkserver
%attr(755,%{liz_user},%{liz_group}) %dir %{liz_datadir}
%{_mandir}/man5/mfschunkserver.cfg.5*
%{_mandir}/man5/mfshdd.cfg.5*
%{_mandir}/man8/mfschunkserver.8*
%{liz_confdir}/mfschunkserver.cfg.dist
%{liz_confdir}/mfshdd.cfg.dist
%if "%{distro}" == "el6"
%attr(754,root,root) %{_initrddir}/lizardfs-chunkserver
%endif
%if "%{distro}" == "el7"
%attr(644,root,root) %{_unitdir}/lizardfs-chunkserver.service
%endif
%files client
%defattr(644,root,root,755)
%doc NEWS README UPGRADE
%attr(755,root,root) %{_bindir}/mfstools
%attr(755,root,root) %{_bindir}/mfsmount
%attr(755,root,root) %{_bindir}/mfssnapshot
%{_bindir}/mfsappendchunks
%{_bindir}/mfscheckfile
%{_bindir}/mfsdeleattr
%{_bindir}/mfsdirinfo
%{_bindir}/mfsfileinfo
%{_bindir}/mfsfilerepair
%{_bindir}/mfsgeteattr
%{_bindir}/mfsgetgoal
%{_bindir}/mfsgettrashtime
%{_bindir}/mfsmakesnapshot
%{_bindir}/mfsrepquota
%{_bindir}/mfsrgetgoal
%{_bindir}/mfsrgettrashtime
%{_bindir}/mfsrsetgoal
%{_bindir}/mfsrsettrashtime
%{_bindir}/mfsseteattr
%{_bindir}/mfssetgoal
%{_bindir}/mfssetquota
%{_bindir}/mfssettrashtime
%{_mandir}/man1/mfsappendchunks.1*
%{_mandir}/man1/mfscheckfile.1*
%{_mandir}/man1/mfsdeleattr.1*
%{_mandir}/man1/mfsdirinfo.1*
%{_mandir}/man1/mfsfileinfo.1*
%{_mandir}/man1/mfsfilerepair.1*
%{_mandir}/man1/mfsgeteattr.1*
%{_mandir}/man1/mfsgetgoal.1*
%{_mandir}/man1/mfsgettrashtime.1*
%{_mandir}/man1/mfsmakesnapshot.1*
%{_mandir}/man1/mfsrepquota.1*
%{_mandir}/man1/mfsrgetgoal.1*
%{_mandir}/man1/mfsrgettrashtime.1*
%{_mandir}/man1/mfsrsetgoal.1*
%{_mandir}/man1/mfsrsettrashtime.1*
%{_mandir}/man1/mfsseteattr.1*
%{_mandir}/man1/mfssetgoal.1*
%{_mandir}/man1/mfssetquota.1*
%{_mandir}/man1/mfssettrashtime.1*
%{_mandir}/man1/mfstools.1*
%{_mandir}/man5/iolimits.cfg.5*
%{_mandir}/man7/mfs.7*
%{_mandir}/man7/moosefs.7*
%{_mandir}/man1/mfsmount.1*
%{liz_confdir}/mfsmount.cfg.dist
%{liz_confdir}/iolimits.cfg.dist
%files cgi
%defattr(644,root,root,755)
%doc NEWS README UPGRADE
%dir %{_datadir}/mfscgi
%{_datadir}/mfscgi/err.gif
%{_datadir}/mfscgi/favicon.ico
%{_datadir}/mfscgi/index.html
%{_datadir}/mfscgi/logomini.png
%{_datadir}/mfscgi/mfs.css
%attr(755,root,root) %{_datadir}/mfscgi/mfs.cgi
%attr(755,root,root) %{_datadir}/mfscgi/chart.cgi
%files cgiserv
%defattr(644,root,root,755)
%attr(755,root,root) %{_sbindir}/lizardfs-cgiserver
%attr(755,root,root) %{_sbindir}/mfscgiserv
%{_mandir}/man8/lizardfs-cgiserver.8*
%{_mandir}/man8/mfscgiserv.8*
%if "%{distro}" == "el6"
%attr(754,root,root) %{_initrddir}/lizardfs-cgiserv
%endif
%if "%{distro}" == "el7"
%attr(644,root,root) %{_unitdir}/lizardfs-cgiserv.service
%endif
%files adm
%defattr(644,root,root,755)
%doc NEWS README UPGRADE
%attr(755,root,root) %{_bindir}/lizardfs-admin
%{_mandir}/man8/lizardfs-admin.8*
%{_bindir}/lizardfs-probe
%{_mandir}/man8/lizardfs-probe.8*
%changelog
* Wed Dec 2 2015 Piotr Sarna - 3.9.4
- (master) Removed master server overload on restarting chunkservers
- (master) Improved global file locks engine
- (chunkserver) Fixed leaking descriptors problem
- (chunkserver) Improved mechanism of moving chunks to new directory layout
- (chunkserver) Fixed issues related to scanning directories with new chunk format present
- (mount) Removed hang in mount when chunkserver reported no valid copies of a file
- (master) Changed handling of legacy (pre-3.9.2) chunkservers in new installations
- (cgi) Added XOR replication to statistics
- (all) Removed default linking to tcmalloc library due to performance drop
* Fri Oct 23 2015 Piotr Sarna - 3.9.2
- (all) Introduced XOR goal types
- (all) Added file locks (flock & fcntl)
- (all) Increased max number of files from 500 million to over 4 billion
- (all) Introduced managing open file limits by PAM
- (master) Improved consistency of applying changelogs by shadow masters
- (master) Redesigned snapshot execution in master
- (master) Redesigned chunk loop logic
- (master) Added option to limit chunk loop's CPU usage
- (master) Removed hard coded connection limit
- (chunkserver) Added new network threads responsible for handling requests
sent by chunkserver's clients
- (chunkserver) Introduced new more efficient directory layout
- (chunkserver) Added option to choose if fsync should be performed after each write
for increased safety
- (chunkserver) Removed hard coded connection limit
- (chunkserver) Added replication network bandwidth limiting
- (mount) Improved symlink cache and added configurable timeout value
- (all) Minor bug fixes and improvements
* Mon Feb 09 2015 Adam Ochmanski - 2.6.0
- (all) Added comments in all config files
- (all) Improve messages printed by daemons when starting
- (cgi) A new chunkserver's chart: number of chunk tests
- (cgi) Fixed paths to static content
- (cgi) New implementation of the CGI server; mfscgiserv is now deprecated.
- (cgi) New table: 'Metadata Servers' in the 'Servers' tab
- (chunkserver) Allowed starts with damaged disks
- (chunkserver) A new option: HDD_ADVISE_NO_CACHE
- (chunkserver) Improved handling of disk read errors
- (chunkserver) Removed 'testing chunk: xxxxxx' log messages
- (master) A new feature: disabling atime updates (globally)
- (master) Fixed rotating changelogs and downloading files in shadow mode
- (probe) New commands
- (probe) Renamed to lizardfs-admin
- (all) Minor bug fixes and improvements
* Fri Nov 07 2014 Alek Lewandowski - 2.5.4
- (all) Boost is no longer required to build the source code of LizardFS
or use the binary version
- (all) Added tiering (aka 'custom goal') feature, which allows
users to label chunkservers and to request chunks to be stored
on specific groups of servers
- (cgi) "Exports" tabs renamed to "Config", now it also shows goal
definitions
- (cgi) Added new tab "Chunks"
- (probe) New command "chunks-health" makes it possible to get number of
missing or endangered chunks
- (master) Fixed reporting memory usage in CGI
- (mount) Fixed caching contents of open directories
- (mount) Add a .lizardfs_tweaks file
- (all) Other minor fixes and improvements
* Mon Sep 15 2014 Alek Lewandowski - 2.5.2
- (master, shadow) Metadata checksum mechanism, allowing to
find and fix possible metadata inconsistencies between master
and shadow
- (mount, master) ACL cache in mount, reducing the load of
the master server
- (packaging) Support packaging for RedHat based systems
- (master) Improved chunkserver deregistration mechanism in
order to avoid temporary master unresponsiveness
- (polonaise) Add filesystem API for developers allowing to
use the filesystem without FUSE (and thus working also on
Windows)
- (all) Minor fixes and improvements
* Tue Jul 15 2014 Marcin Sulikowski - 2.5.0
- (master) High availability provided by shadow master servers
- (mount, chunkserver) CRC algorithm replaced with a 3 times faster
implementation
- (mount, master) Support for quotas (for users and groups)
- (mount, master) Support for posix access contol lists (requires
additional OS support)
- (mount, master) Support for global I/O limiting (bandwidth limiting)
- (mount) Support for per-mountpoint I/O limiting (bandwidth limiting)
- (adm) New package lizardfs-adm with a lizardfs-probe command-line
tool which can be used to query the installation for variuos
parameteres
- (master) New mechanism of storing metadata backup files which
improves performance of the hourly metadata dumps
- (all) A comprehensive test suite added
- (all) Multiple bugfixes
* Wed Oct 16 2013 Peter aNeutrino - 1.6.28-1
- (all) compile with g++ by default
- (deb) fix init scripts for debian packages
- (all) fix build on Mac OS X
- (cgi) introducing LizardFS logo
* Thu Feb 16 2012 Jakub Bogusz - 1.6.27-1
- adjusted to keep configuration files in /etc/mfs
- require just mfsexports.cfg (master) and mfshdd.cfg (chunkserver) in RH-like
init scripts; for other files defaults are just fine to run services
- moved mfscgiserv to -cgiserv subpackage (-cgi alone can be used with any
external CGI-capable HTTP server), added mfscgiserv init script
* Fri Nov 19 2010 Jakub Bogusz - 1.6.19-1
- separated mfs-metalogger subpackage (following Debian packaging)
* Fri Oct 8 2010 Jakub Bogusz - 1.6.17-1
- added init scripts based on work of Steve Huff (Dag Apt Repository)
(included in RPMs when building with --define "distro rh")
* Mon Jul 19 2010 Jakub Kruszona-Zawadzki - 1.6.16-1
- added mfscgiserv man page
* Fri Jun 11 2010 Jakub Bogusz - 1.6.15-1
- initial spec file, based on Debian packaging;
partially inspired by spec file by Kirby Zhou
lizardfs-v.3.9.4/rpm/service-files/ 0000775 0000000 0000000 00000000000 12631772427 0017162 5 ustar 00root root 0000000 0000000 lizardfs-v.3.9.4/rpm/service-files/lizardfs-cgiserv.service 0000664 0000000 0000000 00000000617 12631772427 0024026 0 ustar 00root root 0000000 0000000 [Unit]
Description=LizardFS CGI server daemon
Documentation=man:lizardfs-cgiserver
After=network.target
[Service]
Environment=BIND_HOST=0.0.0.0
Environment=BIND_PORT=9425
Environment=ROOT_PATH=/usr/share/mfscgi
EnvironmentFile=-/etc/default/%p
ExecStart=/usr/sbin/lizardfs-cgiserver -H ${BIND_HOST} -P ${BIND_PORT} -R ${ROOT_PATH}
Restart=on-abort
User=nobody
[Install]
WantedBy=multi-user.target
lizardfs-v.3.9.4/rpm/service-files/lizardfs-chunkserver.service 0000664 0000000 0000000 00000000457 12631772427 0024725 0 ustar 00root root 0000000 0000000 [Unit]
Description=LizardFS chunkserver daemon
Documentation=man:mfschunkserver
After=network.target
[Service]
Type=forking
ExecStart=/usr/sbin/mfschunkserver start
ExecStop=/usr/sbin/mfschunkserver stop
ExecReload=/usr/sbin/mfschunkserver reload
Restart=on-abort
[Install]
WantedBy=multi-user.target
lizardfs-v.3.9.4/rpm/service-files/lizardfs-master.service 0000664 0000000 0000000 00000000444 12631772427 0023655 0 ustar 00root root 0000000 0000000 [Unit]
Description=LizardFS master server daemon
Documentation=man:mfsmaster
After=network.target
[Service]
Type=forking
TimeoutSec=0
ExecStart=/usr/sbin/mfsmaster start
ExecStop=/usr/sbin/mfsmaster stop
ExecReload=/usr/sbin/mfsmaster reload
Restart=no
[Install]
WantedBy=multi-user.target
lizardfs-v.3.9.4/rpm/service-files/lizardfs-metalogger.service 0000664 0000000 0000000 00000000461 12631772427 0024507 0 ustar 00root root 0000000 0000000 [Unit]
Description=LizardFS metalogger server daemon
Documentation=man:mfsmetalogger
After=network.target
[Service]
Type=forking
ExecStart=/usr/sbin/mfsmetalogger start
ExecStop=/usr/sbin/mfsmetalogger stop
ExecReload=/usr/sbin/mfsmetalogger reload
Restart=on-abort
[Install]
WantedBy=multi-user.target
lizardfs-v.3.9.4/src/ 0000775 0000000 0000000 00000000000 12631772427 0014413 5 ustar 00root root 0000000 0000000 lizardfs-v.3.9.4/src/admin/ 0000775 0000000 0000000 00000000000 12631772427 0015503 5 ustar 00root root 0000000 0000000 lizardfs-v.3.9.4/src/admin/CMakeLists.txt 0000664 0000000 0000000 00000001160 12631772427 0020241 0 ustar 00root root 0000000 0000000 collect_sources(LIZARDFS_ADMIN)
add_library(lizardfs-admin-lib ${LIZARDFS_ADMIN_SOURCES})
target_link_libraries(lizardfs-admin-lib mfscommon)
add_tests(lizardfs-admin-lib ${LIZARDFS_ADMIN_TESTS})
add_executable(lizardfs-admin ${LIZARDFS_ADMIN_MAIN})
target_link_libraries(lizardfs-admin lizardfs-admin-lib)
install(TARGETS lizardfs-admin RUNTIME DESTINATION ${BIN_SUBDIR})
add_custom_target(lizardfs-probe ALL
COMMAND ln -sf lizardfs-admin lizardfs-probe
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
DEPENDS lizardfs-admin)
install(FILES ${CMAKE_CURRENT_BINARY_DIR}/lizardfs-probe DESTINATION ${BIN_SUBDIR})
lizardfs-v.3.9.4/src/admin/chunk_health_command.cc 0000664 0000000 0000000 00000013735 12631772427 0022156 0 ustar 00root root 0000000 0000000 /*
Copyright 2013-2014 EditShare, 2013-2015 Skytechnology sp. z o.o.
This file is part of LizardFS.
LizardFS is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with LizardFS. If not, see .
*/
#include "common/platform.h"
#include "admin/chunk_health_command.h"
#include
#include "protocol/cltoma.h"
#include "protocol/matocl.h"
#include "common/server_connection.h"
std::vector ChunksHealthCommand::goals;
std::map ChunksHealthCommand::goalNames;
const std::string ChunksHealthCommand::kOptionAvailability = "--availability";
const std::string ChunksHealthCommand::kOptionReplication = "--replication";
const std::string ChunksHealthCommand::kOptionDeletion = "--deletion";
std::string ChunksHealthCommand::name() const {
return "chunks-health";
}
LizardFsProbeCommand::SupportedOptions ChunksHealthCommand::supportedOptions() const {
return {
{kPorcelainMode, kPorcelainModeDescription},
{kOptionAvailability, "Print report about availability of chunks."},
{kOptionReplication, "Print report about about number of chunks that need replication."},
{kOptionDeletion, "Print report about about number of chunks that need deletion."},
};
}
void ChunksHealthCommand::usage() const {
std::cerr << name() << " \n";
std::cerr << " Returns chunks health reports in the installation.\n";
std::cerr << " By default (if no report is specified) all reports will be shown.\n";
std::cerr << " In replication and deletion states, the column means the number of chunks\n";
std::cerr << " with number of copies specified in the label to replicate/delete.\n";
}
void ChunksHealthCommand::initializeGoals(ServerConnection& connection) {
if (!goals.empty()) {
return;
}
std::vector serializedGoals;
auto request = cltoma::listGoals::build(true);
auto response = connection.sendAndReceive(request, LIZ_MATOCL_LIST_GOALS);
matocl::listGoals::deserialize(response, serializedGoals);
for (const SerializedGoal& goal : serializedGoals) {
goals.push_back(goal.id);
goalNames[goal.id] = goal.name;
}
}
void ChunksHealthCommand::run(const Options& options) const {
if (options.arguments().size() != 2) {
throw WrongUsageException("Expected and for " + name() + '\n');
}
ServerConnection connection(options.argument(0), options.argument(1));
bool regularOnly = false;
auto request = cltoma::chunksHealth::build(regularOnly);
auto response = connection.sendAndReceive(request, LIZ_MATOCL_CHUNKS_HEALTH);
ChunksAvailabilityState availability;
ChunksReplicationState replication;
matocl::chunksHealth::deserialize(response, regularOnly, availability, replication);
if (regularOnly) {
throw Exception("Incorrect response type received");
}
initializeGoals(connection);
bool showAllReports = !options.isSet(kOptionAvailability)
&& !options.isSet(kOptionReplication)
&& !options.isSet(kOptionDeletion);
if (showAllReports || options.isSet(kOptionAvailability)) {
printState(availability, options.isSet(kPorcelainMode));
}
if (showAllReports || options.isSet(kOptionReplication)) {
printState(true, replication, options.isSet(kPorcelainMode));
}
if (showAllReports || options.isSet(kOptionDeletion)) {
printState(false, replication, options.isSet(kPorcelainMode));
}
}
void ChunksHealthCommand::printState(const ChunksAvailabilityState& state, bool isPorcelain) const {
if (isPorcelain) {
for (uint8_t goal : goals) {
std::cout << "AVA"
<< ' ' << goalNames.at(goal)
<< ' ' << state.safeChunks(goal)
<< ' ' << state.endangeredChunks(goal)
<< ' ' << state.lostChunks(goal) << std::endl;
}
} else {
std::cout << "Chunks availability state:" << std::endl;
std::cout << "\tGoal\tSafe\tUnsafe\tLost" << std::endl;
for (uint8_t goal : goals) {
if (state.safeChunks(goal) + state.endangeredChunks(goal)
+ state.lostChunks(goal) == 0) {
continue;
}
std::cout << '\t' << goalNames.at(goal)
<< '\t' << print(state.safeChunks(goal))
<< '\t' << print(state.endangeredChunks(goal))
<< '\t' << print(state.lostChunks(goal)) << std::endl;
}
std::cout << std::endl;
}
}
void ChunksHealthCommand::printState(bool isReplication, const ChunksReplicationState& state,
bool isPorcelain) const {
if (isPorcelain) {
for (uint8_t goal : goals) {
std::cout << (isReplication ? "REP" : "DEL") << ' ' << goalNames.at(goal);
for (uint32_t part = 0; part < ChunksReplicationState::kMaxPartsCount; ++part) {
isReplication
? std::cout << ' ' << state.chunksToReplicate(goal, part)
: std::cout << ' ' << state.chunksToDelete(goal, part);
}
std::cout << std::endl;
}
} else {
isReplication ? std::cout << "Chunks replication state:" << std::endl
: std::cout << "Chunks deletion state:" << std::endl;
std::cout << "\tGoal";
for (uint32_t i = 0; i < ChunksReplicationState::kMaxPartsCount; ++i) {
std::cout << '\t' << i;
}
std::cout << '+' << std::endl;
for (uint8_t goal : goals) {
std::string line = '\t' + goalNames.at(goal);
uint64_t sum = 0;
for (uint32_t part = 0; part < ChunksReplicationState::kMaxPartsCount; ++part) {
uint64_t chunksCount = isReplication ? state.chunksToReplicate(goal, part)
: state.chunksToDelete(goal, part);
sum += chunksCount;
line += '\t' + print(chunksCount);
}
if (sum) {
std::cout << line << std::endl;
}
}
std::cout << std::endl;
}
}
std::string ChunksHealthCommand::print(uint64_t number) const {
if (number == 0) {
return "-";
}
return std::to_string(number);
}
lizardfs-v.3.9.4/src/admin/chunk_health_command.h 0000664 0000000 0000000 00000003170 12631772427 0022010 0 ustar 00root root 0000000 0000000 /*
Copyright 2013-2014 EditShare, 2013-2015 Skytechnology sp. z o.o.
This file is part of LizardFS.
LizardFS is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3.
LizardFS is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with LizardFS. If not, see .
*/
#pragma once
#include "common/platform.h"
#include