Project import
diff --git a/f2fs-tools/AUTHORS b/f2fs-tools/AUTHORS
new file mode 100644
index 0000000..6ec1861
--- /dev/null
+++ b/f2fs-tools/AUTHORS
@@ -0,0 +1 @@
+This package has been developed by Praesto Team at Samsung Electronics Co., Ltd.
diff --git a/f2fs-tools/Android.mk b/f2fs-tools/Android.mk
new file mode 100644
index 0000000..55f4a4e
--- /dev/null
+++ b/f2fs-tools/Android.mk
@@ -0,0 +1,128 @@
+LOCAL_PATH:= $(call my-dir)
+
+# f2fs-tools depends on Linux kernel headers being in the system include path.
+ifeq ($(HOST_OS),linux)
+
+# The versions depend on $(LOCAL_PATH)/VERSION
+version_CFLAGS := -DF2FS_MAJOR_VERSION=1 -DF2FS_MINOR_VERSION=4 -DF2FS_TOOLS_VERSION=\"1.4.0\" -DF2FS_TOOLS_DATE=\"2014-10-18\"
+
+# external/e2fsprogs/lib is needed for uuid/uuid.h
+common_C_INCLUDES := $(LOCAL_PATH)/include external/e2fsprogs/lib/
+
+#----------------------------------------------------------
+include $(CLEAR_VARS)
+LOCAL_MODULE := libf2fs_fmt
+LOCAL_SRC_FILES := \
+ lib/libf2fs.c \
+ mkfs/f2fs_format.c \
+ mkfs/f2fs_format_utils.c \
+
+LOCAL_C_INCLUDES := $(common_C_INCLUDES)
+LOCAL_CFLAGS := $(version_CFLAGS)
+LOCAL_EXPORT_CFLAGS := $(version_CFLAGS)
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include $(LOCAL_PATH)/mkfs
+include $(BUILD_STATIC_LIBRARY)
+
+#----------------------------------------------------------
+include $(CLEAR_VARS)
+LOCAL_MODULE := libf2fs_fmt_host
+LOCAL_SRC_FILES := \
+ lib/libf2fs.c \
+ mkfs/f2fs_format.c \
+ mkfs/f2fs_format_utils.c \
+
+LOCAL_C_INCLUDES := $(common_C_INCLUDES)
+LOCAL_CFLAGS := $(version_CFLAGS)
+LOCAL_EXPORT_CFLAGS := $(version_CFLAGS)
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include $(LOCAL_PATH)/mkfs
+include $(BUILD_HOST_STATIC_LIBRARY)
+
+#----------------------------------------------------------
+include $(CLEAR_VARS)
+LOCAL_MODULE := libf2fs_fmt_host_dyn
+LOCAL_SRC_FILES := \
+ lib/libf2fs.c \
+ mkfs/f2fs_format.c \
+
+LOCAL_C_INCLUDES := $(common_C_INCLUDES)
+LOCAL_CFLAGS := $(version_CFLAGS)
+LOCAL_EXPORT_CFLAGS := $(version_CFLAGS)
+LOCAL_EXPORT_C_INCLUDES := $(LOCAL_PATH)/include $(LOCAL_PATH)/mkfs
+LOCAL_STATIC_LIBRARIES := \
+ libf2fs_ioutils_host \
+ libext2_uuid-host \
+ libsparse_host \
+ libz
+# LOCAL_LDLIBS := -ldl
+include $(BUILD_HOST_SHARED_LIBRARY)
+
+#----------------------------------------------------------
+include $(CLEAR_VARS)
+# The LOCAL_MODULE name is referenced by the code. Don't change it.
+LOCAL_MODULE := mkfs.f2fs
+
+# mkfs.f2fs is used in recovery: must be static.
+LOCAL_FORCE_STATIC_EXECUTABLE := true
+
+LOCAL_MODULE_PATH := $(TARGET_RECOVERY_ROOT_OUT)/sbin
+
+LOCAL_SRC_FILES := \
+ lib/libf2fs_io.c \
+ mkfs/f2fs_format_main.c
+LOCAL_C_INCLUDES := $(common_C_INCLUDES)
+LOCAL_CFLAGS := $(version_CFLAGS)
+LOCAL_STATIC_LIBRARIES := libc libf2fs_fmt libext2_uuid_static
+LOCAL_MODULE_TAGS := optional
+include $(BUILD_EXECUTABLE)
+
+#----------------------------------------------------------
+include $(CLEAR_VARS)
+LOCAL_MODULE := make_f2fs
+
+LOCAL_SRC_FILES := \
+ lib/libf2fs_io.c \
+ mkfs/f2fs_format_main.c
+LOCAL_C_INCLUDES := $(common_C_INCLUDES)
+LOCAL_CFLAGS := $(version_CFLAGS)
+LOCAL_STATIC_LIBRARIES := libf2fs_fmt
+LOCAL_SHARED_LIBRARIES := libext2_uuid
+LOCAL_SYSTEM_SHARED_LIBRARIES := libc
+LOCAL_MODULE_TAGS := optional
+include $(BUILD_EXECUTABLE)
+
+#----------------------------------------------------------
+include $(CLEAR_VARS)
+# The LOCAL_MODULE name is referenced by the code. Don't change it.
+LOCAL_MODULE := fsck.f2fs
+LOCAL_SRC_FILES := \
+ fsck/dump.c \
+ fsck/fsck.c \
+ fsck/main.c \
+ fsck/mount.c \
+ lib/libf2fs.c \
+ lib/libf2fs_io.c \
+
+LOCAL_C_INCLUDES := $(common_C_INCLUDES)
+LOCAL_CFLAGS := $(version_CFLAGS)
+LOCAL_SHARED_LIBRARIES := libext2_uuid
+LOCAL_SYSTEM_SHARED_LIBRARIES := libc
+LOCAL_MODULE_TAGS := optional
+include $(BUILD_EXECUTABLE)
+
+#----------------------------------------------------------
+include $(CLEAR_VARS)
+LOCAL_MODULE := fsck.f2fs
+LOCAL_SRC_FILES := \
+ fsck/dump.c \
+ fsck/fsck.c \
+ fsck/main.c \
+ fsck/mount.c \
+ lib/libf2fs.c \
+ lib/libf2fs_io.c \
+
+LOCAL_C_INCLUDES := $(common_C_INCLUDES)
+LOCAL_CFLAGS := $(version_CFLAGS)
+LOCAL_HOST_SHARED_LIBRARIES := libext2_uuid_host
+include $(BUILD_HOST_EXECUTABLE)
+
+endif
diff --git a/f2fs-tools/COPYING b/f2fs-tools/COPYING
new file mode 100644
index 0000000..52f956d
--- /dev/null
+++ b/f2fs-tools/COPYING
@@ -0,0 +1,864 @@
+The tools for F2FS are covered by GNU Public License version 2.
+Exceptionally, the following files are also covered by the GNU Lesser General
+Public License Version 2.1 as the dual licenses.
+- include/f2fs_fs.h
+- lib/libf2fs.c
+- lib/libf2fs_io.c
+- mkfs/f2fs_format.c
+- mkfs/f2fs_format_main.c
+- mkfs/f2fs_format_utils.c
+- mkfs/f2fs_format_utils.h
+
+================================================================================
+Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ http://www.samsung.com/
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 2 as
+published by the Free Software Foundation.
+
+================================================================================
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.) 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
+this service 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 make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. 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.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+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
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the 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 a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE 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.
+
+ 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
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ 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 2 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, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision 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, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This 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 Library General
+Public License instead of this License.
+
+================================================================================
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+ When we speak of free software, we are referring to freedom of use,
+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 this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing non-free programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard. To achieve this, non-free programs must be
+allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely well-defined independent of the
+ application. Therefore, Subsection 2d requires that any
+ application-supplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+ 6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interface-compatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+ 7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+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
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser 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 Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "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
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY 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
+LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the
+ library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/f2fs-tools/ChangeLog b/f2fs-tools/ChangeLog
new file mode 100644
index 0000000..9739e99
--- /dev/null
+++ b/f2fs-tools/ChangeLog
@@ -0,0 +1,4 @@
+f2fs-tools-1.0.0 Tue Aug 14, 2012 KST
+ * The first release of f2fs-tools.
+f2fs-tools-1.0.1 Tue Jun 04, 2013 KST
+ * Added fsck and dump for f2fs-tools.
diff --git a/f2fs-tools/MODULE_LICENSE_LGPL b/f2fs-tools/MODULE_LICENSE_LGPL
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/f2fs-tools/MODULE_LICENSE_LGPL
diff --git a/f2fs-tools/Makefile.am b/f2fs-tools/Makefile.am
new file mode 100644
index 0000000..d2921d6
--- /dev/null
+++ b/f2fs-tools/Makefile.am
@@ -0,0 +1,5 @@
+## Makefile.am
+
+ACLOCAL_AMFLAGS = -I m4
+
+SUBDIRS = man lib mkfs fsck tools
diff --git a/f2fs-tools/NOTICE b/f2fs-tools/NOTICE
new file mode 100644
index 0000000..52f956d
--- /dev/null
+++ b/f2fs-tools/NOTICE
@@ -0,0 +1,864 @@
+The tools for F2FS are covered by GNU Public License version 2.
+Exceptionally, the following files are also covered by the GNU Lesser General
+Public License Version 2.1 as the dual licenses.
+- include/f2fs_fs.h
+- lib/libf2fs.c
+- lib/libf2fs_io.c
+- mkfs/f2fs_format.c
+- mkfs/f2fs_format_main.c
+- mkfs/f2fs_format_utils.c
+- mkfs/f2fs_format_utils.h
+
+================================================================================
+Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ http://www.samsung.com/
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 2 as
+published by the Free Software Foundation.
+
+================================================================================
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.) 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
+this service 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 make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. 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.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+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
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the 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 a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE 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.
+
+ 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
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ 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 2 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, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision 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, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This 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 Library General
+Public License instead of this License.
+
+================================================================================
+ GNU LESSER GENERAL PUBLIC LICENSE
+ Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL. It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+ This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it. You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+ When we speak of free software, we are referring to freedom of use,
+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 this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+ To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights. These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+ For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you. You must make sure that they, too, receive or can get the source
+code. If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it. And you must show them these terms so they know their rights.
+
+ We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+ To protect each distributor, we want to make it very clear that
+there is no warranty for the free library. Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+ Finally, software patents pose a constant threat to the existence of
+any free program. We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder. Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+ Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License. This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License. We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+ When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library. The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom. The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+ We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License. It also provides other free software developers Less
+of an advantage over competing non-free programs. These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries. However, the Lesser license provides advantages in certain
+special circumstances.
+
+ For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard. To achieve this, non-free programs must be
+allowed to use the library. A more frequent case is that a free
+library does the same job as widely used non-free libraries. In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+ In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software. For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+ Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+ The precise terms and conditions for copying, distribution and
+modification follow. Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library". The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+ GNU LESSER GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+ A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+ The "Library", below, refers to any such software library or work
+which has been distributed under these terms. A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language. (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+ "Source code" for a work means the preferred form of the work for
+making modifications to it. For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+ Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it). Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+
+ 1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+ You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+ 2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) The modified work must itself be a software library.
+
+ b) You must cause the files modified to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ c) You must cause the whole of the work to be licensed at no
+ charge to all third parties under the terms of this License.
+
+ d) If a facility in the modified Library refers to a function or a
+ table of data to be supplied by an application program that uses
+ the facility, other than as an argument passed when the facility
+ is invoked, then you must make a good faith effort to ensure that,
+ in the event an application does not supply such function or
+ table, the facility still operates, and performs whatever part of
+ its purpose remains meaningful.
+
+ (For example, a function in a library to compute square roots has
+ a purpose that is entirely well-defined independent of the
+ application. Therefore, Subsection 2d requires that any
+ application-supplied function or table used by this function must
+ be optional: if the application does not supply it, the square
+ root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library. To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License. (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.) Do not make any other change in
+these notices.
+
+ Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+ This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+ 4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+ If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library". Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+ However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library". The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+ When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library. The
+threshold for this to be true is not precisely defined by law.
+
+ If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work. (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+ Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+ 6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+ You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License. You must supply a copy of this License. If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License. Also, you must do one
+of these things:
+
+ a) Accompany the work with the complete corresponding
+ machine-readable source code for the Library including whatever
+ changes were used in the work (which must be distributed under
+ Sections 1 and 2 above); and, if the work is an executable linked
+ with the Library, with the complete machine-readable "work that
+ uses the Library", as object code and/or source code, so that the
+ user can modify the Library and then relink to produce a modified
+ executable containing the modified Library. (It is understood
+ that the user who changes the contents of definitions files in the
+ Library will not necessarily be able to recompile the application
+ to use the modified definitions.)
+
+ b) Use a suitable shared library mechanism for linking with the
+ Library. A suitable mechanism is one that (1) uses at run time a
+ copy of the library already present on the user's computer system,
+ rather than copying library functions into the executable, and (2)
+ will operate properly with a modified version of the library, if
+ the user installs one, as long as the modified version is
+ interface-compatible with the version that the work was made with.
+
+ c) Accompany the work with a written offer, valid for at
+ least three years, to give the same user the materials
+ specified in Subsection 6a, above, for a charge no more
+ than the cost of performing this distribution.
+
+ d) If distribution of the work is made by offering access to copy
+ from a designated place, offer equivalent access to copy the above
+ specified materials from the same place.
+
+ e) Verify that the user has already received a copy of these
+ materials or that you have already sent this user a copy.
+
+ For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it. However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+ It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system. Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+ 7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+ a) Accompany the combined library with a copy of the same work
+ based on the Library, uncombined with any other library
+ facilities. This must be distributed under the terms of the
+ Sections above.
+
+ b) Give prominent notice with the combined library of the fact
+ that part of it is a work based on the Library, and explaining
+ where to find the accompanying uncombined form of the same work.
+
+ 8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License. Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License. However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+ 9. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Library or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+ 10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+ 11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+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
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all. For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded. In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+ 13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser 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 Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation. If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+ 14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission. For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this. Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+ NO WARRANTY
+
+ 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "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
+LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY 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
+LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Libraries
+
+ If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change. You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+ To apply these terms, attach the following notices to the library. It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the library's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library 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
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the
+ library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+ <signature of Ty Coon>, 1 April 1990
+ Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/f2fs-tools/README b/f2fs-tools/README
new file mode 100644
index 0000000..222cbc3
--- /dev/null
+++ b/f2fs-tools/README
@@ -0,0 +1,48 @@
+F2FS format utilility
+---------------------
+
+To use f2fs filesystem, you should format the storage partition
+with this utilility. Otherwise, you cannot mount f2fs.
+
+Before compilation
+------------------
+
+Your should install the following packages.
+ - libuuid-devel or uuid-dev
+ - pkg-config
+ - autoconf
+ - libtool
+
+Initial compilation
+-------------------
+
+Before compilation initially, autoconf/automake tools should be run.
+
+ # autoreconf --install
+
+How to compile
+--------------
+
+ # ./configure
+ # make
+
+How to cross-compile (e.g., for ARM)
+------------------------------------
+
+ 1. Add the below line into mkfs/Makefile.am:
+ mkfs_f2fs_LDFLAGS = -all-static
+
+ 2. Add the below line into fsck/Makefile.am:
+ fsck_f2fs_LDFLAGS = -all-static
+
+ 3. then, do:
+ # LDFLAGS=--static ./configure \
+ --host=arm-none-linux-gnueabi --target=arm-none-linux-gnueabi
+ # make
+
+How to run by default
+---------------------
+
+ $ ./mkfs.f2fs -l [LABEL] $DEV
+
+For more mkfs options, see man page.
diff --git a/f2fs-tools/VERSION b/f2fs-tools/VERSION
new file mode 100644
index 0000000..0e58c09
--- /dev/null
+++ b/f2fs-tools/VERSION
@@ -0,0 +1,2 @@
+1.4.1
+2015-03-04
diff --git a/f2fs-tools/configure.ac b/f2fs-tools/configure.ac
new file mode 100644
index 0000000..ae451b8
--- /dev/null
+++ b/f2fs-tools/configure.ac
@@ -0,0 +1,92 @@
+# -*- Autoconf -*-
+# Process this file with autoconf to produce a configure script.
+
+AC_PREREQ([2.68])
+
+# Get version from file VERSION
+m4_define([f2fs_tools_version], m4_esyscmd([sed -n '1p' VERSION | tr -d '\n']))
+m4_define([f2fs_tools_date], m4_esyscmd([sed -n '2p' VERSION | tr -d '\n']))
+m4_define([f2fs_tools_gitdate],
+ m4_esyscmd([git log -1 --pretty=format:%ci 2> /dev/null]))
+
+AC_INIT([F2FS tools], [f2fs_tools_version],
+ [linux-f2fs-devel@lists.sourceforge.net])
+
+AC_DEFINE([F2FS_TOOLS_VERSION], "f2fs_tools_version", [f2fs-tools version])
+AC_DEFINE([F2FS_MAJOR_VERSION], m4_bpatsubst(f2fs_tools_version,
+ [\([0-9]*\)\(\w\|\W\)*], [\1]),
+ [Major version for f2fs-tools])
+AC_DEFINE([F2FS_MINOR_VERSION], m4_bpatsubst(f2fs_tools_version,
+ [\([0-9]*\).\([0-9]*\)\(\w\|\W\)*], [\2]),
+ [Minor version for f2fs-tools])
+
+AC_CHECK_FILE(.git,
+ AC_DEFINE([F2FS_TOOLS_DATE],
+ "m4_bpatsubst(f2fs_tools_gitdate,
+ [\([0-9-]*\)\(\w\|\W\)*], [\1])",
+ [f2fs-tools date based on Git commits]),
+ AC_DEFINE([F2FS_TOOLS_DATE],
+ "f2fs_tools_date",
+ [f2fs-tools date based on Source releases]))
+
+AC_CONFIG_SRCDIR([config.h.in])
+AC_CONFIG_HEADER([config.h])
+AC_CONFIG_MACRO_DIR([m4])
+AC_CONFIG_AUX_DIR([build-aux])
+AM_INIT_AUTOMAKE([foreign tar-pax dist-xz])
+
+AC_CHECK_HEADERS_ONCE([
+ fcntl.h
+ mntent.h
+ stdlib.h
+ string.h
+ unistd.h
+ sys/ioctl.h
+ sys/mount.h
+])
+
+# Checks for programs.
+AC_PROG_CC
+AC_PROG_LIBTOOL
+AC_PATH_PROG([LDCONFIG], [ldconfig],
+ [AC_MSG_ERROR([ldconfig not found])],
+ [$PATH:/sbin])
+
+# Checks for libraries.
+PKG_CHECK_MODULES([libuuid], [uuid])
+
+# Checks for header files.
+AC_CHECK_HEADERS([linux/fs.h fcntl.h mntent.h stdlib.h string.h \
+ sys/ioctl.h sys/mount.h unistd.h linux/falloc.h byteswap.h])
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_C_INLINE
+AC_TYPE_INT32_T
+AC_TYPE_INT8_T
+AC_TYPE_SIZE_T
+
+# Checks for library functions.
+AC_FUNC_GETMNTENT
+AC_CHECK_FUNCS_ONCE([
+ getmntent
+ memset
+])
+
+AS_IF([test "$ac_cv_header_byteswap_h" = "yes"],
+ [AC_CHECK_DECLS([bswap_64],,,[#include <byteswap.h>])])
+
+# Install directories
+AC_PREFIX_DEFAULT([/usr])
+AC_SUBST([sbindir], [/sbin])
+AC_SUBST([sysconfdir], [/etc])
+AC_SUBST([localstatedir], [/var])
+AC_CONFIG_FILES([
+ Makefile
+ man/Makefile
+ lib/Makefile
+ mkfs/Makefile
+ fsck/Makefile
+ tools/Makefile
+])
+
+AC_OUTPUT
diff --git a/f2fs-tools/fsck/Makefile.am b/f2fs-tools/fsck/Makefile.am
new file mode 100644
index 0000000..3258e47
--- /dev/null
+++ b/f2fs-tools/fsck/Makefile.am
@@ -0,0 +1,10 @@
+## Makefile.am
+
+AM_CPPFLAGS = ${libuuid_CFLAGS} -I$(top_srcdir)/include
+AM_CFLAGS = -Wall
+sbin_PROGRAMS = fsck.f2fs
+fsck_f2fs_SOURCES = main.c fsck.c dump.c mount.c
+fsck_f2fs_LDADD = ${libuuid_LIBS} $(top_builddir)/lib/libf2fs.la
+
+install-data-hook:
+ ln -sf fsck.f2fs $(DESTDIR)/$(sbindir)/dump.f2fs
diff --git a/f2fs-tools/fsck/dump.c b/f2fs-tools/fsck/dump.c
new file mode 100644
index 0000000..3c4a8d1
--- /dev/null
+++ b/f2fs-tools/fsck/dump.c
@@ -0,0 +1,466 @@
+/**
+ * dump.c
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include <inttypes.h>
+
+#include "fsck.h"
+#include <locale.h>
+
+#define BUF_SZ 80
+
+const char *seg_type_name[SEG_TYPE_MAX] = {
+ "SEG_TYPE_DATA",
+ "SEG_TYPE_CUR_DATA",
+ "SEG_TYPE_NODE",
+ "SEG_TYPE_CUR_NODE",
+};
+
+void sit_dump(struct f2fs_sb_info *sbi, int start_sit, int end_sit)
+{
+ struct seg_entry *se;
+ int segno;
+ char buf[BUF_SZ];
+ u32 free_segs = 0;;
+ u64 valid_blocks = 0;
+ int ret;
+ int fd;
+
+ fd = open("dump_sit", O_CREAT|O_WRONLY|O_TRUNC, 0666);
+ ASSERT(fd >= 0);
+
+ for (segno = start_sit; segno < end_sit; segno++) {
+ se = get_seg_entry(sbi, segno);
+
+ memset(buf, 0, BUF_SZ);
+ snprintf(buf, BUF_SZ, "%5d %8d\n", segno, se->valid_blocks);
+
+ ret = write(fd, buf, strlen(buf));
+ ASSERT(ret >= 0);
+
+ DBG(4, "SIT[0x%3x] : 0x%x\n", segno, se->valid_blocks);
+ if (se->valid_blocks == 0x0) {
+ free_segs++;
+ } else {
+ ASSERT(se->valid_blocks <= 512);
+ valid_blocks += se->valid_blocks;
+ }
+ }
+
+ memset(buf, 0, BUF_SZ);
+ snprintf(buf, BUF_SZ, "valid_segs:%d\t free_segs:%d\n",
+ SM_I(sbi)->main_segments - free_segs, free_segs);
+ ret = write(fd, buf, strlen(buf));
+ ASSERT(ret >= 0);
+
+ close(fd);
+ DBG(1, "Blocks [0x%" PRIx64 "] Free Segs [0x%x]\n", valid_blocks, free_segs);
+}
+
+void ssa_dump(struct f2fs_sb_info *sbi, int start_ssa, int end_ssa)
+{
+ struct f2fs_summary_block sum_blk;
+ char buf[BUF_SZ];
+ int segno, i, ret;
+ int fd;
+
+ fd = open("dump_ssa", O_CREAT|O_WRONLY|O_TRUNC, 0666);
+ ASSERT(fd >= 0);
+
+ snprintf(buf, BUF_SZ, "Note: dump.f2fs -b blkaddr = 0x%x + segno * "
+ " 0x200 + offset\n",
+ sbi->sm_info->main_blkaddr);
+ ret = write(fd, buf, strlen(buf));
+ ASSERT(ret >= 0);
+
+ for (segno = start_ssa; segno < end_ssa; segno++) {
+ ret = get_sum_block(sbi, segno, &sum_blk);
+
+ memset(buf, 0, BUF_SZ);
+ switch (ret) {
+ case SEG_TYPE_CUR_NODE:
+ snprintf(buf, BUF_SZ, "\n\nsegno: %x, Current Node\n", segno);
+ break;
+ case SEG_TYPE_CUR_DATA:
+ snprintf(buf, BUF_SZ, "\n\nsegno: %x, Current Data\n", segno);
+ break;
+ case SEG_TYPE_NODE:
+ snprintf(buf, BUF_SZ, "\n\nsegno: %x, Node\n", segno);
+ break;
+ case SEG_TYPE_DATA:
+ snprintf(buf, BUF_SZ, "\n\nsegno: %x, Data\n", segno);
+ break;
+ }
+ ret = write(fd, buf, strlen(buf));
+ ASSERT(ret >= 0);
+
+ for (i = 0; i < ENTRIES_IN_SUM; i++) {
+ memset(buf, 0, BUF_SZ);
+ if (i % 10 == 0) {
+ buf[0] = '\n';
+ ret = write(fd, buf, strlen(buf));
+ ASSERT(ret >= 0);
+ }
+ snprintf(buf, BUF_SZ, "[%3d: %6x]", i,
+ le32_to_cpu(sum_blk.entries[i].nid));
+ ret = write(fd, buf, strlen(buf));
+ ASSERT(ret >= 0);
+ }
+ }
+ close(fd);
+}
+
+static void dump_data_blk(__u64 offset, u32 blkaddr)
+{
+ char buf[F2FS_BLKSIZE];
+
+ if (blkaddr == NULL_ADDR)
+ return;
+
+ /* get data */
+ if (blkaddr == NEW_ADDR) {
+ memset(buf, 0, F2FS_BLKSIZE);
+ } else {
+ int ret;
+ ret = dev_read_block(buf, blkaddr);
+ ASSERT(ret >= 0);
+ }
+
+ /* write blkaddr */
+ dev_write_dump(buf, offset, F2FS_BLKSIZE);
+}
+
+static void dump_node_blk(struct f2fs_sb_info *sbi, int ntype,
+ u32 nid, u64 *ofs)
+{
+ struct node_info ni;
+ struct f2fs_node *node_blk;
+ u32 skip = 0;
+ u32 i, idx;
+
+ switch (ntype) {
+ case TYPE_DIRECT_NODE:
+ skip = idx = ADDRS_PER_BLOCK;
+ break;
+ case TYPE_INDIRECT_NODE:
+ idx = NIDS_PER_BLOCK;
+ skip = idx * ADDRS_PER_BLOCK;
+ break;
+ case TYPE_DOUBLE_INDIRECT_NODE:
+ skip = 0;
+ idx = NIDS_PER_BLOCK;
+ break;
+ }
+
+ if (nid == 0) {
+ *ofs += skip;
+ return;
+ }
+
+ get_node_info(sbi, nid, &ni);
+
+ node_blk = calloc(BLOCK_SZ, 1);
+ dev_read_block(node_blk, ni.blk_addr);
+
+ for (i = 0; i < idx; i++, (*ofs)++) {
+ switch (ntype) {
+ case TYPE_DIRECT_NODE:
+ dump_data_blk(*ofs * F2FS_BLKSIZE,
+ le32_to_cpu(node_blk->dn.addr[i]));
+ break;
+ case TYPE_INDIRECT_NODE:
+ dump_node_blk(sbi, TYPE_DIRECT_NODE,
+ le32_to_cpu(node_blk->in.nid[i]), ofs);
+ break;
+ case TYPE_DOUBLE_INDIRECT_NODE:
+ dump_node_blk(sbi, TYPE_INDIRECT_NODE,
+ le32_to_cpu(node_blk->in.nid[i]), ofs);
+ break;
+ }
+ }
+ free(node_blk);
+}
+
+static void dump_inode_blk(struct f2fs_sb_info *sbi, u32 nid,
+ struct f2fs_node *node_blk)
+{
+ u32 i = 0;
+ u64 ofs = 0;
+
+ /* TODO: need to dump xattr */
+
+ if((node_blk->i.i_inline & F2FS_INLINE_DATA)){
+ DBG(3, "ino[0x%x] has inline data!\n", nid);
+ /* recover from inline data */
+ dev_write_dump(((unsigned char *)node_blk) + INLINE_DATA_OFFSET,
+ 0, MAX_INLINE_DATA);
+ return;
+ }
+
+ /* check data blocks in inode */
+ for (i = 0; i < ADDRS_PER_INODE(&node_blk->i); i++, ofs++)
+ dump_data_blk(ofs * F2FS_BLKSIZE,
+ le32_to_cpu(node_blk->i.i_addr[i]));
+
+ /* check node blocks in inode */
+ for (i = 0; i < 5; i++) {
+ if (i == 0 || i == 1)
+ dump_node_blk(sbi, TYPE_DIRECT_NODE,
+ node_blk->i.i_nid[i], &ofs);
+ else if (i == 2 || i == 3)
+ dump_node_blk(sbi, TYPE_INDIRECT_NODE,
+ node_blk->i.i_nid[i], &ofs);
+ else if (i == 4)
+ dump_node_blk(sbi, TYPE_DOUBLE_INDIRECT_NODE,
+ node_blk->i.i_nid[i], &ofs);
+ else
+ ASSERT(0);
+ }
+}
+
+void dump_file(struct f2fs_sb_info *sbi, struct node_info *ni,
+ struct f2fs_node *node_blk)
+{
+ struct f2fs_inode *inode = &node_blk->i;
+ u32 imode = le32_to_cpu(inode->i_mode);
+ char name[255] = {0};
+ char path[1024] = {0};
+ char ans[255] = {0};
+ int ret;
+
+ if (!S_ISREG(imode)) {
+ MSG(0, "Not a regular file\n\n");
+ return;
+ }
+
+ printf("Do you want to dump this file into ./lost_found/? [Y/N] ");
+ ret = scanf("%s", ans);
+ ASSERT(ret >= 0);
+
+ if (!strcasecmp(ans, "y")) {
+ ret = system("mkdir -p ./lost_found");
+ ASSERT(ret >= 0);
+
+ /* make a file */
+ strncpy(name, (const char *)inode->i_name,
+ le32_to_cpu(inode->i_namelen));
+ name[le32_to_cpu(inode->i_namelen)] = 0;
+ sprintf(path, "./lost_found/%s", name);
+
+ config.dump_fd = open(path, O_TRUNC|O_CREAT|O_RDWR, 0666);
+ ASSERT(config.dump_fd >= 0);
+
+ /* dump file's data */
+ dump_inode_blk(sbi, ni->ino, node_blk);
+
+ /* adjust file size */
+ ret = ftruncate(config.dump_fd, le32_to_cpu(inode->i_size));
+ ASSERT(ret >= 0);
+
+ close(config.dump_fd);
+ }
+}
+
+void dump_node(struct f2fs_sb_info *sbi, nid_t nid)
+{
+ struct node_info ni;
+ struct f2fs_node *node_blk;
+
+ get_node_info(sbi, nid, &ni);
+
+ node_blk = calloc(BLOCK_SZ, 1);
+ dev_read_block(node_blk, ni.blk_addr);
+
+ DBG(1, "Node ID [0x%x]\n", nid);
+ DBG(1, "nat_entry.block_addr [0x%x]\n", ni.blk_addr);
+ DBG(1, "nat_entry.version [0x%x]\n", ni.version);
+ DBG(1, "nat_entry.ino [0x%x]\n", ni.ino);
+
+ if (ni.blk_addr == 0x0)
+ MSG(0, "Invalid nat entry\n\n");
+
+ DBG(1, "node_blk.footer.ino [0x%x]\n", le32_to_cpu(node_blk->footer.ino));
+ DBG(1, "node_blk.footer.nid [0x%x]\n", le32_to_cpu(node_blk->footer.nid));
+
+ if (le32_to_cpu(node_blk->footer.ino) == ni.ino &&
+ le32_to_cpu(node_blk->footer.nid) == ni.nid) {
+ print_node_info(node_blk);
+ dump_file(sbi, &ni, node_blk);
+ } else {
+ MSG(0, "Invalid node block\n\n");
+ }
+
+ free(node_blk);
+}
+
+static void dump_node_from_blkaddr(u32 blk_addr)
+{
+ struct f2fs_node *node_blk;
+ int ret;
+
+ node_blk = calloc(BLOCK_SZ, 1);
+ ASSERT(node_blk);
+
+ ret = dev_read_block(node_blk, blk_addr);
+ ASSERT(ret >= 0);
+
+ if (config.dbg_lv > 0)
+ print_node_info(node_blk);
+ else
+ print_inode_info(&node_blk->i, 1);
+
+ free(node_blk);
+}
+
+static void dump_data_offset(u32 blk_addr, int ofs_in_node)
+{
+ struct f2fs_node *node_blk;
+ unsigned int indirect_blks = 2 * NIDS_PER_BLOCK + 4;
+ unsigned int bidx = 0;
+ unsigned int node_ofs;
+ int ret;
+
+ node_blk = calloc(BLOCK_SZ, 1);
+ ASSERT(node_blk);
+
+ ret = dev_read_block(node_blk, blk_addr);
+ ASSERT(ret >= 0);
+
+ node_ofs = ofs_of_node(node_blk);
+
+ if (node_ofs == 0)
+ goto got_it;
+
+ if (node_ofs > 0 && node_ofs <= 2) {
+ bidx = node_ofs - 1;
+ } else if (node_ofs <= indirect_blks) {
+ int dec = (node_ofs - 4) / (NIDS_PER_BLOCK + 1);
+ bidx = node_ofs - 2 - dec;
+ } else {
+ int dec = (node_ofs - indirect_blks - 3) / (NIDS_PER_BLOCK + 1);
+ bidx = node_ofs - 5 - dec;
+ }
+ bidx = bidx * ADDRS_PER_BLOCK + ADDRS_PER_INODE(&node_blk->i);
+got_it:
+ bidx += ofs_in_node;
+
+ setlocale(LC_ALL, "");
+ MSG(0, " - Data offset : 0x%x (4KB), %'u (bytes)\n",
+ bidx, bidx * 4096);
+ free(node_blk);
+}
+
+static void dump_node_offset(u32 blk_addr)
+{
+ struct f2fs_node *node_blk;
+ int ret;
+
+ node_blk = calloc(BLOCK_SZ, 1);
+ ASSERT(node_blk);
+
+ ret = dev_read_block(node_blk, blk_addr);
+ ASSERT(ret >= 0);
+
+ MSG(0, " - Node offset : 0x%x\n", ofs_of_node(node_blk));
+ free(node_blk);
+}
+
+int dump_info_from_blkaddr(struct f2fs_sb_info *sbi, u32 blk_addr)
+{
+ nid_t nid;
+ int type;
+ struct f2fs_summary sum_entry;
+ struct node_info ni, ino_ni;
+ int ret = 0;
+
+ MSG(0, "\n== Dump data from block address ==\n\n");
+
+ if (blk_addr < SM_I(sbi)->seg0_blkaddr) {
+ MSG(0, "\nFS Reserved Area for SEG #0: ");
+ ret = -EINVAL;
+ } else if (blk_addr < SIT_I(sbi)->sit_base_addr) {
+ MSG(0, "\nFS Metadata Area: ");
+ ret = -EINVAL;
+ } else if (blk_addr < NM_I(sbi)->nat_blkaddr) {
+ MSG(0, "\nFS SIT Area: ");
+ ret = -EINVAL;
+ } else if (blk_addr < SM_I(sbi)->ssa_blkaddr) {
+ MSG(0, "\nFS NAT Area: ");
+ ret = -EINVAL;
+ } else if (blk_addr < SM_I(sbi)->main_blkaddr) {
+ MSG(0, "\nFS SSA Area: ");
+ ret = -EINVAL;
+ } else if (blk_addr > __end_block_addr(sbi)) {
+ MSG(0, "\nOut of address space: ");
+ ret = -EINVAL;
+ }
+
+ if (ret) {
+ MSG(0, "User data is from 0x%x to 0x%x\n\n",
+ SM_I(sbi)->main_blkaddr,
+ __end_block_addr(sbi));
+ return ret;
+ }
+
+ type = get_sum_entry(sbi, blk_addr, &sum_entry);
+ nid = le32_to_cpu(sum_entry.nid);
+
+ get_node_info(sbi, nid, &ni);
+
+ DBG(1, "Note: blkaddr = main_blkaddr + segno * 512 + offset\n");
+ DBG(1, "Block_addr [0x%x]\n", blk_addr);
+ DBG(1, " - Segno [0x%x]\n", GET_SEGNO(sbi, blk_addr));
+ DBG(1, " - Offset [0x%x]\n", OFFSET_IN_SEG(sbi, blk_addr));
+ DBG(1, "SUM.nid [0x%x]\n", nid);
+ DBG(1, "SUM.type [%s]\n", seg_type_name[type]);
+ DBG(1, "SUM.version [%d]\n", sum_entry.version);
+ DBG(1, "SUM.ofs_in_node [0x%x]\n", sum_entry.ofs_in_node);
+ DBG(1, "NAT.blkaddr [0x%x]\n", ni.blk_addr);
+ DBG(1, "NAT.ino [0x%x]\n", ni.ino);
+
+ get_node_info(sbi, ni.ino, &ino_ni);
+
+ /* inode block address */
+ if (ni.blk_addr == NULL_ADDR || ino_ni.blk_addr == NULL_ADDR) {
+ MSG(0, "FS Userdata Area: Obsolete block from 0x%x\n",
+ blk_addr);
+ return -EINVAL;
+ }
+
+ /* print inode */
+ if (config.dbg_lv > 0)
+ dump_node_from_blkaddr(ino_ni.blk_addr);
+
+ if (type == SEG_TYPE_CUR_DATA || type == SEG_TYPE_DATA) {
+ MSG(0, "FS Userdata Area: Data block from 0x%x\n", blk_addr);
+ MSG(0, " - Direct node block : id = 0x%x from 0x%x\n",
+ nid, ni.blk_addr);
+ MSG(0, " - Inode block : id = 0x%x from 0x%x\n",
+ ni.ino, ino_ni.blk_addr);
+ dump_node_from_blkaddr(ino_ni.blk_addr);
+ dump_data_offset(ni.blk_addr,
+ le16_to_cpu(sum_entry.ofs_in_node));
+ } else {
+ MSG(0, "FS Userdata Area: Node block from 0x%x\n", blk_addr);
+ if (ni.ino == ni.nid) {
+ MSG(0, " - Inode block : id = 0x%x from 0x%x\n",
+ ni.ino, ino_ni.blk_addr);
+ dump_node_from_blkaddr(ino_ni.blk_addr);
+ } else {
+ MSG(0, " - Node block : id = 0x%x from 0x%x\n",
+ nid, ni.blk_addr);
+ MSG(0, " - Inode block : id = 0x%x from 0x%x\n",
+ ni.ino, ino_ni.blk_addr);
+ dump_node_from_blkaddr(ino_ni.blk_addr);
+ dump_node_offset(ni.blk_addr);
+ }
+ }
+
+ return 0;
+}
diff --git a/f2fs-tools/fsck/f2fs.h b/f2fs-tools/fsck/f2fs.h
new file mode 100644
index 0000000..c268f15
--- /dev/null
+++ b/f2fs-tools/fsck/f2fs.h
@@ -0,0 +1,387 @@
+/**
+ * f2fs.h
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef _F2FS_H_
+#define _F2FS_H_
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+#include <errno.h>
+#include <mntent.h>
+#include <linux/types.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/mount.h>
+#include <assert.h>
+
+#include <f2fs_fs.h>
+
+#define EXIT_ERR_CODE (-1)
+#define ver_after(a, b) (typecheck(unsigned long long, a) && \
+ typecheck(unsigned long long, b) && \
+ ((long long)((a) - (b)) > 0))
+
+struct list_head {
+ struct list_head *next, *prev;
+};
+
+enum {
+ NAT_BITMAP,
+ SIT_BITMAP
+};
+
+struct node_info {
+ nid_t nid;
+ nid_t ino;
+ u32 blk_addr;
+ unsigned char version;
+};
+
+struct f2fs_nm_info {
+ block_t nat_blkaddr;
+ nid_t max_nid;
+ nid_t init_scan_nid;
+ nid_t next_scan_nid;
+
+ unsigned int nat_cnt;
+ unsigned int fcnt;
+
+ char *nat_bitmap;
+ int bitmap_size;
+};
+
+struct seg_entry {
+ unsigned short valid_blocks; /* # of valid blocks */
+ unsigned char *cur_valid_map; /* validity bitmap of blocks */
+ /*
+ * # of valid blocks and the validity bitmap stored in the the last
+ * checkpoint pack. This information is used by the SSR mode.
+ */
+ unsigned short ckpt_valid_blocks;
+ unsigned char *ckpt_valid_map;
+ unsigned char type; /* segment type like CURSEG_XXX_TYPE */
+ unsigned char orig_type; /* segment type like CURSEG_XXX_TYPE */
+ unsigned long long mtime; /* modification time of the segment */
+};
+
+struct sec_entry {
+ unsigned int valid_blocks; /* # of valid blocks in a section */
+};
+
+struct sit_info {
+
+ block_t sit_base_addr; /* start block address of SIT area */
+ block_t sit_blocks; /* # of blocks used by SIT area */
+ block_t written_valid_blocks; /* # of valid blocks in main area */
+ char *sit_bitmap; /* SIT bitmap pointer */
+ unsigned int bitmap_size; /* SIT bitmap size */
+
+ unsigned long *dirty_sentries_bitmap; /* bitmap for dirty sentries */
+ unsigned int dirty_sentries; /* # of dirty sentries */
+ unsigned int sents_per_block; /* # of SIT entries per block */
+ struct seg_entry *sentries; /* SIT segment-level cache */
+ struct sec_entry *sec_entries; /* SIT section-level cache */
+
+ unsigned long long elapsed_time; /* elapsed time after mount */
+ unsigned long long mounted_time; /* mount time */
+ unsigned long long min_mtime; /* min. modification time */
+ unsigned long long max_mtime; /* max. modification time */
+};
+
+struct curseg_info {
+ struct f2fs_summary_block *sum_blk; /* cached summary block */
+ unsigned char alloc_type; /* current allocation type */
+ unsigned int segno; /* current segment number */
+ unsigned short next_blkoff; /* next block offset to write */
+ unsigned int zone; /* current zone number */
+ unsigned int next_segno; /* preallocated segment */
+};
+
+struct f2fs_sm_info {
+ struct sit_info *sit_info;
+ struct curseg_info *curseg_array;
+
+ block_t seg0_blkaddr;
+ block_t main_blkaddr;
+ block_t ssa_blkaddr;
+
+ unsigned int segment_count;
+ unsigned int main_segments;
+ unsigned int reserved_segments;
+ unsigned int ovp_segments;
+};
+
+struct f2fs_sb_info {
+ struct f2fs_fsck *fsck;
+
+ struct f2fs_super_block *raw_super;
+ struct f2fs_nm_info *nm_info;
+ struct f2fs_sm_info *sm_info;
+ struct f2fs_checkpoint *ckpt;
+ int cur_cp;
+
+ struct list_head orphan_inode_list;
+ unsigned int n_orphans;
+
+ /* basic file system units */
+ unsigned int log_sectors_per_block; /* log2 sectors per block */
+ unsigned int log_blocksize; /* log2 block size */
+ unsigned int blocksize; /* block size */
+ unsigned int root_ino_num; /* root inode number*/
+ unsigned int node_ino_num; /* node inode number*/
+ unsigned int meta_ino_num; /* meta inode number*/
+ unsigned int log_blocks_per_seg; /* log2 blocks per segment */
+ unsigned int blocks_per_seg; /* blocks per segment */
+ unsigned int segs_per_sec; /* segments per section */
+ unsigned int secs_per_zone; /* sections per zone */
+ unsigned int total_sections; /* total section count */
+ unsigned int total_node_count; /* total node block count */
+ unsigned int total_valid_node_count; /* valid node block count */
+ unsigned int total_valid_inode_count; /* valid inode count */
+ int active_logs; /* # of active logs */
+
+ block_t user_block_count; /* # of user blocks */
+ block_t total_valid_block_count; /* # of valid blocks */
+ block_t alloc_valid_block_count; /* # of allocated blocks */
+ block_t last_valid_block_count; /* for recovery */
+ u32 s_next_generation; /* for NFS support */
+
+ unsigned int cur_victim_sec; /* current victim section num */
+
+};
+
+static inline struct f2fs_super_block *F2FS_RAW_SUPER(struct f2fs_sb_info *sbi)
+{
+ return (struct f2fs_super_block *)(sbi->raw_super);
+}
+
+static inline struct f2fs_checkpoint *F2FS_CKPT(struct f2fs_sb_info *sbi)
+{
+ return (struct f2fs_checkpoint *)(sbi->ckpt);
+}
+
+static inline struct f2fs_fsck *F2FS_FSCK(struct f2fs_sb_info *sbi)
+{
+ return (struct f2fs_fsck *)(sbi->fsck);
+}
+
+static inline struct f2fs_nm_info *NM_I(struct f2fs_sb_info *sbi)
+{
+ return (struct f2fs_nm_info *)(sbi->nm_info);
+}
+
+static inline struct f2fs_sm_info *SM_I(struct f2fs_sb_info *sbi)
+{
+ return (struct f2fs_sm_info *)(sbi->sm_info);
+}
+
+static inline struct sit_info *SIT_I(struct f2fs_sb_info *sbi)
+{
+ return (struct sit_info *)(SM_I(sbi)->sit_info);
+}
+
+static inline void *inline_data_addr(struct f2fs_node *node_blk)
+{
+ return (void *)&(node_blk->i.i_addr[1]);
+}
+
+static inline unsigned int ofs_of_node(struct f2fs_node *node_blk)
+{
+ unsigned flag = le32_to_cpu(node_blk->footer.flag);
+ return flag >> OFFSET_BIT_SHIFT;
+}
+
+static inline unsigned long __bitmap_size(struct f2fs_sb_info *sbi, int flag)
+{
+ struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
+
+ /* return NAT or SIT bitmap */
+ if (flag == NAT_BITMAP)
+ return le32_to_cpu(ckpt->nat_ver_bitmap_bytesize);
+ else if (flag == SIT_BITMAP)
+ return le32_to_cpu(ckpt->sit_ver_bitmap_bytesize);
+
+ return 0;
+}
+
+static inline void *__bitmap_ptr(struct f2fs_sb_info *sbi, int flag)
+{
+ struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
+ int offset;
+ if (le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload) > 0) {
+ if (flag == NAT_BITMAP)
+ return &ckpt->sit_nat_version_bitmap;
+ else
+ return ((char *)ckpt + F2FS_BLKSIZE);
+ } else {
+ offset = (flag == NAT_BITMAP) ?
+ le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
+ return &ckpt->sit_nat_version_bitmap + offset;
+ }
+}
+
+static inline bool is_set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
+{
+ unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
+ return ckpt_flags & f;
+}
+
+static inline block_t __start_cp_addr(struct f2fs_sb_info *sbi)
+{
+ block_t start_addr;
+ struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
+ unsigned long long ckpt_version = le64_to_cpu(ckpt->checkpoint_ver);
+
+ start_addr = le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_blkaddr);
+
+ /*
+ * odd numbered checkpoint should at cp segment 0
+ * and even segent must be at cp segment 1
+ */
+ if (!(ckpt_version & 1))
+ start_addr += sbi->blocks_per_seg;
+
+ return start_addr;
+}
+
+static inline block_t __start_sum_addr(struct f2fs_sb_info *sbi)
+{
+ return le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum);
+}
+
+static inline block_t __end_block_addr(struct f2fs_sb_info *sbi)
+{
+ block_t end = SM_I(sbi)->main_blkaddr;
+ return end + le64_to_cpu(F2FS_RAW_SUPER(sbi)->block_count);
+}
+
+#define GET_ZONENO_FROM_SEGNO(sbi, segno) \
+ ((segno / sbi->segs_per_sec) / sbi->secs_per_zone)
+
+#define IS_DATASEG(t) \
+ ((t == CURSEG_HOT_DATA) || (t == CURSEG_COLD_DATA) || \
+ (t == CURSEG_WARM_DATA))
+
+#define IS_NODESEG(t) \
+ ((t == CURSEG_HOT_NODE) || (t == CURSEG_COLD_NODE) || \
+ (t == CURSEG_WARM_NODE))
+
+#define GET_SUM_BLKADDR(sbi, segno) \
+ ((sbi->sm_info->ssa_blkaddr) + segno)
+
+#define GET_SEGOFF_FROM_SEG0(sbi, blk_addr) \
+ ((blk_addr) - SM_I(sbi)->seg0_blkaddr)
+
+#define GET_SEGNO_FROM_SEG0(sbi, blk_addr) \
+ (GET_SEGOFF_FROM_SEG0(sbi, blk_addr) >> sbi->log_blocks_per_seg)
+
+#define GET_BLKOFF_FROM_SEG0(sbi, blk_addr) \
+ (GET_SEGOFF_FROM_SEG0(sbi, blk_addr) & (sbi->blocks_per_seg - 1))
+
+#define FREE_I_START_SEGNO(sbi) \
+ GET_SEGNO_FROM_SEG0(sbi, SM_I(sbi)->main_blkaddr)
+#define GET_R2L_SEGNO(sbi, segno) (segno + FREE_I_START_SEGNO(sbi))
+
+#define START_BLOCK(sbi, segno) (SM_I(sbi)->main_blkaddr + \
+ (segno << sbi->log_blocks_per_seg))
+
+static inline struct curseg_info *CURSEG_I(struct f2fs_sb_info *sbi, int type)
+{
+ return (struct curseg_info *)(SM_I(sbi)->curseg_array + type);
+}
+
+static inline block_t start_sum_block(struct f2fs_sb_info *sbi)
+{
+ return __start_cp_addr(sbi) + le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_start_sum);
+}
+
+static inline block_t sum_blk_addr(struct f2fs_sb_info *sbi, int base, int type)
+{
+ return __start_cp_addr(sbi) + le32_to_cpu(F2FS_CKPT(sbi)->cp_pack_total_block_count)
+ - (base + 1) + type;
+}
+
+
+#define nats_in_cursum(sum) (le16_to_cpu(sum->n_nats))
+#define sits_in_cursum(sum) (le16_to_cpu(sum->n_sits))
+
+#define nat_in_journal(sum, i) (sum->nat_j.entries[i].ne)
+#define nid_in_journal(sum, i) (sum->nat_j.entries[i].nid)
+#define sit_in_journal(sum, i) (sum->sit_j.entries[i].se)
+#define segno_in_journal(sum, i) (sum->sit_j.entries[i].segno)
+
+#define SIT_ENTRY_OFFSET(sit_i, segno) \
+ (segno % sit_i->sents_per_block)
+#define SIT_BLOCK_OFFSET(sit_i, segno) \
+ (segno / SIT_ENTRY_PER_BLOCK)
+#define TOTAL_SEGS(sbi) (SM_I(sbi)->main_segments)
+
+static inline bool IS_VALID_NID(struct f2fs_sb_info *sbi, u32 nid)
+{
+ return (nid <= (NAT_ENTRY_PER_BLOCK *
+ F2FS_RAW_SUPER(sbi)->segment_count_nat
+ << (sbi->log_blocks_per_seg - 1)));
+}
+
+static inline bool IS_VALID_BLK_ADDR(struct f2fs_sb_info *sbi, u32 addr)
+{
+ int i;
+
+ if (addr >= F2FS_RAW_SUPER(sbi)->block_count ||
+ addr < SM_I(sbi)->main_blkaddr) {
+ ASSERT_MSG("block addr [0x%x]\n", addr);
+ return 0;
+ }
+
+ for (i = 0; i < NO_CHECK_TYPE; i++) {
+ struct curseg_info *curseg = CURSEG_I(sbi, i);
+
+ if (START_BLOCK(sbi, curseg->segno) +
+ curseg->next_blkoff == addr)
+ return 0;
+ }
+ return 1;
+}
+
+static inline u64 BLKOFF_FROM_MAIN(struct f2fs_sb_info *sbi, u64 blk_addr)
+{
+ ASSERT(blk_addr >= SM_I(sbi)->main_blkaddr);
+ return blk_addr - SM_I(sbi)->main_blkaddr;
+}
+
+static inline u32 GET_SEGNO(struct f2fs_sb_info *sbi, u64 blk_addr)
+{
+ return (u32)(BLKOFF_FROM_MAIN(sbi, blk_addr)
+ >> sbi->log_blocks_per_seg);
+}
+
+static inline u32 OFFSET_IN_SEG(struct f2fs_sb_info *sbi, u64 blk_addr)
+{
+ return (u32)(BLKOFF_FROM_MAIN(sbi, blk_addr)
+ % (1 << sbi->log_blocks_per_seg));
+}
+
+static inline void node_info_from_raw_nat(struct node_info *ni,
+ struct f2fs_nat_entry *raw_nat)
+{
+ ni->ino = le32_to_cpu(raw_nat->ino);
+ ni->blk_addr = le32_to_cpu(raw_nat->block_addr);
+ ni->version = raw_nat->version;
+}
+
+extern int lookup_nat_in_journal(struct f2fs_sb_info *sbi, u32 nid, struct f2fs_nat_entry *ne);
+#define IS_SUM_NODE_SEG(footer) (footer.entry_type == SUM_TYPE_NODE)
+
+#endif /* _F2FS_H_ */
diff --git a/f2fs-tools/fsck/fsck.c b/f2fs-tools/fsck/fsck.c
new file mode 100644
index 0000000..1b27ae0
--- /dev/null
+++ b/f2fs-tools/fsck/fsck.c
@@ -0,0 +1,1210 @@
+/**
+ * fsck.c
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include "fsck.h"
+
+char *tree_mark;
+uint32_t tree_mark_size = 256;
+
+static inline int f2fs_set_main_bitmap(struct f2fs_sb_info *sbi, u32 blk,
+ int type)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ struct seg_entry *se;
+
+ se = get_seg_entry(sbi, GET_SEGNO(sbi, blk));
+ if (se->type != type) {
+ if (type == CURSEG_WARM_DATA) {
+ if (se->type != CURSEG_COLD_DATA) {
+ DBG(1, "Wrong segment type [0x%x] %x -> %x",
+ GET_SEGNO(sbi, blk), se->type,
+ CURSEG_WARM_DATA);
+ se->type = CURSEG_WARM_DATA;
+ }
+ } else {
+ DBG(1, "Wrong segment type [0x%x] %x -> %x",
+ GET_SEGNO(sbi, blk), se->type, type);
+ se->type = type;
+ }
+ }
+ return f2fs_set_bit(BLKOFF_FROM_MAIN(sbi, blk), fsck->main_area_bitmap);
+}
+
+static inline int f2fs_test_main_bitmap(struct f2fs_sb_info *sbi, u32 blk)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+
+ return f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, blk),
+ fsck->main_area_bitmap);
+}
+
+static inline int f2fs_test_sit_bitmap(struct f2fs_sb_info *sbi, u32 blk)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+
+ return f2fs_test_bit(BLKOFF_FROM_MAIN(sbi, blk), fsck->sit_area_bitmap);
+}
+
+static int add_into_hard_link_list(struct f2fs_sb_info *sbi,
+ u32 nid, u32 link_cnt)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ struct hard_link_node *node = NULL, *tmp = NULL, *prev = NULL;
+
+ node = calloc(sizeof(struct hard_link_node), 1);
+ ASSERT(node != NULL);
+
+ node->nid = nid;
+ node->links = link_cnt;
+ node->next = NULL;
+
+ if (fsck->hard_link_list_head == NULL) {
+ fsck->hard_link_list_head = node;
+ goto out;
+ }
+
+ tmp = fsck->hard_link_list_head;
+
+ /* Find insertion position */
+ while (tmp && (nid < tmp->nid)) {
+ ASSERT(tmp->nid != nid);
+ prev = tmp;
+ tmp = tmp->next;
+ }
+
+ if (tmp == fsck->hard_link_list_head) {
+ node->next = tmp;
+ fsck->hard_link_list_head = node;
+ } else {
+ prev->next = node;
+ node->next = tmp;
+ }
+
+out:
+ DBG(2, "ino[0x%x] has hard links [0x%x]\n", nid, link_cnt);
+ return 0;
+}
+
+static int find_and_dec_hard_link_list(struct f2fs_sb_info *sbi, u32 nid)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ struct hard_link_node *node = NULL, *prev = NULL;
+
+ if (fsck->hard_link_list_head == NULL)
+ return -EINVAL;
+
+ node = fsck->hard_link_list_head;
+
+ while (node && (nid < node->nid)) {
+ prev = node;
+ node = node->next;
+ }
+
+ if (node == NULL || (nid != node->nid))
+ return -EINVAL;
+
+ /* Decrease link count */
+ node->links = node->links - 1;
+
+ /* if link count becomes one, remove the node */
+ if (node->links == 1) {
+ if (fsck->hard_link_list_head == node)
+ fsck->hard_link_list_head = node->next;
+ else
+ prev->next = node->next;
+ free(node);
+ }
+ return 0;
+}
+
+static int is_valid_ssa_node_blk(struct f2fs_sb_info *sbi, u32 nid,
+ u32 blk_addr)
+{
+ int ret = 0;
+ struct f2fs_summary sum_entry;
+
+ ret = get_sum_entry(sbi, blk_addr, &sum_entry);
+
+ if (ret != SEG_TYPE_NODE && ret != SEG_TYPE_CUR_NODE) {
+ ASSERT_MSG("Summary footer is not for node segment");
+ return -EINVAL;
+ }
+
+ if (le32_to_cpu(sum_entry.nid) != nid) {
+ DBG(0, "nid [0x%x]\n", nid);
+ DBG(0, "target blk_addr [0x%x]\n", blk_addr);
+ DBG(0, "summary blk_addr [0x%x]\n",
+ GET_SUM_BLKADDR(sbi,
+ GET_SEGNO(sbi, blk_addr)));
+ DBG(0, "seg no / offset [0x%x / 0x%x]\n",
+ GET_SEGNO(sbi, blk_addr),
+ OFFSET_IN_SEG(sbi, blk_addr));
+ DBG(0, "summary_entry.nid [0x%x]\n",
+ le32_to_cpu(sum_entry.nid));
+ DBG(0, "--> node block's nid [0x%x]\n", nid);
+ ASSERT_MSG("Invalid node seg summary\n");
+ return -EINVAL;
+ }
+ return 0;
+}
+
+static int is_valid_ssa_data_blk(struct f2fs_sb_info *sbi, u32 blk_addr,
+ u32 parent_nid, u16 idx_in_node, u8 version)
+{
+ int ret = 0;
+ struct f2fs_summary sum_entry;
+
+ ret = get_sum_entry(sbi, blk_addr, &sum_entry);
+
+ if (ret != SEG_TYPE_DATA && ret != SEG_TYPE_CUR_DATA) {
+ ASSERT_MSG("Summary footer is not for data segment");
+ return -EINVAL;
+ }
+
+ if (le32_to_cpu(sum_entry.nid) != parent_nid ||
+ sum_entry.version != version ||
+ le16_to_cpu(sum_entry.ofs_in_node) != idx_in_node) {
+
+ DBG(0, "summary_entry.nid [0x%x]\n",
+ le32_to_cpu(sum_entry.nid));
+ DBG(0, "summary_entry.version [0x%x]\n",
+ sum_entry.version);
+ DBG(0, "summary_entry.ofs_in_node [0x%x]\n",
+ le16_to_cpu(sum_entry.ofs_in_node));
+ DBG(0, "parent nid [0x%x]\n", parent_nid);
+ DBG(0, "version from nat [0x%x]\n", version);
+ DBG(0, "idx in parent node [0x%x]\n", idx_in_node);
+
+ DBG(0, "Target data block addr [0x%x]\n", blk_addr);
+ ASSERT_MSG("Invalid data seg summary\n");
+ return -EINVAL;
+ }
+ return 0;
+}
+
+static int sanity_check_nid(struct f2fs_sb_info *sbi, u32 nid,
+ struct f2fs_node *node_blk,
+ enum FILE_TYPE ftype, enum NODE_TYPE ntype,
+ struct node_info *ni)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ int ret;
+
+ if (!IS_VALID_NID(sbi, nid)) {
+ ASSERT_MSG("nid is not valid. [0x%x]", nid);
+ return -EINVAL;
+ }
+
+ get_node_info(sbi, nid, ni);
+ if (ni->blk_addr == NEW_ADDR) {
+ ASSERT_MSG("nid is NEW_ADDR. [0x%x]", nid);
+ return -EINVAL;
+ }
+
+ if (!IS_VALID_BLK_ADDR(sbi, ni->blk_addr)) {
+ ASSERT_MSG("blkaddres is not valid. [0x%x]", ni->blk_addr);
+ return -EINVAL;
+ }
+
+ if (is_valid_ssa_node_blk(sbi, nid, ni->blk_addr)) {
+ ASSERT_MSG("summary node block is not valid. [0x%x]", nid);
+ return -EINVAL;
+ }
+
+ ret = dev_read_block(node_blk, ni->blk_addr);
+ ASSERT(ret >= 0);
+
+ if (ntype == TYPE_INODE &&
+ node_blk->footer.nid != node_blk->footer.ino) {
+ ASSERT_MSG("nid[0x%x] footer.nid[0x%x] footer.ino[0x%x]",
+ nid, le32_to_cpu(node_blk->footer.nid),
+ le32_to_cpu(node_blk->footer.ino));
+ return -EINVAL;
+ }
+ if (ntype != TYPE_INODE &&
+ node_blk->footer.nid == node_blk->footer.ino) {
+ ASSERT_MSG("nid[0x%x] footer.nid[0x%x] footer.ino[0x%x]",
+ nid, le32_to_cpu(node_blk->footer.nid),
+ le32_to_cpu(node_blk->footer.ino));
+ return -EINVAL;
+ }
+
+ if (le32_to_cpu(node_blk->footer.nid) != nid) {
+ ASSERT_MSG("nid[0x%x] blk_addr[0x%x] footer.nid[0x%x]",
+ nid, ni->blk_addr,
+ le32_to_cpu(node_blk->footer.nid));
+ return -EINVAL;
+ }
+
+ if (ntype == TYPE_XATTR) {
+ u32 flag = le32_to_cpu(node_blk->footer.flag);
+
+ if ((flag >> OFFSET_BIT_SHIFT) != XATTR_NODE_OFFSET) {
+ ASSERT_MSG("xnid[0x%x] has wrong ofs:[0x%x]",
+ nid, flag);
+ return -EINVAL;
+ }
+ }
+
+ if ((ntype == TYPE_INODE && ftype == F2FS_FT_DIR) ||
+ (ntype == TYPE_XATTR && ftype == F2FS_FT_XATTR)) {
+ /* not included '.' & '..' */
+ if (f2fs_test_main_bitmap(sbi, ni->blk_addr) != 0) {
+ ASSERT_MSG("Duplicated node blk. nid[0x%x][0x%x]\n",
+ nid, ni->blk_addr);
+ return -EINVAL;
+ }
+ }
+
+ /* workaround to fix later */
+ if (ftype != F2FS_FT_ORPHAN ||
+ f2fs_test_bit(nid, fsck->nat_area_bitmap) != 0)
+ f2fs_clear_bit(nid, fsck->nat_area_bitmap);
+ else
+ ASSERT_MSG("orphan or xattr nid is duplicated [0x%x]\n",
+ nid);
+
+ if (f2fs_test_sit_bitmap(sbi, ni->blk_addr) == 0)
+ ASSERT_MSG("SIT bitmap is 0x0. blk_addr[0x%x]",
+ ni->blk_addr);
+
+ if (f2fs_test_main_bitmap(sbi, ni->blk_addr) == 0) {
+ fsck->chk.valid_blk_cnt++;
+ fsck->chk.valid_node_cnt++;
+ }
+ return 0;
+}
+
+static int fsck_chk_xattr_blk(struct f2fs_sb_info *sbi, u32 ino,
+ u32 x_nid, u32 *blk_cnt)
+{
+ struct f2fs_node *node_blk = NULL;
+ struct node_info ni;
+ int ret = 0;
+
+ if (x_nid == 0x0)
+ return 0;
+
+ node_blk = (struct f2fs_node *)calloc(BLOCK_SZ, 1);
+ ASSERT(node_blk != NULL);
+
+ /* Sanity check */
+ if (sanity_check_nid(sbi, x_nid, node_blk,
+ F2FS_FT_XATTR, TYPE_XATTR, &ni)) {
+ ret = -EINVAL;
+ goto out;
+ }
+
+ *blk_cnt = *blk_cnt + 1;
+ f2fs_set_main_bitmap(sbi, ni.blk_addr, CURSEG_COLD_NODE);
+ DBG(2, "ino[0x%x] x_nid[0x%x]\n", ino, x_nid);
+out:
+ free(node_blk);
+ return ret;
+}
+
+int fsck_chk_node_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode,
+ u32 nid, enum FILE_TYPE ftype, enum NODE_TYPE ntype,
+ u32 *blk_cnt)
+{
+ struct node_info ni;
+ struct f2fs_node *node_blk = NULL;
+
+ node_blk = (struct f2fs_node *)calloc(BLOCK_SZ, 1);
+ ASSERT(node_blk != NULL);
+
+ if (sanity_check_nid(sbi, nid, node_blk, ftype, ntype, &ni))
+ goto err;
+
+ if (ntype == TYPE_INODE) {
+ fsck_chk_inode_blk(sbi, nid, ftype, node_blk, blk_cnt, &ni);
+ } else {
+ switch (ntype) {
+ case TYPE_DIRECT_NODE:
+ f2fs_set_main_bitmap(sbi, ni.blk_addr,
+ CURSEG_WARM_NODE);
+ fsck_chk_dnode_blk(sbi, inode, nid, ftype, node_blk,
+ blk_cnt, &ni);
+ break;
+ case TYPE_INDIRECT_NODE:
+ f2fs_set_main_bitmap(sbi, ni.blk_addr,
+ CURSEG_COLD_NODE);
+ fsck_chk_idnode_blk(sbi, inode, ftype, node_blk,
+ blk_cnt);
+ break;
+ case TYPE_DOUBLE_INDIRECT_NODE:
+ f2fs_set_main_bitmap(sbi, ni.blk_addr,
+ CURSEG_COLD_NODE);
+ fsck_chk_didnode_blk(sbi, inode, ftype, node_blk,
+ blk_cnt);
+ break;
+ default:
+ ASSERT(0);
+ }
+ }
+ free(node_blk);
+ return 0;
+err:
+ free(node_blk);
+ return -EINVAL;
+}
+
+/* start with valid nid and blkaddr */
+void fsck_chk_inode_blk(struct f2fs_sb_info *sbi, u32 nid,
+ enum FILE_TYPE ftype, struct f2fs_node *node_blk,
+ u32 *blk_cnt, struct node_info *ni)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ u32 child_cnt = 0, child_files = 0;
+ enum NODE_TYPE ntype;
+ u32 i_links = le32_to_cpu(node_blk->i.i_links);
+ u64 i_blocks = le64_to_cpu(node_blk->i.i_blocks);
+ unsigned int idx = 0;
+ int need_fix = 0;
+ int ret;
+
+ if (f2fs_test_main_bitmap(sbi, ni->blk_addr) == 0)
+ fsck->chk.valid_inode_cnt++;
+
+ if (ftype == F2FS_FT_DIR) {
+ f2fs_set_main_bitmap(sbi, ni->blk_addr, CURSEG_HOT_NODE);
+ } else {
+ if (f2fs_test_main_bitmap(sbi, ni->blk_addr) == 0) {
+ f2fs_set_main_bitmap(sbi, ni->blk_addr,
+ CURSEG_WARM_NODE);
+ if (i_links > 1) {
+ /* First time. Create new hard link node */
+ add_into_hard_link_list(sbi, nid, i_links);
+ fsck->chk.multi_hard_link_files++;
+ }
+ } else {
+ DBG(3, "[0x%x] has hard links [0x%x]\n", nid, i_links);
+ if (find_and_dec_hard_link_list(sbi, nid)) {
+ ASSERT_MSG("[0x%x] needs more i_links=0x%x",
+ nid, i_links);
+ if (config.fix_on) {
+ node_blk->i.i_links =
+ cpu_to_le32(i_links + 1);
+ need_fix = 1;
+ FIX_MSG("File: 0x%x "
+ "i_links= 0x%x -> 0x%x",
+ nid, i_links, i_links + 1);
+ }
+ goto check;
+ }
+ /* No need to go deep into the node */
+ return;
+ }
+ }
+
+ if (fsck_chk_xattr_blk(sbi, nid,
+ le32_to_cpu(node_blk->i.i_xattr_nid), blk_cnt) &&
+ config.fix_on) {
+ node_blk->i.i_xattr_nid = 0;
+ need_fix = 1;
+ FIX_MSG("Remove xattr block: 0x%x, x_nid = 0x%x",
+ nid, le32_to_cpu(node_blk->i.i_xattr_nid));
+ }
+
+ if (ftype == F2FS_FT_CHRDEV || ftype == F2FS_FT_BLKDEV ||
+ ftype == F2FS_FT_FIFO || ftype == F2FS_FT_SOCK)
+ goto check;
+
+ if((node_blk->i.i_inline & F2FS_INLINE_DATA)) {
+ if (le32_to_cpu(node_blk->i.i_addr[0]) != 0) {
+ /* should fix this bug all the time */
+ FIX_MSG("inline_data has wrong 0'th block = %x",
+ le32_to_cpu(node_blk->i.i_addr[0]));
+ node_blk->i.i_addr[0] = 0;
+ node_blk->i.i_blocks = cpu_to_le64(*blk_cnt);
+ need_fix = 1;
+ }
+ if (!(node_blk->i.i_inline & F2FS_DATA_EXIST)) {
+ char buf[MAX_INLINE_DATA];
+ memset(buf, 0, MAX_INLINE_DATA);
+
+ if (memcmp(buf, &node_blk->i.i_addr[1],
+ MAX_INLINE_DATA)) {
+ FIX_MSG("inline_data has DATA_EXIST");
+ node_blk->i.i_inline |= F2FS_DATA_EXIST;
+ need_fix = 1;
+ }
+ }
+ DBG(3, "ino[0x%x] has inline data!\n", nid);
+ goto check;
+ }
+ if((node_blk->i.i_inline & F2FS_INLINE_DENTRY)) {
+ DBG(3, "ino[0x%x] has inline dentry!\n", nid);
+ ret = fsck_chk_inline_dentries(sbi, node_blk,
+ &child_cnt, &child_files);
+ if (ret < 0) {
+ /* should fix this bug all the time */
+ need_fix = 1;
+ }
+ goto check;
+ }
+
+ /* readahead node blocks */
+ for (idx = 0; idx < 5; idx++) {
+ u32 nid = le32_to_cpu(node_blk->i.i_nid[idx]);
+
+ if (nid != 0) {
+ struct node_info ni;
+
+ get_node_info(sbi, nid, &ni);
+ if (IS_VALID_BLK_ADDR(sbi, ni.blk_addr))
+ dev_reada_block(ni.blk_addr);
+ }
+ }
+
+ /* check data blocks in inode */
+ for (idx = 0; idx < ADDRS_PER_INODE(&node_blk->i); idx++) {
+ if (le32_to_cpu(node_blk->i.i_addr[idx]) != 0) {
+ ret = fsck_chk_data_blk(sbi,
+ le32_to_cpu(node_blk->i.i_addr[idx]),
+ &child_cnt, &child_files,
+ (i_blocks == *blk_cnt),
+ ftype, nid, idx, ni->version);
+ if (!ret) {
+ *blk_cnt = *blk_cnt + 1;
+ } else if (config.fix_on) {
+ node_blk->i.i_addr[idx] = 0;
+ need_fix = 1;
+ FIX_MSG("[0x%x] i_addr[%d] = 0", nid, idx);
+ }
+ }
+ }
+
+ /* check node blocks in inode */
+ for (idx = 0; idx < 5; idx++) {
+ if (idx == 0 || idx == 1)
+ ntype = TYPE_DIRECT_NODE;
+ else if (idx == 2 || idx == 3)
+ ntype = TYPE_INDIRECT_NODE;
+ else if (idx == 4)
+ ntype = TYPE_DOUBLE_INDIRECT_NODE;
+ else
+ ASSERT(0);
+
+ if (le32_to_cpu(node_blk->i.i_nid[idx]) != 0) {
+ ret = fsck_chk_node_blk(sbi, &node_blk->i,
+ le32_to_cpu(node_blk->i.i_nid[idx]),
+ ftype, ntype, blk_cnt);
+ if (!ret) {
+ *blk_cnt = *blk_cnt + 1;
+ } else if (config.fix_on) {
+ node_blk->i.i_nid[idx] = 0;
+ need_fix = 1;
+ FIX_MSG("[0x%x] i_nid[%d] = 0", nid, idx);
+ }
+ }
+ }
+check:
+ if (ftype == F2FS_FT_DIR)
+ DBG(1, "Directory Inode: 0x%x [%s] depth: %d has %d files\n\n",
+ le32_to_cpu(node_blk->footer.ino),
+ node_blk->i.i_name,
+ le32_to_cpu(node_blk->i.i_current_depth),
+ child_files);
+ if (ftype == F2FS_FT_ORPHAN)
+ DBG(1, "Orphan Inode: 0x%x [%s] i_blocks: %u\n\n",
+ le32_to_cpu(node_blk->footer.ino),
+ node_blk->i.i_name,
+ (u32)i_blocks);
+
+ if (i_blocks != *blk_cnt) {
+ ASSERT_MSG("ino: 0x%x has i_blocks: %08"PRIx64", "
+ "but has %u blocks",
+ nid, i_blocks, *blk_cnt);
+ if (config.fix_on) {
+ node_blk->i.i_blocks = cpu_to_le64(*blk_cnt);
+ need_fix = 1;
+ FIX_MSG("[0x%x] i_blocks=0x%08"PRIx64" -> 0x%x",
+ nid, i_blocks, *blk_cnt);
+ }
+ }
+ if (ftype == F2FS_FT_DIR && i_links != child_cnt) {
+ ASSERT_MSG("ino: 0x%x has i_links: %u but real links: %u",
+ nid, i_links, child_cnt);
+ if (config.fix_on) {
+ node_blk->i.i_links = cpu_to_le32(child_cnt);
+ need_fix = 1;
+ FIX_MSG("Dir: 0x%x i_links= 0x%x -> 0x%x",
+ nid, i_links, child_cnt);
+ }
+ }
+
+ if (ftype == F2FS_FT_ORPHAN && i_links)
+ ASSERT_MSG("ino: 0x%x is orphan inode, but has i_links: %u",
+ nid, i_links);
+ if (need_fix) {
+ ret = dev_write_block(node_blk, ni->blk_addr);
+ ASSERT(ret >= 0);
+ }
+}
+
+int fsck_chk_dnode_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode,
+ u32 nid, enum FILE_TYPE ftype, struct f2fs_node *node_blk,
+ u32 *blk_cnt, struct node_info *ni)
+{
+ int idx, ret;
+ u32 child_cnt = 0, child_files = 0;
+ int need_fix = 0;
+
+ for (idx = 0; idx < ADDRS_PER_BLOCK; idx++) {
+ if (le32_to_cpu(node_blk->dn.addr[idx]) == 0x0)
+ continue;
+ ret = fsck_chk_data_blk(sbi,
+ le32_to_cpu(node_blk->dn.addr[idx]),
+ &child_cnt, &child_files,
+ le64_to_cpu(inode->i_blocks) == *blk_cnt, ftype,
+ nid, idx, ni->version);
+ if (!ret) {
+ *blk_cnt = *blk_cnt + 1;
+ } else if (config.fix_on) {
+ node_blk->dn.addr[idx] = 0;
+ need_fix = 1;
+ FIX_MSG("[0x%x] dn.addr[%d] = 0", nid, idx);
+ }
+ }
+ if (need_fix) {
+ ret = dev_write_block(node_blk, ni->blk_addr);
+ ASSERT(ret >= 0);
+ }
+ return 0;
+}
+
+int fsck_chk_idnode_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode,
+ enum FILE_TYPE ftype, struct f2fs_node *node_blk, u32 *blk_cnt)
+{
+ int ret;
+ int i = 0;
+
+ for (i = 0 ; i < NIDS_PER_BLOCK; i++) {
+ if (le32_to_cpu(node_blk->in.nid[i]) == 0x0)
+ continue;
+ ret = fsck_chk_node_blk(sbi, inode,
+ le32_to_cpu(node_blk->in.nid[i]),
+ ftype, TYPE_DIRECT_NODE, blk_cnt);
+ if (!ret)
+ *blk_cnt = *blk_cnt + 1;
+ else if (ret == -EINVAL)
+ printf("delete in.nid[i] = 0;\n");
+ }
+ return 0;
+}
+
+int fsck_chk_didnode_blk(struct f2fs_sb_info *sbi, struct f2fs_inode *inode,
+ enum FILE_TYPE ftype, struct f2fs_node *node_blk, u32 *blk_cnt)
+{
+ int i = 0;
+ int ret = 0;
+
+ for (i = 0; i < NIDS_PER_BLOCK; i++) {
+ if (le32_to_cpu(node_blk->in.nid[i]) == 0x0)
+ continue;
+ ret = fsck_chk_node_blk(sbi, inode,
+ le32_to_cpu(node_blk->in.nid[i]),
+ ftype, TYPE_INDIRECT_NODE, blk_cnt);
+ if (!ret)
+ *blk_cnt = *blk_cnt + 1;
+ else if (ret == -EINVAL)
+ printf("delete in.nid[i] = 0;\n");
+ }
+ return 0;
+}
+
+static void print_dentry(__u32 depth, __u8 *name,
+ unsigned long *bitmap,
+ struct f2fs_dir_entry *dentry,
+ int max, int idx, int last_blk)
+{
+ int last_de = 0;
+ int next_idx = 0;
+ int name_len;
+ unsigned int i;
+ int bit_offset;
+
+ if (config.dbg_lv != -1)
+ return;
+
+ name_len = le16_to_cpu(dentry[idx].name_len);
+ next_idx = idx + (name_len + F2FS_SLOT_LEN - 1) / F2FS_SLOT_LEN;
+
+ bit_offset = find_next_bit(bitmap, max, next_idx);
+ if (bit_offset >= max && last_blk)
+ last_de = 1;
+
+ if (tree_mark_size <= depth) {
+ tree_mark_size *= 2;
+ tree_mark = realloc(tree_mark, tree_mark_size);
+ }
+
+ if (last_de)
+ tree_mark[depth] = '`';
+ else
+ tree_mark[depth] = '|';
+
+ if (tree_mark[depth - 1] == '`')
+ tree_mark[depth - 1] = ' ';
+
+
+ for (i = 1; i < depth; i++)
+ printf("%c ", tree_mark[i]);
+ printf("%c-- %s 0x%x\n", last_de ? '`' : '|',
+ name, le32_to_cpu(dentry[idx].ino));
+}
+
+static int __chk_dentries(struct f2fs_sb_info *sbi, u32 *child_cnt,
+ u32* child_files,
+ unsigned long *bitmap,
+ struct f2fs_dir_entry *dentry,
+ __u8 (*filenames)[F2FS_SLOT_LEN],
+ int max, int last_blk)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ enum FILE_TYPE ftype;
+ int dentries = 0;
+ u32 blk_cnt;
+ u8 *name;
+ u32 hash_code, ino;
+ u16 name_len;;
+ int ret = 0;
+ int fixed = 0;
+ int i;
+
+ /* readahead inode blocks */
+ for (i = 0; i < max;) {
+ if (test_bit(i, bitmap) == 0) {
+ i++;
+ continue;
+ }
+ ino = le32_to_cpu(dentry[i].ino);
+
+ if (IS_VALID_NID(sbi, ino)) {
+ struct node_info ni;
+
+ get_node_info(sbi, ino, &ni);
+ if (IS_VALID_BLK_ADDR(sbi, ni.blk_addr))
+ dev_reada_block(ni.blk_addr);
+ }
+ name_len = le16_to_cpu(dentry[i].name_len);
+ i += (name_len + F2FS_SLOT_LEN - 1) / F2FS_SLOT_LEN;
+ }
+
+ for (i = 0; i < max;) {
+ if (test_bit(i, bitmap) == 0) {
+ i++;
+ continue;
+ }
+ if (!IS_VALID_NID(sbi, le32_to_cpu(dentry[i].ino))) {
+ DBG(1, "Bad dentry 0x%x with invalid NID/ino 0x%x",
+ i, le32_to_cpu(dentry[i].ino));
+ if (config.fix_on) {
+ FIX_MSG("Clear bad dentry 0x%x with bad ino 0x%x",
+ i, le32_to_cpu(dentry[i].ino));
+ clear_bit(i, bitmap);
+ i++;
+ fixed = 1;
+ continue;
+ }
+ }
+ ftype = dentry[i].file_type;
+ if ((ftype <= F2FS_FT_UNKNOWN || ftype > F2FS_FT_LAST_FILE_TYPE) && config.fix_on) {
+ DBG(1, "Bad dentry 0x%x with unexpected ftype 0x%x",
+ i, ftype);
+ if (config.fix_on) {
+ FIX_MSG("Clear bad dentry 0x%x with bad ftype 0x%x",
+ i, ftype);
+ clear_bit(i, bitmap);
+ i++;
+ fixed = 1;
+ continue;
+ }
+ }
+ name_len = le16_to_cpu(dentry[i].name_len);
+ name = calloc(name_len + 1, 1);
+ memcpy(name, filenames[i], name_len);
+ hash_code = f2fs_dentry_hash((const unsigned char *)name,
+ name_len);
+
+ /* fix hash_code made by old buggy code */
+ if (le32_to_cpu(dentry[i].hash_code) != hash_code) {
+ dentry[i].hash_code = hash_code;
+ fixed = 1;
+ FIX_MSG("hash_code[%d] of %s", i, name);
+ }
+
+ /* Becareful. 'dentry.file_type' is not imode. */
+ if (ftype == F2FS_FT_DIR) {
+ *child_cnt = *child_cnt + 1;
+ if ((name[0] == '.' && name_len == 1) ||
+ (name[0] == '.' && name[1] == '.' &&
+ name_len == 2)) {
+ i++;
+ free(name);
+ continue;
+ }
+ }
+
+ DBG(1, "[%3u]-[0x%x] name[%s] len[0x%x] ino[0x%x] type[0x%x]\n",
+ fsck->dentry_depth, i, name, name_len,
+ le32_to_cpu(dentry[i].ino),
+ dentry[i].file_type);
+
+ print_dentry(fsck->dentry_depth, name, bitmap,
+ dentry, max, i, last_blk);
+
+ blk_cnt = 1;
+ ret = fsck_chk_node_blk(sbi,
+ NULL, le32_to_cpu(dentry[i].ino),
+ ftype, TYPE_INODE, &blk_cnt);
+
+ if (ret && config.fix_on) {
+ int j;
+ int slots = (name_len + F2FS_SLOT_LEN - 1) /
+ F2FS_SLOT_LEN;
+ for (j = 0; j < slots; j++)
+ clear_bit(i + j, bitmap);
+ FIX_MSG("Unlink [0x%x] - %s len[0x%x], type[0x%x]",
+ le32_to_cpu(dentry[i].ino),
+ name, name_len,
+ dentry[i].file_type);
+ i += slots;
+ free(name);
+ fixed = 1;
+ continue;
+ }
+
+ i += (name_len + F2FS_SLOT_LEN - 1) / F2FS_SLOT_LEN;
+ dentries++;
+ *child_files = *child_files + 1;
+ free(name);
+ }
+ return fixed ? -1 : dentries;
+}
+
+int fsck_chk_inline_dentries(struct f2fs_sb_info *sbi,
+ struct f2fs_node *node_blk, u32 *child_cnt, u32 *child_files)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ struct f2fs_inline_dentry *de_blk;
+ int dentries;
+
+ de_blk = inline_data_addr(node_blk);
+ ASSERT(de_blk != NULL);
+
+ fsck->dentry_depth++;
+ dentries = __chk_dentries(sbi, child_cnt, child_files,
+ (unsigned long *)de_blk->dentry_bitmap,
+ de_blk->dentry, de_blk->filename,
+ NR_INLINE_DENTRY, 1);
+ if (dentries < 0) {
+ DBG(1, "[%3d] Inline Dentry Block Fixed hash_codes\n\n",
+ fsck->dentry_depth);
+ } else {
+ DBG(1, "[%3d] Inline Dentry Block Done : "
+ "dentries:%d in %d slots (len:%d)\n\n",
+ fsck->dentry_depth, dentries,
+ (int)NR_INLINE_DENTRY, F2FS_NAME_LEN);
+ }
+ fsck->dentry_depth--;
+ return dentries;
+}
+
+int fsck_chk_dentry_blk(struct f2fs_sb_info *sbi, u32 blk_addr,
+ u32 *child_cnt, u32 *child_files, int last_blk)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ struct f2fs_dentry_block *de_blk;
+ int dentries, ret;
+
+ de_blk = (struct f2fs_dentry_block *)calloc(BLOCK_SZ, 1);
+ ASSERT(de_blk != NULL);
+
+ ret = dev_read_block(de_blk, blk_addr);
+ ASSERT(ret >= 0);
+
+ fsck->dentry_depth++;
+ dentries = __chk_dentries(sbi, child_cnt, child_files,
+ (unsigned long *)de_blk->dentry_bitmap,
+ de_blk->dentry, de_blk->filename,
+ NR_DENTRY_IN_BLOCK, last_blk);
+
+ if (dentries < 0) {
+ ret = dev_write_block(de_blk, blk_addr);
+ ASSERT(ret >= 0);
+ DBG(1, "[%3d] Dentry Block [0x%x] Fixed hash_codes\n\n",
+ fsck->dentry_depth, blk_addr);
+ } else {
+ DBG(1, "[%3d] Dentry Block [0x%x] Done : "
+ "dentries:%d in %d slots (len:%d)\n\n",
+ fsck->dentry_depth, blk_addr, dentries,
+ NR_DENTRY_IN_BLOCK, F2FS_NAME_LEN);
+ }
+ fsck->dentry_depth--;
+ free(de_blk);
+ return 0;
+}
+
+int fsck_chk_data_blk(struct f2fs_sb_info *sbi, u32 blk_addr,
+ u32 *child_cnt, u32 *child_files, int last_blk,
+ enum FILE_TYPE ftype, u32 parent_nid, u16 idx_in_node, u8 ver)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+
+ /* Is it reserved block? */
+ if (blk_addr == NEW_ADDR) {
+ fsck->chk.valid_blk_cnt++;
+ return 0;
+ }
+
+ if (!IS_VALID_BLK_ADDR(sbi, blk_addr)) {
+ ASSERT_MSG("blkaddres is not valid. [0x%x]", blk_addr);
+ return -EINVAL;
+ }
+
+ if (is_valid_ssa_data_blk(sbi, blk_addr, parent_nid,
+ idx_in_node, ver)) {
+ ASSERT_MSG("summary data block is not valid. [0x%x]",
+ parent_nid);
+ return -EINVAL;
+ }
+
+ if (f2fs_test_sit_bitmap(sbi, blk_addr) == 0)
+ ASSERT_MSG("SIT bitmap is 0x0. blk_addr[0x%x]", blk_addr);
+
+ if (f2fs_test_main_bitmap(sbi, blk_addr) != 0)
+ ASSERT_MSG("Duplicated data [0x%x]. pnid[0x%x] idx[0x%x]",
+ blk_addr, parent_nid, idx_in_node);
+
+
+ fsck->chk.valid_blk_cnt++;
+
+ if (ftype == F2FS_FT_DIR) {
+ f2fs_set_main_bitmap(sbi, blk_addr, CURSEG_HOT_DATA);
+ return fsck_chk_dentry_blk(sbi, blk_addr, child_cnt,
+ child_files, last_blk);
+ } else {
+ f2fs_set_main_bitmap(sbi, blk_addr, CURSEG_WARM_DATA);
+ }
+ return 0;
+}
+
+void fsck_chk_orphan_node(struct f2fs_sb_info *sbi)
+{
+ u32 blk_cnt = 0;
+ block_t start_blk, orphan_blkaddr, i, j;
+ struct f2fs_orphan_block *orphan_blk;
+ struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
+
+ if (!is_set_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG))
+ return;
+
+ start_blk = __start_cp_addr(sbi) + 1 +
+ le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);
+ orphan_blkaddr = __start_sum_addr(sbi) - 1;
+ orphan_blk = calloc(BLOCK_SZ, 1);
+
+ for (i = 0; i < orphan_blkaddr; i++) {
+ int ret = dev_read_block(orphan_blk, start_blk + i);
+
+ ASSERT(ret >= 0);
+
+ for (j = 0; j < le32_to_cpu(orphan_blk->entry_count); j++) {
+ nid_t ino = le32_to_cpu(orphan_blk->ino[j]);
+ DBG(1, "[%3d] ino [0x%x]\n", i, ino);
+ if (config.fix_on) {
+ FIX_MSG("Discard orphan inodes: ino [0x%x]",
+ ino);
+ continue;
+ }
+ blk_cnt = 1;
+ fsck_chk_node_blk(sbi, NULL, ino,
+ F2FS_FT_ORPHAN, TYPE_INODE, &blk_cnt);
+ }
+ memset(orphan_blk, 0, BLOCK_SZ);
+ }
+ free(orphan_blk);
+}
+
+void fsck_init(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ struct f2fs_sm_info *sm_i = SM_I(sbi);
+
+ /*
+ * We build three bitmap for main/sit/nat so that may check consistency
+ * of filesystem.
+ * 1. main_area_bitmap will be used to check whether all blocks of main
+ * area is used or not.
+ * 2. nat_area_bitmap has bitmap information of used nid in NAT.
+ * 3. sit_area_bitmap has bitmap information of used main block.
+ * At Last sequence, we compare main_area_bitmap with sit_area_bitmap.
+ */
+ fsck->nr_main_blks = sm_i->main_segments << sbi->log_blocks_per_seg;
+ fsck->main_area_bitmap_sz = (fsck->nr_main_blks + 7) / 8;
+ fsck->main_area_bitmap = calloc(fsck->main_area_bitmap_sz, 1);
+ ASSERT(fsck->main_area_bitmap != NULL);
+
+ build_nat_area_bitmap(sbi);
+
+ build_sit_area_bitmap(sbi);
+
+ tree_mark = calloc(tree_mark_size, 1);
+ ASSERT(tree_mark != NULL);
+}
+
+static void fix_nat_entries(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ u32 i;
+
+ for (i = 0; i < fsck->nr_nat_entries; i++)
+ if (f2fs_test_bit(i, fsck->nat_area_bitmap) != 0)
+ nullify_nat_entry(sbi, i);
+}
+
+static void fix_checkpoint(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ struct f2fs_super_block *raw_sb = sbi->raw_super;
+ struct f2fs_checkpoint *ckp = F2FS_CKPT(sbi);
+ unsigned long long cp_blk_no;
+ u32 i;
+ int ret;
+ u_int32_t crc = 0;
+
+ ckp->ckpt_flags = cpu_to_le32(CP_UMOUNT_FLAG);
+ ckp->cp_pack_total_block_count =
+ cpu_to_le32(8 + le32_to_cpu(raw_sb->cp_payload));
+ ckp->cp_pack_start_sum = cpu_to_le32(1 +
+ le32_to_cpu(raw_sb->cp_payload));
+
+ ckp->free_segment_count = cpu_to_le32(fsck->chk.free_segs);
+ ckp->valid_block_count = cpu_to_le32(fsck->chk.valid_blk_cnt);
+ ckp->valid_node_count = cpu_to_le32(fsck->chk.valid_node_cnt);
+ ckp->valid_inode_count = cpu_to_le32(fsck->chk.valid_inode_cnt);
+
+ crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, ckp, CHECKSUM_OFFSET);
+ *((__le32 *)((unsigned char *)ckp + CHECKSUM_OFFSET)) =
+ cpu_to_le32(crc);
+
+ cp_blk_no = le32_to_cpu(raw_sb->cp_blkaddr);
+ if (sbi->cur_cp == 2)
+ cp_blk_no += 1 << le32_to_cpu(raw_sb->log_blocks_per_seg);
+
+ ret = dev_write_block(ckp, cp_blk_no++);
+ ASSERT(ret >= 0);
+
+ for (i = 0; i < le32_to_cpu(raw_sb->cp_payload); i++) {
+ ret = dev_write_block(((unsigned char *)ckp) + i * F2FS_BLKSIZE,
+ cp_blk_no++);
+ ASSERT(ret >= 0);
+ }
+
+ for (i = 0; i < NO_CHECK_TYPE; i++) {
+ struct curseg_info *curseg = CURSEG_I(sbi, i);
+
+ ret = dev_write_block(curseg->sum_blk, cp_blk_no++);
+ ASSERT(ret >= 0);
+ }
+
+ ret = dev_write_block(ckp, cp_blk_no++);
+ ASSERT(ret >= 0);
+}
+
+int check_curseg_offset(struct f2fs_sb_info *sbi)
+{
+ int i;
+
+ for (i = 0; i < NO_CHECK_TYPE; i++) {
+ struct curseg_info *curseg = CURSEG_I(sbi, i);
+ struct seg_entry *se;
+
+ se = get_seg_entry(sbi, curseg->segno);
+ if (f2fs_test_bit(curseg->next_blkoff,
+ (const char *)se->cur_valid_map) == 1) {
+ ASSERT_MSG("Next block offset is not free, type:%d", i);
+ return -EINVAL;
+ }
+ }
+ return 0;
+}
+
+int check_sit_types(struct f2fs_sb_info *sbi)
+{
+ unsigned int i;
+ int err = 0;
+
+ for (i = 0; i < TOTAL_SEGS(sbi); i++) {
+ struct seg_entry *se;
+
+ se = get_seg_entry(sbi, i);
+ if (se->orig_type != se->type) {
+ if (se->orig_type == CURSEG_COLD_DATA) {
+ se->type = se->orig_type;
+ } else {
+ FIX_MSG("Wrong segment type [0x%x] %x -> %x",
+ i, se->orig_type, se->type);
+ err = -EINVAL;
+ }
+ }
+ }
+ return err;
+}
+
+int fsck_verify(struct f2fs_sb_info *sbi)
+{
+ unsigned int i = 0;
+ int ret = 0;
+ int force = 0;
+ u32 nr_unref_nid = 0;
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ struct hard_link_node *node = NULL;
+
+ printf("\n");
+
+ for (i = 0; i < fsck->nr_nat_entries; i++) {
+ if (f2fs_test_bit(i, fsck->nat_area_bitmap) != 0) {
+ printf("NID[0x%x] is unreachable\n", i);
+ nr_unref_nid++;
+ }
+ }
+
+ if (fsck->hard_link_list_head != NULL) {
+ node = fsck->hard_link_list_head;
+ while (node) {
+ printf("NID[0x%x] has [0x%x] more unreachable links\n",
+ node->nid, node->links);
+ node = node->next;
+ }
+ config.bug_on = 1;
+ }
+
+ printf("[FSCK] Unreachable nat entries ");
+ if (nr_unref_nid == 0x0) {
+ printf(" [Ok..] [0x%x]\n", nr_unref_nid);
+ } else {
+ printf(" [Fail] [0x%x]\n", nr_unref_nid);
+ ret = EXIT_ERR_CODE;
+ config.bug_on = 1;
+ }
+
+ printf("[FSCK] SIT valid block bitmap checking ");
+ if (memcmp(fsck->sit_area_bitmap, fsck->main_area_bitmap,
+ fsck->sit_area_bitmap_sz) == 0x0) {
+ printf("[Ok..]\n");
+ } else {
+ printf("[Fail]\n");
+ ret = EXIT_ERR_CODE;
+ config.bug_on = 1;
+ }
+
+ printf("[FSCK] Hard link checking for regular file ");
+ if (fsck->hard_link_list_head == NULL) {
+ printf(" [Ok..] [0x%x]\n", fsck->chk.multi_hard_link_files);
+ } else {
+ printf(" [Fail] [0x%x]\n", fsck->chk.multi_hard_link_files);
+ ret = EXIT_ERR_CODE;
+ config.bug_on = 1;
+ }
+
+ printf("[FSCK] valid_block_count matching with CP ");
+ if (sbi->total_valid_block_count == fsck->chk.valid_blk_cnt) {
+ printf(" [Ok..] [0x%x]\n", (u32)fsck->chk.valid_blk_cnt);
+ } else {
+ printf(" [Fail] [0x%x]\n", (u32)fsck->chk.valid_blk_cnt);
+ ret = EXIT_ERR_CODE;
+ config.bug_on = 1;
+ }
+
+ printf("[FSCK] valid_node_count matcing with CP (de lookup) ");
+ if (sbi->total_valid_node_count == fsck->chk.valid_node_cnt) {
+ printf(" [Ok..] [0x%x]\n", fsck->chk.valid_node_cnt);
+ } else {
+ printf(" [Fail] [0x%x]\n", fsck->chk.valid_node_cnt);
+ ret = EXIT_ERR_CODE;
+ config.bug_on = 1;
+ }
+
+ printf("[FSCK] valid_node_count matcing with CP (nat lookup) ");
+ if (sbi->total_valid_node_count == fsck->chk.valid_nat_entry_cnt) {
+ printf(" [Ok..] [0x%x]\n", fsck->chk.valid_nat_entry_cnt);
+ } else {
+ printf(" [Fail] [0x%x]\n", fsck->chk.valid_nat_entry_cnt);
+ ret = EXIT_ERR_CODE;
+ config.bug_on = 1;
+ }
+
+ printf("[FSCK] valid_inode_count matched with CP ");
+ if (sbi->total_valid_inode_count == fsck->chk.valid_inode_cnt) {
+ printf(" [Ok..] [0x%x]\n", fsck->chk.valid_inode_cnt);
+ } else {
+ printf(" [Fail] [0x%x]\n", fsck->chk.valid_inode_cnt);
+ ret = EXIT_ERR_CODE;
+ config.bug_on = 1;
+ }
+
+ printf("[FSCK] free segment_count matched with CP ");
+ if (le32_to_cpu(F2FS_CKPT(sbi)->free_segment_count) ==
+ fsck->chk.sit_free_segs) {
+ printf(" [Ok..] [0x%x]\n", fsck->chk.sit_free_segs);
+ } else {
+ printf(" [Fail] [0x%x]\n", fsck->chk.sit_free_segs);
+ ret = EXIT_ERR_CODE;
+ config.bug_on = 1;
+ }
+
+ printf("[FSCK] next block offset is free ");
+ if (check_curseg_offset(sbi) == 0) {
+ printf(" [Ok..]\n");
+ } else {
+ printf(" [Fail]\n");
+ ret = EXIT_ERR_CODE;
+ config.bug_on = 1;
+ }
+
+ printf("[FSCK] fixing SIT types\n");
+ if (check_sit_types(sbi) != 0)
+ force = 1;
+
+ printf("[FSCK] other corrupted bugs ");
+ if (config.bug_on == 0) {
+ printf(" [Ok..]\n");
+ } else {
+ printf(" [Fail]\n");
+ ret = EXIT_ERR_CODE;
+ }
+
+ /* fix global metadata */
+ if (force || (config.bug_on && config.fix_on)) {
+ fix_nat_entries(sbi);
+ rewrite_sit_area_bitmap(sbi);
+ fix_checkpoint(sbi);
+ }
+ return ret;
+}
+
+void fsck_free(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ if (fsck->main_area_bitmap)
+ free(fsck->main_area_bitmap);
+
+ if (fsck->nat_area_bitmap)
+ free(fsck->nat_area_bitmap);
+
+ if (fsck->sit_area_bitmap)
+ free(fsck->sit_area_bitmap);
+
+ if (tree_mark)
+ free(tree_mark);
+}
diff --git a/f2fs-tools/fsck/fsck.h b/f2fs-tools/fsck/fsck.h
new file mode 100644
index 0000000..9cad013
--- /dev/null
+++ b/f2fs-tools/fsck/fsck.h
@@ -0,0 +1,131 @@
+/**
+ * fsck.h
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef _FSCK_H_
+#define _FSCK_H_
+
+#include "f2fs.h"
+
+/* fsck.c */
+struct orphan_info {
+ u32 nr_inodes;
+ u32 *ino_list;
+};
+
+struct f2fs_fsck {
+ struct f2fs_sb_info sbi;
+
+ struct orphan_info orphani;
+ struct chk_result {
+ u64 valid_blk_cnt;
+ u32 valid_nat_entry_cnt;
+ u32 valid_node_cnt;
+ u32 valid_inode_cnt;
+ u32 multi_hard_link_files;
+ u64 sit_valid_blocks;
+ u32 sit_free_segs;
+ u32 free_segs;
+ } chk;
+
+ struct hard_link_node *hard_link_list_head;
+
+ char *main_seg_usage;
+ char *main_area_bitmap;
+ char *nat_area_bitmap;
+ char *sit_area_bitmap;
+
+ u64 main_area_bitmap_sz;
+ u32 nat_area_bitmap_sz;
+ u32 sit_area_bitmap_sz;
+
+ u64 nr_main_blks;
+ u32 nr_nat_entries;
+
+ u32 dentry_depth;
+};
+
+#define BLOCK_SZ 4096
+struct block {
+ unsigned char buf[BLOCK_SZ];
+};
+
+enum NODE_TYPE {
+ TYPE_INODE = 37,
+ TYPE_DIRECT_NODE = 43,
+ TYPE_INDIRECT_NODE = 53,
+ TYPE_DOUBLE_INDIRECT_NODE = 67,
+ TYPE_XATTR = 77
+};
+
+struct hard_link_node {
+ u32 nid;
+ u32 links;
+ struct hard_link_node *next;
+};
+
+enum seg_type {
+ SEG_TYPE_DATA,
+ SEG_TYPE_CUR_DATA,
+ SEG_TYPE_NODE,
+ SEG_TYPE_CUR_NODE,
+ SEG_TYPE_MAX,
+};
+
+extern void fsck_chk_orphan_node(struct f2fs_sb_info *);
+extern int fsck_chk_node_blk(struct f2fs_sb_info *, struct f2fs_inode *, u32,
+ enum FILE_TYPE, enum NODE_TYPE, u32 *);
+extern void fsck_chk_inode_blk(struct f2fs_sb_info *, u32, enum FILE_TYPE,
+ struct f2fs_node *, u32 *, struct node_info *);
+extern int fsck_chk_dnode_blk(struct f2fs_sb_info *, struct f2fs_inode *,
+ u32, enum FILE_TYPE, struct f2fs_node *, u32 *,
+ struct node_info *);
+extern int fsck_chk_idnode_blk(struct f2fs_sb_info *, struct f2fs_inode *,
+ enum FILE_TYPE, struct f2fs_node *, u32 *);
+extern int fsck_chk_didnode_blk(struct f2fs_sb_info *, struct f2fs_inode *,
+ enum FILE_TYPE, struct f2fs_node *, u32 *);
+extern int fsck_chk_data_blk(struct f2fs_sb_info *sbi, u32, u32 *, u32 *,
+ int, enum FILE_TYPE, u32, u16, u8);
+extern int fsck_chk_dentry_blk(struct f2fs_sb_info *, u32, u32 *, u32 *, int);
+int fsck_chk_inline_dentries(struct f2fs_sb_info *, struct f2fs_node *,
+ u32 *, u32 *);
+
+extern void print_node_info(struct f2fs_node *);
+extern void print_inode_info(struct f2fs_inode *, int);
+extern struct seg_entry *get_seg_entry(struct f2fs_sb_info *, unsigned int);
+extern int get_sum_block(struct f2fs_sb_info *, unsigned int,
+ struct f2fs_summary_block *);
+extern int get_sum_entry(struct f2fs_sb_info *, u32, struct f2fs_summary *);
+extern void get_node_info(struct f2fs_sb_info *, nid_t, struct node_info *);
+extern void nullify_nat_entry(struct f2fs_sb_info *, u32);
+extern void rewrite_sit_area_bitmap(struct f2fs_sb_info *);
+extern void build_nat_area_bitmap(struct f2fs_sb_info *);
+extern void build_sit_area_bitmap(struct f2fs_sb_info *);
+extern void fsck_init(struct f2fs_sb_info *);
+extern int fsck_verify(struct f2fs_sb_info *);
+extern void fsck_free(struct f2fs_sb_info *);
+extern int f2fs_do_mount(struct f2fs_sb_info *);
+extern void f2fs_do_umount(struct f2fs_sb_info *);
+
+/* dump.c */
+struct dump_option {
+ nid_t nid;
+ int start_sit;
+ int end_sit;
+ int start_ssa;
+ int end_ssa;
+ int32_t blk_addr;
+};
+
+extern void sit_dump(struct f2fs_sb_info *, int, int);
+extern void ssa_dump(struct f2fs_sb_info *, int, int);
+extern void dump_node(struct f2fs_sb_info *, nid_t);
+extern int dump_info_from_blkaddr(struct f2fs_sb_info *, u32);
+
+#endif /* _FSCK_H_ */
diff --git a/f2fs-tools/fsck/main.c b/f2fs-tools/fsck/main.c
new file mode 100644
index 0000000..3606f62
--- /dev/null
+++ b/f2fs-tools/fsck/main.c
@@ -0,0 +1,261 @@
+/**
+ * main.c
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include "fsck.h"
+#include <libgen.h>
+
+struct f2fs_fsck gfsck;
+
+void fsck_usage()
+{
+ MSG(0, "\nUsage: fsck.f2fs [options] device\n");
+ MSG(0, "[options]:\n");
+ MSG(0, " -a check/fix potential corruption, reported by f2fs\n");
+ MSG(0, " -d debug level [default:0]\n");
+ MSG(0, " -f check/fix entire partition\n");
+ MSG(0, " -t show directory tree [-d -1]\n");
+ exit(1);
+}
+
+void dump_usage()
+{
+ MSG(0, "\nUsage: dump.f2fs [options] device\n");
+ MSG(0, "[options]:\n");
+ MSG(0, " -d debug level [default:0]\n");
+ MSG(0, " -i inode no (hex)\n");
+ MSG(0, " -s [SIT dump segno from #1~#2 (decimal), for all 0~-1]\n");
+ MSG(0, " -a [SSA dump segno from #1~#2 (decimal), for all 0~-1]\n");
+ MSG(0, " -b blk_addr (in 4KB)\n");
+
+ exit(1);
+}
+
+void f2fs_parse_options(int argc, char *argv[])
+{
+ int option = 0;
+ char *prog = basename(argv[0]);
+
+ if (!strcmp("fsck.f2fs", prog)) {
+ const char *option_string = "ad:ft";
+
+ config.func = FSCK;
+ while ((option = getopt(argc, argv, option_string)) != EOF) {
+ switch (option) {
+ case 'a':
+ config.auto_fix = 1;
+ MSG(0, "Info: Fix the reported corruption.\n");
+ break;
+ case 'd':
+ config.dbg_lv = atoi(optarg);
+ MSG(0, "Info: Debug level = %d\n",
+ config.dbg_lv);
+ break;
+ case 'f':
+ config.fix_on = 1;
+ MSG(0, "Info: Force to fix corruption\n");
+ break;
+ case 't':
+ config.dbg_lv = -1;
+ break;
+ default:
+ MSG(0, "\tError: Unknown option %c\n", option);
+ fsck_usage();
+ break;
+ }
+ }
+ } else if (!strcmp("dump.f2fs", prog)) {
+ const char *option_string = "d:i:s:a:b:";
+ static struct dump_option dump_opt = {
+ .nid = 3, /* default root ino */
+ .start_sit = -1,
+ .end_sit = -1,
+ .start_ssa = -1,
+ .end_ssa = -1,
+ .blk_addr = -1,
+ };
+
+ config.func = DUMP;
+ while ((option = getopt(argc, argv, option_string)) != EOF) {
+ int ret = 0;
+
+ switch (option) {
+ case 'd':
+ config.dbg_lv = atoi(optarg);
+ MSG(0, "Info: Debug level = %d\n",
+ config.dbg_lv);
+ break;
+ case 'i':
+ if (strncmp(optarg, "0x", 2))
+ ret = sscanf(optarg, "%d",
+ &dump_opt.nid);
+ else
+ ret = sscanf(optarg, "%x",
+ &dump_opt.nid);
+ break;
+ case 's':
+ ret = sscanf(optarg, "%d~%d",
+ &dump_opt.start_sit,
+ &dump_opt.end_sit);
+ break;
+ case 'a':
+ ret = sscanf(optarg, "%d~%d",
+ &dump_opt.start_ssa,
+ &dump_opt.end_ssa);
+ break;
+ case 'b':
+ if (strncmp(optarg, "0x", 2))
+ ret = sscanf(optarg, "%d",
+ &dump_opt.blk_addr);
+ else
+ ret = sscanf(optarg, "%x",
+ &dump_opt.blk_addr);
+ break;
+ default:
+ MSG(0, "\tError: Unknown option %c\n", option);
+ dump_usage();
+ break;
+ }
+ ASSERT(ret >= 0);
+ }
+
+ config.private = &dump_opt;
+ }
+
+ if ((optind + 1) != argc) {
+ MSG(0, "\tError: Device not specified\n");
+ if (config.func == FSCK)
+ fsck_usage();
+ else if (config.func == DUMP)
+ dump_usage();
+ }
+ config.device_name = argv[optind];
+}
+
+static void do_fsck(struct f2fs_sb_info *sbi)
+{
+ u32 blk_cnt;
+
+ fsck_init(sbi);
+
+ fsck_chk_orphan_node(sbi);
+
+ /* Traverse all block recursively from root inode */
+ blk_cnt = 1;
+ fsck_chk_node_blk(sbi, NULL, sbi->root_ino_num,
+ F2FS_FT_DIR, TYPE_INODE, &blk_cnt);
+ fsck_verify(sbi);
+ fsck_free(sbi);
+}
+
+static void do_dump(struct f2fs_sb_info *sbi)
+{
+ struct dump_option *opt = (struct dump_option *)config.private;
+ struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
+ u32 flag = le32_to_cpu(ckpt->ckpt_flags);
+
+ fsck_init(sbi);
+
+ if (opt->end_sit == -1)
+ opt->end_sit = SM_I(sbi)->main_segments;
+ if (opt->end_ssa == -1)
+ opt->end_ssa = SM_I(sbi)->main_segments;
+ if (opt->start_sit != -1)
+ sit_dump(sbi, opt->start_sit, opt->end_sit);
+ if (opt->start_ssa != -1)
+ ssa_dump(sbi, opt->start_ssa, opt->end_ssa);
+ if (opt->blk_addr != -1) {
+ dump_info_from_blkaddr(sbi, opt->blk_addr);
+ goto cleanup;
+ }
+
+ MSG(0, "Info: checkpoint state = %x : ", flag);
+ if (flag & CP_FSCK_FLAG)
+ MSG(0, "%s", " fsck");
+ if (flag & CP_ERROR_FLAG)
+ MSG(0, "%s", " error");
+ if (flag & CP_COMPACT_SUM_FLAG)
+ MSG(0, "%s", " compacted_summary");
+ if (flag & CP_ORPHAN_PRESENT_FLAG)
+ MSG(0, "%s", " orphan_inodes");
+ if (flag & CP_FASTBOOT_FLAG)
+ MSG(0, "%s", " fastboot");
+ if (flag & CP_UMOUNT_FLAG)
+ MSG(0, "%s", " unmount");
+ else
+ MSG(0, "%s", " sudden-power-off");
+ MSG(0, "\n");
+
+ dump_node(sbi, opt->nid);
+cleanup:
+ fsck_free(sbi);
+}
+
+int main(int argc, char **argv)
+{
+ struct f2fs_sb_info *sbi;
+ int ret = 0;
+
+ f2fs_init_configuration(&config);
+
+ f2fs_parse_options(argc, argv);
+
+ if (f2fs_dev_is_umounted(&config) < 0)
+ return -1;
+
+ /* Get device */
+ if (f2fs_get_device_info(&config) < 0)
+ return -1;
+fsck_again:
+ memset(&gfsck, 0, sizeof(gfsck));
+ gfsck.sbi.fsck = &gfsck;
+ sbi = &gfsck.sbi;
+
+ ret = f2fs_do_mount(sbi);
+ if (ret == 1) {
+ free(sbi->ckpt);
+ free(sbi->raw_super);
+ goto out;
+ } else if (ret < 0)
+ return -1;
+
+ switch (config.func) {
+ case FSCK:
+ do_fsck(sbi);
+ break;
+ case DUMP:
+ do_dump(sbi);
+ break;
+ }
+
+ f2fs_do_umount(sbi);
+out:
+ if (config.func == FSCK && config.bug_on) {
+ if (config.fix_on == 0 && config.auto_fix == 0) {
+ char ans[255] = {0};
+retry:
+ printf("Do you want to fix this partition? [Y/N] ");
+ ret = scanf("%s", ans);
+ ASSERT(ret >= 0);
+ if (!strcasecmp(ans, "y"))
+ config.fix_on = 1;
+ else if (!strcasecmp(ans, "n"))
+ config.fix_on = 0;
+ else
+ goto retry;
+
+ if (config.fix_on)
+ goto fsck_again;
+ }
+ }
+ f2fs_finalize_device(&config);
+
+ printf("\nDone.\n");
+ return 0;
+}
diff --git a/f2fs-tools/fsck/mount.c b/f2fs-tools/fsck/mount.c
new file mode 100644
index 0000000..6d96db8
--- /dev/null
+++ b/f2fs-tools/fsck/mount.c
@@ -0,0 +1,1326 @@
+/**
+ * mount.c
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#include "fsck.h"
+#include <locale.h>
+
+void print_inode_info(struct f2fs_inode *inode, int name)
+{
+ unsigned int i = 0;
+ int namelen = le32_to_cpu(inode->i_namelen);
+
+ if (name && namelen) {
+ inode->i_name[namelen] = '\0';
+ MSG(0, " - File name : %s\n", inode->i_name);
+ setlocale(LC_ALL, "");
+ MSG(0, " - File size : %'llu (bytes)\n",
+ le64_to_cpu(inode->i_size));
+ return;
+ }
+
+ DISP_u32(inode, i_mode);
+ DISP_u32(inode, i_uid);
+ DISP_u32(inode, i_gid);
+ DISP_u32(inode, i_links);
+ DISP_u64(inode, i_size);
+ DISP_u64(inode, i_blocks);
+
+ DISP_u64(inode, i_atime);
+ DISP_u32(inode, i_atime_nsec);
+ DISP_u64(inode, i_ctime);
+ DISP_u32(inode, i_ctime_nsec);
+ DISP_u64(inode, i_mtime);
+ DISP_u32(inode, i_mtime_nsec);
+
+ DISP_u32(inode, i_generation);
+ DISP_u32(inode, i_current_depth);
+ DISP_u32(inode, i_xattr_nid);
+ DISP_u32(inode, i_flags);
+ DISP_u32(inode, i_inline);
+ DISP_u32(inode, i_pino);
+
+ if (namelen) {
+ DISP_u32(inode, i_namelen);
+ inode->i_name[namelen] = '\0';
+ DISP_utf(inode, i_name);
+ }
+
+ printf("i_ext: fofs:%x blkaddr:%x len:%x\n",
+ inode->i_ext.fofs,
+ inode->i_ext.blk_addr,
+ inode->i_ext.len);
+
+ DISP_u32(inode, i_addr[0]); /* Pointers to data blocks */
+ DISP_u32(inode, i_addr[1]); /* Pointers to data blocks */
+ DISP_u32(inode, i_addr[2]); /* Pointers to data blocks */
+ DISP_u32(inode, i_addr[3]); /* Pointers to data blocks */
+
+ for (i = 4; i < ADDRS_PER_INODE(inode); i++) {
+ if (inode->i_addr[i] != 0x0) {
+ printf("i_addr[0x%x] points data block\r\t\t[0x%4x]\n",
+ i, inode->i_addr[i]);
+ break;
+ }
+ }
+
+ DISP_u32(inode, i_nid[0]); /* direct */
+ DISP_u32(inode, i_nid[1]); /* direct */
+ DISP_u32(inode, i_nid[2]); /* indirect */
+ DISP_u32(inode, i_nid[3]); /* indirect */
+ DISP_u32(inode, i_nid[4]); /* double indirect */
+
+ printf("\n");
+}
+
+void print_node_info(struct f2fs_node *node_block)
+{
+ nid_t ino = le32_to_cpu(node_block->footer.ino);
+ nid_t nid = le32_to_cpu(node_block->footer.nid);
+ /* Is this inode? */
+ if (ino == nid) {
+ DBG(0, "Node ID [0x%x:%u] is inode\n", nid, nid);
+ print_inode_info(&node_block->i, 0);
+ } else {
+ int i;
+ u32 *dump_blk = (u32 *)node_block;
+ DBG(0, "Node ID [0x%x:%u] is direct node or indirect node.\n",
+ nid, nid);
+ for (i = 0; i <= 10; i++)
+ MSG(0, "[%d]\t\t\t[0x%8x : %d]\n",
+ i, dump_blk[i], dump_blk[i]);
+ }
+}
+
+void print_raw_sb_info(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_super_block *sb = F2FS_RAW_SUPER(sbi);
+
+ if (!config.dbg_lv)
+ return;
+
+ printf("\n");
+ printf("+--------------------------------------------------------+\n");
+ printf("| Super block |\n");
+ printf("+--------------------------------------------------------+\n");
+
+ DISP_u32(sb, magic);
+ DISP_u32(sb, major_ver);
+ DISP_u32(sb, minor_ver);
+ DISP_u32(sb, log_sectorsize);
+ DISP_u32(sb, log_sectors_per_block);
+
+ DISP_u32(sb, log_blocksize);
+ DISP_u32(sb, log_blocks_per_seg);
+ DISP_u32(sb, segs_per_sec);
+ DISP_u32(sb, secs_per_zone);
+ DISP_u32(sb, checksum_offset);
+ DISP_u64(sb, block_count);
+
+ DISP_u32(sb, section_count);
+ DISP_u32(sb, segment_count);
+ DISP_u32(sb, segment_count_ckpt);
+ DISP_u32(sb, segment_count_sit);
+ DISP_u32(sb, segment_count_nat);
+
+ DISP_u32(sb, segment_count_ssa);
+ DISP_u32(sb, segment_count_main);
+ DISP_u32(sb, segment0_blkaddr);
+
+ DISP_u32(sb, cp_blkaddr);
+ DISP_u32(sb, sit_blkaddr);
+ DISP_u32(sb, nat_blkaddr);
+ DISP_u32(sb, ssa_blkaddr);
+ DISP_u32(sb, main_blkaddr);
+
+ DISP_u32(sb, root_ino);
+ DISP_u32(sb, node_ino);
+ DISP_u32(sb, meta_ino);
+ DISP_u32(sb, cp_payload);
+ DISP("%s", sb, version);
+ printf("\n");
+}
+
+void print_ckpt_info(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_checkpoint *cp = F2FS_CKPT(sbi);
+
+ if (!config.dbg_lv)
+ return;
+
+ printf("\n");
+ printf("+--------------------------------------------------------+\n");
+ printf("| Checkpoint |\n");
+ printf("+--------------------------------------------------------+\n");
+
+ DISP_u64(cp, checkpoint_ver);
+ DISP_u64(cp, user_block_count);
+ DISP_u64(cp, valid_block_count);
+ DISP_u32(cp, rsvd_segment_count);
+ DISP_u32(cp, overprov_segment_count);
+ DISP_u32(cp, free_segment_count);
+
+ DISP_u32(cp, alloc_type[CURSEG_HOT_NODE]);
+ DISP_u32(cp, alloc_type[CURSEG_WARM_NODE]);
+ DISP_u32(cp, alloc_type[CURSEG_COLD_NODE]);
+ DISP_u32(cp, cur_node_segno[0]);
+ DISP_u32(cp, cur_node_segno[1]);
+ DISP_u32(cp, cur_node_segno[2]);
+
+ DISP_u32(cp, cur_node_blkoff[0]);
+ DISP_u32(cp, cur_node_blkoff[1]);
+ DISP_u32(cp, cur_node_blkoff[2]);
+
+
+ DISP_u32(cp, alloc_type[CURSEG_HOT_DATA]);
+ DISP_u32(cp, alloc_type[CURSEG_WARM_DATA]);
+ DISP_u32(cp, alloc_type[CURSEG_COLD_DATA]);
+ DISP_u32(cp, cur_data_segno[0]);
+ DISP_u32(cp, cur_data_segno[1]);
+ DISP_u32(cp, cur_data_segno[2]);
+
+ DISP_u32(cp, cur_data_blkoff[0]);
+ DISP_u32(cp, cur_data_blkoff[1]);
+ DISP_u32(cp, cur_data_blkoff[2]);
+
+ DISP_u32(cp, ckpt_flags);
+ DISP_u32(cp, cp_pack_total_block_count);
+ DISP_u32(cp, cp_pack_start_sum);
+ DISP_u32(cp, valid_node_count);
+ DISP_u32(cp, valid_inode_count);
+ DISP_u32(cp, next_free_nid);
+ DISP_u32(cp, sit_ver_bitmap_bytesize);
+ DISP_u32(cp, nat_ver_bitmap_bytesize);
+ DISP_u32(cp, checksum_offset);
+ DISP_u64(cp, elapsed_time);
+
+ DISP_u32(cp, sit_nat_version_bitmap[0]);
+ printf("\n\n");
+}
+
+int sanity_check_raw_super(struct f2fs_super_block *raw_super)
+{
+ unsigned int blocksize;
+
+ if (F2FS_SUPER_MAGIC != le32_to_cpu(raw_super->magic)) {
+ return -1;
+ }
+
+ if (F2FS_BLKSIZE != PAGE_CACHE_SIZE) {
+ return -1;
+ }
+
+ blocksize = 1 << le32_to_cpu(raw_super->log_blocksize);
+ if (F2FS_BLKSIZE != blocksize) {
+ return -1;
+ }
+
+ if (le32_to_cpu(raw_super->log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE ||
+ le32_to_cpu(raw_super->log_sectorsize) <
+ F2FS_MIN_LOG_SECTOR_SIZE) {
+ return -1;
+ }
+
+ if (le32_to_cpu(raw_super->log_sectors_per_block) +
+ le32_to_cpu(raw_super->log_sectorsize) !=
+ F2FS_MAX_LOG_SECTOR_SIZE) {
+ return -1;
+ }
+
+ return 0;
+}
+
+int validate_super_block(struct f2fs_sb_info *sbi, int block)
+{
+ u64 offset;
+
+ sbi->raw_super = malloc(sizeof(struct f2fs_super_block));
+
+ if (block == 0)
+ offset = F2FS_SUPER_OFFSET;
+ else
+ offset = F2FS_BLKSIZE + F2FS_SUPER_OFFSET;
+
+ if (dev_read(sbi->raw_super, offset, sizeof(struct f2fs_super_block)))
+ return -1;
+
+ if (!sanity_check_raw_super(sbi->raw_super)) {
+ /* get kernel version */
+ if (config.kd >= 0) {
+ dev_read_version(config.version, 0, VERSION_LEN);
+ get_kernel_version(config.version);
+ } else {
+ memset(config.version, 0, VERSION_LEN);
+ }
+
+ /* build sb version */
+ memcpy(config.sb_version, sbi->raw_super->version, VERSION_LEN);
+ get_kernel_version(config.sb_version);
+ memcpy(config.init_version, sbi->raw_super->init_version, VERSION_LEN);
+ get_kernel_version(config.init_version);
+
+ MSG(0, "Info: MKFS version\n \"%s\"\n", config.init_version);
+ MSG(0, "Info: FSCK version\n from \"%s\"\n to \"%s\"\n",
+ config.sb_version, config.version);
+ if (memcmp(config.sb_version, config.version, VERSION_LEN)) {
+ int ret;
+
+ memcpy(sbi->raw_super->version,
+ config.version, VERSION_LEN);
+ ret = dev_write(sbi->raw_super, offset,
+ sizeof(struct f2fs_super_block));
+ ASSERT(ret >= 0);
+
+ config.auto_fix = 0;
+ config.fix_on = 1;
+ }
+ return 0;
+ }
+
+ free(sbi->raw_super);
+ MSG(0, "\tCan't find a valid F2FS superblock at 0x%x\n", block);
+
+ return -EINVAL;
+}
+
+int init_sb_info(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_super_block *raw_super = sbi->raw_super;
+
+ sbi->log_sectors_per_block =
+ le32_to_cpu(raw_super->log_sectors_per_block);
+ sbi->log_blocksize = le32_to_cpu(raw_super->log_blocksize);
+ sbi->blocksize = 1 << sbi->log_blocksize;
+ sbi->log_blocks_per_seg = le32_to_cpu(raw_super->log_blocks_per_seg);
+ sbi->blocks_per_seg = 1 << sbi->log_blocks_per_seg;
+ sbi->segs_per_sec = le32_to_cpu(raw_super->segs_per_sec);
+ sbi->secs_per_zone = le32_to_cpu(raw_super->secs_per_zone);
+ sbi->total_sections = le32_to_cpu(raw_super->section_count);
+ sbi->total_node_count =
+ (le32_to_cpu(raw_super->segment_count_nat) / 2)
+ * sbi->blocks_per_seg * NAT_ENTRY_PER_BLOCK;
+ sbi->root_ino_num = le32_to_cpu(raw_super->root_ino);
+ sbi->node_ino_num = le32_to_cpu(raw_super->node_ino);
+ sbi->meta_ino_num = le32_to_cpu(raw_super->meta_ino);
+ sbi->cur_victim_sec = NULL_SEGNO;
+ return 0;
+}
+
+void *validate_checkpoint(struct f2fs_sb_info *sbi, block_t cp_addr,
+ unsigned long long *version)
+{
+ void *cp_page_1, *cp_page_2;
+ struct f2fs_checkpoint *cp_block;
+ unsigned long blk_size = sbi->blocksize;
+ unsigned long long cur_version = 0, pre_version = 0;
+ unsigned int crc = 0;
+ size_t crc_offset;
+
+ /* Read the 1st cp block in this CP pack */
+ cp_page_1 = malloc(PAGE_SIZE);
+ if (dev_read_block(cp_page_1, cp_addr) < 0)
+ return NULL;
+
+ cp_block = (struct f2fs_checkpoint *)cp_page_1;
+ crc_offset = le32_to_cpu(cp_block->checksum_offset);
+ if (crc_offset >= blk_size)
+ goto invalid_cp1;
+
+ crc = *(unsigned int *)((unsigned char *)cp_block + crc_offset);
+ if (f2fs_crc_valid(crc, cp_block, crc_offset))
+ goto invalid_cp1;
+
+ pre_version = le64_to_cpu(cp_block->checkpoint_ver);
+
+ /* Read the 2nd cp block in this CP pack */
+ cp_page_2 = malloc(PAGE_SIZE);
+ cp_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1;
+
+ if (dev_read_block(cp_page_2, cp_addr) < 0)
+ goto invalid_cp2;
+
+ cp_block = (struct f2fs_checkpoint *)cp_page_2;
+ crc_offset = le32_to_cpu(cp_block->checksum_offset);
+ if (crc_offset >= blk_size)
+ goto invalid_cp2;
+
+ crc = *(unsigned int *)((unsigned char *)cp_block + crc_offset);
+ if (f2fs_crc_valid(crc, cp_block, crc_offset))
+ goto invalid_cp2;
+
+ cur_version = le64_to_cpu(cp_block->checkpoint_ver);
+
+ if (cur_version == pre_version) {
+ *version = cur_version;
+ free(cp_page_2);
+ return cp_page_1;
+ }
+
+invalid_cp2:
+ free(cp_page_2);
+invalid_cp1:
+ free(cp_page_1);
+ return NULL;
+}
+
+int get_valid_checkpoint(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_super_block *raw_sb = sbi->raw_super;
+ void *cp1, *cp2, *cur_page;
+ unsigned long blk_size = sbi->blocksize;
+ unsigned long long cp1_version = 0, cp2_version = 0;
+ unsigned long long cp_start_blk_no;
+ unsigned int cp_blks = 1 + le32_to_cpu(F2FS_RAW_SUPER(sbi)->cp_payload);
+ int ret;
+
+ sbi->ckpt = malloc(cp_blks * blk_size);
+ if (!sbi->ckpt)
+ return -ENOMEM;
+ /*
+ * Finding out valid cp block involves read both
+ * sets( cp pack1 and cp pack 2)
+ */
+ cp_start_blk_no = le32_to_cpu(raw_sb->cp_blkaddr);
+ cp1 = validate_checkpoint(sbi, cp_start_blk_no, &cp1_version);
+
+ /* The second checkpoint pack should start at the next segment */
+ cp_start_blk_no += 1 << le32_to_cpu(raw_sb->log_blocks_per_seg);
+ cp2 = validate_checkpoint(sbi, cp_start_blk_no, &cp2_version);
+
+ if (cp1 && cp2) {
+ if (ver_after(cp2_version, cp1_version)) {
+ cur_page = cp2;
+ sbi->cur_cp = 2;
+ } else {
+ cur_page = cp1;
+ sbi->cur_cp = 1;
+ }
+ } else if (cp1) {
+ cur_page = cp1;
+ sbi->cur_cp = 1;
+ } else if (cp2) {
+ cur_page = cp2;
+ sbi->cur_cp = 2;
+ } else {
+ free(cp1);
+ free(cp2);
+ goto fail_no_cp;
+ }
+
+ memcpy(sbi->ckpt, cur_page, blk_size);
+
+ if (cp_blks > 1) {
+ unsigned int i;
+ unsigned long long cp_blk_no;
+
+ cp_blk_no = le32_to_cpu(raw_sb->cp_blkaddr);
+ if (cur_page == cp2)
+ cp_blk_no += 1 <<
+ le32_to_cpu(raw_sb->log_blocks_per_seg);
+ /* copy sit bitmap */
+ for (i = 1; i < cp_blks; i++) {
+ unsigned char *ckpt = (unsigned char *)sbi->ckpt;
+ ret = dev_read_block(cur_page, cp_blk_no + i);
+ ASSERT(ret >= 0);
+ memcpy(ckpt + i * blk_size, cur_page, blk_size);
+ }
+ }
+ free(cp1);
+ free(cp2);
+ return 0;
+
+fail_no_cp:
+ free(sbi->ckpt);
+ return -EINVAL;
+}
+
+int sanity_check_ckpt(struct f2fs_sb_info *sbi)
+{
+ unsigned int total, fsmeta;
+ struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
+ struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
+
+ total = le32_to_cpu(raw_super->segment_count);
+ fsmeta = le32_to_cpu(raw_super->segment_count_ckpt);
+ fsmeta += le32_to_cpu(raw_super->segment_count_sit);
+ fsmeta += le32_to_cpu(raw_super->segment_count_nat);
+ fsmeta += le32_to_cpu(ckpt->rsvd_segment_count);
+ fsmeta += le32_to_cpu(raw_super->segment_count_ssa);
+
+ if (fsmeta >= total)
+ return 1;
+
+ return 0;
+}
+
+int init_node_manager(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_super_block *sb_raw = F2FS_RAW_SUPER(sbi);
+ struct f2fs_nm_info *nm_i = NM_I(sbi);
+ unsigned char *version_bitmap;
+ unsigned int nat_segs, nat_blocks;
+
+ nm_i->nat_blkaddr = le32_to_cpu(sb_raw->nat_blkaddr);
+
+ /* segment_count_nat includes pair segment so divide to 2. */
+ nat_segs = le32_to_cpu(sb_raw->segment_count_nat) >> 1;
+ nat_blocks = nat_segs << le32_to_cpu(sb_raw->log_blocks_per_seg);
+ nm_i->max_nid = NAT_ENTRY_PER_BLOCK * nat_blocks;
+ nm_i->fcnt = 0;
+ nm_i->nat_cnt = 0;
+ nm_i->init_scan_nid = le32_to_cpu(sbi->ckpt->next_free_nid);
+ nm_i->next_scan_nid = le32_to_cpu(sbi->ckpt->next_free_nid);
+
+ nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP);
+
+ nm_i->nat_bitmap = malloc(nm_i->bitmap_size);
+ if (!nm_i->nat_bitmap)
+ return -ENOMEM;
+ version_bitmap = __bitmap_ptr(sbi, NAT_BITMAP);
+ if (!version_bitmap)
+ return -EFAULT;
+
+ /* copy version bitmap */
+ memcpy(nm_i->nat_bitmap, version_bitmap, nm_i->bitmap_size);
+ return 0;
+}
+
+int build_node_manager(struct f2fs_sb_info *sbi)
+{
+ int err;
+ sbi->nm_info = malloc(sizeof(struct f2fs_nm_info));
+ if (!sbi->nm_info)
+ return -ENOMEM;
+
+ err = init_node_manager(sbi);
+ if (err)
+ return err;
+
+ return 0;
+}
+
+int build_sit_info(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_super_block *raw_sb = F2FS_RAW_SUPER(sbi);
+ struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
+ struct sit_info *sit_i;
+ unsigned int sit_segs, start;
+ char *src_bitmap, *dst_bitmap;
+ unsigned int bitmap_size;
+
+ sit_i = malloc(sizeof(struct sit_info));
+ if (!sit_i)
+ return -ENOMEM;
+
+ SM_I(sbi)->sit_info = sit_i;
+
+ sit_i->sentries = calloc(TOTAL_SEGS(sbi) * sizeof(struct seg_entry), 1);
+
+ for (start = 0; start < TOTAL_SEGS(sbi); start++) {
+ sit_i->sentries[start].cur_valid_map
+ = calloc(SIT_VBLOCK_MAP_SIZE, 1);
+ sit_i->sentries[start].ckpt_valid_map
+ = calloc(SIT_VBLOCK_MAP_SIZE, 1);
+ if (!sit_i->sentries[start].cur_valid_map
+ || !sit_i->sentries[start].ckpt_valid_map)
+ return -ENOMEM;
+ }
+
+ sit_segs = le32_to_cpu(raw_sb->segment_count_sit) >> 1;
+ bitmap_size = __bitmap_size(sbi, SIT_BITMAP);
+ src_bitmap = __bitmap_ptr(sbi, SIT_BITMAP);
+
+ dst_bitmap = malloc(bitmap_size);
+ memcpy(dst_bitmap, src_bitmap, bitmap_size);
+
+ sit_i->sit_base_addr = le32_to_cpu(raw_sb->sit_blkaddr);
+ sit_i->sit_blocks = sit_segs << sbi->log_blocks_per_seg;
+ sit_i->written_valid_blocks = le64_to_cpu(ckpt->valid_block_count);
+ sit_i->sit_bitmap = dst_bitmap;
+ sit_i->bitmap_size = bitmap_size;
+ sit_i->dirty_sentries = 0;
+ sit_i->sents_per_block = SIT_ENTRY_PER_BLOCK;
+ sit_i->elapsed_time = le64_to_cpu(ckpt->elapsed_time);
+ return 0;
+}
+
+void reset_curseg(struct f2fs_sb_info *sbi, int type)
+{
+ struct curseg_info *curseg = CURSEG_I(sbi, type);
+ struct summary_footer *sum_footer;
+ struct seg_entry *se;
+
+ sum_footer = &(curseg->sum_blk->footer);
+ memset(sum_footer, 0, sizeof(struct summary_footer));
+ if (IS_DATASEG(type))
+ SET_SUM_TYPE(sum_footer, SUM_TYPE_DATA);
+ if (IS_NODESEG(type))
+ SET_SUM_TYPE(sum_footer, SUM_TYPE_NODE);
+ se = get_seg_entry(sbi, curseg->segno);
+ se->type = type;
+}
+
+static void read_compacted_summaries(struct f2fs_sb_info *sbi)
+{
+ struct curseg_info *curseg;
+ unsigned int i, j, offset;
+ block_t start;
+ char *kaddr;
+ int ret;
+
+ start = start_sum_block(sbi);
+
+ kaddr = (char *)malloc(PAGE_SIZE);
+ ret = dev_read_block(kaddr, start++);
+ ASSERT(ret >= 0);
+
+ curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
+ memcpy(&curseg->sum_blk->n_nats, kaddr, SUM_JOURNAL_SIZE);
+
+ curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
+ memcpy(&curseg->sum_blk->n_sits, kaddr + SUM_JOURNAL_SIZE,
+ SUM_JOURNAL_SIZE);
+
+ offset = 2 * SUM_JOURNAL_SIZE;
+ for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_DATA; i++) {
+ unsigned short blk_off;
+ struct curseg_info *curseg = CURSEG_I(sbi, i);
+
+ reset_curseg(sbi, i);
+
+ if (curseg->alloc_type == SSR)
+ blk_off = sbi->blocks_per_seg;
+ else
+ blk_off = curseg->next_blkoff;
+
+ for (j = 0; j < blk_off; j++) {
+ struct f2fs_summary *s;
+ s = (struct f2fs_summary *)(kaddr + offset);
+ curseg->sum_blk->entries[j] = *s;
+ offset += SUMMARY_SIZE;
+ if (offset + SUMMARY_SIZE <=
+ PAGE_CACHE_SIZE - SUM_FOOTER_SIZE)
+ continue;
+ memset(kaddr, 0, PAGE_SIZE);
+ ret = dev_read_block(kaddr, start++);
+ ASSERT(ret >= 0);
+ offset = 0;
+ }
+ }
+ free(kaddr);
+}
+
+static void restore_node_summary(struct f2fs_sb_info *sbi,
+ unsigned int segno, struct f2fs_summary_block *sum_blk)
+{
+ struct f2fs_node *node_blk;
+ struct f2fs_summary *sum_entry;
+ block_t addr;
+ unsigned int i;
+ int ret;
+
+ node_blk = malloc(F2FS_BLKSIZE);
+ ASSERT(node_blk);
+
+ /* scan the node segment */
+ addr = START_BLOCK(sbi, segno);
+ sum_entry = &sum_blk->entries[0];
+
+ for (i = 0; i < sbi->blocks_per_seg; i++, sum_entry++) {
+ ret = dev_read_block(node_blk, addr);
+ ASSERT(ret >= 0);
+ sum_entry->nid = node_blk->footer.nid;
+ addr++;
+ }
+ free(node_blk);
+}
+
+static void read_normal_summaries(struct f2fs_sb_info *sbi, int type)
+{
+ struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
+ struct f2fs_summary_block *sum_blk;
+ struct curseg_info *curseg;
+ unsigned int segno = 0;
+ block_t blk_addr = 0;
+ int ret;
+
+ if (IS_DATASEG(type)) {
+ segno = le32_to_cpu(ckpt->cur_data_segno[type]);
+ if (is_set_ckpt_flags(ckpt, CP_UMOUNT_FLAG))
+ blk_addr = sum_blk_addr(sbi, NR_CURSEG_TYPE, type);
+ else
+ blk_addr = sum_blk_addr(sbi, NR_CURSEG_DATA_TYPE, type);
+ } else {
+ segno = le32_to_cpu(ckpt->cur_node_segno[type -
+ CURSEG_HOT_NODE]);
+ if (is_set_ckpt_flags(ckpt, CP_UMOUNT_FLAG))
+ blk_addr = sum_blk_addr(sbi, NR_CURSEG_NODE_TYPE,
+ type - CURSEG_HOT_NODE);
+ else
+ blk_addr = GET_SUM_BLKADDR(sbi, segno);
+ }
+
+ sum_blk = (struct f2fs_summary_block *)malloc(PAGE_SIZE);
+ ret = dev_read_block(sum_blk, blk_addr);
+ ASSERT(ret >= 0);
+
+ if (IS_NODESEG(type) && !is_set_ckpt_flags(ckpt, CP_UMOUNT_FLAG))
+ restore_node_summary(sbi, segno, sum_blk);
+
+ curseg = CURSEG_I(sbi, type);
+ memcpy(curseg->sum_blk, sum_blk, PAGE_CACHE_SIZE);
+ reset_curseg(sbi, type);
+ free(sum_blk);
+}
+
+static void restore_curseg_summaries(struct f2fs_sb_info *sbi)
+{
+ int type = CURSEG_HOT_DATA;
+
+ if (is_set_ckpt_flags(F2FS_CKPT(sbi), CP_COMPACT_SUM_FLAG)) {
+ read_compacted_summaries(sbi);
+ type = CURSEG_HOT_NODE;
+ }
+
+ for (; type <= CURSEG_COLD_NODE; type++)
+ read_normal_summaries(sbi, type);
+}
+
+static void build_curseg(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
+ struct curseg_info *array;
+ unsigned short blk_off;
+ unsigned int segno;
+ int i;
+
+ array = malloc(sizeof(*array) * NR_CURSEG_TYPE);
+ ASSERT(array);
+
+ SM_I(sbi)->curseg_array = array;
+
+ for (i = 0; i < NR_CURSEG_TYPE; i++) {
+ array[i].sum_blk = malloc(PAGE_CACHE_SIZE);
+ ASSERT(array[i].sum_blk);
+ if (i <= CURSEG_COLD_DATA) {
+ blk_off = le16_to_cpu(ckpt->cur_data_blkoff[i]);
+ segno = le32_to_cpu(ckpt->cur_data_segno[i]);
+ }
+ if (i > CURSEG_COLD_DATA) {
+ blk_off = le16_to_cpu(ckpt->cur_node_blkoff[i -
+ CURSEG_HOT_NODE]);
+ segno = le32_to_cpu(ckpt->cur_node_segno[i -
+ CURSEG_HOT_NODE]);
+ }
+ array[i].segno = segno;
+ array[i].zone = GET_ZONENO_FROM_SEGNO(sbi, segno);
+ array[i].next_segno = NULL_SEGNO;
+ array[i].next_blkoff = blk_off;
+ array[i].alloc_type = ckpt->alloc_type[i];
+ }
+ restore_curseg_summaries(sbi);
+}
+
+inline void check_seg_range(struct f2fs_sb_info *sbi, unsigned int segno)
+{
+ unsigned int end_segno = SM_I(sbi)->segment_count - 1;
+ ASSERT(segno <= end_segno);
+}
+
+static struct f2fs_sit_block *get_current_sit_page(struct f2fs_sb_info *sbi,
+ unsigned int segno)
+{
+ struct sit_info *sit_i = SIT_I(sbi);
+ unsigned int offset = SIT_BLOCK_OFFSET(sit_i, segno);
+ block_t blk_addr = sit_i->sit_base_addr + offset;
+ struct f2fs_sit_block *sit_blk = calloc(BLOCK_SZ, 1);
+ int ret;
+
+ check_seg_range(sbi, segno);
+
+ /* calculate sit block address */
+ if (f2fs_test_bit(offset, sit_i->sit_bitmap))
+ blk_addr += sit_i->sit_blocks;
+
+ ret = dev_read_block(sit_blk, blk_addr);
+ ASSERT(ret >= 0);
+
+ return sit_blk;
+}
+
+void rewrite_current_sit_page(struct f2fs_sb_info *sbi,
+ unsigned int segno, struct f2fs_sit_block *sit_blk)
+{
+ struct sit_info *sit_i = SIT_I(sbi);
+ unsigned int offset = SIT_BLOCK_OFFSET(sit_i, segno);
+ block_t blk_addr = sit_i->sit_base_addr + offset;
+ int ret;
+
+ /* calculate sit block address */
+ if (f2fs_test_bit(offset, sit_i->sit_bitmap))
+ blk_addr += sit_i->sit_blocks;
+
+ ret = dev_write_block(sit_blk, blk_addr);
+ ASSERT(ret >= 0);
+}
+
+void check_block_count(struct f2fs_sb_info *sbi,
+ unsigned int segno, struct f2fs_sit_entry *raw_sit)
+{
+ struct f2fs_sm_info *sm_info = SM_I(sbi);
+ unsigned int end_segno = sm_info->segment_count - 1;
+ int valid_blocks = 0;
+ unsigned int i;
+
+ /* check segment usage */
+ if (GET_SIT_VBLOCKS(raw_sit) > sbi->blocks_per_seg)
+ ASSERT_MSG("Invalid SIT vblocks: segno=0x%x, %u",
+ segno, GET_SIT_VBLOCKS(raw_sit));
+
+ /* check boundary of a given segment number */
+ if (segno > end_segno)
+ ASSERT_MSG("Invalid SEGNO: 0x%x", segno);
+
+ /* check bitmap with valid block count */
+ for (i = 0; i < SIT_VBLOCK_MAP_SIZE; i++)
+ valid_blocks += get_bits_in_byte(raw_sit->valid_map[i]);
+
+ if (GET_SIT_VBLOCKS(raw_sit) != valid_blocks)
+ ASSERT_MSG("Wrong SIT valid blocks: segno=0x%x, %u vs. %u",
+ segno, GET_SIT_VBLOCKS(raw_sit), valid_blocks);
+
+ if (GET_SIT_TYPE(raw_sit) >= NO_CHECK_TYPE)
+ ASSERT_MSG("Wrong SIT type: segno=0x%x, %u",
+ segno, GET_SIT_TYPE(raw_sit));
+}
+
+void seg_info_from_raw_sit(struct seg_entry *se,
+ struct f2fs_sit_entry *raw_sit)
+{
+ se->valid_blocks = GET_SIT_VBLOCKS(raw_sit);
+ se->ckpt_valid_blocks = GET_SIT_VBLOCKS(raw_sit);
+ memcpy(se->cur_valid_map, raw_sit->valid_map, SIT_VBLOCK_MAP_SIZE);
+ memcpy(se->ckpt_valid_map, raw_sit->valid_map, SIT_VBLOCK_MAP_SIZE);
+ se->type = GET_SIT_TYPE(raw_sit);
+ se->orig_type = GET_SIT_TYPE(raw_sit);
+ se->mtime = le64_to_cpu(raw_sit->mtime);
+}
+
+struct seg_entry *get_seg_entry(struct f2fs_sb_info *sbi,
+ unsigned int segno)
+{
+ struct sit_info *sit_i = SIT_I(sbi);
+ return &sit_i->sentries[segno];
+}
+
+int get_sum_block(struct f2fs_sb_info *sbi, unsigned int segno,
+ struct f2fs_summary_block *sum_blk)
+{
+ struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
+ struct curseg_info *curseg;
+ int type, ret;
+ u64 ssa_blk;
+
+ ssa_blk = GET_SUM_BLKADDR(sbi, segno);
+ for (type = 0; type < NR_CURSEG_NODE_TYPE; type++) {
+ if (segno == ckpt->cur_node_segno[type]) {
+ curseg = CURSEG_I(sbi, CURSEG_HOT_NODE + type);
+ if (!IS_SUM_NODE_SEG(curseg->sum_blk->footer)) {
+ ASSERT_MSG("segno [0x%x] indicates a data "
+ "segment, but should be node",
+ segno);
+ return -EINVAL;
+ }
+ memcpy(sum_blk, curseg->sum_blk, BLOCK_SZ);
+ return SEG_TYPE_CUR_NODE;
+ }
+ }
+
+ for (type = 0; type < NR_CURSEG_DATA_TYPE; type++) {
+ if (segno == ckpt->cur_data_segno[type]) {
+ curseg = CURSEG_I(sbi, type);
+ if (IS_SUM_NODE_SEG(curseg->sum_blk->footer)) {
+ ASSERT_MSG("segno [0x%x] indicates a node "
+ "segment, but should be data",
+ segno);
+ return -EINVAL;
+ }
+ DBG(2, "segno [0x%x] is current data seg[0x%x]\n",
+ segno, type);
+ memcpy(sum_blk, curseg->sum_blk, BLOCK_SZ);
+ return SEG_TYPE_CUR_DATA;
+ }
+ }
+
+ ret = dev_read_block(sum_blk, ssa_blk);
+ ASSERT(ret >= 0);
+
+ if (IS_SUM_NODE_SEG(sum_blk->footer))
+ return SEG_TYPE_NODE;
+ else
+ return SEG_TYPE_DATA;
+
+}
+
+int get_sum_entry(struct f2fs_sb_info *sbi, u32 blk_addr,
+ struct f2fs_summary *sum_entry)
+{
+ struct f2fs_summary_block *sum_blk;
+ u32 segno, offset;
+ int ret;
+
+ segno = GET_SEGNO(sbi, blk_addr);
+ offset = OFFSET_IN_SEG(sbi, blk_addr);
+
+ sum_blk = calloc(BLOCK_SZ, 1);
+
+ ret = get_sum_block(sbi, segno, sum_blk);
+ memcpy(sum_entry, &(sum_blk->entries[offset]),
+ sizeof(struct f2fs_summary));
+ free(sum_blk);
+ return ret;
+}
+
+static void get_nat_entry(struct f2fs_sb_info *sbi, nid_t nid,
+ struct f2fs_nat_entry *raw_nat)
+{
+ struct f2fs_nm_info *nm_i = NM_I(sbi);
+ struct f2fs_nat_block *nat_block;
+ pgoff_t block_off;
+ pgoff_t block_addr;
+ int seg_off, entry_off;
+ int ret;
+
+ if (lookup_nat_in_journal(sbi, nid, raw_nat) >= 0)
+ return;
+
+ nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1);
+
+ block_off = nid / NAT_ENTRY_PER_BLOCK;
+ entry_off = nid % NAT_ENTRY_PER_BLOCK;
+
+ seg_off = block_off >> sbi->log_blocks_per_seg;
+ block_addr = (pgoff_t)(nm_i->nat_blkaddr +
+ (seg_off << sbi->log_blocks_per_seg << 1) +
+ (block_off & ((1 << sbi->log_blocks_per_seg) - 1)));
+
+ if (f2fs_test_bit(block_off, nm_i->nat_bitmap))
+ block_addr += sbi->blocks_per_seg;
+
+ ret = dev_read_block(nat_block, block_addr);
+ ASSERT(ret >= 0);
+
+ memcpy(raw_nat, &nat_block->entries[entry_off],
+ sizeof(struct f2fs_nat_entry));
+ free(nat_block);
+}
+
+void get_node_info(struct f2fs_sb_info *sbi, nid_t nid, struct node_info *ni)
+{
+ struct f2fs_nat_entry raw_nat;
+ get_nat_entry(sbi, nid, &raw_nat);
+ ni->nid = nid;
+ node_info_from_raw_nat(ni, &raw_nat);
+}
+
+void build_sit_entries(struct f2fs_sb_info *sbi)
+{
+ struct sit_info *sit_i = SIT_I(sbi);
+ struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
+ struct f2fs_summary_block *sum = curseg->sum_blk;
+ unsigned int segno;
+
+ for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) {
+ struct seg_entry *se = &sit_i->sentries[segno];
+ struct f2fs_sit_block *sit_blk;
+ struct f2fs_sit_entry sit;
+ int i;
+
+ for (i = 0; i < sits_in_cursum(sum); i++) {
+ if (le32_to_cpu(segno_in_journal(sum, i)) == segno) {
+ sit = sit_in_journal(sum, i);
+ goto got_it;
+ }
+ }
+ sit_blk = get_current_sit_page(sbi, segno);
+ sit = sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, segno)];
+ free(sit_blk);
+got_it:
+ check_block_count(sbi, segno, &sit);
+ seg_info_from_raw_sit(se, &sit);
+ }
+
+}
+
+int build_segment_manager(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
+ struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
+ struct f2fs_sm_info *sm_info;
+
+ sm_info = malloc(sizeof(struct f2fs_sm_info));
+ if (!sm_info)
+ return -ENOMEM;
+
+ /* init sm info */
+ sbi->sm_info = sm_info;
+ sm_info->seg0_blkaddr = le32_to_cpu(raw_super->segment0_blkaddr);
+ sm_info->main_blkaddr = le32_to_cpu(raw_super->main_blkaddr);
+ sm_info->segment_count = le32_to_cpu(raw_super->segment_count);
+ sm_info->reserved_segments = le32_to_cpu(ckpt->rsvd_segment_count);
+ sm_info->ovp_segments = le32_to_cpu(ckpt->overprov_segment_count);
+ sm_info->main_segments = le32_to_cpu(raw_super->segment_count_main);
+ sm_info->ssa_blkaddr = le32_to_cpu(raw_super->ssa_blkaddr);
+
+ build_sit_info(sbi);
+
+ build_curseg(sbi);
+
+ build_sit_entries(sbi);
+
+ return 0;
+}
+
+void build_sit_area_bitmap(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ struct f2fs_sm_info *sm_i = SM_I(sbi);
+ unsigned int segno = 0;
+ char *ptr = NULL;
+ u32 sum_vblocks = 0;
+ u32 free_segs = 0;
+ struct seg_entry *se;
+
+ fsck->sit_area_bitmap_sz = sm_i->main_segments * SIT_VBLOCK_MAP_SIZE;
+ fsck->sit_area_bitmap = calloc(1, fsck->sit_area_bitmap_sz);
+ ptr = fsck->sit_area_bitmap;
+
+ ASSERT(fsck->sit_area_bitmap_sz == fsck->main_area_bitmap_sz);
+
+ for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) {
+ se = get_seg_entry(sbi, segno);
+
+ memcpy(ptr, se->cur_valid_map, SIT_VBLOCK_MAP_SIZE);
+ ptr += SIT_VBLOCK_MAP_SIZE;
+
+ if (se->valid_blocks == 0x0) {
+ if (sbi->ckpt->cur_node_segno[0] == segno ||
+ sbi->ckpt->cur_data_segno[0] == segno ||
+ sbi->ckpt->cur_node_segno[1] == segno ||
+ sbi->ckpt->cur_data_segno[1] == segno ||
+ sbi->ckpt->cur_node_segno[2] == segno ||
+ sbi->ckpt->cur_data_segno[2] == segno) {
+ continue;
+ } else {
+ free_segs++;
+ }
+ } else {
+ sum_vblocks += se->valid_blocks;
+ }
+ }
+ fsck->chk.sit_valid_blocks = sum_vblocks;
+ fsck->chk.sit_free_segs = free_segs;
+
+ DBG(1, "Blocks [0x%x : %d] Free Segs [0x%x : %d]\n\n",
+ sum_vblocks, sum_vblocks,
+ free_segs, free_segs);
+}
+
+void rewrite_sit_area_bitmap(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_COLD_DATA);
+ struct sit_info *sit_i = SIT_I(sbi);
+ unsigned int segno = 0;
+ struct f2fs_summary_block *sum = curseg->sum_blk;
+ char *ptr = NULL;
+
+ /* remove sit journal */
+ sum->n_sits = 0;
+
+ fsck->chk.free_segs = 0;
+
+ ptr = fsck->main_area_bitmap;
+
+ for (segno = 0; segno < TOTAL_SEGS(sbi); segno++) {
+ struct f2fs_sit_block *sit_blk;
+ struct f2fs_sit_entry *sit;
+ struct seg_entry *se;
+ u16 valid_blocks = 0;
+ u16 type;
+ int i;
+
+ sit_blk = get_current_sit_page(sbi, segno);
+ sit = &sit_blk->entries[SIT_ENTRY_OFFSET(sit_i, segno)];
+ memcpy(sit->valid_map, ptr, SIT_VBLOCK_MAP_SIZE);
+
+ /* update valid block count */
+ for (i = 0; i < SIT_VBLOCK_MAP_SIZE; i++)
+ valid_blocks += get_bits_in_byte(sit->valid_map[i]);
+
+ se = get_seg_entry(sbi, segno);
+ type = se->type;
+ if (type >= NO_CHECK_TYPE) {
+ ASSERT_MSG("Invalide type and valid blocks=%x,%x",
+ segno, valid_blocks);
+ type = 0;
+ }
+ sit->vblocks = cpu_to_le16((type << SIT_VBLOCKS_SHIFT) |
+ valid_blocks);
+ rewrite_current_sit_page(sbi, segno, sit_blk);
+ free(sit_blk);
+
+ if (valid_blocks == 0 &&
+ sbi->ckpt->cur_node_segno[0] != segno &&
+ sbi->ckpt->cur_data_segno[0] != segno &&
+ sbi->ckpt->cur_node_segno[1] != segno &&
+ sbi->ckpt->cur_data_segno[1] != segno &&
+ sbi->ckpt->cur_node_segno[2] != segno &&
+ sbi->ckpt->cur_data_segno[2] != segno)
+ fsck->chk.free_segs++;
+
+ ptr += SIT_VBLOCK_MAP_SIZE;
+ }
+}
+
+int lookup_nat_in_journal(struct f2fs_sb_info *sbi, u32 nid,
+ struct f2fs_nat_entry *raw_nat)
+{
+ struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
+ struct f2fs_summary_block *sum = curseg->sum_blk;
+ int i = 0;
+
+ for (i = 0; i < nats_in_cursum(sum); i++) {
+ if (le32_to_cpu(nid_in_journal(sum, i)) == nid) {
+ memcpy(raw_nat, &nat_in_journal(sum, i),
+ sizeof(struct f2fs_nat_entry));
+ DBG(3, "==> Found nid [0x%x] in nat cache\n", nid);
+ return i;
+ }
+ }
+ return -1;
+}
+
+void nullify_nat_entry(struct f2fs_sb_info *sbi, u32 nid)
+{
+ struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
+ struct f2fs_summary_block *sum = curseg->sum_blk;
+ struct f2fs_nm_info *nm_i = NM_I(sbi);
+ struct f2fs_nat_block *nat_block;
+ pgoff_t block_off;
+ pgoff_t block_addr;
+ int seg_off, entry_off;
+ int ret;
+ int i = 0;
+
+ /* check in journal */
+ for (i = 0; i < nats_in_cursum(sum); i++) {
+ if (le32_to_cpu(nid_in_journal(sum, i)) == nid) {
+ memset(&nat_in_journal(sum, i), 0,
+ sizeof(struct f2fs_nat_entry));
+ FIX_MSG("Remove nid [0x%x] in nat journal\n", nid);
+ return;
+ }
+ }
+ nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1);
+
+ block_off = nid / NAT_ENTRY_PER_BLOCK;
+ entry_off = nid % NAT_ENTRY_PER_BLOCK;
+
+ seg_off = block_off >> sbi->log_blocks_per_seg;
+ block_addr = (pgoff_t)(nm_i->nat_blkaddr +
+ (seg_off << sbi->log_blocks_per_seg << 1) +
+ (block_off & ((1 << sbi->log_blocks_per_seg) - 1)));
+
+ if (f2fs_test_bit(block_off, nm_i->nat_bitmap))
+ block_addr += sbi->blocks_per_seg;
+
+ ret = dev_read_block(nat_block, block_addr);
+ ASSERT(ret >= 0);
+
+ memset(&nat_block->entries[entry_off], 0,
+ sizeof(struct f2fs_nat_entry));
+
+ ret = dev_write_block(nat_block, block_addr);
+ ASSERT(ret >= 0);
+ free(nat_block);
+}
+
+void build_nat_area_bitmap(struct f2fs_sb_info *sbi)
+{
+ struct f2fs_fsck *fsck = F2FS_FSCK(sbi);
+ struct f2fs_super_block *raw_sb = F2FS_RAW_SUPER(sbi);
+ struct f2fs_nm_info *nm_i = NM_I(sbi);
+ struct f2fs_nat_block *nat_block;
+ u32 nid, nr_nat_blks;
+ pgoff_t block_off;
+ pgoff_t block_addr;
+ int seg_off;
+ int ret;
+ unsigned int i;
+
+ nat_block = (struct f2fs_nat_block *)calloc(BLOCK_SZ, 1);
+ ASSERT(nat_block);
+
+ /* Alloc & build nat entry bitmap */
+ nr_nat_blks = (le32_to_cpu(raw_sb->segment_count_nat) / 2) <<
+ sbi->log_blocks_per_seg;
+
+ fsck->nr_nat_entries = nr_nat_blks * NAT_ENTRY_PER_BLOCK;
+ fsck->nat_area_bitmap_sz = (fsck->nr_nat_entries + 7) / 8;
+ fsck->nat_area_bitmap = calloc(fsck->nat_area_bitmap_sz, 1);
+ ASSERT(fsck->nat_area_bitmap != NULL);
+
+ for (block_off = 0; block_off < nr_nat_blks; block_off++) {
+
+ seg_off = block_off >> sbi->log_blocks_per_seg;
+ block_addr = (pgoff_t)(nm_i->nat_blkaddr +
+ (seg_off << sbi->log_blocks_per_seg << 1) +
+ (block_off & ((1 << sbi->log_blocks_per_seg) - 1)));
+
+ if (f2fs_test_bit(block_off, nm_i->nat_bitmap))
+ block_addr += sbi->blocks_per_seg;
+
+ ret = dev_read_block(nat_block, block_addr);
+ ASSERT(ret >= 0);
+
+ nid = block_off * NAT_ENTRY_PER_BLOCK;
+ for (i = 0; i < NAT_ENTRY_PER_BLOCK; i++) {
+ struct f2fs_nat_entry raw_nat;
+ struct node_info ni;
+ ni.nid = nid + i;
+
+ if ((nid + i) == F2FS_NODE_INO(sbi) ||
+ (nid + i) == F2FS_META_INO(sbi)) {
+ ASSERT(nat_block->entries[i].block_addr != 0x0);
+ continue;
+ }
+
+ if (lookup_nat_in_journal(sbi, nid + i,
+ &raw_nat) >= 0) {
+ node_info_from_raw_nat(&ni, &raw_nat);
+ if (ni.blk_addr != 0x0) {
+ f2fs_set_bit(nid + i,
+ fsck->nat_area_bitmap);
+ fsck->chk.valid_nat_entry_cnt++;
+ DBG(3, "nid[0x%x] in nat cache\n",
+ nid + i);
+ }
+ } else {
+ node_info_from_raw_nat(&ni,
+ &nat_block->entries[i]);
+ if (ni.blk_addr == 0)
+ continue;
+ ASSERT(nid + i != 0x0);
+
+ DBG(3, "nid[0x%8x] addr[0x%16x] ino[0x%8x]\n",
+ nid + i, ni.blk_addr, ni.ino);
+ f2fs_set_bit(nid + i, fsck->nat_area_bitmap);
+ fsck->chk.valid_nat_entry_cnt++;
+ }
+ }
+ }
+ free(nat_block);
+
+ DBG(1, "valid nat entries (block_addr != 0x0) [0x%8x : %u]\n",
+ fsck->chk.valid_nat_entry_cnt,
+ fsck->chk.valid_nat_entry_cnt);
+}
+
+int f2fs_do_mount(struct f2fs_sb_info *sbi)
+{
+ int ret;
+
+ sbi->active_logs = NR_CURSEG_TYPE;
+ ret = validate_super_block(sbi, 0);
+ if (ret) {
+ ret = validate_super_block(sbi, 1);
+ if (ret)
+ return -1;
+ }
+
+ print_raw_sb_info(sbi);
+
+ init_sb_info(sbi);
+
+ ret = get_valid_checkpoint(sbi);
+ if (ret) {
+ ERR_MSG("Can't find valid checkpoint\n");
+ return -1;
+ }
+
+ if (sanity_check_ckpt(sbi)) {
+ ERR_MSG("Checkpoint is polluted\n");
+ return -1;
+ }
+
+ print_ckpt_info(sbi);
+
+ if (config.auto_fix) {
+ u32 flag = le32_to_cpu(sbi->ckpt->ckpt_flags);
+
+ if (flag & CP_FSCK_FLAG)
+ config.fix_on = 1;
+ else
+ return 1;
+ }
+
+ config.bug_on = 0;
+
+ sbi->total_valid_node_count = le32_to_cpu(sbi->ckpt->valid_node_count);
+ sbi->total_valid_inode_count =
+ le32_to_cpu(sbi->ckpt->valid_inode_count);
+ sbi->user_block_count = le64_to_cpu(sbi->ckpt->user_block_count);
+ sbi->total_valid_block_count =
+ le64_to_cpu(sbi->ckpt->valid_block_count);
+ sbi->last_valid_block_count = sbi->total_valid_block_count;
+ sbi->alloc_valid_block_count = 0;
+
+ if (build_segment_manager(sbi)) {
+ ERR_MSG("build_segment_manager failed\n");
+ return -1;
+ }
+
+ if (build_node_manager(sbi)) {
+ ERR_MSG("build_segment_manager failed\n");
+ return -1;
+ }
+
+ return 0;
+}
+
+void f2fs_do_umount(struct f2fs_sb_info *sbi)
+{
+ struct sit_info *sit_i = SIT_I(sbi);
+ struct f2fs_sm_info *sm_i = SM_I(sbi);
+ struct f2fs_nm_info *nm_i = NM_I(sbi);
+ unsigned int i;
+
+ /* free nm_info */
+ free(nm_i->nat_bitmap);
+ free(sbi->nm_info);
+
+ /* free sit_info */
+ for (i = 0; i < TOTAL_SEGS(sbi); i++) {
+ free(sit_i->sentries[i].cur_valid_map);
+ free(sit_i->sentries[i].ckpt_valid_map);
+ }
+ free(sit_i->sit_bitmap);
+ free(sm_i->sit_info);
+
+ /* free sm_info */
+ for (i = 0; i < NR_CURSEG_TYPE; i++)
+ free(sm_i->curseg_array[i].sum_blk);
+
+ free(sm_i->curseg_array);
+ free(sbi->sm_info);
+
+ free(sbi->ckpt);
+ free(sbi->raw_super);
+}
diff --git a/f2fs-tools/include/f2fs_fs.h b/f2fs-tools/include/f2fs_fs.h
new file mode 100644
index 0000000..6ce58c2
--- /dev/null
+++ b/f2fs-tools/include/f2fs_fs.h
@@ -0,0 +1,797 @@
+/**
+ * f2fs_fs.h
+ *
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com/
+ *
+ * Dual licensed under the GPL or LGPL version 2 licenses.
+ *
+ * The byteswap codes are copied from:
+ * samba_3_master/lib/ccan/endian/endian.h under LGPL 2.1
+ */
+#ifndef __F2FS_FS_H__
+#define __F2FS_FS_H__
+
+#include <inttypes.h>
+#include <linux/types.h>
+#include <sys/types.h>
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+typedef u_int64_t u64;
+typedef u_int32_t u32;
+typedef u_int16_t u16;
+typedef u_int8_t u8;
+typedef u32 block_t;
+typedef u32 nid_t;
+typedef u8 bool;
+typedef unsigned long pgoff_t;
+
+#if HAVE_BYTESWAP_H
+#include <byteswap.h>
+#else
+/**
+ * bswap_16 - reverse bytes in a uint16_t value.
+ * @val: value whose bytes to swap.
+ *
+ * Example:
+ * // Output contains "1024 is 4 as two bytes reversed"
+ * printf("1024 is %u as two bytes reversed\n", bswap_16(1024));
+ */
+static inline uint16_t bswap_16(uint16_t val)
+{
+ return ((val & (uint16_t)0x00ffU) << 8)
+ | ((val & (uint16_t)0xff00U) >> 8);
+}
+
+/**
+ * bswap_32 - reverse bytes in a uint32_t value.
+ * @val: value whose bytes to swap.
+ *
+ * Example:
+ * // Output contains "1024 is 262144 as four bytes reversed"
+ * printf("1024 is %u as four bytes reversed\n", bswap_32(1024));
+ */
+static inline uint32_t bswap_32(uint32_t val)
+{
+ return ((val & (uint32_t)0x000000ffUL) << 24)
+ | ((val & (uint32_t)0x0000ff00UL) << 8)
+ | ((val & (uint32_t)0x00ff0000UL) >> 8)
+ | ((val & (uint32_t)0xff000000UL) >> 24);
+}
+#endif /* !HAVE_BYTESWAP_H */
+
+#if defined HAVE_DECL_BSWAP_64 && !HAVE_DECL_BSWAP_64
+/**
+ * bswap_64 - reverse bytes in a uint64_t value.
+ * @val: value whose bytes to swap.
+ *
+ * Example:
+ * // Output contains "1024 is 1125899906842624 as eight bytes reversed"
+ * printf("1024 is %llu as eight bytes reversed\n",
+ * (unsigned long long)bswap_64(1024));
+ */
+static inline uint64_t bswap_64(uint64_t val)
+{
+ return ((val & (uint64_t)0x00000000000000ffULL) << 56)
+ | ((val & (uint64_t)0x000000000000ff00ULL) << 40)
+ | ((val & (uint64_t)0x0000000000ff0000ULL) << 24)
+ | ((val & (uint64_t)0x00000000ff000000ULL) << 8)
+ | ((val & (uint64_t)0x000000ff00000000ULL) >> 8)
+ | ((val & (uint64_t)0x0000ff0000000000ULL) >> 24)
+ | ((val & (uint64_t)0x00ff000000000000ULL) >> 40)
+ | ((val & (uint64_t)0xff00000000000000ULL) >> 56);
+}
+#endif
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+#define le16_to_cpu(x) ((__u16)(x))
+#define le32_to_cpu(x) ((__u32)(x))
+#define le64_to_cpu(x) ((__u64)(x))
+#define cpu_to_le16(x) ((__u16)(x))
+#define cpu_to_le32(x) ((__u32)(x))
+#define cpu_to_le64(x) ((__u64)(x))
+#elif __BYTE_ORDER == __BIG_ENDIAN
+#define le16_to_cpu(x) bswap_16(x)
+#define le32_to_cpu(x) bswap_32(x)
+#define le64_to_cpu(x) bswap_64(x)
+#define cpu_to_le16(x) bswap_16(x)
+#define cpu_to_le32(x) bswap_32(x)
+#define cpu_to_le64(x) bswap_64(x)
+#endif
+
+#define typecheck(type,x) \
+ ({ type __dummy; \
+ typeof(x) __dummy2; \
+ (void)(&__dummy == &__dummy2); \
+ 1; \
+ })
+
+#define NULL_SEGNO ((unsigned int)~0)
+
+/*
+ * Debugging interfaces
+ */
+#define FIX_MSG(fmt, ...) \
+ do { \
+ printf("[FIX] (%s:%4d) ", __func__, __LINE__); \
+ printf(" --> "fmt"\n", ##__VA_ARGS__); \
+ } while (0)
+
+#define ASSERT_MSG(fmt, ...) \
+ do { \
+ printf("[ASSERT] (%s:%4d) ", __func__, __LINE__); \
+ printf(" --> "fmt"\n", ##__VA_ARGS__); \
+ config.bug_on = 1; \
+ } while (0)
+
+#define ASSERT(exp) \
+ do { \
+ if (!(exp)) { \
+ printf("[ASSERT] (%s:%4d) " #exp"\n", \
+ __func__, __LINE__); \
+ exit(-1); \
+ } \
+ } while (0)
+
+#define ERR_MSG(fmt, ...) \
+ do { \
+ printf("[%s:%d] " fmt, __func__, __LINE__, ##__VA_ARGS__); \
+ } while (0)
+
+#define MSG(n, fmt, ...) \
+ do { \
+ if (config.dbg_lv >= n) { \
+ printf(fmt, ##__VA_ARGS__); \
+ } \
+ } while (0)
+
+#define DBG(n, fmt, ...) \
+ do { \
+ if (config.dbg_lv >= n) { \
+ printf("[%s:%4d] " fmt, \
+ __func__, __LINE__, ##__VA_ARGS__); \
+ } \
+ } while (0)
+
+/* Display on console */
+#define DISP(fmt, ptr, member) \
+ do { \
+ printf("%-30s" fmt, #member, ((ptr)->member)); \
+ } while (0)
+
+#define DISP_u32(ptr, member) \
+ do { \
+ assert(sizeof((ptr)->member) <= 4); \
+ printf("%-30s" "\t\t[0x%8x : %u]\n", \
+ #member, ((ptr)->member), ((ptr)->member)); \
+ } while (0)
+
+#define DISP_u64(ptr, member) \
+ do { \
+ assert(sizeof((ptr)->member) == 8); \
+ printf("%-30s" "\t\t[0x%8llx : %llu]\n", \
+ #member, ((ptr)->member), ((ptr)->member)); \
+ } while (0)
+
+#define DISP_utf(ptr, member) \
+ do { \
+ printf("%-30s" "\t\t[%s]\n", #member, ((ptr)->member)); \
+ } while (0)
+
+/* Display to buffer */
+#define BUF_DISP_u32(buf, data, len, ptr, member) \
+ do { \
+ assert(sizeof((ptr)->member) <= 4); \
+ snprintf(buf, len, #member); \
+ snprintf(data, len, "0x%x : %u", ((ptr)->member), \
+ ((ptr)->member)); \
+ } while (0)
+
+#define BUF_DISP_u64(buf, data, len, ptr, member) \
+ do { \
+ assert(sizeof((ptr)->member) == 8); \
+ snprintf(buf, len, #member); \
+ snprintf(data, len, "0x%llx : %llu", ((ptr)->member), \
+ ((ptr)->member)); \
+ } while (0)
+
+#define BUF_DISP_utf(buf, data, len, ptr, member) \
+ snprintf(buf, len, #member)
+
+/* these are defined in kernel */
+#define PAGE_SIZE 4096
+#define PAGE_CACHE_SIZE 4096
+#define BITS_PER_BYTE 8
+#define F2FS_SUPER_MAGIC 0xF2F52010 /* F2FS Magic Number */
+#define CHECKSUM_OFFSET 4092
+
+/* for mkfs */
+#define F2FS_MIN_VOLUME_SIZE 104857600
+#define F2FS_NUMBER_OF_CHECKPOINT_PACK 2
+#define DEFAULT_SECTOR_SIZE 512
+#define DEFAULT_SECTORS_PER_BLOCK 8
+#define DEFAULT_BLOCKS_PER_SEGMENT 512
+#define DEFAULT_SEGMENTS_PER_SECTION 1
+
+#define VERSION_LEN 256
+
+enum f2fs_config_func {
+ FSCK,
+ DUMP,
+};
+
+struct f2fs_configuration {
+ u_int32_t sector_size;
+ u_int32_t reserved_segments;
+ u_int32_t overprovision;
+ u_int32_t cur_seg[6];
+ u_int32_t segs_per_sec;
+ u_int32_t secs_per_zone;
+ u_int32_t segs_per_zone;
+ u_int32_t start_sector;
+ u_int64_t total_sectors;
+ u_int32_t sectors_per_blk;
+ u_int32_t blks_per_seg;
+ __u8 init_version[VERSION_LEN + 1];
+ __u8 sb_version[VERSION_LEN + 1];
+ __u8 version[VERSION_LEN + 1];
+ char *vol_label;
+ int heap;
+ int32_t fd, kd;
+ int32_t dump_fd;
+ char *device_name;
+ char *extension_list;
+ int dbg_lv;
+ int trim;
+ int func;
+ void *private;
+ int fix_on;
+ int bug_on;
+ int auto_fix;
+} __attribute__((packed));
+
+#ifdef CONFIG_64BIT
+#define BITS_PER_LONG 64
+#else
+#define BITS_PER_LONG 32
+#endif
+
+#define BIT_MASK(nr) (1 << (nr % BITS_PER_LONG))
+#define BIT_WORD(nr) (nr / BITS_PER_LONG)
+
+/*
+ * Copied from fs/f2fs/f2fs.h
+ */
+#define NR_CURSEG_DATA_TYPE (3)
+#define NR_CURSEG_NODE_TYPE (3)
+#define NR_CURSEG_TYPE (NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)
+
+enum {
+ CURSEG_HOT_DATA = 0, /* directory entry blocks */
+ CURSEG_WARM_DATA, /* data blocks */
+ CURSEG_COLD_DATA, /* multimedia or GCed data blocks */
+ CURSEG_HOT_NODE, /* direct node blocks of directory files */
+ CURSEG_WARM_NODE, /* direct node blocks of normal files */
+ CURSEG_COLD_NODE, /* indirect node blocks */
+ NO_CHECK_TYPE
+};
+
+/*
+ * Copied from fs/f2fs/segment.h
+ */
+#define GET_SUM_TYPE(footer) ((footer)->entry_type)
+#define SET_SUM_TYPE(footer, type) ((footer)->entry_type = type)
+
+/*
+ * Copied from include/linux/f2fs_sb.h
+ */
+#define F2FS_SUPER_OFFSET 1024 /* byte-size offset */
+#define F2FS_MIN_LOG_SECTOR_SIZE 9 /* 9 bits for 512 bytes */
+#define F2FS_MAX_LOG_SECTOR_SIZE 12 /* 12 bits for 4096 bytes */
+#define F2FS_BLKSIZE 4096 /* support only 4KB block */
+#define F2FS_MAX_EXTENSION 64 /* # of extension entries */
+#define F2FS_BLK_ALIGN(x) (((x) + F2FS_BLKSIZE - 1) / F2FS_BLKSIZE)
+
+#define NULL_ADDR 0x0U
+#define NEW_ADDR -1U
+
+#define F2FS_ROOT_INO(sbi) (sbi->root_ino_num)
+#define F2FS_NODE_INO(sbi) (sbi->node_ino_num)
+#define F2FS_META_INO(sbi) (sbi->meta_ino_num)
+
+/* This flag is used by node and meta inodes, and by recovery */
+#define GFP_F2FS_ZERO (GFP_NOFS | __GFP_ZERO)
+
+/*
+ * For further optimization on multi-head logs, on-disk layout supports maximum
+ * 16 logs by default. The number, 16, is expected to cover all the cases
+ * enoughly. The implementaion currently uses no more than 6 logs.
+ * Half the logs are used for nodes, and the other half are used for data.
+ */
+#define MAX_ACTIVE_LOGS 16
+#define MAX_ACTIVE_NODE_LOGS 8
+#define MAX_ACTIVE_DATA_LOGS 8
+
+/*
+ * For superblock
+ */
+struct f2fs_super_block {
+ __le32 magic; /* Magic Number */
+ __le16 major_ver; /* Major Version */
+ __le16 minor_ver; /* Minor Version */
+ __le32 log_sectorsize; /* log2 sector size in bytes */
+ __le32 log_sectors_per_block; /* log2 # of sectors per block */
+ __le32 log_blocksize; /* log2 block size in bytes */
+ __le32 log_blocks_per_seg; /* log2 # of blocks per segment */
+ __le32 segs_per_sec; /* # of segments per section */
+ __le32 secs_per_zone; /* # of sections per zone */
+ __le32 checksum_offset; /* checksum offset inside super block */
+ __le64 block_count; /* total # of user blocks */
+ __le32 section_count; /* total # of sections */
+ __le32 segment_count; /* total # of segments */
+ __le32 segment_count_ckpt; /* # of segments for checkpoint */
+ __le32 segment_count_sit; /* # of segments for SIT */
+ __le32 segment_count_nat; /* # of segments for NAT */
+ __le32 segment_count_ssa; /* # of segments for SSA */
+ __le32 segment_count_main; /* # of segments for main area */
+ __le32 segment0_blkaddr; /* start block address of segment 0 */
+ __le32 cp_blkaddr; /* start block address of checkpoint */
+ __le32 sit_blkaddr; /* start block address of SIT */
+ __le32 nat_blkaddr; /* start block address of NAT */
+ __le32 ssa_blkaddr; /* start block address of SSA */
+ __le32 main_blkaddr; /* start block address of main area */
+ __le32 root_ino; /* root inode number */
+ __le32 node_ino; /* node inode number */
+ __le32 meta_ino; /* meta inode number */
+ __u8 uuid[16]; /* 128-bit uuid for volume */
+ __le16 volume_name[512]; /* volume name */
+ __le32 extension_count; /* # of extensions below */
+ __u8 extension_list[F2FS_MAX_EXTENSION][8]; /* extension array */
+ __le32 cp_payload;
+ __u8 version[VERSION_LEN]; /* the kernel version */
+ __u8 init_version[VERSION_LEN]; /* the initial kernel version */
+} __attribute__((packed));
+
+/*
+ * For checkpoint
+ */
+#define CP_FASTBOOT_FLAG 0x00000020
+#define CP_FSCK_FLAG 0x00000010
+#define CP_ERROR_FLAG 0x00000008
+#define CP_COMPACT_SUM_FLAG 0x00000004
+#define CP_ORPHAN_PRESENT_FLAG 0x00000002
+#define CP_UMOUNT_FLAG 0x00000001
+
+struct f2fs_checkpoint {
+ __le64 checkpoint_ver; /* checkpoint block version number */
+ __le64 user_block_count; /* # of user blocks */
+ __le64 valid_block_count; /* # of valid blocks in main area */
+ __le32 rsvd_segment_count; /* # of reserved segments for gc */
+ __le32 overprov_segment_count; /* # of overprovision segments */
+ __le32 free_segment_count; /* # of free segments in main area */
+
+ /* information of current node segments */
+ __le32 cur_node_segno[MAX_ACTIVE_NODE_LOGS];
+ __le16 cur_node_blkoff[MAX_ACTIVE_NODE_LOGS];
+ /* information of current data segments */
+ __le32 cur_data_segno[MAX_ACTIVE_DATA_LOGS];
+ __le16 cur_data_blkoff[MAX_ACTIVE_DATA_LOGS];
+ __le32 ckpt_flags; /* Flags : umount and journal_present */
+ __le32 cp_pack_total_block_count; /* total # of one cp pack */
+ __le32 cp_pack_start_sum; /* start block number of data summary */
+ __le32 valid_node_count; /* Total number of valid nodes */
+ __le32 valid_inode_count; /* Total number of valid inodes */
+ __le32 next_free_nid; /* Next free node number */
+ __le32 sit_ver_bitmap_bytesize; /* Default value 64 */
+ __le32 nat_ver_bitmap_bytesize; /* Default value 256 */
+ __le32 checksum_offset; /* checksum offset inside cp block */
+ __le64 elapsed_time; /* mounted time */
+ /* allocation type of current segment */
+ unsigned char alloc_type[MAX_ACTIVE_LOGS];
+
+ /* SIT and NAT version bitmap */
+ unsigned char sit_nat_version_bitmap[1];
+} __attribute__((packed));
+
+/*
+ * For orphan inode management
+ */
+#define F2FS_ORPHANS_PER_BLOCK 1020
+
+struct f2fs_orphan_block {
+ __le32 ino[F2FS_ORPHANS_PER_BLOCK]; /* inode numbers */
+ __le32 reserved; /* reserved */
+ __le16 blk_addr; /* block index in current CP */
+ __le16 blk_count; /* Number of orphan inode blocks in CP */
+ __le32 entry_count; /* Total number of orphan nodes in current CP */
+ __le32 check_sum; /* CRC32 for orphan inode block */
+} __attribute__((packed));
+
+/*
+ * For NODE structure
+ */
+struct f2fs_extent {
+ __le32 fofs; /* start file offset of the extent */
+ __le32 blk_addr; /* start block address of the extent */
+ __le32 len; /* lengh of the extent */
+} __attribute__((packed));
+
+#define F2FS_NAME_LEN 255
+#define F2FS_INLINE_XATTR_ADDRS 50 /* 200 bytes for inline xattrs */
+#define DEF_ADDRS_PER_INODE 923 /* Address Pointers in an Inode */
+#define ADDRS_PER_INODE(fi) addrs_per_inode(fi)
+#define ADDRS_PER_BLOCK 1018 /* Address Pointers in a Direct Block */
+#define NIDS_PER_BLOCK 1018 /* Node IDs in an Indirect Block */
+
+#define NODE_DIR1_BLOCK (DEF_ADDRS_PER_INODE + 1)
+#define NODE_DIR2_BLOCK (DEF_ADDRS_PER_INODE + 2)
+#define NODE_IND1_BLOCK (DEF_ADDRS_PER_INODE + 3)
+#define NODE_IND2_BLOCK (DEF_ADDRS_PER_INODE + 4)
+#define NODE_DIND_BLOCK (DEF_ADDRS_PER_INODE + 5)
+
+#define F2FS_INLINE_XATTR 0x01 /* file inline xattr flag */
+#define F2FS_INLINE_DATA 0x02 /* file inline data flag */
+#define F2FS_INLINE_DENTRY 0x04 /* file inline dentry flag */
+#define F2FS_DATA_EXIST 0x08 /* file inline data exist flag */
+
+#define MAX_INLINE_DATA (sizeof(__le32) * (DEF_ADDRS_PER_INODE - \
+ F2FS_INLINE_XATTR_ADDRS - 1))
+
+#define INLINE_DATA_OFFSET (PAGE_CACHE_SIZE - sizeof(struct node_footer) \
+ - sizeof(__le32)*(DEF_ADDRS_PER_INODE + 5 - 1))
+
+#define DEF_DIR_LEVEL 0
+
+struct f2fs_inode {
+ __le16 i_mode; /* file mode */
+ __u8 i_advise; /* file hints */
+ __u8 i_inline; /* file inline flags */
+ __le32 i_uid; /* user ID */
+ __le32 i_gid; /* group ID */
+ __le32 i_links; /* links count */
+ __le64 i_size; /* file size in bytes */
+ __le64 i_blocks; /* file size in blocks */
+ __le64 i_atime; /* access time */
+ __le64 i_ctime; /* change time */
+ __le64 i_mtime; /* modification time */
+ __le32 i_atime_nsec; /* access time in nano scale */
+ __le32 i_ctime_nsec; /* change time in nano scale */
+ __le32 i_mtime_nsec; /* modification time in nano scale */
+ __le32 i_generation; /* file version (for NFS) */
+ __le32 i_current_depth; /* only for directory depth */
+ __le32 i_xattr_nid; /* nid to save xattr */
+ __le32 i_flags; /* file attributes */
+ __le32 i_pino; /* parent inode number */
+ __le32 i_namelen; /* file name length */
+ __u8 i_name[F2FS_NAME_LEN]; /* file name for SPOR */
+ __u8 i_dir_level; /* dentry_level for large dir */
+
+ struct f2fs_extent i_ext; /* caching a largest extent */
+
+ __le32 i_addr[DEF_ADDRS_PER_INODE]; /* Pointers to data blocks */
+
+ __le32 i_nid[5]; /* direct(2), indirect(2),
+ double_indirect(1) node id */
+} __attribute__((packed));
+
+struct direct_node {
+ __le32 addr[ADDRS_PER_BLOCK]; /* array of data block address */
+} __attribute__((packed));
+
+struct indirect_node {
+ __le32 nid[NIDS_PER_BLOCK]; /* array of data block address */
+} __attribute__((packed));
+
+enum {
+ COLD_BIT_SHIFT = 0,
+ FSYNC_BIT_SHIFT,
+ DENT_BIT_SHIFT,
+ OFFSET_BIT_SHIFT
+};
+
+#define XATTR_NODE_OFFSET ((((unsigned int)-1) << OFFSET_BIT_SHIFT) \
+ >> OFFSET_BIT_SHIFT)
+
+struct node_footer {
+ __le32 nid; /* node id */
+ __le32 ino; /* inode nunmber */
+ __le32 flag; /* include cold/fsync/dentry marks and offset */
+ __le64 cp_ver; /* checkpoint version */
+ __le32 next_blkaddr; /* next node page block address */
+} __attribute__((packed));
+
+struct f2fs_node {
+ /* can be one of three types: inode, direct, and indirect types */
+ union {
+ struct f2fs_inode i;
+ struct direct_node dn;
+ struct indirect_node in;
+ };
+ struct node_footer footer;
+} __attribute__((packed));
+
+/*
+ * For NAT entries
+ */
+#define NAT_ENTRY_PER_BLOCK (PAGE_CACHE_SIZE / sizeof(struct f2fs_nat_entry))
+
+struct f2fs_nat_entry {
+ __u8 version; /* latest version of cached nat entry */
+ __le32 ino; /* inode number */
+ __le32 block_addr; /* block address */
+} __attribute__((packed));
+
+struct f2fs_nat_block {
+ struct f2fs_nat_entry entries[NAT_ENTRY_PER_BLOCK];
+} __attribute__((packed));
+
+/*
+ * For SIT entries
+ *
+ * Each segment is 2MB in size by default so that a bitmap for validity of
+ * there-in blocks should occupy 64 bytes, 512 bits.
+ * Not allow to change this.
+ */
+#define SIT_VBLOCK_MAP_SIZE 64
+#define SIT_ENTRY_PER_BLOCK (PAGE_CACHE_SIZE / sizeof(struct f2fs_sit_entry))
+
+/*
+ * F2FS uses 4 bytes to represent block address. As a result, supported size of
+ * disk is 16 TB and it equals to 16 * 1024 * 1024 / 2 segments.
+ */
+#define F2FS_MAX_SEGMENT ((16 * 1024 * 1024) / 2)
+#define MAX_SIT_BITMAP_SIZE ((F2FS_MAX_SEGMENT / SIT_ENTRY_PER_BLOCK) / 8)
+
+/*
+ * Note that f2fs_sit_entry->vblocks has the following bit-field information.
+ * [15:10] : allocation type such as CURSEG_XXXX_TYPE
+ * [9:0] : valid block count
+ */
+#define SIT_VBLOCKS_SHIFT 10
+#define SIT_VBLOCKS_MASK ((1 << SIT_VBLOCKS_SHIFT) - 1)
+#define GET_SIT_VBLOCKS(raw_sit) \
+ (le16_to_cpu((raw_sit)->vblocks) & SIT_VBLOCKS_MASK)
+#define GET_SIT_TYPE(raw_sit) \
+ ((le16_to_cpu((raw_sit)->vblocks) & ~SIT_VBLOCKS_MASK) \
+ >> SIT_VBLOCKS_SHIFT)
+
+struct f2fs_sit_entry {
+ __le16 vblocks; /* reference above */
+ __u8 valid_map[SIT_VBLOCK_MAP_SIZE]; /* bitmap for valid blocks */
+ __le64 mtime; /* segment age for cleaning */
+} __attribute__((packed));
+
+struct f2fs_sit_block {
+ struct f2fs_sit_entry entries[SIT_ENTRY_PER_BLOCK];
+} __attribute__((packed));
+
+/*
+ * For segment summary
+ *
+ * One summary block contains exactly 512 summary entries, which represents
+ * exactly 2MB segment by default. Not allow to change the basic units.
+ *
+ * NOTE: For initializing fields, you must use set_summary
+ *
+ * - If data page, nid represents dnode's nid
+ * - If node page, nid represents the node page's nid.
+ *
+ * The ofs_in_node is used by only data page. It represents offset
+ * from node's page's beginning to get a data block address.
+ * ex) data_blkaddr = (block_t)(nodepage_start_address + ofs_in_node)
+ */
+#define ENTRIES_IN_SUM 512
+#define SUMMARY_SIZE (7) /* sizeof(struct summary) */
+#define SUM_FOOTER_SIZE (5) /* sizeof(struct summary_footer) */
+#define SUM_ENTRIES_SIZE (SUMMARY_SIZE * ENTRIES_IN_SUM)
+
+/* a summary entry for a 4KB-sized block in a segment */
+struct f2fs_summary {
+ __le32 nid; /* parent node id */
+ union {
+ __u8 reserved[3];
+ struct {
+ __u8 version; /* node version number */
+ __le16 ofs_in_node; /* block index in parent node */
+ } __attribute__((packed));
+ };
+} __attribute__((packed));
+
+/* summary block type, node or data, is stored to the summary_footer */
+#define SUM_TYPE_NODE (1)
+#define SUM_TYPE_DATA (0)
+
+struct summary_footer {
+ unsigned char entry_type; /* SUM_TYPE_XXX */
+ __u32 check_sum; /* summary checksum */
+} __attribute__((packed));
+
+#define SUM_JOURNAL_SIZE (F2FS_BLKSIZE - SUM_FOOTER_SIZE -\
+ SUM_ENTRIES_SIZE)
+#define NAT_JOURNAL_ENTRIES ((SUM_JOURNAL_SIZE - 2) /\
+ sizeof(struct nat_journal_entry))
+#define NAT_JOURNAL_RESERVED ((SUM_JOURNAL_SIZE - 2) %\
+ sizeof(struct nat_journal_entry))
+#define SIT_JOURNAL_ENTRIES ((SUM_JOURNAL_SIZE - 2) /\
+ sizeof(struct sit_journal_entry))
+#define SIT_JOURNAL_RESERVED ((SUM_JOURNAL_SIZE - 2) %\
+ sizeof(struct sit_journal_entry))
+/*
+ * frequently updated NAT/SIT entries can be stored in the spare area in
+ * summary blocks
+ */
+enum {
+ NAT_JOURNAL = 0,
+ SIT_JOURNAL
+};
+
+struct nat_journal_entry {
+ __le32 nid;
+ struct f2fs_nat_entry ne;
+} __attribute__((packed));
+
+struct nat_journal {
+ struct nat_journal_entry entries[NAT_JOURNAL_ENTRIES];
+ __u8 reserved[NAT_JOURNAL_RESERVED];
+} __attribute__((packed));
+
+struct sit_journal_entry {
+ __le32 segno;
+ struct f2fs_sit_entry se;
+} __attribute__((packed));
+
+struct sit_journal {
+ struct sit_journal_entry entries[SIT_JOURNAL_ENTRIES];
+ __u8 reserved[SIT_JOURNAL_RESERVED];
+} __attribute__((packed));
+
+/* 4KB-sized summary block structure */
+struct f2fs_summary_block {
+ struct f2fs_summary entries[ENTRIES_IN_SUM];
+ union {
+ __le16 n_nats;
+ __le16 n_sits;
+ };
+ /* spare area is used by NAT or SIT journals */
+ union {
+ struct nat_journal nat_j;
+ struct sit_journal sit_j;
+ };
+ struct summary_footer footer;
+} __attribute__((packed));
+
+/*
+ * For directory operations
+ */
+#define F2FS_DOT_HASH 0
+#define F2FS_DDOT_HASH F2FS_DOT_HASH
+#define F2FS_MAX_HASH (~((0x3ULL) << 62))
+#define F2FS_HASH_COL_BIT ((0x1ULL) << 63)
+
+typedef __le32 f2fs_hash_t;
+
+/* One directory entry slot covers 8bytes-long file name */
+#define F2FS_SLOT_LEN 8
+#define F2FS_SLOT_LEN_BITS 3
+
+#define GET_DENTRY_SLOTS(x) ((x + F2FS_SLOT_LEN - 1) >> F2FS_SLOT_LEN_BITS)
+
+/* the number of dentry in a block */
+#define NR_DENTRY_IN_BLOCK 214
+
+/* MAX level for dir lookup */
+#define MAX_DIR_HASH_DEPTH 63
+
+#define SIZE_OF_DIR_ENTRY 11 /* by byte */
+#define SIZE_OF_DENTRY_BITMAP ((NR_DENTRY_IN_BLOCK + BITS_PER_BYTE - 1) / \
+ BITS_PER_BYTE)
+#define SIZE_OF_RESERVED (PAGE_SIZE - ((SIZE_OF_DIR_ENTRY + \
+ F2FS_SLOT_LEN) * \
+ NR_DENTRY_IN_BLOCK + SIZE_OF_DENTRY_BITMAP))
+
+/* One directory entry slot representing F2FS_SLOT_LEN-sized file name */
+struct f2fs_dir_entry {
+ __le32 hash_code; /* hash code of file name */
+ __le32 ino; /* inode number */
+ __le16 name_len; /* lengh of file name */
+ __u8 file_type; /* file type */
+} __attribute__((packed));
+
+/* 4KB-sized directory entry block */
+struct f2fs_dentry_block {
+ /* validity bitmap for directory entries in each block */
+ __u8 dentry_bitmap[SIZE_OF_DENTRY_BITMAP];
+ __u8 reserved[SIZE_OF_RESERVED];
+ struct f2fs_dir_entry dentry[NR_DENTRY_IN_BLOCK];
+ __u8 filename[NR_DENTRY_IN_BLOCK][F2FS_SLOT_LEN];
+} __attribute__((packed));
+
+/* for inline dir */
+#define NR_INLINE_DENTRY (MAX_INLINE_DATA * BITS_PER_BYTE / \
+ ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
+ BITS_PER_BYTE + 1))
+#define INLINE_DENTRY_BITMAP_SIZE ((NR_INLINE_DENTRY + \
+ BITS_PER_BYTE - 1) / BITS_PER_BYTE)
+#define INLINE_RESERVED_SIZE (MAX_INLINE_DATA - \
+ ((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
+ NR_INLINE_DENTRY + INLINE_DENTRY_BITMAP_SIZE))
+
+/* inline directory entry structure */
+struct f2fs_inline_dentry {
+ __u8 dentry_bitmap[INLINE_DENTRY_BITMAP_SIZE];
+ __u8 reserved[INLINE_RESERVED_SIZE];
+ struct f2fs_dir_entry dentry[NR_INLINE_DENTRY];
+ __u8 filename[NR_INLINE_DENTRY][F2FS_SLOT_LEN];
+} __packed;
+
+/* file types used in inode_info->flags */
+enum FILE_TYPE {
+ F2FS_FT_UNKNOWN,
+ F2FS_FT_REG_FILE,
+ F2FS_FT_DIR,
+ F2FS_FT_CHRDEV,
+ F2FS_FT_BLKDEV,
+ F2FS_FT_FIFO,
+ F2FS_FT_SOCK,
+ F2FS_FT_SYMLINK,
+ F2FS_FT_MAX,
+ /* added for fsck */
+ F2FS_FT_ORPHAN,
+ F2FS_FT_XATTR,
+ F2FS_FT_LAST_FILE_TYPE = F2FS_FT_XATTR,
+};
+
+/* from f2fs/segment.h */
+enum {
+ LFS = 0,
+ SSR
+};
+
+extern void ASCIIToUNICODE(u_int16_t *, u_int8_t *);
+extern int log_base_2(u_int32_t);
+extern unsigned int addrs_per_inode(struct f2fs_inode *);
+
+extern int get_bits_in_byte(unsigned char n);
+extern int set_bit(unsigned int nr,void * addr);
+extern int clear_bit(unsigned int nr, void * addr);
+extern int test_bit(unsigned int nr, const void * addr);
+extern int f2fs_test_bit(unsigned int, const char *);
+extern int f2fs_set_bit(unsigned int, char *);
+extern int f2fs_clear_bit(unsigned int, char *);
+extern unsigned long find_next_bit(const unsigned long *,
+ unsigned long, unsigned long);
+
+extern u_int32_t f2fs_cal_crc32(u_int32_t, void *, int);
+extern int f2fs_crc_valid(u_int32_t blk_crc, void *buf, int len);
+
+extern void f2fs_init_configuration(struct f2fs_configuration *);
+extern int f2fs_dev_is_umounted(struct f2fs_configuration *);
+extern int f2fs_get_device_info(struct f2fs_configuration *);
+extern void f2fs_finalize_device(struct f2fs_configuration *);
+
+extern int dev_read(void *, __u64, size_t);
+extern int dev_write(void *, __u64, size_t);
+extern int dev_write_block(void *, __u64);
+extern int dev_write_dump(void *, __u64, size_t);
+/* All bytes in the buffer must be 0 use dev_fill(). */
+extern int dev_fill(void *, __u64, size_t);
+
+extern int dev_read_block(void *, __u64);
+extern int dev_read_blocks(void *, __u64, __u32 );
+extern int dev_reada_block(__u64);
+
+extern int dev_read_version(void *, __u64, size_t);
+extern void get_kernel_version(__u8 *);
+f2fs_hash_t f2fs_dentry_hash(const unsigned char *, int);
+
+extern struct f2fs_configuration config;
+
+#define ALIGN(val, size) ((val) + (size) - 1) / (size)
+#define SEG_ALIGN(blks) ALIGN(blks, config.blks_per_seg)
+#define ZONE_ALIGN(blks) ALIGN(blks, config.blks_per_seg * \
+ config.segs_per_zone)
+
+#endif /*__F2FS_FS_H */
diff --git a/f2fs-tools/include/list.h b/f2fs-tools/include/list.h
new file mode 100644
index 0000000..571cd5c
--- /dev/null
+++ b/f2fs-tools/include/list.h
@@ -0,0 +1,88 @@
+
+#define POISON_POINTER_DELTA 0
+#define LIST_POISON1 ((void *) (0x00100100 + POISON_POINTER_DELTA))
+#define LIST_POISON2 ((void *) (0x00200200 + POISON_POINTER_DELTA))
+
+#if !defined(offsetof)
+#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+#endif
+#define container_of(ptr, type, member) ({ \
+ const typeof( ((type *)0)->member ) *__mptr = (ptr); \
+ (type *)( (char *)__mptr - offsetof(type,member) );})
+
+struct list_head {
+ struct list_head *next, *prev;
+};
+
+#define LIST_HEAD_INIT(name) { &(name), &(name) }
+
+#define LIST_HEAD(name) \
+ struct list_head name = LIST_HEAD_INIT(name)
+
+static inline void INIT_LIST_HEAD(struct list_head *list)
+{
+ list->next = list;
+ list->prev = list;
+}
+
+static inline void __list_add(struct list_head *new,
+ struct list_head *prev,
+ struct list_head *next)
+{
+ next->prev = new;
+ new->next = next;
+ new->prev = prev;
+ prev->next = new;
+}
+
+static inline void list_add(struct list_head *new, struct list_head *head)
+{
+ __list_add(new, head, head->next);
+}
+
+static inline void list_add_tail(struct list_head *new, struct list_head *head)
+{
+ __list_add(new, head->prev, head);
+}
+
+static inline void __list_del(struct list_head * prev, struct list_head * next)
+{
+ next->prev = prev;
+ prev->next = next;
+}
+
+static inline void __list_del_entry(struct list_head *entry)
+{
+ __list_del(entry->prev, entry->next);
+}
+
+static inline void list_del(struct list_head *entry)
+{
+ __list_del(entry->prev, entry->next);
+ entry->next = LIST_POISON1;
+ entry->prev = LIST_POISON2;
+}
+
+static inline int list_empty(const struct list_head *head)
+{
+ return head->next == head;
+}
+
+#define list_entry(ptr, type, member) \
+ container_of(ptr, type, member)
+
+#define list_for_each(pos, head) \
+ for (pos = (head)->next; pos != (head); pos = pos->next)
+
+#define list_for_each_safe(pos, n, head) \
+ for (pos = (head)->next, n = pos->next; pos != (head); \
+ pos = n, n = pos->next)
+#define list_for_each_entry(pos, head, member) \
+ for (pos = list_entry((head)->next, typeof(*pos), member); \
+ &pos->member != (head); \
+ pos = list_entry(pos->member.next, typeof(*pos), member))
+#define list_for_each_entry_safe(pos, n, head, member) \
+ for (pos = list_entry((head)->next, typeof(*pos), member), \
+ n = list_entry(pos->member.next, typeof(*pos), member); \
+ &pos->member != (head); \
+ pos = n, n = list_entry(n->member.next, typeof(*n), member))
diff --git a/f2fs-tools/lib/Makefile.am b/f2fs-tools/lib/Makefile.am
new file mode 100644
index 0000000..a6b304c
--- /dev/null
+++ b/f2fs-tools/lib/Makefile.am
@@ -0,0 +1,7 @@
+## Makefile.am
+
+lib_LTLIBRARIES = libf2fs.la
+
+libf2fs_la_SOURCES = libf2fs.c libf2fs_io.c
+libf2fs_la_CFLAGS = -Wall
+libf2fs_la_CPPFLAGS = -I$(top_srcdir)/include
diff --git a/f2fs-tools/lib/libf2fs.c b/f2fs-tools/lib/libf2fs.c
new file mode 100644
index 0000000..9e19e9b
--- /dev/null
+++ b/f2fs-tools/lib/libf2fs.c
@@ -0,0 +1,511 @@
+/**
+ * libf2fs.c
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com/
+ *
+ * Dual licensed under the GPL or LGPL version 2 licenses.
+ */
+#define _LARGEFILE64_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <mntent.h>
+#include <time.h>
+#include <sys/stat.h>
+#include <sys/mount.h>
+#include <sys/ioctl.h>
+#include <linux/hdreg.h>
+
+#include <f2fs_fs.h>
+
+void ASCIIToUNICODE(u_int16_t *out_buf, u_int8_t *in_buf)
+{
+ u_int8_t *pchTempPtr = in_buf;
+ u_int16_t *pwTempPtr = out_buf;
+
+ while (*pchTempPtr != '\0') {
+ *pwTempPtr = (u_int16_t)*pchTempPtr;
+ pchTempPtr++;
+ pwTempPtr++;
+ }
+ *pwTempPtr = '\0';
+ return;
+}
+
+int log_base_2(u_int32_t num)
+{
+ int ret = 0;
+ if (num <= 0 || (num & (num - 1)) != 0)
+ return -1;
+
+ while (num >>= 1)
+ ret++;
+ return ret;
+}
+
+/*
+ * f2fs bit operations
+ */
+static const int bits_in_byte[256] = {
+ 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
+ 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+ 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+ 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+ 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+ 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+ 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+ 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+ 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
+ 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+ 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+ 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+ 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
+ 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+ 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
+ 4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8,
+};
+
+int get_bits_in_byte(unsigned char n)
+{
+ return bits_in_byte[n];
+}
+
+int set_bit(unsigned int nr,void * addr)
+{
+ int mask, retval;
+ unsigned char *ADDR = (unsigned char *) addr;
+
+ ADDR += nr >> 3;
+ mask = 1 << ((nr & 0x07));
+ retval = mask & *ADDR;
+ *ADDR |= mask;
+ return retval;
+}
+
+int clear_bit(unsigned int nr, void * addr)
+{
+ int mask, retval;
+ unsigned char *ADDR = (unsigned char *) addr;
+
+ ADDR += nr >> 3;
+ mask = 1 << ((nr & 0x07));
+ retval = mask & *ADDR;
+ *ADDR &= ~mask;
+ return retval;
+}
+
+int test_bit(unsigned int nr, const void * addr)
+{
+ const __u32 *p = (const __u32 *)addr;
+
+ nr = nr ^ 0;
+
+ return ((1 << (nr & 31)) & (p[nr >> 5])) != 0;
+}
+
+int f2fs_test_bit(unsigned int nr, const char *p)
+{
+ int mask;
+ char *addr = (char *)p;
+
+ addr += (nr >> 3);
+ mask = 1 << (7 - (nr & 0x07));
+ return (mask & *addr) != 0;
+}
+
+int f2fs_set_bit(unsigned int nr, char *addr)
+{
+ int mask;
+ int ret;
+
+ addr += (nr >> 3);
+ mask = 1 << (7 - (nr & 0x07));
+ ret = mask & *addr;
+ *addr |= mask;
+ return ret;
+}
+
+int f2fs_clear_bit(unsigned int nr, char *addr)
+{
+ int mask;
+ int ret;
+
+ addr += (nr >> 3);
+ mask = 1 << (7 - (nr & 0x07));
+ ret = mask & *addr;
+ *addr &= ~mask;
+ return ret;
+}
+
+static inline unsigned long __ffs(unsigned long word)
+{
+ int num = 0;
+
+#if BITS_PER_LONG == 64
+ if ((word & 0xffffffff) == 0) {
+ num += 32;
+ word >>= 32;
+ }
+#endif
+ if ((word & 0xffff) == 0) {
+ num += 16;
+ word >>= 16;
+ }
+ if ((word & 0xff) == 0) {
+ num += 8;
+ word >>= 8;
+ }
+ if ((word & 0xf) == 0) {
+ num += 4;
+ word >>= 4;
+ }
+ if ((word & 0x3) == 0) {
+ num += 2;
+ word >>= 2;
+ }
+ if ((word & 0x1) == 0)
+ num += 1;
+ return num;
+}
+
+unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
+ unsigned long offset)
+{
+ const unsigned long *p = addr + BIT_WORD(offset);
+ unsigned long result = offset & ~(BITS_PER_LONG-1);
+ unsigned long tmp;
+
+ if (offset >= size)
+ return size;
+ size -= result;
+ offset %= BITS_PER_LONG;
+ if (offset) {
+ tmp = *(p++);
+ tmp &= (~0UL << offset);
+ if (size < BITS_PER_LONG)
+ goto found_first;
+ if (tmp)
+ goto found_middle;
+ size -= BITS_PER_LONG;
+ result += BITS_PER_LONG;
+ }
+ while (size & ~(BITS_PER_LONG-1)) {
+ if ((tmp = *(p++)))
+ goto found_middle;
+ result += BITS_PER_LONG;
+ size -= BITS_PER_LONG;
+ }
+ if (!size)
+ return result;
+ tmp = *p;
+
+found_first:
+ tmp &= (~0UL >> (BITS_PER_LONG - size));
+ if (tmp == 0UL) /* Are any bits set? */
+ return result + size; /* Nope. */
+found_middle:
+ return result + __ffs(tmp);
+}
+
+/*
+ * Hashing code adapted from ext3
+ */
+#define DELTA 0x9E3779B9
+
+static void TEA_transform(unsigned int buf[4], unsigned int const in[])
+{
+ __u32 sum = 0;
+ __u32 b0 = buf[0], b1 = buf[1];
+ __u32 a = in[0], b = in[1], c = in[2], d = in[3];
+ int n = 16;
+
+ do {
+ sum += DELTA;
+ b0 += ((b1 << 4)+a) ^ (b1+sum) ^ ((b1 >> 5)+b);
+ b1 += ((b0 << 4)+c) ^ (b0+sum) ^ ((b0 >> 5)+d);
+ } while (--n);
+
+ buf[0] += b0;
+ buf[1] += b1;
+
+}
+
+static void str2hashbuf(const unsigned char *msg, int len,
+ unsigned int *buf, int num)
+{
+ unsigned pad, val;
+ int i;
+
+ pad = (__u32)len | ((__u32)len << 8);
+ pad |= pad << 16;
+
+ val = pad;
+ if (len > num * 4)
+ len = num * 4;
+ for (i = 0; i < len; i++) {
+ if ((i % 4) == 0)
+ val = pad;
+ val = msg[i] + (val << 8);
+ if ((i % 4) == 3) {
+ *buf++ = val;
+ val = pad;
+ num--;
+ }
+ }
+ if (--num >= 0)
+ *buf++ = val;
+ while (--num >= 0)
+ *buf++ = pad;
+
+}
+
+/**
+ * Return hash value of directory entry
+ * @param name dentry name
+ * @param len name lenth
+ * @return return on success hash value, errno on failure
+ */
+f2fs_hash_t f2fs_dentry_hash(const unsigned char *name, int len)
+{
+ __u32 hash;
+ f2fs_hash_t f2fs_hash;
+ const unsigned char *p;
+ __u32 in[8], buf[4];
+
+ /* special hash codes for special dentries */
+ if ((len <= 2) && (name[0] == '.') &&
+ (name[1] == '.' || name[1] == '\0'))
+ return 0;
+
+ /* Initialize the default seed for the hash checksum functions */
+ buf[0] = 0x67452301;
+ buf[1] = 0xefcdab89;
+ buf[2] = 0x98badcfe;
+ buf[3] = 0x10325476;
+
+ p = name;
+ while (1) {
+ str2hashbuf(p, len, in, 4);
+ TEA_transform(buf, in);
+ p += 16;
+ if (len <= 16)
+ break;
+ len -= 16;
+ }
+ hash = buf[0];
+
+ f2fs_hash = cpu_to_le32(hash & ~F2FS_HASH_COL_BIT);
+ return f2fs_hash;
+}
+
+unsigned int addrs_per_inode(struct f2fs_inode *i)
+{
+ if (i->i_inline & F2FS_INLINE_XATTR)
+ return DEF_ADDRS_PER_INODE - F2FS_INLINE_XATTR_ADDRS;
+ return DEF_ADDRS_PER_INODE;
+}
+
+/*
+ * CRC32
+ */
+#define CRCPOLY_LE 0xedb88320
+
+u_int32_t f2fs_cal_crc32(u_int32_t crc, void *buf, int len)
+{
+ int i;
+ unsigned char *p = (unsigned char *)buf;
+ while (len--) {
+ crc ^= *p++;
+ for (i = 0; i < 8; i++)
+ crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
+ }
+ return crc;
+}
+
+int f2fs_crc_valid(u_int32_t blk_crc, void *buf, int len)
+{
+ u_int32_t cal_crc = 0;
+
+ cal_crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, buf, len);
+
+ if (cal_crc != blk_crc) {
+ DBG(0,"CRC validation failed: cal_crc = %u, "
+ "blk_crc = %u buff_size = 0x%x\n",
+ cal_crc, blk_crc, len);
+ return -1;
+ }
+ return 0;
+}
+
+/*
+ * device information
+ */
+void f2fs_init_configuration(struct f2fs_configuration *c)
+{
+ c->total_sectors = 0;
+ c->sector_size = DEFAULT_SECTOR_SIZE;
+ c->sectors_per_blk = DEFAULT_SECTORS_PER_BLOCK;
+ c->blks_per_seg = DEFAULT_BLOCKS_PER_SEGMENT;
+
+ /* calculated by overprovision ratio */
+ c->reserved_segments = 48;
+ c->overprovision = 5;
+ c->segs_per_sec = 1;
+ c->secs_per_zone = 1;
+ c->segs_per_zone = 1;
+ c->heap = 1;
+ c->vol_label = "";
+ c->device_name = NULL;
+ c->trim = 1;
+}
+
+static int is_mounted(const char *mpt, const char *device)
+{
+ FILE *file = NULL;
+ struct mntent *mnt = NULL;
+
+ file = setmntent(mpt, "r");
+ if (file == NULL)
+ return 0;
+
+ while ((mnt = getmntent(file)) != NULL) {
+ if (!strcmp(device, mnt->mnt_fsname))
+ break;
+ }
+ endmntent(file);
+ return mnt ? 1 : 0;
+}
+
+int f2fs_dev_is_umounted(struct f2fs_configuration *c)
+{
+ struct stat st_buf;
+ int ret = 0;
+
+ ret = is_mounted(MOUNTED, c->device_name);
+ if (ret) {
+ MSG(0, "\tError: Not available on mounted device!\n");
+ return -1;
+ }
+
+ /*
+ * if failed due to /etc/mtab file not present
+ * try with /proc/mounts.
+ */
+ ret = is_mounted("/proc/mounts", c->device_name);
+ if (ret) {
+ MSG(0, "\tError: Not available on mounted device!\n");
+ return -1;
+ }
+
+ /*
+ * If f2fs is umounted with -l, the process can still use
+ * the file system. In this case, we should not format.
+ */
+ if (stat(c->device_name, &st_buf) == 0 && S_ISBLK(st_buf.st_mode)) {
+ int fd = open(c->device_name, O_RDONLY | O_EXCL);
+
+ if (fd >= 0) {
+ close(fd);
+ } else if (errno == EBUSY) {
+ MSG(0, "\tError: In use by the system!\n");
+ return -1;
+ }
+ }
+ return 0;
+}
+
+void get_kernel_version(__u8 *version)
+{
+ int i;
+ for (i = 0; i < VERSION_LEN; i++) {
+ if (version[i] == '\n')
+ break;
+ }
+ memset(version + i, 0, VERSION_LEN + 1 - i);
+}
+
+int f2fs_get_device_info(struct f2fs_configuration *c)
+{
+ int32_t fd = 0;
+ uint32_t sector_size;
+#ifndef BLKGETSIZE64
+ uint32_t total_sectors;
+#endif
+ struct stat stat_buf;
+ struct hd_geometry geom;
+ u_int64_t wanted_total_sectors = c->total_sectors;
+
+ fd = open(c->device_name, O_RDWR);
+ if (fd < 0) {
+ MSG(0, "\tError: Failed to open the device!\n");
+ return -1;
+ }
+ c->fd = fd;
+
+ c->kd = open("/proc/version", O_RDONLY);
+ if (c->kd < 0)
+ MSG(0, "\tInfo: No support kernel version!\n");
+
+ if (fstat(fd, &stat_buf) < 0 ) {
+ MSG(0, "\tError: Failed to get the device stat!\n");
+ return -1;
+ }
+
+ if (S_ISREG(stat_buf.st_mode)) {
+ c->total_sectors = stat_buf.st_size / c->sector_size;
+ } else if (S_ISBLK(stat_buf.st_mode)) {
+ if (ioctl(fd, BLKSSZGET, §or_size) < 0) {
+ MSG(0, "\tError: Using the default sector size\n");
+ } else {
+ if (c->sector_size < sector_size) {
+ c->sector_size = sector_size;
+ c->sectors_per_blk = PAGE_SIZE / sector_size;
+ }
+ }
+
+#ifdef BLKGETSIZE64
+ if (ioctl(fd, BLKGETSIZE64, &c->total_sectors) < 0) {
+ MSG(0, "\tError: Cannot get the device size\n");
+ return -1;
+ }
+ c->total_sectors /= c->sector_size;
+#else
+ if (ioctl(fd, BLKGETSIZE, &total_sectors) < 0) {
+ MSG(0, "\tError: Cannot get the device size\n");
+ return -1;
+ }
+ total_sectors /= c->sector_size;
+ c->total_sectors = total_sectors;
+#endif
+ if (ioctl(fd, HDIO_GETGEO, &geom) < 0)
+ c->start_sector = 0;
+ else
+ c->start_sector = geom.start;
+ } else {
+ MSG(0, "\tError: Volume type is not supported!!!\n");
+ return -1;
+ }
+ if (wanted_total_sectors && wanted_total_sectors < c->total_sectors) {
+ MSG(0, "Info: total device sectors = %"PRIu64" (in %u bytes)\n",
+ c->total_sectors, c->sector_size);
+ c->total_sectors = wanted_total_sectors;
+
+ }
+ MSG(0, "Info: sector size = %u\n", c->sector_size);
+ MSG(0, "Info: total sectors = %"PRIu64" (in %u bytes)\n",
+ c->total_sectors, c->sector_size);
+ if (c->total_sectors <
+ (F2FS_MIN_VOLUME_SIZE / c->sector_size)) {
+ MSG(0, "Error: Min volume size supported is %d\n",
+ F2FS_MIN_VOLUME_SIZE);
+ return -1;
+ }
+
+ return 0;
+}
+
diff --git a/f2fs-tools/lib/libf2fs_io.c b/f2fs-tools/lib/libf2fs_io.c
new file mode 100644
index 0000000..afa345f
--- /dev/null
+++ b/f2fs-tools/lib/libf2fs_io.c
@@ -0,0 +1,121 @@
+/**
+ * libf2fs.c
+ *
+ * Copyright (c) 2013 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com/
+ *
+ * Dual licensed under the GPL or LGPL version 2 licenses.
+ */
+#define _LARGEFILE64_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <mntent.h>
+#include <time.h>
+#include <sys/stat.h>
+#include <sys/mount.h>
+#include <sys/ioctl.h>
+#include <linux/hdreg.h>
+
+#include <f2fs_fs.h>
+
+struct f2fs_configuration config;
+
+/*
+ * IO interfaces
+ */
+int dev_read_version(void *buf, __u64 offset, size_t len)
+{
+ if (lseek64(config.kd, (off64_t)offset, SEEK_SET) < 0)
+ return -1;
+ if (read(config.kd, buf, len) < 0)
+ return -1;
+ return 0;
+}
+
+int dev_read(void *buf, __u64 offset, size_t len)
+{
+ if (lseek64(config.fd, (off64_t)offset, SEEK_SET) < 0)
+ return -1;
+ if (read(config.fd, buf, len) < 0)
+ return -1;
+ return 0;
+}
+
+int dev_readahead(__u64 offset, size_t len)
+{
+#ifdef POSIX_FADV_WILLNEED
+ return posix_fadvise(config.fd, offset, len, POSIX_FADV_WILLNEED);
+#else
+ return 0;
+#endif
+}
+
+int dev_write(void *buf, __u64 offset, size_t len)
+{
+ if (lseek64(config.fd, (off64_t)offset, SEEK_SET) < 0)
+ return -1;
+ if (write(config.fd, buf, len) < 0)
+ return -1;
+ return 0;
+}
+
+int dev_write_block(void *buf, __u64 blk_addr)
+{
+ return dev_write(buf, blk_addr * F2FS_BLKSIZE, F2FS_BLKSIZE);
+}
+
+int dev_write_dump(void *buf, __u64 offset, size_t len)
+{
+ if (lseek64(config.dump_fd, (off64_t)offset, SEEK_SET) < 0)
+ return -1;
+ if (write(config.dump_fd, buf, len) < 0)
+ return -1;
+ return 0;
+}
+
+int dev_fill(void *buf, __u64 offset, size_t len)
+{
+ /* Only allow fill to zero */
+ if (*((__u8*)buf))
+ return -1;
+ if (lseek64(config.fd, (off64_t)offset, SEEK_SET) < 0)
+ return -1;
+ if (write(config.fd, buf, len) < 0)
+ return -1;
+ return 0;
+}
+
+int dev_read_block(void *buf, __u64 blk_addr)
+{
+ return dev_read(buf, blk_addr * F2FS_BLKSIZE, F2FS_BLKSIZE);
+}
+
+int dev_read_blocks(void *buf, __u64 addr, __u32 nr_blks)
+{
+ return dev_read(buf, addr * F2FS_BLKSIZE, nr_blks * F2FS_BLKSIZE);
+}
+
+int dev_reada_block(__u64 blk_addr)
+{
+ return dev_readahead(blk_addr * F2FS_BLKSIZE, F2FS_BLKSIZE);
+}
+
+void f2fs_finalize_device(struct f2fs_configuration *c)
+{
+ /*
+ * We should call fsync() to flush out all the dirty pages
+ * in the block device page cache.
+ */
+ if (fsync(c->fd) < 0)
+ MSG(0, "\tError: Could not conduct fsync!!!\n");
+
+ if (close(c->fd) < 0)
+ MSG(0, "\tError: Failed to close device file!!!\n");
+
+ close(c->kd);
+}
diff --git a/f2fs-tools/man/Makefile.am b/f2fs-tools/man/Makefile.am
new file mode 100644
index 0000000..477d654
--- /dev/null
+++ b/f2fs-tools/man/Makefile.am
@@ -0,0 +1,3 @@
+## Makefile.am
+
+dist_man_MANS = mkfs.f2fs.8
diff --git a/f2fs-tools/man/mkfs.f2fs.8 b/f2fs-tools/man/mkfs.f2fs.8
new file mode 100644
index 0000000..f386ac6
--- /dev/null
+++ b/f2fs-tools/man/mkfs.f2fs.8
@@ -0,0 +1,91 @@
+.\" Copyright (c) 2012 Samsung Electronics Co., Ltd.
+.\" http://www.samsung.com/
+.\" Written by Jaegeuk Kim <jaegeuk.kim@samsung.com>
+.\"
+.TH MKFS.F2FS 8 "January 2013" "f2fs-tools version 1.2.0"
+.SH NAME
+mkfs.f2fs \- create an F2FS file system
+.SH SYNOPSIS
+.B mkfs.f2fs
+[
+.B \-a
+.I heap-based-allocation
+]
+[
+.B \-l
+.I volume-label
+]
+[
+.B \-o
+.I overprovision-ratio-percentage
+]
+[
+.B \-s
+.I log-based-#-of-segments-per-section
+]
+[
+.B \-z
+.I #-of-sections-per-zone
+]
+[
+.B \-e
+.I extenstion-list
+]
+[
+.B \-d
+.I debugging-level
+]
+.I device
+.SH DESCRIPTION
+.B mkfs.f2fs
+is used to create a f2fs file system (usually in a disk partition).
+\fIdevice\fP is the special file corresponding to the device (e.g.
+\fI/dev/sdXX\fP).
+.PP
+The exit code returned by
+.B mkfs.f2fs
+is 0 on success and 1 on failure.
+.SH OPTIONS
+.TP
+.BI \-a " heap-based-allocation"
+Specify 1 or 0 to enable/disable heap based block allocation policy.
+If the value is equal to 1, each of active log areas are initially
+assigned separately according to the whole volume size.
+The default value is 1.
+.TP
+.BI \-l " volume-label"
+Specify the volume label to the partition mounted as F2FS.
+.TP
+.BI \-o " overprovision-ratio-percentage"
+Specify the percentage over the volume size for overprovision area. This area
+is hidden to users, and utilized by F2FS cleaner. The default percentage is 5%.
+.TP
+.BI \-s " log-based-#-of-segments-per-section"
+Specify the log-based number of segments per section. A section consists of
+multiple consecutive segments, and is the unit of garbage collection.
+The default number is 0, which means one segment is assigned to a section.
+.TP
+.BI \-z " #-of-sections-per-zone"
+Specify the number of sections per zone. A zone consists of multiple sections.
+F2FS allocates segments for active logs with separated zones as much as possible.
+The default number is 1, which means a zone consists of one section.
+.TP
+.BI \-e " extension-list"
+Specify a file extension list in order f2fs to treat them as cold files.
+The data of files having those extensions will be stored to the cold log.
+The default list includes most of multimedia file extensions such as jpg, gif,
+mpeg, mkv, and so on.
+.TP
+.BI \-d " debug-level"
+Specify the level of debugging options.
+The default number is 0, which shows basic debugging messages.
+.TP
+.SH AUTHOR
+This version of
+.B mkfs.f2fs
+has been written by Jaegeuk Kim <jaegeuk.kim@samsung.com>.
+.SH AVAILABILITY
+.B mkfs.f2fs
+is available from git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs-tools.git.
+.SH SEE ALSO
+.BR mkfs (8).
diff --git a/f2fs-tools/mkfs/Makefile.am b/f2fs-tools/mkfs/Makefile.am
new file mode 100644
index 0000000..fa48699
--- /dev/null
+++ b/f2fs-tools/mkfs/Makefile.am
@@ -0,0 +1,7 @@
+## Makefile.am
+
+AM_CPPFLAGS = ${libuuid_CFLAGS} -I$(top_srcdir)/include
+AM_CFLAGS = -Wall -DWITH_BLKDISCARD
+sbin_PROGRAMS = mkfs.f2fs
+mkfs_f2fs_SOURCES = f2fs_format_main.c f2fs_format.c f2fs_format_utils.c
+mkfs_f2fs_LDADD = ${libuuid_LIBS} $(top_builddir)/lib/libf2fs.la
diff --git a/f2fs-tools/mkfs/f2fs_format.c b/f2fs-tools/mkfs/f2fs_format.c
new file mode 100644
index 0000000..094afa3
--- /dev/null
+++ b/f2fs-tools/mkfs/f2fs_format.c
@@ -0,0 +1,963 @@
+/**
+ * f2fs_format.c
+ *
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com/
+ *
+ * Dual licensed under the GPL or LGPL version 2 licenses.
+ */
+#define _LARGEFILE64_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/mount.h>
+#include <time.h>
+#include <uuid/uuid.h>
+
+#include "f2fs_fs.h"
+#include "f2fs_format_utils.h"
+
+extern struct f2fs_configuration config;
+struct f2fs_super_block sb;
+struct f2fs_checkpoint *cp;
+
+/* Return first segment number of each area */
+#define prev_zone(cur) (config.cur_seg[cur] - config.segs_per_zone)
+#define next_zone(cur) (config.cur_seg[cur] + config.segs_per_zone)
+#define last_zone(cur) ((cur - 1) * config.segs_per_zone)
+#define last_section(cur) (cur + (config.secs_per_zone - 1) * config.segs_per_sec)
+
+#define set_sb_le64(member, val) (sb.member = cpu_to_le64(val))
+#define set_sb_le32(member, val) (sb.member = cpu_to_le32(val))
+#define set_sb_le16(member, val) (sb.member = cpu_to_le16(val))
+#define get_sb_le64(member) le64_to_cpu(sb.member)
+#define get_sb_le32(member) le32_to_cpu(sb.member)
+#define get_sb_le16(member) le16_to_cpu(sb.member)
+
+#define set_sb(member, val) \
+ do { \
+ typeof(sb.member) t; \
+ switch (sizeof(t)) { \
+ case 8: set_sb_le64(member, val); break; \
+ case 4: set_sb_le32(member, val); break; \
+ case 2: set_sb_le16(member, val); break; \
+ } \
+ } while(0)
+
+#define get_sb(member) \
+ ({ \
+ typeof(sb.member) t; \
+ switch (sizeof(t)) { \
+ case 8: t = get_sb_le64(member); break; \
+ case 4: t = get_sb_le32(member); break; \
+ case 2: t = get_sb_le16(member); break; \
+ } \
+ t; \
+ })
+
+#define set_cp_le64(member, val) (cp->member = cpu_to_le64(val))
+#define set_cp_le32(member, val) (cp->member = cpu_to_le32(val))
+#define set_cp_le16(member, val) (cp->member = cpu_to_le16(val))
+#define get_cp_le64(member) le64_to_cpu(cp->member)
+#define get_cp_le32(member) le32_to_cpu(cp->member)
+#define get_cp_le16(member) le16_to_cpu(cp->member)
+
+#define set_cp(member, val) \
+ do { \
+ typeof(cp->member) t; \
+ switch (sizeof(t)) { \
+ case 8: set_cp_le64(member, val); break; \
+ case 4: set_cp_le32(member, val); break; \
+ case 2: set_cp_le16(member, val); break; \
+ } \
+ } while(0)
+
+#define get_cp(member) \
+ ({ \
+ typeof(cp->member) t; \
+ switch (sizeof(t)) { \
+ case 8: t = get_cp_le64(member); break; \
+ case 4: t = get_cp_le32(member); break; \
+ case 2: t = get_cp_le16(member); break; \
+ } \
+ t; \
+ })
+
+
+const char *media_ext_lists[] = {
+ "jpg",
+ "gif",
+ "png",
+ "avi",
+ "divx",
+ "mp4",
+ "mp3",
+ "3gp",
+ "wmv",
+ "wma",
+ "mpeg",
+ "mkv",
+ "mov",
+ "asx",
+ "asf",
+ "wmx",
+ "svi",
+ "wvx",
+ "wm",
+ "mpg",
+ "mpe",
+ "rm",
+ "ogg",
+ "jpeg",
+ "video",
+ "apk", /* for android system */
+ NULL
+};
+
+static void configure_extension_list(void)
+{
+ const char **extlist = media_ext_lists;
+ char *ext_str = config.extension_list;
+ char *ue;
+ int name_len;
+ int i = 0;
+
+ sb.extension_count = 0;
+ memset(sb.extension_list, 0,
+ sizeof(sb.extension_list));
+
+ while (*extlist) {
+ name_len = strlen(*extlist);
+ memcpy(sb.extension_list[i++], *extlist, name_len);
+ extlist++;
+ }
+ set_sb(extension_count, i);
+
+ if (!ext_str)
+ return;
+
+ /* add user ext list */
+ ue = strtok(ext_str, ",");
+ while (ue != NULL) {
+ name_len = strlen(ue);
+ memcpy(sb.extension_list[i++], ue, name_len);
+ ue = strtok(NULL, ",");
+ if (i >= F2FS_MAX_EXTENSION)
+ break;
+ }
+
+ set_sb(extension_count, i);
+
+ free(config.extension_list);
+}
+
+static int f2fs_prepare_super_block(void)
+{
+ u_int32_t blk_size_bytes;
+ u_int32_t log_sectorsize, log_sectors_per_block;
+ u_int32_t log_blocksize, log_blks_per_seg;
+ u_int32_t segment_size_bytes, zone_size_bytes;
+ u_int32_t sit_segments;
+ u_int32_t blocks_for_sit, blocks_for_nat, blocks_for_ssa;
+ u_int32_t total_valid_blks_available;
+ u_int64_t zone_align_start_offset, diff, total_meta_segments;
+ u_int32_t sit_bitmap_size, max_sit_bitmap_size;
+ u_int32_t max_nat_bitmap_size, max_nat_segments;
+ u_int32_t total_zones;
+
+ set_sb(magic, F2FS_SUPER_MAGIC);
+ set_sb(major_ver, F2FS_MAJOR_VERSION);
+ set_sb(minor_ver, F2FS_MINOR_VERSION);
+
+ log_sectorsize = log_base_2(config.sector_size);
+ log_sectors_per_block = log_base_2(config.sectors_per_blk);
+ log_blocksize = log_sectorsize + log_sectors_per_block;
+ log_blks_per_seg = log_base_2(config.blks_per_seg);
+
+ set_sb(log_sectorsize, log_sectorsize);
+ set_sb(log_sectors_per_block, log_sectors_per_block);
+
+ set_sb(log_blocksize, log_blocksize);
+ set_sb(log_blocks_per_seg, log_blks_per_seg);
+
+ set_sb(segs_per_sec, config.segs_per_sec);
+ set_sb(secs_per_zone, config.secs_per_zone);
+
+ blk_size_bytes = 1 << log_blocksize;
+ segment_size_bytes = blk_size_bytes * config.blks_per_seg;
+ zone_size_bytes =
+ blk_size_bytes * config.secs_per_zone *
+ config.segs_per_sec * config.blks_per_seg;
+
+ sb.checksum_offset = 0;
+
+ set_sb(block_count, config.total_sectors >> log_sectors_per_block);
+
+ zone_align_start_offset =
+ (config.start_sector * config.sector_size +
+ 2 * F2FS_BLKSIZE + zone_size_bytes - 1) /
+ zone_size_bytes * zone_size_bytes -
+ config.start_sector * config.sector_size;
+
+ if (config.start_sector % config.sectors_per_blk) {
+ MSG(1, "\tWARN: Align start sector number to the page unit\n");
+ MSG(1, "\ti.e., start sector: %d, ofs:%d (sects/page: %d)\n",
+ config.start_sector,
+ config.start_sector % config.sectors_per_blk,
+ config.sectors_per_blk);
+ }
+
+ set_sb(segment_count, (config.total_sectors * config.sector_size -
+ zone_align_start_offset) / segment_size_bytes);
+
+ set_sb(segment0_blkaddr, zone_align_start_offset / blk_size_bytes);
+ sb.cp_blkaddr = sb.segment0_blkaddr;
+
+ MSG(0, "Info: zone aligned segment0 blkaddr: %u\n", get_sb(segment0_blkaddr));
+
+ set_sb(segment_count_ckpt, F2FS_NUMBER_OF_CHECKPOINT_PACK);
+
+ set_sb(sit_blkaddr, get_sb(segment0_blkaddr) + get_sb(segment_count_ckpt) *
+ config.blks_per_seg);
+
+ blocks_for_sit = ALIGN(get_sb(segment_count), SIT_ENTRY_PER_BLOCK);
+
+ sit_segments = SEG_ALIGN(blocks_for_sit);
+
+ set_sb(segment_count_sit, sit_segments * 2);
+
+ set_sb(nat_blkaddr, get_sb(sit_blkaddr) + get_sb(segment_count_sit) *
+ config.blks_per_seg);
+
+ total_valid_blks_available = (get_sb(segment_count) -
+ (get_sb(segment_count_ckpt) + get_sb(segment_count_sit))) *
+ config.blks_per_seg;
+
+ blocks_for_nat = ALIGN(total_valid_blks_available, NAT_ENTRY_PER_BLOCK);
+
+ set_sb(segment_count_nat, SEG_ALIGN(blocks_for_nat));
+ /*
+ * The number of node segments should not be exceeded a "Threshold".
+ * This number resizes NAT bitmap area in a CP page.
+ * So the threshold is determined not to overflow one CP page
+ */
+ sit_bitmap_size = ((get_sb(segment_count_sit) / 2) <<
+ log_blks_per_seg) / 8;
+
+ if (sit_bitmap_size > MAX_SIT_BITMAP_SIZE)
+ max_sit_bitmap_size = MAX_SIT_BITMAP_SIZE;
+ else
+ max_sit_bitmap_size = sit_bitmap_size;
+
+ /*
+ * It should be reserved minimum 1 segment for nat.
+ * When sit is too large, we should expand cp area. It requires more pages for cp.
+ */
+ if (max_sit_bitmap_size >
+ (CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 65)) {
+ max_nat_bitmap_size = CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1;
+ set_sb(cp_payload, F2FS_BLK_ALIGN(max_sit_bitmap_size));
+ } else {
+ max_nat_bitmap_size = CHECKSUM_OFFSET - sizeof(struct f2fs_checkpoint) + 1
+ - max_sit_bitmap_size;
+ sb.cp_payload = 0;
+ }
+
+ max_nat_segments = (max_nat_bitmap_size * 8) >> log_blks_per_seg;
+
+ if (get_sb(segment_count_nat) > max_nat_segments)
+ set_sb(segment_count_nat, max_nat_segments);
+
+ set_sb(segment_count_nat, get_sb(segment_count_nat) * 2);
+
+ set_sb(ssa_blkaddr, get_sb(nat_blkaddr) + get_sb(segment_count_nat) *
+ config.blks_per_seg);
+
+ total_valid_blks_available = (get_sb(segment_count) -
+ (get_sb(segment_count_ckpt) +
+ get_sb(segment_count_sit) +
+ get_sb(segment_count_nat))) *
+ config.blks_per_seg;
+
+ blocks_for_ssa = total_valid_blks_available /
+ config.blks_per_seg + 1;
+
+ set_sb(segment_count_ssa, SEG_ALIGN(blocks_for_ssa));
+
+ total_meta_segments = get_sb(segment_count_ckpt) +
+ get_sb(segment_count_sit) +
+ get_sb(segment_count_nat) +
+ get_sb(segment_count_ssa);
+ diff = total_meta_segments % (config.segs_per_zone);
+ if (diff)
+ set_sb(segment_count_ssa, get_sb(segment_count_ssa) +
+ (config.segs_per_zone - diff));
+
+ set_sb(main_blkaddr, get_sb(ssa_blkaddr) + get_sb(segment_count_ssa) *
+ config.blks_per_seg);
+
+ set_sb(segment_count_main, get_sb(segment_count) -
+ (get_sb(segment_count_ckpt) +
+ get_sb(segment_count_sit) +
+ get_sb(segment_count_nat) +
+ get_sb(segment_count_ssa)));
+
+ set_sb(section_count, get_sb(segment_count_main) / config.segs_per_sec);
+
+ set_sb(segment_count_main, get_sb(section_count) * config.segs_per_sec);
+
+ if ((get_sb(segment_count_main) - 2) <
+ config.reserved_segments) {
+ MSG(1, "\tError: Device size is not sufficient for F2FS volume,\
+ more segment needed =%u",
+ config.reserved_segments -
+ (get_sb(segment_count_main) - 2));
+ return -1;
+ }
+
+ uuid_generate(sb.uuid);
+
+ ASCIIToUNICODE(sb.volume_name, (u_int8_t *)config.vol_label);
+
+ set_sb(node_ino, 1);
+ set_sb(meta_ino, 2);
+ set_sb(root_ino, 3);
+
+ total_zones = get_sb(segment_count_main) / (config.segs_per_zone);
+ if (total_zones <= 6) {
+ MSG(1, "\tError: %d zones: Need more zones \
+ by shrinking zone size\n", total_zones);
+ return -1;
+ }
+
+ if (config.heap) {
+ config.cur_seg[CURSEG_HOT_NODE] = last_section(last_zone(total_zones));
+ config.cur_seg[CURSEG_WARM_NODE] = prev_zone(CURSEG_HOT_NODE);
+ config.cur_seg[CURSEG_COLD_NODE] = prev_zone(CURSEG_WARM_NODE);
+ config.cur_seg[CURSEG_HOT_DATA] = prev_zone(CURSEG_COLD_NODE);
+ config.cur_seg[CURSEG_COLD_DATA] = 0;
+ config.cur_seg[CURSEG_WARM_DATA] = next_zone(CURSEG_COLD_DATA);
+ } else {
+ config.cur_seg[CURSEG_HOT_NODE] = 0;
+ config.cur_seg[CURSEG_WARM_NODE] = next_zone(CURSEG_HOT_NODE);
+ config.cur_seg[CURSEG_COLD_NODE] = next_zone(CURSEG_WARM_NODE);
+ config.cur_seg[CURSEG_HOT_DATA] = next_zone(CURSEG_COLD_NODE);
+ config.cur_seg[CURSEG_COLD_DATA] = next_zone(CURSEG_HOT_DATA);
+ config.cur_seg[CURSEG_WARM_DATA] = next_zone(CURSEG_COLD_DATA);
+ }
+
+ configure_extension_list();
+
+ /* get kernel version */
+ if (config.kd >= 0) {
+ dev_read_version(config.version, 0, VERSION_LEN);
+ get_kernel_version(config.version);
+ MSG(0, "Info: format version with\n \"%s\"\n", config.version);
+ } else {
+ memset(config.version, 0, VERSION_LEN);
+ }
+
+ memcpy(sb.version, config.version, VERSION_LEN);
+ memcpy(sb.init_version, config.version, VERSION_LEN);
+
+ return 0;
+}
+
+static int f2fs_init_sit_area(void)
+{
+ u_int32_t blk_size, seg_size;
+ u_int32_t index = 0;
+ u_int64_t sit_seg_addr = 0;
+ u_int8_t *zero_buf = NULL;
+
+ blk_size = 1 << get_sb(log_blocksize);
+ seg_size = (1 << get_sb(log_blocks_per_seg)) * blk_size;
+
+ zero_buf = calloc(sizeof(u_int8_t), seg_size);
+ if(zero_buf == NULL) {
+ MSG(1, "\tError: Calloc Failed for sit_zero_buf!!!\n");
+ return -1;
+ }
+
+ sit_seg_addr = get_sb(sit_blkaddr);
+ sit_seg_addr *= blk_size;
+
+ DBG(1, "\tFilling sit area at offset 0x%08"PRIx64"\n", sit_seg_addr);
+ for (index = 0; index < (get_sb(segment_count_sit) / 2); index++) {
+ if (dev_fill(zero_buf, sit_seg_addr, seg_size)) {
+ MSG(1, "\tError: While zeroing out the sit area \
+ on disk!!!\n");
+ free(zero_buf);
+ return -1;
+ }
+ sit_seg_addr += seg_size;
+ }
+
+ free(zero_buf);
+ return 0 ;
+}
+
+static int f2fs_init_nat_area(void)
+{
+ u_int32_t blk_size, seg_size;
+ u_int32_t index = 0;
+ u_int64_t nat_seg_addr = 0;
+ u_int8_t *nat_buf = NULL;
+
+ blk_size = 1 << get_sb(log_blocksize);
+ seg_size = (1 << get_sb(log_blocks_per_seg)) * blk_size;
+
+ nat_buf = calloc(sizeof(u_int8_t), seg_size);
+ if (nat_buf == NULL) {
+ MSG(1, "\tError: Calloc Failed for nat_zero_blk!!!\n");
+ return -1;
+ }
+
+ nat_seg_addr = get_sb(nat_blkaddr);
+ nat_seg_addr *= blk_size;
+
+ DBG(1, "\tFilling nat area at offset 0x%08"PRIx64"\n", nat_seg_addr);
+ for (index = 0; index < get_sb(segment_count_nat) / 2; index++) {
+ if (dev_fill(nat_buf, nat_seg_addr, seg_size)) {
+ MSG(1, "\tError: While zeroing out the nat area \
+ on disk!!!\n");
+ free(nat_buf);
+ return -1;
+ }
+ nat_seg_addr = nat_seg_addr + (2 * seg_size);
+ }
+
+ free(nat_buf);
+ return 0 ;
+}
+
+static int f2fs_write_check_point_pack(void)
+{
+ struct f2fs_summary_block *sum = NULL;
+ u_int32_t blk_size_bytes;
+ u_int64_t cp_seg_blk_offset = 0;
+ u_int32_t crc = 0;
+ unsigned int i;
+ char *cp_payload = NULL;
+ char *sum_compact, *sum_compact_p;
+ struct f2fs_summary *sum_entry;
+ int ret = -1;
+
+ cp = calloc(F2FS_BLKSIZE, 1);
+ if (cp == NULL) {
+ MSG(1, "\tError: Calloc Failed for f2fs_checkpoint!!!\n");
+ return ret;
+ }
+
+ sum = calloc(F2FS_BLKSIZE, 1);
+ if (sum == NULL) {
+ MSG(1, "\tError: Calloc Failed for summay_node!!!\n");
+ goto free_cp;
+ }
+
+ sum_compact = calloc(F2FS_BLKSIZE, 1);
+ if (sum == NULL) {
+ MSG(1, "\tError: Calloc Failed for summay buffer!!!\n");
+ goto free_sum;
+ }
+ sum_compact_p = sum_compact;
+
+ cp_payload = calloc(F2FS_BLKSIZE, 1);
+ if (cp_payload == NULL) {
+ MSG(1, "\tError: Calloc Failed for cp_payload!!!\n");
+ goto free_sum_compact;
+ }
+
+ /* 1. cp page 1 of checkpoint pack 1 */
+ set_cp(checkpoint_ver, 1);
+ set_cp(cur_node_segno[0], config.cur_seg[CURSEG_HOT_NODE]);
+ set_cp(cur_node_segno[1], config.cur_seg[CURSEG_WARM_NODE]);
+ set_cp(cur_node_segno[2], config.cur_seg[CURSEG_COLD_NODE]);
+ set_cp(cur_data_segno[0], config.cur_seg[CURSEG_HOT_DATA]);
+ set_cp(cur_data_segno[1], config.cur_seg[CURSEG_WARM_DATA]);
+ set_cp(cur_data_segno[2], config.cur_seg[CURSEG_COLD_DATA]);
+ for (i = 3; i < MAX_ACTIVE_NODE_LOGS; i++) {
+ set_cp(cur_node_segno[i], 0xffffffff);
+ set_cp(cur_data_segno[i], 0xffffffff);
+ }
+
+ set_cp(cur_node_blkoff[0], 1);
+ set_cp(cur_data_blkoff[0], 1);
+ set_cp(valid_block_count, 2);
+ set_cp(rsvd_segment_count, config.reserved_segments);
+ set_cp(overprov_segment_count, (get_sb(segment_count_main) -
+ get_cp(rsvd_segment_count)) *
+ config.overprovision / 100);
+ set_cp(overprov_segment_count, get_cp(overprov_segment_count) +
+ get_cp(rsvd_segment_count));
+
+ /* main segments - reserved segments - (node + data segments) */
+ set_cp(free_segment_count, get_sb(segment_count_main) - 6);
+ set_cp(user_block_count, ((get_cp(free_segment_count) + 6 -
+ get_cp(overprov_segment_count)) * config.blks_per_seg));
+ /* cp page (2), data summaries (1), node summaries (3) */
+ set_cp(cp_pack_total_block_count, 6 + get_sb(cp_payload));
+ set_cp(ckpt_flags, CP_UMOUNT_FLAG | CP_COMPACT_SUM_FLAG);
+ set_cp(cp_pack_start_sum, 1 + get_sb(cp_payload));
+ set_cp(valid_node_count, 1);
+ set_cp(valid_inode_count, 1);
+ set_cp(next_free_nid, get_sb(root_ino) + 1);
+ set_cp(sit_ver_bitmap_bytesize, ((get_sb(segment_count_sit) / 2) <<
+ get_sb(log_blocks_per_seg)) / 8);
+
+ set_cp(nat_ver_bitmap_bytesize, ((get_sb(segment_count_nat) / 2) <<
+ get_sb(log_blocks_per_seg)) / 8);
+
+ set_cp(checksum_offset, CHECKSUM_OFFSET);
+
+ crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET);
+ *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) =
+ cpu_to_le32(crc);
+
+ blk_size_bytes = 1 << get_sb(log_blocksize);
+ cp_seg_blk_offset = get_sb(segment0_blkaddr);
+ cp_seg_blk_offset *= blk_size_bytes;
+
+ DBG(1, "\tWriting main segments, cp at offset 0x%08"PRIx64"\n", cp_seg_blk_offset);
+ if (dev_write(cp, cp_seg_blk_offset, blk_size_bytes)) {
+ MSG(1, "\tError: While writing the cp to disk!!!\n");
+ goto free_cp_payload;
+ }
+
+ for (i = 0; i < get_sb(cp_payload); i++) {
+ cp_seg_blk_offset += blk_size_bytes;
+ if (dev_fill(cp_payload, cp_seg_blk_offset, blk_size_bytes)) {
+ MSG(1, "\tError: While zeroing out the sit bitmap area \
+ on disk!!!\n");
+ goto free_cp_payload;
+ }
+ }
+
+ /* Prepare and write Segment summary for HOT/WARM/COLD DATA
+ *
+ * The structure of compact summary
+ * +-------------------+
+ * | nat_journal |
+ * +-------------------+
+ * | sit_journal |
+ * +-------------------+
+ * | hot data summary |
+ * +-------------------+
+ * | warm data summary |
+ * +-------------------+
+ * | cold data summary |
+ * +-------------------+
+ */
+ memset(sum, 0, sizeof(struct f2fs_summary_block));
+ SET_SUM_TYPE((&sum->footer), SUM_TYPE_DATA);
+
+ sum->n_nats = cpu_to_le16(1);
+ sum->nat_j.entries[0].nid = sb.root_ino;
+ sum->nat_j.entries[0].ne.version = 0;
+ sum->nat_j.entries[0].ne.ino = sb.root_ino;
+ sum->nat_j.entries[0].ne.block_addr = cpu_to_le32(
+ get_sb(main_blkaddr) +
+ get_cp(cur_node_segno[0]) * config.blks_per_seg);
+
+ memcpy(sum_compact_p, &sum->n_nats, SUM_JOURNAL_SIZE);
+ sum_compact_p += SUM_JOURNAL_SIZE;
+
+ memset(sum, 0, sizeof(struct f2fs_summary_block));
+ /* inode sit for root */
+ sum->n_sits = cpu_to_le16(6);
+ sum->sit_j.entries[0].segno = cp->cur_node_segno[0];
+ sum->sit_j.entries[0].se.vblocks = cpu_to_le16((CURSEG_HOT_NODE << 10) | 1);
+ f2fs_set_bit(0, (char *)sum->sit_j.entries[0].se.valid_map);
+ sum->sit_j.entries[1].segno = cp->cur_node_segno[1];
+ sum->sit_j.entries[1].se.vblocks = cpu_to_le16((CURSEG_WARM_NODE << 10));
+ sum->sit_j.entries[2].segno = cp->cur_node_segno[2];
+ sum->sit_j.entries[2].se.vblocks = cpu_to_le16((CURSEG_COLD_NODE << 10));
+
+ /* data sit for root */
+ sum->sit_j.entries[3].segno = cp->cur_data_segno[0];
+ sum->sit_j.entries[3].se.vblocks = cpu_to_le16((CURSEG_HOT_DATA << 10) | 1);
+ f2fs_set_bit(0, (char *)sum->sit_j.entries[3].se.valid_map);
+ sum->sit_j.entries[4].segno = cp->cur_data_segno[1];
+ sum->sit_j.entries[4].se.vblocks = cpu_to_le16((CURSEG_WARM_DATA << 10));
+ sum->sit_j.entries[5].segno = cp->cur_data_segno[2];
+ sum->sit_j.entries[5].se.vblocks = cpu_to_le16((CURSEG_COLD_DATA << 10));
+
+ memcpy(sum_compact_p, &sum->n_sits, SUM_JOURNAL_SIZE);
+ sum_compact_p += SUM_JOURNAL_SIZE;
+
+ /* hot data summary */
+ sum_entry = (struct f2fs_summary *)sum_compact_p;
+ sum_entry->nid = sb.root_ino;
+ sum_entry->ofs_in_node = 0;
+ /* warm data summary, nothing to do */
+ /* cold data summary, nothing to do */
+
+ cp_seg_blk_offset += blk_size_bytes;
+ DBG(1, "\tWriting Segment summary for HOT/WARM/COLD_DATA, at offset 0x%08"PRIx64"\n",
+ cp_seg_blk_offset);
+ if (dev_write(sum_compact, cp_seg_blk_offset, blk_size_bytes)) {
+ MSG(1, "\tError: While writing the sum_blk to disk!!!\n");
+ goto free_cp_payload;
+ }
+
+ /* Prepare and write Segment summary for HOT_NODE */
+ memset(sum, 0, sizeof(struct f2fs_summary_block));
+ SET_SUM_TYPE((&sum->footer), SUM_TYPE_NODE);
+
+ sum->entries[0].nid = sb.root_ino;
+ sum->entries[0].ofs_in_node = 0;
+
+ cp_seg_blk_offset += blk_size_bytes;
+ DBG(1, "\tWriting Segment summary for HOT_NODE, at offset 0x%08"PRIx64"\n",
+ cp_seg_blk_offset);
+ if (dev_write(sum, cp_seg_blk_offset, blk_size_bytes)) {
+ MSG(1, "\tError: While writing the sum_blk to disk!!!\n");
+ goto free_cp_payload;
+ }
+
+ /* Fill segment summary for WARM_NODE to zero. */
+ memset(sum, 0, sizeof(struct f2fs_summary_block));
+ SET_SUM_TYPE((&sum->footer), SUM_TYPE_NODE);
+
+ cp_seg_blk_offset += blk_size_bytes;
+ DBG(1, "\tWriting Segment summary for WARM_NODE, at offset 0x%08"PRIx64"\n",
+ cp_seg_blk_offset);
+ if (dev_write(sum, cp_seg_blk_offset, blk_size_bytes)) {
+ MSG(1, "\tError: While writing the sum_blk to disk!!!\n");
+ goto free_cp_payload;
+ }
+
+ /* Fill segment summary for COLD_NODE to zero. */
+ memset(sum, 0, sizeof(struct f2fs_summary_block));
+ SET_SUM_TYPE((&sum->footer), SUM_TYPE_NODE);
+ cp_seg_blk_offset += blk_size_bytes;
+ DBG(1, "\tWriting Segment summary for COLD_NODE, at offset 0x%08"PRIx64"\n",
+ cp_seg_blk_offset);
+ if (dev_write(sum, cp_seg_blk_offset, blk_size_bytes)) {
+ MSG(1, "\tError: While writing the sum_blk to disk!!!\n");
+ goto free_cp_payload;
+ }
+
+ /* cp page2 */
+ cp_seg_blk_offset += blk_size_bytes;
+ DBG(1, "\tWriting cp page2, at offset 0x%08"PRIx64"\n", cp_seg_blk_offset);
+ if (dev_write(cp, cp_seg_blk_offset, blk_size_bytes)) {
+ MSG(1, "\tError: While writing the cp to disk!!!\n");
+ goto free_cp_payload;
+ }
+
+ /* cp page 1 of check point pack 2
+ * Initiatialize other checkpoint pack with version zero
+ */
+ cp->checkpoint_ver = 0;
+
+ crc = f2fs_cal_crc32(F2FS_SUPER_MAGIC, cp, CHECKSUM_OFFSET);
+ *((__le32 *)((unsigned char *)cp + CHECKSUM_OFFSET)) =
+ cpu_to_le32(crc);
+ cp_seg_blk_offset = (get_sb(segment0_blkaddr) +
+ config.blks_per_seg) *
+ blk_size_bytes;
+ DBG(1, "\tWriting cp page 1 of checkpoint pack 2, at offset 0x%08"PRIx64"\n", cp_seg_blk_offset);
+ if (dev_write(cp, cp_seg_blk_offset, blk_size_bytes)) {
+ MSG(1, "\tError: While writing the cp to disk!!!\n");
+ goto free_cp_payload;
+ }
+
+ for (i = 0; i < get_sb(cp_payload); i++) {
+ cp_seg_blk_offset += blk_size_bytes;
+ if (dev_fill(cp_payload, cp_seg_blk_offset, blk_size_bytes)) {
+ MSG(1, "\tError: While zeroing out the sit bitmap area \
+ on disk!!!\n");
+ goto free_cp_payload;
+ }
+ }
+
+ /* cp page 2 of check point pack 2 */
+ cp_seg_blk_offset += blk_size_bytes * (le32_to_cpu(cp->cp_pack_total_block_count)
+ - get_sb(cp_payload) - 1);
+ DBG(1, "\tWriting cp page 2 of checkpoint pack 2, at offset 0x%08"PRIx64"\n", cp_seg_blk_offset);
+ if (dev_write(cp, cp_seg_blk_offset, blk_size_bytes)) {
+ MSG(1, "\tError: While writing the cp to disk!!!\n");
+ goto free_cp_payload;
+ }
+
+ ret = 0;
+
+free_cp_payload:
+ free(cp_payload);
+free_sum_compact:
+ free(sum_compact);
+free_sum:
+ free(sum);
+free_cp:
+ free(cp);
+ return ret;
+}
+
+static int f2fs_write_super_block(void)
+{
+ int index;
+ u_int8_t *zero_buff;
+
+ zero_buff = calloc(F2FS_BLKSIZE, 1);
+
+ memcpy(zero_buff + F2FS_SUPER_OFFSET, &sb,
+ sizeof(sb));
+ DBG(1, "\tWriting super block, at offset 0x%08x\n", 0);
+ for (index = 0; index < 2; index++) {
+ if (dev_write(zero_buff, index * F2FS_BLKSIZE, F2FS_BLKSIZE)) {
+ MSG(1, "\tError: While while writing supe_blk \
+ on disk!!! index : %d\n", index);
+ free(zero_buff);
+ return -1;
+ }
+ }
+
+ free(zero_buff);
+ return 0;
+}
+
+static int f2fs_write_root_inode(void)
+{
+ struct f2fs_node *raw_node = NULL;
+ u_int64_t blk_size_bytes, data_blk_nor;
+ u_int64_t main_area_node_seg_blk_offset = 0;
+
+ raw_node = calloc(F2FS_BLKSIZE, 1);
+ if (raw_node == NULL) {
+ MSG(1, "\tError: Calloc Failed for raw_node!!!\n");
+ return -1;
+ }
+
+ raw_node->footer.nid = sb.root_ino;
+ raw_node->footer.ino = sb.root_ino;
+ raw_node->footer.cp_ver = cpu_to_le64(1);
+ raw_node->footer.next_blkaddr = cpu_to_le32(
+ get_sb(main_blkaddr) +
+ config.cur_seg[CURSEG_HOT_NODE] *
+ config.blks_per_seg + 1);
+
+ raw_node->i.i_mode = cpu_to_le16(0x41ed);
+ raw_node->i.i_links = cpu_to_le32(2);
+ raw_node->i.i_uid = cpu_to_le32(getuid());
+ raw_node->i.i_gid = cpu_to_le32(getgid());
+
+ blk_size_bytes = 1 << get_sb(log_blocksize);
+ raw_node->i.i_size = cpu_to_le64(1 * blk_size_bytes); /* dentry */
+ raw_node->i.i_blocks = cpu_to_le64(2);
+
+ raw_node->i.i_atime = cpu_to_le32(time(NULL));
+ raw_node->i.i_atime_nsec = 0;
+ raw_node->i.i_ctime = cpu_to_le32(time(NULL));
+ raw_node->i.i_ctime_nsec = 0;
+ raw_node->i.i_mtime = cpu_to_le32(time(NULL));
+ raw_node->i.i_mtime_nsec = 0;
+ raw_node->i.i_generation = 0;
+ raw_node->i.i_xattr_nid = 0;
+ raw_node->i.i_flags = 0;
+ raw_node->i.i_current_depth = cpu_to_le32(1);
+ raw_node->i.i_dir_level = DEF_DIR_LEVEL;
+
+ data_blk_nor = get_sb(main_blkaddr) +
+ config.cur_seg[CURSEG_HOT_DATA] * config.blks_per_seg;
+ raw_node->i.i_addr[0] = cpu_to_le32(data_blk_nor);
+
+ raw_node->i.i_ext.fofs = 0;
+ raw_node->i.i_ext.blk_addr = cpu_to_le32(data_blk_nor);
+ raw_node->i.i_ext.len = cpu_to_le32(1);
+
+ main_area_node_seg_blk_offset = get_sb(main_blkaddr);
+ main_area_node_seg_blk_offset += config.cur_seg[CURSEG_HOT_NODE] *
+ config.blks_per_seg;
+ main_area_node_seg_blk_offset *= blk_size_bytes;
+
+ DBG(1, "\tWriting root inode (hot node), at offset 0x%08"PRIx64"\n", main_area_node_seg_blk_offset);
+ if (dev_write(raw_node, main_area_node_seg_blk_offset, F2FS_BLKSIZE)) {
+ MSG(1, "\tError: While writing the raw_node to disk!!!\n");
+ free(raw_node);
+ return -1;
+ }
+
+ memset(raw_node, 0xff, sizeof(struct f2fs_node));
+
+ /* avoid power-off-recovery based on roll-forward policy */
+ main_area_node_seg_blk_offset = get_sb(main_blkaddr);
+ main_area_node_seg_blk_offset += config.cur_seg[CURSEG_WARM_NODE] *
+ config.blks_per_seg;
+ main_area_node_seg_blk_offset *= blk_size_bytes;
+
+ DBG(1, "\tWriting root inode (warm node), at offset 0x%08"PRIx64"\n", main_area_node_seg_blk_offset);
+ if (dev_write(raw_node, main_area_node_seg_blk_offset, F2FS_BLKSIZE)) {
+ MSG(1, "\tError: While writing the raw_node to disk!!!\n");
+ free(raw_node);
+ return -1;
+ }
+ free(raw_node);
+ return 0;
+}
+
+static int f2fs_update_nat_root(void)
+{
+ struct f2fs_nat_block *nat_blk = NULL;
+ u_int64_t blk_size_bytes, nat_seg_blk_offset = 0;
+
+ nat_blk = calloc(F2FS_BLKSIZE, 1);
+ if(nat_blk == NULL) {
+ MSG(1, "\tError: Calloc Failed for nat_blk!!!\n");
+ return -1;
+ }
+
+ /* update root */
+ nat_blk->entries[get_sb(root_ino)].block_addr = cpu_to_le32(
+ get_sb(main_blkaddr) +
+ config.cur_seg[CURSEG_HOT_NODE] * config.blks_per_seg);
+ nat_blk->entries[get_sb(root_ino)].ino = sb.root_ino;
+
+ /* update node nat */
+ nat_blk->entries[get_sb(node_ino)].block_addr = cpu_to_le32(1);
+ nat_blk->entries[get_sb(node_ino)].ino = sb.node_ino;
+
+ /* update meta nat */
+ nat_blk->entries[get_sb(meta_ino)].block_addr = cpu_to_le32(1);
+ nat_blk->entries[get_sb(meta_ino)].ino = sb.meta_ino;
+
+ blk_size_bytes = 1 << get_sb(log_blocksize);
+ nat_seg_blk_offset = get_sb(nat_blkaddr);
+ nat_seg_blk_offset *= blk_size_bytes;
+
+ DBG(1, "\tWriting nat root, at offset 0x%08"PRIx64"\n", nat_seg_blk_offset);
+ if (dev_write(nat_blk, nat_seg_blk_offset, F2FS_BLKSIZE)) {
+ MSG(1, "\tError: While writing the nat_blk set0 to disk!\n");
+ free(nat_blk);
+ return -1;
+ }
+
+ free(nat_blk);
+ return 0;
+}
+
+static int f2fs_add_default_dentry_root(void)
+{
+ struct f2fs_dentry_block *dent_blk = NULL;
+ u_int64_t blk_size_bytes, data_blk_offset = 0;
+
+ dent_blk = calloc(F2FS_BLKSIZE, 1);
+ if(dent_blk == NULL) {
+ MSG(1, "\tError: Calloc Failed for dent_blk!!!\n");
+ return -1;
+ }
+
+ dent_blk->dentry[0].hash_code = 0;
+ dent_blk->dentry[0].ino = sb.root_ino;
+ dent_blk->dentry[0].name_len = cpu_to_le16(1);
+ dent_blk->dentry[0].file_type = F2FS_FT_DIR;
+ memcpy(dent_blk->filename[0], ".", 1);
+
+ dent_blk->dentry[1].hash_code = 0;
+ dent_blk->dentry[1].ino = sb.root_ino;
+ dent_blk->dentry[1].name_len = cpu_to_le16(2);
+ dent_blk->dentry[1].file_type = F2FS_FT_DIR;
+ memcpy(dent_blk->filename[1], "..", 2);
+
+ /* bitmap for . and .. */
+ dent_blk->dentry_bitmap[0] = (1 << 1) | (1 << 0);
+ blk_size_bytes = 1 << get_sb(log_blocksize);
+ data_blk_offset = get_sb(main_blkaddr);
+ data_blk_offset += config.cur_seg[CURSEG_HOT_DATA] *
+ config.blks_per_seg;
+ data_blk_offset *= blk_size_bytes;
+
+ DBG(1, "\tWriting default dentry root, at offset 0x%08"PRIx64"\n", data_blk_offset);
+ if (dev_write(dent_blk, data_blk_offset, F2FS_BLKSIZE)) {
+ MSG(1, "\tError: While writing the dentry_blk to disk!!!\n");
+ free(dent_blk);
+ return -1;
+ }
+
+ free(dent_blk);
+ return 0;
+}
+
+static int f2fs_create_root_dir(void)
+{
+ int err = 0;
+
+ err = f2fs_write_root_inode();
+ if (err < 0) {
+ MSG(1, "\tError: Failed to write root inode!!!\n");
+ goto exit;
+ }
+
+ err = f2fs_update_nat_root();
+ if (err < 0) {
+ MSG(1, "\tError: Failed to update NAT for root!!!\n");
+ goto exit;
+ }
+
+ err = f2fs_add_default_dentry_root();
+ if (err < 0) {
+ MSG(1, "\tError: Failed to add default dentries for root!!!\n");
+ goto exit;
+ }
+exit:
+ if (err)
+ MSG(1, "\tError: Could not create the root directory!!!\n");
+
+ return err;
+}
+
+int f2fs_format_device(void)
+{
+ int err = 0;
+
+ err= f2fs_prepare_super_block();
+ if (err < 0) {
+ MSG(0, "\tError: Failed to prepare a super block!!!\n");
+ goto exit;
+ }
+
+ err = f2fs_trim_device();
+ if (err < 0) {
+ MSG(0, "\tError: Failed to trim whole device!!!\n");
+ goto exit;
+ }
+
+ err = f2fs_init_sit_area();
+ if (err < 0) {
+ MSG(0, "\tError: Failed to Initialise the SIT AREA!!!\n");
+ goto exit;
+ }
+
+ err = f2fs_init_nat_area();
+ if (err < 0) {
+ MSG(0, "\tError: Failed to Initialise the NAT AREA!!!\n");
+ goto exit;
+ }
+
+ err = f2fs_create_root_dir();
+ if (err < 0) {
+ MSG(0, "\tError: Failed to create the root directory!!!\n");
+ goto exit;
+ }
+
+ err = f2fs_write_check_point_pack();
+ if (err < 0) {
+ MSG(0, "\tError: Failed to write the check point pack!!!\n");
+ goto exit;
+ }
+
+ err = f2fs_write_super_block();
+ if (err < 0) {
+ MSG(0, "\tError: Failed to write the Super Block!!!\n");
+ goto exit;
+ }
+exit:
+ if (err)
+ MSG(0, "\tError: Could not format the device!!!\n");
+
+ return err;
+}
diff --git a/f2fs-tools/mkfs/f2fs_format_main.c b/f2fs-tools/mkfs/f2fs_format_main.c
new file mode 100644
index 0000000..bba2085
--- /dev/null
+++ b/f2fs-tools/mkfs/f2fs_format_main.c
@@ -0,0 +1,139 @@
+/**
+ * f2fs_format.c
+ *
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com/
+ *
+ * Dual licensed under the GPL or LGPL version 2 licenses.
+ */
+#define _LARGEFILE64_SOURCE
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <sys/mount.h>
+#include <time.h>
+//#include <linux/fs.h>
+#include <uuid/uuid.h>
+
+#include "f2fs_fs.h"
+#include "f2fs_format_utils.h"
+
+extern struct f2fs_configuration config;
+
+static void mkfs_usage()
+{
+ MSG(0, "\nUsage: mkfs.f2fs [options] device [sectors]\n");
+ MSG(0, "[options]:\n");
+ MSG(0, " -a heap-based allocation [default:1]\n");
+ MSG(0, " -d debug level [default:0]\n");
+ MSG(0, " -e [extension list] e.g. \"mp3,gif,mov\"\n");
+ MSG(0, " -l label\n");
+ MSG(0, " -o overprovision ratio [default:5]\n");
+ MSG(0, " -s # of segments per section [default:1]\n");
+ MSG(0, " -z # of sections per zone [default:1]\n");
+ MSG(0, " -t 0: nodiscard, 1: discard [default:1]\n");
+ MSG(0, "sectors: number of sectors. [default: determined by device size]\n");
+ exit(1);
+}
+
+static void f2fs_parse_options(int argc, char *argv[])
+{
+ static const char *option_string = "a:d:e:l:o:s:z:t:";
+ int32_t option=0;
+
+ while ((option = getopt(argc,argv,option_string)) != EOF) {
+ switch (option) {
+ case 'a':
+ config.heap = atoi(optarg);
+ if (config.heap == 0)
+ MSG(0, "Info: Disable heap-based policy\n");
+ break;
+ case 'd':
+ config.dbg_lv = atoi(optarg);
+ MSG(0, "Info: Debug level = %d\n", config.dbg_lv);
+ break;
+ case 'e':
+ config.extension_list = strdup(optarg);
+ MSG(0, "Info: Add new extension list\n");
+ break;
+ case 'l': /*v: volume label */
+ if (strlen(optarg) > 512) {
+ MSG(0, "Error: Volume Label should be less than\
+ 512 characters\n");
+ mkfs_usage();
+ }
+ config.vol_label = optarg;
+ MSG(0, "Info: Label = %s\n", config.vol_label);
+ break;
+ case 'o':
+ config.overprovision = atoi(optarg);
+ MSG(0, "Info: Overprovision ratio = %u%%\n",
+ atoi(optarg));
+ break;
+ case 's':
+ config.segs_per_sec = atoi(optarg);
+ MSG(0, "Info: Segments per section = %d\n",
+ atoi(optarg));
+ break;
+ case 'z':
+ config.secs_per_zone = atoi(optarg);
+ MSG(0, "Info: Sections per zone = %d\n", atoi(optarg));
+ break;
+ case 't':
+ config.trim = atoi(optarg);
+ MSG(0, "Info: Trim is %s\n", config.trim ? "enabled": "disabled");
+ break;
+ default:
+ MSG(0, "\tError: Unknown option %c\n",option);
+ mkfs_usage();
+ break;
+ }
+ }
+
+ if (optind >= argc) {
+ MSG(0, "\tError: Device not specified\n");
+ mkfs_usage();
+ }
+ config.device_name = argv[optind];
+
+ if ((optind + 1) < argc) {
+ /* We have a sector count. */
+ config.total_sectors = atoll(argv[optind+1]);
+ MSG(0, "\ttotal_sectors=%08"PRIx64" (%s bytes)\n",
+ config.total_sectors, argv[optind+1]);
+ }
+
+ config.reserved_segments =
+ (2 * (100 / config.overprovision + 1) + 6)
+ * config.segs_per_sec;
+ config.segs_per_zone = config.segs_per_sec * config.secs_per_zone;
+}
+
+int main(int argc, char *argv[])
+{
+ MSG(0, "\n\tF2FS-tools: mkfs.f2fs Ver: %s (%s)\n\n",
+ F2FS_TOOLS_VERSION,
+ F2FS_TOOLS_DATE);
+ f2fs_init_configuration(&config);
+
+ f2fs_parse_options(argc, argv);
+
+ if (f2fs_dev_is_umounted(&config) < 0)
+ return -1;
+
+ if (f2fs_get_device_info(&config) < 0)
+ return -1;
+
+ if (f2fs_format_device() < 0)
+ return -1;
+
+ f2fs_finalize_device(&config);
+
+ MSG(0, "Info: format successful\n");
+
+ return 0;
+}
diff --git a/f2fs-tools/mkfs/f2fs_format_utils.c b/f2fs-tools/mkfs/f2fs_format_utils.c
new file mode 100644
index 0000000..a0f85f5
--- /dev/null
+++ b/f2fs-tools/mkfs/f2fs_format_utils.c
@@ -0,0 +1,68 @@
+/**
+ * f2fs_format_utils.c
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com/
+ *
+ * Dual licensed under the GPL or LGPL version 2 licenses.
+ */
+#define _LARGEFILE_SOURCE
+#define _LARGEFILE64_SOURCE
+#ifndef _GNU_SOURCE
+#define _GNU_SOURCE
+#endif
+
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include "f2fs_fs.h"
+
+#ifdef HAVE_LINUX_FS_H
+#include <linux/fs.h>
+#endif
+#ifdef HAVE_LINUX_FALLOC_H
+#include <linux/falloc.h>
+#endif
+
+int f2fs_trim_device()
+{
+ unsigned long long range[2];
+ struct stat stat_buf;
+
+ if (!config.trim)
+ return 0;
+
+ range[0] = 0;
+ range[1] = config.total_sectors * config.sector_size;
+
+ if (fstat(config.fd, &stat_buf) < 0 ) {
+ MSG(1, "\tError: Failed to get the device stat!!!\n");
+ return -1;
+ }
+
+#if defined(WITH_BLKDISCARD) && defined(BLKDISCARD)
+ MSG(0, "Info: Discarding device\n");
+ if (S_ISREG(stat_buf.st_mode)) {
+#ifdef FALLOC_FL_PUNCH_HOLE
+ if (fallocate(config.fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
+ range[0], range[1]) < 0) {
+ MSG(0, "Info: fallocate(PUNCH_HOLE|KEEP_SIZE) is failed\n");
+ }
+#endif
+ return 0;
+ } else if (S_ISBLK(stat_buf.st_mode)) {
+ if (ioctl(config.fd, BLKDISCARD, &range) < 0) {
+ MSG(0, "Info: This device doesn't support TRIM\n");
+ } else {
+ MSG(0, "Info: Discarded %lu sectors\n",
+ config.total_sectors);
+ }
+ } else
+ return -1;
+#endif
+ return 0;
+}
+
diff --git a/f2fs-tools/mkfs/f2fs_format_utils.h b/f2fs-tools/mkfs/f2fs_format_utils.h
new file mode 100644
index 0000000..9eb2cea
--- /dev/null
+++ b/f2fs-tools/mkfs/f2fs_format_utils.h
@@ -0,0 +1,16 @@
+/**
+ * f2fs_format_utils.c
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * http://www.samsung.com/
+ *
+ * Dual licensed under the GPL or LGPL version 2 licenses.
+ */
+#define _LARGEFILE64_SOURCE
+
+#include "f2fs_fs.h"
+
+extern struct f2fs_configuration config;
+
+int f2fs_trim_device(void);
+int f2fs_format_device(void);
diff --git a/f2fs-tools/scripts/dumpf2fs.sh b/f2fs-tools/scripts/dumpf2fs.sh
new file mode 100755
index 0000000..2c2a273
--- /dev/null
+++ b/f2fs-tools/scripts/dumpf2fs.sh
@@ -0,0 +1,61 @@
+#!/system/bin/sh
+DEV=/dev/block/mmcblk0p16
+
+CMD=$1
+BASE=0x200000
+BASE_MAIN=0xac00000
+
+case $CMD in
+cp1)
+ echo dump cp1
+ let addr=$BASE
+ echo $addr
+ hexdump -s $addr -n 4096 $DEV;;
+cp2)
+ echo dump cp2
+ let addr=$BASE+0x200000
+ hexdump -s $addr -n 4096 $DEV;;
+cp)
+ echo dump cp1 and cp2
+ let addr=$BASE
+ hexdump -s $addr -n 409 $DEV
+ let addr=$BASE+0x200000
+ hexdump -s $addr -n 4096 $DEV;;
+cp1_all)
+ echo dump cp1 all
+ let addr=$BASE
+ hexdump -s $addr -n 20480 $DEV;;
+cp2_all)
+ echo dump cp2 all
+ let addr=$BASE+0x200000
+ hexdump -s $addr -n 20480 $DEV;;
+cp_all)
+ echo dump cp1 and cp2 all
+ let addr=$BASE
+ hexdump -s $addr -n 20480 $DEV
+ let addr=$BASE+0x200000
+ hexdump -s $addr -n 20480 $DEV;;
+blk)
+ let addr=$BASE_MAIN+$2*0x200000+$3*0x1000
+ hexdump -s $addr -n 4096 $DEV
+ echo ;;
+inode)
+ let addr=$BASE_MAIN+$2*0x200000+$3*0x1000
+ for i in `seq $3 511`
+ do
+ hexdump -s $addr -n 8 $DEV
+ let end=$addr+0x0ff0
+ hexdump -s $end -n 16 $DEV
+ let addr=$addr+0x1000
+ done
+ echo ;;
+*)
+ let addr=$1*0x1000
+ let segno=$addr-$BASE_MAIN
+ let segno=$segno/0x200000
+ let off=$addr-$BASE_MAIN
+ let off=$off%0x200000/0x1000
+ echo $segno, $off
+ hexdump -s $addr -n 4096 $DEV
+ echo ;;
+esac
diff --git a/f2fs-tools/scripts/spo_test.sh b/f2fs-tools/scripts/spo_test.sh
new file mode 100755
index 0000000..2191214
--- /dev/null
+++ b/f2fs-tools/scripts/spo_test.sh
@@ -0,0 +1,70 @@
+#!/bin/bash
+
+MNT=/mnt/f2fs
+DEV=/dev/sdb1
+USER_DIR=/home/zeus
+F2FS_DIR=$USER_DIR/f2fs_test
+
+check_stop() {
+ stop=`cat /tmp/stop`
+ if [ $stop -eq 1 ]; then
+ exit
+ fi
+}
+
+case $1 in
+start)
+ echo 0 > /tmp/stop
+ umount /mnt/*
+ echo 3 > /proc/sys/vm/drop_caches
+ echo 8 > /proc/sys/kernel/printk
+
+ date >> $USER_DIR/por_result
+ sync
+
+ insmod $F2FS_DIR/src/fs/f2fs/f2fs.ko || exit
+
+ echo Start checking F2FS without fsync
+ check_stop
+ fsck.f2fs $DEV -d 0 || exit
+ mount -t f2fs -o disable_roll_forward $DEV $MNT || exit
+ umount $MNT
+ echo 3 > /proc/sys/vm/drop_caches
+
+ echo Start checking F2FS with fsync
+ check_stop
+ fsck.f2fs $DEV -d 0 || exit
+ mount -t f2fs $DEV $MNT || exit
+ umount $MNT
+
+ check_stop
+ fsck.f2fs $DEV -d 0 || exit
+ mount -t f2fs $DEV $MNT || exit
+
+ count=`cat $USER_DIR/por_time`
+ if [ $count -eq 20 ]; then
+ echo Start rm all
+ time rm -rf $MNT/* || exit
+ echo 0 > $USER_DIR/por_time
+ sync
+ else
+ echo $((count+1)) > $USER_DIR/por_time
+ fi
+ echo 8 > /proc/sys/kernel/printk
+ echo Start fsstress
+ date
+ $F2FS_DIR/stress_test/fsstress/fsstress -z -f link=0 -f mkdir=3 -f mknod=3 -f rmdir=2 -f symlink=3 -f truncate=4 -f write=10 -f creat=10 -f unlink=5 -f rename=5 -f fsync=10 -p 10 -n 10000 -l 0 -d $MNT &
+ RANDOM=`date '+%s'`
+ rand=$[($RANDOM % 540) + 60]
+ echo Start sleep: $rand seconds
+ sleep $rand
+
+ echo Reboot now
+ check_stop
+ echo b > /proc/sysrq-trigger
+ ;;
+stop)
+ killall -9 fsstress
+ echo 1 > /tmp/stop
+ ;;
+esac
diff --git a/f2fs-tools/scripts/tracepoint.sh b/f2fs-tools/scripts/tracepoint.sh
new file mode 100755
index 0000000..15588d7
--- /dev/null
+++ b/f2fs-tools/scripts/tracepoint.sh
@@ -0,0 +1,71 @@
+#!/system/bin/sh
+
+TRACE=/sys/kernel/debug/tracing/
+dev=$(((8<<20) + 17)) # sdb1 (8,17)
+
+echo 1 > $TRACE/tracing_on
+
+# mmc tracepoints
+echo 0 > $TRACE/events/mmc/enable
+
+# block tracepoints
+#echo "dev == $dev" > $TRACE/events/block/block_rq_complete/filter
+echo 0 > $TRACE/events/block/block_rq_complete/enable
+echo 0 > $TRACE/events/block/block_bio_complete/enable
+
+# GC
+G=0
+echo $G > $TRACE/events/f2fs/f2fs_get_victim/enable
+
+# block allocation
+A=0
+echo $A > $TRACE/events/f2fs/f2fs_reserve_new_block/enable
+
+# block truncation
+T=0
+echo $T > $TRACE/events/f2fs/f2fs_truncate/enable
+echo $T > $TRACE/events/f2fs/f2fs_truncate_inode_blocks_enter/enable
+echo $T > $TRACE/events/f2fs/f2fs_truncate_inode_blocks_exit/enable
+echo $T > $TRACE/events/f2fs/f2fs_truncate_blocks_enter/enable
+echo $T > $TRACE/events/f2fs/f2fs_truncate_blocks_exit/enable
+echo $T > $TRACE/events/f2fs/f2fs_truncate_nodes_enter/enable
+echo $T > $TRACE/events/f2fs/f2fs_truncate_nodes_exit/enable
+echo $T > $TRACE/events/f2fs/f2fs_truncate_data_blocks_range/enable
+echo $T > $TRACE/events/f2fs/f2fs_truncate_node/enable
+echo $T > $TRACE/events/f2fs/f2fs_truncate_partial_nodes/enable
+
+# syscalls
+S=0
+echo $S > $TRACE/events/f2fs/f2fs_unlink_enter/enable
+echo $S > $TRACE/events/f2fs/f2fs_unlink_exit/enable
+echo $S > $TRACE/events/f2fs/f2fs_fallocate/enable
+echo $S > $TRACE/events/f2fs/f2fs_get_data_block/enable
+
+# IOs
+R=0
+W=0
+echo $R > $TRACE/events/f2fs/f2fs_readpage/enable
+echo $W > $TRACE/events/f2fs/f2fs_writepage/enable
+echo $W > $TRACE/events/f2fs/f2fs_write_begin/enable
+echo $W > $TRACE/events/f2fs/f2fs_write_end/enable
+
+echo 0 > $TRACE/events/f2fs/f2fs_submit_page_bio/enable
+echo 0 > $TRACE/events/f2fs/f2fs_submit_page_mbio/enable
+echo $R > $TRACE/events/f2fs/f2fs_submit_read_bio/enable
+echo $W > $TRACE/events/f2fs/f2fs_submit_write_bio/enable
+
+echo 0 > $TRACE/events/f2fs/f2fs_issue_discard/enable
+echo 0 > $TRACE/events/f2fs/f2fs_issue_flush/enable
+
+# VFS interfaces
+V=0
+echo $V > $TRACE/events/f2fs/f2fs_iget/enable
+echo $V > $TRACE/events/f2fs/f2fs_iget_exit/enable
+echo $V > $TRACE/events/f2fs/f2fs_new_inode/enable
+echo $V > $TRACE/events/f2fs/f2fs_evict_inode/enable
+echo $V > $TRACE/events/f2fs/f2fs_sync_file_enter/enable
+echo $V > $TRACE/events/f2fs/f2fs_sync_file_exit/enable
+echo $V > $TRACE/events/f2fs/f2fs_write_checkpoint/enable
+echo $V > $TRACE/events/f2fs/f2fs_sync_fs/enable
+
+cat $TRACE/trace_pipe
diff --git a/f2fs-tools/tools/Makefile.am b/f2fs-tools/tools/Makefile.am
new file mode 100644
index 0000000..69a0bb1
--- /dev/null
+++ b/f2fs-tools/tools/Makefile.am
@@ -0,0 +1,8 @@
+## Makefile.am
+
+AM_CPPFLAGS = ${libuuid_CFLAGS} -I$(top_srcdir)/include
+AM_CFLAGS = -Wall
+sbin_PROGRAMS = f2fstat fibmap.f2fs parse.f2fs
+f2fstat_SOURCES = f2fstat.c
+fibmap_f2fs_SOURCES = fibmap.c
+parse_f2fs_SOURCES = f2fs_io_parse.c
diff --git a/f2fs-tools/tools/f2fs_io_parse.c b/f2fs-tools/tools/f2fs_io_parse.c
new file mode 100644
index 0000000..7f97270
--- /dev/null
+++ b/f2fs-tools/tools/f2fs_io_parse.c
@@ -0,0 +1,322 @@
+/*
+ * f2fs IO tracer
+ *
+ * Copyright (c) 2014 Motorola Mobility
+ * Copyright (c) 2014 Jaegeuk Kim <jaegeuk@kernel.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#define _LARGEFILE64_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/queue.h>
+#include <assert.h>
+#include <locale.h>
+
+#define P_NAMELEN 16
+
+/* For global trace methods */
+enum show_type {
+ SHOW_PID,
+ SHOW_FTYPE,
+ SHOW_ALL,
+};
+
+enum trace_types {
+ TP_PID,
+ TP_IOS,
+ TP_MAX,
+};
+
+struct tps {
+ enum trace_types type;
+ const char *name;
+};
+
+struct tps trace_points[] = {
+ { TP_PID, "f2fs_trace_pid" },
+ { TP_IOS, "f2fs_trace_ios" },
+};
+
+/* For f2fs_trace_pid and f2fs_trace_ios */
+enum rw_type {
+ READ,
+ WRITE,
+ MAX_RW,
+};
+
+enum file_type {
+ __NORMAL_FILE,
+ __DIR_FILE,
+ __NODE_FILE,
+ __META_FILE,
+ __ATOMIC_FILE,
+ __VOLATILE_FILE,
+ __MISC_FILE,
+ __NR_FILES,
+};
+
+char *file_type_string[] = {
+ "User ",
+ "Dir ",
+ "Node ",
+ "Meta ",
+ "Atomic ",
+ "Voltile ",
+ "Misc ",
+};
+
+struct pid_ent {
+ int pid;
+ char name[P_NAMELEN];
+ unsigned long long io[__NR_FILES][MAX_RW];
+ unsigned long long total_io[MAX_RW];
+ LIST_ENTRY(pid_ent) ptr;
+};
+
+/* global variables */
+int major = 0, minor = 0;
+int show_option = SHOW_ALL;
+unsigned long long total_io[__NR_FILES][MAX_RW];
+
+LIST_HEAD(plist, pid_ent) pid_info;
+
+/* Functions */
+static inline int atoh(char *str)
+{
+ int val;
+ sscanf(str, "%x", &val);
+ return val;
+}
+
+static void do_init()
+{
+ struct pid_ent *misc;
+
+ misc = calloc(1, sizeof(struct pid_ent));
+ assert(misc);
+
+ LIST_INIT(&pid_info);
+ LIST_INSERT_HEAD(&pid_info, misc, ptr);
+}
+
+void show_usage()
+{
+ printf("\nUsage: parse.f2fs [options] log_file\n");
+ printf("[options]:\n");
+ printf(" -a RW sorted by pid & file types\n");
+ printf(" -f RW sorted by file types\n");
+ printf(" -p RW sorted by pid\n");
+ printf(" -m major number\n");
+ printf(" -n minor number\n");
+ exit(1);
+}
+
+static int parse_options(int argc, char *argv[])
+{
+ const char *option_string = "fm:n:p";
+ int option = 0;
+
+ while ((option = getopt(argc, argv, option_string)) != EOF) {
+ switch (option) {
+ case 'f':
+ show_option = SHOW_FTYPE;
+ break;
+ case 'm':
+ major = atoh(optarg);
+ break;
+ case 'n':
+ minor = atoh(optarg);
+ break;
+ case 'p':
+ show_option = SHOW_PID;
+ break;
+ default:
+ printf("\tError: Unknown option %c\n", option);
+ show_usage();
+ break;
+ }
+ }
+ if ((optind + 1) != argc) {
+ printf("\tError: Log file is not specified.\n");
+ show_usage();
+ }
+ return optind;
+}
+
+struct pid_ent *get_pid_entry(int pid)
+{
+ struct pid_ent *entry;
+
+ LIST_FOREACH(entry, &pid_info, ptr) {
+ if (entry->pid == pid)
+ return entry;
+ }
+ return LIST_FIRST(&pid_info);
+}
+
+static void handle_tp_pid(char *ptr)
+{
+ struct pid_ent *pent;
+
+ pent = calloc(1, sizeof(struct pid_ent));
+ assert(pent);
+
+ ptr = strtok(NULL, " ");
+ pent->pid = atoh(ptr);
+
+ ptr = strtok(NULL, " ");
+ strcpy(pent->name, ptr);
+
+ LIST_INSERT_HEAD(&pid_info, pent, ptr);
+}
+
+static void handle_tp_ios(char *ptr)
+{
+ int pid, type, rw, len;
+ struct pid_ent *p;
+
+ ptr = strtok(NULL, " ");
+ pid = atoh(ptr);
+
+ ptr = strtok(NULL, " ");
+ ptr = strtok(NULL, " ");
+ type = atoh(ptr);
+
+ ptr = strtok(NULL, " ");
+ rw = atoh(ptr);
+
+ ptr = strtok(NULL, " ");
+ /* unsigned long long blkaddr = atoh(ptr); */
+
+ ptr = strtok(NULL, " ");
+ len = atoh(ptr);
+
+ /* update per-pid stat */
+ p = get_pid_entry(pid);
+ p->io[type][rw & 0x1] += len;
+ p->total_io[rw & 0x1] += len;
+
+ /* update total stat */
+ total_io[type][rw & 0x1] += len;
+}
+
+static void do_parse(FILE *file)
+{
+ char line[300];
+ char *ptr;
+ int i;
+
+ while (fgets(line, sizeof(line), file) != NULL) {
+ ptr = strtok(line, ":");
+
+ ptr = strtok(NULL, " :");
+
+ for (i = 0; i < TP_MAX; i++) {
+ if (!strcmp(ptr, trace_points[i].name))
+ break;
+ }
+ if (i == TP_MAX)
+ continue;
+ ptr = strtok(NULL, " :");
+ if (major && major != atoh(ptr))
+ continue;
+ ptr = strtok(NULL, " :");
+ if (minor && minor != atoh(ptr))
+ continue;
+
+ switch (i) {
+ case TP_PID:
+ handle_tp_pid(ptr);
+ break;
+ case TP_IOS:
+ handle_tp_ios(ptr);
+ break;
+ }
+ }
+}
+
+static void __print_pid()
+{
+ struct pid_ent *entry;
+ int i;
+
+ setlocale(LC_ALL, "");
+ printf("%8s %16s %17s ||", "PID", "NAME", "R/W in 4KB");
+ for (i = 0; i < __NR_FILES; i++)
+ printf(" %17s |", file_type_string[i]);
+ printf("\n");
+
+ LIST_FOREACH(entry, &pid_info, ptr) {
+ printf("%8x %16s %'8lld %'8lld ||",
+ entry->pid, entry->name,
+ entry->total_io[READ],
+ entry->total_io[WRITE]);
+ for (i = 0; i < __NR_FILES; i++)
+ printf(" %'8lld %'8lld |",
+ entry->io[i][READ],
+ entry->io[i][WRITE]);
+ printf("\n");
+ }
+}
+
+static void __print_ftype()
+{
+ int i;
+
+ setlocale(LC_ALL, "");
+ printf("\n===== Data R/W in 4KB accoring to File types =====\n");
+ for (i = 0; i < __NR_FILES; i++)
+ printf(" %17s |", file_type_string[i]);
+ printf("\n");
+
+ for (i = 0; i < __NR_FILES; i++)
+ printf(" %'8lld %'8lld |",
+ total_io[i][READ],
+ total_io[i][WRITE]);
+ printf("\n");
+}
+
+static void do_print()
+{
+ switch (show_option) {
+ case SHOW_PID:
+ __print_pid();
+ break;
+ case SHOW_FTYPE:
+ __print_ftype();
+ break;
+ case SHOW_ALL:
+ __print_pid();
+ printf("\n\n");
+ __print_ftype();
+ break;
+ }
+}
+
+int main(int argc, char **argv)
+{
+ FILE *file;
+ int opt;
+
+ opt = parse_options(argc, argv);
+
+ file = fopen(argv[opt], "r");
+ if (!file) {
+ perror("open log file");
+ exit(EXIT_FAILURE);
+ }
+
+ do_init();
+
+ do_parse(file);
+
+ do_print();
+
+ fclose(file);
+ return 0;
+}
diff --git a/f2fs-tools/tools/f2fstat.c b/f2fs-tools/tools/f2fstat.c
new file mode 100644
index 0000000..7f485b0
--- /dev/null
+++ b/f2fs-tools/tools/f2fstat.c
@@ -0,0 +1,311 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <libgen.h>
+
+#ifdef DEBUG
+#define dbg(fmt, args...) printf(fmt, __VA_ARGS__);
+#else
+#define dbg(fmt, args...)
+#endif
+
+/*
+ * f2fs status
+ */
+#define F2FS_STATUS "/sys/kernel/debug/f2fs/status"
+
+#define KEY_NODE 0x00000001
+#define KEY_META 0x00000010
+
+unsigned long util;
+unsigned long used_node_blks;
+unsigned long used_data_blks;
+//unsigned long inline_inode;
+
+unsigned long free_segs;
+unsigned long valid_segs;
+unsigned long dirty_segs;
+unsigned long prefree_segs;
+
+unsigned long gc, bg_gc;
+unsigned long cp;
+unsigned long gc_data_blks;
+unsigned long gc_node_blks;
+
+//unsigned long extent_hit_ratio;
+
+unsigned long dirty_node, node_kb;
+unsigned long dirty_dents;
+unsigned long dirty_meta, meta_kb;
+unsigned long nat_caches;
+unsigned long dirty_sit;
+
+unsigned long free_nids;
+
+unsigned long ssr_blks;
+unsigned long lfs_blks;
+unsigned long memory_kb;
+
+struct options {
+ int delay;
+ int interval;
+ char partname[32];
+};
+
+struct mm_table {
+ const char *name;
+ unsigned long *val;
+ int flag;
+};
+
+static int compare_mm_table(const void *a, const void *b)
+{
+ dbg("[COMPARE] %s, %s\n", ((struct mm_table *)a)->name, ((struct mm_table *)b)->name);
+ return strcmp(((struct mm_table *)a)->name, ((struct mm_table *)b)->name);
+}
+
+static inline void remove_newline(char **head)
+{
+again:
+ if (**head == '\n') {
+ *head = *head + 1;
+ goto again;
+ }
+}
+
+void f2fstat(struct options *opt)
+{
+ int fd;
+ int ret;
+ char keyname[32];
+ char buf[4096];
+ struct mm_table key = { keyname, NULL };
+ struct mm_table *found;
+ int f2fstat_table_cnt;
+ char *head, *tail;
+ int found_cnt = 0;
+
+ static struct mm_table f2fstat_table[] = {
+ { " - Data", &used_data_blks, 0 },
+ { " - Dirty", &dirty_segs, 0 },
+ { " - Free", &free_segs, 0 },
+ { " - NATs", &nat_caches, 0 },
+ { " - Node", &used_node_blks, 0 },
+ { " - Prefree", &prefree_segs, 0 },
+ { " - SITs", &dirty_sit, 0 },
+ { " - Valid", &valid_segs, 0 },
+ { " - dents", &dirty_dents, 0 },
+ { " - free_nids", &free_nids, 0 },
+ { " - meta", &dirty_meta, KEY_META },
+ { " - nodes", &dirty_node, KEY_NODE },
+ { "CP calls", &cp, 0 },
+ { "GC calls", &gc, 0 },
+ { "LFS", &lfs_blks, 0 },
+ { "Memory", &memory_kb, 0 },
+ { "SSR", &ssr_blks, 0 },
+ { "Utilization", &util, 0 },
+ };
+
+ f2fstat_table_cnt = sizeof(f2fstat_table)/sizeof(struct mm_table);
+
+ fd = open(F2FS_STATUS, O_RDONLY);
+ if (fd < 0) {
+ perror("open " F2FS_STATUS);
+ exit(EXIT_FAILURE);
+ }
+
+ ret = read(fd, buf, 4096);
+ if (ret < 0) {
+ perror("read " F2FS_STATUS);
+ exit(EXIT_FAILURE);
+ }
+ buf[ret] = '\0';
+
+ head = buf;
+
+ if (opt->partname[0] != '\0') {
+ head = strstr(buf, opt->partname);
+ if (head == NULL)
+ exit(EXIT_FAILURE);
+ }
+
+ for (;;) {
+ remove_newline(&head);
+ tail = strchr(head, ':');
+ if (!tail)
+ break;
+ *tail = '\0';
+ if (strlen(head) >= sizeof(keyname)) {
+ dbg("[OVER] %s\n", head);
+ *tail = ':';
+ tail = strchr(head, '\n');
+ head = tail + 1;
+ continue;
+ }
+
+ strcpy(keyname, head);
+
+ found = bsearch(&key, f2fstat_table, f2fstat_table_cnt, sizeof(struct mm_table), compare_mm_table);
+ dbg("[RESULT] %s (%s)\n", head, (found) ? "O" : "X");
+ head = tail + 1;
+ if (!found)
+ goto nextline;
+
+ *(found->val) = strtoul(head, &tail, 10);
+ if (found->flag) {
+ int npages;
+ tail = strstr(head, "in");
+ head = tail + 2;
+ npages = strtoul(head, &tail, 10);
+ switch (found->flag & (KEY_NODE | KEY_META)) {
+ case KEY_NODE:
+ node_kb = npages * 4;
+ break;
+ case KEY_META:
+ meta_kb = npages * 4;
+ break;
+ }
+ }
+ if (++found_cnt == f2fstat_table_cnt)
+ break;
+nextline:
+ tail = strchr(head, '\n');
+ if (!tail)
+ break;
+ head = tail + 1;
+ }
+
+ close(fd);
+}
+
+void usage(void)
+{
+ printf("Usage: f2fstat [option]\n"
+ " -d delay (secs)\n"
+ " -i interval of head info\n"
+ " -p partition name (e.g. /dev/sda3)\n");
+ exit(EXIT_FAILURE);
+}
+
+void parse_option(int argc, char *argv[], struct options *opt)
+{
+ int option;
+ const char *option_string = "d:i:p:h";
+
+ while ((option = getopt(argc, argv, option_string)) != EOF) {
+ switch (option) {
+ case 'd':
+ opt->delay = atoi(optarg);
+ break;
+ case 'i':
+ opt->interval = atoi(optarg);
+ break;
+ case 'p':
+ strcpy(opt->partname, basename(optarg));
+ break;
+ default:
+ usage();
+ break;
+ }
+ }
+}
+
+void __make_head(char *head, int index, int i, int len)
+{
+ char name_h[5][20] = {"main segments", "page/slab caches", "cp/gc", "blks", "memory"};
+ int half = (len - strlen(name_h[i])) / 2;
+
+ *(head + index) = '|';
+ index++;
+ memset(head + index, '-', half);
+ index += half;
+ strcpy(head + index, name_h[i]);
+ index += strlen(name_h[i]);
+ memset(head + index, '-', half);
+}
+
+void print_head(char *res)
+{
+ char *ptr, *ptr_buf;
+ char buf[1024], head[1024];
+ char name[20][10] = {"util", "node", "data", "free", "valid", "dirty", "prefree", "node", "dent", "meta",
+ "sit", "nat", "fnid", "cp", "gc", "ssr", "lfs", "total", "node", "meta"};
+ int i, len, prev_index = 0;
+
+ ptr_buf = buf;
+ memset(buf, ' ', 1024);
+ memset(head, ' ', 1024);
+
+ for (i = 0; i < 20; i++) {
+ ptr = (i == 0) ? strtok(res, " ") : strtok(NULL, " ");
+ strncpy(ptr_buf, name[i], strlen(name[i]));
+ if (i == 1) {
+ prev_index = ptr_buf - buf - 1;
+ } else if (i == 7) {
+ len = (ptr_buf - buf) - 1 - prev_index;
+ __make_head(head, prev_index, 0, len);
+ prev_index = ptr_buf - buf - 1;
+ } else if (i == 13) {
+ len = (ptr_buf - buf) - 1 - prev_index;
+ __make_head(head, prev_index, 1, len);
+ prev_index = ptr_buf - buf - 1;
+ } else if (i == 15) {
+ len = (ptr_buf - buf) - 1 - prev_index;
+ __make_head(head, prev_index, 2, len);
+ prev_index = ptr_buf - buf - 1;
+ } else if (i == 17) {
+ len = (ptr_buf - buf) - 1 - prev_index;
+ __make_head(head, prev_index, 3, len);
+ prev_index = ptr_buf - buf - 1;
+ }
+
+ len = strlen(ptr);
+ ptr_buf += (len > strlen(name[i]) ? len : strlen(name[i])) + 1;
+ }
+
+ len = (ptr_buf - buf) - 1 - prev_index;
+ __make_head(head, prev_index, 4, len);
+
+ *ptr_buf = 0;
+ *(head + (ptr_buf - buf - 1)) = '|';
+ *(head + (ptr_buf - buf)) = 0;
+ fprintf(stderr, "%s\n%s\n", head, buf);
+}
+
+int main(int argc, char *argv[])
+{
+ char format[] = "%4ld %4ld %4ld %4ld %5ld %5ld %7ld %4ld %4ld %4ld %3ld %3ld %4ld %2ld %2ld %3ld %3ld %5ld %4ld %4ld";
+ char buf[1024], tmp[1024];
+ int head_interval;
+ struct options opt = {
+ .delay = 1,
+ .interval = 20,
+ .partname = { 0, },
+ };
+
+ parse_option(argc, argv, &opt);
+ head_interval = opt.interval;
+
+ while (1) {
+ memset(buf, 0, 1024);
+ f2fstat(&opt);
+ sprintf(buf, format, util, used_node_blks, used_data_blks,
+ free_segs, valid_segs, dirty_segs, prefree_segs,
+ dirty_node, dirty_dents, dirty_meta, dirty_sit, nat_caches, free_nids,
+ cp, gc, ssr_blks, lfs_blks, memory_kb, node_kb, meta_kb);
+
+ strcpy(tmp, buf);
+ if (head_interval == opt.interval)
+ print_head(tmp);
+ if (head_interval-- == 0)
+ head_interval = opt.interval;
+
+ fprintf(stderr, "%s\n", buf);
+
+ sleep(opt.delay);
+ }
+
+ return 0;
+}
diff --git a/f2fs-tools/tools/fibmap.c b/f2fs-tools/tools/fibmap.c
new file mode 100644
index 0000000..224b233
--- /dev/null
+++ b/f2fs-tools/tools/fibmap.c
@@ -0,0 +1,165 @@
+#define _LARGEFILE64_SOURCE
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <libgen.h>
+#include <linux/hdreg.h>
+#include <linux/types.h>
+#include <linux/fs.h>
+#include <inttypes.h>
+
+struct file_ext {
+ __u32 f_pos;
+ __u32 start_blk;
+ __u32 end_blk;
+ __u32 blk_count;
+};
+
+void print_ext(struct file_ext *ext)
+{
+ if (ext->end_blk == 0)
+ printf("%8d %8d %8d %8d\n", ext->f_pos, 0, 0, ext->blk_count);
+ else
+ printf("%8d %8d %8d %8d\n", ext->f_pos, ext->start_blk,
+ ext->end_blk, ext->blk_count);
+}
+
+void print_stat(struct stat64 *st)
+{
+ printf("--------------------------------------------\n");
+ printf("dev [%d:%d]\n", major(st->st_dev), minor(st->st_dev));
+ printf("ino [0x%8"PRIx64" : %"PRIu64"]\n",
+ st->st_ino, st->st_ino);
+ printf("mode [0x%8x : %d]\n", st->st_mode, st->st_mode);
+ printf("nlink [0x%8lx : %ld]\n", st->st_nlink, st->st_nlink);
+ printf("uid [0x%8x : %d]\n", st->st_uid, st->st_uid);
+ printf("gid [0x%8x : %d]\n", st->st_gid, st->st_gid);
+ printf("size [0x%8"PRIx64" : %"PRIu64"]\n",
+ st->st_size, st->st_size);
+ printf("blksize [0x%8lx : %ld]\n", st->st_blksize, st->st_blksize);
+ printf("blocks [0x%8"PRIx64" : %"PRIu64"]\n",
+ st->st_blocks, st->st_blocks);
+ printf("--------------------------------------------\n\n");
+}
+
+void stat_bdev(struct stat64 *st, unsigned int *start_lba)
+{
+ struct stat bdev_stat;
+ struct hd_geometry geom;
+ char devname[32] = { 0, };
+ char linkname[32] = { 0, };
+ int fd;
+
+ sprintf(devname, "/dev/block/%d:%d", major(st->st_dev), minor(st->st_dev));
+
+ fd = open(devname, O_RDONLY);
+ if (fd < 0)
+ return;
+
+ if (fstat(fd, &bdev_stat) < 0)
+ goto out;
+
+ if (S_ISBLK(bdev_stat.st_mode)) {
+ if (ioctl(fd, HDIO_GETGEO, &geom) < 0)
+ *start_lba = 0;
+ else
+ *start_lba = geom.start;
+ }
+
+ if (readlink(devname, linkname, sizeof(linkname)) < 0)
+ goto out;
+
+ printf("----------------bdev info-------------------\n");
+ printf("devname = %s\n", basename(linkname));
+ printf("start_lba = %u\n", *start_lba);
+
+out:
+ close(fd);
+
+}
+
+int main(int argc, char *argv[])
+{
+ int fd;
+ int ret = 0;
+ char *filename;
+ struct stat64 st;
+ int total_blks;
+ unsigned int i;
+ struct file_ext ext;
+ __u32 start_lba;
+ __u32 blknum;
+
+ if (argc != 2) {
+ fprintf(stderr, "No filename\n");
+ exit(-1);
+ }
+ filename = argv[1];
+
+ fd = open(filename, O_RDONLY|O_LARGEFILE);
+ if (fd < 0) {
+ ret = errno;
+ perror(filename);
+ exit(-1);
+ }
+
+ fsync(fd);
+
+ if (fstat64(fd, &st) < 0) {
+ ret = errno;
+ perror(filename);
+ goto out;
+ }
+
+ stat_bdev(&st, &start_lba);
+
+ total_blks = (st.st_size + st.st_blksize - 1) / st.st_blksize;
+
+ printf("\n----------------file info-------------------\n");
+ printf("%s :\n", filename);
+ print_stat(&st);
+ printf("file_pos start_blk end_blk blks\n");
+
+ blknum = 0;
+ if (ioctl(fd, FIBMAP, &blknum) < 0) {
+ ret = errno;
+ perror("ioctl(FIBMAP)");
+ goto out;
+ }
+ ext.f_pos = 0;
+ ext.start_blk = blknum;
+ ext.end_blk = blknum;
+ ext.blk_count = 1;
+
+ for (i = 1; i < total_blks; i++) {
+ blknum = i;
+
+ if (ioctl(fd, FIBMAP, &blknum) < 0) {
+ ret = errno;
+ perror("ioctl(FIBMAP)");
+ goto out;
+ }
+
+ if ((blknum == 0 && blknum == ext.end_blk) || (ext.end_blk + 1) == blknum) {
+ ext.end_blk = blknum;
+ ext.blk_count++;
+ } else {
+ print_ext(&ext);
+ ext.f_pos = i * st.st_blksize;
+ ext.start_blk = blknum;
+ ext.end_blk = blknum;
+ ext.blk_count = 1;
+ }
+ }
+
+ print_ext(&ext);
+out:
+ close(fd);
+ return ret;
+}
