Merge tag 'for-3.8-merge' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk...
authorLinus Torvalds <torvalds@linux-foundation.org>
Thu, 20 Dec 2012 21:54:51 +0000 (13:54 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Thu, 20 Dec 2012 21:54:52 +0000 (13:54 -0800)
Pull new F2FS filesystem from Jaegeuk Kim:
 "Introduce a new file system, Flash-Friendly File System (F2FS), to
  Linux 3.8.

  Highlights:
   - Add initial f2fs source codes
   - Fix an endian conversion bug
   - Fix build failures on random configs
   - Fix the power-off-recovery routine
   - Minor cleanup, coding style, and typos patches"

From the Kconfig help text:

  F2FS is based on Log-structured File System (LFS), which supports
  versatile "flash-friendly" features. The design has been focused on
  addressing the fundamental issues in LFS, which are snowball effect
  of wandering tree and high cleaning overhead.

  Since flash-based storages show different characteristics according to
  the internal geometry or flash memory management schemes aka FTL, F2FS
  and tools support various parameters not only for configuring on-disk
  layout, but also for selecting allocation and cleaning algorithms.

and there's an article by Neil Brown about it on lwn.net:

  http://lwn.net/Articles/518988/

* tag 'for-3.8-merge' of git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs: (36 commits)
  f2fs: fix tracking parent inode number
  f2fs: cleanup the f2fs_bio_alloc routine
  f2fs: introduce accessor to retrieve number of dentry slots
  f2fs: remove redundant call to f2fs_put_page in delete entry
  f2fs: make use of GFP_F2FS_ZERO for setting gfp_mask
  f2fs: rewrite f2fs_bio_alloc to make it simpler
  f2fs: fix a typo in f2fs documentation
  f2fs: remove unused variable
  f2fs: move error condition for mkdir at proper place
  f2fs: remove unneeded initialization
  f2fs: check read only condition before beginning write out
  f2fs: remove unneeded memset from init_once
  f2fs: show error in case of invalid mount arguments
  f2fs: fix the compiler warning for uninitialized use of variable
  f2fs: resolve build failures
  f2fs: adjust kernel coding style
  f2fs: fix endian conversion bugs reported by sparse
  f2fs: remove unneeded version.h header file from f2fs.h
  f2fs: update the f2fs document
  f2fs: update Kconfig and Makefile
  ...

29 files changed:
Documentation/filesystems/00-INDEX
Documentation/filesystems/f2fs.txt [new file with mode: 0644]
fs/Kconfig
fs/Makefile
fs/f2fs/Kconfig [new file with mode: 0644]
fs/f2fs/Makefile [new file with mode: 0644]
fs/f2fs/acl.c [new file with mode: 0644]
fs/f2fs/acl.h [new file with mode: 0644]
fs/f2fs/checkpoint.c [new file with mode: 0644]
fs/f2fs/data.c [new file with mode: 0644]
fs/f2fs/debug.c [new file with mode: 0644]
fs/f2fs/dir.c [new file with mode: 0644]
fs/f2fs/f2fs.h [new file with mode: 0644]
fs/f2fs/file.c [new file with mode: 0644]
fs/f2fs/gc.c [new file with mode: 0644]
fs/f2fs/gc.h [new file with mode: 0644]
fs/f2fs/hash.c [new file with mode: 0644]
fs/f2fs/inode.c [new file with mode: 0644]
fs/f2fs/namei.c [new file with mode: 0644]
fs/f2fs/node.c [new file with mode: 0644]
fs/f2fs/node.h [new file with mode: 0644]
fs/f2fs/recovery.c [new file with mode: 0644]
fs/f2fs/segment.c [new file with mode: 0644]
fs/f2fs/segment.h [new file with mode: 0644]
fs/f2fs/super.c [new file with mode: 0644]
fs/f2fs/xattr.c [new file with mode: 0644]
fs/f2fs/xattr.h [new file with mode: 0644]
include/linux/f2fs_fs.h [new file with mode: 0644]
include/uapi/linux/magic.h

index 7b52ba7..8042050 100644 (file)
@@ -50,6 +50,8 @@ ext4.txt
        - info, mount options and specifications for the Ext4 filesystem.
 files.txt
        - info on file management in the Linux kernel.
+f2fs.txt
+       - info and mount options for the F2FS filesystem.
 fuse.txt
        - info on the Filesystem in User SpacE including mount options.
 gfs2.txt
diff --git a/Documentation/filesystems/f2fs.txt b/Documentation/filesystems/f2fs.txt
new file mode 100644 (file)
index 0000000..8fbd8b4
--- /dev/null
@@ -0,0 +1,421 @@
+================================================================================
+WHAT IS Flash-Friendly File System (F2FS)?
+================================================================================
+
+NAND flash memory-based storage devices, such as SSD, eMMC, and SD cards, have
+been equipped on a variety systems ranging from mobile to server systems. Since
+they are known to have different characteristics from the conventional rotating
+disks, a file system, an upper layer to the storage device, should adapt to the
+changes from the sketch in the design level.
+
+F2FS is a file system exploiting NAND flash memory-based storage devices, which
+is based on Log-structured File System (LFS). The design has been focused on
+addressing the fundamental issues in LFS, which are snowball effect of wandering
+tree and high cleaning overhead.
+
+Since a NAND flash memory-based storage device shows different characteristic
+according to its internal geometry or flash memory management scheme, namely FTL,
+F2FS and its tools support various parameters not only for configuring on-disk
+layout, but also for selecting allocation and cleaning algorithms.
+
+The file system formatting tool, "mkfs.f2fs", is available from the following
+git tree:
+>> git://git.kernel.org/pub/scm/linux/kernel/git/jaegeuk/f2fs-tools.git
+
+For reporting bugs and sending patches, please use the following mailing list:
+>> linux-f2fs-devel@lists.sourceforge.net
+
+================================================================================
+BACKGROUND AND DESIGN ISSUES
+================================================================================
+
+Log-structured File System (LFS)
+--------------------------------
+"A log-structured file system writes all modifications to disk sequentially in
+a log-like structure, thereby speeding up  both file writing and crash recovery.
+The log is the only structure on disk; it contains indexing information so that
+files can be read back from the log efficiently. In order to maintain large free
+areas on disk for fast writing, we divide  the log into segments and use a
+segment cleaner to compress the live information from heavily fragmented
+segments." from Rosenblum, M. and Ousterhout, J. K., 1992, "The design and
+implementation of a log-structured file system", ACM Trans. Computer Systems
+10, 1, 26–52.
+
+Wandering Tree Problem
+----------------------
+In LFS, when a file data is updated and written to the end of log, its direct
+pointer block is updated due to the changed location. Then the indirect pointer
+block is also updated due to the direct pointer block update. In this manner,
+the upper index structures such as inode, inode map, and checkpoint block are
+also updated recursively. This problem is called as wandering tree problem [1],
+and in order to enhance the performance, it should eliminate or relax the update
+propagation as much as possible.
+
+[1] Bityutskiy, A. 2005. JFFS3 design issues. http://www.linux-mtd.infradead.org/
+
+Cleaning Overhead
+-----------------
+Since LFS is based on out-of-place writes, it produces so many obsolete blocks
+scattered across the whole storage. In order to serve new empty log space, it
+needs to reclaim these obsolete blocks seamlessly to users. This job is called
+as a cleaning process.
+
+The process consists of three operations as follows.
+1. A victim segment is selected through referencing segment usage table.
+2. It loads parent index structures of all the data in the victim identified by
+   segment summary blocks.
+3. It checks the cross-reference between the data and its parent index structure.
+4. It moves valid data selectively.
+
+This cleaning job may cause unexpected long delays, so the most important goal
+is to hide the latencies to users. And also definitely, it should reduce the
+amount of valid data to be moved, and move them quickly as well.
+
+================================================================================
+KEY FEATURES
+================================================================================
+
+Flash Awareness
+---------------
+- Enlarge the random write area for better performance, but provide the high
+  spatial locality
+- Align FS data structures to the operational units in FTL as best efforts
+
+Wandering Tree Problem
+----------------------
+- Use a term, “node”, that represents inodes as well as various pointer blocks
+- Introduce Node Address Table (NAT) containing the locations of all the “node”
+  blocks; this will cut off the update propagation.
+
+Cleaning Overhead
+-----------------
+- Support a background cleaning process
+- Support greedy and cost-benefit algorithms for victim selection policies
+- Support multi-head logs for static/dynamic hot and cold data separation
+- Introduce adaptive logging for efficient block allocation
+
+================================================================================
+MOUNT OPTIONS
+================================================================================
+
+background_gc_off      Turn off cleaning operations, namely garbage collection,
+                      triggered in background when I/O subsystem is idle.
+disable_roll_forward   Disable the roll-forward recovery routine
+discard                Issue discard/TRIM commands when a segment is cleaned.
+no_heap                Disable heap-style segment allocation which finds free
+                       segments for data from the beginning of main area, while
+                      for node from the end of main area.
+nouser_xattr           Disable Extended User Attributes. Note: xattr is enabled
+                       by default if CONFIG_F2FS_FS_XATTR is selected.
+noacl                  Disable POSIX Access Control List. Note: acl is enabled
+                       by default if CONFIG_F2FS_FS_POSIX_ACL is selected.
+active_logs=%u         Support configuring the number of active logs. In the
+                       current design, f2fs supports only 2, 4, and 6 logs.
+                       Default number is 6.
+disable_ext_identify   Disable the extension list configured by mkfs, so f2fs
+                       does not aware of cold files such as media files.
+
+================================================================================
+DEBUGFS ENTRIES
+================================================================================
+
+/sys/kernel/debug/f2fs/ contains information about all the partitions mounted as
+f2fs. Each file shows the whole f2fs information.
+
+/sys/kernel/debug/f2fs/status includes:
+ - major file system information managed by f2fs currently
+ - average SIT information about whole segments
+ - current memory footprint consumed by f2fs.
+
+================================================================================
+USAGE
+================================================================================
+
+1. Download userland tools and compile them.
+
+2. Skip, if f2fs was compiled statically inside kernel.
+   Otherwise, insert the f2fs.ko module.
+ # insmod f2fs.ko
+
+3. Create a directory trying to mount
+ # mkdir /mnt/f2fs
+
+4. Format the block device, and then mount as f2fs
+ # mkfs.f2fs -l label /dev/block_device
+ # mount -t f2fs /dev/block_device /mnt/f2fs
+
+Format options
+--------------
+-l [label]   : Give a volume label, up to 256 unicode name.
+-a [0 or 1]  : Split start location of each area for heap-based allocation.
+               1 is set by default, which performs this.
+-o [int]     : Set overprovision ratio in percent over volume size.
+               5 is set by default.
+-s [int]     : Set the number of segments per section.
+               1 is set by default.
+-z [int]     : Set the number of sections per zone.
+               1 is set by default.
+-e [str]     : Set basic extension list. e.g. "mp3,gif,mov"
+
+================================================================================
+DESIGN
+================================================================================
+
+On-disk Layout
+--------------
+
+F2FS divides the whole volume into a number of segments, each of which is fixed
+to 2MB in size. A section is composed of consecutive segments, and a zone
+consists of a set of sections. By default, section and zone sizes are set to one
+segment size identically, but users can easily modify the sizes by mkfs.
+
+F2FS splits the entire volume into six areas, and all the areas except superblock
+consists of multiple segments as described below.
+
+                                            align with the zone size <-|
+                 |-> align with the segment size
+     _________________________________________________________________________
+    |            |            |    Node     |   Segment   |   Segment  |      |
+    | Superblock | Checkpoint |   Address   |    Info.    |   Summary  | Main |
+    |    (SB)    |   (CP)     | Table (NAT) | Table (SIT) | Area (SSA) |      |
+    |____________|_____2______|______N______|______N______|______N_____|__N___|
+                                                                       .      .
+                                                             .                .
+                                                 .                            .
+                                    ._________________________________________.
+                                    |_Segment_|_..._|_Segment_|_..._|_Segment_|
+                                    .           .
+                                    ._________._________
+                                    |_section_|__...__|_
+                                    .            .
+                                   .________.
+                                   |__zone__|
+
+- Superblock (SB)
+ : It is located at the beginning of the partition, and there exist two copies
+   to avoid file system crash. It contains basic partition information and some
+   default parameters of f2fs.
+
+- Checkpoint (CP)
+ : It contains file system information, bitmaps for valid NAT/SIT sets, orphan
+   inode lists, and summary entries of current active segments.
+
+- Node Address Table (NAT)
+ : It is composed of a block address table for all the node blocks stored in
+   Main area.
+
+- Segment Information Table (SIT)
+ : It contains segment information such as valid block count and bitmap for the
+   validity of all the blocks.
+
+- Segment Summary Area (SSA)
+ : It contains summary entries which contains the owner information of all the
+   data and node blocks stored in Main area.
+
+- Main Area
+ : It contains file and directory data including their indices.
+
+In order to avoid misalignment between file system and flash-based storage, F2FS
+aligns the start block address of CP with the segment size. Also, it aligns the
+start block address of Main area with the zone size by reserving some segments
+in SSA area.
+
+Reference the following survey for additional technical details.
+https://wiki.linaro.org/WorkingGroups/Kernel/Projects/FlashCardSurvey
+
+File System Metadata Structure
+------------------------------
+
+F2FS adopts the checkpointing scheme to maintain file system consistency. At
+mount time, F2FS first tries to find the last valid checkpoint data by scanning
+CP area. In order to reduce the scanning time, F2FS uses only two copies of CP.
+One of them always indicates the last valid data, which is called as shadow copy
+mechanism. In addition to CP, NAT and SIT also adopt the shadow copy mechanism.
+
+For file system consistency, each CP points to which NAT and SIT copies are
+valid, as shown as below.
+
+  +--------+----------+---------+
+  |   CP   |    NAT   |   SIT   |
+  +--------+----------+---------+
+  .         .          .          .
+  .            .              .              .
+  .               .                 .                 .
+  +-------+-------+--------+--------+--------+--------+
+  | CP #0 | CP #1 | NAT #0 | NAT #1 | SIT #0 | SIT #1 |
+  +-------+-------+--------+--------+--------+--------+
+     |             ^                          ^
+     |             |                          |
+     `----------------------------------------'
+
+Index Structure
+---------------
+
+The key data structure to manage the data locations is a "node". Similar to
+traditional file structures, F2FS has three types of node: inode, direct node,
+indirect node. F2FS assigns 4KB to an inode block which contains 923 data block
+indices, two direct node pointers, two indirect node pointers, and one double
+indirect node pointer as described below. One direct node block contains 1018
+data blocks, and one indirect node block contains also 1018 node blocks. Thus,
+one inode block (i.e., a file) covers:
+
+  4KB * (923 + 2 * 1018 + 2 * 1018 * 1018 + 1018 * 1018 * 1018) := 3.94TB.
+
+   Inode block (4KB)
+     |- data (923)
+     |- direct node (2)
+     |          `- data (1018)
+     |- indirect node (2)
+     |            `- direct node (1018)
+     |                       `- data (1018)
+     `- double indirect node (1)
+                         `- indirect node (1018)
+                                     `- direct node (1018)
+                                                `- data (1018)
+
+Note that, all the node blocks are mapped by NAT which means the location of
+each node is translated by the NAT table. In the consideration of the wandering
+tree problem, F2FS is able to cut off the propagation of node updates caused by
+leaf data writes.
+
+Directory Structure
+-------------------
+
+A directory entry occupies 11 bytes, which consists of the following attributes.
+
+- hash         hash value of the file name
+- ino          inode number
+- len          the length of file name
+- type         file type such as directory, symlink, etc
+
+A dentry block consists of 214 dentry slots and file names. Therein a bitmap is
+used to represent whether each dentry is valid or not. A dentry block occupies
+4KB with the following composition.
+
+  Dentry Block(4 K) = bitmap (27 bytes) + reserved (3 bytes) +
+                     dentries(11 * 214 bytes) + file name (8 * 214 bytes)
+
+                         [Bucket]
+             +--------------------------------+
+             |dentry block 1 | dentry block 2 |
+             +--------------------------------+
+             .               .
+       .                             .
+  .       [Dentry Block Structure: 4KB]       .
+  +--------+----------+----------+------------+
+  | bitmap | reserved | dentries | file names |
+  +--------+----------+----------+------------+
+  [Dentry Block: 4KB] .   .
+                .               .
+            .                          .
+            +------+------+-----+------+
+            | hash | ino  | len | type |
+            +------+------+-----+------+
+            [Dentry Structure: 11 bytes]
+
+F2FS implements multi-level hash tables for directory structure. Each level has
+a hash table with dedicated number of hash buckets as shown below. Note that
+"A(2B)" means a bucket includes 2 data blocks.
+
+----------------------
+A : bucket
+B : block
+N : MAX_DIR_HASH_DEPTH
+----------------------
+
+level #0   | A(2B)
+           |
+level #1   | A(2B) - A(2B)
+           |
+level #2   | A(2B) - A(2B) - A(2B) - A(2B)
+     .     |   .       .       .       .
+level #N/2 | A(2B) - A(2B) - A(2B) - A(2B) - A(2B) - ... - A(2B)
+     .     |   .       .       .       .
+level #N   | A(4B) - A(4B) - A(4B) - A(4B) - A(4B) - ... - A(4B)
+
+The number of blocks and buckets are determined by,
+
+                            ,- 2, if n < MAX_DIR_HASH_DEPTH / 2,
+  # of blocks in level #n = |
+                            `- 4, Otherwise
+
+                             ,- 2^n, if n < MAX_DIR_HASH_DEPTH / 2,
+  # of buckets in level #n = |
+                             `- 2^((MAX_DIR_HASH_DEPTH / 2) - 1), Otherwise
+
+When F2FS finds a file name in a directory, at first a hash value of the file
+name is calculated. Then, F2FS scans the hash table in level #0 to find the
+dentry consisting of the file name and its inode number. If not found, F2FS
+scans the next hash table in level #1. In this way, F2FS scans hash tables in
+each levels incrementally from 1 to N. In each levels F2FS needs to scan only
+one bucket determined by the following equation, which shows O(log(# of files))
+complexity.
+
+  bucket number to scan in level #n = (hash value) % (# of buckets in level #n)
+
+In the case of file creation, F2FS finds empty consecutive slots that cover the
+file name. F2FS searches the empty slots in the hash tables of whole levels from
+1 to N in the same way as the lookup operation.
+
+The following figure shows an example of two cases holding children.
+       --------------> Dir <--------------
+       |                                 |
+    child                             child
+
+    child - child                     [hole] - child
+
+    child - child - child             [hole] - [hole] - child
+
+   Case 1:                           Case 2:
+   Number of children = 6,           Number of children = 3,
+   File size = 7                     File size = 7
+
+Default Block Allocation
+------------------------
+
+At runtime, F2FS manages six active logs inside "Main" area: Hot/Warm/Cold node
+and Hot/Warm/Cold data.
+
+- Hot node     contains direct node blocks of directories.
+- Warm node    contains direct node blocks except hot node blocks.
+- Cold node    contains indirect node blocks
+- Hot data     contains dentry blocks
+- Warm data    contains data blocks except hot and cold data blocks
+- Cold data    contains multimedia data or migrated data blocks
+
+LFS has two schemes for free space management: threaded log and copy-and-compac-
+tion. The copy-and-compaction scheme which is known as cleaning, is well-suited
+for devices showing very good sequential write performance, since free segments
+are served all the time for writing new data. However, it suffers from cleaning
+overhead under high utilization. Contrarily, the threaded log scheme suffers
+from random writes, but no cleaning process is needed. F2FS adopts a hybrid
+scheme where the copy-and-compaction scheme is adopted by default, but the
+policy is dynamically changed to the threaded log scheme according to the file
+system status.
+
+In order to align F2FS with underlying flash-based storage, F2FS allocates a
+segment in a unit of section. F2FS expects that the section size would be the
+same as the unit size of garbage collection in FTL. Furthermore, with respect
+to the mapping granularity in FTL, F2FS allocates each section of the active
+logs from different zones as much as possible, since FTL can write the data in
+the active logs into one allocation unit according to its mapping granularity.
+
+Cleaning process
+----------------
+
+F2FS does cleaning both on demand and in the background. On-demand cleaning is
+triggered when there are not enough free segments to serve VFS calls. Background
+cleaner is operated by a kernel thread, and triggers the cleaning job when the
+system is idle.
+
+F2FS supports two victim selection policies: greedy and cost-benefit algorithms.
+In the greedy algorithm, F2FS selects a victim segment having the smallest number
+of valid blocks. In the cost-benefit algorithm, F2FS selects a victim segment
+according to the segment age and the number of valid blocks in order to address
+log block thrashing problem in the greedy algorithm. F2FS adopts the greedy
+algorithm for on-demand cleaner, while background cleaner adopts cost-benefit
+algorithm.
+
+In order to identify whether the data in the victim segment are valid or not,
+F2FS manages a bitmap. Each bit represents the validity of a block, and the
+bitmap is composed of a bit stream covering whole blocks in main area.
index eaff24a..cfe512f 100644 (file)
@@ -220,6 +220,7 @@ source "fs/pstore/Kconfig"
 source "fs/sysv/Kconfig"
 source "fs/ufs/Kconfig"
 source "fs/exofs/Kconfig"
+source "fs/f2fs/Kconfig"
 
 endif # MISC_FILESYSTEMS
 
index 1d7af79..9d53192 100644 (file)
@@ -123,6 +123,7 @@ obj-$(CONFIG_DEBUG_FS)              += debugfs/
 obj-$(CONFIG_OCFS2_FS)         += ocfs2/
 obj-$(CONFIG_BTRFS_FS)         += btrfs/
 obj-$(CONFIG_GFS2_FS)           += gfs2/
+obj-$(CONFIG_F2FS_FS)          += f2fs/
 obj-y                          += exofs/ # Multiple modules
 obj-$(CONFIG_CEPH_FS)          += ceph/
 obj-$(CONFIG_PSTORE)           += pstore/
diff --git a/fs/f2fs/Kconfig b/fs/f2fs/Kconfig
new file mode 100644 (file)
index 0000000..fd27e7e
--- /dev/null
@@ -0,0 +1,53 @@
+config F2FS_FS
+       tristate "F2FS filesystem support (EXPERIMENTAL)"
+       depends on BLOCK
+       help
+         F2FS is based on Log-structured File System (LFS), which supports
+         versatile "flash-friendly" features. The design has been focused on
+         addressing the fundamental issues in LFS, which are snowball effect
+         of wandering tree and high cleaning overhead.
+
+         Since flash-based storages show different characteristics according to
+         the internal geometry or flash memory management schemes aka FTL, F2FS
+         and tools support various parameters not only for configuring on-disk
+         layout, but also for selecting allocation and cleaning algorithms.
+
+         If unsure, say N.
+
+config F2FS_STAT_FS
+       bool "F2FS Status Information"
+       depends on F2FS_FS && DEBUG_FS
+       default y
+       help
+         /sys/kernel/debug/f2fs/ contains information about all the partitions
+         mounted as f2fs. Each file shows the whole f2fs information.
+
+         /sys/kernel/debug/f2fs/status includes:
+           - major file system information managed by f2fs currently
+           - average SIT information about whole segments
+           - current memory footprint consumed by f2fs.
+
+config F2FS_FS_XATTR
+       bool "F2FS extended attributes"
+       depends on F2FS_FS
+       default y
+       help
+         Extended attributes are name:value pairs associated with inodes by
+         the kernel or by users (see the attr(5) manual page, or visit
+         <http://acl.bestbits.at/> for details).
+
+         If unsure, say N.
+
+config F2FS_FS_POSIX_ACL
+       bool "F2FS Access Control Lists"
+       depends on F2FS_FS_XATTR
+       select FS_POSIX_ACL
+       default y
+       help
+         Posix Access Control Lists (ACLs) support permissions for users and
+         gourps beyond the owner/group/world scheme.
+
+         To learn more about Access Control Lists, visit the POSIX ACLs for
+         Linux website <http://acl.bestbits.at/>.
+
+         If you don't know what Access Control Lists are, say N
diff --git a/fs/f2fs/Makefile b/fs/f2fs/Makefile
new file mode 100644 (file)
index 0000000..27a0820
--- /dev/null
@@ -0,0 +1,7 @@
+obj-$(CONFIG_F2FS_FS) += f2fs.o
+
+f2fs-y         := dir.o file.o inode.o namei.o hash.o super.o
+f2fs-y         += checkpoint.o gc.o data.o node.o segment.o recovery.o
+f2fs-$(CONFIG_F2FS_STAT_FS) += debug.o
+f2fs-$(CONFIG_F2FS_FS_XATTR) += xattr.o
+f2fs-$(CONFIG_F2FS_FS_POSIX_ACL) += acl.o
diff --git a/fs/f2fs/acl.c b/fs/f2fs/acl.c
new file mode 100644 (file)
index 0000000..fed74d1
--- /dev/null
@@ -0,0 +1,414 @@
+/*
+ * fs/f2fs/acl.c
+ *
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ *             http://www.samsung.com/
+ *
+ * Portions of this code from linux/fs/ext2/acl.c
+ *
+ * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
+ *
+ * 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 <linux/f2fs_fs.h>
+#include "f2fs.h"
+#include "xattr.h"
+#include "acl.h"
+
+#define get_inode_mode(i)      ((is_inode_flag_set(F2FS_I(i), FI_ACL_MODE)) ? \
+                                       (F2FS_I(i)->i_acl_mode) : ((i)->i_mode))
+
+static inline size_t f2fs_acl_size(int count)
+{
+       if (count <= 4) {
+               return sizeof(struct f2fs_acl_header) +
+                       count * sizeof(struct f2fs_acl_entry_short);
+       } else {
+               return sizeof(struct f2fs_acl_header) +
+                       4 * sizeof(struct f2fs_acl_entry_short) +
+                       (count - 4) * sizeof(struct f2fs_acl_entry);
+       }
+}
+
+static inline int f2fs_acl_count(size_t size)
+{
+       ssize_t s;
+       size -= sizeof(struct f2fs_acl_header);
+       s = size - 4 * sizeof(struct f2fs_acl_entry_short);
+       if (s < 0) {
+               if (size % sizeof(struct f2fs_acl_entry_short))
+                       return -1;
+               return size / sizeof(struct f2fs_acl_entry_short);
+       } else {
+               if (s % sizeof(struct f2fs_acl_entry))
+                       return -1;
+               return s / sizeof(struct f2fs_acl_entry) + 4;
+       }
+}
+
+static struct posix_acl *f2fs_acl_from_disk(const char *value, size_t size)
+{
+       int i, count;
+       struct posix_acl *acl;
+       struct f2fs_acl_header *hdr = (struct f2fs_acl_header *)value;
+       struct f2fs_acl_entry *entry = (struct f2fs_acl_entry *)(hdr + 1);
+       const char *end = value + size;
+
+       if (hdr->a_version != cpu_to_le32(F2FS_ACL_VERSION))
+               return ERR_PTR(-EINVAL);
+
+       count = f2fs_acl_count(size);
+       if (count < 0)
+               return ERR_PTR(-EINVAL);
+       if (count == 0)
+               return NULL;
+
+       acl = posix_acl_alloc(count, GFP_KERNEL);
+       if (!acl)
+               return ERR_PTR(-ENOMEM);
+
+       for (i = 0; i < count; i++) {
+
+               if ((char *)entry > end)
+                       goto fail;
+
+               acl->a_entries[i].e_tag  = le16_to_cpu(entry->e_tag);
+               acl->a_entries[i].e_perm = le16_to_cpu(entry->e_perm);
+
+               switch (acl->a_entries[i].e_tag) {
+               case ACL_USER_OBJ:
+               case ACL_GROUP_OBJ:
+               case ACL_MASK:
+               case ACL_OTHER:
+                       acl->a_entries[i].e_id = ACL_UNDEFINED_ID;
+                       entry = (struct f2fs_acl_entry *)((char *)entry +
+                                       sizeof(struct f2fs_acl_entry_short));
+                       break;
+
+               case ACL_USER:
+                       acl->a_entries[i].e_uid =
+                               make_kuid(&init_user_ns,
+                                               le32_to_cpu(entry->e_id));
+                       entry = (struct f2fs_acl_entry *)((char *)entry +
+                                       sizeof(struct f2fs_acl_entry));
+                       break;
+               case ACL_GROUP:
+                       acl->a_entries[i].e_gid =
+                               make_kgid(&init_user_ns,
+                                               le32_to_cpu(entry->e_id));
+                       entry = (struct f2fs_acl_entry *)((char *)entry +
+                                       sizeof(struct f2fs_acl_entry));
+                       break;
+               default:
+                       goto fail;
+               }
+       }
+       if ((char *)entry != end)
+               goto fail;
+       return acl;
+fail:
+       posix_acl_release(acl);
+       return ERR_PTR(-EINVAL);
+}
+
+static void *f2fs_acl_to_disk(const struct posix_acl *acl, size_t *size)
+{
+       struct f2fs_acl_header *f2fs_acl;
+       struct f2fs_acl_entry *entry;
+       int i;
+
+       f2fs_acl = kmalloc(sizeof(struct f2fs_acl_header) + acl->a_count *
+                       sizeof(struct f2fs_acl_entry), GFP_KERNEL);
+       if (!f2fs_acl)
+               return ERR_PTR(-ENOMEM);
+
+       f2fs_acl->a_version = cpu_to_le32(F2FS_ACL_VERSION);
+       entry = (struct f2fs_acl_entry *)(f2fs_acl + 1);
+
+       for (i = 0; i < acl->a_count; i++) {
+
+               entry->e_tag  = cpu_to_le16(acl->a_entries[i].e_tag);
+               entry->e_perm = cpu_to_le16(acl->a_entries[i].e_perm);
+
+               switch (acl->a_entries[i].e_tag) {
+               case ACL_USER:
+                       entry->e_id = cpu_to_le32(
+                                       from_kuid(&init_user_ns,
+                                               acl->a_entries[i].e_uid));
+                       entry = (struct f2fs_acl_entry *)((char *)entry +
+                                       sizeof(struct f2fs_acl_entry));
+                       break;
+               case ACL_GROUP:
+                       entry->e_id = cpu_to_le32(
+                                       from_kgid(&init_user_ns,
+                                               acl->a_entries[i].e_gid));
+                       entry = (struct f2fs_acl_entry *)((char *)entry +
+                                       sizeof(struct f2fs_acl_entry));
+                       break;
+               case ACL_USER_OBJ:
+               case ACL_GROUP_OBJ:
+               case ACL_MASK:
+               case ACL_OTHER:
+                       entry = (struct f2fs_acl_entry *)((char *)entry +
+                                       sizeof(struct f2fs_acl_entry_short));
+                       break;
+               default:
+                       goto fail;
+               }
+       }
+       *size = f2fs_acl_size(acl->a_count);
+       return (void *)f2fs_acl;
+
+fail:
+       kfree(f2fs_acl);
+       return ERR_PTR(-EINVAL);
+}
+
+struct posix_acl *f2fs_get_acl(struct inode *inode, int type)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       int name_index = F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT;
+       void *value = NULL;
+       struct posix_acl *acl;
+       int retval;
+
+       if (!test_opt(sbi, POSIX_ACL))
+               return NULL;
+
+       acl = get_cached_acl(inode, type);
+       if (acl != ACL_NOT_CACHED)
+               return acl;
+
+       if (type == ACL_TYPE_ACCESS)
+               name_index = F2FS_XATTR_INDEX_POSIX_ACL_ACCESS;
+
+       retval = f2fs_getxattr(inode, name_index, "", NULL, 0);
+       if (retval > 0) {
+               value = kmalloc(retval, GFP_KERNEL);
+               if (!value)
+                       return ERR_PTR(-ENOMEM);
+               retval = f2fs_getxattr(inode, name_index, "", value, retval);
+       }
+
+       if (retval < 0) {
+               if (retval == -ENODATA)
+                       acl = NULL;
+               else
+                       acl = ERR_PTR(retval);
+       } else {
+               acl = f2fs_acl_from_disk(value, retval);
+       }
+       kfree(value);
+       if (!IS_ERR(acl))
+               set_cached_acl(inode, type, acl);
+
+       return acl;
+}
+
+static int f2fs_set_acl(struct inode *inode, int type, struct posix_acl *acl)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       struct f2fs_inode_info *fi = F2FS_I(inode);
+       int name_index;
+       void *value = NULL;
+       size_t size = 0;
+       int error;
+
+       if (!test_opt(sbi, POSIX_ACL))
+               return 0;
+       if (S_ISLNK(inode->i_mode))
+               return -EOPNOTSUPP;
+
+       switch (type) {
+       case ACL_TYPE_ACCESS:
+               name_index = F2FS_XATTR_INDEX_POSIX_ACL_ACCESS;
+               if (acl) {
+                       error = posix_acl_equiv_mode(acl, &inode->i_mode);
+                       if (error < 0)
+                               return error;
+                       set_acl_inode(fi, inode->i_mode);
+                       if (error == 0)
+                               acl = NULL;
+               }
+               break;
+
+       case ACL_TYPE_DEFAULT:
+               name_index = F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT;
+               if (!S_ISDIR(inode->i_mode))
+                       return acl ? -EACCES : 0;
+               break;
+
+       default:
+               return -EINVAL;
+       }
+
+       if (acl) {
+               value = f2fs_acl_to_disk(acl, &size);
+               if (IS_ERR(value)) {
+                       cond_clear_inode_flag(fi, FI_ACL_MODE);
+                       return (int)PTR_ERR(value);
+               }
+       }
+
+       error = f2fs_setxattr(inode, name_index, "", value, size);
+
+       kfree(value);
+       if (!error)
+               set_cached_acl(inode, type, acl);
+
+       cond_clear_inode_flag(fi, FI_ACL_MODE);
+       return error;
+}
+
+int f2fs_init_acl(struct inode *inode, struct inode *dir)
+{
+       struct posix_acl *acl = NULL;
+       struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
+       int error = 0;
+
+       if (!S_ISLNK(inode->i_mode)) {
+               if (test_opt(sbi, POSIX_ACL)) {
+                       acl = f2fs_get_acl(dir, ACL_TYPE_DEFAULT);
+                       if (IS_ERR(acl))
+                               return PTR_ERR(acl);
+               }
+               if (!acl)
+                       inode->i_mode &= ~current_umask();
+       }
+
+       if (test_opt(sbi, POSIX_ACL) && acl) {
+
+               if (S_ISDIR(inode->i_mode)) {
+                       error = f2fs_set_acl(inode, ACL_TYPE_DEFAULT, acl);
+                       if (error)
+                               goto cleanup;
+               }
+               error = posix_acl_create(&acl, GFP_KERNEL, &inode->i_mode);
+               if (error < 0)
+                       return error;
+               if (error > 0)
+                       error = f2fs_set_acl(inode, ACL_TYPE_ACCESS, acl);
+       }
+cleanup:
+       posix_acl_release(acl);
+       return error;
+}
+
+int f2fs_acl_chmod(struct inode *inode)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       struct posix_acl *acl;
+       int error;
+       mode_t mode = get_inode_mode(inode);
+
+       if (!test_opt(sbi, POSIX_ACL))
+               return 0;
+       if (S_ISLNK(mode))
+               return -EOPNOTSUPP;
+
+       acl = f2fs_get_acl(inode, ACL_TYPE_ACCESS);
+       if (IS_ERR(acl) || !acl)
+               return PTR_ERR(acl);
+
+       error = posix_acl_chmod(&acl, GFP_KERNEL, mode);
+       if (error)
+               return error;
+       error = f2fs_set_acl(inode, ACL_TYPE_ACCESS, acl);
+       posix_acl_release(acl);
+       return error;
+}
+
+static size_t f2fs_xattr_list_acl(struct dentry *dentry, char *list,
+               size_t list_size, const char *name, size_t name_len, int type)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
+       const char *xname = POSIX_ACL_XATTR_DEFAULT;
+       size_t size;
+
+       if (!test_opt(sbi, POSIX_ACL))
+               return 0;
+
+       if (type == ACL_TYPE_ACCESS)
+               xname = POSIX_ACL_XATTR_ACCESS;
+
+       size = strlen(xname) + 1;
+       if (list && size <= list_size)
+               memcpy(list, xname, size);
+       return size;
+}
+
+static int f2fs_xattr_get_acl(struct dentry *dentry, const char *name,
+               void *buffer, size_t size, int type)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
+       struct posix_acl *acl;
+       int error;
+
+       if (strcmp(name, "") != 0)
+               return -EINVAL;
+       if (!test_opt(sbi, POSIX_ACL))
+               return -EOPNOTSUPP;
+
+       acl = f2fs_get_acl(dentry->d_inode, type);
+       if (IS_ERR(acl))
+               return PTR_ERR(acl);
+       if (!acl)
+               return -ENODATA;
+       error = posix_acl_to_xattr(&init_user_ns, acl, buffer, size);
+       posix_acl_release(acl);
+
+       return error;
+}
+
+static int f2fs_xattr_set_acl(struct dentry *dentry, const char *name,
+               const void *value, size_t size, int flags, int type)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
+       struct inode *inode = dentry->d_inode;
+       struct posix_acl *acl = NULL;
+       int error;
+
+       if (strcmp(name, "") != 0)
+               return -EINVAL;
+       if (!test_opt(sbi, POSIX_ACL))
+               return -EOPNOTSUPP;
+       if (!inode_owner_or_capable(inode))
+               return -EPERM;
+
+       if (value) {
+               acl = posix_acl_from_xattr(&init_user_ns, value, size);
+               if (IS_ERR(acl))
+                       return PTR_ERR(acl);
+               if (acl) {
+                       error = posix_acl_valid(acl);
+                       if (error)
+                               goto release_and_out;
+               }
+       } else {
+               acl = NULL;
+       }
+
+       error = f2fs_set_acl(inode, type, acl);
+
+release_and_out:
+       posix_acl_release(acl);
+       return error;
+}
+
+const struct xattr_handler f2fs_xattr_acl_default_handler = {
+       .prefix = POSIX_ACL_XATTR_DEFAULT,
+       .flags = ACL_TYPE_DEFAULT,
+       .list = f2fs_xattr_list_acl,
+       .get = f2fs_xattr_get_acl,
+       .set = f2fs_xattr_set_acl,
+};
+
+const struct xattr_handler f2fs_xattr_acl_access_handler = {
+       .prefix = POSIX_ACL_XATTR_ACCESS,
+       .flags = ACL_TYPE_ACCESS,
+       .list = f2fs_xattr_list_acl,
+       .get = f2fs_xattr_get_acl,
+       .set = f2fs_xattr_set_acl,
+};
diff --git a/fs/f2fs/acl.h b/fs/f2fs/acl.h
new file mode 100644 (file)
index 0000000..80f4306
--- /dev/null
@@ -0,0 +1,57 @@
+/*
+ * fs/f2fs/acl.h
+ *
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ *             http://www.samsung.com/
+ *
+ * Portions of this code from linux/fs/ext2/acl.h
+ *
+ * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
+ *
+ * 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_ACL_H__
+#define __F2FS_ACL_H__
+
+#include <linux/posix_acl_xattr.h>
+
+#define F2FS_ACL_VERSION       0x0001
+
+struct f2fs_acl_entry {
+       __le16 e_tag;
+       __le16 e_perm;
+       __le32 e_id;
+};
+
+struct f2fs_acl_entry_short {
+       __le16 e_tag;
+       __le16 e_perm;
+};
+
+struct f2fs_acl_header {
+       __le32 a_version;
+};
+
+#ifdef CONFIG_F2FS_FS_POSIX_ACL
+
+extern struct posix_acl *f2fs_get_acl(struct inode *inode, int type);
+extern int f2fs_acl_chmod(struct inode *inode);
+extern int f2fs_init_acl(struct inode *inode, struct inode *dir);
+#else
+#define f2fs_check_acl NULL
+#define f2fs_get_acl   NULL
+#define f2fs_set_acl   NULL
+
+static inline int f2fs_acl_chmod(struct inode *inode)
+{
+       return 0;
+}
+
+static inline int f2fs_init_acl(struct inode *inode, struct inode *dir)
+{
+       return 0;
+}
+#endif
+#endif /* __F2FS_ACL_H__ */
diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
new file mode 100644 (file)
index 0000000..6ef36c3
--- /dev/null
@@ -0,0 +1,794 @@
+/*
+ * fs/f2fs/checkpoint.c
+ *
+ * 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.
+ */
+#include <linux/fs.h>
+#include <linux/bio.h>
+#include <linux/mpage.h>
+#include <linux/writeback.h>
+#include <linux/blkdev.h>
+#include <linux/f2fs_fs.h>
+#include <linux/pagevec.h>
+#include <linux/swap.h>
+
+#include "f2fs.h"
+#include "node.h"
+#include "segment.h"
+
+static struct kmem_cache *orphan_entry_slab;
+static struct kmem_cache *inode_entry_slab;
+
+/*
+ * We guarantee no failure on the returned page.
+ */
+struct page *grab_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)
+{
+       struct address_space *mapping = sbi->meta_inode->i_mapping;
+       struct page *page = NULL;
+repeat:
+       page = grab_cache_page(mapping, index);
+       if (!page) {
+               cond_resched();
+               goto repeat;
+       }
+
+       /* We wait writeback only inside grab_meta_page() */
+       wait_on_page_writeback(page);
+       SetPageUptodate(page);
+       return page;
+}
+
+/*
+ * We guarantee no failure on the returned page.
+ */
+struct page *get_meta_page(struct f2fs_sb_info *sbi, pgoff_t index)
+{
+       struct address_space *mapping = sbi->meta_inode->i_mapping;
+       struct page *page;
+repeat:
+       page = grab_cache_page(mapping, index);
+       if (!page) {
+               cond_resched();
+               goto repeat;
+       }
+       if (f2fs_readpage(sbi, page, index, READ_SYNC)) {
+               f2fs_put_page(page, 1);
+               goto repeat;
+       }
+       mark_page_accessed(page);
+
+       /* We do not allow returning an errorneous page */
+       return page;
+}
+
+static int f2fs_write_meta_page(struct page *page,
+                               struct writeback_control *wbc)
+{
+       struct inode *inode = page->mapping->host;
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       int err;
+
+       wait_on_page_writeback(page);
+
+       err = write_meta_page(sbi, page, wbc);
+       if (err) {
+               wbc->pages_skipped++;
+               set_page_dirty(page);
+       }
+
+       dec_page_count(sbi, F2FS_DIRTY_META);
+
+       /* In this case, we should not unlock this page */
+       if (err != AOP_WRITEPAGE_ACTIVATE)
+               unlock_page(page);
+       return err;
+}
+
+static int f2fs_write_meta_pages(struct address_space *mapping,
+                               struct writeback_control *wbc)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(mapping->host->i_sb);
+       struct block_device *bdev = sbi->sb->s_bdev;
+       long written;
+
+       if (wbc->for_kupdate)
+               return 0;
+
+       if (get_pages(sbi, F2FS_DIRTY_META) == 0)
+               return 0;
+
+       /* if mounting is failed, skip writing node pages */
+       mutex_lock(&sbi->cp_mutex);
+       written = sync_meta_pages(sbi, META, bio_get_nr_vecs(bdev));
+       mutex_unlock(&sbi->cp_mutex);
+       wbc->nr_to_write -= written;
+       return 0;
+}
+
+long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
+                                               long nr_to_write)
+{
+       struct address_space *mapping = sbi->meta_inode->i_mapping;
+       pgoff_t index = 0, end = LONG_MAX;
+       struct pagevec pvec;
+       long nwritten = 0;
+       struct writeback_control wbc = {
+               .for_reclaim = 0,
+       };
+
+       pagevec_init(&pvec, 0);
+
+       while (index <= end) {
+               int i, nr_pages;
+               nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
+                               PAGECACHE_TAG_DIRTY,
+                               min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
+               if (nr_pages == 0)
+                       break;
+
+               for (i = 0; i < nr_pages; i++) {
+                       struct page *page = pvec.pages[i];
+                       lock_page(page);
+                       BUG_ON(page->mapping != mapping);
+                       BUG_ON(!PageDirty(page));
+                       clear_page_dirty_for_io(page);
+                       f2fs_write_meta_page(page, &wbc);
+                       if (nwritten++ >= nr_to_write)
+                               break;
+               }
+               pagevec_release(&pvec);
+               cond_resched();
+       }
+
+       if (nwritten)
+               f2fs_submit_bio(sbi, type, nr_to_write == LONG_MAX);
+
+       return nwritten;
+}
+
+static int f2fs_set_meta_page_dirty(struct page *page)
+{
+       struct address_space *mapping = page->mapping;
+       struct f2fs_sb_info *sbi = F2FS_SB(mapping->host->i_sb);
+
+       SetPageUptodate(page);
+       if (!PageDirty(page)) {
+               __set_page_dirty_nobuffers(page);
+               inc_page_count(sbi, F2FS_DIRTY_META);
+               F2FS_SET_SB_DIRT(sbi);
+               return 1;
+       }
+       return 0;
+}
+
+const struct address_space_operations f2fs_meta_aops = {
+       .writepage      = f2fs_write_meta_page,
+       .writepages     = f2fs_write_meta_pages,
+       .set_page_dirty = f2fs_set_meta_page_dirty,
+};
+
+int check_orphan_space(struct f2fs_sb_info *sbi)
+{
+       unsigned int max_orphans;
+       int err = 0;
+
+       /*
+        * considering 512 blocks in a segment 5 blocks are needed for cp
+        * and log segment summaries. Remaining blocks are used to keep
+        * orphan entries with the limitation one reserved segment
+        * for cp pack we can have max 1020*507 orphan entries
+        */
+       max_orphans = (sbi->blocks_per_seg - 5) * F2FS_ORPHANS_PER_BLOCK;
+       mutex_lock(&sbi->orphan_inode_mutex);
+       if (sbi->n_orphans >= max_orphans)
+               err = -ENOSPC;
+       mutex_unlock(&sbi->orphan_inode_mutex);
+       return err;
+}
+
+void add_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
+{
+       struct list_head *head, *this;
+       struct orphan_inode_entry *new = NULL, *orphan = NULL;
+
+       mutex_lock(&sbi->orphan_inode_mutex);
+       head = &sbi->orphan_inode_list;
+       list_for_each(this, head) {
+               orphan = list_entry(this, struct orphan_inode_entry, list);
+               if (orphan->ino == ino)
+                       goto out;
+               if (orphan->ino > ino)
+                       break;
+               orphan = NULL;
+       }
+retry:
+       new = kmem_cache_alloc(orphan_entry_slab, GFP_ATOMIC);
+       if (!new) {
+               cond_resched();
+               goto retry;
+       }
+       new->ino = ino;
+       INIT_LIST_HEAD(&new->list);
+
+       /* add new_oentry into list which is sorted by inode number */
+       if (orphan) {
+               struct orphan_inode_entry *prev;
+
+               /* get previous entry */
+               prev = list_entry(orphan->list.prev, typeof(*prev), list);
+               if (&prev->list != head)
+                       /* insert new orphan inode entry */
+                       list_add(&new->list, &prev->list);
+               else
+                       list_add(&new->list, head);
+       } else {
+               list_add_tail(&new->list, head);
+       }
+       sbi->n_orphans++;
+out:
+       mutex_unlock(&sbi->orphan_inode_mutex);
+}
+
+void remove_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
+{
+       struct list_head *this, *next, *head;
+       struct orphan_inode_entry *orphan;
+
+       mutex_lock(&sbi->orphan_inode_mutex);
+       head = &sbi->orphan_inode_list;
+       list_for_each_safe(this, next, head) {
+               orphan = list_entry(this, struct orphan_inode_entry, list);
+               if (orphan->ino == ino) {
+                       list_del(&orphan->list);
+                       kmem_cache_free(orphan_entry_slab, orphan);
+                       sbi->n_orphans--;
+                       break;
+               }
+       }
+       mutex_unlock(&sbi->orphan_inode_mutex);
+}
+
+static void recover_orphan_inode(struct f2fs_sb_info *sbi, nid_t ino)
+{
+       struct inode *inode = f2fs_iget(sbi->sb, ino);
+       BUG_ON(IS_ERR(inode));
+       clear_nlink(inode);
+
+       /* truncate all the data during iput */
+       iput(inode);
+}
+
+int recover_orphan_inodes(struct f2fs_sb_info *sbi)
+{
+       block_t start_blk, orphan_blkaddr, i, j;
+
+       if (!is_set_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG))
+               return 0;
+
+       sbi->por_doing = 1;
+       start_blk = __start_cp_addr(sbi) + 1;
+       orphan_blkaddr = __start_sum_addr(sbi) - 1;
+
+       for (i = 0; i < orphan_blkaddr; i++) {
+               struct page *page = get_meta_page(sbi, start_blk + i);
+               struct f2fs_orphan_block *orphan_blk;
+
+               orphan_blk = (struct f2fs_orphan_block *)page_address(page);
+               for (j = 0; j < le32_to_cpu(orphan_blk->entry_count); j++) {
+                       nid_t ino = le32_to_cpu(orphan_blk->ino[j]);
+                       recover_orphan_inode(sbi, ino);
+               }
+               f2fs_put_page(page, 1);
+       }
+       /* clear Orphan Flag */
+       clear_ckpt_flags(F2FS_CKPT(sbi), CP_ORPHAN_PRESENT_FLAG);
+       sbi->por_doing = 0;
+       return 0;
+}
+
+static void write_orphan_inodes(struct f2fs_sb_info *sbi, block_t start_blk)
+{
+       struct list_head *head, *this, *next;
+       struct f2fs_orphan_block *orphan_blk = NULL;
+       struct page *page = NULL;
+       unsigned int nentries = 0;
+       unsigned short index = 1;
+       unsigned short orphan_blocks;
+
+       orphan_blocks = (unsigned short)((sbi->n_orphans +
+               (F2FS_ORPHANS_PER_BLOCK - 1)) / F2FS_ORPHANS_PER_BLOCK);
+
+       mutex_lock(&sbi->orphan_inode_mutex);
+       head = &sbi->orphan_inode_list;
+
+       /* loop for each orphan inode entry and write them in Jornal block */
+       list_for_each_safe(this, next, head) {
+               struct orphan_inode_entry *orphan;
+
+               orphan = list_entry(this, struct orphan_inode_entry, list);
+
+               if (nentries == F2FS_ORPHANS_PER_BLOCK) {
+                       /*
+                        * an orphan block is full of 1020 entries,
+                        * then we need to flush current orphan blocks
+                        * and bring another one in memory
+                        */
+                       orphan_blk->blk_addr = cpu_to_le16(index);
+                       orphan_blk->blk_count = cpu_to_le16(orphan_blocks);
+                       orphan_blk->entry_count = cpu_to_le32(nentries);
+                       set_page_dirty(page);
+                       f2fs_put_page(page, 1);
+                       index++;
+                       start_blk++;
+                       nentries = 0;
+                       page = NULL;
+               }
+               if (page)
+                       goto page_exist;
+
+               page = grab_meta_page(sbi, start_blk);
+               orphan_blk = (struct f2fs_orphan_block *)page_address(page);
+               memset(orphan_blk, 0, sizeof(*orphan_blk));
+page_exist:
+               orphan_blk->ino[nentries++] = cpu_to_le32(orphan->ino);
+       }
+       if (!page)
+               goto end;
+
+       orphan_blk->blk_addr = cpu_to_le16(index);
+       orphan_blk->blk_count = cpu_to_le16(orphan_blocks);
+       orphan_blk->entry_count = cpu_to_le32(nentries);
+       set_page_dirty(page);
+       f2fs_put_page(page, 1);
+end:
+       mutex_unlock(&sbi->orphan_inode_mutex);
+}
+
+static struct page *validate_checkpoint(struct f2fs_sb_info *sbi,
+                               block_t cp_addr, unsigned long long *version)
+{
+       struct page *cp_page_1, *cp_page_2 = NULL;
+       unsigned long blk_size = sbi->blocksize;
+       struct f2fs_checkpoint *cp_block;
+       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 = get_meta_page(sbi, cp_addr);
+
+       /* get the version number */
+       cp_block = (struct f2fs_checkpoint *)page_address(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_addr += le32_to_cpu(cp_block->cp_pack_total_block_count) - 1;
+       cp_page_2 = get_meta_page(sbi, cp_addr);
+
+       cp_block = (struct f2fs_checkpoint *)page_address(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;
+               f2fs_put_page(cp_page_2, 1);
+               return cp_page_1;
+       }
+invalid_cp2:
+       f2fs_put_page(cp_page_2, 1);
+invalid_cp1:
+       f2fs_put_page(cp_page_1, 1);
+       return NULL;
+}
+
+int get_valid_checkpoint(struct f2fs_sb_info *sbi)
+{
+       struct f2fs_checkpoint *cp_block;
+       struct f2fs_super_block *fsb = sbi->raw_super;
+       struct page *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;
+
+       sbi->ckpt = kzalloc(blk_size, GFP_KERNEL);
+       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(fsb->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(fsb->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;
+               else
+                       cur_page = cp1;
+       } else if (cp1) {
+               cur_page = cp1;
+       } else if (cp2) {
+               cur_page = cp2;
+       } else {
+               goto fail_no_cp;
+       }
+
+       cp_block = (struct f2fs_checkpoint *)page_address(cur_page);
+       memcpy(sbi->ckpt, cp_block, blk_size);
+
+       f2fs_put_page(cp1, 1);
+       f2fs_put_page(cp2, 1);
+       return 0;
+
+fail_no_cp:
+       kfree(sbi->ckpt);
+       return -EINVAL;
+}
+
+void set_dirty_dir_page(struct inode *inode, struct page *page)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       struct list_head *head = &sbi->dir_inode_list;
+       struct dir_inode_entry *new;
+       struct list_head *this;
+
+       if (!S_ISDIR(inode->i_mode))
+               return;
+retry:
+       new = kmem_cache_alloc(inode_entry_slab, GFP_NOFS);
+       if (!new) {
+               cond_resched();
+               goto retry;
+       }
+       new->inode = inode;
+       INIT_LIST_HEAD(&new->list);
+
+       spin_lock(&sbi->dir_inode_lock);
+       list_for_each(this, head) {
+               struct dir_inode_entry *entry;
+               entry = list_entry(this, struct dir_inode_entry, list);
+               if (entry->inode == inode) {
+                       kmem_cache_free(inode_entry_slab, new);
+                       goto out;
+               }
+       }
+       list_add_tail(&new->list, head);
+       sbi->n_dirty_dirs++;
+
+       BUG_ON(!S_ISDIR(inode->i_mode));
+out:
+       inc_page_count(sbi, F2FS_DIRTY_DENTS);
+       inode_inc_dirty_dents(inode);
+       SetPagePrivate(page);
+
+       spin_unlock(&sbi->dir_inode_lock);
+}
+
+void remove_dirty_dir_inode(struct inode *inode)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       struct list_head *head = &sbi->dir_inode_list;
+       struct list_head *this;
+
+       if (!S_ISDIR(inode->i_mode))
+               return;
+
+       spin_lock(&sbi->dir_inode_lock);
+       if (atomic_read(&F2FS_I(inode)->dirty_dents))
+               goto out;
+
+       list_for_each(this, head) {
+               struct dir_inode_entry *entry;
+               entry = list_entry(this, struct dir_inode_entry, list);
+               if (entry->inode == inode) {
+                       list_del(&entry->list);
+                       kmem_cache_free(inode_entry_slab, entry);
+                       sbi->n_dirty_dirs--;
+                       break;
+               }
+       }
+out:
+       spin_unlock(&sbi->dir_inode_lock);
+}
+
+void sync_dirty_dir_inodes(struct f2fs_sb_info *sbi)
+{
+       struct list_head *head = &sbi->dir_inode_list;
+       struct dir_inode_entry *entry;
+       struct inode *inode;
+retry:
+       spin_lock(&sbi->dir_inode_lock);
+       if (list_empty(head)) {
+               spin_unlock(&sbi->dir_inode_lock);
+               return;
+       }
+       entry = list_entry(head->next, struct dir_inode_entry, list);
+       inode = igrab(entry->inode);
+       spin_unlock(&sbi->dir_inode_lock);
+       if (inode) {
+               filemap_flush(inode->i_mapping);
+               iput(inode);
+       } else {
+               /*
+                * We should submit bio, since it exists several
+                * wribacking dentry pages in the freeing inode.
+                */
+               f2fs_submit_bio(sbi, DATA, true);
+       }
+       goto retry;
+}
+
+/*
+ * Freeze all the FS-operations for checkpoint.
+ */
+void block_operations(struct f2fs_sb_info *sbi)
+{
+       int t;
+       struct writeback_control wbc = {
+               .sync_mode = WB_SYNC_ALL,
+               .nr_to_write = LONG_MAX,
+               .for_reclaim = 0,
+       };
+
+       /* Stop renaming operation */
+       mutex_lock_op(sbi, RENAME);
+       mutex_lock_op(sbi, DENTRY_OPS);
+
+retry_dents:
+       /* write all the dirty dentry pages */
+       sync_dirty_dir_inodes(sbi);
+
+       mutex_lock_op(sbi, DATA_WRITE);
+       if (get_pages(sbi, F2FS_DIRTY_DENTS)) {
+               mutex_unlock_op(sbi, DATA_WRITE);
+               goto retry_dents;
+       }
+
+       /* block all the operations */
+       for (t = DATA_NEW; t <= NODE_TRUNC; t++)
+               mutex_lock_op(sbi, t);
+
+       mutex_lock(&sbi->write_inode);
+
+       /*
+        * POR: we should ensure that there is no dirty node pages
+        * until finishing nat/sit flush.
+        */
+retry:
+       sync_node_pages(sbi, 0, &wbc);
+
+       mutex_lock_op(sbi, NODE_WRITE);
+
+       if (get_pages(sbi, F2FS_DIRTY_NODES)) {
+               mutex_unlock_op(sbi, NODE_WRITE);
+               goto retry;
+       }
+       mutex_unlock(&sbi->write_inode);
+}
+
+static void unblock_operations(struct f2fs_sb_info *sbi)
+{
+       int t;
+       for (t = NODE_WRITE; t >= RENAME; t--)
+               mutex_unlock_op(sbi, t);
+}
+
+static void do_checkpoint(struct f2fs_sb_info *sbi, bool is_umount)
+{
+       struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
+       nid_t last_nid = 0;
+       block_t start_blk;
+       struct page *cp_page;
+       unsigned int data_sum_blocks, orphan_blocks;
+       unsigned int crc32 = 0;
+       void *kaddr;
+       int i;
+
+       /* Flush all the NAT/SIT pages */
+       while (get_pages(sbi, F2FS_DIRTY_META))
+               sync_meta_pages(sbi, META, LONG_MAX);
+
+       next_free_nid(sbi, &last_nid);
+
+       /*
+        * modify checkpoint
+        * version number is already updated
+        */
+       ckpt->elapsed_time = cpu_to_le64(get_mtime(sbi));
+       ckpt->valid_block_count = cpu_to_le64(valid_user_blocks(sbi));
+       ckpt->free_segment_count = cpu_to_le32(free_segments(sbi));
+       for (i = 0; i < 3; i++) {
+               ckpt->cur_node_segno[i] =
+                       cpu_to_le32(curseg_segno(sbi, i + CURSEG_HOT_NODE));
+               ckpt->cur_node_blkoff[i] =
+                       cpu_to_le16(curseg_blkoff(sbi, i + CURSEG_HOT_NODE));
+               ckpt->alloc_type[i + CURSEG_HOT_NODE] =
+                               curseg_alloc_type(sbi, i + CURSEG_HOT_NODE);
+       }
+       for (i = 0; i < 3; i++) {
+               ckpt->cur_data_segno[i] =
+                       cpu_to_le32(curseg_segno(sbi, i + CURSEG_HOT_DATA));
+               ckpt->cur_data_blkoff[i] =
+                       cpu_to_le16(curseg_blkoff(sbi, i + CURSEG_HOT_DATA));
+               ckpt->alloc_type[i + CURSEG_HOT_DATA] =
+                               curseg_alloc_type(sbi, i + CURSEG_HOT_DATA);
+       }
+
+       ckpt->valid_node_count = cpu_to_le32(valid_node_count(sbi));
+       ckpt->valid_inode_count = cpu_to_le32(valid_inode_count(sbi));
+       ckpt->next_free_nid = cpu_to_le32(last_nid);
+
+       /* 2 cp  + n data seg summary + orphan inode blocks */
+       data_sum_blocks = npages_for_summary_flush(sbi);
+       if (data_sum_blocks < 3)
+               set_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);
+       else
+               clear_ckpt_flags(ckpt, CP_COMPACT_SUM_FLAG);
+
+       orphan_blocks = (sbi->n_orphans + F2FS_ORPHANS_PER_BLOCK - 1)
+                                       / F2FS_ORPHANS_PER_BLOCK;
+       ckpt->cp_pack_start_sum = cpu_to_le32(1 + orphan_blocks);
+
+       if (is_umount) {
+               set_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
+               ckpt->cp_pack_total_block_count = cpu_to_le32(2 +
+                       data_sum_blocks + orphan_blocks + NR_CURSEG_NODE_TYPE);
+       } else {
+               clear_ckpt_flags(ckpt, CP_UMOUNT_FLAG);
+               ckpt->cp_pack_total_block_count = cpu_to_le32(2 +
+                       data_sum_blocks + orphan_blocks);
+       }
+
+       if (sbi->n_orphans)
+               set_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
+       else
+               clear_ckpt_flags(ckpt, CP_ORPHAN_PRESENT_FLAG);
+
+       /* update SIT/NAT bitmap */
+       get_sit_bitmap(sbi, __bitmap_ptr(sbi, SIT_BITMAP));
+       get_nat_bitmap(sbi, __bitmap_ptr(sbi, NAT_BITMAP));
+
+       crc32 = f2fs_crc32(ckpt, le32_to_cpu(ckpt->checksum_offset));
+       *(__le32 *)((unsigned char *)ckpt +
+                               le32_to_cpu(ckpt->checksum_offset))
+                               = cpu_to_le32(crc32);
+
+       start_blk = __start_cp_addr(sbi);
+
+       /* write out checkpoint buffer at block 0 */
+       cp_page = grab_meta_page(sbi, start_blk++);
+       kaddr = page_address(cp_page);
+       memcpy(kaddr, ckpt, (1 << sbi->log_blocksize));
+       set_page_dirty(cp_page);
+       f2fs_put_page(cp_page, 1);
+
+       if (sbi->n_orphans) {
+               write_orphan_inodes(sbi, start_blk);
+               start_blk += orphan_blocks;
+       }
+
+       write_data_summaries(sbi, start_blk);
+       start_blk += data_sum_blocks;
+       if (is_umount) {
+               write_node_summaries(sbi, start_blk);
+               start_blk += NR_CURSEG_NODE_TYPE;
+       }
+
+       /* writeout checkpoint block */
+       cp_page = grab_meta_page(sbi, start_blk);
+       kaddr = page_address(cp_page);
+       memcpy(kaddr, ckpt, (1 << sbi->log_blocksize));
+       set_page_dirty(cp_page);
+       f2fs_put_page(cp_page, 1);
+
+       /* wait for previous submitted node/meta pages writeback */
+       while (get_pages(sbi, F2FS_WRITEBACK))
+               congestion_wait(BLK_RW_ASYNC, HZ / 50);
+
+       filemap_fdatawait_range(sbi->node_inode->i_mapping, 0, LONG_MAX);
+       filemap_fdatawait_range(sbi->meta_inode->i_mapping, 0, LONG_MAX);
+
+       /* update user_block_counts */
+       sbi->last_valid_block_count = sbi->total_valid_block_count;
+       sbi->alloc_valid_block_count = 0;
+
+       /* Here, we only have one bio having CP pack */
+       if (is_set_ckpt_flags(ckpt, CP_ERROR_FLAG))
+               sbi->sb->s_flags |= MS_RDONLY;
+       else
+               sync_meta_pages(sbi, META_FLUSH, LONG_MAX);
+
+       clear_prefree_segments(sbi);
+       F2FS_RESET_SB_DIRT(sbi);
+}
+
+/*
+ * We guarantee that this checkpoint procedure should not fail.
+ */
+void write_checkpoint(struct f2fs_sb_info *sbi, bool blocked, bool is_umount)
+{
+       struct f2fs_checkpoint *ckpt = F2FS_CKPT(sbi);
+       unsigned long long ckpt_ver;
+
+       if (!blocked) {
+               mutex_lock(&sbi->cp_mutex);
+               block_operations(sbi);
+       }
+
+       f2fs_submit_bio(sbi, DATA, true);
+       f2fs_submit_bio(sbi, NODE, true);
+       f2fs_submit_bio(sbi, META, true);
+
+       /*
+        * update checkpoint pack index
+        * Increase the version number so that
+        * SIT entries and seg summaries are written at correct place
+        */
+       ckpt_ver = le64_to_cpu(ckpt->checkpoint_ver);
+       ckpt->checkpoint_ver = cpu_to_le64(++ckpt_ver);
+
+       /* write cached NAT/SIT entries to NAT/SIT area */
+       flush_nat_entries(sbi);
+       flush_sit_entries(sbi);
+
+       reset_victim_segmap(sbi);
+
+       /* unlock all the fs_lock[] in do_checkpoint() */
+       do_checkpoint(sbi, is_umount);
+
+       unblock_operations(sbi);
+       mutex_unlock(&sbi->cp_mutex);
+}
+
+void init_orphan_info(struct f2fs_sb_info *sbi)
+{
+       mutex_init(&sbi->orphan_inode_mutex);
+       INIT_LIST_HEAD(&sbi->orphan_inode_list);
+       sbi->n_orphans = 0;
+}
+
+int create_checkpoint_caches(void)
+{
+       orphan_entry_slab = f2fs_kmem_cache_create("f2fs_orphan_entry",
+                       sizeof(struct orphan_inode_entry), NULL);
+       if (unlikely(!orphan_entry_slab))
+               return -ENOMEM;
+       inode_entry_slab = f2fs_kmem_cache_create("f2fs_dirty_dir_entry",
+                       sizeof(struct dir_inode_entry), NULL);
+       if (unlikely(!inode_entry_slab)) {
+               kmem_cache_destroy(orphan_entry_slab);
+               return -ENOMEM;
+       }
+       return 0;
+}
+
+void destroy_checkpoint_caches(void)
+{
+       kmem_cache_destroy(orphan_entry_slab);
+       kmem_cache_destroy(inode_entry_slab);
+}
diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
new file mode 100644 (file)
index 0000000..655aeab
--- /dev/null
@@ -0,0 +1,702 @@
+/*
+ * fs/f2fs/data.c
+ *
+ * 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.
+ */
+#include <linux/fs.h>
+#include <linux/f2fs_fs.h>
+#include <linux/buffer_head.h>
+#include <linux/mpage.h>
+#include <linux/writeback.h>
+#include <linux/backing-dev.h>
+#include <linux/blkdev.h>
+#include <linux/bio.h>
+
+#include "f2fs.h"
+#include "node.h"
+#include "segment.h"
+
+/*
+ * Lock ordering for the change of data block address:
+ * ->data_page
+ *  ->node_page
+ *    update block addresses in the node page
+ */
+static void __set_data_blkaddr(struct dnode_of_data *dn, block_t new_addr)
+{
+       struct f2fs_node *rn;
+       __le32 *addr_array;
+       struct page *node_page = dn->node_page;
+       unsigned int ofs_in_node = dn->ofs_in_node;
+
+       wait_on_page_writeback(node_page);
+
+       rn = (struct f2fs_node *)page_address(node_page);
+
+       /* Get physical address of data block */
+       addr_array = blkaddr_in_node(rn);
+       addr_array[ofs_in_node] = cpu_to_le32(new_addr);
+       set_page_dirty(node_page);
+}
+
+int reserve_new_block(struct dnode_of_data *dn)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);
+
+       if (is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC))
+               return -EPERM;
+       if (!inc_valid_block_count(sbi, dn->inode, 1))
+               return -ENOSPC;
+
+       __set_data_blkaddr(dn, NEW_ADDR);
+       dn->data_blkaddr = NEW_ADDR;
+       sync_inode_page(dn);
+       return 0;
+}
+
+static int check_extent_cache(struct inode *inode, pgoff_t pgofs,
+                                       struct buffer_head *bh_result)
+{
+       struct f2fs_inode_info *fi = F2FS_I(inode);
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       pgoff_t start_fofs, end_fofs;
+       block_t start_blkaddr;
+
+       read_lock(&fi->ext.ext_lock);
+       if (fi->ext.len == 0) {
+               read_unlock(&fi->ext.ext_lock);
+               return 0;
+       }
+
+       sbi->total_hit_ext++;
+       start_fofs = fi->ext.fofs;
+       end_fofs = fi->ext.fofs + fi->ext.len - 1;
+       start_blkaddr = fi->ext.blk_addr;
+
+       if (pgofs >= start_fofs && pgofs <= end_fofs) {
+               unsigned int blkbits = inode->i_sb->s_blocksize_bits;
+               size_t count;
+
+               clear_buffer_new(bh_result);
+               map_bh(bh_result, inode->i_sb,
+                               start_blkaddr + pgofs - start_fofs);
+               count = end_fofs - pgofs + 1;
+               if (count < (UINT_MAX >> blkbits))
+                       bh_result->b_size = (count << blkbits);
+               else
+                       bh_result->b_size = UINT_MAX;
+
+               sbi->read_hit_ext++;
+               read_unlock(&fi->ext.ext_lock);
+               return 1;
+       }
+       read_unlock(&fi->ext.ext_lock);
+       return 0;
+}
+
+void update_extent_cache(block_t blk_addr, struct dnode_of_data *dn)
+{
+       struct f2fs_inode_info *fi = F2FS_I(dn->inode);
+       pgoff_t fofs, start_fofs, end_fofs;
+       block_t start_blkaddr, end_blkaddr;
+
+       BUG_ON(blk_addr == NEW_ADDR);
+       fofs = start_bidx_of_node(ofs_of_node(dn->node_page)) + dn->ofs_in_node;
+
+       /* Update the page address in the parent node */
+       __set_data_blkaddr(dn, blk_addr);
+
+       write_lock(&fi->ext.ext_lock);
+
+       start_fofs = fi->ext.fofs;
+       end_fofs = fi->ext.fofs + fi->ext.len - 1;
+       start_blkaddr = fi->ext.blk_addr;
+       end_blkaddr = fi->ext.blk_addr + fi->ext.len - 1;
+
+       /* Drop and initialize the matched extent */
+       if (fi->ext.len == 1 && fofs == start_fofs)
+               fi->ext.len = 0;
+
+       /* Initial extent */
+       if (fi->ext.len == 0) {
+               if (blk_addr != NULL_ADDR) {
+                       fi->ext.fofs = fofs;
+                       fi->ext.blk_addr = blk_addr;
+                       fi->ext.len = 1;
+               }
+               goto end_update;
+       }
+
+       /* Frone merge */
+       if (fofs == start_fofs - 1 && blk_addr == start_blkaddr - 1) {
+               fi->ext.fofs--;
+               fi->ext.blk_addr--;
+               fi->ext.len++;
+               goto end_update;
+       }
+
+       /* Back merge */
+       if (fofs == end_fofs + 1 && blk_addr == end_blkaddr + 1) {
+               fi->ext.len++;
+               goto end_update;
+       }
+
+       /* Split the existing extent */
+       if (fi->ext.len > 1 &&
+               fofs >= start_fofs && fofs <= end_fofs) {
+               if ((end_fofs - fofs) < (fi->ext.len >> 1)) {
+                       fi->ext.len = fofs - start_fofs;
+               } else {
+                       fi->ext.fofs = fofs + 1;
+                       fi->ext.blk_addr = start_blkaddr +
+                                       fofs - start_fofs + 1;
+                       fi->ext.len -= fofs - start_fofs + 1;
+               }
+               goto end_update;
+       }
+       write_unlock(&fi->ext.ext_lock);
+       return;
+
+end_update:
+       write_unlock(&fi->ext.ext_lock);
+       sync_inode_page(dn);
+       return;
+}
+
+struct page *find_data_page(struct inode *inode, pgoff_t index)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       struct address_space *mapping = inode->i_mapping;
+       struct dnode_of_data dn;
+       struct page *page;
+       int err;
+
+       page = find_get_page(mapping, index);
+       if (page && PageUptodate(page))
+               return page;
+       f2fs_put_page(page, 0);
+
+       set_new_dnode(&dn, inode, NULL, NULL, 0);
+       err = get_dnode_of_data(&dn, index, RDONLY_NODE);
+       if (err)
+               return ERR_PTR(err);
+       f2fs_put_dnode(&dn);
+
+       if (dn.data_blkaddr == NULL_ADDR)
+               return ERR_PTR(-ENOENT);
+
+       /* By fallocate(), there is no cached page, but with NEW_ADDR */
+       if (dn.data_blkaddr == NEW_ADDR)
+               return ERR_PTR(-EINVAL);
+
+       page = grab_cache_page(mapping, index);
+       if (!page)
+               return ERR_PTR(-ENOMEM);
+
+       err = f2fs_readpage(sbi, page, dn.data_blkaddr, READ_SYNC);
+       if (err) {
+               f2fs_put_page(page, 1);
+               return ERR_PTR(err);
+       }
+       unlock_page(page);
+       return page;
+}
+
+/*
+ * If it tries to access a hole, return an error.
+ * Because, the callers, functions in dir.c and GC, should be able to know
+ * whether this page exists or not.
+ */
+struct page *get_lock_data_page(struct inode *inode, pgoff_t index)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       struct address_space *mapping = inode->i_mapping;
+       struct dnode_of_data dn;
+       struct page *page;
+       int err;
+
+       set_new_dnode(&dn, inode, NULL, NULL, 0);
+       err = get_dnode_of_data(&dn, index, RDONLY_NODE);
+       if (err)
+               return ERR_PTR(err);
+       f2fs_put_dnode(&dn);
+
+       if (dn.data_blkaddr == NULL_ADDR)
+               return ERR_PTR(-ENOENT);
+
+       page = grab_cache_page(mapping, index);
+       if (!page)
+               return ERR_PTR(-ENOMEM);
+
+       if (PageUptodate(page))
+               return page;
+
+       BUG_ON(dn.data_blkaddr == NEW_ADDR);
+       BUG_ON(dn.data_blkaddr == NULL_ADDR);
+
+       err = f2fs_readpage(sbi, page, dn.data_blkaddr, READ_SYNC);
+       if (err) {
+               f2fs_put_page(page, 1);
+               return ERR_PTR(err);
+       }
+       return page;
+}
+
+/*
+ * Caller ensures that this data page is never allocated.
+ * A new zero-filled data page is allocated in the page cache.
+ */
+struct page *get_new_data_page(struct inode *inode, pgoff_t index,
+                                               bool new_i_size)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       struct address_space *mapping = inode->i_mapping;
+       struct page *page;
+       struct dnode_of_data dn;
+       int err;
+
+       set_new_dnode(&dn, inode, NULL, NULL, 0);
+       err = get_dnode_of_data(&dn, index, 0);
+       if (err)
+               return ERR_PTR(err);
+
+       if (dn.data_blkaddr == NULL_ADDR) {
+               if (reserve_new_block(&dn)) {
+                       f2fs_put_dnode(&dn);
+                       return ERR_PTR(-ENOSPC);
+               }
+       }
+       f2fs_put_dnode(&dn);
+
+       page = grab_cache_page(mapping, index);
+       if (!page)
+               return ERR_PTR(-ENOMEM);
+
+       if (PageUptodate(page))
+               return page;
+
+       if (dn.data_blkaddr == NEW_ADDR) {
+               zero_user_segment(page, 0, PAGE_CACHE_SIZE);
+       } else {
+               err = f2fs_readpage(sbi, page, dn.data_blkaddr, READ_SYNC);
+               if (err) {
+                       f2fs_put_page(page, 1);
+                       return ERR_PTR(err);
+               }
+       }
+       SetPageUptodate(page);
+
+       if (new_i_size &&
+               i_size_read(inode) < ((index + 1) << PAGE_CACHE_SHIFT)) {
+               i_size_write(inode, ((index + 1) << PAGE_CACHE_SHIFT));
+               mark_inode_dirty_sync(inode);
+       }
+       return page;
+}
+
+static void read_end_io(struct bio *bio, int err)
+{
+       const int uptodate = test_bit(BIO_UPTODATE, &bio->bi_flags);
+       struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
+
+       do {
+               struct page *page = bvec->bv_page;
+
+               if (--bvec >= bio->bi_io_vec)
+                       prefetchw(&bvec->bv_page->flags);
+
+               if (uptodate) {
+                       SetPageUptodate(page);
+               } else {
+                       ClearPageUptodate(page);
+                       SetPageError(page);
+               }
+               unlock_page(page);
+       } while (bvec >= bio->bi_io_vec);
+       kfree(bio->bi_private);
+       bio_put(bio);
+}
+
+/*
+ * Fill the locked page with data located in the block address.
+ * Read operation is synchronous, and caller must unlock the page.
+ */
+int f2fs_readpage(struct f2fs_sb_info *sbi, struct page *page,
+                                       block_t blk_addr, int type)
+{
+       struct block_device *bdev = sbi->sb->s_bdev;
+       bool sync = (type == READ_SYNC);
+       struct bio *bio;
+
+       /* This page can be already read by other threads */
+       if (PageUptodate(page)) {
+               if (!sync)
+                       unlock_page(page);
+               return 0;
+       }
+
+       down_read(&sbi->bio_sem);
+
+       /* Allocate a new bio */
+       bio = f2fs_bio_alloc(bdev, 1);
+
+       /* Initialize the bio */
+       bio->bi_sector = SECTOR_FROM_BLOCK(sbi, blk_addr);
+       bio->bi_end_io = read_end_io;
+
+       if (bio_add_page(bio, page, PAGE_CACHE_SIZE, 0) < PAGE_CACHE_SIZE) {
+               kfree(bio->bi_private);
+               bio_put(bio);
+               up_read(&sbi->bio_sem);
+               return -EFAULT;
+       }
+
+       submit_bio(type, bio);
+       up_read(&sbi->bio_sem);
+
+       /* wait for read completion if sync */
+       if (sync) {
+               lock_page(page);
+               if (PageError(page))
+                       return -EIO;
+       }
+       return 0;
+}
+
+/*
+ * This function should be used by the data read flow only where it
+ * does not check the "create" flag that indicates block allocation.
+ * The reason for this special functionality is to exploit VFS readahead
+ * mechanism.
+ */
+static int get_data_block_ro(struct inode *inode, sector_t iblock,
+                       struct buffer_head *bh_result, int create)
+{
+       unsigned int blkbits = inode->i_sb->s_blocksize_bits;
+       unsigned maxblocks = bh_result->b_size >> blkbits;
+       struct dnode_of_data dn;
+       pgoff_t pgofs;
+       int err;
+
+       /* Get the page offset from the block offset(iblock) */
+       pgofs = (pgoff_t)(iblock >> (PAGE_CACHE_SHIFT - blkbits));
+
+       if (check_extent_cache(inode, pgofs, bh_result))
+               return 0;
+
+       /* When reading holes, we need its node page */
+       set_new_dnode(&dn, inode, NULL, NULL, 0);
+       err = get_dnode_of_data(&dn, pgofs, RDONLY_NODE);
+       if (err)
+               return (err == -ENOENT) ? 0 : err;
+
+       /* It does not support data allocation */
+       BUG_ON(create);
+
+       if (dn.data_blkaddr != NEW_ADDR && dn.data_blkaddr != NULL_ADDR) {
+               int i;
+               unsigned int end_offset;
+
+               end_offset = IS_INODE(dn.node_page) ?
+                               ADDRS_PER_INODE :
+                               ADDRS_PER_BLOCK;
+
+               clear_buffer_new(bh_result);
+
+               /* Give more consecutive addresses for the read ahead */
+               for (i = 0; i < end_offset - dn.ofs_in_node; i++)
+                       if (((datablock_addr(dn.node_page,
+                                                       dn.ofs_in_node + i))
+                               != (dn.data_blkaddr + i)) || maxblocks == i)
+                               break;
+               map_bh(bh_result, inode->i_sb, dn.data_blkaddr);
+               bh_result->b_size = (i << blkbits);
+       }
+       f2fs_put_dnode(&dn);
+       return 0;
+}
+
+static int f2fs_read_data_page(struct file *file, struct page *page)
+{
+       return mpage_readpage(page, get_data_block_ro);
+}
+
+static int f2fs_read_data_pages(struct file *file,
+                       struct address_space *mapping,
+                       struct list_head *pages, unsigned nr_pages)
+{
+       return mpage_readpages(mapping, pages, nr_pages, get_data_block_ro);
+}
+
+int do_write_data_page(struct page *page)
+{
+       struct inode *inode = page->mapping->host;
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       block_t old_blk_addr, new_blk_addr;
+       struct dnode_of_data dn;
+       int err = 0;
+
+       set_new_dnode(&dn, inode, NULL, NULL, 0);
+       err = get_dnode_of_data(&dn, page->index, RDONLY_NODE);
+       if (err)
+               return err;
+
+       old_blk_addr = dn.data_blkaddr;
+
+       /* This page is already truncated */
+       if (old_blk_addr == NULL_ADDR)
+               goto out_writepage;
+
+       set_page_writeback(page);
+
+       /*
+        * If current allocation needs SSR,
+        * it had better in-place writes for updated data.
+        */
+       if (old_blk_addr != NEW_ADDR && !is_cold_data(page) &&
+                               need_inplace_update(inode)) {
+               rewrite_data_page(F2FS_SB(inode->i_sb), page,
+                                               old_blk_addr);
+       } else {
+               write_data_page(inode, page, &dn,
+                               old_blk_addr, &new_blk_addr);
+               update_extent_cache(new_blk_addr, &dn);
+               F2FS_I(inode)->data_version =
+                       le64_to_cpu(F2FS_CKPT(sbi)->checkpoint_ver);
+       }
+out_writepage:
+       f2fs_put_dnode(&dn);
+       return err;
+}
+
+static int f2fs_write_data_page(struct page *page,
+                                       struct writeback_control *wbc)
+{
+       struct inode *inode = page->mapping->host;
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       loff_t i_size = i_size_read(inode);
+       const pgoff_t end_index = ((unsigned long long) i_size)
+                                                       >> PAGE_CACHE_SHIFT;
+       unsigned offset;
+       int err = 0;
+
+       if (page->index < end_index)
+               goto out;
+
+       /*
+        * If the offset is out-of-range of file size,
+        * this page does not have to be written to disk.
+        */
+       offset = i_size & (PAGE_CACHE_SIZE - 1);
+       if ((page->index >= end_index + 1) || !offset) {
+               if (S_ISDIR(inode->i_mode)) {
+                       dec_page_count(sbi, F2FS_DIRTY_DENTS);
+                       inode_dec_dirty_dents(inode);
+               }
+               goto unlock_out;
+       }
+
+       zero_user_segment(page, offset, PAGE_CACHE_SIZE);
+out:
+       if (sbi->por_doing)
+               goto redirty_out;
+
+       if (wbc->for_reclaim && !S_ISDIR(inode->i_mode) && !is_cold_data(page))
+               goto redirty_out;
+
+       mutex_lock_op(sbi, DATA_WRITE);
+       if (S_ISDIR(inode->i_mode)) {
+               dec_page_count(sbi, F2FS_DIRTY_DENTS);
+               inode_dec_dirty_dents(inode);
+       }
+       err = do_write_data_page(page);
+       if (err && err != -ENOENT) {
+               wbc->pages_skipped++;
+               set_page_dirty(page);
+       }
+       mutex_unlock_op(sbi, DATA_WRITE);
+
+       if (wbc->for_reclaim)
+               f2fs_submit_bio(sbi, DATA, true);
+
+       if (err == -ENOENT)
+               goto unlock_out;
+
+       clear_cold_data(page);
+       unlock_page(page);
+
+       if (!wbc->for_reclaim && !S_ISDIR(inode->i_mode))
+               f2fs_balance_fs(sbi);
+       return 0;
+
+unlock_out:
+       unlock_page(page);
+       return (err == -ENOENT) ? 0 : err;
+
+redirty_out:
+       wbc->pages_skipped++;
+       set_page_dirty(page);
+       return AOP_WRITEPAGE_ACTIVATE;
+}
+
+#define MAX_DESIRED_PAGES_WP   4096
+
+static int f2fs_write_data_pages(struct address_space *mapping,
+                           struct writeback_control *wbc)
+{
+       struct inode *inode = mapping->host;
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       int ret;
+       long excess_nrtw = 0, desired_nrtw;
+
+       if (wbc->nr_to_write < MAX_DESIRED_PAGES_WP) {
+               desired_nrtw = MAX_DESIRED_PAGES_WP;
+               excess_nrtw = desired_nrtw - wbc->nr_to_write;
+               wbc->nr_to_write = desired_nrtw;
+       }
+
+       if (!S_ISDIR(inode->i_mode))
+               mutex_lock(&sbi->writepages);
+       ret = generic_writepages(mapping, wbc);
+       if (!S_ISDIR(inode->i_mode))
+               mutex_unlock(&sbi->writepages);
+       f2fs_submit_bio(sbi, DATA, (wbc->sync_mode == WB_SYNC_ALL));
+
+       remove_dirty_dir_inode(inode);
+
+       wbc->nr_to_write -= excess_nrtw;
+       return ret;
+}
+
+static int f2fs_write_begin(struct file *file, struct address_space *mapping,
+               loff_t pos, unsigned len, unsigned flags,
+               struct page **pagep, void **fsdata)
+{
+       struct inode *inode = mapping->host;
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       struct page *page;
+       pgoff_t index = ((unsigned long long) pos) >> PAGE_CACHE_SHIFT;
+       struct dnode_of_data dn;
+       int err = 0;
+
+       /* for nobh_write_end */
+       *fsdata = NULL;
+
+       f2fs_balance_fs(sbi);
+
+       page = grab_cache_page_write_begin(mapping, index, flags);
+       if (!page)
+               return -ENOMEM;
+       *pagep = page;
+
+       mutex_lock_op(sbi, DATA_NEW);
+
+       set_new_dnode(&dn, inode, NULL, NULL, 0);
+       err = get_dnode_of_data(&dn, index, 0);
+       if (err) {
+               mutex_unlock_op(sbi, DATA_NEW);
+               f2fs_put_page(page, 1);
+               return err;
+       }
+
+       if (dn.data_blkaddr == NULL_ADDR) {
+               err = reserve_new_block(&dn);
+               if (err) {
+                       f2fs_put_dnode(&dn);
+                       mutex_unlock_op(sbi, DATA_NEW);
+                       f2fs_put_page(page, 1);
+                       return err;
+               }
+       }
+       f2fs_put_dnode(&dn);
+
+       mutex_unlock_op(sbi, DATA_NEW);
+
+       if ((len == PAGE_CACHE_SIZE) || PageUptodate(page))
+               return 0;
+
+       if ((pos & PAGE_CACHE_MASK) >= i_size_read(inode)) {
+               unsigned start = pos & (PAGE_CACHE_SIZE - 1);
+               unsigned end = start + len;
+
+               /* Reading beyond i_size is simple: memset to zero */
+               zero_user_segments(page, 0, start, end, PAGE_CACHE_SIZE);
+               return 0;
+       }
+
+       if (dn.data_blkaddr == NEW_ADDR) {
+               zero_user_segment(page, 0, PAGE_CACHE_SIZE);
+       } else {
+               err = f2fs_readpage(sbi, page, dn.data_blkaddr, READ_SYNC);
+               if (err) {
+                       f2fs_put_page(page, 1);
+                       return err;
+               }
+       }
+       SetPageUptodate(page);
+       clear_cold_data(page);
+       return 0;
+}
+
+static ssize_t f2fs_direct_IO(int rw, struct kiocb *iocb,
+               const struct iovec *iov, loff_t offset, unsigned long nr_segs)
+{
+       struct file *file = iocb->ki_filp;
+       struct inode *inode = file->f_mapping->host;
+
+       if (rw == WRITE)
+               return 0;
+
+       /* Needs synchronization with the cleaner */
+       return blockdev_direct_IO(rw, iocb, inode, iov, offset, nr_segs,
+                                                 get_data_block_ro);
+}
+
+static void f2fs_invalidate_data_page(struct page *page, unsigned long offset)
+{
+       struct inode *inode = page->mapping->host;
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       if (S_ISDIR(inode->i_mode) && PageDirty(page)) {
+               dec_page_count(sbi, F2FS_DIRTY_DENTS);
+               inode_dec_dirty_dents(inode);
+       }
+       ClearPagePrivate(page);
+}
+
+static int f2fs_release_data_page(struct page *page, gfp_t wait)
+{
+       ClearPagePrivate(page);
+       return 0;
+}
+
+static int f2fs_set_data_page_dirty(struct page *page)
+{
+       struct address_space *mapping = page->mapping;
+       struct inode *inode = mapping->host;
+
+       SetPageUptodate(page);
+       if (!PageDirty(page)) {
+               __set_page_dirty_nobuffers(page);
+               set_dirty_dir_page(inode, page);
+               return 1;
+       }
+       return 0;
+}
+
+const struct address_space_operations f2fs_dblock_aops = {
+       .readpage       = f2fs_read_data_page,
+       .readpages      = f2fs_read_data_pages,
+       .writepage      = f2fs_write_data_page,
+       .writepages     = f2fs_write_data_pages,
+       .write_begin    = f2fs_write_begin,
+       .write_end      = nobh_write_end,
+       .set_page_dirty = f2fs_set_data_page_dirty,
+       .invalidatepage = f2fs_invalidate_data_page,
+       .releasepage    = f2fs_release_data_page,
+       .direct_IO      = f2fs_direct_IO,
+};
diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
new file mode 100644 (file)
index 0000000..0e0380a
--- /dev/null
@@ -0,0 +1,361 @@
+/*
+ * f2fs debugging statistics
+ *
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ *             http://www.samsung.com/
+ * Copyright (c) 2012 Linux Foundation
+ * Copyright (c) 2012 Greg Kroah-Hartman <gregkh@linuxfoundation.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.
+ */
+
+#include <linux/fs.h>
+#include <linux/backing-dev.h>
+#include <linux/proc_fs.h>
+#include <linux/f2fs_fs.h>
+#include <linux/blkdev.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+
+#include "f2fs.h"
+#include "node.h"
+#include "segment.h"
+#include "gc.h"
+
+static LIST_HEAD(f2fs_stat_list);
+static struct dentry *debugfs_root;
+
+static void update_general_status(struct f2fs_sb_info *sbi)
+{
+       struct f2fs_stat_info *si = sbi->stat_info;
+       int i;
+
+       /* valid check of the segment numbers */
+       si->hit_ext = sbi->read_hit_ext;
+       si->total_ext = sbi->total_hit_ext;
+       si->ndirty_node = get_pages(sbi, F2FS_DIRTY_NODES);
+       si->ndirty_dent = get_pages(sbi, F2FS_DIRTY_DENTS);
+       si->ndirty_dirs = sbi->n_dirty_dirs;
+       si->ndirty_meta = get_pages(sbi, F2FS_DIRTY_META);
+       si->total_count = (int)sbi->user_block_count / sbi->blocks_per_seg;
+       si->rsvd_segs = reserved_segments(sbi);
+       si->overp_segs = overprovision_segments(sbi);
+       si->valid_count = valid_user_blocks(sbi);
+       si->valid_node_count = valid_node_count(sbi);
+       si->valid_inode_count = valid_inode_count(sbi);
+       si->utilization = utilization(sbi);
+
+       si->free_segs = free_segments(sbi);
+       si->free_secs = free_sections(sbi);
+       si->prefree_count = prefree_segments(sbi);
+       si->dirty_count = dirty_segments(sbi);
+       si->node_pages = sbi->node_inode->i_mapping->nrpages;
+       si->meta_pages = sbi->meta_inode->i_mapping->nrpages;
+       si->nats = NM_I(sbi)->nat_cnt;
+       si->sits = SIT_I(sbi)->dirty_sentries;
+       si->fnids = NM_I(sbi)->fcnt;
+       si->bg_gc = sbi->bg_gc;
+       si->util_free = (int)(free_user_blocks(sbi) >> sbi->log_blocks_per_seg)
+               * 100 / (int)(sbi->user_block_count >> sbi->log_blocks_per_seg)
+               / 2;
+       si->util_valid = (int)(written_block_count(sbi) >>
+                                               sbi->log_blocks_per_seg)
+               * 100 / (int)(sbi->user_block_count >> sbi->log_blocks_per_seg)
+               / 2;
+       si->util_invalid = 50 - si->util_free - si->util_valid;
+       for (i = CURSEG_HOT_DATA; i <= CURSEG_COLD_NODE; i++) {
+               struct curseg_info *curseg = CURSEG_I(sbi, i);
+               si->curseg[i] = curseg->segno;
+               si->cursec[i] = curseg->segno / sbi->segs_per_sec;
+               si->curzone[i] = si->cursec[i] / sbi->secs_per_zone;
+       }
+
+       for (i = 0; i < 2; i++) {
+               si->segment_count[i] = sbi->segment_count[i];
+               si->block_count[i] = sbi->block_count[i];
+       }
+}
+
+/*
+ * This function calculates BDF of every segments
+ */
+static void update_sit_info(struct f2fs_sb_info *sbi)
+{
+       struct f2fs_stat_info *si = sbi->stat_info;
+       unsigned int blks_per_sec, hblks_per_sec, total_vblocks, bimodal, dist;
+       struct sit_info *sit_i = SIT_I(sbi);
+       unsigned int segno, vblocks;
+       int ndirty = 0;
+
+       bimodal = 0;
+       total_vblocks = 0;
+       blks_per_sec = sbi->segs_per_sec * (1 << sbi->log_blocks_per_seg);
+       hblks_per_sec = blks_per_sec / 2;
+       mutex_lock(&sit_i->sentry_lock);
+       for (segno = 0; segno < TOTAL_SEGS(sbi); segno += sbi->segs_per_sec) {
+               vblocks = get_valid_blocks(sbi, segno, sbi->segs_per_sec);
+               dist = abs(vblocks - hblks_per_sec);
+               bimodal += dist * dist;
+
+               if (vblocks > 0 && vblocks < blks_per_sec) {
+                       total_vblocks += vblocks;
+                       ndirty++;
+               }
+       }
+       mutex_unlock(&sit_i->sentry_lock);
+       dist = sbi->total_sections * hblks_per_sec * hblks_per_sec / 100;
+       si->bimodal = bimodal / dist;
+       if (si->dirty_count)
+               si->avg_vblocks = total_vblocks / ndirty;
+       else
+               si->avg_vblocks = 0;
+}
+
+/*
+ * This function calculates memory footprint.
+ */
+static void update_mem_info(struct f2fs_sb_info *sbi)
+{
+       struct f2fs_stat_info *si = sbi->stat_info;
+       unsigned npages;
+
+       if (si->base_mem)
+               goto get_cache;
+
+       si->base_mem = sizeof(struct f2fs_sb_info) + sbi->sb->s_blocksize;
+       si->base_mem += 2 * sizeof(struct f2fs_inode_info);
+       si->base_mem += sizeof(*sbi->ckpt);
+
+       /* build sm */
+       si->base_mem += sizeof(struct f2fs_sm_info);
+
+       /* build sit */
+       si->base_mem += sizeof(struct sit_info);
+       si->base_mem += TOTAL_SEGS(sbi) * sizeof(struct seg_entry);
+       si->base_mem += f2fs_bitmap_size(TOTAL_SEGS(sbi));
+       si->base_mem += 2 * SIT_VBLOCK_MAP_SIZE * TOTAL_SEGS(sbi);
+       if (sbi->segs_per_sec > 1)
+               si->base_mem += sbi->total_sections *
+                       sizeof(struct sec_entry);
+       si->base_mem += __bitmap_size(sbi, SIT_BITMAP);
+
+       /* build free segmap */
+       si->base_mem += sizeof(struct free_segmap_info);
+       si->base_mem += f2fs_bitmap_size(TOTAL_SEGS(sbi));
+       si->base_mem += f2fs_bitmap_size(sbi->total_sections);
+
+       /* build curseg */
+       si->base_mem += sizeof(struct curseg_info) * NR_CURSEG_TYPE;
+       si->base_mem += PAGE_CACHE_SIZE * NR_CURSEG_TYPE;
+
+       /* build dirty segmap */
+       si->base_mem += sizeof(struct dirty_seglist_info);
+       si->base_mem += NR_DIRTY_TYPE * f2fs_bitmap_size(TOTAL_SEGS(sbi));
+       si->base_mem += 2 * f2fs_bitmap_size(TOTAL_SEGS(sbi));
+
+       /* buld nm */
+       si->base_mem += sizeof(struct f2fs_nm_info);
+       si->base_mem += __bitmap_size(sbi, NAT_BITMAP);
+
+       /* build gc */
+       si->base_mem += sizeof(struct f2fs_gc_kthread);
+
+get_cache:
+       /* free nids */
+       si->cache_mem = NM_I(sbi)->fcnt;
+       si->cache_mem += NM_I(sbi)->nat_cnt;
+       npages = sbi->node_inode->i_mapping->nrpages;
+       si->cache_mem += npages << PAGE_CACHE_SHIFT;
+       npages = sbi->meta_inode->i_mapping->nrpages;
+       si->cache_mem += npages << PAGE_CACHE_SHIFT;
+       si->cache_mem += sbi->n_orphans * sizeof(struct orphan_inode_entry);
+       si->cache_mem += sbi->n_dirty_dirs * sizeof(struct dir_inode_entry);
+}
+
+static int stat_show(struct seq_file *s, void *v)
+{
+       struct f2fs_stat_info *si, *next;
+       int i = 0;
+       int j;
+
+       list_for_each_entry_safe(si, next, &f2fs_stat_list, stat_list) {
+
+               mutex_lock(&si->stat_lock);
+               if (!si->sbi) {
+                       mutex_unlock(&si->stat_lock);
+                       continue;
+               }
+               update_general_status(si->sbi);
+
+               seq_printf(s, "\n=====[ partition info. #%d ]=====\n", i++);
+               seq_printf(s, "[SB: 1] [CP: 2] [NAT: %d] [SIT: %d] ",
+                          si->nat_area_segs, si->sit_area_segs);
+               seq_printf(s, "[SSA: %d] [MAIN: %d",
+                          si->ssa_area_segs, si->main_area_segs);
+               seq_printf(s, "(OverProv:%d Resv:%d)]\n\n",
+                          si->overp_segs, si->rsvd_segs);
+               seq_printf(s, "Utilization: %d%% (%d valid blocks)\n",
+                          si->utilization, si->valid_count);
+               seq_printf(s, "  - Node: %u (Inode: %u, ",
+                          si->valid_node_count, si->valid_inode_count);
+               seq_printf(s, "Other: %u)\n  - Data: %u\n",
+                          si->valid_node_count - si->valid_inode_count,
+                          si->valid_count - si->valid_node_count);
+               seq_printf(s, "\nMain area: %d segs, %d secs %d zones\n",
+                          si->main_area_segs, si->main_area_sections,
+                          si->main_area_zones);
+               seq_printf(s, "  - COLD  data: %d, %d, %d\n",
+                          si->curseg[CURSEG_COLD_DATA],
+                          si->cursec[CURSEG_COLD_DATA],
+                          si->curzone[CURSEG_COLD_DATA]);
+               seq_printf(s, "  - WARM  data: %d, %d, %d\n",
+                          si->curseg[CURSEG_WARM_DATA],
+                          si->cursec[CURSEG_WARM_DATA],
+                          si->curzone[CURSEG_WARM_DATA]);
+               seq_printf(s, "  - HOT   data: %d, %d, %d\n",
+                          si->curseg[CURSEG_HOT_DATA],
+                          si->cursec[CURSEG_HOT_DATA],
+                          si->curzone[CURSEG_HOT_DATA]);
+               seq_printf(s, "  - Dir   dnode: %d, %d, %d\n",
+                          si->curseg[CURSEG_HOT_NODE],
+                          si->cursec[CURSEG_HOT_NODE],
+                          si->curzone[CURSEG_HOT_NODE]);
+               seq_printf(s, "  - File   dnode: %d, %d, %d\n",
+                          si->curseg[CURSEG_WARM_NODE],
+                          si->cursec[CURSEG_WARM_NODE],
+                          si->curzone[CURSEG_WARM_NODE]);
+               seq_printf(s, "  - Indir nodes: %d, %d, %d\n",
+                          si->curseg[CURSEG_COLD_NODE],
+                          si->cursec[CURSEG_COLD_NODE],
+                          si->curzone[CURSEG_COLD_NODE]);
+               seq_printf(s, "\n  - Valid: %d\n  - Dirty: %d\n",
+                          si->main_area_segs - si->dirty_count -
+                          si->prefree_count - si->free_segs,
+                          si->dirty_count);
+               seq_printf(s, "  - Prefree: %d\n  - Free: %d (%d)\n\n",
+                          si->prefree_count, si->free_segs, si->free_secs);
+               seq_printf(s, "GC calls: %d (BG: %d)\n",
+                          si->call_count, si->bg_gc);
+               seq_printf(s, "  - data segments : %d\n", si->data_segs);
+               seq_printf(s, "  - node segments : %d\n", si->node_segs);
+               seq_printf(s, "Try to move %d blocks\n", si->tot_blks);
+               seq_printf(s, "  - data blocks : %d\n", si->data_blks);
+               seq_printf(s, "  - node blocks : %d\n", si->node_blks);
+               seq_printf(s, "\nExtent Hit Ratio: %d / %d\n",
+                          si->hit_ext, si->total_ext);
+               seq_printf(s, "\nBalancing F2FS Async:\n");
+               seq_printf(s, "  - nodes %4d in %4d\n",
+                          si->ndirty_node, si->node_pages);
+               seq_printf(s, "  - dents %4d in dirs:%4d\n",
+                          si->ndirty_dent, si->ndirty_dirs);
+               seq_printf(s, "  - meta %4d in %4d\n",
+                          si->ndirty_meta, si->meta_pages);
+               seq_printf(s, "  - NATs %5d > %lu\n",
+                          si->nats, NM_WOUT_THRESHOLD);
+               seq_printf(s, "  - SITs: %5d\n  - free_nids: %5d\n",
+                          si->sits, si->fnids);
+               seq_printf(s, "\nDistribution of User Blocks:");
+               seq_printf(s, " [ valid | invalid | free ]\n");
+               seq_printf(s, "  [");
+
+               for (j = 0; j < si->util_valid; j++)
+                       seq_printf(s, "-");
+               seq_printf(s, "|");
+
+               for (j = 0; j < si->util_invalid; j++)
+                       seq_printf(s, "-");
+               seq_printf(s, "|");
+
+               for (j = 0; j < si->util_free; j++)
+                       seq_printf(s, "-");
+               seq_printf(s, "]\n\n");
+               seq_printf(s, "SSR: %u blocks in %u segments\n",
+                          si->block_count[SSR], si->segment_count[SSR]);
+               seq_printf(s, "LFS: %u blocks in %u segments\n",
+                          si->block_count[LFS], si->segment_count[LFS]);
+
+               /* segment usage info */
+               update_sit_info(si->sbi);
+               seq_printf(s, "\nBDF: %u, avg. vblocks: %u\n",
+                          si->bimodal, si->avg_vblocks);
+
+               /* memory footprint */
+               update_mem_info(si->sbi);
+               seq_printf(s, "\nMemory: %u KB = static: %u + cached: %u\n",
+                               (si->base_mem + si->cache_mem) >> 10,
+                               si->base_mem >> 10, si->cache_mem >> 10);
+               mutex_unlock(&si->stat_lock);
+       }
+       return 0;
+}
+
+static int stat_open(struct inode *inode, struct file *file)
+{
+       return single_open(file, stat_show, inode->i_private);
+}
+
+static const struct file_operations stat_fops = {
+       .open = stat_open,
+       .read = seq_read,
+       .llseek = seq_lseek,
+       .release = single_release,
+};
+
+static int init_stats(struct f2fs_sb_info *sbi)
+{
+       struct f2fs_super_block *raw_super = F2FS_RAW_SUPER(sbi);
+       struct f2fs_stat_info *si;
+
+       sbi->stat_info = kzalloc(sizeof(struct f2fs_stat_info), GFP_KERNEL);
+       if (!sbi->stat_info)
+               return -ENOMEM;
+
+       si = sbi->stat_info;
+       mutex_init(&si->stat_lock);
+       list_add_tail(&si->stat_list, &f2fs_stat_list);
+
+       si->all_area_segs = le32_to_cpu(raw_super->segment_count);
+       si->sit_area_segs = le32_to_cpu(raw_super->segment_count_sit);
+       si->nat_area_segs = le32_to_cpu(raw_super->segment_count_nat);
+       si->ssa_area_segs = le32_to_cpu(raw_super->segment_count_ssa);
+       si->main_area_segs = le32_to_cpu(raw_super->segment_count_main);
+       si->main_area_sections = le32_to_cpu(raw_super->section_count);
+       si->main_area_zones = si->main_area_sections /
+                               le32_to_cpu(raw_super->secs_per_zone);
+       si->sbi = sbi;
+       return 0;
+}
+
+int f2fs_build_stats(struct f2fs_sb_info *sbi)
+{
+       int retval;
+
+       retval = init_stats(sbi);
+       if (retval)
+               return retval;
+
+       if (!debugfs_root)
+               debugfs_root = debugfs_create_dir("f2fs", NULL);
+
+       debugfs_create_file("status", S_IRUGO, debugfs_root, NULL, &stat_fops);
+       return 0;
+}
+
+void f2fs_destroy_stats(struct f2fs_sb_info *sbi)
+{
+       struct f2fs_stat_info *si = sbi->stat_info;
+
+       list_del(&si->stat_list);
+       mutex_lock(&si->stat_lock);
+       si->sbi = NULL;
+       mutex_unlock(&si->stat_lock);
+       kfree(sbi->stat_info);
+}
+
+void destroy_root_stats(void)
+{
+       debugfs_remove_recursive(debugfs_root);
+       debugfs_root = NULL;
+}
diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
new file mode 100644 (file)
index 0000000..b4e24f3
--- /dev/null
@@ -0,0 +1,672 @@
+/*
+ * fs/f2fs/dir.c
+ *
+ * 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.
+ */
+#include <linux/fs.h>
+#include <linux/f2fs_fs.h>
+#include "f2fs.h"
+#include "acl.h"
+
+static unsigned long dir_blocks(struct inode *inode)
+{
+       return ((unsigned long long) (i_size_read(inode) + PAGE_CACHE_SIZE - 1))
+                                                       >> PAGE_CACHE_SHIFT;
+}
+
+static unsigned int dir_buckets(unsigned int level)
+{
+       if (level < MAX_DIR_HASH_DEPTH / 2)
+               return 1 << level;
+       else
+               return 1 << ((MAX_DIR_HASH_DEPTH / 2) - 1);
+}
+
+static unsigned int bucket_blocks(unsigned int level)
+{
+       if (level < MAX_DIR_HASH_DEPTH / 2)
+               return 2;
+       else
+               return 4;
+}
+
+static unsigned char f2fs_filetype_table[F2FS_FT_MAX] = {
+       [F2FS_FT_UNKNOWN]       = DT_UNKNOWN,
+       [F2FS_FT_REG_FILE]      = DT_REG,
+       [F2FS_FT_DIR]           = DT_DIR,
+       [F2FS_FT_CHRDEV]        = DT_CHR,
+       [F2FS_FT_BLKDEV]        = DT_BLK,
+       [F2FS_FT_FIFO]          = DT_FIFO,
+       [F2FS_FT_SOCK]          = DT_SOCK,
+       [F2FS_FT_SYMLINK]       = DT_LNK,
+};
+
+#define S_SHIFT 12
+static unsigned char f2fs_type_by_mode[S_IFMT >> S_SHIFT] = {
+       [S_IFREG >> S_SHIFT]    = F2FS_FT_REG_FILE,
+       [S_IFDIR >> S_SHIFT]    = F2FS_FT_DIR,
+       [S_IFCHR >> S_SHIFT]    = F2FS_FT_CHRDEV,
+       [S_IFBLK >> S_SHIFT]    = F2FS_FT_BLKDEV,
+       [S_IFIFO >> S_SHIFT]    = F2FS_FT_FIFO,
+       [S_IFSOCK >> S_SHIFT]   = F2FS_FT_SOCK,
+       [S_IFLNK >> S_SHIFT]    = F2FS_FT_SYMLINK,
+};
+
+static void set_de_type(struct f2fs_dir_entry *de, struct inode *inode)
+{
+       mode_t mode = inode->i_mode;
+       de->file_type = f2fs_type_by_mode[(mode & S_IFMT) >> S_SHIFT];
+}
+
+static unsigned long dir_block_index(unsigned int level, unsigned int idx)
+{
+       unsigned long i;
+       unsigned long bidx = 0;
+
+       for (i = 0; i < level; i++)
+               bidx += dir_buckets(i) * bucket_blocks(i);
+       bidx += idx * bucket_blocks(level);
+       return bidx;
+}
+
+static bool early_match_name(const char *name, int namelen,
+                       f2fs_hash_t namehash, struct f2fs_dir_entry *de)
+{
+       if (le16_to_cpu(de->name_len) != namelen)
+               return false;
+
+       if (de->hash_code != namehash)
+               return false;
+
+       return true;
+}
+
+static struct f2fs_dir_entry *find_in_block(struct page *dentry_page,
+                       const char *name, int namelen, int *max_slots,
+                       f2fs_hash_t namehash, struct page **res_page)
+{
+       struct f2fs_dir_entry *de;
+       unsigned long bit_pos, end_pos, next_pos;
+       struct f2fs_dentry_block *dentry_blk = kmap(dentry_page);
+       int slots;
+
+       bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
+                                       NR_DENTRY_IN_BLOCK, 0);
+       while (bit_pos < NR_DENTRY_IN_BLOCK) {
+               de = &dentry_blk->dentry[bit_pos];
+               slots = GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
+
+               if (early_match_name(name, namelen, namehash, de)) {
+                       if (!memcmp(dentry_blk->filename[bit_pos],
+                                                       name, namelen)) {
+                               *res_page = dentry_page;
+                               goto found;
+                       }
+               }
+               next_pos = bit_pos + slots;
+               bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
+                               NR_DENTRY_IN_BLOCK, next_pos);
+               if (bit_pos >= NR_DENTRY_IN_BLOCK)
+                       end_pos = NR_DENTRY_IN_BLOCK;
+               else
+                       end_pos = bit_pos;
+               if (*max_slots < end_pos - next_pos)
+                       *max_slots = end_pos - next_pos;
+       }
+
+       de = NULL;
+       kunmap(dentry_page);
+found:
+       return de;
+}
+
+static struct f2fs_dir_entry *find_in_level(struct inode *dir,
+               unsigned int level, const char *name, int namelen,
+                       f2fs_hash_t namehash, struct page **res_page)
+{
+       int s = GET_DENTRY_SLOTS(namelen);
+       unsigned int nbucket, nblock;
+       unsigned int bidx, end_block;
+       struct page *dentry_page;
+       struct f2fs_dir_entry *de = NULL;
+       bool room = false;
+       int max_slots = 0;
+
+       BUG_ON(level > MAX_DIR_HASH_DEPTH);
+
+       nbucket = dir_buckets(level);
+       nblock = bucket_blocks(level);
+
+       bidx = dir_block_index(level, le32_to_cpu(namehash) % nbucket);
+       end_block = bidx + nblock;
+
+       for (; bidx < end_block; bidx++) {
+               /* no need to allocate new dentry pages to all the indices */
+               dentry_page = find_data_page(dir, bidx);
+               if (IS_ERR(dentry_page)) {
+                       room = true;
+                       continue;
+               }
+
+               de = find_in_block(dentry_page, name, namelen,
+                                       &max_slots, namehash, res_page);
+               if (de)
+                       break;
+
+               if (max_slots >= s)
+                       room = true;
+               f2fs_put_page(dentry_page, 0);
+       }
+
+       if (!de && room && F2FS_I(dir)->chash != namehash) {
+               F2FS_I(dir)->chash = namehash;
+               F2FS_I(dir)->clevel = level;
+       }
+
+       return de;
+}
+
+/*
+ * Find an entry in the specified directory with the wanted name.
+ * It returns the page where the entry was found (as a parameter - res_page),
+ * and the entry itself. Page is returned mapped and unlocked.
+ * Entry is guaranteed to be valid.
+ */
+struct f2fs_dir_entry *f2fs_find_entry(struct inode *dir,
+                       struct qstr *child, struct page **res_page)
+{
+       const char *name = child->name;
+       int namelen = child->len;
+       unsigned long npages = dir_blocks(dir);
+       struct f2fs_dir_entry *de = NULL;
+       f2fs_hash_t name_hash;
+       unsigned int max_depth;
+       unsigned int level;
+
+       if (npages == 0)
+               return NULL;
+
+       *res_page = NULL;
+
+       name_hash = f2fs_dentry_hash(name, namelen);
+       max_depth = F2FS_I(dir)->i_current_depth;
+
+       for (level = 0; level < max_depth; level++) {
+               de = find_in_level(dir, level, name,
+                               namelen, name_hash, res_page);
+               if (de)
+                       break;
+       }
+       if (!de && F2FS_I(dir)->chash != name_hash) {
+               F2FS_I(dir)->chash = name_hash;
+               F2FS_I(dir)->clevel = level - 1;
+       }
+       return de;
+}
+
+struct f2fs_dir_entry *f2fs_parent_dir(struct inode *dir, struct page **p)
+{
+       struct page *page = NULL;
+       struct f2fs_dir_entry *de = NULL;
+       struct f2fs_dentry_block *dentry_blk = NULL;
+
+       page = get_lock_data_page(dir, 0);
+       if (IS_ERR(page))
+               return NULL;
+
+       dentry_blk = kmap(page);
+       de = &dentry_blk->dentry[1];
+       *p = page;
+       unlock_page(page);
+       return de;
+}
+
+ino_t f2fs_inode_by_name(struct inode *dir, struct qstr *qstr)
+{
+       ino_t res = 0;
+       struct f2fs_dir_entry *de;
+       struct page *page;
+
+       de = f2fs_find_entry(dir, qstr, &page);
+       if (de) {
+               res = le32_to_cpu(de->ino);
+               kunmap(page);
+               f2fs_put_page(page, 0);
+       }
+
+       return res;
+}
+
+void f2fs_set_link(struct inode *dir, struct f2fs_dir_entry *de,
+               struct page *page, struct inode *inode)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
+
+       mutex_lock_op(sbi, DENTRY_OPS);
+       lock_page(page);
+       wait_on_page_writeback(page);
+       de->ino = cpu_to_le32(inode->i_ino);
+       set_de_type(de, inode);
+       kunmap(page);
+       set_page_dirty(page);
+       dir->i_mtime = dir->i_ctime = CURRENT_TIME;
+       mark_inode_dirty(dir);
+
+       /* update parent inode number before releasing dentry page */
+       F2FS_I(inode)->i_pino = dir->i_ino;
+
+       f2fs_put_page(page, 1);
+       mutex_unlock_op(sbi, DENTRY_OPS);
+}
+
+void init_dent_inode(struct dentry *dentry, struct page *ipage)
+{
+       struct f2fs_node *rn;
+
+       if (IS_ERR(ipage))
+               return;
+
+       wait_on_page_writeback(ipage);
+
+       /* copy dentry info. to this inode page */
+       rn = (struct f2fs_node *)page_address(ipage);
+       rn->i.i_namelen = cpu_to_le32(dentry->d_name.len);
+       memcpy(rn->i.i_name, dentry->d_name.name, dentry->d_name.len);
+       set_page_dirty(ipage);
+}
+
+static int init_inode_metadata(struct inode *inode, struct dentry *dentry)
+{
+       struct inode *dir = dentry->d_parent->d_inode;
+
+       if (is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) {
+               int err;
+               err = new_inode_page(inode, dentry);
+               if (err)
+                       return err;
+
+               if (S_ISDIR(inode->i_mode)) {
+                       err = f2fs_make_empty(inode, dir);
+                       if (err) {
+                               remove_inode_page(inode);
+                               return err;
+                       }
+               }
+
+               err = f2fs_init_acl(inode, dir);
+               if (err) {
+                       remove_inode_page(inode);
+                       return err;
+               }
+       } else {
+               struct page *ipage;
+               ipage = get_node_page(F2FS_SB(dir->i_sb), inode->i_ino);
+               if (IS_ERR(ipage))
+                       return PTR_ERR(ipage);
+               init_dent_inode(dentry, ipage);
+               f2fs_put_page(ipage, 1);
+       }
+       if (is_inode_flag_set(F2FS_I(inode), FI_INC_LINK)) {
+               inc_nlink(inode);
+               f2fs_write_inode(inode, NULL);
+       }
+       return 0;
+}
+
+static void update_parent_metadata(struct inode *dir, struct inode *inode,
+                                               unsigned int current_depth)
+{
+       bool need_dir_update = false;
+
+       if (is_inode_flag_set(F2FS_I(inode), FI_NEW_INODE)) {
+               if (S_ISDIR(inode->i_mode)) {
+                       inc_nlink(dir);
+                       need_dir_update = true;
+               }
+               clear_inode_flag(F2FS_I(inode), FI_NEW_INODE);
+       }
+       dir->i_mtime = dir->i_ctime = CURRENT_TIME;
+       if (F2FS_I(dir)->i_current_depth != current_depth) {
+               F2FS_I(dir)->i_current_depth = current_depth;
+               need_dir_update = true;
+       }
+
+       if (need_dir_update)
+               f2fs_write_inode(dir, NULL);
+       else
+               mark_inode_dirty(dir);
+
+       if (is_inode_flag_set(F2FS_I(inode), FI_INC_LINK))
+               clear_inode_flag(F2FS_I(inode), FI_INC_LINK);
+}
+
+static int room_for_filename(struct f2fs_dentry_block *dentry_blk, int slots)
+{
+       int bit_start = 0;
+       int zero_start, zero_end;
+next:
+       zero_start = find_next_zero_bit_le(&dentry_blk->dentry_bitmap,
+                                               NR_DENTRY_IN_BLOCK,
+                                               bit_start);
+       if (zero_start >= NR_DENTRY_IN_BLOCK)
+               return NR_DENTRY_IN_BLOCK;
+
+       zero_end = find_next_bit_le(&dentry_blk->dentry_bitmap,
+                                               NR_DENTRY_IN_BLOCK,
+                                               zero_start);
+       if (zero_end - zero_start >= slots)
+               return zero_start;
+
+       bit_start = zero_end + 1;
+
+       if (zero_end + 1 >= NR_DENTRY_IN_BLOCK)
+               return NR_DENTRY_IN_BLOCK;
+       goto next;
+}
+
+int f2fs_add_link(struct dentry *dentry, struct inode *inode)
+{
+       unsigned int bit_pos;
+       unsigned int level;
+       unsigned int current_depth;
+       unsigned long bidx, block;
+       f2fs_hash_t dentry_hash;
+       struct f2fs_dir_entry *de;
+       unsigned int nbucket, nblock;
+       struct inode *dir = dentry->d_parent->d_inode;
+       struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
+       const char *name = dentry->d_name.name;
+       int namelen = dentry->d_name.len;
+       struct page *dentry_page = NULL;
+       struct f2fs_dentry_block *dentry_blk = NULL;
+       int slots = GET_DENTRY_SLOTS(namelen);
+       int err = 0;
+       int i;
+
+       dentry_hash = f2fs_dentry_hash(name, dentry->d_name.len);
+       level = 0;
+       current_depth = F2FS_I(dir)->i_current_depth;
+       if (F2FS_I(dir)->chash == dentry_hash) {
+               level = F2FS_I(dir)->clevel;
+               F2FS_I(dir)->chash = 0;
+       }
+
+start:
+       if (current_depth == MAX_DIR_HASH_DEPTH)
+               return -ENOSPC;
+
+       /* Increase the depth, if required */
+       if (level == current_depth)
+               ++current_depth;
+
+       nbucket = dir_buckets(level);
+       nblock = bucket_blocks(level);
+
+       bidx = dir_block_index(level, (le32_to_cpu(dentry_hash) % nbucket));
+
+       for (block = bidx; block <= (bidx + nblock - 1); block++) {
+               mutex_lock_op(sbi, DENTRY_OPS);
+               dentry_page = get_new_data_page(dir, block, true);
+               if (IS_ERR(dentry_page)) {
+                       mutex_unlock_op(sbi, DENTRY_OPS);
+                       return PTR_ERR(dentry_page);
+               }
+
+               dentry_blk = kmap(dentry_page);
+               bit_pos = room_for_filename(dentry_blk, slots);
+               if (bit_pos < NR_DENTRY_IN_BLOCK)
+                       goto add_dentry;
+
+               kunmap(dentry_page);
+               f2fs_put_page(dentry_page, 1);
+               mutex_unlock_op(sbi, DENTRY_OPS);
+       }
+
+       /* Move to next level to find the empty slot for new dentry */
+       ++level;
+       goto start;
+add_dentry:
+       err = init_inode_metadata(inode, dentry);
+       if (err)
+               goto fail;
+
+       wait_on_page_writeback(dentry_page);
+
+       de = &dentry_blk->dentry[bit_pos];
+       de->hash_code = dentry_hash;
+       de->name_len = cpu_to_le16(namelen);
+       memcpy(dentry_blk->filename[bit_pos], name, namelen);
+       de->ino = cpu_to_le32(inode->i_ino);
+       set_de_type(de, inode);
+       for (i = 0; i < slots; i++)
+               test_and_set_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);
+       set_page_dirty(dentry_page);
+
+       update_parent_metadata(dir, inode, current_depth);
+
+       /* update parent inode number before releasing dentry page */
+       F2FS_I(inode)->i_pino = dir->i_ino;
+fail:
+       kunmap(dentry_page);
+       f2fs_put_page(dentry_page, 1);
+       mutex_unlock_op(sbi, DENTRY_OPS);
+       return err;
+}
+
+/*
+ * It only removes the dentry from the dentry page,corresponding name
+ * entry in name page does not need to be touched during deletion.
+ */
+void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
+                                               struct inode *inode)
+{
+       struct  f2fs_dentry_block *dentry_blk;
+       unsigned int bit_pos;
+       struct address_space *mapping = page->mapping;
+       struct inode *dir = mapping->host;
+       struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
+       int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
+       void *kaddr = page_address(page);
+       int i;
+
+       mutex_lock_op(sbi, DENTRY_OPS);
+
+       lock_page(page);
+       wait_on_page_writeback(page);
+
+       dentry_blk = (struct f2fs_dentry_block *)kaddr;
+       bit_pos = dentry - (struct f2fs_dir_entry *)dentry_blk->dentry;
+       for (i = 0; i < slots; i++)
+               test_and_clear_bit_le(bit_pos + i, &dentry_blk->dentry_bitmap);
+
+       /* Let's check and deallocate this dentry page */
+       bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
+                       NR_DENTRY_IN_BLOCK,
+                       0);
+       kunmap(page); /* kunmap - pair of f2fs_find_entry */
+       set_page_dirty(page);
+
+       dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+
+       if (inode && S_ISDIR(inode->i_mode)) {
+               drop_nlink(dir);
+               f2fs_write_inode(dir, NULL);
+       } else {
+               mark_inode_dirty(dir);
+       }
+
+       if (inode) {
+               inode->i_ctime = dir->i_ctime = dir->i_mtime = CURRENT_TIME;
+               drop_nlink(inode);
+               if (S_ISDIR(inode->i_mode)) {
+                       drop_nlink(inode);
+                       i_size_write(inode, 0);
+               }
+               f2fs_write_inode(inode, NULL);
+               if (inode->i_nlink == 0)
+                       add_orphan_inode(sbi, inode->i_ino);
+       }
+
+       if (bit_pos == NR_DENTRY_IN_BLOCK) {
+               truncate_hole(dir, page->index, page->index + 1);
+               clear_page_dirty_for_io(page);
+               ClearPageUptodate(page);
+               dec_page_count(sbi, F2FS_DIRTY_DENTS);
+               inode_dec_dirty_dents(dir);
+       }
+       f2fs_put_page(page, 1);
+
+       mutex_unlock_op(sbi, DENTRY_OPS);
+}
+
+int f2fs_make_empty(struct inode *inode, struct inode *parent)
+{
+       struct page *dentry_page;
+       struct f2fs_dentry_block *dentry_blk;
+       struct f2fs_dir_entry *de;
+       void *kaddr;
+
+       dentry_page = get_new_data_page(inode, 0, true);
+       if (IS_ERR(dentry_page))
+               return PTR_ERR(dentry_page);
+
+       kaddr = kmap_atomic(dentry_page);
+       dentry_blk = (struct f2fs_dentry_block *)kaddr;
+
+       de = &dentry_blk->dentry[0];
+       de->name_len = cpu_to_le16(1);
+       de->hash_code = 0;
+       de->ino = cpu_to_le32(inode->i_ino);
+       memcpy(dentry_blk->filename[0], ".", 1);
+       set_de_type(de, inode);
+
+       de = &dentry_blk->dentry[1];
+       de->hash_code = 0;
+       de->name_len = cpu_to_le16(2);
+       de->ino = cpu_to_le32(parent->i_ino);
+       memcpy(dentry_blk->filename[1], "..", 2);
+       set_de_type(de, inode);
+
+       test_and_set_bit_le(0, &dentry_blk->dentry_bitmap);
+       test_and_set_bit_le(1, &dentry_blk->dentry_bitmap);
+       kunmap_atomic(kaddr);
+
+       set_page_dirty(dentry_page);
+       f2fs_put_page(dentry_page, 1);
+       return 0;
+}
+
+bool f2fs_empty_dir(struct inode *dir)
+{
+       unsigned long bidx;
+       struct page *dentry_page;
+       unsigned int bit_pos;
+       struct  f2fs_dentry_block *dentry_blk;
+       unsigned long nblock = dir_blocks(dir);
+
+       for (bidx = 0; bidx < nblock; bidx++) {
+               void *kaddr;
+               dentry_page = get_lock_data_page(dir, bidx);
+               if (IS_ERR(dentry_page)) {
+                       if (PTR_ERR(dentry_page) == -ENOENT)
+                               continue;
+                       else
+                               return false;
+               }
+
+               kaddr = kmap_atomic(dentry_page);
+               dentry_blk = (struct f2fs_dentry_block *)kaddr;
+               if (bidx == 0)
+                       bit_pos = 2;
+               else
+                       bit_pos = 0;
+               bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
+                                               NR_DENTRY_IN_BLOCK,
+                                               bit_pos);
+               kunmap_atomic(kaddr);
+
+               f2fs_put_page(dentry_page, 1);
+
+               if (bit_pos < NR_DENTRY_IN_BLOCK)
+                       return false;
+       }
+       return true;
+}
+
+static int f2fs_readdir(struct file *file, void *dirent, filldir_t filldir)
+{
+       unsigned long pos = file->f_pos;
+       struct inode *inode = file->f_dentry->d_inode;
+       unsigned long npages = dir_blocks(inode);
+       unsigned char *types = NULL;
+       unsigned int bit_pos = 0, start_bit_pos = 0;
+       int over = 0;
+       struct f2fs_dentry_block *dentry_blk = NULL;
+       struct f2fs_dir_entry *de = NULL;
+       struct page *dentry_page = NULL;
+       unsigned int n = 0;
+       unsigned char d_type = DT_UNKNOWN;
+       int slots;
+
+       types = f2fs_filetype_table;
+       bit_pos = (pos % NR_DENTRY_IN_BLOCK);
+       n = (pos / NR_DENTRY_IN_BLOCK);
+
+       for ( ; n < npages; n++) {
+               dentry_page = get_lock_data_page(inode, n);
+               if (IS_ERR(dentry_page))
+                       continue;
+
+               start_bit_pos = bit_pos;
+               dentry_blk = kmap(dentry_page);
+               while (bit_pos < NR_DENTRY_IN_BLOCK) {
+                       d_type = DT_UNKNOWN;
+                       bit_pos = find_next_bit_le(&dentry_blk->dentry_bitmap,
+                                                       NR_DENTRY_IN_BLOCK,
+                                                       bit_pos);
+                       if (bit_pos >= NR_DENTRY_IN_BLOCK)
+                               break;
+
+                       de = &dentry_blk->dentry[bit_pos];
+                       if (types && de->file_type < F2FS_FT_MAX)
+                               d_type = types[de->file_type];
+
+                       over = filldir(dirent,
+                                       dentry_blk->filename[bit_pos],
+                                       le16_to_cpu(de->name_len),
+                                       (n * NR_DENTRY_IN_BLOCK) + bit_pos,
+                                       le32_to_cpu(de->ino), d_type);
+                       if (over) {
+                               file->f_pos += bit_pos - start_bit_pos;
+                               goto success;
+                       }
+                       slots = GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
+                       bit_pos += slots;
+               }
+               bit_pos = 0;
+               file->f_pos = (n + 1) * NR_DENTRY_IN_BLOCK;
+               kunmap(dentry_page);
+               f2fs_put_page(dentry_page, 1);
+               dentry_page = NULL;
+       }
+success:
+       if (dentry_page && !IS_ERR(dentry_page)) {
+               kunmap(dentry_page);
+               f2fs_put_page(dentry_page, 1);
+       }
+
+       return 0;
+}
+
+const struct file_operations f2fs_dir_operations = {
+       .llseek         = generic_file_llseek,
+       .read           = generic_read_dir,
+       .readdir        = f2fs_readdir,
+       .fsync          = f2fs_sync_file,
+       .unlocked_ioctl = f2fs_ioctl,
+};
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
new file mode 100644 (file)
index 0000000..a18d63d
--- /dev/null
@@ -0,0 +1,1083 @@
+/*
+ * fs/f2fs/f2fs.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.
+ */
+#ifndef _LINUX_F2FS_H
+#define _LINUX_F2FS_H
+
+#include <linux/types.h>
+#include <linux/page-flags.h>
+#include <linux/buffer_head.h>
+#include <linux/slab.h>
+#include <linux/crc32.h>
+#include <linux/magic.h>
+
+/*
+ * For mount options
+ */
+#define F2FS_MOUNT_BG_GC               0x00000001
+#define F2FS_MOUNT_DISABLE_ROLL_FORWARD        0x00000002
+#define F2FS_MOUNT_DISCARD             0x00000004
+#define F2FS_MOUNT_NOHEAP              0x00000008
+#define F2FS_MOUNT_XATTR_USER          0x00000010
+#define F2FS_MOUNT_POSIX_ACL           0x00000020
+#define F2FS_MOUNT_DISABLE_EXT_IDENTIFY        0x00000040
+
+#define clear_opt(sbi, option) (sbi->mount_opt.opt &= ~F2FS_MOUNT_##option)
+#define set_opt(sbi, option)   (sbi->mount_opt.opt |= F2FS_MOUNT_##option)
+#define test_opt(sbi, option)  (sbi->mount_opt.opt & F2FS_MOUNT_##option)
+
+#define ver_after(a, b)        (typecheck(unsigned long long, a) &&            \
+               typecheck(unsigned long long, b) &&                     \
+               ((long long)((a) - (b)) > 0))
+
+typedef u64 block_t;
+typedef u32 nid_t;
+
+struct f2fs_mount_info {
+       unsigned int    opt;
+};
+
+static inline __u32 f2fs_crc32(void *buff, size_t len)
+{
+       return crc32_le(F2FS_SUPER_MAGIC, buff, len);
+}
+
+static inline bool f2fs_crc_valid(__u32 blk_crc, void *buff, size_t buff_size)
+{
+       return f2fs_crc32(buff, buff_size) == blk_crc;
+}
+
+/*
+ * For checkpoint manager
+ */
+enum {
+       NAT_BITMAP,
+       SIT_BITMAP
+};
+
+/* for the list of orphan inodes */
+struct orphan_inode_entry {
+       struct list_head list;  /* list head */
+       nid_t ino;              /* inode number */
+};
+
+/* for the list of directory inodes */
+struct dir_inode_entry {
+       struct list_head list;  /* list head */
+       struct inode *inode;    /* vfs inode pointer */
+};
+
+/* for the list of fsync inodes, used only during recovery */
+struct fsync_inode_entry {
+       struct list_head list;  /* list head */
+       struct inode *inode;    /* vfs inode pointer */
+       block_t blkaddr;        /* block address locating the last inode */
+};
+
+#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)
+
+static inline int update_nats_in_cursum(struct f2fs_summary_block *rs, int i)
+{
+       int before = nats_in_cursum(rs);
+       rs->n_nats = cpu_to_le16(before + i);
+       return before;
+}
+
+static inline int update_sits_in_cursum(struct f2fs_summary_block *rs, int i)
+{
+       int before = sits_in_cursum(rs);
+       rs->n_sits = cpu_to_le16(before + i);
+       return before;
+}
+
+/*
+ * For INODE and NODE manager
+ */
+#define XATTR_NODE_OFFSET      (-1)    /*
+                                        * store xattrs to one node block per
+                                        * file keeping -1 as its node offset to
+                                        * distinguish from index node blocks.
+                                        */
+#define RDONLY_NODE            1       /*
+                                        * specify a read-only mode when getting
+                                        * a node block. 0 is read-write mode.
+                                        * used by get_dnode_of_data().
+                                        */
+#define F2FS_LINK_MAX          32000   /* maximum link count per file */
+
+/* for in-memory extent cache entry */
+struct extent_info {
+       rwlock_t ext_lock;      /* rwlock for consistency */
+       unsigned int fofs;      /* start offset in a file */
+       u32 blk_addr;           /* start block address of the extent */
+       unsigned int len;       /* lenth of the extent */
+};
+
+/*
+ * i_advise uses FADVISE_XXX_BIT. We can add additional hints later.
+ */
+#define FADVISE_COLD_BIT       0x01
+
+struct f2fs_inode_info {
+       struct inode vfs_inode;         /* serve a vfs inode */
+       unsigned long i_flags;          /* keep an inode flags for ioctl */
+       unsigned char i_advise;         /* use to give file attribute hints */
+       unsigned int i_current_depth;   /* use only in directory structure */
+       unsigned int i_pino;            /* parent inode number */
+       umode_t i_acl_mode;             /* keep file acl mode temporarily */
+
+       /* Use below internally in f2fs*/
+       unsigned long flags;            /* use to pass per-file flags */
+       unsigned long long data_version;/* lastes version of data for fsync */
+       atomic_t dirty_dents;           /* # of dirty dentry pages */
+       f2fs_hash_t chash;              /* hash value of given file name */
+       unsigned int clevel;            /* maximum level of given file name */
+       nid_t i_xattr_nid;              /* node id that contains xattrs */
+       struct extent_info ext;         /* in-memory extent cache entry */
+};
+
+static inline void get_extent_info(struct extent_info *ext,
+                                       struct f2fs_extent i_ext)
+{
+       write_lock(&ext->ext_lock);
+       ext->fofs = le32_to_cpu(i_ext.fofs);
+       ext->blk_addr = le32_to_cpu(i_ext.blk_addr);
+       ext->len = le32_to_cpu(i_ext.len);
+       write_unlock(&ext->ext_lock);
+}
+
+static inline void set_raw_extent(struct extent_info *ext,
+                                       struct f2fs_extent *i_ext)
+{
+       read_lock(&ext->ext_lock);
+       i_ext->fofs = cpu_to_le32(ext->fofs);
+       i_ext->blk_addr = cpu_to_le32(ext->blk_addr);
+       i_ext->len = cpu_to_le32(ext->len);
+       read_unlock(&ext->ext_lock);
+}
+
+struct f2fs_nm_info {
+       block_t nat_blkaddr;            /* base disk address of NAT */
+       nid_t max_nid;                  /* maximum possible node ids */
+       nid_t init_scan_nid;            /* the first nid to be scanned */
+       nid_t next_scan_nid;            /* the next nid to be scanned */
+
+       /* NAT cache management */
+       struct radix_tree_root nat_root;/* root of the nat entry cache */
+       rwlock_t nat_tree_lock;         /* protect nat_tree_lock */
+       unsigned int nat_cnt;           /* the # of cached nat entries */
+       struct list_head nat_entries;   /* cached nat entry list (clean) */
+       struct list_head dirty_nat_entries; /* cached nat entry list (dirty) */
+
+       /* free node ids management */
+       struct list_head free_nid_list; /* a list for free nids */
+       spinlock_t free_nid_list_lock;  /* protect free nid list */
+       unsigned int fcnt;              /* the number of free node id */
+       struct mutex build_lock;        /* lock for build free nids */
+
+       /* for checkpoint */
+       char *nat_bitmap;               /* NAT bitmap pointer */
+       int bitmap_size;                /* bitmap size */
+};
+
+/*
+ * this structure is used as one of function parameters.
+ * all the information are dedicated to a given direct node block determined
+ * by the data offset in a file.
+ */
+struct dnode_of_data {
+       struct inode *inode;            /* vfs inode pointer */
+       struct page *inode_page;        /* its inode page, NULL is possible */
+       struct page *node_page;         /* cached direct node page */
+       nid_t nid;                      /* node id of the direct node block */
+       unsigned int ofs_in_node;       /* data offset in the node page */
+       bool inode_page_locked;         /* inode page is locked or not */
+       block_t data_blkaddr;           /* block address of the node block */
+};
+
+static inline void set_new_dnode(struct dnode_of_data *dn, struct inode *inode,
+               struct page *ipage, struct page *npage, nid_t nid)
+{
+       dn->inode = inode;
+       dn->inode_page = ipage;
+       dn->node_page = npage;
+       dn->nid = nid;
+       dn->inode_page_locked = 0;
+}
+
+/*
+ * For SIT manager
+ *
+ * By default, there are 6 active log areas across the whole main area.
+ * When considering hot and cold data separation to reduce cleaning overhead,
+ * we split 3 for data logs and 3 for node logs as hot, warm, and cold types,
+ * respectively.
+ * In the current design, you should not change the numbers intentionally.
+ * Instead, as a mount option such as active_logs=x, you can use 2, 4, and 6
+ * logs individually according to the underlying devices. (default: 6)
+ * Just in case, on-disk layout covers maximum 16 logs that consist of 8 for
+ * data and 8 for node logs.
+ */
+#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
+};
+
+struct f2fs_sm_info {
+       struct sit_info *sit_info;              /* whole segment information */
+       struct free_segmap_info *free_info;     /* free segment information */
+       struct dirty_seglist_info *dirty_info;  /* dirty segment information */
+       struct curseg_info *curseg_array;       /* active segment information */
+
+       struct list_head wblist_head;   /* list of under-writeback pages */
+       spinlock_t wblist_lock;         /* lock for checkpoint */
+
+       block_t seg0_blkaddr;           /* block address of 0'th segment */
+       block_t main_blkaddr;           /* start block address of main area */
+       block_t ssa_blkaddr;            /* start block address of SSA area */
+
+       unsigned int segment_count;     /* total # of segments */
+       unsigned int main_segments;     /* # of segments in main area */
+       unsigned int reserved_segments; /* # of reserved segments */
+       unsigned int ovp_segments;      /* # of overprovision segments */
+};
+
+/*
+ * For directory operation
+ */
+#define        NODE_DIR1_BLOCK         (ADDRS_PER_INODE + 1)
+#define        NODE_DIR2_BLOCK         (ADDRS_PER_INODE + 2)
+#define        NODE_IND1_BLOCK         (ADDRS_PER_INODE + 3)
+#define        NODE_IND2_BLOCK         (ADDRS_PER_INODE + 4)
+#define        NODE_DIND_BLOCK         (ADDRS_PER_INODE + 5)
+
+/*
+ * For superblock
+ */
+/*
+ * COUNT_TYPE for monitoring
+ *
+ * f2fs monitors the number of several block types such as on-writeback,
+ * dirty dentry blocks, dirty node blocks, and dirty meta blocks.
+ */
+enum count_type {
+       F2FS_WRITEBACK,
+       F2FS_DIRTY_DENTS,
+       F2FS_DIRTY_NODES,
+       F2FS_DIRTY_META,
+       NR_COUNT_TYPE,
+};
+
+/*
+ * FS_LOCK nesting subclasses for the lock validator:
+ *
+ * The locking order between these classes is
+ * RENAME -> DENTRY_OPS -> DATA_WRITE -> DATA_NEW
+ *    -> DATA_TRUNC -> NODE_WRITE -> NODE_NEW -> NODE_TRUNC
+ */
+enum lock_type {
+       RENAME,         /* for renaming operations */
+       DENTRY_OPS,     /* for directory operations */
+       DATA_WRITE,     /* for data write */
+       DATA_NEW,       /* for data allocation */
+       DATA_TRUNC,     /* for data truncate */
+       NODE_NEW,       /* for node allocation */
+       NODE_TRUNC,     /* for node truncate */
+       NODE_WRITE,     /* for node write */
+       NR_LOCK_TYPE,
+};
+
+/*
+ * The below are the page types of bios used in submti_bio().
+ * The available types are:
+ * DATA                        User data pages. It operates as async mode.
+ * NODE                        Node pages. It operates as async mode.
+ * META                        FS metadata pages such as SIT, NAT, CP.
+ * NR_PAGE_TYPE                The number of page types.
+ * META_FLUSH          Make sure the previous pages are written
+ *                     with waiting the bio's completion
+ * ...                 Only can be used with META.
+ */
+enum page_type {
+       DATA,
+       NODE,
+       META,
+       NR_PAGE_TYPE,
+       META_FLUSH,
+};
+
+struct f2fs_sb_info {
+       struct super_block *sb;                 /* pointer to VFS super block */
+       struct buffer_head *raw_super_buf;      /* buffer head of raw sb */
+       struct f2fs_super_block *raw_super;     /* raw super block pointer */
+       int s_dirty;                            /* dirty flag for checkpoint */
+
+       /* for node-related operations */
+       struct f2fs_nm_info *nm_info;           /* node manager */
+       struct inode *node_inode;               /* cache node blocks */
+
+       /* for segment-related operations */
+       struct f2fs_sm_info *sm_info;           /* segment manager */
+       struct bio *bio[NR_PAGE_TYPE];          /* bios to merge */
+       sector_t last_block_in_bio[NR_PAGE_TYPE];       /* last block number */
+       struct rw_semaphore bio_sem;            /* IO semaphore */
+
+       /* for checkpoint */
+       struct f2fs_checkpoint *ckpt;           /* raw checkpoint pointer */
+       struct inode *meta_inode;               /* cache meta blocks */
+       struct mutex cp_mutex;                  /* for checkpoint procedure */
+       struct mutex fs_lock[NR_LOCK_TYPE];     /* for blocking FS operations */
+       struct mutex write_inode;               /* mutex for write inode */
+       struct mutex writepages;                /* mutex for writepages() */
+       int por_doing;                          /* recovery is doing or not */
+
+       /* for orphan inode management */
+       struct list_head orphan_inode_list;     /* orphan inode list */
+       struct mutex orphan_inode_mutex;        /* for orphan inode list */
+       unsigned int n_orphans;                 /* # of orphan inodes */
+
+       /* for directory inode management */
+       struct list_head dir_inode_list;        /* dir inode list */
+       spinlock_t dir_inode_lock;              /* for dir inode list lock */
+       unsigned int n_dirty_dirs;              /* # of dir inodes */
+
+       /* 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 */
+       atomic_t nr_pages[NR_COUNT_TYPE];       /* # of pages, see count_type */
+
+       struct f2fs_mount_info mount_opt;       /* mount options */
+
+       /* for cleaning operations */
+       struct mutex gc_mutex;                  /* mutex for GC */
+       struct f2fs_gc_kthread  *gc_thread;     /* GC thread */
+
+       /*
+        * for stat information.
+        * one is for the LFS mode, and the other is for the SSR mode.
+        */
+       struct f2fs_stat_info *stat_info;       /* FS status information */
+       unsigned int segment_count[2];          /* # of allocated segments */
+       unsigned int block_count[2];            /* # of allocated blocks */
+       unsigned int last_victim[2];            /* last victim segment # */
+       int total_hit_ext, read_hit_ext;        /* extent cache hit ratio */
+       int bg_gc;                              /* background gc calls */
+       spinlock_t stat_lock;                   /* lock for stat operations */
+};
+
+/*
+ * Inline functions
+ */
+static inline struct f2fs_inode_info *F2FS_I(struct inode *inode)
+{
+       return container_of(inode, struct f2fs_inode_info, vfs_inode);
+}
+
+static inline struct f2fs_sb_info *F2FS_SB(struct super_block *sb)
+{
+       return sb->s_fs_info;
+}
+
+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_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 struct free_segmap_info *FREE_I(struct f2fs_sb_info *sbi)
+{
+       return (struct free_segmap_info *)(SM_I(sbi)->free_info);
+}
+
+static inline struct dirty_seglist_info *DIRTY_I(struct f2fs_sb_info *sbi)
+{
+       return (struct dirty_seglist_info *)(SM_I(sbi)->dirty_info);
+}
+
+static inline void F2FS_SET_SB_DIRT(struct f2fs_sb_info *sbi)
+{
+       sbi->s_dirty = 1;
+}
+
+static inline void F2FS_RESET_SB_DIRT(struct f2fs_sb_info *sbi)
+{
+       sbi->s_dirty = 0;
+}
+
+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 void set_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
+{
+       unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
+       ckpt_flags |= f;
+       cp->ckpt_flags = cpu_to_le32(ckpt_flags);
+}
+
+static inline void clear_ckpt_flags(struct f2fs_checkpoint *cp, unsigned int f)
+{
+       unsigned int ckpt_flags = le32_to_cpu(cp->ckpt_flags);
+       ckpt_flags &= (~f);
+       cp->ckpt_flags = cpu_to_le32(ckpt_flags);
+}
+
+static inline void mutex_lock_op(struct f2fs_sb_info *sbi, enum lock_type t)
+{
+       mutex_lock_nested(&sbi->fs_lock[t], t);
+}
+
+static inline void mutex_unlock_op(struct f2fs_sb_info *sbi, enum lock_type t)
+{
+       mutex_unlock(&sbi->fs_lock[t]);
+}
+
+/*
+ * Check whether the given nid is within node id range.
+ */
+static inline void check_nid_range(struct f2fs_sb_info *sbi, nid_t nid)
+{
+       BUG_ON((nid >= NM_I(sbi)->max_nid));
+}
+
+#define F2FS_DEFAULT_ALLOCATED_BLOCKS  1
+
+/*
+ * Check whether the inode has blocks or not
+ */
+static inline int F2FS_HAS_BLOCKS(struct inode *inode)
+{
+       if (F2FS_I(inode)->i_xattr_nid)
+               return (inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS + 1);
+       else
+               return (inode->i_blocks > F2FS_DEFAULT_ALLOCATED_BLOCKS);
+}
+
+static inline bool inc_valid_block_count(struct f2fs_sb_info *sbi,
+                                struct inode *inode, blkcnt_t count)
+{
+       block_t valid_block_count;
+
+       spin_lock(&sbi->stat_lock);
+       valid_block_count =
+               sbi->total_valid_block_count + (block_t)count;
+       if (valid_block_count > sbi->user_block_count) {
+               spin_unlock(&sbi->stat_lock);
+               return false;
+       }
+       inode->i_blocks += count;
+       sbi->total_valid_block_count = valid_block_count;
+       sbi->alloc_valid_block_count += (block_t)count;
+       spin_unlock(&sbi->stat_lock);
+       return true;
+}
+
+static inline int dec_valid_block_count(struct f2fs_sb_info *sbi,
+                                               struct inode *inode,
+                                               blkcnt_t count)
+{
+       spin_lock(&sbi->stat_lock);
+       BUG_ON(sbi->total_valid_block_count < (block_t) count);
+       BUG_ON(inode->i_blocks < count);
+       inode->i_blocks -= count;
+       sbi->total_valid_block_count -= (block_t)count;
+       spin_unlock(&sbi->stat_lock);
+       return 0;
+}
+
+static inline void inc_page_count(struct f2fs_sb_info *sbi, int count_type)
+{
+       atomic_inc(&sbi->nr_pages[count_type]);
+       F2FS_SET_SB_DIRT(sbi);
+}
+
+static inline void inode_inc_dirty_dents(struct inode *inode)
+{
+       atomic_inc(&F2FS_I(inode)->dirty_dents);
+}
+
+static inline void dec_page_count(struct f2fs_sb_info *sbi, int count_type)
+{
+       atomic_dec(&sbi->nr_pages[count_type]);
+}
+
+static inline void inode_dec_dirty_dents(struct inode *inode)
+{
+       atomic_dec(&F2FS_I(inode)->dirty_dents);
+}
+
+static inline int get_pages(struct f2fs_sb_info *sbi, int count_type)
+{
+       return atomic_read(&sbi->nr_pages[count_type]);
+}
+
+static inline block_t valid_user_blocks(struct f2fs_sb_info *sbi)
+{
+       block_t ret;
+       spin_lock(&sbi->stat_lock);
+       ret = sbi->total_valid_block_count;
+       spin_unlock(&sbi->stat_lock);
+       return ret;
+}
+
+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 = (flag == NAT_BITMAP) ?
+                       le32_to_cpu(ckpt->sit_ver_bitmap_bytesize) : 0;
+       return &ckpt->sit_nat_version_bitmap + offset;
+}
+
+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 bool inc_valid_node_count(struct f2fs_sb_info *sbi,
+                                               struct inode *inode,
+                                               unsigned int count)
+{
+       block_t valid_block_count;
+       unsigned int valid_node_count;
+
+       spin_lock(&sbi->stat_lock);
+
+       valid_block_count = sbi->total_valid_block_count + (block_t)count;
+       sbi->alloc_valid_block_count += (block_t)count;
+       valid_node_count = sbi->total_valid_node_count + count;
+
+       if (valid_block_count > sbi->user_block_count) {
+               spin_unlock(&sbi->stat_lock);
+               return false;
+       }
+
+       if (valid_node_count > sbi->total_node_count) {
+               spin_unlock(&sbi->stat_lock);
+               return false;
+       }
+
+       if (inode)
+               inode->i_blocks += count;
+       sbi->total_valid_node_count = valid_node_count;
+       sbi->total_valid_block_count = valid_block_count;
+       spin_unlock(&sbi->stat_lock);
+
+       return true;
+}
+
+static inline void dec_valid_node_count(struct f2fs_sb_info *sbi,
+                                               struct inode *inode,
+                                               unsigned int count)
+{
+       spin_lock(&sbi->stat_lock);
+
+       BUG_ON(sbi->total_valid_block_count < count);
+       BUG_ON(sbi->total_valid_node_count < count);
+       BUG_ON(inode->i_blocks < count);
+
+       inode->i_blocks -= count;
+       sbi->total_valid_node_count -= count;
+       sbi->total_valid_block_count -= (block_t)count;
+
+       spin_unlock(&sbi->stat_lock);
+}
+
+static inline unsigned int valid_node_count(struct f2fs_sb_info *sbi)
+{
+       unsigned int ret;
+       spin_lock(&sbi->stat_lock);
+       ret = sbi->total_valid_node_count;
+       spin_unlock(&sbi->stat_lock);
+       return ret;
+}
+
+static inline void inc_valid_inode_count(struct f2fs_sb_info *sbi)
+{
+       spin_lock(&sbi->stat_lock);
+       BUG_ON(sbi->total_valid_inode_count == sbi->total_node_count);
+       sbi->total_valid_inode_count++;
+       spin_unlock(&sbi->stat_lock);
+}
+
+static inline int dec_valid_inode_count(struct f2fs_sb_info *sbi)
+{
+       spin_lock(&sbi->stat_lock);
+       BUG_ON(!sbi->total_valid_inode_count);
+       sbi->total_valid_inode_count--;
+       spin_unlock(&sbi->stat_lock);
+       return 0;
+}
+
+static inline unsigned int valid_inode_count(struct f2fs_sb_info *sbi)
+{
+       unsigned int ret;
+       spin_lock(&sbi->stat_lock);
+       ret = sbi->total_valid_inode_count;
+       spin_unlock(&sbi->stat_lock);
+       return ret;
+}
+
+static inline void f2fs_put_page(struct page *page, int unlock)
+{
+       if (!page || IS_ERR(page))
+               return;
+
+       if (unlock) {
+               BUG_ON(!PageLocked(page));
+               unlock_page(page);
+       }
+       page_cache_release(page);
+}
+
+static inline void f2fs_put_dnode(struct dnode_of_data *dn)
+{
+       if (dn->node_page)
+               f2fs_put_page(dn->node_page, 1);
+       if (dn->inode_page && dn->node_page != dn->inode_page)
+               f2fs_put_page(dn->inode_page, 0);
+       dn->node_page = NULL;
+       dn->inode_page = NULL;
+}
+
+static inline struct kmem_cache *f2fs_kmem_cache_create(const char *name,
+                                       size_t size, void (*ctor)(void *))
+{
+       return kmem_cache_create(name, size, 0, SLAB_RECLAIM_ACCOUNT, ctor);
+}
+
+#define RAW_IS_INODE(p)        ((p)->footer.nid == (p)->footer.ino)
+
+static inline bool IS_INODE(struct page *page)
+{
+       struct f2fs_node *p = (struct f2fs_node *)page_address(page);
+       return RAW_IS_INODE(p);
+}
+
+static inline __le32 *blkaddr_in_node(struct f2fs_node *node)
+{
+       return RAW_IS_INODE(node) ? node->i.i_addr : node->dn.addr;
+}
+
+static inline block_t datablock_addr(struct page *node_page,
+               unsigned int offset)
+{
+       struct f2fs_node *raw_node;
+       __le32 *addr_array;
+       raw_node = (struct f2fs_node *)page_address(node_page);
+       addr_array = blkaddr_in_node(raw_node);
+       return le32_to_cpu(addr_array[offset]);
+}
+
+static inline int f2fs_test_bit(unsigned int nr, char *addr)
+{
+       int mask;
+
+       addr += (nr >> 3);
+       mask = 1 << (7 - (nr & 0x07));
+       return mask & *addr;
+}
+
+static inline 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;
+}
+
+static inline 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;
+}
+
+/* used for f2fs_inode_info->flags */
+enum {
+       FI_NEW_INODE,           /* indicate newly allocated inode */
+       FI_NEED_CP,             /* need to do checkpoint during fsync */
+       FI_INC_LINK,            /* need to increment i_nlink */
+       FI_ACL_MODE,            /* indicate acl mode */
+       FI_NO_ALLOC,            /* should not allocate any blocks */
+};
+
+static inline void set_inode_flag(struct f2fs_inode_info *fi, int flag)
+{
+       set_bit(flag, &fi->flags);
+}
+
+static inline int is_inode_flag_set(struct f2fs_inode_info *fi, int flag)
+{
+       return test_bit(flag, &fi->flags);
+}
+
+static inline void clear_inode_flag(struct f2fs_inode_info *fi, int flag)
+{
+       clear_bit(flag, &fi->flags);
+}
+
+static inline void set_acl_inode(struct f2fs_inode_info *fi, umode_t mode)
+{
+       fi->i_acl_mode = mode;
+       set_inode_flag(fi, FI_ACL_MODE);
+}
+
+static inline int cond_clear_inode_flag(struct f2fs_inode_info *fi, int flag)
+{
+       if (is_inode_flag_set(fi, FI_ACL_MODE)) {
+               clear_inode_flag(fi, FI_ACL_MODE);
+               return 1;
+       }
+       return 0;
+}
+
+/*
+ * file.c
+ */
+int f2fs_sync_file(struct file *, loff_t, loff_t, int);
+void truncate_data_blocks(struct dnode_of_data *);
+void f2fs_truncate(struct inode *);
+int f2fs_setattr(struct dentry *, struct iattr *);
+int truncate_hole(struct inode *, pgoff_t, pgoff_t);
+long f2fs_ioctl(struct file *, unsigned int, unsigned long);
+
+/*
+ * inode.c
+ */
+void f2fs_set_inode_flags(struct inode *);
+struct inode *f2fs_iget_nowait(struct super_block *, unsigned long);
+struct inode *f2fs_iget(struct super_block *, unsigned long);
+void update_inode(struct inode *, struct page *);
+int f2fs_write_inode(struct inode *, struct writeback_control *);
+void f2fs_evict_inode(struct inode *);
+
+/*
+ * namei.c
+ */
+struct dentry *f2fs_get_parent(struct dentry *child);
+
+/*
+ * dir.c
+ */
+struct f2fs_dir_entry *f2fs_find_entry(struct inode *, struct qstr *,
+                                                       struct page **);
+struct f2fs_dir_entry *f2fs_parent_dir(struct inode *, struct page **);
+ino_t f2fs_inode_by_name(struct inode *, struct qstr *);
+void f2fs_set_link(struct inode *, struct f2fs_dir_entry *,
+                               struct page *, struct inode *);
+void init_dent_inode(struct dentry *, struct page *);
+int f2fs_add_link(struct dentry *, struct inode *);
+void f2fs_delete_entry(struct f2fs_dir_entry *, struct page *, struct inode *);
+int f2fs_make_empty(struct inode *, struct inode *);
+bool f2fs_empty_dir(struct inode *);
+
+/*
+ * super.c
+ */
+int f2fs_sync_fs(struct super_block *, int);
+
+/*
+ * hash.c
+ */
+f2fs_hash_t f2fs_dentry_hash(const char *, int);
+
+/*
+ * node.c
+ */
+struct dnode_of_data;
+struct node_info;
+
+int is_checkpointed_node(struct f2fs_sb_info *, nid_t);
+void get_node_info(struct f2fs_sb_info *, nid_t, struct node_info *);
+int get_dnode_of_data(struct dnode_of_data *, pgoff_t, int);
+int truncate_inode_blocks(struct inode *, pgoff_t);
+int remove_inode_page(struct inode *);
+int new_inode_page(struct inode *, struct dentry *);
+struct page *new_node_page(struct dnode_of_data *, unsigned int);
+void ra_node_page(struct f2fs_sb_info *, nid_t);
+struct page *get_node_page(struct f2fs_sb_info *, pgoff_t);
+struct page *get_node_page_ra(struct page *, int);
+void sync_inode_page(struct dnode_of_data *);
+int sync_node_pages(struct f2fs_sb_info *, nid_t, struct writeback_control *);
+bool alloc_nid(struct f2fs_sb_info *, nid_t *);
+void alloc_nid_done(struct f2fs_sb_info *, nid_t);
+void alloc_nid_failed(struct f2fs_sb_info *, nid_t);
+void recover_node_page(struct f2fs_sb_info *, struct page *,
+               struct f2fs_summary *, struct node_info *, block_t);
+int recover_inode_page(struct f2fs_sb_info *, struct page *);
+int restore_node_summary(struct f2fs_sb_info *, unsigned int,
+                               struct f2fs_summary_block *);
+void flush_nat_entries(struct f2fs_sb_info *);
+int build_node_manager(struct f2fs_sb_info *);
+void destroy_node_manager(struct f2fs_sb_info *);
+int create_node_manager_caches(void);
+void destroy_node_manager_caches(void);
+
+/*
+ * segment.c
+ */
+void f2fs_balance_fs(struct f2fs_sb_info *);
+void invalidate_blocks(struct f2fs_sb_info *, block_t);
+void locate_dirty_segment(struct f2fs_sb_info *, unsigned int);
+void clear_prefree_segments(struct f2fs_sb_info *);
+int npages_for_summary_flush(struct f2fs_sb_info *);
+void allocate_new_segments(struct f2fs_sb_info *);
+struct page *get_sum_page(struct f2fs_sb_info *, unsigned int);
+struct bio *f2fs_bio_alloc(struct block_device *, int);
+void f2fs_submit_bio(struct f2fs_sb_info *, enum page_type, bool sync);
+int write_meta_page(struct f2fs_sb_info *, struct page *,
+                                       struct writeback_control *);
+void write_node_page(struct f2fs_sb_info *, struct page *, unsigned int,
+                                       block_t, block_t *);
+void write_data_page(struct inode *, struct page *, struct dnode_of_data*,
+                                       block_t, block_t *);
+void rewrite_data_page(struct f2fs_sb_info *, struct page *, block_t);
+void recover_data_page(struct f2fs_sb_info *, struct page *,
+                               struct f2fs_summary *, block_t, block_t);
+void rewrite_node_page(struct f2fs_sb_info *, struct page *,
+                               struct f2fs_summary *, block_t, block_t);
+void write_data_summaries(struct f2fs_sb_info *, block_t);
+void write_node_summaries(struct f2fs_sb_info *, block_t);
+int lookup_journal_in_cursum(struct f2fs_summary_block *,
+                                       int, unsigned int, int);
+void flush_sit_entries(struct f2fs_sb_info *);
+int build_segment_manager(struct f2fs_sb_info *);
+void reset_victim_segmap(struct f2fs_sb_info *);
+void destroy_segment_manager(struct f2fs_sb_info *);
+
+/*
+ * checkpoint.c
+ */
+struct page *grab_meta_page(struct f2fs_sb_info *, pgoff_t);
+struct page *get_meta_page(struct f2fs_sb_info *, pgoff_t);
+long sync_meta_pages(struct f2fs_sb_info *, enum page_type, long);
+int check_orphan_space(struct f2fs_sb_info *);
+void add_orphan_inode(struct f2fs_sb_info *, nid_t);
+void remove_orphan_inode(struct f2fs_sb_info *, nid_t);
+int recover_orphan_inodes(struct f2fs_sb_info *);
+int get_valid_checkpoint(struct f2fs_sb_info *);
+void set_dirty_dir_page(struct inode *, struct page *);
+void remove_dirty_dir_inode(struct inode *);
+void sync_dirty_dir_inodes(struct f2fs_sb_info *);
+void block_operations(struct f2fs_sb_info *);
+void write_checkpoint(struct f2fs_sb_info *, bool, bool);
+void init_orphan_info(struct f2fs_sb_info *);
+int create_checkpoint_caches(void);
+void destroy_checkpoint_caches(void);
+
+/*
+ * data.c
+ */
+int reserve_new_block(struct dnode_of_data *);
+void update_extent_cache(block_t, struct dnode_of_data *);
+struct page *find_data_page(struct inode *, pgoff_t);
+struct page *get_lock_data_page(struct inode *, pgoff_t);
+struct page *get_new_data_page(struct inode *, pgoff_t, bool);
+int f2fs_readpage(struct f2fs_sb_info *, struct page *, block_t, int);
+int do_write_data_page(struct page *);
+
+/*
+ * gc.c
+ */
+int start_gc_thread(struct f2fs_sb_info *);
+void stop_gc_thread(struct f2fs_sb_info *);
+block_t start_bidx_of_node(unsigned int);
+int f2fs_gc(struct f2fs_sb_info *, int);
+void build_gc_manager(struct f2fs_sb_info *);
+int create_gc_caches(void);
+void destroy_gc_caches(void);
+
+/*
+ * recovery.c
+ */
+void recover_fsync_data(struct f2fs_sb_info *);
+bool space_for_roll_forward(struct f2fs_sb_info *);
+
+/*
+ * debug.c
+ */
+#ifdef CONFIG_F2FS_STAT_FS
+struct f2fs_stat_info {
+       struct list_head stat_list;
+       struct f2fs_sb_info *sbi;
+       struct mutex stat_lock;
+       int all_area_segs, sit_area_segs, nat_area_segs, ssa_area_segs;
+       int main_area_segs, main_area_sections, main_area_zones;
+       int hit_ext, total_ext;
+       int ndirty_node, ndirty_dent, ndirty_dirs, ndirty_meta;
+       int nats, sits, fnids;
+       int total_count, utilization;
+       int bg_gc;
+       unsigned int valid_count, valid_node_count, valid_inode_count;
+       unsigned int bimodal, avg_vblocks;
+       int util_free, util_valid, util_invalid;
+       int rsvd_segs, overp_segs;
+       int dirty_count, node_pages, meta_pages;
+       int prefree_count, call_count;
+       int tot_segs, node_segs, data_segs, free_segs, free_secs;
+       int tot_blks, data_blks, node_blks;
+       int curseg[NR_CURSEG_TYPE];
+       int cursec[NR_CURSEG_TYPE];
+       int curzone[NR_CURSEG_TYPE];
+
+       unsigned int segment_count[2];
+       unsigned int block_count[2];
+       unsigned base_mem, cache_mem;
+};
+
+#define stat_inc_call_count(si)        ((si)->call_count++)
+
+#define stat_inc_seg_count(sbi, type)                                  \
+       do {                                                            \
+               struct f2fs_stat_info *si = sbi->stat_info;             \
+               (si)->tot_segs++;                                       \
+               if (type == SUM_TYPE_DATA)                              \
+                       si->data_segs++;                                \
+               else                                                    \
+                       si->node_segs++;                                \
+       } while (0)
+
+#define stat_inc_tot_blk_count(si, blks)                               \
+       (si->tot_blks += (blks))
+
+#define stat_inc_data_blk_count(sbi, blks)                             \
+       do {                                                            \
+               struct f2fs_stat_info *si = sbi->stat_info;             \
+               stat_inc_tot_blk_count(si, blks);                       \
+               si->data_blks += (blks);                                \
+       } while (0)
+
+#define stat_inc_node_blk_count(sbi, blks)                             \
+       do {                                                            \
+               struct f2fs_stat_info *si = sbi->stat_info;             \
+               stat_inc_tot_blk_count(si, blks);                       \
+               si->node_blks += (blks);                                \
+       } while (0)
+
+int f2fs_build_stats(struct f2fs_sb_info *);
+void f2fs_destroy_stats(struct f2fs_sb_info *);
+void destroy_root_stats(void);
+#else
+#define stat_inc_call_count(si)
+#define stat_inc_seg_count(si, type)
+#define stat_inc_tot_blk_count(si, blks)
+#define stat_inc_data_blk_count(si, blks)
+#define stat_inc_node_blk_count(sbi, blks)
+
+static inline int f2fs_build_stats(struct f2fs_sb_info *sbi) { return 0; }
+static inline void f2fs_destroy_stats(struct f2fs_sb_info *sbi) { }
+static inline void destroy_root_stats(void) { }
+#endif
+
+extern const struct file_operations f2fs_dir_operations;
+extern const struct file_operations f2fs_file_operations;
+extern const struct inode_operations f2fs_file_inode_operations;
+extern const struct address_space_operations f2fs_dblock_aops;
+extern const struct address_space_operations f2fs_node_aops;
+extern const struct address_space_operations f2fs_meta_aops;
+extern const struct inode_operations f2fs_dir_inode_operations;
+extern const struct inode_operations f2fs_symlink_inode_operations;
+extern const struct inode_operations f2fs_special_inode_operations;
+#endif
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
new file mode 100644 (file)
index 0000000..f9e085d
--- /dev/null
@@ -0,0 +1,636 @@
+/*
+ * fs/f2fs/file.c
+ *
+ * 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.
+ */
+#include <linux/fs.h>
+#include <linux/f2fs_fs.h>
+#include <linux/stat.h>
+#include <linux/buffer_head.h>
+#include <linux/writeback.h>
+#include <linux/falloc.h>
+#include <linux/types.h>
+#include <linux/uaccess.h>
+#include <linux/mount.h>
+
+#include "f2fs.h"
+#include "node.h"
+#include "segment.h"
+#include "xattr.h"
+#include "acl.h"
+
+static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
+                                               struct vm_fault *vmf)
+{
+       struct page *page = vmf->page;
+       struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       block_t old_blk_addr;
+       struct dnode_of_data dn;
+       int err;
+
+       f2fs_balance_fs(sbi);
+
+       sb_start_pagefault(inode->i_sb);
+
+       mutex_lock_op(sbi, DATA_NEW);
+
+       /* block allocation */
+       set_new_dnode(&dn, inode, NULL, NULL, 0);
+       err = get_dnode_of_data(&dn, page->index, 0);
+       if (err) {
+               mutex_unlock_op(sbi, DATA_NEW);
+               goto out;
+       }
+
+       old_blk_addr = dn.data_blkaddr;
+
+       if (old_blk_addr == NULL_ADDR) {
+               err = reserve_new_block(&dn);
+               if (err) {
+                       f2fs_put_dnode(&dn);
+                       mutex_unlock_op(sbi, DATA_NEW);
+                       goto out;
+               }
+       }
+       f2fs_put_dnode(&dn);
+
+       mutex_unlock_op(sbi, DATA_NEW);
+
+       lock_page(page);
+       if (page->mapping != inode->i_mapping ||
+                       page_offset(page) >= i_size_read(inode) ||
+                       !PageUptodate(page)) {
+               unlock_page(page);
+               err = -EFAULT;
+               goto out;
+       }
+
+       /*
+        * check to see if the page is mapped already (no holes)
+        */
+       if (PageMappedToDisk(page))
+               goto out;
+
+       /* fill the page */
+       wait_on_page_writeback(page);
+
+       /* page is wholly or partially inside EOF */
+       if (((page->index + 1) << PAGE_CACHE_SHIFT) > i_size_read(inode)) {
+               unsigned offset;
+               offset = i_size_read(inode) & ~PAGE_CACHE_MASK;
+               zero_user_segment(page, offset, PAGE_CACHE_SIZE);
+       }
+       set_page_dirty(page);
+       SetPageUptodate(page);
+
+       file_update_time(vma->vm_file);
+out:
+       sb_end_pagefault(inode->i_sb);
+       return block_page_mkwrite_return(err);
+}
+
+static const struct vm_operations_struct f2fs_file_vm_ops = {
+       .fault        = filemap_fault,
+       .page_mkwrite = f2fs_vm_page_mkwrite,
+};
+
+static int need_to_sync_dir(struct f2fs_sb_info *sbi, struct inode *inode)
+{
+       struct dentry *dentry;
+       nid_t pino;
+
+       inode = igrab(inode);
+       dentry = d_find_any_alias(inode);
+       if (!dentry) {
+               iput(inode);
+               return 0;
+       }
+       pino = dentry->d_parent->d_inode->i_ino;
+       dput(dentry);
+       iput(inode);
+       return !is_checkpointed_node(sbi, pino);
+}
+
+int f2fs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
+{
+       struct inode *inode = file->f_mapping->host;
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       unsigned long long cur_version;
+       int ret = 0;
+       bool need_cp = false;
+       struct writeback_control wbc = {
+               .sync_mode = WB_SYNC_ALL,
+               .nr_to_write = LONG_MAX,
+               .for_reclaim = 0,
+       };
+
+       if (inode->i_sb->s_flags & MS_RDONLY)
+               return 0;
+
+       ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
+       if (ret)
+               return ret;
+
+       mutex_lock(&inode->i_mutex);
+
+       if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))
+               goto out;
+
+       mutex_lock(&sbi->cp_mutex);
+       cur_version = le64_to_cpu(F2FS_CKPT(sbi)->checkpoint_ver);
+       mutex_unlock(&sbi->cp_mutex);
+
+       if (F2FS_I(inode)->data_version != cur_version &&
+                                       !(inode->i_state & I_DIRTY))
+               goto out;
+       F2FS_I(inode)->data_version--;
+
+       if (!S_ISREG(inode->i_mode) || inode->i_nlink != 1)
+               need_cp = true;
+       if (is_inode_flag_set(F2FS_I(inode), FI_NEED_CP))
+               need_cp = true;
+       if (!space_for_roll_forward(sbi))
+               need_cp = true;
+       if (need_to_sync_dir(sbi, inode))
+               need_cp = true;
+
+       f2fs_write_inode(inode, NULL);
+
+       if (need_cp) {
+               /* all the dirty node pages should be flushed for POR */
+               ret = f2fs_sync_fs(inode->i_sb, 1);
+               clear_inode_flag(F2FS_I(inode), FI_NEED_CP);
+       } else {
+               while (sync_node_pages(sbi, inode->i_ino, &wbc) == 0)
+                       f2fs_write_inode(inode, NULL);
+               filemap_fdatawait_range(sbi->node_inode->i_mapping,
+                                                       0, LONG_MAX);
+       }
+out:
+       mutex_unlock(&inode->i_mutex);
+       return ret;
+}
+
+static int f2fs_file_mmap(struct file *file, struct vm_area_struct *vma)
+{
+       file_accessed(file);
+       vma->vm_ops = &f2fs_file_vm_ops;
+       return 0;
+}
+
+static int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
+{
+       int nr_free = 0, ofs = dn->ofs_in_node;
+       struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);
+       struct f2fs_node *raw_node;
+       __le32 *addr;
+
+       raw_node = page_address(dn->node_page);
+       addr = blkaddr_in_node(raw_node) + ofs;
+
+       for ( ; count > 0; count--, addr++, dn->ofs_in_node++) {
+               block_t blkaddr = le32_to_cpu(*addr);
+               if (blkaddr == NULL_ADDR)
+                       continue;
+
+               update_extent_cache(NULL_ADDR, dn);
+               invalidate_blocks(sbi, blkaddr);
+               dec_valid_block_count(sbi, dn->inode, 1);
+               nr_free++;
+       }
+       if (nr_free) {
+               set_page_dirty(dn->node_page);
+               sync_inode_page(dn);
+       }
+       dn->ofs_in_node = ofs;
+       return nr_free;
+}
+
+void truncate_data_blocks(struct dnode_of_data *dn)
+{
+       truncate_data_blocks_range(dn, ADDRS_PER_BLOCK);
+}
+
+static void truncate_partial_data_page(struct inode *inode, u64 from)
+{
+       unsigned offset = from & (PAGE_CACHE_SIZE - 1);
+       struct page *page;
+
+       if (!offset)
+               return;
+
+       page = find_data_page(inode, from >> PAGE_CACHE_SHIFT);
+       if (IS_ERR(page))
+               return;
+
+       lock_page(page);
+       wait_on_page_writeback(page);
+       zero_user(page, offset, PAGE_CACHE_SIZE - offset);
+       set_page_dirty(page);
+       f2fs_put_page(page, 1);
+}
+
+static int truncate_blocks(struct inode *inode, u64 from)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       unsigned int blocksize = inode->i_sb->s_blocksize;
+       struct dnode_of_data dn;
+       pgoff_t free_from;
+       int count = 0;
+       int err;
+
+       free_from = (pgoff_t)
+                       ((from + blocksize - 1) >> (sbi->log_blocksize));
+
+       mutex_lock_op(sbi, DATA_TRUNC);
+
+       set_new_dnode(&dn, inode, NULL, NULL, 0);
+       err = get_dnode_of_data(&dn, free_from, RDONLY_NODE);
+       if (err) {
+               if (err == -ENOENT)
+                       goto free_next;
+               mutex_unlock_op(sbi, DATA_TRUNC);
+               return err;
+       }
+
+       if (IS_INODE(dn.node_page))
+               count = ADDRS_PER_INODE;
+       else
+               count = ADDRS_PER_BLOCK;
+
+       count -= dn.ofs_in_node;
+       BUG_ON(count < 0);
+       if (dn.ofs_in_node || IS_INODE(dn.node_page)) {
+               truncate_data_blocks_range(&dn, count);
+               free_from += count;
+       }
+
+       f2fs_put_dnode(&dn);
+free_next:
+       err = truncate_inode_blocks(inode, free_from);
+       mutex_unlock_op(sbi, DATA_TRUNC);
+
+       /* lastly zero out the first data page */
+       truncate_partial_data_page(inode, from);
+
+       return err;
+}
+
+void f2fs_truncate(struct inode *inode)
+{
+       if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
+                               S_ISLNK(inode->i_mode)))
+               return;
+
+       if (!truncate_blocks(inode, i_size_read(inode))) {
+               inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+               mark_inode_dirty(inode);
+       }
+
+       f2fs_balance_fs(F2FS_SB(inode->i_sb));
+}
+
+static int f2fs_getattr(struct vfsmount *mnt,
+                        struct dentry *dentry, struct kstat *stat)
+{
+       struct inode *inode = dentry->d_inode;
+       generic_fillattr(inode, stat);
+       stat->blocks <<= 3;
+       return 0;
+}
+
+#ifdef CONFIG_F2FS_FS_POSIX_ACL
+static void __setattr_copy(struct inode *inode, const struct iattr *attr)
+{
+       struct f2fs_inode_info *fi = F2FS_I(inode);
+       unsigned int ia_valid = attr->ia_valid;
+
+       if (ia_valid & ATTR_UID)
+               inode->i_uid = attr->ia_uid;
+       if (ia_valid & ATTR_GID)
+               inode->i_gid = attr->ia_gid;
+       if (ia_valid & ATTR_ATIME)
+               inode->i_atime = timespec_trunc(attr->ia_atime,
+                                               inode->i_sb->s_time_gran);
+       if (ia_valid & ATTR_MTIME)
+               inode->i_mtime = timespec_trunc(attr->ia_mtime,
+                                               inode->i_sb->s_time_gran);
+       if (ia_valid & ATTR_CTIME)
+               inode->i_ctime = timespec_trunc(attr->ia_ctime,
+                                               inode->i_sb->s_time_gran);
+       if (ia_valid & ATTR_MODE) {
+               umode_t mode = attr->ia_mode;
+
+               if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
+                       mode &= ~S_ISGID;
+               set_acl_inode(fi, mode);
+       }
+}
+#else
+#define __setattr_copy setattr_copy
+#endif
+
+int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
+{
+       struct inode *inode = dentry->d_inode;
+       struct f2fs_inode_info *fi = F2FS_I(inode);
+       int err;
+
+       err = inode_change_ok(inode, attr);
+       if (err)
+               return err;
+
+       if ((attr->ia_valid & ATTR_SIZE) &&
+                       attr->ia_size != i_size_read(inode)) {
+               truncate_setsize(inode, attr->ia_size);
+               f2fs_truncate(inode);
+       }
+
+       __setattr_copy(inode, attr);
+
+       if (attr->ia_valid & ATTR_MODE) {
+               err = f2fs_acl_chmod(inode);
+               if (err || is_inode_flag_set(fi, FI_ACL_MODE)) {
+                       inode->i_mode = fi->i_acl_mode;
+                       clear_inode_flag(fi, FI_ACL_MODE);
+               }
+       }
+
+       mark_inode_dirty(inode);
+       return err;
+}
+
+const struct inode_operations f2fs_file_inode_operations = {
+       .getattr        = f2fs_getattr,
+       .setattr        = f2fs_setattr,
+       .get_acl        = f2fs_get_acl,
+#ifdef CONFIG_F2FS_FS_XATTR
+       .setxattr       = generic_setxattr,
+       .getxattr       = generic_getxattr,
+       .listxattr      = f2fs_listxattr,
+       .removexattr    = generic_removexattr,
+#endif
+};
+
+static void fill_zero(struct inode *inode, pgoff_t index,
+                                       loff_t start, loff_t len)
+{
+       struct page *page;
+
+       if (!len)
+               return;
+
+       page = get_new_data_page(inode, index, false);
+
+       if (!IS_ERR(page)) {
+               wait_on_page_writeback(page);
+               zero_user(page, start, len);
+               set_page_dirty(page);
+               f2fs_put_page(page, 1);
+       }
+}
+
+int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end)
+{
+       pgoff_t index;
+       int err;
+
+       for (index = pg_start; index < pg_end; index++) {
+               struct dnode_of_data dn;
+               struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+
+               mutex_lock_op(sbi, DATA_TRUNC);
+               set_new_dnode(&dn, inode, NULL, NULL, 0);
+               err = get_dnode_of_data(&dn, index, RDONLY_NODE);
+               if (err) {
+                       mutex_unlock_op(sbi, DATA_TRUNC);
+                       if (err == -ENOENT)
+                               continue;
+                       return err;
+               }
+
+               if (dn.data_blkaddr != NULL_ADDR)
+                       truncate_data_blocks_range(&dn, 1);
+               f2fs_put_dnode(&dn);
+               mutex_unlock_op(sbi, DATA_TRUNC);
+       }
+       return 0;
+}
+
+static int punch_hole(struct inode *inode, loff_t offset, loff_t len, int mode)
+{
+       pgoff_t pg_start, pg_end;
+       loff_t off_start, off_end;
+       int ret = 0;
+
+       pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
+       pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
+
+       off_start = offset & (PAGE_CACHE_SIZE - 1);
+       off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);
+
+       if (pg_start == pg_end) {
+               fill_zero(inode, pg_start, off_start,
+                                               off_end - off_start);
+       } else {
+               if (off_start)
+                       fill_zero(inode, pg_start++, off_start,
+                                       PAGE_CACHE_SIZE - off_start);
+               if (off_end)
+                       fill_zero(inode, pg_end, 0, off_end);
+
+               if (pg_start < pg_end) {
+                       struct address_space *mapping = inode->i_mapping;
+                       loff_t blk_start, blk_end;
+
+                       blk_start = pg_start << PAGE_CACHE_SHIFT;
+                       blk_end = pg_end << PAGE_CACHE_SHIFT;
+                       truncate_inode_pages_range(mapping, blk_start,
+                                       blk_end - 1);
+                       ret = truncate_hole(inode, pg_start, pg_end);
+               }
+       }
+
+       if (!(mode & FALLOC_FL_KEEP_SIZE) &&
+               i_size_read(inode) <= (offset + len)) {
+               i_size_write(inode, offset);
+               mark_inode_dirty(inode);
+       }
+
+       return ret;
+}
+
+static int expand_inode_data(struct inode *inode, loff_t offset,
+                                       loff_t len, int mode)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       pgoff_t index, pg_start, pg_end;
+       loff_t new_size = i_size_read(inode);
+       loff_t off_start, off_end;
+       int ret = 0;
+
+       ret = inode_newsize_ok(inode, (len + offset));
+       if (ret)
+               return ret;
+
+       pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
+       pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
+
+       off_start = offset & (PAGE_CACHE_SIZE - 1);
+       off_end = (offset + len) & (PAGE_CACHE_SIZE - 1);
+
+       for (index = pg_start; index <= pg_end; index++) {
+               struct dnode_of_data dn;
+
+               mutex_lock_op(sbi, DATA_NEW);
+
+               set_new_dnode(&dn, inode, NULL, NULL, 0);
+               ret = get_dnode_of_data(&dn, index, 0);
+               if (ret) {
+                       mutex_unlock_op(sbi, DATA_NEW);
+                       break;
+               }
+
+               if (dn.data_blkaddr == NULL_ADDR) {
+                       ret = reserve_new_block(&dn);
+                       if (ret) {
+                               f2fs_put_dnode(&dn);
+                               mutex_unlock_op(sbi, DATA_NEW);
+                               break;
+                       }
+               }
+               f2fs_put_dnode(&dn);
+
+               mutex_unlock_op(sbi, DATA_NEW);
+
+               if (pg_start == pg_end)
+                       new_size = offset + len;
+               else if (index == pg_start && off_start)
+                       new_size = (index + 1) << PAGE_CACHE_SHIFT;
+               else if (index == pg_end)
+                       new_size = (index << PAGE_CACHE_SHIFT) + off_end;
+               else
+                       new_size += PAGE_CACHE_SIZE;
+       }
+
+       if (!(mode & FALLOC_FL_KEEP_SIZE) &&
+               i_size_read(inode) < new_size) {
+               i_size_write(inode, new_size);
+               mark_inode_dirty(inode);
+       }
+
+       return ret;
+}
+
+static long f2fs_fallocate(struct file *file, int mode,
+                               loff_t offset, loff_t len)
+{
+       struct inode *inode = file->f_path.dentry->d_inode;
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       long ret;
+
+       if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
+               return -EOPNOTSUPP;
+
+       if (mode & FALLOC_FL_PUNCH_HOLE)
+               ret = punch_hole(inode, offset, len, mode);
+       else
+               ret = expand_inode_data(inode, offset, len, mode);
+
+       f2fs_balance_fs(sbi);
+       return ret;
+}
+
+#define F2FS_REG_FLMASK                (~(FS_DIRSYNC_FL | FS_TOPDIR_FL))
+#define F2FS_OTHER_FLMASK      (FS_NODUMP_FL | FS_NOATIME_FL)
+
+static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags)
+{
+       if (S_ISDIR(mode))
+               return flags;
+       else if (S_ISREG(mode))
+               return flags & F2FS_REG_FLMASK;
+       else
+               return flags & F2FS_OTHER_FLMASK;
+}
+
+long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+       struct inode *inode = filp->f_dentry->d_inode;
+       struct f2fs_inode_info *fi = F2FS_I(inode);
+       unsigned int flags;
+       int ret;
+
+       switch (cmd) {
+       case FS_IOC_GETFLAGS:
+               flags = fi->i_flags & FS_FL_USER_VISIBLE;
+               return put_user(flags, (int __user *) arg);
+       case FS_IOC_SETFLAGS:
+       {
+               unsigned int oldflags;
+
+               ret = mnt_want_write(filp->f_path.mnt);
+               if (ret)
+                       return ret;
+
+               if (!inode_owner_or_capable(inode)) {
+                       ret = -EACCES;
+                       goto out;
+               }
+
+               if (get_user(flags, (int __user *) arg)) {
+                       ret = -EFAULT;
+                       goto out;
+               }
+
+               flags = f2fs_mask_flags(inode->i_mode, flags);
+
+               mutex_lock(&inode->i_mutex);
+
+               oldflags = fi->i_flags;
+
+               if ((flags ^ oldflags) & (FS_APPEND_FL | FS_IMMUTABLE_FL)) {
+                       if (!capable(CAP_LINUX_IMMUTABLE)) {
+                               mutex_unlock(&inode->i_mutex);
+                               ret = -EPERM;
+                               goto out;
+                       }
+               }
+
+               flags = flags & FS_FL_USER_MODIFIABLE;
+               flags |= oldflags & ~FS_FL_USER_MODIFIABLE;
+               fi->i_flags = flags;
+               mutex_unlock(&inode->i_mutex);
+
+               f2fs_set_inode_flags(inode);
+               inode->i_ctime = CURRENT_TIME;
+               mark_inode_dirty(inode);
+out:
+               mnt_drop_write(filp->f_path.mnt);
+               return ret;
+       }
+       default:
+               return -ENOTTY;
+       }
+}
+
+const struct file_operations f2fs_file_operations = {
+       .llseek         = generic_file_llseek,
+       .read           = do_sync_read,
+       .write          = do_sync_write,
+       .aio_read       = generic_file_aio_read,
+       .aio_write      = generic_file_aio_write,
+       .open           = generic_file_open,
+       .mmap           = f2fs_file_mmap,
+       .fsync          = f2fs_sync_file,
+       .fallocate      = f2fs_fallocate,
+       .unlocked_ioctl = f2fs_ioctl,
+       .splice_read    = generic_file_splice_read,
+       .splice_write   = generic_file_splice_write,
+};
diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
new file mode 100644 (file)
index 0000000..644aa38
--- /dev/null
@@ -0,0 +1,742 @@
+/*
+ * fs/f2fs/gc.c
+ *
+ * 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.
+ */
+#include <linux/fs.h>
+#include <linux/module.h>
+#include <linux/backing-dev.h>
+#include <linux/proc_fs.h>
+#include <linux/init.h>
+#include <linux/f2fs_fs.h>
+#include <linux/kthread.h>
+#include <linux/delay.h>
+#include <linux/freezer.h>
+#include <linux/blkdev.h>
+
+#include "f2fs.h"
+#include "node.h"
+#include "segment.h"
+#include "gc.h"
+
+static struct kmem_cache *winode_slab;
+
+static int gc_thread_func(void *data)
+{
+       struct f2fs_sb_info *sbi = data;
+       wait_queue_head_t *wq = &sbi->gc_thread->gc_wait_queue_head;
+       long wait_ms;
+
+       wait_ms = GC_THREAD_MIN_SLEEP_TIME;
+
+       do {
+               if (try_to_freeze())
+                       continue;
+               else
+                       wait_event_interruptible_timeout(*wq,
+                                               kthread_should_stop(),
+                                               msecs_to_jiffies(wait_ms));
+               if (kthread_should_stop())
+                       break;
+
+               f2fs_balance_fs(sbi);
+
+               if (!test_opt(sbi, BG_GC))
+                       continue;
+
+               /*
+                * [GC triggering condition]
+                * 0. GC is not conducted currently.
+                * 1. There are enough dirty segments.
+                * 2. IO subsystem is idle by checking the # of writeback pages.
+                * 3. IO subsystem is idle by checking the # of requests in
+                *    bdev's request list.
+                *
+                * Note) We have to avoid triggering GCs too much frequently.
+                * Because it is possible that some segments can be
+                * invalidated soon after by user update or deletion.
+                * So, I'd like to wait some time to collect dirty segments.
+                */
+               if (!mutex_trylock(&sbi->gc_mutex))
+                       continue;
+
+               if (!is_idle(sbi)) {
+                       wait_ms = increase_sleep_time(wait_ms);
+                       mutex_unlock(&sbi->gc_mutex);
+                       continue;
+               }
+
+               if (has_enough_invalid_blocks(sbi))
+                       wait_ms = decrease_sleep_time(wait_ms);
+               else
+                       wait_ms = increase_sleep_time(wait_ms);
+
+               sbi->bg_gc++;
+
+               if (f2fs_gc(sbi, 1) == GC_NONE)
+                       wait_ms = GC_THREAD_NOGC_SLEEP_TIME;
+               else if (wait_ms == GC_THREAD_NOGC_SLEEP_TIME)
+                       wait_ms = GC_THREAD_MAX_SLEEP_TIME;
+
+       } while (!kthread_should_stop());
+       return 0;
+}
+
+int start_gc_thread(struct f2fs_sb_info *sbi)
+{
+       struct f2fs_gc_kthread *gc_th;
+
+       gc_th = kmalloc(sizeof(struct f2fs_gc_kthread), GFP_KERNEL);
+       if (!gc_th)
+               return -ENOMEM;
+
+       sbi->gc_thread = gc_th;
+       init_waitqueue_head(&sbi->gc_thread->gc_wait_queue_head);
+       sbi->gc_thread->f2fs_gc_task = kthread_run(gc_thread_func, sbi,
+                               GC_THREAD_NAME);
+       if (IS_ERR(gc_th->f2fs_gc_task)) {
+               kfree(gc_th);
+               return -ENOMEM;
+       }
+       return 0;
+}
+
+void stop_gc_thread(struct f2fs_sb_info *sbi)
+{
+       struct f2fs_gc_kthread *gc_th = sbi->gc_thread;
+       if (!gc_th)
+               return;
+       kthread_stop(gc_th->f2fs_gc_task);
+       kfree(gc_th);
+       sbi->gc_thread = NULL;
+}
+
+static int select_gc_type(int gc_type)
+{
+       return (gc_type == BG_GC) ? GC_CB : GC_GREEDY;
+}
+
+static void select_policy(struct f2fs_sb_info *sbi, int gc_type,
+                       int type, struct victim_sel_policy *p)
+{
+       struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
+
+       if (p->alloc_mode) {
+               p->gc_mode = GC_GREEDY;
+               p->dirty_segmap = dirty_i->dirty_segmap[type];
+               p->ofs_unit = 1;
+       } else {
+               p->gc_mode = select_gc_type(gc_type);
+               p->dirty_segmap = dirty_i->dirty_segmap[DIRTY];
+               p->ofs_unit = sbi->segs_per_sec;
+       }
+       p->offset = sbi->last_victim[p->gc_mode];
+}
+
+static unsigned int get_max_cost(struct f2fs_sb_info *sbi,
+                               struct victim_sel_policy *p)
+{
+       if (p->gc_mode == GC_GREEDY)
+               return (1 << sbi->log_blocks_per_seg) * p->ofs_unit;
+       else if (p->gc_mode == GC_CB)
+               return UINT_MAX;
+       else /* No other gc_mode */
+               return 0;
+}
+
+static unsigned int check_bg_victims(struct f2fs_sb_info *sbi)
+{
+       struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
+       unsigned int segno;
+
+       /*
+        * If the gc_type is FG_GC, we can select victim segments
+        * selected by background GC before.
+        * Those segments guarantee they have small valid blocks.
+        */
+       segno = find_next_bit(dirty_i->victim_segmap[BG_GC],
+                                               TOTAL_SEGS(sbi), 0);
+       if (segno < TOTAL_SEGS(sbi)) {
+               clear_bit(segno, dirty_i->victim_segmap[BG_GC]);
+               return segno;
+       }
+       return NULL_SEGNO;
+}
+
+static unsigned int get_cb_cost(struct f2fs_sb_info *sbi, unsigned int segno)
+{
+       struct sit_info *sit_i = SIT_I(sbi);
+       unsigned int secno = GET_SECNO(sbi, segno);
+       unsigned int start = secno * sbi->segs_per_sec;
+       unsigned long long mtime = 0;
+       unsigned int vblocks;
+       unsigned char age = 0;
+       unsigned char u;
+       unsigned int i;
+
+       for (i = 0; i < sbi->segs_per_sec; i++)
+               mtime += get_seg_entry(sbi, start + i)->mtime;
+       vblocks = get_valid_blocks(sbi, segno, sbi->segs_per_sec);
+
+       mtime = div_u64(mtime, sbi->segs_per_sec);
+       vblocks = div_u64(vblocks, sbi->segs_per_sec);
+
+       u = (vblocks * 100) >> sbi->log_blocks_per_seg;
+
+       /* Handle if the system time is changed by user */
+       if (mtime < sit_i->min_mtime)
+               sit_i->min_mtime = mtime;
+       if (mtime > sit_i->max_mtime)
+               sit_i->max_mtime = mtime;
+       if (sit_i->max_mtime != sit_i->min_mtime)
+               age = 100 - div64_u64(100 * (mtime - sit_i->min_mtime),
+                               sit_i->max_mtime - sit_i->min_mtime);
+
+       return UINT_MAX - ((100 * (100 - u) * age) / (100 + u));
+}
+
+static unsigned int get_gc_cost(struct f2fs_sb_info *sbi, unsigned int segno,
+                                       struct victim_sel_policy *p)
+{
+       if (p->alloc_mode == SSR)
+               return get_seg_entry(sbi, segno)->ckpt_valid_blocks;
+
+       /* alloc_mode == LFS */
+       if (p->gc_mode == GC_GREEDY)
+               return get_valid_blocks(sbi, segno, sbi->segs_per_sec);
+       else
+               return get_cb_cost(sbi, segno);
+}
+
+/*
+ * This function is called from two pathes.
+ * One is garbage collection and the other is SSR segment selection.
+ * When it is called during GC, it just gets a victim segment
+ * and it does not remove it from dirty seglist.
+ * When it is called from SSR segment selection, it finds a segment
+ * which has minimum valid blocks and removes it from dirty seglist.
+ */
+static int get_victim_by_default(struct f2fs_sb_info *sbi,
+               unsigned int *result, int gc_type, int type, char alloc_mode)
+{
+       struct dirty_seglist_info *dirty_i = DIRTY_I(sbi);
+       struct victim_sel_policy p;
+       unsigned int segno;
+       int nsearched = 0;
+
+       p.alloc_mode = alloc_mode;
+       select_policy(sbi, gc_type, type, &p);
+
+       p.min_segno = NULL_SEGNO;
+       p.min_cost = get_max_cost(sbi, &p);
+
+       mutex_lock(&dirty_i->seglist_lock);
+
+       if (p.alloc_mode == LFS && gc_type == FG_GC) {
+               p.min_segno = check_bg_victims(sbi);
+               if (p.min_segno != NULL_SEGNO)
+                       goto got_it;
+       }
+
+       while (1) {
+               unsigned long cost;
+
+               segno = find_next_bit(p.dirty_segmap,
+                                               TOTAL_SEGS(sbi), p.offset);
+               if (segno >= TOTAL_SEGS(sbi)) {
+                       if (sbi->last_victim[p.gc_mode]) {
+                               sbi->last_victim[p.gc_mode] = 0;
+                               p.offset = 0;
+                               continue;
+                       }
+                       break;
+               }
+               p.offset = ((segno / p.ofs_unit) * p.ofs_unit) + p.ofs_unit;
+
+               if (test_bit(segno, dirty_i->victim_segmap[FG_GC]))
+                       continue;
+               if (gc_type == BG_GC &&
+                               test_bit(segno, dirty_i->victim_segmap[BG_GC]))
+                       continue;
+               if (IS_CURSEC(sbi, GET_SECNO(sbi, segno)))
+                       continue;
+
+               cost = get_gc_cost(sbi, segno, &p);
+
+               if (p.min_cost > cost) {
+                       p.min_segno = segno;
+                       p.min_cost = cost;
+               }
+
+               if (cost == get_max_cost(sbi, &p))
+                       continue;
+
+               if (nsearched++ >= MAX_VICTIM_SEARCH) {
+                       sbi->last_victim[p.gc_mode] = segno;
+                       break;
+               }
+       }
+got_it:
+       if (p.min_segno != NULL_SEGNO) {
+               *result = (p.min_segno / p.ofs_unit) * p.ofs_unit;
+               if (p.alloc_mode == LFS) {
+                       int i;
+                       for (i = 0; i < p.ofs_unit; i++)
+                               set_bit(*result + i,
+                                       dirty_i->victim_segmap[gc_type]);
+               }
+       }
+       mutex_unlock(&dirty_i->seglist_lock);
+
+       return (p.min_segno == NULL_SEGNO) ? 0 : 1;
+}
+
+static const struct victim_selection default_v_ops = {
+       .get_victim = get_victim_by_default,
+};
+
+static struct inode *find_gc_inode(nid_t ino, struct list_head *ilist)
+{
+       struct list_head *this;
+       struct inode_entry *ie;
+
+       list_for_each(this, ilist) {
+               ie = list_entry(this, struct inode_entry, list);
+               if (ie->inode->i_ino == ino)
+                       return ie->inode;
+       }
+       return NULL;
+}
+
+static void add_gc_inode(struct inode *inode, struct list_head *ilist)
+{
+       struct list_head *this;
+       struct inode_entry *new_ie, *ie;
+
+       list_for_each(this, ilist) {
+               ie = list_entry(this, struct inode_entry, list);
+               if (ie->inode == inode) {
+                       iput(inode);
+                       return;
+               }
+       }
+repeat:
+       new_ie = kmem_cache_alloc(winode_slab, GFP_NOFS);
+       if (!new_ie) {
+               cond_resched();
+               goto repeat;
+       }
+       new_ie->inode = inode;
+       list_add_tail(&new_ie->list, ilist);
+}
+
+static void put_gc_inode(struct list_head *ilist)
+{
+       struct inode_entry *ie, *next_ie;
+       list_for_each_entry_safe(ie, next_ie, ilist, list) {
+               iput(ie->inode);
+               list_del(&ie->list);
+               kmem_cache_free(winode_slab, ie);
+       }
+}
+
+static int check_valid_map(struct f2fs_sb_info *sbi,
+                               unsigned int segno, int offset)
+{
+       struct sit_info *sit_i = SIT_I(sbi);
+       struct seg_entry *sentry;
+       int ret;
+
+       mutex_lock(&sit_i->sentry_lock);
+       sentry = get_seg_entry(sbi, segno);
+       ret = f2fs_test_bit(offset, sentry->cur_valid_map);
+       mutex_unlock(&sit_i->sentry_lock);
+       return ret ? GC_OK : GC_NEXT;
+}
+
+/*
+ * This function compares node address got in summary with that in NAT.
+ * On validity, copy that node with cold status, otherwise (invalid node)
+ * ignore that.
+ */
+static int gc_node_segment(struct f2fs_sb_info *sbi,
+               struct f2fs_summary *sum, unsigned int segno, int gc_type)
+{
+       bool initial = true;
+       struct f2fs_summary *entry;
+       int off;
+
+next_step:
+       entry = sum;
+       for (off = 0; off < sbi->blocks_per_seg; off++, entry++) {
+               nid_t nid = le32_to_cpu(entry->nid);
+               struct page *node_page;
+               int err;
+
+               /*
+                * It makes sure that free segments are able to write
+                * all the dirty node pages before CP after this CP.
+                * So let's check the space of dirty node pages.
+                */
+               if (should_do_checkpoint(sbi)) {
+                       mutex_lock(&sbi->cp_mutex);
+                       block_operations(sbi);
+                       return GC_BLOCKED;
+               }
+
+               err = check_valid_map(sbi, segno, off);
+               if (err == GC_ERROR)
+                       return err;
+               else if (err == GC_NEXT)
+                       continue;
+
+               if (initial) {
+                       ra_node_page(sbi, nid);
+                       continue;
+               }
+               node_page = get_node_page(sbi, nid);
+               if (IS_ERR(node_page))
+                       continue;
+
+               /* set page dirty and write it */
+               if (!PageWriteback(node_page))
+                       set_page_dirty(node_page);
+               f2fs_put_page(node_page, 1);
+               stat_inc_node_blk_count(sbi, 1);
+       }
+       if (initial) {
+               initial = false;
+               goto next_step;
+       }
+
+       if (gc_type == FG_GC) {
+               struct writeback_control wbc = {
+                       .sync_mode = WB_SYNC_ALL,
+                       .nr_to_write = LONG_MAX,
+                       .for_reclaim = 0,
+               };
+               sync_node_pages(sbi, 0, &wbc);
+       }
+       return GC_DONE;
+}
+
+/*
+ * Calculate start block index that this node page contains
+ */
+block_t start_bidx_of_node(unsigned int node_ofs)
+{
+       block_t start_bidx;
+       unsigned int bidx, indirect_blks;
+       int dec;
+
+       indirect_blks = 2 * NIDS_PER_BLOCK + 4;
+
+       start_bidx = 1;
+       if (node_ofs == 0) {
+               start_bidx = 0;
+       } else if (node_ofs <= 2) {
+               bidx = node_ofs - 1;
+       } else if (node_ofs <= indirect_blks) {
+               dec = (node_ofs - 4) / (NIDS_PER_BLOCK + 1);
+               bidx = node_ofs - 2 - dec;
+       } else {
+               dec = (node_ofs - indirect_blks - 3) / (NIDS_PER_BLOCK + 1);
+               bidx = node_ofs - 5 - dec;
+       }
+
+       if (start_bidx)
+               start_bidx = bidx * ADDRS_PER_BLOCK + ADDRS_PER_INODE;
+       return start_bidx;
+}
+
+static int check_dnode(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
+               struct node_info *dni, block_t blkaddr, unsigned int *nofs)
+{
+       struct page *node_page;
+       nid_t nid;
+       unsigned int ofs_in_node;
+       block_t source_blkaddr;
+
+       nid = le32_to_cpu(sum->nid);
+       ofs_in_node = le16_to_cpu(sum->ofs_in_node);
+
+       node_page = get_node_page(sbi, nid);
+       if (IS_ERR(node_page))
+               return GC_NEXT;
+
+       get_node_info(sbi, nid, dni);
+
+       if (sum->version != dni->version) {
+               f2fs_put_page(node_page, 1);
+               return GC_NEXT;
+       }
+
+       *nofs = ofs_of_node(node_page);
+       source_blkaddr = datablock_addr(node_page, ofs_in_node);
+       f2fs_put_page(node_page, 1);
+
+       if (source_blkaddr != blkaddr)
+               return GC_NEXT;
+       return GC_OK;
+}
+
+static void move_data_page(struct inode *inode, struct page *page, int gc_type)
+{
+       if (page->mapping != inode->i_mapping)
+               goto out;
+
+       if (inode != page->mapping->host)
+               goto out;
+
+       if (PageWriteback(page))
+               goto out;
+
+       if (gc_type == BG_GC) {
+               set_page_dirty(page);
+               set_cold_data(page);
+       } else {
+               struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+               mutex_lock_op(sbi, DATA_WRITE);
+               if (clear_page_dirty_for_io(page) &&
+                       S_ISDIR(inode->i_mode)) {
+                       dec_page_count(sbi, F2FS_DIRTY_DENTS);
+                       inode_dec_dirty_dents(inode);
+               }
+               set_cold_data(page);
+               do_write_data_page(page);
+               mutex_unlock_op(sbi, DATA_WRITE);
+               clear_cold_data(page);
+       }
+out:
+       f2fs_put_page(page, 1);
+}
+
+/*
+ * This function tries to get parent node of victim data block, and identifies
+ * data block validity. If the block is valid, copy that with cold status and
+ * modify parent node.
+ * If the parent node is not valid or the data block address is different,
+ * the victim data block is ignored.
+ */
+static int gc_data_segment(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,
+               struct list_head *ilist, unsigned int segno, int gc_type)
+{
+       struct super_block *sb = sbi->sb;
+       struct f2fs_summary *entry;
+       block_t start_addr;
+       int err, off;
+       int phase = 0;
+
+       start_addr = START_BLOCK(sbi, segno);
+
+next_step:
+       entry = sum;
+       for (off = 0; off < sbi->blocks_per_seg; off++, entry++) {
+               struct page *data_page;
+               struct inode *inode;
+               struct node_info dni; /* dnode info for the data */
+               unsigned int ofs_in_node, nofs;
+               block_t start_bidx;
+
+               /*
+                * It makes sure that free segments are able to write
+                * all the dirty node pages before CP after this CP.
+                * So let's check the space of dirty node pages.
+                */
+               if (should_do_checkpoint(sbi)) {
+                       mutex_lock(&sbi->cp_mutex);
+                       block_operations(sbi);
+                       err = GC_BLOCKED;
+                       goto stop;
+               }
+
+               err = check_valid_map(sbi, segno, off);
+               if (err == GC_ERROR)
+                       goto stop;
+               else if (err == GC_NEXT)
+                       continue;
+
+               if (phase == 0) {
+                       ra_node_page(sbi, le32_to_cpu(entry->nid));
+                       continue;
+               }
+
+               /* Get an inode by ino with checking validity */
+               err = check_dnode(sbi, entry, &dni, start_addr + off, &nofs);
+               if (err == GC_ERROR)
+                       goto stop;
+               else if (err == GC_NEXT)
+                       continue;
+
+               if (phase == 1) {
+                       ra_node_page(sbi, dni.ino);
+                       continue;
+               }
+
+               start_bidx = start_bidx_of_node(nofs);
+               ofs_in_node = le16_to_cpu(entry->ofs_in_node);
+
+               if (phase == 2) {
+                       inode = f2fs_iget_nowait(sb, dni.ino);
+                       if (IS_ERR(inode))
+                               continue;
+
+                       data_page = find_data_page(inode,
+                                       start_bidx + ofs_in_node);
+                       if (IS_ERR(data_page))
+                               goto next_iput;
+
+                       f2fs_put_page(data_page, 0);
+                       add_gc_inode(inode, ilist);
+               } else {
+                       inode = find_gc_inode(dni.ino, ilist);
+                       if (inode) {
+                               data_page = get_lock_data_page(inode,
+                                               start_bidx + ofs_in_node);
+                               if (IS_ERR(data_page))
+                                       continue;
+                               move_data_page(inode, data_page, gc_type);
+                               stat_inc_data_blk_count(sbi, 1);
+                       }
+               }
+               continue;
+next_iput:
+               iput(inode);
+       }
+       if (++phase < 4)
+               goto next_step;
+       err = GC_DONE;
+stop:
+       if (gc_type == FG_GC)
+               f2fs_submit_bio(sbi, DATA, true);
+       return err;
+}
+
+static int __get_victim(struct f2fs_sb_info *sbi, unsigned int *victim,
+                                               int gc_type, int type)
+{
+       struct sit_info *sit_i = SIT_I(sbi);
+       int ret;
+       mutex_lock(&sit_i->sentry_lock);
+       ret = DIRTY_I(sbi)->v_ops->get_victim(sbi, victim, gc_type, type, LFS);
+       mutex_unlock(&sit_i->sentry_lock);
+       return ret;
+}
+
+static int do_garbage_collect(struct f2fs_sb_info *sbi, unsigned int segno,
+                               struct list_head *ilist, int gc_type)
+{
+       struct page *sum_page;
+       struct f2fs_summary_block *sum;
+       int ret = GC_DONE;
+
+       /* read segment summary of victim */
+       sum_page = get_sum_page(sbi, segno);
+       if (IS_ERR(sum_page))
+               return GC_ERROR;
+
+       /*
+        * CP needs to lock sum_page. In this time, we don't need
+        * to lock this page, because this summary page is not gone anywhere.
+        * Also, this page is not gonna be updated before GC is done.
+        */
+       unlock_page(sum_page);
+       sum = page_address(sum_page);
+
+       switch (GET_SUM_TYPE((&sum->footer))) {
+       case SUM_TYPE_NODE:
+               ret = gc_node_segment(sbi, sum->entries, segno, gc_type);
+               break;
+       case SUM_TYPE_DATA:
+               ret = gc_data_segment(sbi, sum->entries, ilist, segno, gc_type);
+               break;
+       }
+       stat_inc_seg_count(sbi, GET_SUM_TYPE((&sum->footer)));
+       stat_inc_call_count(sbi->stat_info);
+
+       f2fs_put_page(sum_page, 0);
+       return ret;
+}
+
+int f2fs_gc(struct f2fs_sb_info *sbi, int nGC)
+{
+       unsigned int segno;
+       int old_free_secs, cur_free_secs;
+       int gc_status, nfree;
+       struct list_head ilist;
+       int gc_type = BG_GC;
+
+       INIT_LIST_HEAD(&ilist);
+gc_more:
+       nfree = 0;
+       gc_status = GC_NONE;
+
+       if (has_not_enough_free_secs(sbi))
+               old_free_secs = reserved_sections(sbi);
+       else
+               old_free_secs = free_sections(sbi);
+
+       while (sbi->sb->s_flags & MS_ACTIVE) {
+               int i;
+               if (has_not_enough_free_secs(sbi))
+                       gc_type = FG_GC;
+
+               cur_free_secs = free_sections(sbi) + nfree;
+
+               /* We got free space successfully. */
+               if (nGC < cur_free_secs - old_free_secs)
+                       break;
+
+               if (!__get_victim(sbi, &segno, gc_type, NO_CHECK_TYPE))
+                       break;
+
+               for (i = 0; i < sbi->segs_per_sec; i++) {
+                       /*
+                        * do_garbage_collect will give us three gc_status:
+                        * GC_ERROR, GC_DONE, and GC_BLOCKED.
+                        * If GC is finished uncleanly, we have to return
+                        * the victim to dirty segment list.
+                        */
+                       gc_status = do_garbage_collect(sbi, segno + i,
+                                       &ilist, gc_type);
+                       if (gc_status != GC_DONE)
+                               goto stop;
+                       nfree++;
+               }
+       }
+stop:
+       if (has_not_enough_free_secs(sbi) || gc_status == GC_BLOCKED) {
+               write_checkpoint(sbi, (gc_status == GC_BLOCKED), false);
+               if (nfree)
+                       goto gc_more;
+       }
+       mutex_unlock(&sbi->gc_mutex);
+
+       put_gc_inode(&ilist);
+       BUG_ON(!list_empty(&ilist));
+       return gc_status;
+}
+
+void build_gc_manager(struct f2fs_sb_info *sbi)
+{
+       DIRTY_I(sbi)->v_ops = &default_v_ops;
+}
+
+int create_gc_caches(void)
+{
+       winode_slab = f2fs_kmem_cache_create("f2fs_gc_inodes",
+                       sizeof(struct inode_entry), NULL);
+       if (!winode_slab)
+               return -ENOMEM;
+       return 0;
+}
+
+void destroy_gc_caches(void)
+{
+       kmem_cache_destroy(winode_slab);
+}
diff --git a/fs/f2fs/gc.h b/fs/f2fs/gc.h
new file mode 100644 (file)
index 0000000..b026d93
--- /dev/null
@@ -0,0 +1,117 @@
+/*
+ * fs/f2fs/gc.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.
+ */
+#define GC_THREAD_NAME "f2fs_gc_task"
+#define GC_THREAD_MIN_WB_PAGES         1       /*
+                                                * a threshold to determine
+                                                * whether IO subsystem is idle
+                                                * or not
+                                                */
+#define GC_THREAD_MIN_SLEEP_TIME       10000 /* milliseconds */
+#define GC_THREAD_MAX_SLEEP_TIME       30000
+#define GC_THREAD_NOGC_SLEEP_TIME      10000
+#define LIMIT_INVALID_BLOCK    40 /* percentage over total user space */
+#define LIMIT_FREE_BLOCK       40 /* percentage over invalid + free space */
+
+/* Search max. number of dirty segments to select a victim segment */
+#define MAX_VICTIM_SEARCH      20
+
+enum {
+       GC_NONE = 0,
+       GC_ERROR,
+       GC_OK,
+       GC_NEXT,
+       GC_BLOCKED,
+       GC_DONE,
+};
+
+struct f2fs_gc_kthread {
+       struct task_struct *f2fs_gc_task;
+       wait_queue_head_t gc_wait_queue_head;
+};
+
+struct inode_entry {
+       struct list_head list;
+       struct inode *inode;
+};
+
+/*
+ * inline functions
+ */
+static inline block_t free_user_blocks(struct f2fs_sb_info *sbi)
+{
+       if (free_segments(sbi) < overprovision_segments(sbi))
+               return 0;
+       else
+               return (free_segments(sbi) - overprovision_segments(sbi))
+                       << sbi->log_blocks_per_seg;
+}
+
+static inline block_t limit_invalid_user_blocks(struct f2fs_sb_info *sbi)
+{
+       return (long)(sbi->user_block_count * LIMIT_INVALID_BLOCK) / 100;
+}
+
+static inline block_t limit_free_user_blocks(struct f2fs_sb_info *sbi)
+{
+       block_t reclaimable_user_blocks = sbi->user_block_count -
+               written_block_count(sbi);
+       return (long)(reclaimable_user_blocks * LIMIT_FREE_BLOCK) / 100;
+}
+
+static inline long increase_sleep_time(long wait)
+{
+       wait += GC_THREAD_MIN_SLEEP_TIME;
+       if (wait > GC_THREAD_MAX_SLEEP_TIME)
+               wait = GC_THREAD_MAX_SLEEP_TIME;
+       return wait;
+}
+
+static inline long decrease_sleep_time(long wait)
+{
+       wait -= GC_THREAD_MIN_SLEEP_TIME;
+       if (wait <= GC_THREAD_MIN_SLEEP_TIME)
+               wait = GC_THREAD_MIN_SLEEP_TIME;
+       return wait;
+}
+
+static inline bool has_enough_invalid_blocks(struct f2fs_sb_info *sbi)
+{
+       block_t invalid_user_blocks = sbi->user_block_count -
+                                       written_block_count(sbi);
+       /*
+        * Background GC is triggered with the following condition.
+        * 1. There are a number of invalid blocks.
+        * 2. There is not enough free space.
+        */
+       if (invalid_user_blocks > limit_invalid_user_blocks(sbi) &&
+                       free_user_blocks(sbi) < limit_free_user_blocks(sbi))
+               return true;
+       return false;
+}
+
+static inline int is_idle(struct f2fs_sb_info *sbi)
+{
+       struct block_device *bdev = sbi->sb->s_bdev;
+       struct request_queue *q = bdev_get_queue(bdev);
+       struct request_list *rl = &q->root_rl;
+       return !(rl->count[BLK_RW_SYNC]) && !(rl->count[BLK_RW_ASYNC]);
+}
+
+static inline bool should_do_checkpoint(struct f2fs_sb_info *sbi)
+{
+       unsigned int pages_per_sec = sbi->segs_per_sec *
+                                       (1 << sbi->log_blocks_per_seg);
+       int node_secs = ((get_pages(sbi, F2FS_DIRTY_NODES) + pages_per_sec - 1)
+                       >> sbi->log_blocks_per_seg) / sbi->segs_per_sec;
+       int dent_secs = ((get_pages(sbi, F2FS_DIRTY_DENTS) + pages_per_sec - 1)
+                       >> sbi->log_blocks_per_seg) / sbi->segs_per_sec;
+       return free_sections(sbi) <= (node_secs + 2 * dent_secs + 2);
+}
diff --git a/fs/f2fs/hash.c b/fs/f2fs/hash.c
new file mode 100644 (file)
index 0000000..a60f042
--- /dev/null
@@ -0,0 +1,97 @@
+/*
+ * fs/f2fs/hash.c
+ *
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd.
+ *             http://www.samsung.com/
+ *
+ * Portions of this code from linux/fs/ext3/hash.c
+ *
+ * Copyright (C) 2002 by Theodore Ts'o
+ *
+ * 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 <linux/types.h>
+#include <linux/fs.h>
+#include <linux/f2fs_fs.h>
+#include <linux/cryptohash.h>
+#include <linux/pagemap.h>
+
+#include "f2fs.h"
+
+/*
+ * Hashing code copied 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 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;
+}
+
+f2fs_hash_t f2fs_dentry_hash(const char *name, int len)
+{
+       __u32 hash, minor_hash;
+       f2fs_hash_t f2fs_hash;
+       const char *p;
+       __u32 in[8], buf[4];
+
+       /* Initialize the default seed for the hash checksum functions */
+       buf[0] = 0x67452301;
+       buf[1] = 0xefcdab89;
+       buf[2] = 0x98badcfe;
+       buf[3] = 0x10325476;
+
+       p = name;
+       while (len > 0) {
+               str2hashbuf(p, len, in, 4);
+               TEA_transform(buf, in);
+               len -= 16;
+               p += 16;
+       }
+       hash = buf[0];
+       minor_hash = buf[1];
+
+       f2fs_hash = cpu_to_le32(hash & ~F2FS_HASH_COL_BIT);
+       return f2fs_hash;
+}
diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
new file mode 100644 (file)
index 0000000..df5fb38
--- /dev/null
@@ -0,0 +1,268 @@
+/*
+ * fs/f2fs/inode.c
+ *
+ * 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.
+ */
+#include <linux/fs.h>
+#include <linux/f2fs_fs.h>
+#include <linux/buffer_head.h>
+#include <linux/writeback.h>
+
+#include "f2fs.h"
+#include "node.h"
+
+struct f2fs_iget_args {
+       u64 ino;
+       int on_free;
+};
+
+void f2fs_set_inode_flags(struct inode *inode)
+{
+       unsigned int flags = F2FS_I(inode)->i_flags;
+
+       inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE |
+                       S_NOATIME | S_DIRSYNC);
+
+       if (flags & FS_SYNC_FL)
+               inode->i_flags |= S_SYNC;
+       if (flags & FS_APPEND_FL)
+               inode->i_flags |= S_APPEND;
+       if (flags & FS_IMMUTABLE_FL)
+               inode->i_flags |= S_IMMUTABLE;
+       if (flags & FS_NOATIME_FL)
+               inode->i_flags |= S_NOATIME;
+       if (flags & FS_DIRSYNC_FL)
+               inode->i_flags |= S_DIRSYNC;
+}
+
+static int f2fs_iget_test(struct inode *inode, void *data)
+{
+       struct f2fs_iget_args *args = data;
+
+       if (inode->i_ino != args->ino)
+               return 0;
+       if (inode->i_state & (I_FREEING | I_WILL_FREE)) {
+               args->on_free = 1;
+               return 0;
+       }
+       return 1;
+}
+
+struct inode *f2fs_iget_nowait(struct super_block *sb, unsigned long ino)
+{
+       struct f2fs_iget_args args = {
+               .ino = ino,
+               .on_free = 0
+       };
+       struct inode *inode = ilookup5(sb, ino, f2fs_iget_test, &args);
+
+       if (inode)
+               return inode;
+       if (!args.on_free)
+               return f2fs_iget(sb, ino);
+       return ERR_PTR(-ENOENT);
+}
+
+static int do_read_inode(struct inode *inode)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       struct f2fs_inode_info *fi = F2FS_I(inode);
+       struct page *node_page;
+       struct f2fs_node *rn;
+       struct f2fs_inode *ri;
+
+       /* Check if ino is within scope */
+       check_nid_range(sbi, inode->i_ino);
+
+       node_page = get_node_page(sbi, inode->i_ino);
+       if (IS_ERR(node_page))
+               return PTR_ERR(node_page);
+
+       rn = page_address(node_page);
+       ri = &(rn->i);
+
+       inode->i_mode = le16_to_cpu(ri->i_mode);
+       i_uid_write(inode, le32_to_cpu(ri->i_uid));
+       i_gid_write(inode, le32_to_cpu(ri->i_gid));
+       set_nlink(inode, le32_to_cpu(ri->i_links));
+       inode->i_size = le64_to_cpu(ri->i_size);
+       inode->i_blocks = le64_to_cpu(ri->i_blocks);
+
+       inode->i_atime.tv_sec = le64_to_cpu(ri->i_atime);
+       inode->i_ctime.tv_sec = le64_to_cpu(ri->i_ctime);
+       inode->i_mtime.tv_sec = le64_to_cpu(ri->i_mtime);
+       inode->i_atime.tv_nsec = le32_to_cpu(ri->i_atime_nsec);
+       inode->i_ctime.tv_nsec = le32_to_cpu(ri->i_ctime_nsec);
+       inode->i_mtime.tv_nsec = le32_to_cpu(ri->i_mtime_nsec);
+       inode->i_generation = le32_to_cpu(ri->i_generation);
+
+       fi->i_current_depth = le32_to_cpu(ri->i_current_depth);
+       fi->i_xattr_nid = le32_to_cpu(ri->i_xattr_nid);
+       fi->i_flags = le32_to_cpu(ri->i_flags);
+       fi->flags = 0;
+       fi->data_version = le64_to_cpu(F2FS_CKPT(sbi)->checkpoint_ver) - 1;
+       fi->i_advise = ri->i_advise;
+       fi->i_pino = le32_to_cpu(ri->i_pino);
+       get_extent_info(&fi->ext, ri->i_ext);
+       f2fs_put_page(node_page, 1);
+       return 0;
+}
+
+struct inode *f2fs_iget(struct super_block *sb, unsigned long ino)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(sb);
+       struct inode *inode;
+       int ret;
+
+       inode = iget_locked(sb, ino);
+       if (!inode)
+               return ERR_PTR(-ENOMEM);
+       if (!(inode->i_state & I_NEW))
+               return inode;
+       if (ino == F2FS_NODE_INO(sbi) || ino == F2FS_META_INO(sbi))
+               goto make_now;
+
+       ret = do_read_inode(inode);
+       if (ret)
+               goto bad_inode;
+
+       if (!sbi->por_doing && inode->i_nlink == 0) {
+               ret = -ENOENT;
+               goto bad_inode;
+       }
+
+make_now:
+       if (ino == F2FS_NODE_INO(sbi)) {
+               inode->i_mapping->a_ops = &f2fs_node_aops;
+               mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
+       } else if (ino == F2FS_META_INO(sbi)) {
+               inode->i_mapping->a_ops = &f2fs_meta_aops;
+               mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
+       } else if (S_ISREG(inode->i_mode)) {
+               inode->i_op = &f2fs_file_inode_operations;
+               inode->i_fop = &f2fs_file_operations;
+               inode->i_mapping->a_ops = &f2fs_dblock_aops;
+       } else if (S_ISDIR(inode->i_mode)) {
+               inode->i_op = &f2fs_dir_inode_operations;
+               inode->i_fop = &f2fs_dir_operations;
+               inode->i_mapping->a_ops = &f2fs_dblock_aops;
+               mapping_set_gfp_mask(inode->i_mapping, GFP_HIGHUSER_MOVABLE |
+                               __GFP_ZERO);
+       } else if (S_ISLNK(inode->i_mode)) {
+               inode->i_op = &f2fs_symlink_inode_operations;
+               inode->i_mapping->a_ops = &f2fs_dblock_aops;
+       } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
+                       S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
+               inode->i_op = &f2fs_special_inode_operations;
+               init_special_inode(inode, inode->i_mode, inode->i_rdev);
+       } else {
+               ret = -EIO;
+               goto bad_inode;
+       }
+       unlock_new_inode(inode);
+
+       return inode;
+
+bad_inode:
+       iget_failed(inode);
+       return ERR_PTR(ret);
+}
+
+void update_inode(struct inode *inode, struct page *node_page)
+{
+       struct f2fs_node *rn;
+       struct f2fs_inode *ri;
+
+       wait_on_page_writeback(node_page);
+
+       rn = page_address(node_page);
+       ri = &(rn->i);
+
+       ri->i_mode = cpu_to_le16(inode->i_mode);
+       ri->i_advise = F2FS_I(inode)->i_advise;
+       ri->i_uid = cpu_to_le32(i_uid_read(inode));
+       ri->i_gid = cpu_to_le32(i_gid_read(inode));
+       ri->i_links = cpu_to_le32(inode->i_nlink);
+       ri->i_size = cpu_to_le64(i_size_read(inode));
+       ri->i_blocks = cpu_to_le64(inode->i_blocks);
+       set_raw_extent(&F2FS_I(inode)->ext, &ri->i_ext);
+
+       ri->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
+       ri->i_ctime = cpu_to_le64(inode->i_ctime.tv_sec);
+       ri->i_mtime = cpu_to_le64(inode->i_mtime.tv_sec);
+       ri->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
+       ri->i_ctime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
+       ri->i_mtime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
+       ri->i_current_depth = cpu_to_le32(F2FS_I(inode)->i_current_depth);
+       ri->i_xattr_nid = cpu_to_le32(F2FS_I(inode)->i_xattr_nid);
+       ri->i_flags = cpu_to_le32(F2FS_I(inode)->i_flags);
+       ri->i_pino = cpu_to_le32(F2FS_I(inode)->i_pino);
+       ri->i_generation = cpu_to_le32(inode->i_generation);
+       set_page_dirty(node_page);
+}
+
+int f2fs_write_inode(struct inode *inode, struct writeback_control *wbc)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       struct page *node_page;
+       bool need_lock = false;
+
+       if (inode->i_ino == F2FS_NODE_INO(sbi) ||
+                       inode->i_ino == F2FS_META_INO(sbi))
+               return 0;
+
+       node_page = get_node_page(sbi, inode->i_ino);
+       if (IS_ERR(node_page))
+               return PTR_ERR(node_page);
+
+       if (!PageDirty(node_page)) {
+               need_lock = true;
+               f2fs_put_page(node_page, 1);
+               mutex_lock(&sbi->write_inode);
+               node_page = get_node_page(sbi, inode->i_ino);
+               if (IS_ERR(node_page)) {
+                       mutex_unlock(&sbi->write_inode);
+                       return PTR_ERR(node_page);
+               }
+       }
+       update_inode(inode, node_page);
+       f2fs_put_page(node_page, 1);
+       if (need_lock)
+               mutex_unlock(&sbi->write_inode);
+       return 0;
+}
+
+/*
+ * Called at the last iput() if i_nlink is zero
+ */
+void f2fs_evict_inode(struct inode *inode)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+
+       truncate_inode_pages(&inode->i_data, 0);
+
+       if (inode->i_ino == F2FS_NODE_INO(sbi) ||
+                       inode->i_ino == F2FS_META_INO(sbi))
+               goto no_delete;
+
+       BUG_ON(atomic_read(&F2FS_I(inode)->dirty_dents));
+       remove_dirty_dir_inode(inode);
+
+       if (inode->i_nlink || is_bad_inode(inode))
+               goto no_delete;
+
+       set_inode_flag(F2FS_I(inode), FI_NO_ALLOC);
+       i_size_write(inode, 0);
+
+       if (F2FS_HAS_BLOCKS(inode))
+               f2fs_truncate(inode);
+
+       remove_inode_page(inode);
+no_delete:
+       clear_inode(inode);
+}
diff --git a/fs/f2fs/namei.c b/fs/f2fs/namei.c
new file mode 100644 (file)
index 0000000..89b7675
--- /dev/null
@@ -0,0 +1,503 @@
+/*
+ * fs/f2fs/namei.c
+ *
+ * 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.
+ */
+#include <linux/fs.h>
+#include <linux/f2fs_fs.h>
+#include <linux/pagemap.h>
+#include <linux/sched.h>
+#include <linux/ctype.h>
+
+#include "f2fs.h"
+#include "xattr.h"
+#include "acl.h"
+
+static struct inode *f2fs_new_inode(struct inode *dir, umode_t mode)
+{
+       struct super_block *sb = dir->i_sb;
+       struct f2fs_sb_info *sbi = F2FS_SB(sb);
+       nid_t ino;
+       struct inode *inode;
+       bool nid_free = false;
+       int err;
+
+       inode = new_inode(sb);
+       if (!inode)
+               return ERR_PTR(-ENOMEM);
+
+       mutex_lock_op(sbi, NODE_NEW);
+       if (!alloc_nid(sbi, &ino)) {
+               mutex_unlock_op(sbi, NODE_NEW);
+               err = -ENOSPC;
+               goto fail;
+       }
+       mutex_unlock_op(sbi, NODE_NEW);
+
+       inode->i_uid = current_fsuid();
+
+       if (dir->i_mode & S_ISGID) {
+               inode->i_gid = dir->i_gid;
+               if (S_ISDIR(mode))
+                       mode |= S_ISGID;
+       } else {
+               inode->i_gid = current_fsgid();
+       }
+
+       inode->i_ino = ino;
+       inode->i_mode = mode;
+       inode->i_blocks = 0;
+       inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
+       inode->i_generation = sbi->s_next_generation++;
+
+       err = insert_inode_locked(inode);
+       if (err) {
+               err = -EINVAL;
+               nid_free = true;
+               goto out;
+       }
+
+       mark_inode_dirty(inode);
+       return inode;
+
+out:
+       clear_nlink(inode);
+       unlock_new_inode(inode);
+fail:
+       iput(inode);
+       if (nid_free)
+               alloc_nid_failed(sbi, ino);
+       return ERR_PTR(err);
+}
+
+static int is_multimedia_file(const unsigned char *s, const char *sub)
+{
+       int slen = strlen(s);
+       int sublen = strlen(sub);
+       int ret;
+
+       if (sublen > slen)
+               return 1;
+
+       ret = memcmp(s + slen - sublen, sub, sublen);
+       if (ret) {      /* compare upper case */
+               int i;
+               char upper_sub[8];
+               for (i = 0; i < sublen && i < sizeof(upper_sub); i++)
+                       upper_sub[i] = toupper(sub[i]);
+               return memcmp(s + slen - sublen, upper_sub, sublen);
+       }
+
+       return ret;
+}
+
+/*
+ * Set multimedia files as cold files for hot/cold data separation
+ */
+static inline void set_cold_file(struct f2fs_sb_info *sbi, struct inode *inode,
+               const unsigned char *name)
+{
+       int i;
+       __u8 (*extlist)[8] = sbi->raw_super->extension_list;
+
+       int count = le32_to_cpu(sbi->raw_super->extension_count);
+       for (i = 0; i < count; i++) {
+               if (!is_multimedia_file(name, extlist[i])) {
+                       F2FS_I(inode)->i_advise |= FADVISE_COLD_BIT;
+                       break;
+               }
+       }
+}
+
+static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,
+                                               bool excl)
+{
+       struct super_block *sb = dir->i_sb;
+       struct f2fs_sb_info *sbi = F2FS_SB(sb);
+       struct inode *inode;
+       nid_t ino = 0;
+       int err;
+
+       inode = f2fs_new_inode(dir, mode);
+       if (IS_ERR(inode))
+               return PTR_ERR(inode);
+
+       if (!test_opt(sbi, DISABLE_EXT_IDENTIFY))
+               set_cold_file(sbi, inode, dentry->d_name.name);
+
+       inode->i_op = &f2fs_file_inode_operations;
+       inode->i_fop = &f2fs_file_operations;
+       inode->i_mapping->a_ops = &f2fs_dblock_aops;
+       ino = inode->i_ino;
+
+       err = f2fs_add_link(dentry, inode);
+       if (err)
+               goto out;
+
+       alloc_nid_done(sbi, ino);
+
+       if (!sbi->por_doing)
+               d_instantiate(dentry, inode);
+       unlock_new_inode(inode);
+
+       f2fs_balance_fs(sbi);
+       return 0;
+out:
+       clear_nlink(inode);
+       unlock_new_inode(inode);
+       iput(inode);
+       alloc_nid_failed(sbi, ino);
+       return err;
+}
+
+static int f2fs_link(struct dentry *old_dentry, struct inode *dir,
+               struct dentry *dentry)
+{
+       struct inode *inode = old_dentry->d_inode;
+       struct super_block *sb = dir->i_sb;
+       struct f2fs_sb_info *sbi = F2FS_SB(sb);
+       int err;
+
+       inode->i_ctime = CURRENT_TIME;
+       atomic_inc(&inode->i_count);
+
+       set_inode_flag(F2FS_I(inode), FI_INC_LINK);
+       err = f2fs_add_link(dentry, inode);
+       if (err)
+               goto out;
+
+       d_instantiate(dentry, inode);
+
+       f2fs_balance_fs(sbi);
+       return 0;
+out:
+       clear_inode_flag(F2FS_I(inode), FI_INC_LINK);
+       iput(inode);
+       return err;
+}
+
+struct dentry *f2fs_get_parent(struct dentry *child)
+{
+       struct qstr dotdot = QSTR_INIT("..", 2);
+       unsigned long ino = f2fs_inode_by_name(child->d_inode, &dotdot);
+       if (!ino)
+               return ERR_PTR(-ENOENT);
+       return d_obtain_alias(f2fs_iget(child->d_inode->i_sb, ino));
+}
+
+static struct dentry *f2fs_lookup(struct inode *dir, struct dentry *dentry,
+               unsigned int flags)
+{
+       struct inode *inode = NULL;
+       struct f2fs_dir_entry *de;
+       struct page *page;
+
+       if (dentry->d_name.len > F2FS_MAX_NAME_LEN)
+               return ERR_PTR(-ENAMETOOLONG);
+
+       de = f2fs_find_entry(dir, &dentry->d_name, &page);
+       if (de) {
+               nid_t ino = le32_to_cpu(de->ino);
+               kunmap(page);
+               f2fs_put_page(page, 0);
+
+               inode = f2fs_iget(dir->i_sb, ino);
+               if (IS_ERR(inode))
+                       return ERR_CAST(inode);
+       }
+
+       return d_splice_alias(inode, dentry);
+}
+
+static int f2fs_unlink(struct inode *dir, struct dentry *dentry)
+{
+       struct super_block *sb = dir->i_sb;
+       struct f2fs_sb_info *sbi = F2FS_SB(sb);
+       struct inode *inode = dentry->d_inode;
+       struct f2fs_dir_entry *de;
+       struct page *page;
+       int err = -ENOENT;
+
+       de = f2fs_find_entry(dir, &dentry->d_name, &page);
+       if (!de)
+               goto fail;
+
+       err = check_orphan_space(sbi);
+       if (err) {
+               kunmap(page);
+               f2fs_put_page(page, 0);
+               goto fail;
+       }
+
+       f2fs_delete_entry(de, page, inode);
+
+       /* In order to evict this inode,  we set it dirty */
+       mark_inode_dirty(inode);
+       f2fs_balance_fs(sbi);
+fail:
+       return err;
+}
+
+static int f2fs_symlink(struct inode *dir, struct dentry *dentry,
+                                       const char *symname)
+{
+       struct super_block *sb = dir->i_sb;
+       struct f2fs_sb_info *sbi = F2FS_SB(sb);
+       struct inode *inode;
+       unsigned symlen = strlen(symname) + 1;
+       int err;
+
+       inode = f2fs_new_inode(dir, S_IFLNK | S_IRWXUGO);
+       if (IS_ERR(inode))
+               return PTR_ERR(inode);
+
+       inode->i_op = &f2fs_symlink_inode_operations;
+       inode->i_mapping->a_ops = &f2fs_dblock_aops;
+
+       err = f2fs_add_link(dentry, inode);
+       if (err)
+               goto out;
+
+       err = page_symlink(inode, symname, symlen);
+       alloc_nid_done(sbi, inode->i_ino);
+
+       d_instantiate(dentry, inode);
+       unlock_new_inode(inode);
+
+       f2fs_balance_fs(sbi);
+
+       return err;
+out:
+       clear_nlink(inode);
+       unlock_new_inode(inode);
+       iput(inode);
+       alloc_nid_failed(sbi, inode->i_ino);
+       return err;
+}
+
+static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
+       struct inode *inode;
+       int err;
+
+       inode = f2fs_new_inode(dir, S_IFDIR | mode);
+       if (IS_ERR(inode))
+               return PTR_ERR(inode);
+
+       inode->i_op = &f2fs_dir_inode_operations;
+       inode->i_fop = &f2fs_dir_operations;
+       inode->i_mapping->a_ops = &f2fs_dblock_aops;
+       mapping_set_gfp_mask(inode->i_mapping, GFP_F2FS_ZERO);
+
+       set_inode_flag(F2FS_I(inode), FI_INC_LINK);
+       err = f2fs_add_link(dentry, inode);
+       if (err)
+               goto out_fail;
+
+       alloc_nid_done(sbi, inode->i_ino);
+
+       d_instantiate(dentry, inode);
+       unlock_new_inode(inode);
+
+       f2fs_balance_fs(sbi);
+       return 0;
+
+out_fail:
+       clear_inode_flag(F2FS_I(inode), FI_INC_LINK);
+       clear_nlink(inode);
+       unlock_new_inode(inode);
+       iput(inode);
+       alloc_nid_failed(sbi, inode->i_ino);
+       return err;
+}
+
+static int f2fs_rmdir(struct inode *dir, struct dentry *dentry)
+{
+       struct inode *inode = dentry->d_inode;
+       if (f2fs_empty_dir(inode))
+               return f2fs_unlink(dir, dentry);
+       return -ENOTEMPTY;
+}
+
+static int f2fs_mknod(struct inode *dir, struct dentry *dentry,
+                               umode_t mode, dev_t rdev)
+{
+       struct super_block *sb = dir->i_sb;
+       struct f2fs_sb_info *sbi = F2FS_SB(sb);
+       struct inode *inode;
+       int err = 0;
+
+       if (!new_valid_dev(rdev))
+               return -EINVAL;
+
+       inode = f2fs_new_inode(dir, mode);
+       if (IS_ERR(inode))
+               return PTR_ERR(inode);
+
+       init_special_inode(inode, inode->i_mode, rdev);
+       inode->i_op = &f2fs_special_inode_operations;
+
+       err = f2fs_add_link(dentry, inode);
+       if (err)
+               goto out;
+
+       alloc_nid_done(sbi, inode->i_ino);
+       d_instantiate(dentry, inode);
+       unlock_new_inode(inode);
+
+       f2fs_balance_fs(sbi);
+
+       return 0;
+out:
+       clear_nlink(inode);
+       unlock_new_inode(inode);
+       iput(inode);
+       alloc_nid_failed(sbi, inode->i_ino);
+       return err;
+}
+
+static int f2fs_rename(struct inode *old_dir, struct dentry *old_dentry,
+                       struct inode *new_dir, struct dentry *new_dentry)
+{
+       struct super_block *sb = old_dir->i_sb;
+       struct f2fs_sb_info *sbi = F2FS_SB(sb);
+       struct inode *old_inode = old_dentry->d_inode;
+       struct inode *new_inode = new_dentry->d_inode;
+       struct page *old_dir_page;
+       struct page *old_page;
+       struct f2fs_dir_entry *old_dir_entry = NULL;
+       struct f2fs_dir_entry *old_entry;
+       struct f2fs_dir_entry *new_entry;
+       int err = -ENOENT;
+
+       old_entry = f2fs_find_entry(old_dir, &old_dentry->d_name, &old_page);
+       if (!old_entry)
+               goto out;
+
+       if (S_ISDIR(old_inode->i_mode)) {
+               err = -EIO;
+               old_dir_entry = f2fs_parent_dir(old_inode, &old_dir_page);
+               if (!old_dir_entry)
+                       goto out_old;
+       }
+
+       mutex_lock_op(sbi, RENAME);
+
+       if (new_inode) {
+               struct page *new_page;
+
+               err = -ENOTEMPTY;
+               if (old_dir_entry && !f2fs_empty_dir(new_inode))
+                       goto out_dir;
+
+               err = -ENOENT;
+               new_entry = f2fs_find_entry(new_dir, &new_dentry->d_name,
+                                               &new_page);
+               if (!new_entry)
+                       goto out_dir;
+
+               f2fs_set_link(new_dir, new_entry, new_page, old_inode);
+
+               new_inode->i_ctime = CURRENT_TIME;
+               if (old_dir_entry)
+                       drop_nlink(new_inode);
+               drop_nlink(new_inode);
+               if (!new_inode->i_nlink)
+                       add_orphan_inode(sbi, new_inode->i_ino);
+               f2fs_write_inode(new_inode, NULL);
+       } else {
+               err = f2fs_add_link(new_dentry, old_inode);
+               if (err)
+                       goto out_dir;
+
+               if (old_dir_entry) {
+                       inc_nlink(new_dir);
+                       f2fs_write_inode(new_dir, NULL);
+               }
+       }
+
+       old_inode->i_ctime = CURRENT_TIME;
+       set_inode_flag(F2FS_I(old_inode), FI_NEED_CP);
+       mark_inode_dirty(old_inode);
+
+       f2fs_delete_entry(old_entry, old_page, NULL);
+
+       if (old_dir_entry) {
+               if (old_dir != new_dir) {
+                       f2fs_set_link(old_inode, old_dir_entry,
+                                               old_dir_page, new_dir);
+               } else {
+                       kunmap(old_dir_page);
+                       f2fs_put_page(old_dir_page, 0);
+               }
+               drop_nlink(old_dir);
+               f2fs_write_inode(old_dir, NULL);
+       }
+
+       mutex_unlock_op(sbi, RENAME);
+
+       f2fs_balance_fs(sbi);
+       return 0;
+
+out_dir:
+       if (old_dir_entry) {
+               kunmap(old_dir_page);
+               f2fs_put_page(old_dir_page, 0);
+       }
+       mutex_unlock_op(sbi, RENAME);
+out_old:
+       kunmap(old_page);
+       f2fs_put_page(old_page, 0);
+out:
+       return err;
+}
+
+const struct inode_operations f2fs_dir_inode_operations = {
+       .create         = f2fs_create,
+       .lookup         = f2fs_lookup,
+       .link           = f2fs_link,
+       .unlink         = f2fs_unlink,
+       .symlink        = f2fs_symlink,
+       .mkdir          = f2fs_mkdir,
+       .rmdir          = f2fs_rmdir,
+       .mknod          = f2fs_mknod,
+       .rename         = f2fs_rename,
+       .setattr        = f2fs_setattr,
+       .get_acl        = f2fs_get_acl,
+#ifdef CONFIG_F2FS_FS_XATTR
+       .setxattr       = generic_setxattr,
+       .getxattr       = generic_getxattr,
+       .listxattr      = f2fs_listxattr,
+       .removexattr    = generic_removexattr,
+#endif
+};
+
+const struct inode_operations f2fs_symlink_inode_operations = {
+       .readlink       = generic_readlink,
+       .follow_link    = page_follow_link_light,
+       .put_link       = page_put_link,
+       .setattr        = f2fs_setattr,
+#ifdef CONFIG_F2FS_FS_XATTR
+       .setxattr       = generic_setxattr,
+       .getxattr       = generic_getxattr,
+       .listxattr      = f2fs_listxattr,
+       .removexattr    = generic_removexattr,
+#endif
+};
+
+const struct inode_operations f2fs_special_inode_operations = {
+       .setattr        = f2fs_setattr,
+       .get_acl        = f2fs_get_acl,
+#ifdef CONFIG_F2FS_FS_XATTR
+       .setxattr       = generic_setxattr,
+       .getxattr       = generic_getxattr,
+       .listxattr      = f2fs_listxattr,
+       .removexattr    = generic_removexattr,
+#endif
+};
diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
new file mode 100644 (file)
index 0000000..1987036
--- /dev/null
@@ -0,0 +1,1764 @@
+/*
+ * fs/f2fs/node.c
+ *
+ * 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.
+ */
+#include <linux/fs.h>
+#include <linux/f2fs_fs.h>
+#include <linux/mpage.h>
+#include <linux/backing-dev.h>
+#include <linux/blkdev.h>
+#include <linux/pagevec.h>
+#include <linux/swap.h>
+
+#include "f2fs.h"
+#include "node.h"
+#include "segment.h"
+
+static struct kmem_cache *nat_entry_slab;
+static struct kmem_cache *free_nid_slab;
+
+static void clear_node_page_dirty(struct page *page)
+{
+       struct address_space *mapping = page->mapping;
+       struct f2fs_sb_info *sbi = F2FS_SB(mapping->host->i_sb);
+       unsigned int long flags;
+
+       if (PageDirty(page)) {
+               spin_lock_irqsave(&mapping->tree_lock, flags);
+               radix_tree_tag_clear(&mapping->page_tree,
+                               page_index(page),
+                               PAGECACHE_TAG_DIRTY);
+               spin_unlock_irqrestore(&mapping->tree_lock, flags);
+
+               clear_page_dirty_for_io(page);
+               dec_page_count(sbi, F2FS_DIRTY_NODES);
+       }
+       ClearPageUptodate(page);
+}
+
+static struct page *get_current_nat_page(struct f2fs_sb_info *sbi, nid_t nid)
+{
+       pgoff_t index = current_nat_addr(sbi, nid);
+       return get_meta_page(sbi, index);
+}
+
+static struct page *get_next_nat_page(struct f2fs_sb_info *sbi, nid_t nid)
+{
+       struct page *src_page;
+       struct page *dst_page;
+       pgoff_t src_off;
+       pgoff_t dst_off;
+       void *src_addr;
+       void *dst_addr;
+       struct f2fs_nm_info *nm_i = NM_I(sbi);
+
+       src_off = current_nat_addr(sbi, nid);
+       dst_off = next_nat_addr(sbi, src_off);
+
+       /* get current nat block page with lock */
+       src_page = get_meta_page(sbi, src_off);
+
+       /* Dirty src_page means that it is already the new target NAT page. */
+       if (PageDirty(src_page))
+               return src_page;
+
+       dst_page = grab_meta_page(sbi, dst_off);
+
+       src_addr = page_address(src_page);
+       dst_addr = page_address(dst_page);
+       memcpy(dst_addr, src_addr, PAGE_CACHE_SIZE);
+       set_page_dirty(dst_page);
+       f2fs_put_page(src_page, 1);
+
+       set_to_next_nat(nm_i, nid);
+
+       return dst_page;
+}
+
+/*
+ * Readahead NAT pages
+ */
+static void ra_nat_pages(struct f2fs_sb_info *sbi, int nid)
+{
+       struct address_space *mapping = sbi->meta_inode->i_mapping;
+       struct f2fs_nm_info *nm_i = NM_I(sbi);
+       struct page *page;
+       pgoff_t index;
+       int i;
+
+       for (i = 0; i < FREE_NID_PAGES; i++, nid += NAT_ENTRY_PER_BLOCK) {
+               if (nid >= nm_i->max_nid)
+                       nid = 0;
+               index = current_nat_addr(sbi, nid);
+
+               page = grab_cache_page(mapping, index);
+               if (!page)
+                       continue;
+               if (f2fs_readpage(sbi, page, index, READ)) {
+                       f2fs_put_page(page, 1);
+                       continue;
+               }
+               page_cache_release(page);
+       }
+}
+
+static struct nat_entry *__lookup_nat_cache(struct f2fs_nm_info *nm_i, nid_t n)
+{
+       return radix_tree_lookup(&nm_i->nat_root, n);
+}
+
+static unsigned int __gang_lookup_nat_cache(struct f2fs_nm_info *nm_i,
+               nid_t start, unsigned int nr, struct nat_entry **ep)
+{
+       return radix_tree_gang_lookup(&nm_i->nat_root, (void **)ep, start, nr);
+}
+
+static void __del_from_nat_cache(struct f2fs_nm_info *nm_i, struct nat_entry *e)
+{
+       list_del(&e->list);
+       radix_tree_delete(&nm_i->nat_root, nat_get_nid(e));
+       nm_i->nat_cnt--;
+       kmem_cache_free(nat_entry_slab, e);
+}
+
+int is_checkpointed_node(struct f2fs_sb_info *sbi, nid_t nid)
+{
+       struct f2fs_nm_info *nm_i = NM_I(sbi);
+       struct nat_entry *e;
+       int is_cp = 1;
+
+       read_lock(&nm_i->nat_tree_lock);
+       e = __lookup_nat_cache(nm_i, nid);
+       if (e && !e->checkpointed)
+               is_cp = 0;
+       read_unlock(&nm_i->nat_tree_lock);
+       return is_cp;
+}
+
+static struct nat_entry *grab_nat_entry(struct f2fs_nm_info *nm_i, nid_t nid)
+{
+       struct nat_entry *new;
+
+       new = kmem_cache_alloc(nat_entry_slab, GFP_ATOMIC);
+       if (!new)
+               return NULL;
+       if (radix_tree_insert(&nm_i->nat_root, nid, new)) {
+               kmem_cache_free(nat_entry_slab, new);
+               return NULL;
+       }
+       memset(new, 0, sizeof(struct nat_entry));
+       nat_set_nid(new, nid);
+       list_add_tail(&new->list, &nm_i->nat_entries);
+       nm_i->nat_cnt++;
+       return new;
+}
+
+static void cache_nat_entry(struct f2fs_nm_info *nm_i, nid_t nid,
+                                               struct f2fs_nat_entry *ne)
+{
+       struct nat_entry *e;
+retry:
+       write_lock(&nm_i->nat_tree_lock);
+       e = __lookup_nat_cache(nm_i, nid);
+       if (!e) {
+               e = grab_nat_entry(nm_i, nid);
+               if (!e) {
+                       write_unlock(&nm_i->nat_tree_lock);
+                       goto retry;
+               }
+               nat_set_blkaddr(e, le32_to_cpu(ne->block_addr));
+               nat_set_ino(e, le32_to_cpu(ne->ino));
+               nat_set_version(e, ne->version);
+               e->checkpointed = true;
+       }
+       write_unlock(&nm_i->nat_tree_lock);
+}
+
+static void set_node_addr(struct f2fs_sb_info *sbi, struct node_info *ni,
+                       block_t new_blkaddr)
+{
+       struct f2fs_nm_info *nm_i = NM_I(sbi);
+       struct nat_entry *e;
+retry:
+       write_lock(&nm_i->nat_tree_lock);
+       e = __lookup_nat_cache(nm_i, ni->nid);
+       if (!e) {
+               e = grab_nat_entry(nm_i, ni->nid);
+               if (!e) {
+                       write_unlock(&nm_i->nat_tree_lock);
+                       goto retry;
+               }
+               e->ni = *ni;
+               e->checkpointed = true;
+               BUG_ON(ni->blk_addr == NEW_ADDR);
+       } else if (new_blkaddr == NEW_ADDR) {
+               /*
+                * when nid is reallocated,
+                * previous nat entry can be remained in nat cache.
+                * So, reinitialize it with new information.
+                */
+               e->ni = *ni;
+               BUG_ON(ni->blk_addr != NULL_ADDR);
+       }
+
+       if (new_blkaddr == NEW_ADDR)
+               e->checkpointed = false;
+
+       /* sanity check */
+       BUG_ON(nat_get_blkaddr(e) != ni->blk_addr);
+       BUG_ON(nat_get_blkaddr(e) == NULL_ADDR &&
+                       new_blkaddr == NULL_ADDR);
+       BUG_ON(nat_get_blkaddr(e) == NEW_ADDR &&
+                       new_blkaddr == NEW_ADDR);
+       BUG_ON(nat_get_blkaddr(e) != NEW_ADDR &&
+                       nat_get_blkaddr(e) != NULL_ADDR &&
+                       new_blkaddr == NEW_ADDR);
+
+       /* increament version no as node is removed */
+       if (nat_get_blkaddr(e) != NEW_ADDR && new_blkaddr == NULL_ADDR) {
+               unsigned char version = nat_get_version(e);
+               nat_set_version(e, inc_node_version(version));
+       }
+
+       /* change address */
+       nat_set_blkaddr(e, new_blkaddr);
+       __set_nat_cache_dirty(nm_i, e);
+       write_unlock(&nm_i->nat_tree_lock);
+}
+
+static int try_to_free_nats(struct f2fs_sb_info *sbi, int nr_shrink)
+{
+       struct f2fs_nm_info *nm_i = NM_I(sbi);
+
+       if (nm_i->nat_cnt < 2 * NM_WOUT_THRESHOLD)
+               return 0;
+
+       write_lock(&nm_i->nat_tree_lock);
+       while (nr_shrink && !list_empty(&nm_i->nat_entries)) {
+               struct nat_entry *ne;
+               ne = list_first_entry(&nm_i->nat_entries,
+                                       struct nat_entry, list);
+               __del_from_nat_cache(nm_i, ne);
+               nr_shrink--;
+       }
+       write_unlock(&nm_i->nat_tree_lock);
+       return nr_shrink;
+}
+
+/*
+ * This function returns always success
+ */
+void get_node_info(struct f2fs_sb_info *sbi, nid_t nid, struct node_info *ni)
+{
+       struct f2fs_nm_info *nm_i = NM_I(sbi);
+       struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
+       struct f2fs_summary_block *sum = curseg->sum_blk;
+       nid_t start_nid = START_NID(nid);
+       struct f2fs_nat_block *nat_blk;
+       struct page *page = NULL;
+       struct f2fs_nat_entry ne;
+       struct nat_entry *e;
+       int i;
+
+       memset(&ne, 0, sizeof(struct f2fs_nat_entry));
+       ni->nid = nid;
+
+       /* Check nat cache */
+       read_lock(&nm_i->nat_tree_lock);
+       e = __lookup_nat_cache(nm_i, nid);
+       if (e) {
+               ni->ino = nat_get_ino(e);
+               ni->blk_addr = nat_get_blkaddr(e);
+               ni->version = nat_get_version(e);
+       }
+       read_unlock(&nm_i->nat_tree_lock);
+       if (e)
+               return;
+
+       /* Check current segment summary */
+       mutex_lock(&curseg->curseg_mutex);
+       i = lookup_journal_in_cursum(sum, NAT_JOURNAL, nid, 0);
+       if (i >= 0) {
+               ne = nat_in_journal(sum, i);
+               node_info_from_raw_nat(ni, &ne);
+       }
+       mutex_unlock(&curseg->curseg_mutex);
+       if (i >= 0)
+               goto cache;
+
+       /* Fill node_info from nat page */
+       page = get_current_nat_page(sbi, start_nid);
+       nat_blk = (struct f2fs_nat_block *)page_address(page);
+       ne = nat_blk->entries[nid - start_nid];
+       node_info_from_raw_nat(ni, &ne);
+       f2fs_put_page(page, 1);
+cache:
+       /* cache nat entry */
+       cache_nat_entry(NM_I(sbi), nid, &ne);
+}
+
+/*
+ * The maximum depth is four.
+ * Offset[0] will have raw inode offset.
+ */
+static int get_node_path(long block, int offset[4], unsigned int noffset[4])
+{
+       const long direct_index = ADDRS_PER_INODE;
+       const long direct_blks = ADDRS_PER_BLOCK;
+       const long dptrs_per_blk = NIDS_PER_BLOCK;
+       const long indirect_blks = ADDRS_PER_BLOCK * NIDS_PER_BLOCK;
+       const long dindirect_blks = indirect_blks * NIDS_PER_BLOCK;
+       int n = 0;
+       int level = 0;
+
+       noffset[0] = 0;
+
+       if (block < direct_index) {
+               offset[n++] = block;
+               level = 0;
+               goto got;
+       }
+       block -= direct_index;
+       if (block < direct_blks) {
+               offset[n++] = NODE_DIR1_BLOCK;
+               noffset[n] = 1;
+               offset[n++] = block;
+               level = 1;
+               goto got;
+       }
+       block -= direct_blks;
+       if (block < direct_blks) {
+               offset[n++] = NODE_DIR2_BLOCK;
+               noffset[n] = 2;
+               offset[n++] = block;
+               level = 1;
+               goto got;
+       }
+       block -= direct_blks;
+       if (block < indirect_blks) {
+               offset[n++] = NODE_IND1_BLOCK;
+               noffset[n] = 3;
+               offset[n++] = block / direct_blks;
+               noffset[n] = 4 + offset[n - 1];
+               offset[n++] = block % direct_blks;
+               level = 2;
+               goto got;
+       }
+       block -= indirect_blks;
+       if (block < indirect_blks) {
+               offset[n++] = NODE_IND2_BLOCK;
+               noffset[n] = 4 + dptrs_per_blk;
+               offset[n++] = block / direct_blks;
+               noffset[n] = 5 + dptrs_per_blk + offset[n - 1];
+               offset[n++] = block % direct_blks;
+               level = 2;
+               goto got;
+       }
+       block -= indirect_blks;
+       if (block < dindirect_blks) {
+               offset[n++] = NODE_DIND_BLOCK;
+               noffset[n] = 5 + (dptrs_per_blk * 2);
+               offset[n++] = block / indirect_blks;
+               noffset[n] = 6 + (dptrs_per_blk * 2) +
+                             offset[n - 1] * (dptrs_per_blk + 1);
+               offset[n++] = (block / direct_blks) % dptrs_per_blk;
+               noffset[n] = 7 + (dptrs_per_blk * 2) +
+                             offset[n - 2] * (dptrs_per_blk + 1) +
+                             offset[n - 1];
+               offset[n++] = block % direct_blks;
+               level = 3;
+               goto got;
+       } else {
+               BUG();
+       }
+got:
+       return level;
+}
+
+/*
+ * Caller should call f2fs_put_dnode(dn).
+ */
+int get_dnode_of_data(struct dnode_of_data *dn, pgoff_t index, int ro)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);
+       struct page *npage[4];
+       struct page *parent;
+       int offset[4];
+       unsigned int noffset[4];
+       nid_t nids[4];
+       int level, i;
+       int err = 0;
+
+       level = get_node_path(index, offset, noffset);
+
+       nids[0] = dn->inode->i_ino;
+       npage[0] = get_node_page(sbi, nids[0]);
+       if (IS_ERR(npage[0]))
+               return PTR_ERR(npage[0]);
+
+       parent = npage[0];
+       nids[1] = get_nid(parent, offset[0], true);
+       dn->inode_page = npage[0];
+       dn->inode_page_locked = true;
+
+       /* get indirect or direct nodes */
+       for (i = 1; i <= level; i++) {
+               bool done = false;
+
+               if (!nids[i] && !ro) {
+                       mutex_lock_op(sbi, NODE_NEW);
+
+                       /* alloc new node */
+                       if (!alloc_nid(sbi, &(nids[i]))) {
+                               mutex_unlock_op(sbi, NODE_NEW);
+                               err = -ENOSPC;
+                               goto release_pages;
+                       }
+
+                       dn->nid = nids[i];
+                       npage[i] = new_node_page(dn, noffset[i]);
+                       if (IS_ERR(npage[i])) {
+                               alloc_nid_failed(sbi, nids[i]);
+                               mutex_unlock_op(sbi, NODE_NEW);
+                               err = PTR_ERR(npage[i]);
+                               goto release_pages;
+                       }
+
+                       set_nid(parent, offset[i - 1], nids[i], i == 1);
+                       alloc_nid_done(sbi, nids[i]);
+                       mutex_unlock_op(sbi, NODE_NEW);
+                       done = true;
+               } else if (ro && i == level && level > 1) {
+                       npage[i] = get_node_page_ra(parent, offset[i - 1]);
+                       if (IS_ERR(npage[i])) {
+                               err = PTR_ERR(npage[i]);
+                               goto release_pages;
+                       }
+                       done = true;
+               }
+               if (i == 1) {
+                       dn->inode_page_locked = false;
+                       unlock_page(parent);
+               } else {
+                       f2fs_put_page(parent, 1);
+               }
+
+               if (!done) {
+                       npage[i] = get_node_page(sbi, nids[i]);
+                       if (IS_ERR(npage[i])) {
+                               err = PTR_ERR(npage[i]);
+                               f2fs_put_page(npage[0], 0);
+                               goto release_out;
+                       }
+               }
+               if (i < level) {
+                       parent = npage[i];
+                       nids[i + 1] = get_nid(parent, offset[i], false);
+               }
+       }
+       dn->nid = nids[level];
+       dn->ofs_in_node = offset[level];
+       dn->node_page = npage[level];
+       dn->data_blkaddr = datablock_addr(dn->node_page, dn->ofs_in_node);
+       return 0;
+
+release_pages:
+       f2fs_put_page(parent, 1);
+       if (i > 1)
+               f2fs_put_page(npage[0], 0);
+release_out:
+       dn->inode_page = NULL;
+       dn->node_page = NULL;
+       return err;
+}
+
+static void truncate_node(struct dnode_of_data *dn)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);
+       struct node_info ni;
+
+       get_node_info(sbi, dn->nid, &ni);
+       BUG_ON(ni.blk_addr == NULL_ADDR);
+
+       if (ni.blk_addr != NULL_ADDR)
+               invalidate_blocks(sbi, ni.blk_addr);
+
+       /* Deallocate node address */
+       dec_valid_node_count(sbi, dn->inode, 1);
+       set_node_addr(sbi, &ni, NULL_ADDR);
+
+       if (dn->nid == dn->inode->i_ino) {
+               remove_orphan_inode(sbi, dn->nid);
+               dec_valid_inode_count(sbi);
+       } else {
+               sync_inode_page(dn);
+       }
+
+       clear_node_page_dirty(dn->node_page);
+       F2FS_SET_SB_DIRT(sbi);
+
+       f2fs_put_page(dn->node_page, 1);
+       dn->node_page = NULL;
+}
+
+static int truncate_dnode(struct dnode_of_data *dn)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);
+       struct page *page;
+
+       if (dn->nid == 0)
+               return 1;
+
+       /* get direct node */
+       page = get_node_page(sbi, dn->nid);
+       if (IS_ERR(page) && PTR_ERR(page) == -ENOENT)
+               return 1;
+       else if (IS_ERR(page))
+               return PTR_ERR(page);
+
+       /* Make dnode_of_data for parameter */
+       dn->node_page = page;
+       dn->ofs_in_node = 0;
+       truncate_data_blocks(dn);
+       truncate_node(dn);
+       return 1;
+}
+
+static int truncate_nodes(struct dnode_of_data *dn, unsigned int nofs,
+                                               int ofs, int depth)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);
+       struct dnode_of_data rdn = *dn;
+       struct page *page;
+       struct f2fs_node *rn;
+       nid_t child_nid;
+       unsigned int child_nofs;
+       int freed = 0;
+       int i, ret;
+
+       if (dn->nid == 0)
+               return NIDS_PER_BLOCK + 1;
+
+       page = get_node_page(sbi, dn->nid);
+       if (IS_ERR(page))
+               return PTR_ERR(page);
+
+       rn = (struct f2fs_node *)page_address(page);
+       if (depth < 3) {
+               for (i = ofs; i < NIDS_PER_BLOCK; i++, freed++) {
+                       child_nid = le32_to_cpu(rn->in.nid[i]);
+                       if (child_nid == 0)
+                               continue;
+                       rdn.nid = child_nid;
+                       ret = truncate_dnode(&rdn);
+                       if (ret < 0)
+                               goto out_err;
+                       set_nid(page, i, 0, false);
+               }
+       } else {
+               child_nofs = nofs + ofs * (NIDS_PER_BLOCK + 1) + 1;
+               for (i = ofs; i < NIDS_PER_BLOCK; i++) {
+                       child_nid = le32_to_cpu(rn->in.nid[i]);
+                       if (child_nid == 0) {
+                               child_nofs += NIDS_PER_BLOCK + 1;
+                               continue;
+                       }
+                       rdn.nid = child_nid;
+                       ret = truncate_nodes(&rdn, child_nofs, 0, depth - 1);
+                       if (ret == (NIDS_PER_BLOCK + 1)) {
+                               set_nid(page, i, 0, false);
+                               child_nofs += ret;
+                       } else if (ret < 0 && ret != -ENOENT) {
+                               goto out_err;
+                       }
+               }
+               freed = child_nofs;
+       }
+
+       if (!ofs) {
+               /* remove current indirect node */
+               dn->node_page = page;
+               truncate_node(dn);
+               freed++;
+       } else {
+               f2fs_put_page(page, 1);
+       }
+       return freed;
+
+out_err:
+       f2fs_put_page(page, 1);
+       return ret;
+}
+
+static int truncate_partial_nodes(struct dnode_of_data *dn,
+                       struct f2fs_inode *ri, int *offset, int depth)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);
+       struct page *pages[2];
+       nid_t nid[3];
+       nid_t child_nid;
+       int err = 0;
+       int i;
+       int idx = depth - 2;
+
+       nid[0] = le32_to_cpu(ri->i_nid[offset[0] - NODE_DIR1_BLOCK]);
+       if (!nid[0])
+               return 0;
+
+       /* get indirect nodes in the path */
+       for (i = 0; i < depth - 1; i++) {
+               /* refernece count'll be increased */
+               pages[i] = get_node_page(sbi, nid[i]);
+               if (IS_ERR(pages[i])) {
+                       depth = i + 1;
+                       err = PTR_ERR(pages[i]);
+                       goto fail;
+               }
+               nid[i + 1] = get_nid(pages[i], offset[i + 1], false);
+       }
+
+       /* free direct nodes linked to a partial indirect node */
+       for (i = offset[depth - 1]; i < NIDS_PER_BLOCK; i++) {
+               child_nid = get_nid(pages[idx], i, false);
+               if (!child_nid)
+                       continue;
+               dn->nid = child_nid;
+               err = truncate_dnode(dn);
+               if (err < 0)
+                       goto fail;
+               set_nid(pages[idx], i, 0, false);
+       }
+
+       if (offset[depth - 1] == 0) {
+               dn->node_page = pages[idx];
+               dn->nid = nid[idx];
+               truncate_node(dn);
+       } else {
+               f2fs_put_page(pages[idx], 1);
+       }
+       offset[idx]++;
+       offset[depth - 1] = 0;
+fail:
+       for (i = depth - 3; i >= 0; i--)
+               f2fs_put_page(pages[i], 1);
+       return err;
+}
+
+/*
+ * All the block addresses of data and nodes should be nullified.
+ */
+int truncate_inode_blocks(struct inode *inode, pgoff_t from)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       int err = 0, cont = 1;
+       int level, offset[4], noffset[4];
+       unsigned int nofs;
+       struct f2fs_node *rn;
+       struct dnode_of_data dn;
+       struct page *page;
+
+       level = get_node_path(from, offset, noffset);
+
+       page = get_node_page(sbi, inode->i_ino);
+       if (IS_ERR(page))
+               return PTR_ERR(page);
+
+       set_new_dnode(&dn, inode, page, NULL, 0);
+       unlock_page(page);
+
+       rn = page_address(page);
+       switch (level) {
+       case 0:
+       case 1:
+               nofs = noffset[1];
+               break;
+       case 2:
+               nofs = noffset[1];
+               if (!offset[level - 1])
+                       goto skip_partial;
+               err = truncate_partial_nodes(&dn, &rn->i, offset, level);
+               if (err < 0 && err != -ENOENT)
+                       goto fail;
+               nofs += 1 + NIDS_PER_BLOCK;
+               break;
+       case 3:
+               nofs = 5 + 2 * NIDS_PER_BLOCK;
+               if (!offset[level - 1])
+                       goto skip_partial;
+               err = truncate_partial_nodes(&dn, &rn->i, offset, level);
+               if (err < 0 && err != -ENOENT)
+                       goto fail;
+               break;
+       default:
+               BUG();
+       }
+
+skip_partial:
+       while (cont) {
+               dn.nid = le32_to_cpu(rn->i.i_nid[offset[0] - NODE_DIR1_BLOCK]);
+               switch (offset[0]) {
+               case NODE_DIR1_BLOCK:
+               case NODE_DIR2_BLOCK:
+                       err = truncate_dnode(&dn);
+                       break;
+
+               case NODE_IND1_BLOCK:
+               case NODE_IND2_BLOCK:
+                       err = truncate_nodes(&dn, nofs, offset[1], 2);
+                       break;
+
+               case NODE_DIND_BLOCK:
+                       err = truncate_nodes(&dn, nofs, offset[1], 3);
+                       cont = 0;
+                       break;
+
+               default:
+                       BUG();
+               }
+               if (err < 0 && err != -ENOENT)
+                       goto fail;
+               if (offset[1] == 0 &&
+                               rn->i.i_nid[offset[0] - NODE_DIR1_BLOCK]) {
+                       lock_page(page);
+                       wait_on_page_writeback(page);
+                       rn->i.i_nid[offset[0] - NODE_DIR1_BLOCK] = 0;
+                       set_page_dirty(page);
+                       unlock_page(page);
+               }
+               offset[1] = 0;
+               offset[0]++;
+               nofs += err;
+       }
+fail:
+       f2fs_put_page(page, 0);
+       return err > 0 ? 0 : err;
+}
+
+int remove_inode_page(struct inode *inode)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       struct page *page;
+       nid_t ino = inode->i_ino;
+       struct dnode_of_data dn;
+
+       mutex_lock_op(sbi, NODE_TRUNC);
+       page = get_node_page(sbi, ino);
+       if (IS_ERR(page)) {
+               mutex_unlock_op(sbi, NODE_TRUNC);
+               return PTR_ERR(page);
+       }
+
+       if (F2FS_I(inode)->i_xattr_nid) {
+               nid_t nid = F2FS_I(inode)->i_xattr_nid;
+               struct page *npage = get_node_page(sbi, nid);
+
+               if (IS_ERR(npage)) {
+                       mutex_unlock_op(sbi, NODE_TRUNC);
+                       return PTR_ERR(npage);
+               }
+
+               F2FS_I(inode)->i_xattr_nid = 0;
+               set_new_dnode(&dn, inode, page, npage, nid);
+               dn.inode_page_locked = 1;
+               truncate_node(&dn);
+       }
+       if (inode->i_blocks == 1) {
+               /* inernally call f2fs_put_page() */
+               set_new_dnode(&dn, inode, page, page, ino);
+               truncate_node(&dn);
+       } else if (inode->i_blocks == 0) {
+               struct node_info ni;
+               get_node_info(sbi, inode->i_ino, &ni);
+
+               /* called after f2fs_new_inode() is failed */
+               BUG_ON(ni.blk_addr != NULL_ADDR);
+               f2fs_put_page(page, 1);
+       } else {
+               BUG();
+       }
+       mutex_unlock_op(sbi, NODE_TRUNC);
+       return 0;
+}
+
+int new_inode_page(struct inode *inode, struct dentry *dentry)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       struct page *page;
+       struct dnode_of_data dn;
+
+       /* allocate inode page for new inode */
+       set_new_dnode(&dn, inode, NULL, NULL, inode->i_ino);
+       mutex_lock_op(sbi, NODE_NEW);
+       page = new_node_page(&dn, 0);
+       init_dent_inode(dentry, page);
+       mutex_unlock_op(sbi, NODE_NEW);
+       if (IS_ERR(page))
+               return PTR_ERR(page);
+       f2fs_put_page(page, 1);
+       return 0;
+}
+
+struct page *new_node_page(struct dnode_of_data *dn, unsigned int ofs)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(dn->inode->i_sb);
+       struct address_space *mapping = sbi->node_inode->i_mapping;
+       struct node_info old_ni, new_ni;
+       struct page *page;
+       int err;
+
+       if (is_inode_flag_set(F2FS_I(dn->inode), FI_NO_ALLOC))
+               return ERR_PTR(-EPERM);
+
+       page = grab_cache_page(mapping, dn->nid);
+       if (!page)
+               return ERR_PTR(-ENOMEM);
+
+       get_node_info(sbi, dn->nid, &old_ni);
+
+       SetPageUptodate(page);
+       fill_node_footer(page, dn->nid, dn->inode->i_ino, ofs, true);
+
+       /* Reinitialize old_ni with new node page */
+       BUG_ON(old_ni.blk_addr != NULL_ADDR);
+       new_ni = old_ni;
+       new_ni.ino = dn->inode->i_ino;
+
+       if (!inc_valid_node_count(sbi, dn->inode, 1)) {
+               err = -ENOSPC;
+               goto fail;
+       }
+       set_node_addr(sbi, &new_ni, NEW_ADDR);
+
+       dn->node_page = page;
+       sync_inode_page(dn);
+       set_page_dirty(page);
+       set_cold_node(dn->inode, page);
+       if (ofs == 0)
+               inc_valid_inode_count(sbi);
+
+       return page;
+
+fail:
+       f2fs_put_page(page, 1);
+       return ERR_PTR(err);
+}
+
+static int read_node_page(struct page *page, int type)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(page->mapping->host->i_sb);
+       struct node_info ni;
+
+       get_node_info(sbi, page->index, &ni);
+
+       if (ni.blk_addr == NULL_ADDR)
+               return -ENOENT;
+       return f2fs_readpage(sbi, page, ni.blk_addr, type);
+}
+
+/*
+ * Readahead a node page
+ */
+void ra_node_page(struct f2fs_sb_info *sbi, nid_t nid)
+{
+       struct address_space *mapping = sbi->node_inode->i_mapping;
+       struct page *apage;
+
+       apage = find_get_page(mapping, nid);
+       if (apage && PageUptodate(apage))
+               goto release_out;
+       f2fs_put_page(apage, 0);
+
+       apage = grab_cache_page(mapping, nid);
+       if (!apage)
+               return;
+
+       if (read_node_page(apage, READA))
+               goto unlock_out;
+
+       page_cache_release(apage);
+       return;
+
+unlock_out:
+       unlock_page(apage);
+release_out:
+       page_cache_release(apage);
+}
+
+struct page *get_node_page(struct f2fs_sb_info *sbi, pgoff_t nid)
+{
+       int err;
+       struct page *page;
+       struct address_space *mapping = sbi->node_inode->i_mapping;
+
+       page = grab_cache_page(mapping, nid);
+       if (!page)
+               return ERR_PTR(-ENOMEM);
+
+       err = read_node_page(page, READ_SYNC);
+       if (err) {
+               f2fs_put_page(page, 1);
+               return ERR_PTR(err);
+       }
+
+       BUG_ON(nid != nid_of_node(page));
+       mark_page_accessed(page);
+       return page;
+}
+
+/*
+ * Return a locked page for the desired node page.
+ * And, readahead MAX_RA_NODE number of node pages.
+ */
+struct page *get_node_page_ra(struct page *parent, int start)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(parent->mapping->host->i_sb);
+       struct address_space *mapping = sbi->node_inode->i_mapping;
+       int i, end;
+       int err = 0;
+       nid_t nid;
+       struct page *page;
+
+       /* First, try getting the desired direct node. */
+       nid = get_nid(parent, start, false);
+       if (!nid)
+               return ERR_PTR(-ENOENT);
+
+       page = find_get_page(mapping, nid);
+       if (page && PageUptodate(page))
+               goto page_hit;
+       f2fs_put_page(page, 0);
+
+repeat:
+       page = grab_cache_page(mapping, nid);
+       if (!page)
+               return ERR_PTR(-ENOMEM);
+
+       err = read_node_page(page, READA);
+       if (err) {
+               f2fs_put_page(page, 1);
+               return ERR_PTR(err);
+       }
+
+       /* Then, try readahead for siblings of the desired node */
+       end = start + MAX_RA_NODE;
+       end = min(end, NIDS_PER_BLOCK);
+       for (i = start + 1; i < end; i++) {
+               nid = get_nid(parent, i, false);
+               if (!nid)
+                       continue;
+               ra_node_page(sbi, nid);
+       }
+
+page_hit:
+       lock_page(page);
+       if (PageError(page)) {
+               f2fs_put_page(page, 1);
+               return ERR_PTR(-EIO);
+       }
+
+       /* Has the page been truncated? */
+       if (page->mapping != mapping) {
+               f2fs_put_page(page, 1);
+               goto repeat;
+       }
+       return page;
+}
+
+void sync_inode_page(struct dnode_of_data *dn)
+{
+       if (IS_INODE(dn->node_page) || dn->inode_page == dn->node_page) {
+               update_inode(dn->inode, dn->node_page);
+       } else if (dn->inode_page) {
+               if (!dn->inode_page_locked)
+                       lock_page(dn->inode_page);
+               update_inode(dn->inode, dn->inode_page);
+               if (!dn->inode_page_locked)
+                       unlock_page(dn->inode_page);
+       } else {
+               f2fs_write_inode(dn->inode, NULL);
+       }
+}
+
+int sync_node_pages(struct f2fs_sb_info *sbi, nid_t ino,
+                                       struct writeback_control *wbc)
+{
+       struct address_space *mapping = sbi->node_inode->i_mapping;
+       pgoff_t index, end;
+       struct pagevec pvec;
+       int step = ino ? 2 : 0;
+       int nwritten = 0, wrote = 0;
+
+       pagevec_init(&pvec, 0);
+
+next_step:
+       index = 0;
+       end = LONG_MAX;
+
+       while (index <= end) {
+               int i, nr_pages;
+               nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
+                               PAGECACHE_TAG_DIRTY,
+                               min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
+               if (nr_pages == 0)
+                       break;
+
+               for (i = 0; i < nr_pages; i++) {
+                       struct page *page = pvec.pages[i];
+
+                       /*
+                        * flushing sequence with step:
+                        * 0. indirect nodes
+                        * 1. dentry dnodes
+                        * 2. file dnodes
+                        */
+                       if (step == 0 && IS_DNODE(page))
+                               continue;
+                       if (step == 1 && (!IS_DNODE(page) ||
+                                               is_cold_node(page)))
+                               continue;
+                       if (step == 2 && (!IS_DNODE(page) ||
+                                               !is_cold_node(page)))
+                               continue;
+
+                       /*
+                        * If an fsync mode,
+                        * we should not skip writing node pages.
+                        */
+                       if (ino && ino_of_node(page) == ino)
+                               lock_page(page);
+                       else if (!trylock_page(page))
+                               continue;
+
+                       if (unlikely(page->mapping != mapping)) {
+continue_unlock:
+                               unlock_page(page);
+                               continue;
+                       }
+                       if (ino && ino_of_node(page) != ino)
+                               goto continue_unlock;
+
+                       if (!PageDirty(page)) {
+                               /* someone wrote it for us */
+                               goto continue_unlock;
+                       }
+
+                       if (!clear_page_dirty_for_io(page))
+                               goto continue_unlock;
+
+                       /* called by fsync() */
+                       if (ino && IS_DNODE(page)) {
+                               int mark = !is_checkpointed_node(sbi, ino);
+                               set_fsync_mark(page, 1);
+                               if (IS_INODE(page))
+                                       set_dentry_mark(page, mark);
+                               nwritten++;
+                       } else {
+                               set_fsync_mark(page, 0);
+                               set_dentry_mark(page, 0);
+                       }
+                       mapping->a_ops->writepage(page, wbc);
+                       wrote++;
+
+                       if (--wbc->nr_to_write == 0)
+                               break;
+               }
+               pagevec_release(&pvec);
+               cond_resched();
+
+               if (wbc->nr_to_write == 0) {
+                       step = 2;
+                       break;
+               }
+       }
+
+       if (step < 2) {
+               step++;
+               goto next_step;
+       }
+
+       if (wrote)
+               f2fs_submit_bio(sbi, NODE, wbc->sync_mode == WB_SYNC_ALL);
+
+       return nwritten;
+}
+
+static int f2fs_write_node_page(struct page *page,
+                               struct writeback_control *wbc)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(page->mapping->host->i_sb);
+       nid_t nid;
+       unsigned int nofs;
+       block_t new_addr;
+       struct node_info ni;
+
+       if (wbc->for_reclaim) {
+               dec_page_count(sbi, F2FS_DIRTY_NODES);
+               wbc->pages_skipped++;
+               set_page_dirty(page);
+               return AOP_WRITEPAGE_ACTIVATE;
+       }
+
+       wait_on_page_writeback(page);
+
+       mutex_lock_op(sbi, NODE_WRITE);
+
+       /* get old block addr of this node page */
+       nid = nid_of_node(page);
+       nofs = ofs_of_node(page);
+       BUG_ON(page->index != nid);
+
+       get_node_info(sbi, nid, &ni);
+
+       /* This page is already truncated */
+       if (ni.blk_addr == NULL_ADDR)
+               return 0;
+
+       set_page_writeback(page);
+
+       /* insert node offset */
+       write_node_page(sbi, page, nid, ni.blk_addr, &new_addr);
+       set_node_addr(sbi, &ni, new_addr);
+       dec_page_count(sbi, F2FS_DIRTY_NODES);
+
+       mutex_unlock_op(sbi, NODE_WRITE);
+       unlock_page(page);
+       return 0;
+}
+
+static int f2fs_write_node_pages(struct address_space *mapping,
+                           struct writeback_control *wbc)
+{
+       struct f2fs_sb_info *sbi = F2FS_SB(mapping->host->i_sb);
+       struct block_device *bdev = sbi->sb->s_bdev;
+       long nr_to_write = wbc->nr_to_write;
+
+       if (wbc->for_kupdate)
+               return 0;
+
+       if (get_pages(sbi, F2FS_DIRTY_NODES) == 0)
+               return 0;
+
+       if (try_to_free_nats(sbi, NAT_ENTRY_PER_BLOCK)) {
+               write_checkpoint(sbi, false, false);
+               return 0;
+       }
+
+       /* if mounting is failed, skip writing node pages */
+       wbc->nr_to_write = bio_get_nr_vecs(bdev);
+       sync_node_pages(sbi, 0, wbc);
+       wbc->nr_to_write = nr_to_write -
+               (bio_get_nr_vecs(bdev) - wbc->nr_to_write);
+       return 0;
+}
+
+static int f2fs_set_node_page_dirty(struct page *page)
+{
+       struct address_space *mapping = page->mapping;
+       struct f2fs_sb_info *sbi = F2FS_SB(mapping->host->i_sb);
+
+       SetPageUptodate(page);
+       if (!PageDirty(page)) {
+               __set_page_dirty_nobuffers(page);
+               inc_page_count(sbi, F2FS_DIRTY_NODES);
+               SetPagePrivate(page);
+               return 1;
+       }
+       return 0;
+}
+
+static void f2fs_invalidate_node_page(struct page *page, unsigned long offset)
+{
+       struct inode *inode = page->mapping->host;
+       struct f2fs_sb_info *sbi = F2FS_SB(inode->i_sb);
+       if (PageDirty(page))
+               dec_page_count(sbi, F2FS_DIRTY_NODES);
+       ClearPagePrivate(page);
+}
+
+static int f2fs_release_node_page(struct page *page, gfp_t wait)
+{
+       ClearPagePrivate(page);
+       return 0;
+}
+
+/*
+ * Structure of the f2fs node operations
+ */
+const struct address_space_operations f2fs_node_aops = {
+       .writepage      = f2fs_write_node_page,
+       .writepages     = f2fs_write_node_pages,
+       .set_page_dirty = f2fs_set_node_page_dirty,
+       .invalidatepage = f2fs_invalidate_node_page,
+       .releasepage    = f2fs_release_node_page,
+};
+
+static struct free_nid *__lookup_free_nid_list(nid_t n, struct list_head *head)
+{
+       struct list_head *this;
+       struct free_nid *i = NULL;
+       list_for_each(this, head) {
+               i = list_entry(this, struct free_nid, list);
+               if (i->nid == n)
+                       break;
+               i = NULL;
+       }
+       return i;
+}
+
+static void __del_from_free_nid_list(struct free_nid *i)
+{
+       list_del(&i->list);
+       kmem_cache_free(free_nid_slab, i);
+}
+
+static int add_free_nid(struct f2fs_nm_info *nm_i, nid_t nid)
+{
+       struct free_nid *i;
+
+       if (nm_i->fcnt > 2 * MAX_FREE_NIDS)
+               return 0;
+retry:
+       i = kmem_cache_alloc(free_nid_slab, GFP_NOFS);
+       if (!i) {
+               cond_resched();
+               goto retry;
+       }
+       i->nid = nid;
+       i->state = NID_NEW;
+
+       spin_lock(&nm_i->free_nid_list_lock);
+       if (__lookup_free_nid_list(nid, &nm_i->free_nid_list)) {
+               spin_unlock(&nm_i->free_nid_list_lock);
+               kmem_cache_free(free_nid_slab, i);
+               return 0;
+       }
+       list_add_tail(&i->list, &nm_i->free_nid_list);
+       nm_i->fcnt++;
+       spin_unlock(&nm_i->free_nid_list_lock);
+       return 1;
+}
+
+static void remove_free_nid(struct f2fs_nm_info *nm_i, nid_t nid)
+{
+       struct free_nid *i;
+       spin_lock(&nm_i->free_nid_list_lock);
+       i = __lookup_free_nid_list(nid, &nm_i->free_nid_list);
+       if (i && i->state == NID_NEW) {
+               __del_from_free_nid_list(i);
+               nm_i->fcnt--;
+       }
+       spin_unlock(&nm_i->free_nid_list_lock);
+}
+
+static int scan_nat_page(struct f2fs_nm_info *nm_i,
+                       struct page *nat_page, nid_t start_nid)
+{
+       struct f2fs_nat_block *nat_blk = page_address(nat_page);
+       block_t blk_addr;
+       int fcnt = 0;
+       int i;
+
+       /* 0 nid should not be used */
+       if (start_nid == 0)
+               ++start_nid;
+
+       i = start_nid % NAT_ENTRY_PER_BLOCK;
+
+       for (; i < NAT_ENTRY_PER_BLOCK; i++, start_nid++) {
+               blk_addr  = le32_to_cpu(nat_blk->entries[i].block_addr);
+               BUG_ON(blk_addr == NEW_ADDR);
+               if (blk_addr == NULL_ADDR)
+                       fcnt += add_free_nid(nm_i, start_nid);
+       }
+       return fcnt;
+}
+
+static void build_free_nids(struct f2fs_sb_info *sbi)
+{
+       struct free_nid *fnid, *next_fnid;
+       struct f2fs_nm_info *nm_i = NM_I(sbi);
+       struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
+       struct f2fs_summary_block *sum = curseg->sum_blk;
+       nid_t nid = 0;
+       bool is_cycled = false;
+       int fcnt = 0;
+       int i;
+
+       nid = nm_i->next_scan_nid;
+       nm_i->init_scan_nid = nid;
+
+       ra_nat_pages(sbi, nid);
+
+       while (1) {
+               struct page *page = get_current_nat_page(sbi, nid);
+
+               fcnt += scan_nat_page(nm_i, page, nid);
+               f2fs_put_page(page, 1);
+
+               nid += (NAT_ENTRY_PER_BLOCK - (nid % NAT_ENTRY_PER_BLOCK));
+
+               if (nid >= nm_i->max_nid) {
+                       nid = 0;
+                       is_cycled = true;
+               }
+               if (fcnt > MAX_FREE_NIDS)
+                       break;
+               if (is_cycled && nm_i->init_scan_nid <= nid)
+                       break;
+       }
+
+       nm_i->next_scan_nid = nid;
+
+       /* find free nids from current sum_pages */
+       mutex_lock(&curseg->curseg_mutex);
+       for (i = 0; i < nats_in_cursum(sum); i++) {
+               block_t addr = le32_to_cpu(nat_in_journal(sum, i).block_addr);
+               nid = le32_to_cpu(nid_in_journal(sum, i));
+               if (addr == NULL_ADDR)
+                       add_free_nid(nm_i, nid);
+               else
+                       remove_free_nid(nm_i, nid);
+       }
+       mutex_unlock(&curseg->curseg_mutex);
+
+       /* remove the free nids from current allocated nids */
+       list_for_each_entry_safe(fnid, next_fnid, &nm_i->free_nid_list, list) {
+               struct nat_entry *ne;
+
+               read_lock(&nm_i->nat_tree_lock);
+               ne = __lookup_nat_cache(nm_i, fnid->nid);
+               if (ne && nat_get_blkaddr(ne) != NULL_ADDR)
+                       remove_free_nid(nm_i, fnid->nid);
+               read_unlock(&nm_i->nat_tree_lock);
+       }
+}
+
+/*
+ * If this function returns success, caller can obtain a new nid
+ * from second parameter of this function.
+ * The returned nid could be used ino as well as nid when inode is created.
+ */
+bool alloc_nid(struct f2fs_sb_info *sbi, nid_t *nid)
+{
+       struct f2fs_nm_info *nm_i = NM_I(sbi);
+       struct free_nid *i = NULL;
+       struct list_head *this;
+retry:
+       mutex_lock(&nm_i->build_lock);
+       if (!nm_i->fcnt) {
+               /* scan NAT in order to build free nid list */
+               build_free_nids(sbi);
+               if (!nm_i->fcnt) {
+                       mutex_unlock(&nm_i->build_lock);
+                       return false;
+               }
+       }
+       mutex_unlock(&nm_i->build_lock);
+
+       /*
+        * We check fcnt again since previous check is racy as
+        * we didn't hold free_nid_list_lock. So other thread
+        * could consume all of free nids.
+        */
+       spin_lock(&nm_i->free_nid_list_lock);
+       if (!nm_i->fcnt) {
+               spin_unlock(&nm_i->free_nid_list_lock);
+               goto retry;
+       }
+
+       BUG_ON(list_empty(&nm_i->free_nid_list));
+       list_for_each(this, &nm_i->free_nid_list) {
+               i = list_entry(this, struct free_nid, list);
+               if (i->state == NID_NEW)
+                       break;
+       }
+
+       BUG_ON(i->state != NID_NEW);
+       *nid = i->nid;
+       i->state = NID_ALLOC;
+       nm_i->fcnt--;
+       spin_unlock(&nm_i->free_nid_list_lock);
+       return true;
+}
+
+/*
+ * alloc_nid() should be called prior to this function.
+ */
+void alloc_nid_done(struct f2fs_sb_info *sbi, nid_t nid)
+{
+       struct f2fs_nm_info *nm_i = NM_I(sbi);
+       struct free_nid *i;
+
+       spin_lock(&nm_i->free_nid_list_lock);
+       i = __lookup_free_nid_list(nid, &nm_i->free_nid_list);
+       if (i) {
+               BUG_ON(i->state != NID_ALLOC);
+               __del_from_free_nid_list(i);
+       }
+       spin_unlock(&nm_i->free_nid_list_lock);
+}
+
+/*
+ * alloc_nid() should be called prior to this function.
+ */
+void alloc_nid_failed(struct f2fs_sb_info *sbi, nid_t nid)
+{
+       alloc_nid_done(sbi, nid);
+       add_free_nid(NM_I(sbi), nid);
+}
+
+void recover_node_page(struct f2fs_sb_info *sbi, struct page *page,
+               struct f2fs_summary *sum, struct node_info *ni,
+               block_t new_blkaddr)
+{
+       rewrite_node_page(sbi, page, sum, ni->blk_addr, new_blkaddr);
+       set_node_addr(sbi, ni, new_blkaddr);
+       clear_node_page_dirty(page);
+}
+
+int recover_inode_page(struct f2fs_sb_info *sbi, struct page *page)
+{
+       struct address_space *mapping = sbi->node_inode->i_mapping;
+       struct f2fs_node *src, *dst;
+       nid_t ino = ino_of_node(page);
+       struct node_info old_ni, new_ni;
+       struct page *ipage;
+
+       ipage = grab_cache_page(mapping, ino);
+       if (!ipage)
+               return -ENOMEM;
+
+       /* Should not use this inode  from free nid list */
+       remove_free_nid(NM_I(sbi), ino);
+
+       get_node_info(sbi, ino, &old_ni);
+       SetPageUptodate(ipage);
+       fill_node_footer(ipage, ino, ino, 0, true);
+
+       src = (struct f2fs_node *)page_address(page);
+       dst = (struct f2fs_node *)page_address(ipage);
+
+       memcpy(dst, src, (unsigned long)&src->i.i_ext - (unsigned long)&src->i);
+       dst->i.i_size = 0;
+       dst->i.i_blocks = cpu_to_le64(1);
+       dst->i.i_links = cpu_to_le32(1);
+       dst->i.i_xattr_nid = 0;
+
+       new_ni = old_ni;
+       new_ni.ino = ino;
+
+       set_node_addr(sbi, &new_ni, NEW_ADDR);
+       inc_valid_inode_count(sbi);
+
+       f2fs_put_page(ipage, 1);
+       return 0;
+}
+
+int restore_node_summary(struct f2fs_sb_info *sbi,
+                       unsigned int segno, struct f2fs_summary_block *sum)
+{
+       struct f2fs_node *rn;
+       struct f2fs_summary *sum_entry;
+       struct page *page;
+       block_t addr;
+       int i, last_offset;
+
+       /* alloc temporal page for read node */
+       page = alloc_page(GFP_NOFS | __GFP_ZERO);
+       if (IS_ERR(page))
+               return PTR_ERR(page);
+       lock_page(page);
+
+       /* scan the node segment */
+       last_offset = sbi->blocks_per_seg;
+       addr = START_BLOCK(sbi, segno);
+       sum_entry = &sum->entries[0];
+
+       for (i = 0; i < last_offset; i++, sum_entry++) {
+               if (f2fs_readpage(sbi, page, addr, READ_SYNC))
+                       goto out;
+
+               rn = (struct f2fs_node *)page_address(page);
+               sum_entry->nid = rn->footer.nid;
+               sum_entry->version = 0;
+               sum_entry->ofs_in_node = 0;
+               addr++;
+
+               /*
+                * In order to read next node page,
+                * we must clear PageUptodate flag.
+                */
+               ClearPageUptodate(page);
+       }
+out:
+       unlock_page(page);
+       __free_pages(page, 0);
+       return 0;
+}
+
+static bool flush_nats_in_journal(struct f2fs_sb_info *sbi)
+{
+       struct f2fs_nm_info *nm_i = NM_I(sbi);
+       struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
+       struct f2fs_summary_block *sum = curseg->sum_blk;
+       int i;
+
+       mutex_lock(&curseg->curseg_mutex);
+
+       if (nats_in_cursum(sum) < NAT_JOURNAL_ENTRIES) {
+               mutex_unlock(&curseg->curseg_mutex);
+               return false;
+       }
+
+       for (i = 0; i < nats_in_cursum(sum); i++) {
+               struct nat_entry *ne;
+               struct f2fs_nat_entry raw_ne;
+               nid_t nid = le32_to_cpu(nid_in_journal(sum, i));
+
+               raw_ne = nat_in_journal(sum, i);
+retry:
+               write_lock(&nm_i->nat_tree_lock);
+               ne = __lookup_nat_cache(nm_i, nid);
+               if (ne) {
+                       __set_nat_cache_dirty(nm_i, ne);
+                       write_unlock(&nm_i->nat_tree_lock);
+                       continue;
+               }
+               ne = grab_nat_entry(nm_i, nid);
+               if (!ne) {
+                       write_unlock(&nm_i->nat_tree_lock);
+                       goto retry;
+               }
+               nat_set_blkaddr(ne, le32_to_cpu(raw_ne.block_addr));
+               nat_set_ino(ne, le32_to_cpu(raw_ne.ino));
+               nat_set_version(ne, raw_ne.version);
+               __set_nat_cache_dirty(nm_i, ne);
+               write_unlock(&nm_i->nat_tree_lock);
+       }
+       update_nats_in_cursum(sum, -i);
+       mutex_unlock(&curseg->curseg_mutex);
+       return true;
+}
+
+/*
+ * This function is called during the checkpointing process.
+ */
+void flush_nat_entries(struct f2fs_sb_info *sbi)
+{
+       struct f2fs_nm_info *nm_i = NM_I(sbi);
+       struct curseg_info *curseg = CURSEG_I(sbi, CURSEG_HOT_DATA);
+       struct f2fs_summary_block *sum = curseg->sum_blk;
+       struct list_head *cur, *n;
+       struct page *page = NULL;
+       struct f2fs_nat_block *nat_blk = NULL;
+       nid_t start_nid = 0, end_nid = 0;
+       bool flushed;
+
+       flushed = flush_nats_in_journal(sbi);
+
+       if (!flushed)
+               mutex_lock(&curseg->curseg_mutex);
+
+       /* 1) flush dirty nat caches */
+       list_for_each_safe(cur, n, &nm_i->dirty_nat_entries) {
+               struct nat_entry *ne;
+               nid_t nid;
+               struct f2fs_nat_entry raw_ne;
+               int offset = -1;
+               block_t old_blkaddr, new_blkaddr;
+
+               ne = list_entry(cur, struct nat_entry, list);
+               nid = nat_get_nid(ne);
+
+               if (nat_get_blkaddr(ne) == NEW_ADDR)
+                       continue;
+               if (flushed)
+                       goto to_nat_page;
+
+               /* if there is room for nat enries in curseg->sumpage */
+               offset = lookup_journal_in_cursum(sum, NAT_JOURNAL, nid, 1);
+               if (offset >= 0) {
+                       raw_ne = nat_in_journal(sum, offset);
+                       old_blkaddr = le32_to_cpu(raw_ne.block_addr);
+                       goto flush_now;
+               }
+to_nat_page:
+               if (!page || (start_nid > nid || nid > end_nid)) {
+                       if (page) {
+                               f2fs_put_page(page, 1);
+                               page = NULL;
+                       }
+                       start_nid = START_NID(nid);
+                       end_nid = start_nid + NAT_ENTRY_PER_BLOCK - 1;
+
+                       /*
+                        * get nat block with dirty flag, increased reference
+                        * count, mapped and lock
+                        */
+                       page = get_next_nat_page(sbi, start_nid);
+                       nat_blk = page_address(page);
+               }
+
+               BUG_ON(!nat_blk);
+               raw_ne = nat_blk->entries[nid - start_nid];
+               old_blkaddr = le32_to_cpu(raw_ne.block_addr);
+flush_now:
+               new_blkaddr = nat_get_blkaddr(ne);
+
+               raw_ne.ino = cpu_to_le32(nat_get_ino(ne));
+               raw_ne.block_addr = cpu_to_le32(new_blkaddr);
+               raw_ne.version = nat_get_version(ne);
+
+               if (offset < 0) {
+                       nat_blk->entries[nid - start_nid] = raw_ne;
+               } else {
+                       nat_in_journal(sum, offset) = raw_ne;
+                       nid_in_journal(sum, offset) = cpu_to_le32(nid);
+               }
+
+               if (nat_get_blkaddr(ne) == NULL_ADDR) {
+                       write_lock(&nm_i->nat_tree_lock);
+                       __del_from_nat_cache(nm_i, ne);
+                       write_unlock(&nm_i->nat_tree_lock);
+
+                       /* We can reuse this freed nid at this point */
+                       add_free_nid(NM_I(sbi), nid);
+               } else {
+                       write_lock(&nm_i->nat_tree_lock);
+                       __clear_nat_cache_dirty(nm_i, ne);
+                       ne->checkpointed = true;
+                       write_unlock(&nm_i->nat_tree_lock);
+               }
+       }
+       if (!flushed)
+               mutex_unlock(&curseg->curseg_mutex);
+       f2fs_put_page(page, 1);
+
+       /* 2) shrink nat caches if necessary */
+       try_to_free_nats(sbi, nm_i->nat_cnt - NM_WOUT_THRESHOLD);
+}
+
+static 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;
+
+       INIT_LIST_HEAD(&nm_i->free_nid_list);
+       INIT_RADIX_TREE(&nm_i->nat_root, GFP_ATOMIC);
+       INIT_LIST_HEAD(&nm_i->nat_entries);
+       INIT_LIST_HEAD(&nm_i->dirty_nat_entries);
+
+       mutex_init(&nm_i->build_lock);
+       spin_lock_init(&nm_i->free_nid_list_lock);
+       rwlock_init(&nm_i->nat_tree_lock);
+
+       nm_i->bitmap_size = __bitmap_size(sbi, NAT_BITMAP);
+       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->nat_bitmap = kzalloc(nm_i->bitmap_size, GFP_KERNEL);
+       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 = kzalloc(sizeof(struct f2fs_nm_info), GFP_KERNEL);
+       if (!sbi->nm_info)
+               return -ENOMEM;
+
+       err = init_node_manager(sbi);
+       if (err)
+               return err;
+
+       build_free_nids(sbi);
+       return 0;
+}
+
+void destroy_node_manager(struct f2fs_sb_info *sbi)
+{
+       struct f2fs_nm_info *nm_i = NM_I(sbi);
+       struct free_nid *i, *next_i;
+       struct nat_entry *natvec[NATVEC_SIZE];
+       nid_t nid = 0;
+       unsigned int found;
+
+       if (!nm_i)
+               return;
+
+       /* destroy free nid list */
+       spin_lock(&nm_i->free_nid_list_lock);
+       list_for_each_entry_safe(i, next_i, &nm_i->free_nid_list, list) {
+               BUG_ON(i->state == NID_ALLOC);
+               __del_from_free_nid_list(i);
+               nm_i->fcnt--;
+       }
+       BUG_ON(nm_i->fcnt);
+       spin_unlock(&nm_i->free_nid_list_lock);
+
+       /* destroy nat cache */
+       write_lock(&nm_i->nat_tree_lock);
+       while ((found = __gang_lookup_nat_cache(nm_i,
+                                       nid, NATVEC_SIZE, natvec))) {
+               unsigned idx;
+               for (idx = 0; idx < found; idx++) {
+                       struct nat_entry *e = natvec[idx];
+                       nid = nat_get_nid(e) + 1;
+                       __del_from_nat_cache(nm_i, e);
+               }
+       }
+       BUG_ON(nm_i->nat_cnt);
+       write_unlock(&nm_i->nat_tree_lock);
+
+       kfree(nm_i->nat_bitmap);
+       sbi->nm_info = NULL;
+       kfree(nm_i);
+}
+
+int create_node_manager_caches(void)
+{
+       nat_entry_slab = f2fs_kmem_cache_create("nat_entry",
+                       sizeof(struct nat_entry), NULL);
+       if (!nat_entry_slab)
+               return -ENOMEM;
+
+       free_nid_slab = f2fs_kmem_cache_create("free_nid",
+                       sizeof(struct free_nid), NULL);
+       if (!free_nid_slab) {
+               kmem_cache_destroy(nat_entry_slab);
+               return -ENOMEM;