path: root/main/grub/f2fs-support.patch

From 71f9e4ac44142af52c3fc1860436cf9e432bf764 Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <jaegeuk@kernel.org>
Date: Thu, 29 Mar 2018 16:37:39 +0100
Subject: fs: Add F2FS support

"F2FS (Flash-Friendly File System) is flash-friendly file system which was merged
into Linux kernel v3.8 in 2013.

The motive for F2FS was to build a file system that from the start, takes into
account the characteristics of NAND flash memory-based storage devices (such as
solid-state disks, eMMC, and SD cards).

F2FS was designed on a basis of a log-structured file system approach, which
remedies some known issues of the older log structured file systems, such as
the snowball effect of wandering trees and high cleaning overhead. In addition,
since a NAND-based storage device shows different characteristics according to
its internal geometry or flash memory management scheme (such as the Flash
Translation Layer or FTL), it supports various parameters not only for
configuring on-disk layout, but also for selecting allocation and cleaning
algorithm.", quote by https://en.wikipedia.org/wiki/F2FS.

The source codes for F2FS are available from:

http://git.kernel.org/cgit/linux/kernel/git/jaegeuk/f2fs.git
http://git.kernel.org/cgit/linux/kernel/git/jaegeuk/f2fs-tools.git

This patch has been integrated in OpenMandriva Lx 3.
  https://www.openmandriva.org/

Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
Signed-off-by: Pete Batard <pete@akeo.ie>
Signed-off-by: Daniel Kiper <daniel.kiper@oracle.com>
Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
---
 Makefile.util.def            |    7 +
 docs/grub.texi               |    7 +-
 grub-core/Makefile.core.def  |    5 +
 grub-core/fs/f2fs.c          | 1314 ++++++++++++++++++++++++++++++++++++++++++
 po/exclude.pot               |    1 +
 tests/f2fs_test.in           |   19 +
 tests/util/grub-fs-tester.in |   10 +-
 7 files changed, 1358 insertions(+), 5 deletions(-)
 create mode 100644 grub-core/fs/f2fs.c
 create mode 100644 tests/f2fs_test.in

diff --git a/Makefile.util.def b/Makefile.util.def
index f9caccb..3180ac8 100644
--- a/Makefile.util.def
+++ b/Makefile.util.def
@@ -99,6 +99,7 @@ library = {
   common = grub-core/fs/ext2.c;
   common = grub-core/fs/fat.c;
   common = grub-core/fs/exfat.c;
+  common = grub-core/fs/f2fs.c;
   common = grub-core/fs/fshelp.c;
   common = grub-core/fs/hfs.c;
   common = grub-core/fs/hfsplus.c;
@@ -776,6 +777,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 65b4bbe..0f2ab91 100644
--- a/docs/grub.texi
+++ b/docs/grub.texi
@@ -360,8 +360,9 @@ 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{HFS+}, @dfn{ISO9660} (including Joliet, Rock-ridge and multi-chunk files),
+@dfn{Linux ext2/ext3/ext4}, @dfn{DOS FAT12/FAT16/FAT32},
+@dfn{exFAT}, @dfn{F2FS}, @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},
 @dfn{Amiga Smart FileSystem (SFS)}, @dfn{Squash4}, @dfn{tar}, @dfn{UDF},
@@ -5375,7 +5376,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 2c1d62c..fc4767f 100644
--- a/grub-core/Makefile.core.def
+++ b/grub-core/Makefile.core.def
@@ -1315,6 +1315,11 @@ module = {
 };
 
 module = {
+  name = f2fs;
+  common = fs/f2fs.c;
+};
+
+module = {
   name = fshelp;
   common = fs/fshelp.c;
 };
diff --git a/grub-core/fs/f2fs.c b/grub-core/fs/f2fs.c
new file mode 100644
index 0000000..1cad261
--- /dev/null
+++ b/grub-core/fs/f2fs.c
@@ -0,0 +1,1314 @@
+/*
+ *  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
+
+#define CHECKSUM_OFFSET           4092  /* Must be aligned 4 bytes. */
+#define U32_CHECKSUM_OFFSET       (CHECKSUM_OFFSET >> 2)
+#define CRCPOLY_LE                0xedb88320
+
+/* Byte-size offset. */
+#define F2FS_SUPER_OFFSET         ((grub_disk_addr_t)1024)
+#define F2FS_SUPER_OFFSET0        (F2FS_SUPER_OFFSET >> GRUB_DISK_SECTOR_BITS)
+#define F2FS_SUPER_OFFSET1        ((F2FS_SUPER_OFFSET + F2FS_BLKSIZE) >> \
+                                        GRUB_DISK_SECTOR_BITS)
+
+/* 9 bits for 512 bytes. */
+#define F2FS_MIN_LOG_SECTOR_SIZE  9
+
+/* Support only 4KB block. */
+#define F2FS_BLK_BITS             12
+#define F2FS_BLKSIZE              (1 << F2FS_BLK_BITS)
+#define F2FS_BLK_SEC_BITS         (F2FS_BLK_BITS - GRUB_DISK_SECTOR_BITS)
+
+#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               (sizeof(struct grub_f2fs_nat_jent))
+#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            (sizeof(struct grub_f2fs_nat_entry))
+#define NAT_ENTRY_PER_BLOCK       (F2FS_BLKSIZE / NAT_ENTRY_SIZE)
+
+#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
+
+#define CKPT_FLAG_SET(ckpt, f)    (ckpt)->ckpt_flags & \
+                                        grub_cpu_to_le32_compile_time (f)
+
+#define F2FS_INLINE_XATTR         0x01  /* File inline xattr flag. */
+#define F2FS_INLINE_DATA          0x02  /* File inline data flag. */
+#define F2FS_INLINE_DENTRY        0x04  /* File inline dentry flag. */
+#define F2FS_DATA_EXIST           0x08  /* File inline data exist flag. */
+#define F2FS_INLINE_DOTS          0x10  /* File having implicit dot dentries. */
+
+#define MAX_VOLUME_NAME           512
+
+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[MAX_VOLUME_NAME];
+  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;
+    /* Should occupy F2FS_BLKSIZE totally. */
+    char                          buf[F2FS_BLKSIZE - 40];
+  };
+  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_uint8_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 int
+grub_f2fs_test_bit_le (int nr, const grub_uint8_t *addr)
+{
+  return addr[nr >> 3] & (1 << (nr & 7));
+}
+
+static char *
+get_inline_addr (struct grub_f2fs_inode *inode)
+{
+  return (char *) &inode->i_addr[1];
+}
+
+static grub_uint64_t
+grub_f2fs_file_size (struct grub_f2fs_inode *inode)
+{
+  return grub_le_to_cpu64 (inode->i_size);
+}
+
+static grub_uint32_t
+start_cp_addr (struct grub_f2fs_data *data)
+{
+  struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
+  grub_uint32_t start_addr = data->cp_blkaddr;
+
+  if (!(ckpt->checkpoint_ver & grub_cpu_to_le64_compile_time(1)))
+    return start_addr + data->blocks_per_seg;
+
+  return start_addr;
+}
+
+static 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 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 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 grub_uint32_t
+get_node_id (struct grub_f2fs_node *rn, int off, int inode_block)
+{
+  if (inode_block)
+    return grub_le_to_cpu32 (rn->i.i_nid[off - NODE_DIR1_BLOCK]);
+
+  return grub_le_to_cpu32 (rn->in.nid[off]);
+}
+
+static grub_err_t
+grub_f2fs_block_read (struct grub_f2fs_data *data, grub_uint32_t blkaddr,
+                      void *buf)
+{
+  return grub_disk_read (data->disk,
+                         ((grub_disk_addr_t)blkaddr) << F2FS_BLK_SEC_BITS,
+                         0, F2FS_BLKSIZE, buf);
+}
+
+/* CRC32 */
+static grub_uint32_t
+grub_f2fs_cal_crc32 (const void *buf, const grub_uint32_t len)
+{
+  grub_uint32_t crc = F2FS_SUPER_MAGIC;
+  unsigned char *p = (unsigned char *)buf;
+  grub_uint32_t tmp = len;
+  int i;
+
+  while (tmp--)
+    {
+      crc ^= *p++;
+      for (i = 0; i < 8; i++)
+        crc = (crc >> 1) ^ ((crc & 1) ? CRCPOLY_LE : 0);
+    }
+
+  return crc;
+}
+
+static int
+grub_f2fs_crc_valid (grub_uint32_t blk_crc, void *buf, const grub_uint32_t len)
+{
+  grub_uint32_t cal_crc = 0;
+
+  cal_crc = grub_f2fs_cal_crc32 (buf, len);
+
+  return (cal_crc == blk_crc) ? 1 : 0;
+}
+
+static int
+grub_f2fs_test_bit (grub_uint32_t nr, const char *p)
+{
+  int mask;
+
+  p += (nr >> 3);
+  mask = 1 << (7 - (nr & 0x07));
+
+  return mask & *p;
+}
+
+static int
+grub_f2fs_sanity_check_sb (struct grub_f2fs_superblock *sb)
+{
+  grub_uint32_t log_sectorsize, log_sectors_per_block;
+
+  if (sb->magic != grub_cpu_to_le32_compile_time (F2FS_SUPER_MAGIC))
+    return -1;
+
+  if (sb->log_blocksize != grub_cpu_to_le32_compile_time (F2FS_BLK_BITS))
+    return -1;
+
+  log_sectorsize = grub_le_to_cpu32 (sb->log_sectorsize);
+  log_sectors_per_block = grub_le_to_cpu32 (sb->log_sectors_per_block);
+
+  if (log_sectorsize > F2FS_BLK_BITS)
+    return -1;
+
+  if (log_sectorsize < F2FS_MIN_LOG_SECTOR_SIZE)
+    return -1;
+
+  if (log_sectors_per_block + log_sectorsize != F2FS_BLK_BITS)
+    return -1;
+
+  return 0;
+}
+
+static int
+grub_f2fs_read_sb (struct grub_f2fs_data *data, grub_disk_addr_t offset)
+{
+  grub_disk_t disk = data->disk;
+  grub_err_t err;
+
+  /* Read first super block. */
+  err = grub_disk_read (disk, offset, 0, sizeof (data->sblock), &data->sblock);
+  if (err)
+    return -1;
+
+  return grub_f2fs_sanity_check_sb (&data->sblock);
+}
+
+static void *
+validate_checkpoint (struct grub_f2fs_data *data, grub_uint32_t cp_addr,
+                     grub_uint64_t *version)
+{
+  grub_uint32_t *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 != CHECKSUM_OFFSET)
+    goto invalid_cp1;
+
+  crc = grub_le_to_cpu32 (*(cp_page_1 + U32_CHECKSUM_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 != CHECKSUM_OFFSET)
+    goto invalid_cp2;
+
+  crc = grub_le_to_cpu32 (*(cp_page_2 + U32_CHECKSUM_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");
+
+  grub_memcpy (&data->ckpt, cur_page, F2FS_BLKSIZE);
+
+  grub_free (cp1);
+  grub_free (cp2);
+
+  return 0;
+}
+
+static grub_err_t
+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->i_inline & F2FS_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
+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_malloc (sizeof (*data));
+  if (!data)
+    return NULL;
+
+  data->disk = disk;
+
+  if (grub_f2fs_read_sb (data, F2FS_SUPER_OFFSET0))
+    {
+      if (grub_f2fs_read_sb (data, F2FS_SUPER_OFFSET1))
+        {
+          if (grub_errno == GRUB_ERR_NONE)
+            grub_error (GRUB_ERR_BAD_FS,
+                        "not a F2FS filesystem (no superblock)");
+          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;
+
+  data->nat_bitmap = nat_bitmap_ptr (data);
+
+  err = get_nat_journal (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:
+  grub_free (data);
+
+  return NULL;
+}
+
+/* Guarantee inline_data was handled by caller. */
+static grub_disk_addr_t
+grub_f2fs_get_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 = grub_f2fs_file_size (inode);
+  char *inline_addr = get_inline_addr (inode);
+
+  if (inode->i_inline & F2FS_INLINE_DATA)
+    {
+      if (filesize > MAX_INLINE_DATA)
+        return -1;
+
+      if (len > filesize - pos)
+        len = filesize - pos;
+
+      grub_memcpy (buf, 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_get_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;
+  grub_uint64_t filesize;
+
+  if (!diro->inode_read)
+    {
+      grub_f2fs_read_node (diro->data, diro->ino, &diro->inode);
+      if (grub_errno)
+        return 0;
+    }
+
+  filesize = grub_f2fs_file_size(&diro->inode.i);
+
+  symlink = grub_malloc (filesize + 1);
+  if (!symlink)
+    return 0;
+
+  grub_f2fs_read_file (diro, 0, 0, 0, filesize, symlink);
+  if (grub_errno)
+    {
+      grub_free (symlink);
+      return 0;
+    }
+
+  symlink[filesize] = '\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;
+      enum grub_fshelp_filetype type = GRUB_FSHELP_UNKNOWN;
+      enum FILE_TYPE ftype;
+      int name_len;
+      int ret;
+
+      if (grub_f2fs_test_bit_le (i, ctx->bitmap) == 0)
+        {
+          i++;
+          continue;
+        }
+
+      ftype = ctx->dentry[i].file_type;
+      name_len = grub_le_to_cpu16 (ctx->dentry[i].name_len);
+      filename = grub_malloc (name_len + 1);
+      if (!filename)
+        return 0;
+
+      grub_memcpy (filename, ctx->filename[i], name_len);
+      filename[name_len] = 0;
+
+      fdiro = grub_malloc (sizeof (struct grub_fshelp_node));
+      if (!fdiro)
+        {
+          grub_free(filename);
+          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;
+
+      ret = ctx->hook (filename, type, fdiro, ctx->hook_data);
+      grub_free(filename);
+      if (ret)
+        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 *) get_inline_addr (dir);
+
+  ctx->bitmap = 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->i_inline & F2FS_INLINE_DENTRY)
+    return grub_f2fs_iterate_inline_dir (inode, &ctx);
+
+  while (fpos < grub_f2fs_file_size (inode))
+    {
+      struct grub_f2fs_dentry_block *de_blk;
+      char *buf;
+      int ret;
+
+      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 = de_blk->dentry_bitmap;
+      ctx.dentry = de_blk->dentry;
+      ctx.filename = de_blk->filename;
+      ctx.max = NR_DENTRY_IN_BLOCK;
+
+      ret = grub_f2fs_check_dentries (&ctx);
+      grub_free (buf);
+      if (ret)
+        return 1;
+
+      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);
+  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;
+  struct grub_f2fs_inode *inode;
+
+  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, sizeof (*data->inode));
+  grub_free (fdiro);
+
+  inode = &(data->inode->i);
+  file->size = grub_f2fs_file_size (inode);
+  file->data = data;
+  file->offset = 0;
+
+  if (inode->i_inline & F2FS_INLINE_DATA && file->size > MAX_INLINE_DATA)
+    grub_error (GRUB_ERR_BAD_FS, "corrupted inline_data: need fsck");
+
+  return 0;
+
+ fail:
+  if (fdiro != &data->diropen)
+    grub_free (fdiro);
+  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;
+
+  grub_free (data);
+
+  grub_dl_unref (my_mod);
+
+  return GRUB_ERR_NONE;
+}
+
+static grub_uint8_t *
+grub_f2fs_utf16_to_utf8 (grub_uint16_t *in_buf_le)
+{
+  grub_uint16_t in_buf[MAX_VOLUME_NAME];
+  grub_uint8_t *out_buf;
+  int len = 0;
+
+  out_buf = grub_malloc (MAX_VOLUME_NAME * GRUB_MAX_UTF8_PER_UTF16 + 1);
+  if (!out_buf)
+    return NULL;
+
+  while (*in_buf_le != 0 && len < MAX_VOLUME_NAME) {
+    in_buf[len] = grub_le_to_cpu16 (in_buf_le[len]);
+    len++;
+  }
+
+  *grub_utf16_to_utf8 (out_buf, in_buf, len) = '\0';
+
+  return out_buf;
+}
+
+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 = (char *) grub_f2fs_utf16_to_utf8 (data->sblock.volume_name);
+  else
+    *label = NULL;
+
+  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;
+
+  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 0a9b215..816089c 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..1ea77c8
--- /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 15969d7..26bd57a 100644
--- a/tests/util/grub-fs-tester.in
+++ b/tests/util/grub-fs-tester.in
@@ -172,7 +172,7 @@ for LOGSECSIZE in $(range "$MINLOGSECSIZE" "$MAXLOGSECSIZE" 1); do
 	xsquash*)
 	    MINBLKSIZE=4096
 	    MAXBLKSIZE=1048576;;
-	xxfs)
+	xxfs|xf2fs)
 	    MINBLKSIZE=$SECSIZE
 		# OS Limitation: GNU/Linux doesn't accept > 4096
 	    MAXBLKSIZE=4096;;
@@ -299,6 +299,10 @@ for LOGSECSIZE in $(range "$MINLOGSECSIZE" "$MAXLOGSECSIZE" 1); do
 		x"btrfs"*)
 		    FSLABEL="grub_;/testé莭莽😁киритi urewfceniuewruevrewnuuireurevueurnievrewfnerfcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvrevuurerejiremvreijnvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoi";;
 
+	    # FS LIMITATION: f2fs label is at most 512 UTF-16 chars
+		x"f2fs")
+		    FSLABEL="grub_;/testé䏌䐓䏕киритiurewfceniuewruewnuuireurevueurnievrewfnerfcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvrevuurerejiremvreijnvvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoirvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoircreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoifoiq";;
+
 	    # FS LIMITATION: exfat is at most 15 UTF-16 chars
 		x"exfat")
 		    FSLABEL="géт ;/莭莽😁кир";;
@@ -508,7 +512,7 @@ for LOGSECSIZE in $(range "$MINLOGSECSIZE" "$MAXLOGSECSIZE" 1); do
 	    # 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"xfs_crc" | 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;;
@@ -792,6 +796,8 @@ for LOGSECSIZE in $(range "$MINLOGSECSIZE" "$MAXLOGSECSIZE" 1); do
 		    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 "${MOUNTDEVICE}" ;;
 		xext2_old)
-- 
cgit v1.0-41-gc330