summarylogtreecommitdiffstats
diff options
context:
space:
mode:
authorJoe Maples2016-05-08 14:51:51 -0400
committerJoe Maples2016-05-08 14:51:51 -0400
commite3da971d6d780ee6df92ccfe9474e58bd54ebe27 (patch)
treefedc3427c83c2196b38ffde372853e744da263ca
parent37703ae85d9773fdc3f3d8ddcb773ad71c59e09c (diff)
downloadaur-e3da971d6d780ee6df92ccfe9474e58bd54ebe27.tar.gz
Add f2fs patch and PKGBUILD support
Signed-off-by: Joe Maples <joe@frap129.org>
-rw-r--r--PKGBUILD21
-rw-r--r--grub-add-f2fs-support-v8.patch1457
2 files changed, 1472 insertions, 6 deletions
diff --git a/PKGBUILD b/PKGBUILD
index 4cd9372be360..15e0355f87e3 100644
--- a/PKGBUILD
+++ b/PKGBUILD
@@ -1,4 +1,5 @@
-# Maintainer : Keshav Amburay <(the ddoott ridikulus ddoott rat) (aatt) (gemmaeiil) (ddoott) (ccoomm)>
+# Maintainer : Joe Maples <joe@frap129.org>
+# Contributor: Keshav Amburay <(the ddoott ridikulus ddoott rat) (aatt) (gemmaeiil) (ddoott) (ccoomm)>
# Contributor: Zack Buhman
# Contributor: Tobias Powalowski <tpowa@archlinux.org>
# Contributor: Ronald van Haren <ronald.archlinux.org>
@@ -18,10 +19,10 @@ _UNIFONT_VER="6.3.20131217"
[[ "${CARCH}" == "i686" ]] && _EMU_ARCH="i386"
_pkgname="grub"
-pkgname="${_pkgname}-git"
+pkgname="${_pkgname}-f2fs"
-pkgdesc="GNU GRand Unified Bootloader (2) - GIT Version"
-pkgver=2.02.beta2.428.g697ecef
+pkgdesc="GNU GRand Unified Bootloader (2) - GIT Version with F2FS Support"
+pkgver=2.02.beta3.16.gb524fa2
pkgrel=1
url="https://www.gnu.org/software/grub/"
arch=('x86_64' 'i686')
@@ -30,7 +31,7 @@ backup=('boot/grub/grub.cfg' 'etc/default/grub' 'etc/grub.d/40_custom')
install="${_pkgname}.install"
options=('!makeflags')
-conflicts=('grub' 'grub-common' 'grub-bios' "grub-efi-${_EFI_ARCH}" 'grub-emu' 'grub-bzr' 'grub-legacy')
+conflicts=('grub' 'grub-common' 'grub-bios' "grub-efi-${_EFI_ARCH}" 'grub-emu' 'grub-bzr' 'grub-legacy' 'grub-git')
provides=("grub=${pkgver}" "grub-common=${pkgver}" "grub-bios=${pkgver}" "grub-efi-${_EFI_ARCH}=${pkgver}" "grub-emu=${pkgver}" "grub-bzr=${pkgver}")
makedepends=('git' 'rsync' 'xz' 'freetype2' 'ttf-dejavu' 'python' 'autogen'
@@ -42,7 +43,8 @@ optdepends=('freetype2: For grub-mkfont usage'
'efibootmgr: For grub-install EFI support'
'libisoburn: Provides xorriso for generating grub rescue iso using grub-mkrescue'
'os-prober: To detect other OSes when generating grub.cfg in BIOS systems'
- 'mtools: For grub-mkrescue FAT FS support')
+ 'mtools: For grub-mkrescue FAT FS support'
+ 'f2fs-tools: For f2fs filesystem support')
if [[ "${_GRUB_EMU_BUILD}" == "1" ]]; then
makedepends+=('libusbx' 'sdl')
@@ -56,6 +58,7 @@ source=("grub::git+git://git.sv.gnu.org/grub.git#branch=master"
"http://ftp.gnu.org/gnu/unifont/unifont-${_UNIFONT_VER}/unifont-${_UNIFONT_VER}.bdf.gz.sig"
'grub-10_linux-detect-archlinux-initramfs.patch'
'grub-add-GRUB_COLOR_variables.patch'
+ 'grub-add-f2fs-support-v8.patch'
'60_memtest86+'
'grub.default'
'grub.cfg')
@@ -66,6 +69,7 @@ sha1sums=('SKIP'
'SKIP'
'7ffd63c38d74f969f72e38fea3500345c5b968b2'
'c03d2ea83aa6a44dc383fbf67c29c20469e57f1b'
+ '13ef175e398f56af052330331a54b853e0f29031'
'10e30eb68fb95c86301112ac95c5b7515413152a'
'55cf103b60f405bd37d44dd24357dedfff0214ee'
'5b7fcb0718a23035c039eb2fda9e088bb13ae611')
@@ -89,6 +93,11 @@ prepare() {
## Based on http://lists.gnu.org/archive/html/grub-devel/2012-02/msg00021.html
patch -Np1 -i "${srcdir}/grub-add-GRUB_COLOR_variables.patch"
echo
+
+ msg "Patch to enable f2fs filesystem support"
+ ## Based on https://lists.gnu.org/archive/html/grub-devel/2016-03/msg00080.html
+ patch -Np1 -i "${srcdir}/grub-add-f2fs-support-v8.patch"
+ echo
msg "Fix DejaVuSans.ttf location so that grub-mkfont can create *.pf2 files for starfield theme"
sed 's|/usr/share/fonts/dejavu|/usr/share/fonts/dejavu /usr/share/fonts/TTF|g' -i "${srcdir}/grub/configure.ac"
diff --git a/grub-add-f2fs-support-v8.patch b/grub-add-f2fs-support-v8.patch
new file mode 100644
index 000000000000..3f72b8f643f6
--- /dev/null
+++ b/grub-add-f2fs-support-v8.patch
@@ -0,0 +1,1457 @@
+From 267e58a541d07806820a2f78995fc9f18eb73518 Mon Sep 17 00:00:00 2001
+From: Joe Maples <joe@frap129.org>
+Date: Sun, 8 May 2016 14:38:56 -0400
+Subject: [PATCH] [f2fs-dev] [PATCH v8] 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
+
+Signed-off-by: Jaegeuk Kim <address@hidden>
+---
+ Makefile.util.def | 7 +
+ grub-core/Makefile.core.def | 5 +
+ grub-core/fs/f2fs.c | 1289 ++++++++++++++++++++++++++++++++++++++++++
+ po/exclude.pot | 1 +
+ tests/f2fs_test.in | 19 +
+ tests/util/grub-fs-tester.in | 10 +-
+ 6 files changed, 1328 insertions(+), 3 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/grub-core/Makefile.core.def b/grub-core/Makefile.core.def
+index 58b4208..c6343d9 100644
+--- a/grub-core/Makefile.core.def
++++ b/grub-core/Makefile.core.def
+@@ -1289,6 +1289,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..e2336d5
+--- /dev/null
++++ b/grub-core/fs/f2fs.c
+@@ -0,0 +1,1289 @@
++/*
++ * f2fs.c - Flash-Friendly File System
++ *
++ * Written by Jaegeuk Kim <address@hidden>
++ *
++ * 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)
++
++/* 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 */
++
++enum FILE_TYPE
++{
++ F2FS_FT_UNKNOWN,
++ F2FS_FT_REG_FILE = 1,
++ F2FS_FT_DIR = 2,
++ F2FS_FT_SYMLINK = 7,
++};
++
++#define MAX_VOLUME_NAME 512
++
++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;
++ char buf[F2FS_BLKSIZE - 40]; /* Should occupy F2FS_BLKSIZE totally */
++ };
++ 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 inline int
++grub_f2fs_test_bit_le (int nr, const grub_uint8_t *addr)
++{
++ return addr[nr >> 3] & (1 << (nr & 7));
++}
++
++static inline char *
++__inline_addr (struct grub_f2fs_inode *inode)
++{
++ return (char *)&inode->i_addr[1];
++}
++
++static inline grub_uint64_t
++grub_f2fs_file_size (struct grub_f2fs_inode *inode)
++{
++ return grub_le_to_cpu64 (inode->i_size);
++}
++
++static inline grub_uint32_t
++__start_cp_addr (struct grub_f2fs_data *data)
++{
++ struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
++ grub_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 inline grub_uint32_t
++__start_sum_block (struct grub_f2fs_data *data)
++{
++ struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
++
++ return __start_cp_addr (data) + grub_le_to_cpu32 (ckpt->cp_pack_start_sum);
++}
++
++static inline grub_uint32_t
++__sum_blk_addr (struct grub_f2fs_data *data, int base, int type)
++{
++ struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
++
++ return __start_cp_addr (data) +
++ grub_le_to_cpu32 (ckpt->cp_pack_total_block_count)
++ - (base + 1) + type;
++}
++
++static inline void *
++__nat_bitmap_ptr (struct grub_f2fs_data *data)
++{
++ struct grub_f2fs_checkpoint *ckpt = &data->ckpt;
++ grub_uint32_t offset;
++
++ if (grub_le_to_cpu32 (data->sblock.cp_payload) > 0)
++ return ckpt->sit_nat_version_bitmap;
++
++ offset = grub_le_to_cpu32 (ckpt->sit_ver_bitmap_bytesize);
++ return ckpt->sit_nat_version_bitmap + offset;
++}
++
++static inline grub_uint32_t
++__get_node_id (struct grub_f2fs_node *rn, int off, int 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 inline grub_err_t
++grub_f2fs_block_read (struct grub_f2fs_data *data, grub_uint32_t blkaddr, void *buf)
++{
++ return grub_disk_read (data->disk,
++ ((grub_disk_addr_t)blkaddr) << F2FS_BLK_SEC_BITS,
++ 0, F2FS_BLKSIZE, buf);
++}
++
++/*
++ * CRC32
++*/
++#define CRCPOLY_LE 0xedb88320
++
++static inline 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 inline 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 inline 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 = __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 *) __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 424de22..b440886 100644
+--- a/tests/util/grub-fs-tester.in
++++ b/tests/util/grub-fs-tester.in
+@@ -142,7 +142,7 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
+ xsquash*)
+ MINBLKSIZE=4096
+ MAXBLKSIZE=1048576;;
+- xxfs)
++ xxfs|xf2fs)
+ MINBLKSIZE=$SECSIZE
+ # OS Limitation: GNU/Linux doesn't accept > 4096
+ MAXBLKSIZE=4096;;
+@@ -264,7 +264,9 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
+ # FS LIMITATION: btrfs label is at most 255 UTF-8 chars
+ x"btrfs"*)
+ FSLABEL="grub_;/testé莭莽😁киритi urewfceniuewruevrewnuuireurevueurnievrewfnerfcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvrevuurerejiremvreijnvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoif";;
+-
++ # FS LIMITATION: f2fs label is at most 512 UTF-16 chars
++ x"f2fs")
++ FSLABEL="grub_;/testé䏌䐓䏕киритi urewfceniuewruewnuuireurevueurnievrewfnerfcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvrevuurerejiremvreijnvvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoirvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoircreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoifoiq";;
+ # FS LIMITATION: exfat is at most 15 UTF-16 chars
+ x"exfat")
+ FSLABEL="géт ;/莭莽😁кир";;
+@@ -474,7 +476,7 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
+ # FIXME: Not sure about BtrFS, NTFS, JFS, AFS, UDF and SFS. Check it.
+ # FS LIMITATION: as far as I know those FS don't store their last modification date.
+ x"jfs_caseins" | x"jfs" | x"xfs" | x"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;;
+@@ -753,6 +755,8 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
+ MOUNTDEVICE="/dev/mapper/grub_test-testvol"
+ MOUNTFS=ext2
+ "mkfs.ext2" -L "$FSLABEL" -q "${MOUNTDEVICE}" ;;
++ xf2fs)
++ "mkfs.f2fs" -l "$FSLABEL" -q "${LODEVICES[0]}" ;;
+ xnilfs2)
+ "mkfs.nilfs2" -L "$FSLABEL" -b $BLKSIZE -q "${LODEVICES[0]}" ;;
+ xext2_old)
+--
+2.8.0
+