[PATCH] F2FS support

* [PATCH] F2FS support
@ 2015-03-24  8:19 Jaegeuk Kim
  2015-03-28  7:31 ` Andrei Borzenkov
  0 siblings, 1 reply; 18+ messages in thread
From: Jaegeuk Kim @ 2015-03-24  8:19 UTC (permalink / raw)
  To: grub-devel, linux-f2fs-devel; +Cc: Jaegeuk Kim

 * Makefile.util.def: Add f2fs.c.
 * doc/grub.texi: Add f2fs description.
 * grub-core/Makefile.core.def: Add f2fs module.
 * grub-core/fs/f2fs.c: New file.
 * tests/f2fs_test.in: New file.
 * tests/util/grub-fs-tester.in: Add f2fs requirements.

Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
---
 ChangeLog-2015               |   11 +
 Makefile.util.def            |    7 +
 docs/grub.texi               |    5 +-
 grub-core/Makefile.core.def  |    5 +
 grub-core/fs/f2fs.c          | 1321 ++++++++++++++++++++++++++++++++++++++++++
 po/exclude.pot               |    1 +
 tests/f2fs_test.in           |   19 +
 tests/util/grub-fs-tester.in |   14 +-
 8 files changed, 1378 insertions(+), 5 deletions(-)
 create mode 100644 grub-core/fs/f2fs.c
 create mode 100644 tests/f2fs_test.in

diff --git a/ChangeLog-2015 b/ChangeLog-2015
index 869f6bf..59351de 100644
--- a/ChangeLog-2015
+++ b/ChangeLog-2015
@@ -1,3 +1,14 @@
+2015-03-12  Jaegeuk Kim <jaegeuk@kernel.org>
+
+	F2FS support.
+
+	* Makefile.util.def: Add f2fs.c.
+	* doc/grub.texi: Add f2fs description.
+	* grub-core/Makefile.core.def: Add f2fs module.
+	* grub-core/fs/f2fs.c: New file.
+	* tests/f2fs_test.in: New file.
+	* tests/util/grub-fs-tester.in: Add f2fs requirements.
+
 2015-01-23  Vladimir Serbinenko  <phcoder@gmail.com>
 
 	* tests/file_filter/file: Really add missing file.
diff --git a/Makefile.util.def b/Makefile.util.def
index 67dfb29..0b17907 100644
--- a/Makefile.util.def
+++ b/Makefile.util.def
@@ -98,6 +98,7 @@ library = {
   common = grub-core/fs/newc.c;
   common = grub-core/fs/ext2.c;
   common = grub-core/fs/fat.c;
+  common = grub-core/fs/f2fs.c;
   common = grub-core/fs/exfat.c;
   common = grub-core/fs/fshelp.c;
   common = grub-core/fs/hfs.c;
@@ -767,6 +768,12 @@ script = {
 
 script = {
   testcase;
+  name = f2fs_test;
+  common = tests/f2fs_test.in;
+};
+
+script = {
+  testcase;
   name = nilfs2_test;
   common = tests/nilfs2_test.in;
 };
diff --git a/docs/grub.texi b/docs/grub.texi
index 46b9e7f..edf4eea 100644
--- a/docs/grub.texi
+++ b/docs/grub.texi
@@ -360,7 +360,8 @@ blocklist notation. The currently supported filesystem types are @dfn{Amiga
 Fast FileSystem (AFFS)}, @dfn{AtheOS fs}, @dfn{BeFS},
 @dfn{BtrFS} (including raid0, raid1, raid10, gzip and lzo),
 @dfn{cpio} (little- and big-endian bin, odc and newc variants),
-@dfn{Linux ext2/ext3/ext4}, @dfn{DOS FAT12/FAT16/FAT32}, @dfn{exFAT}, @dfn{HFS},
+@dfn{Linux ext2/ext3/ext4}, @dfn{DOS FAT12/FAT16/FAT32}, @dfn{f2fs},
+@dfn{exFAT}, @dfn{HFS},
 @dfn{HFS+}, @dfn{ISO9660} (including Joliet, Rock-ridge and multi-chunk files),
 @dfn{JFS}, @dfn{Minix fs} (versions 1, 2 and 3), @dfn{nilfs2},
 @dfn{NTFS} (including compression), @dfn{ReiserFS}, @dfn{ROMFS},
@@ -5289,7 +5290,7 @@ NTFS, JFS, UDF, HFS+, exFAT, long filenames in FAT, Joliet part of
 ISO9660 are treated as UTF-16 as per specification. AFS and BFS are read
 as UTF-8, again according to specification. BtrFS, cpio, tar, squash4, minix,
 minix2, minix3, ROMFS, ReiserFS, XFS, ext2, ext3, ext4, FAT (short names),
-RockRidge part of ISO9660, nilfs2, UFS1, UFS2 and ZFS are assumed
+f2fs, RockRidge part of ISO9660, nilfs2, UFS1, UFS2 and ZFS are assumed
 to be UTF-8. This might be false on systems configured with legacy charset
 but as long as the charset used is superset of ASCII you should be able to
 access ASCII-named files. And it's recommended to configure your system to use
diff --git a/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
index 8eaae45..3fcd07e 100644
--- a/grub-core/Makefile.core.def
+++ b/grub-core/Makefile.core.def
@@ -1281,6 +1281,11 @@ module = {
 };
 
 module = {
+  name = f2fs;
+  common = fs/f2fs.c;
+};
+
+module = {
   name = exfat;
   common = fs/exfat.c;
 };
diff --git a/grub-core/fs/f2fs.c b/grub-core/fs/f2fs.c
new file mode 100644
index 0000000..40360d5
--- /dev/null
+++ b/grub-core/fs/f2fs.c
@@ -0,0 +1,1321 @@
+/*
+ *  f2fs.c - Flash-Friendly File System
+ *
+ *  Written by Jaegeuk Kim <jaegeuk@kernel.org>
+ *
+ *  Copyright (C) 2015  Free Software Foundation, Inc.
+ *
+ *  GRUB is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  GRUB is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <grub/err.h>
+#include <grub/file.h>
+#include <grub/mm.h>
+#include <grub/misc.h>
+#include <grub/disk.h>
+#include <grub/dl.h>
+#include <grub/types.h>
+#include <grub/charset.h>
+#include <grub/fshelp.h>
+
+GRUB_MOD_LICENSE ("GPLv3+");
+
+/* F2FS Magic Number */
+#define F2FS_SUPER_MAGIC	0xF2F52010
+
+/* byte-size offset */
+#define F2FS_SUPER_OFFSET		1024
+
+/* 12 bits for 4096 bytes */
+#define F2FS_MAX_LOG_SECTOR_SIZE	12
+
+/* 9 bits for 512 bytes */
+#define F2FS_MIN_LOG_SECTOR_SIZE	9
+
+/* support only 4KB block */
+#define F2FS_BLKSIZE			4096
+#define F2FS_BLK_BITS			12
+#define F2FS_BLK_SEC_BITS		(3)
+
+#define VERSION_LEN	256
+#define F2FS_MAX_EXTENSION		64
+
+#define CP_COMPACT_SUM_FLAG	0x00000004
+#define CP_UMOUNT_FLAG		0x00000001
+
+#define MAX_ACTIVE_LOGS	16
+#define MAX_ACTIVE_NODE_LOGS	8
+#define MAX_ACTIVE_DATA_LOGS	8
+#define	NR_CURSEG_DATA_TYPE	(3)
+#define NR_CURSEG_NODE_TYPE	(3)
+#define NR_CURSEG_TYPE	(NR_CURSEG_DATA_TYPE + NR_CURSEG_NODE_TYPE)
+
+#define ENTRIES_IN_SUM		512
+#define	SUMMARY_SIZE		(7)
+#define	SUM_FOOTER_SIZE		(5)
+#define JENTRY_SIZE		(13)
+#define SUM_ENTRIES_SIZE	(SUMMARY_SIZE * ENTRIES_IN_SUM)
+#define SUM_JOURNAL_SIZE	(F2FS_BLKSIZE - SUM_FOOTER_SIZE -\
+				SUM_ENTRIES_SIZE)
+#define NAT_JOURNAL_ENTRIES	((SUM_JOURNAL_SIZE - 2) / JENTRY_SIZE)
+#define NAT_JOURNAL_RESERVED	((SUM_JOURNAL_SIZE - 2) % JENTRY_SIZE)
+
+#define NAT_ENTRY_SIZE (9)
+#define NAT_ENTRY_PER_BLOCK (F2FS_BLKSIZE / NAT_ENTRY_SIZE)
+
+#define ver_after (a, b) (typecheck (unsigned long long, a) &&          \
+		typecheck (unsigned long long, b) &&                    \
+		((long long)((a) - (b)) > 0))
+
+#define F2FS_NAME_LEN		255
+#define F2FS_SLOT_LEN		8
+#define NR_DENTRY_IN_BLOCK	214
+#define SIZE_OF_DIR_ENTRY	11	/* by byte */
+#define BITS_PER_BYTE		8
+#define SIZE_OF_DENTRY_BITMAP	((NR_DENTRY_IN_BLOCK + BITS_PER_BYTE - 1) / \
+					BITS_PER_BYTE)
+#define SIZE_OF_RESERVED	(F2FS_BLKSIZE - ((SIZE_OF_DIR_ENTRY + \
+				F2FS_SLOT_LEN) * \
+				NR_DENTRY_IN_BLOCK + SIZE_OF_DENTRY_BITMAP))
+
+#define F2FS_INLINE_XATTR_ADDRS	50	/* 200 bytes for inline xattrs */
+#define DEF_ADDRS_PER_INODE	923	/* Address Pointers in an Inode */
+
+#define ADDRS_PER_BLOCK		1018	/* Address Pointers in a Direct Block */
+#define NIDS_PER_BLOCK		1018	/* Node IDs in an Indirect Block */
+#define	NODE_DIR1_BLOCK		(DEF_ADDRS_PER_INODE + 1)
+#define	NODE_DIR2_BLOCK		(DEF_ADDRS_PER_INODE + 2)
+#define	NODE_IND1_BLOCK		(DEF_ADDRS_PER_INODE + 3)
+#define	NODE_IND2_BLOCK		(DEF_ADDRS_PER_INODE + 4)
+#define	NODE_DIND_BLOCK		(DEF_ADDRS_PER_INODE + 5)
+
+#define MAX_INLINE_DATA		(4 * (DEF_ADDRS_PER_INODE - \
+						F2FS_INLINE_XATTR_ADDRS - 1))
+#define NR_INLINE_DENTRY	(MAX_INLINE_DATA * BITS_PER_BYTE / \
+				((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
+				BITS_PER_BYTE + 1))
+#define INLINE_DENTRY_BITMAP_SIZE	((NR_INLINE_DENTRY + \
+					BITS_PER_BYTE - 1) / BITS_PER_BYTE)
+#define INLINE_RESERVED_SIZE	(MAX_INLINE_DATA - \
+				((SIZE_OF_DIR_ENTRY + F2FS_SLOT_LEN) * \
+				NR_INLINE_DENTRY + INLINE_DENTRY_BITMAP_SIZE))
+#define CURSEG_HOT_DATA	0
+
+enum
+  {
+    FI_INLINE_XATTR = 9,
+    FI_INLINE_DATA = 10,
+    FI_INLINE_DENTRY = 11,
+    FI_DATA_EXIST = 18,
+  };
+
+enum FILE_TYPE
+  {
+  F2FS_FT_UNKNOWN,
+  F2FS_FT_REG_FILE = 1,
+  F2FS_FT_DIR = 2,
+  F2FS_FT_SYMLINK = 7,
+  };
+
+struct grub_f2fs_superblock
+{
+  grub_uint32_t magic;
+  grub_uint16_t dummy1[2];
+  grub_uint32_t log_sectorsize;
+  grub_uint32_t log_sectors_per_block;
+  grub_uint32_t log_blocksize;
+  grub_uint32_t log_blocks_per_seg;
+  grub_uint32_t segs_per_sec;
+  grub_uint32_t secs_per_zone;
+  grub_uint32_t checksum_offset;
+  grub_uint8_t dummy2[40];
+  grub_uint32_t cp_blkaddr;
+  grub_uint32_t sit_blkaddr;
+  grub_uint32_t nat_blkaddr;
+  grub_uint32_t ssa_blkaddr;
+  grub_uint32_t main_blkaddr;
+  grub_uint32_t root_ino;
+  grub_uint32_t node_ino;
+  grub_uint32_t meta_ino;
+  grub_uint8_t uuid[16];
+  grub_uint16_t volume_name[512];
+  grub_uint32_t extension_count;
+  grub_uint8_t extension_list[F2FS_MAX_EXTENSION][8];
+  grub_uint32_t cp_payload;
+  grub_uint8_t version[VERSION_LEN];
+  grub_uint8_t init_version[VERSION_LEN];
+} GRUB_PACKED;
+
+struct grub_f2fs_checkpoint
+{
+  grub_uint64_t checkpoint_ver;
+  grub_uint64_t user_block_count;
+  grub_uint64_t valid_block_count;
+  grub_uint32_t rsvd_segment_count;
+  grub_uint32_t overprov_segment_count;
+  grub_uint32_t free_segment_count;
+  grub_uint32_t cur_node_segno[MAX_ACTIVE_NODE_LOGS];
+  grub_uint16_t cur_node_blkoff[MAX_ACTIVE_NODE_LOGS];
+  grub_uint32_t cur_data_segno[MAX_ACTIVE_DATA_LOGS];
+  grub_uint16_t cur_data_blkoff[MAX_ACTIVE_DATA_LOGS];
+  grub_uint32_t ckpt_flags;
+  grub_uint32_t cp_pack_total_block_count;
+  grub_uint32_t cp_pack_start_sum;
+  grub_uint32_t valid_node_count;
+  grub_uint32_t valid_inode_count;
+  grub_uint32_t next_free_nid;
+  grub_uint32_t sit_ver_bitmap_bytesize;
+  grub_uint32_t nat_ver_bitmap_bytesize;
+  grub_uint32_t checksum_offset;
+  grub_uint64_t elapsed_time;
+  grub_uint8_t alloc_type[MAX_ACTIVE_LOGS];
+  grub_uint8_t sit_nat_version_bitmap[3900];
+  grub_uint32_t checksum;
+} GRUB_PACKED;
+
+struct grub_f2fs_nat_entry {
+  grub_uint8_t version;
+  grub_uint32_t ino;
+  grub_uint32_t block_addr;
+} GRUB_PACKED;
+
+struct grub_f2fs_nat_jent
+{
+  grub_uint32_t nid;
+  struct grub_f2fs_nat_entry ne;
+} GRUB_PACKED;
+
+struct grub_f2fs_nat_journal {
+  grub_uint16_t n_nats;
+  struct grub_f2fs_nat_jent entries[NAT_JOURNAL_ENTRIES];
+  grub_uint8_t reserved[NAT_JOURNAL_RESERVED];
+} GRUB_PACKED;
+
+struct grub_f2fs_nat_block {
+  struct grub_f2fs_nat_entry ne[NAT_ENTRY_PER_BLOCK];
+} GRUB_PACKED;
+
+struct grub_f2fs_dir_entry
+{
+  grub_uint32_t hash_code;
+  grub_uint32_t ino;
+  grub_uint16_t name_len;
+  grub_uint8_t file_type;
+} GRUB_PACKED;
+
+struct grub_f2fs_inline_dentry
+{
+  grub_uint8_t dentry_bitmap[INLINE_DENTRY_BITMAP_SIZE];
+  grub_uint8_t reserved[INLINE_RESERVED_SIZE];
+  struct grub_f2fs_dir_entry dentry[NR_INLINE_DENTRY];
+  grub_uint8_t filename[NR_INLINE_DENTRY][F2FS_SLOT_LEN];
+} GRUB_PACKED;
+
+struct grub_f2fs_dentry_block {
+  grub_uint8_t dentry_bitmap[SIZE_OF_DENTRY_BITMAP];
+  grub_uint8_t reserved[SIZE_OF_RESERVED];
+  struct grub_f2fs_dir_entry dentry[NR_DENTRY_IN_BLOCK];
+  grub_uint8_t filename[NR_DENTRY_IN_BLOCK][F2FS_SLOT_LEN];
+} GRUB_PACKED;
+
+struct grub_f2fs_inode
+{
+  grub_uint16_t i_mode;
+  grub_uint8_t i_advise;
+  grub_uint8_t i_inline;
+  grub_uint32_t i_uid;
+  grub_uint32_t i_gid;
+  grub_uint32_t i_links;
+  grub_uint64_t i_size;
+  grub_uint64_t i_blocks;
+  grub_uint64_t i_atime;
+  grub_uint64_t i_ctime;
+  grub_uint64_t i_mtime;
+  grub_uint32_t i_atime_nsec;
+  grub_uint32_t i_ctime_nsec;
+  grub_uint32_t i_mtime_nsec;
+  grub_uint32_t i_generation;
+  grub_uint32_t i_current_depth;
+  grub_uint32_t i_xattr_nid;
+  grub_uint32_t i_flags;
+  grub_uint32_t i_pino;
+  grub_uint32_t i_namelen;
+  grub_uint8_t i_name[F2FS_NAME_LEN];
+  grub_uint8_t i_dir_level;
+  grub_uint8_t i_ext[12];
+  grub_uint32_t i_addr[DEF_ADDRS_PER_INODE];
+  grub_uint32_t i_nid[5];
+} GRUB_PACKED;
+
+struct grub_direct_node {
+  grub_uint32_t addr[ADDRS_PER_BLOCK];
+} GRUB_PACKED;
+
+struct grub_indirect_node {
+  grub_uint32_t nid[NIDS_PER_BLOCK];
+} GRUB_PACKED;
+
+struct grub_f2fs_node
+{
+  union
+  {
+    struct grub_f2fs_inode i;
+    struct grub_direct_node dn;
+    struct grub_indirect_node in;
+  };
+  grub_uint8_t dummy[40];
+} GRUB_PACKED;
+
+struct grub_fshelp_node
+{
+  struct grub_f2fs_data *data;
+  struct grub_f2fs_node inode;
+  grub_uint32_t ino;
+  int inode_read;
+};
+
+struct grub_f2fs_data
+{
+  struct grub_f2fs_superblock sblock;
+  struct grub_f2fs_checkpoint ckpt;
+
+  grub_uint32_t root_ino;
+  grub_uint32_t blocks_per_seg;
+  grub_uint32_t cp_blkaddr;
+  grub_uint32_t nat_blkaddr;
+
+  struct grub_f2fs_nat_journal nat_j;
+  char *nat_bitmap;
+
+  grub_disk_t disk;
+  struct grub_f2fs_node *inode;
+  struct grub_fshelp_node diropen;
+};
+
+struct grub_f2fs_dir_iter_ctx
+{
+  struct grub_f2fs_data *data;
+  grub_fshelp_iterate_dir_hook_t hook;
+  void *hook_data;
+  grub_uint32_t *bitmap;
+  grub_uint8_t (*filename)[F2FS_SLOT_LEN];
+  struct grub_f2fs_dir_entry *dentry;
+  int max;
+};
+
+struct grub_f2fs_dir_ctx
+{
+  grub_fs_dir_hook_t hook;
+  void *hook_data;
+  struct grub_f2fs_data *data;
+};
+
+static grub_dl_t my_mod;
+
+static inline int
+__test_bit (int nr, grub_uint32_t *addr)
+{
+  return 1UL & (addr[nr / 32] >> (nr & (31)));
+}
+
+static inline char *
+__inline_addr (struct grub_f2fs_inode *inode)
+{
+  return (char *)&(inode->i_addr[1]);
+}
+
+static inline grub_uint64_t
+__i_size (struct grub_f2fs_inode *inode)
+{
+  return grub_le_to_cpu64 (inode->i_size);
+}
+
+static inline grub_uint32_t
+__start_cp_addr (struct grub_f2fs_data *data)
+{
+  struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
+  grub_uint64_t ckpt_version = grub_le_to_cpu64 (ckpt->checkpoint_ver);
+  grub_uint32_t start_addr = data->cp_blkaddr;
+
+  if (!(ckpt_version & 1))
+    return start_addr + data->blocks_per_seg;
+  return start_addr;
+}
+
+static inline grub_uint32_t
+__start_sum_block (struct grub_f2fs_data *data)
+{
+  struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
+
+  return __start_cp_addr (data) + grub_le_to_cpu32 (ckpt->cp_pack_start_sum);
+}
+
+static inline grub_uint32_t
+__sum_blk_addr (struct grub_f2fs_data *data, int base, int type)
+{
+  struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
+
+  return __start_cp_addr (data) +
+		grub_le_to_cpu32 (ckpt->cp_pack_total_block_count)
+		- (base + 1) + type;
+}
+
+static inline int
+__ckpt_flag_set (struct grub_f2fs_checkpoint *ckpt, unsigned int f)
+{
+  grub_uint32_t ckpt_flags = grub_le_to_cpu32 (ckpt->ckpt_flags);
+  return ckpt_flags & f;
+}
+
+static inline int
+__inode_flag_set (struct grub_f2fs_inode *inode, int flag)
+{
+  grub_uint32_t i_flags = grub_le_to_cpu32 (inode->i_flags);
+  return __test_bit (flag, &i_flags);
+}
+
+static inline grub_uint32_t
+__nat_bitmap_size (struct grub_f2fs_data *data)
+{
+  struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
+
+  return grub_le_to_cpu32 (ckpt->nat_ver_bitmap_bytesize);
+}
+
+static inline void *
+__nat_bitmap_ptr (struct grub_f2fs_data *data)
+{
+  struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
+  grub_uint32_t offset;
+
+  if (grub_le_to_cpu32 (data->sblock.cp_payload) > 0)
+    return ckpt->sit_nat_version_bitmap;
+
+  offset = grub_le_to_cpu32 (ckpt->sit_ver_bitmap_bytesize);
+  return ckpt->sit_nat_version_bitmap + offset;
+}
+
+static inline grub_uint32_t
+__get_node_id (struct grub_f2fs_node *rn, int off, int i)
+{
+  if (i)
+    return grub_le_to_cpu32 (rn->i.i_nid[off - NODE_DIR1_BLOCK]);
+  return grub_le_to_cpu32 (rn->in.nid[off]);
+}
+
+static inline grub_err_t
+grub_f2fs_block_read (struct grub_f2fs_data *data, grub_uint32_t blkaddr, void *buf)
+{
+  return grub_disk_read (data->disk, blkaddr << F2FS_BLK_SEC_BITS,
+					0, F2FS_BLKSIZE, buf);
+}
+
+/*
+ * CRC32
+ */
+#define CRCPOLY_LE 0xedb88320
+
+static inline grub_uint32_t
+grub_f2fs_cal_crc32 (grub_uint32_t crc, void *buf, int len)
+{
+  int i;
+  unsigned char *p = (unsigned char *)buf;
+
+  while (len--)
+    {
+      crc ^= *p++;
+      for (i = 0; i < 8; i++)
+        crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
+    }
+  return crc;
+}
+
+static inline int
+grub_f2fs_crc_valid (grub_uint32_t blk_crc, void *buf, int len)
+{
+  grub_uint32_t cal_crc = 0;
+
+  cal_crc = grub_f2fs_cal_crc32 (F2FS_SUPER_MAGIC, buf, len);
+
+  return (cal_crc == blk_crc) ? 1 : 0;
+}
+
+static inline int
+grub_f2fs_test_bit (grub_uint32_t nr, const char *p)
+{
+  int mask;
+  char *addr = (char *)p;
+
+  addr += (nr >> 3);
+  mask = 1 << (7 - (nr & 0x07));
+  return (mask & *addr) != 0;
+}
+
+static int
+grub_f2fs_sanity_check_sb (struct grub_f2fs_superblock *sb)
+{
+  unsigned int blocksize;
+
+  if (F2FS_SUPER_MAGIC != grub_le_to_cpu32 (sb->magic))
+    return -1;
+
+  blocksize = 1 << grub_le_to_cpu32 (sb->log_blocksize);
+  if (blocksize != F2FS_BLKSIZE)
+    return -1;
+
+  if (grub_le_to_cpu32 (sb->log_sectorsize) > F2FS_MAX_LOG_SECTOR_SIZE)
+    return -1;
+
+  if (grub_le_to_cpu32 (sb->log_sectorsize) < F2FS_MIN_LOG_SECTOR_SIZE)
+    return -1;
+
+  if (grub_le_to_cpu32 (sb->log_sectors_per_block) +
+      grub_le_to_cpu32 (sb->log_sectorsize) != F2FS_MAX_LOG_SECTOR_SIZE)
+    return -1;
+
+  return 0;
+}
+
+static grub_err_t
+grub_f2fs_read_sb (struct grub_f2fs_data *data, int block)
+{
+  grub_disk_t disk = data->disk;
+  grub_uint64_t offset;
+  grub_err_t err;
+
+  if (block == 0)
+    offset = F2FS_SUPER_OFFSET;
+  else
+    offset = F2FS_BLKSIZE + F2FS_SUPER_OFFSET;
+
+  /* Read first super block. */
+  err = grub_disk_read (disk, offset >> GRUB_DISK_SECTOR_BITS, 0,
+			sizeof (data->sblock), &data->sblock);
+  if (err)
+    return err;
+
+  if (grub_f2fs_sanity_check_sb (&data->sblock))
+    err = GRUB_ERR_BAD_FS;
+
+  return err;
+}
+
+static void *
+validate_checkpoint (struct grub_f2fs_data *data, grub_uint32_t cp_addr,
+						grub_uint64_t *version)
+{
+  void *cp_page_1, *cp_page_2;
+  struct grub_f2fs_checkpoint *cp_block;
+  grub_uint64_t cur_version = 0, pre_version = 0;
+  grub_uint32_t crc = 0;
+  grub_uint32_t crc_offset;
+  grub_err_t err;
+
+  /* Read the 1st cp block in this CP pack */
+  cp_page_1 = grub_malloc (F2FS_BLKSIZE);
+  if (!cp_page_1)
+    return NULL;
+
+  err = grub_f2fs_block_read (data, cp_addr, cp_page_1);
+  if (err)
+    goto invalid_cp1;
+
+  cp_block = (struct grub_f2fs_checkpoint *)cp_page_1;
+  crc_offset = grub_le_to_cpu32 (cp_block->checksum_offset);
+  if (crc_offset >= F2FS_BLKSIZE)
+    goto invalid_cp1;
+
+  crc = *(grub_uint32_t *)((char *)cp_block + crc_offset);
+  if (!grub_f2fs_crc_valid (crc, cp_block, crc_offset))
+    goto invalid_cp1;
+
+  pre_version = grub_le_to_cpu64 (cp_block->checkpoint_ver);
+
+  /* Read the 2nd cp block in this CP pack */
+  cp_page_2 = grub_malloc (F2FS_BLKSIZE);
+  if (!cp_page_2)
+    goto invalid_cp1;
+
+  cp_addr += grub_le_to_cpu32 (cp_block->cp_pack_total_block_count) - 1;
+
+  err = grub_f2fs_block_read (data, cp_addr, cp_page_2);
+  if (err)
+    goto invalid_cp2;
+
+  cp_block = (struct grub_f2fs_checkpoint *)cp_page_2;
+  crc_offset = grub_le_to_cpu32 (cp_block->checksum_offset);
+  if (crc_offset >= F2FS_BLKSIZE)
+    goto invalid_cp2;
+
+  crc = *(grub_uint32_t *)((char *)cp_block + crc_offset);
+  if (!grub_f2fs_crc_valid (crc, cp_block, crc_offset))
+    goto invalid_cp2;
+
+  cur_version = grub_le_to_cpu64 (cp_block->checkpoint_ver);
+  if (cur_version == pre_version)
+    {
+      *version = cur_version;
+      grub_free (cp_page_2);
+      return cp_page_1;
+    }
+
+invalid_cp2:
+  grub_free (cp_page_2);
+invalid_cp1:
+  grub_free (cp_page_1);
+  return NULL;
+}
+
+static grub_err_t
+grub_f2fs_read_cp (struct grub_f2fs_data *data)
+{
+  void *cp1, *cp2, *cur_page;
+  grub_uint64_t cp1_version = 0, cp2_version = 0;
+  grub_uint64_t cp_start_blk_no;
+
+  /*
+   * Finding out valid cp block involves read both
+   * sets (cp pack1 and cp pack 2)
+   */
+  cp_start_blk_no = data->cp_blkaddr;
+  cp1 = validate_checkpoint (data, cp_start_blk_no, &cp1_version);
+  if (!cp1 && grub_errno)
+      return grub_errno;
+
+  /* The second checkpoint pack should start at the next segment */
+  cp_start_blk_no += data->blocks_per_seg;
+  cp2 = validate_checkpoint (data, cp_start_blk_no, &cp2_version);
+  if (!cp2 && grub_errno)
+    {
+      grub_free (cp1);
+      return grub_errno;
+    }
+
+  if (cp1 && cp2)
+    cur_page = (cp2_version > cp1_version) ? cp2 : cp1;
+  else if (cp1)
+    cur_page = cp1;
+  else if (cp2)
+    cur_page = cp2;
+  else
+    return grub_error (GRUB_ERR_BAD_FS, "no checkpoints\n");
+
+  grub_memcpy (&data->ckpt, cur_page, F2FS_BLKSIZE);
+
+  grub_free (cp1);
+  grub_free (cp2);
+  return 0;
+}
+
+static int
+get_nat_journal (struct grub_f2fs_data *data)
+{
+  grub_uint32_t block;
+  char *buf;
+  grub_err_t err;
+
+  buf = grub_malloc (F2FS_BLKSIZE);
+  if (!buf)
+    return grub_errno;
+
+  if (__ckpt_flag_set (&data->ckpt, CP_COMPACT_SUM_FLAG))
+    block = __start_sum_block (data);
+  else if (__ckpt_flag_set (&data->ckpt, CP_UMOUNT_FLAG))
+    block = __sum_blk_addr (data, NR_CURSEG_TYPE, CURSEG_HOT_DATA);
+  else
+    block = __sum_blk_addr (data, NR_CURSEG_DATA_TYPE, CURSEG_HOT_DATA);
+
+  err = grub_f2fs_block_read (data, block, buf);
+  if (err)
+    goto fail;
+
+  if (__ckpt_flag_set (&data->ckpt, CP_COMPACT_SUM_FLAG))
+    grub_memcpy (&data->nat_j, buf, SUM_JOURNAL_SIZE);
+  else
+    grub_memcpy (&data->nat_j, buf + SUM_ENTRIES_SIZE, SUM_JOURNAL_SIZE);
+
+fail:
+  grub_free (buf);
+  return err;
+}
+
+static grub_uint32_t
+get_blkaddr_from_nat_journal (struct grub_f2fs_data *data, grub_uint32_t nid)
+{
+  grub_uint16_t n = grub_le_to_cpu16 (data->nat_j.n_nats);
+  grub_uint32_t blkaddr = 0;
+  grub_uint16_t i;
+
+  for (i = 0; i < n; i++)
+    {
+      if (grub_le_to_cpu32 (data->nat_j.entries[i].nid) == nid)
+        {
+          blkaddr = grub_le_to_cpu32 (data->nat_j.entries[i].ne.block_addr);
+          break;
+        }
+    }
+  return blkaddr;
+}
+
+static grub_uint32_t
+get_node_blkaddr (struct grub_f2fs_data *data, grub_uint32_t nid)
+{
+  struct grub_f2fs_nat_block *nat_block;
+  grub_uint32_t seg_off, block_off, entry_off, block_addr;
+  grub_uint32_t blkaddr;
+  grub_err_t err;
+
+  blkaddr = get_blkaddr_from_nat_journal (data, nid);
+  if (blkaddr)
+    return blkaddr;
+
+  nat_block = grub_malloc (F2FS_BLKSIZE);
+  if (!nat_block)
+    return 0;
+
+  block_off = nid / NAT_ENTRY_PER_BLOCK;
+  entry_off = nid % NAT_ENTRY_PER_BLOCK;
+
+  seg_off = block_off / data->blocks_per_seg;
+  block_addr = data->nat_blkaddr +
+		((seg_off * data->blocks_per_seg) << 1) +
+		(block_off & (data->blocks_per_seg - 1));
+
+  if (grub_f2fs_test_bit (block_off, data->nat_bitmap))
+    block_addr += data->blocks_per_seg;
+
+  err = grub_f2fs_block_read (data, block_addr, nat_block);
+  if (err)
+    {
+      grub_free (nat_block);
+      return 0;
+    }
+
+  blkaddr = grub_le_to_cpu32 (nat_block->ne[entry_off].block_addr);
+
+  grub_free (nat_block);
+
+  return blkaddr;
+}
+
+static int
+grub_get_node_path (struct grub_f2fs_inode *inode, grub_uint32_t block,
+			grub_uint32_t offset[4], grub_uint32_t noffset[4])
+{
+  grub_uint32_t direct_blks = ADDRS_PER_BLOCK;
+  grub_uint32_t dptrs_per_blk = NIDS_PER_BLOCK;
+  grub_uint32_t indirect_blks = ADDRS_PER_BLOCK * NIDS_PER_BLOCK;
+  grub_uint32_t dindirect_blks = indirect_blks * NIDS_PER_BLOCK;
+  grub_uint32_t direct_index = DEF_ADDRS_PER_INODE;
+  int n = 0;
+  int level = 0;
+
+  if (__inode_flag_set (inode, FI_INLINE_XATTR))
+    direct_index -= F2FS_INLINE_XATTR_ADDRS;
+
+  noffset[0] = 0;
+
+  if (block < direct_index)
+    {
+      offset[n] = block;
+      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;
+    }
+got:
+  return level;
+}
+
+
+static grub_err_t
+load_nat_info (struct grub_f2fs_data *data)
+{
+  void *version_bitmap;
+  grub_err_t err;
+
+  data->nat_bitmap = grub_malloc (__nat_bitmap_size (data));
+  if (!data->nat_bitmap)
+    return grub_errno;
+
+  version_bitmap = __nat_bitmap_ptr (data);
+
+  /* copy version bitmap */
+  grub_memcpy (data->nat_bitmap, version_bitmap, __nat_bitmap_size (data));
+
+  err = get_nat_journal (data);
+  if (err)
+    grub_free (data->nat_bitmap);
+
+  return err;
+}
+
+static grub_err_t
+grub_f2fs_read_node (struct grub_f2fs_data *data,
+			grub_uint32_t nid, struct grub_f2fs_node *np)
+{
+  grub_uint32_t blkaddr;
+
+  blkaddr = get_node_blkaddr (data, nid);
+  if (!blkaddr)
+    return grub_errno;
+
+  return grub_f2fs_block_read (data, blkaddr, np);
+}
+
+static struct grub_f2fs_data *
+grub_f2fs_mount (grub_disk_t disk)
+{
+  struct grub_f2fs_data *data;
+  grub_err_t err;
+
+  data = grub_zalloc (sizeof (*data));
+  if (!data)
+    return NULL;
+
+  data->disk = disk;
+
+  err = grub_f2fs_read_sb (data, 0);
+  if (err)
+    {
+      err = grub_f2fs_read_sb (data, 1);
+      if (err)
+        {
+          grub_error (GRUB_ERR_BAD_FS, "not a F2FS filesystem");
+          goto fail;
+	}
+    }
+
+  data->root_ino = grub_le_to_cpu32 (data->sblock.root_ino);
+  data->cp_blkaddr = grub_le_to_cpu32 (data->sblock.cp_blkaddr);
+  data->nat_blkaddr = grub_le_to_cpu32 (data->sblock.nat_blkaddr);
+  data->blocks_per_seg = 1 <<
+		grub_le_to_cpu32 (data->sblock.log_blocks_per_seg);
+
+  err = grub_f2fs_read_cp (data);
+  if (err)
+    goto fail;
+
+  err = load_nat_info (data);
+  if (err)
+    goto fail;
+
+  data->diropen.data = data;
+  data->diropen.ino = data->root_ino;
+  data->diropen.inode_read = 1;
+  data->inode = &data->diropen.inode;
+
+  err = grub_f2fs_read_node (data, data->root_ino, data->inode);
+  if (err)
+    goto fail;
+
+  return data;
+
+fail:
+  if (data)
+    grub_free (data->nat_bitmap);
+  grub_free (data);
+  return NULL;
+}
+
+/* guarantee inline_data was handled by caller */
+static grub_disk_addr_t
+grub_f2fs_read_block (grub_fshelp_node_t node, grub_disk_addr_t block_ofs)
+{
+  struct grub_f2fs_data *data = node->data;
+  struct grub_f2fs_inode *inode = &node->inode.i;
+  grub_uint32_t offset[4], noffset[4], nids[4];
+  struct grub_f2fs_node *node_block;
+  grub_uint32_t block_addr = -1;
+  int level, i;
+
+  level = grub_get_node_path (inode, block_ofs, offset, noffset);
+  if (level == 0)
+      return grub_le_to_cpu32 (inode->i_addr[offset[0]]);
+
+  node_block = grub_malloc (F2FS_BLKSIZE);
+  if (!node_block)
+    return -1;
+
+  nids[1] = __get_node_id (&node->inode, offset[0], 1);
+
+  /* get indirect or direct nodes */
+  for (i = 1; i <= level; i++)
+    {
+      grub_f2fs_read_node (data, nids[i], node_block);
+      if (grub_errno)
+        goto fail;
+
+      if (i < level)
+        nids[i + 1] = __get_node_id (node_block, offset[i], 0);
+    }
+
+  block_addr = grub_le_to_cpu32 (node_block->dn.addr[offset[level]]);
+fail:
+  grub_free (node_block);
+  return block_addr;
+}
+
+static grub_ssize_t
+grub_f2fs_read_file (grub_fshelp_node_t node,
+		       grub_disk_read_hook_t read_hook, void *read_hook_data,
+		       grub_off_t pos, grub_size_t len, char *buf)
+{
+  struct grub_f2fs_inode *inode = &(node->inode.i);
+  grub_off_t filesize = __i_size (inode);
+  char *inline_addr = __inline_addr (inode);
+
+  if (__inode_flag_set (&node->inode.i, FI_INLINE_DATA))
+    {
+      if (pos > filesize || filesize > MAX_INLINE_DATA)
+        {
+          grub_error (GRUB_ERR_OUT_OF_RANGE,
+		  N_("attempt to read past the end of file"));
+          return -1;
+        }
+      if (pos + len > filesize)
+        len = filesize - pos;
+
+      grub_memcpy (buf + pos, inline_addr + pos, len);
+      return len;
+    }
+
+  return grub_fshelp_read_file (node->data->disk, node,
+				read_hook, read_hook_data,
+				pos, len, buf, grub_f2fs_read_block,
+				filesize,
+				F2FS_BLK_SEC_BITS, 0);
+}
+
+static char *
+grub_f2fs_read_symlink (grub_fshelp_node_t node)
+{
+  char *symlink;
+  struct grub_fshelp_node *diro = node;
+
+  if (!diro->inode_read)
+    {
+      grub_f2fs_read_node (diro->data, diro->ino, &diro->inode);
+      if (grub_errno)
+	return 0;
+    }
+
+  symlink = grub_malloc (__i_size (&diro->inode.i) + 1);
+  if (!symlink)
+    return 0;
+
+  grub_f2fs_read_file (diro, 0, 0, 0, __i_size (&diro->inode.i), symlink);
+  if (grub_errno)
+    {
+      grub_free (symlink);
+      return 0;
+    }
+
+  symlink[__i_size (&diro->inode.i)] = '\0';
+  return symlink;
+}
+
+static int
+grub_f2fs_check_dentries (struct grub_f2fs_dir_iter_ctx *ctx)
+{
+  struct grub_fshelp_node *fdiro;
+  int i;
+
+  for (i = 0; i < ctx->max;)
+    {
+      char filename[F2FS_NAME_LEN + 1];
+      enum grub_fshelp_filetype type = GRUB_FSHELP_UNKNOWN;
+      enum FILE_TYPE ftype;
+      int name_len;
+
+      if (__test_bit (i, ctx->bitmap) == 0)
+        {
+          i++;
+          continue;
+        }
+
+      ftype = ctx->dentry[i].file_type;
+      name_len = grub_le_to_cpu16 (ctx->dentry[i].name_len);
+      grub_memcpy (filename, ctx->filename[i], name_len);
+      filename[name_len] = '\0';
+
+      fdiro = grub_malloc (sizeof (struct grub_fshelp_node));
+      if (!fdiro)
+        return 0;
+
+      if (ftype == F2FS_FT_DIR)
+        type = GRUB_FSHELP_DIR;
+      else if (ftype == F2FS_FT_SYMLINK)
+        type = GRUB_FSHELP_SYMLINK;
+      else if (ftype == F2FS_FT_REG_FILE)
+        type = GRUB_FSHELP_REG;
+
+      fdiro->data = ctx->data;
+      fdiro->ino = grub_le_to_cpu32 (ctx->dentry[i].ino);
+      fdiro->inode_read = 0;
+
+      if (ctx->hook (filename, type, fdiro, ctx->hook_data))
+        return 1;
+
+      i += (name_len + F2FS_SLOT_LEN - 1) / F2FS_SLOT_LEN;
+    }
+    return 0;
+}
+
+static int
+grub_f2fs_iterate_inline_dir (struct grub_f2fs_inode *dir,
+			struct grub_f2fs_dir_iter_ctx *ctx)
+{
+  struct grub_f2fs_inline_dentry *de_blk;
+
+  de_blk = (struct grub_f2fs_inline_dentry *) __inline_addr (dir);
+
+  ctx->bitmap = (grub_uint32_t *) de_blk->dentry_bitmap;
+  ctx->dentry = de_blk->dentry;
+  ctx->filename = de_blk->filename;
+  ctx->max = NR_INLINE_DENTRY;
+
+  return grub_f2fs_check_dentries (ctx);
+}
+
+static int
+grub_f2fs_iterate_dir (grub_fshelp_node_t dir,
+			 grub_fshelp_iterate_dir_hook_t hook, void *hook_data)
+{
+  struct grub_fshelp_node *diro = (struct grub_fshelp_node *) dir;
+  struct grub_f2fs_inode *inode;
+  struct grub_f2fs_dir_iter_ctx ctx = {
+    .data = diro->data,
+    .hook = hook,
+    .hook_data = hook_data
+  };
+  grub_off_t fpos = 0;
+
+  if (!diro->inode_read)
+    {
+      grub_f2fs_read_node (diro->data, diro->ino, &diro->inode);
+      if (grub_errno)
+	return 0;
+    }
+
+  inode = &diro->inode.i;
+
+  if (__inode_flag_set (inode, FI_INLINE_DENTRY))
+    return grub_f2fs_iterate_inline_dir (inode, &ctx);
+
+  while (fpos < __i_size (inode))
+    {
+      struct grub_f2fs_dentry_block *de_blk;
+      char *buf;
+
+      buf = grub_zalloc (F2FS_BLKSIZE);
+      if (!buf)
+        return 0;
+
+      grub_f2fs_read_file (diro, 0, 0, fpos, F2FS_BLKSIZE, buf);
+      if (grub_errno)
+        {
+          grub_free (buf);
+          return 0;
+        }
+
+      de_blk = (struct grub_f2fs_dentry_block *) buf;
+
+      ctx.bitmap = (grub_uint32_t *) de_blk->dentry_bitmap;
+      ctx.dentry = de_blk->dentry;
+      ctx.filename = de_blk->filename;
+      ctx.max = NR_DENTRY_IN_BLOCK;
+
+      if (grub_f2fs_check_dentries (&ctx))
+        return 1;
+
+      grub_free (buf);
+
+      fpos += F2FS_BLKSIZE;
+    }
+  return 0;
+}
+
+static int
+grub_f2fs_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
+		      grub_fshelp_node_t node, void *data)
+{
+  struct grub_f2fs_dir_ctx *ctx = data;
+  struct grub_dirhook_info info;
+
+  grub_memset (&info, 0, sizeof (info));
+  if (!node->inode_read)
+    {
+      grub_f2fs_read_node (ctx->data, node->ino, &node->inode);
+      if (!grub_errno)
+	node->inode_read = 1;
+      grub_errno = GRUB_ERR_NONE;
+    }
+  if (node->inode_read)
+    {
+      info.mtimeset = 1;
+      info.mtime = grub_le_to_cpu64 (node->inode.i.i_mtime);
+    }
+
+  info.dir = ((filetype & GRUB_FSHELP_TYPE_MASK) == GRUB_FSHELP_DIR);
+  grub_free (node);
+  return ctx->hook (filename, &info, ctx->hook_data);
+}
+
+static grub_err_t
+grub_f2fs_dir (grub_device_t device, const char *path,
+		 grub_fs_dir_hook_t hook, void *hook_data)
+{
+  struct grub_f2fs_dir_ctx ctx = {
+    .hook = hook,
+    .hook_data = hook_data
+  };
+  struct grub_fshelp_node *fdiro = 0;
+
+  grub_dl_ref (my_mod);
+
+  ctx.data = grub_f2fs_mount (device->disk);
+  if (!ctx.data)
+    goto fail;
+
+  grub_fshelp_find_file (path, &ctx.data->diropen, &fdiro,
+			 grub_f2fs_iterate_dir, grub_f2fs_read_symlink,
+			 GRUB_FSHELP_DIR);
+  if (grub_errno)
+    goto fail;
+
+  grub_f2fs_iterate_dir (fdiro, grub_f2fs_dir_iter, &ctx);
+
+fail:
+  if (fdiro != &ctx.data->diropen)
+    grub_free (fdiro);
+  if (ctx.data)
+    grub_free (ctx.data->nat_bitmap);
+  grub_free (ctx.data);
+  grub_dl_unref (my_mod);
+  return grub_errno;
+}
+
+
+/* Open a file named NAME and initialize FILE.  */
+static grub_err_t
+grub_f2fs_open (struct grub_file *file, const char *name)
+{
+  struct grub_f2fs_data *data = NULL;
+  struct grub_fshelp_node *fdiro = 0;
+
+  grub_dl_ref (my_mod);
+
+  data = grub_f2fs_mount (file->device->disk);
+  if (!data)
+    goto fail;
+
+  grub_fshelp_find_file (name, &data->diropen, &fdiro,
+			 grub_f2fs_iterate_dir, grub_f2fs_read_symlink,
+			 GRUB_FSHELP_REG);
+  if (grub_errno)
+    goto fail;
+
+  if (!fdiro->inode_read)
+    {
+      grub_f2fs_read_node (data, fdiro->ino, &fdiro->inode);
+      if (grub_errno)
+	goto fail;
+    }
+
+  grub_memcpy (data->inode, &fdiro->inode, F2FS_BLKSIZE);
+  grub_free (fdiro);
+
+  file->size = __i_size (&(data->inode->i));
+  file->data = data;
+  file->offset = 0;
+
+  return 0;
+
+fail:
+  if (fdiro != &data->diropen)
+    grub_free (fdiro);
+  if (data)
+    grub_free (data->nat_bitmap);
+  grub_free (data);
+
+  grub_dl_unref (my_mod);
+
+  return grub_errno;
+}
+
+static grub_ssize_t
+grub_f2fs_read (grub_file_t file, char *buf, grub_size_t len)
+{
+  struct grub_f2fs_data *data = (struct grub_f2fs_data *) file->data;
+
+  return grub_f2fs_read_file (&data->diropen,
+				file->read_hook, file->read_hook_data,
+				file->offset, len, buf);
+}
+
+static grub_err_t
+grub_f2fs_close (grub_file_t file)
+{
+  struct grub_f2fs_data *data = (struct grub_f2fs_data *) file->data;
+
+  if (data)
+    grub_free (data->nat_bitmap);
+  grub_free (data);
+
+  grub_dl_unref (my_mod);
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_err_t
+grub_f2fs_label (grub_device_t device, char **label)
+{
+  struct grub_f2fs_data *data;
+  grub_disk_t disk = device->disk;
+
+  grub_dl_ref (my_mod);
+
+  data = grub_f2fs_mount (disk);
+  if (data)
+    {
+      *label = grub_zalloc (sizeof (data->sblock.volume_name));
+      grub_utf16_to_utf8 ((grub_uint8_t *) (*label),
+				data->sblock.volume_name, 512);
+    }
+  else
+    *label = NULL;
+
+  if (data)
+    grub_free (data->nat_bitmap);
+  grub_free (data);
+  grub_dl_unref (my_mod);
+  return grub_errno;
+}
+
+static grub_err_t
+grub_f2fs_uuid (grub_device_t device, char **uuid)
+{
+  struct grub_f2fs_data *data;
+  grub_disk_t disk = device->disk;
+
+  grub_dl_ref (my_mod);
+
+  data = grub_f2fs_mount (disk);
+  if (data)
+    {
+      *uuid =
+	grub_xasprintf
+	("%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x",
+	 data->sblock.uuid[0], data->sblock.uuid[1],
+	 data->sblock.uuid[2], data->sblock.uuid[3],
+	 data->sblock.uuid[4], data->sblock.uuid[5],
+	 data->sblock.uuid[6], data->sblock.uuid[7],
+	 data->sblock.uuid[8], data->sblock.uuid[9],
+	 data->sblock.uuid[10], data->sblock.uuid[11],
+	 data->sblock.uuid[12], data->sblock.uuid[13],
+	 data->sblock.uuid[14], data->sblock.uuid[15]);
+    }
+  else
+    *uuid = NULL;
+
+  if (data)
+    grub_free (data->nat_bitmap);
+  grub_free (data);
+  grub_dl_unref (my_mod);
+  return grub_errno;
+}
+
+static struct grub_fs grub_f2fs_fs = {
+  .name = "f2fs",
+  .dir = grub_f2fs_dir,
+  .open = grub_f2fs_open,
+  .read = grub_f2fs_read,
+  .close = grub_f2fs_close,
+  .label = grub_f2fs_label,
+  .uuid = grub_f2fs_uuid,
+#ifdef GRUB_UTIL
+  .reserved_first_sector = 1,
+  .blocklist_install = 0,
+#endif
+  .next = 0
+};
+
+GRUB_MOD_INIT (f2fs)
+{
+  grub_fs_register (&grub_f2fs_fs);
+  my_mod = mod;
+}
+
+GRUB_MOD_FINI (f2fs)
+{
+  grub_fs_unregister (&grub_f2fs_fs);
+}
diff --git a/po/exclude.pot b/po/exclude.pot
index ab52e99..a517fdf 100644
--- a/po/exclude.pot
+++ b/po/exclude.pot
@@ -1214,6 +1214,7 @@ msgstr ""
 
 #: grub-core/commands/xnu_uuid.c:75 grub-core/fs/jfs.c:924
 #: grub-core/fs/nilfs2.c:1135
+#: grub-core/fs/f2fs.c:1259
 #, c-format
 msgid "%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x"
 msgstr ""
diff --git a/tests/f2fs_test.in b/tests/f2fs_test.in
new file mode 100644
index 0000000..98efda6
--- /dev/null
+++ b/tests/f2fs_test.in
@@ -0,0 +1,19 @@
+#!/bin/sh
+
+set -e
+
+if [ "x$EUID" = "x" ] ; then
+  EUID=`id -u`
+fi
+
+if [ "$EUID" != 0 ] ; then
+   exit 77
+fi
+
+if ! which mkfs.f2fs >/dev/null 2>&1; then
+   echo "mkfs.f2fs not installed; cannot test f2fs."
+   exit 77
+fi
+
+
+"@builddir@/grub-fs-tester" f2fs
diff --git a/tests/util/grub-fs-tester.in b/tests/util/grub-fs-tester.in
index e9e85c2..acc35cc 100644
--- a/tests/util/grub-fs-tester.in
+++ b/tests/util/grub-fs-tester.in
@@ -36,7 +36,7 @@ case x"$fs" in
 	MINLOGSECSIZE=8
 	    #  OS LIMITATION: It could go up to 32768 but Linux rejects sector sizes > 4096
 	MAXLOGSECSIZE=12;;
-    xxfs)
+    xxfs|xf2fs)
 	MINLOGSECSIZE=9
   	    # OS LIMITATION: GNU/Linux doesn't accept > 4096
 	MAXLOGSECSIZE=12;;
@@ -135,6 +135,10 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
 	    fi
 	    MAXBLKSIZE=4096
 	    ;;
+	xf2fs)
+	    MINBLKSIZE=$SECSIZE
+		# OS Limitation: GNU/Linux doesn't accept > 4096
+	    MAXBLKSIZE=4096;;
 	xsquash*)
 	    MINBLKSIZE=4096
 	    MAXBLKSIZE=1048576;;
@@ -256,7 +260,9 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
 	    # FS LIMITATION: btrfs label is at most 255 UTF-8 chars
 		x"btrfs"*)
 		    FSLABEL="grub_;/testé莭莽😁киритi urewfceniuewruevrewnuuireurevueurnievrewfnerfcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvrevuurerejiremvreijnvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoif";;
-
+	    # FS LIMITATION: btrfs label is at most 512 UTF-16 chars
+		x"f2fs")
+		    FSLABEL="grub_;/testjaegeuk kim f2fsaskdfjkasdlfajskdfjaksdjfkjaskjkjkzjkjckzjvkcjkjkjekqjkwejkqwrlkasdfjksadjflaskdhzxhvjzxchvjzkxchvjkhakjsdhfjkhqjkwehrjkhasjkdfhjkashdfjkhjzkxhcjkvzhxcjkvhzxjchvkzhxckjvhjzkxchvjkhzjkxchvjkzhxckjvhzkxjchvkjzxhckjvzxcjkvhjzxkchkvjhzxkjcvhjkhjkahsjkdhkjqhwekrjhakjsdfhkjashdkjzhxcvjkhzxcvzxcvggggggggggf";;
 	    # FS LIMITATION: exfat is at most 15 UTF-16 chars
 		x"exfat")
 		    FSLABEL="géт ;/莭莽😁кир";;
@@ -466,7 +472,7 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
 	    # FIXME: Not sure about BtrFS, NTFS, JFS, AFS, UDF and SFS. Check it.
 	# FS LIMITATION: as far as I know those FS don't store their last modification date.
 		x"jfs_caseins" | x"jfs" | x"xfs"| x"btrfs"* | x"reiserfs_old" | x"reiserfs" \
-		    | x"bfs" | x"afs" \
+		    | x"bfs" | x"afs" | x"f2fs" \
 		    | x"tarfs" | x"cpio_"* | x"minix" | x"minix2" \
 		    | x"minix3" | x"ntfs"* | x"udf" | x"sfs"*)
 		    NOFSTIME=y;;
@@ -745,6 +751,8 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
 		    MOUNTDEVICE="/dev/mapper/grub_test-testvol"
 		    MOUNTFS=ext2
 		    "mkfs.ext2" -L "$FSLABEL" -q "${MOUNTDEVICE}"  ;;
+		xf2fs)
+		    "mkfs.f2fs" -l "$FSLABEL" -q "${LODEVICES[0]}" ;;
 		xnilfs2)
 		    "mkfs.nilfs2" -L "$FSLABEL" -b $BLKSIZE  -q "${LODEVICES[0]}" ;;
 		xext2_old)
-- 
2.1.1



^ permalink raw reply related	[flat|nested] 18+ messages in thread