Fri Jul 5 20:08:13 UTC 201920190705200813

a/grub-2.04-x86_64-1.txz:  Upgraded.
ap/mariadb-10.4.6-x86_64-2.txz:  Rebuilt.
  Patched mysql_install_db to comment out PAM related setup.
  Thanks to Labinnah.
l/argon2-20190702-x86_64-2.txz:  Rebuilt.
  Fixed library install path. Thanks to phenixia2003.
l/imagemagick-6.9.10_52-x86_64-1.txz:  Upgraded.
n/ModemManager-1.10.4-x86_64-1.txz:  Upgraded.
x/libdrm-2.4.99-x86_64-1.txz:  Upgraded.
x/libinput-1.13.4-x86_64-1.txz:  Upgraded.
isolinux/efiboot.img:  Rebuilt.

5 files changed, 1 insertions, 1653 deletions

diff --git a/source/a/grub/0001-Fix-CVE-2015-8370-Grub2-user-pass-vulnerability.patch b/source/a/grub/0001-Fix-CVE-2015-8370-Grub2-user-pass-vulnerability.patch
deleted file mode 100644
index 5701b547..00000000
--- a/source/a/grub/0001-Fix-CVE-2015-8370-Grub2-user-pass-vulnerability.patch
+++ /dev/null
@@ -1,45 +0,0 @@
-From 88c9657960a6c5d3673a25c266781e876c181add Mon Sep 17 00:00:00 2001
-From: Hector Marco-Gisbert <hecmargi@upv.es>
-Date: Fri, 13 Nov 2015 16:21:09 +0100
-Subject: [PATCH] Fix security issue when reading username and password
-
-  This patch fixes two integer underflows at:
-    * grub-core/lib/crypto.c
-    * grub-core/normal/auth.c
-
-Signed-off-by: Hector Marco-Gisbert <hecmargi@upv.es>
-Signed-off-by: Ismael Ripoll-Ripoll <iripoll@disca.upv.es>
----
- grub-core/lib/crypto.c  | 2 +-
- grub-core/normal/auth.c | 2 +-
- 2 files changed, 2 insertions(+), 2 deletions(-)
-
-diff --git a/grub-core/lib/crypto.c b/grub-core/lib/crypto.c
-index 010e550..524a3d8 100644
---- a/grub-core/lib/crypto.c
-+++ b/grub-core/lib/crypto.c
-@@ -468,7 +468,7 @@ grub_password_get (char buf[], unsigned buf_size)
- 	  break;
- 	}
- 
--      if (key == '\b')
-+      if (key == '\b' && cur_len)
- 	{
- 	  cur_len--;
- 	  continue;
-diff --git a/grub-core/normal/auth.c b/grub-core/normal/auth.c
-index c6bd96e..5782ec5 100644
---- a/grub-core/normal/auth.c
-+++ b/grub-core/normal/auth.c
-@@ -172,7 +172,7 @@ grub_username_get (char buf[], unsigned buf_size)
- 	  break;
- 	}
- 
--      if (key == '\b')
-+      if (key == '\b' && cur_len)
- 	{
- 	  cur_len--;
- 	  grub_printf ("\b");
--- 
-1.9.1
-
diff --git a/source/a/grub/grub.SlackBuild b/source/a/grub/grub.SlackBuild
index efbb99a7..b6d75649 100755
--- a/source/a/grub/grub.SlackBuild
+++ b/source/a/grub/grub.SlackBuild
@@ -28,7 +28,7 @@ PKGNAM=grub
 VERSION=${VERSION:-$(echo $PKGNAM-*.tar.xz | rev | cut -f 3- -d . | cut -f 1 -d - | rev)}
 # Better to use _ than ~ in the package filenames version:
 PKGVER=$(echo $VERSION | tr '~' '_')
-BUILD=${BUILD:-5}
+BUILD=${BUILD:-1}
 
 # Automatically determine the architecture we're building on:
 if [ -z "$ARCH" ]; then
@@ -109,21 +109,9 @@ zcat $CWD/initrd_naming.patch | patch -p1 --verbose || exit 1
 # Support DejaVuSansMono font (dejavusansmono.pf2) by default:
 zcat $CWD/grub.dejavusansmono.gfxterm.font.diff.gz | patch -p1 --verbose || exit 1
 
-# Fix security issue when reading username and password:
-zcat $CWD/0001-Fix-CVE-2015-8370-Grub2-user-pass-vulnerability.patch.gz | patch -p1 --verbose || exit 1
-
 # Fix alignment error with gcc8:
 zcat $CWD/0198-align-struct-efi_variable-better.patch.gz | patch -p1 --verbose || exit 1
 
-# Fix compatibility with recent xfsprogs:
-zcat $CWD/grub.xfs.sparse.inodes.patch.gz | patch -p1 --verbose || exit 1
-
-# Fix breakage when compiled with recent binutils:
-zcat $CWD/grub.binutils.fix.diff.gz | patch -p1 --verbose || exit 1
-
-# Support F2FS filesystem:
-zcat $CWD/grub.f2fs.patch.gz | patch -p1 --verbose || exit 1
-
 # Regenerate build system to fix dependency on outdated automake:
 autoreconf -vif
 
diff --git a/source/a/grub/grub.binutils.fix.diff b/source/a/grub/grub.binutils.fix.diff
deleted file mode 100644
index b23cb1b6..00000000
--- a/source/a/grub/grub.binutils.fix.diff
+++ /dev/null
@@ -1,20 +0,0 @@
---- ./util/grub-mkimagexx.c.orig	2017-04-24 04:16:00.000000000 -0500
-+++ ./util/grub-mkimagexx.c	2018-09-22 13:35:33.089870295 -0500
-@@ -832,6 +832,7 @@
- 		  break;
- 
- 		case R_X86_64_PC32:
-+		case R_X86_64_PLT32:
- 		  {
- 		    grub_uint32_t *t32 = (grub_uint32_t *) target;
- 		    *t32 = grub_host_to_target64 (grub_target_to_host32 (*t32)
---- ./util/grub-module-verifier.c.orig	2017-04-24 04:16:00.000000000 -0500
-+++ ./util/grub-module-verifier.c	2018-09-22 13:36:05.328867627 -0500
-@@ -19,6 +19,7 @@
-       -1
-     }, (int[]){
-       R_X86_64_PC32,
-+      R_X86_64_PLT32,
-       -1
-     }
-   },
diff --git a/source/a/grub/grub.f2fs.patch b/source/a/grub/grub.f2fs.patch
deleted file mode 100644
index 52771530..00000000
--- a/source/a/grub/grub.f2fs.patch
+++ /dev/null
@@ -1,1514 +0,0 @@
-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
-
-
diff --git a/source/a/grub/grub.xfs.sparse.inodes.patch b/source/a/grub/grub.xfs.sparse.inodes.patch
deleted file mode 100644
index b7c8db4c..00000000
--- a/source/a/grub/grub.xfs.sparse.inodes.patch
+++ /dev/null
@@ -1,61 +0,0 @@
-From cda0a857dd7a27cd5d621747464bfe71e8727fff Mon Sep 17 00:00:00 2001
-From: Daniel Kiper <daniel.kiper@oracle.com>
-Date: Tue, 29 May 2018 16:16:02 +0200
-Subject: xfs: Accept filesystem with sparse inodes
-
-The sparse inode metadata format became a mkfs.xfs default in
-xfsprogs-4.16.0, and such filesystems are now rejected by grub as
-containing an incompatible feature.
-
-In essence, this feature allows xfs to allocate inodes into fragmented
-freespace.  (Without this feature, if xfs could not allocate contiguous
-space for 64 new inodes, inode creation would fail.)
-
-In practice, the disk format change is restricted to the inode btree,
-which as far as I can tell is not used by grub.  If all you're doing
-today is parsing a directory, reading an inode number, and converting
-that inode number to a disk location, then ignoring this feature
-should be fine, so I've added it to XFS_SB_FEAT_INCOMPAT_SUPPORTED
-
-I did some brief testing of this patch by hacking up the regression
-tests to completely fragment freespace on the test xfs filesystem, and
-then write a large-ish number of inodes to consume any existing
-contiguous 64-inode chunk.  This way any files the grub tests add and
-traverse would be in such a fragmented inode allocation.  Tests passed,
-but I'm not sure how to cleanly integrate that into the test harness.
-
-Signed-off-by: Eric Sandeen <sandeen@redhat.com>
-Reviewed-by: Daniel Kiper <daniel.kiper@oracle.com>
-Tested-by: Chris Murphy <lists@colorremedies.com>
----
- grub-core/fs/xfs.c | 11 ++++++++++-
- 1 file changed, 10 insertions(+), 1 deletion(-)
-
-diff --git a/grub-core/fs/xfs.c b/grub-core/fs/xfs.c
-index c6031bd..3b00c74 100644
---- a/grub-core/fs/xfs.c
-+++ b/grub-core/fs/xfs.c
-@@ -79,9 +79,18 @@ GRUB_MOD_LICENSE ("GPLv3+");
- #define XFS_SB_FEAT_INCOMPAT_SPINODES   (1 << 1)        /* sparse inode chunks */
- #define XFS_SB_FEAT_INCOMPAT_META_UUID  (1 << 2)        /* metadata UUID */
- 
--/* We do not currently verify metadata UUID so it is safe to read such filesystem */
-+/*
-+ * Directory entries with ftype are explicitly handled by GRUB code.
-+ *
-+ * We do not currently read the inode btrees, so it is safe to read filesystems
-+ * with the XFS_SB_FEAT_INCOMPAT_SPINODES feature.
-+ *
-+ * We do not currently verify metadata UUID, so it is safe to read filesystems
-+ * with the XFS_SB_FEAT_INCOMPAT_META_UUID feature.
-+ */
- #define XFS_SB_FEAT_INCOMPAT_SUPPORTED \
- 	(XFS_SB_FEAT_INCOMPAT_FTYPE | \
-+	 XFS_SB_FEAT_INCOMPAT_SPINODES | \
- 	 XFS_SB_FEAT_INCOMPAT_META_UUID)
- 
- struct grub_xfs_sblock
--- 
-cgit v1.0-41-gc330
-
-