From 98da28576517634e745ac6a4b65cf869a14bce79 Mon Sep 17 00:00:00 2001 From: Patrick J Volkerding Date: Mon, 8 Apr 2019 20:39:32 +0000 Subject: Mon Apr 8 20:39:32 UTC 2019 a/glibc-zoneinfo-2019a-noarch-1.txz: Upgraded. a/grub-2.02-x86_64-5.txz: Rebuilt. Support F2FS filesystem. Thanks to Nille_kungen. ap/cups-filters-1.22.5-x86_64-1.txz: Upgraded. ap/itstool-2.0.6-x86_64-1.txz: Upgraded. d/python-setuptools-41.0.0-x86_64-1.txz: Upgraded. l/gobject-introspection-1.60.1-x86_64-1.txz: Upgraded. l/imagemagick-6.9.10_39-x86_64-1.txz: Upgraded. l/libcroco-0.6.13-x86_64-1.txz: Upgraded. l/libnotify-0.7.8-x86_64-1.txz: Upgraded. n/cifs-utils-6.9-x86_64-1.txz: Upgraded. n/nfs-utils-2.3.3-x86_64-2.txz: Rebuilt. Include recovery directory. Thanks to upnort. n/samba-4.10.2-x86_64-1.txz: Upgraded. This is a security release in order to address the following defects: World writable files in Samba AD DC private/ dir. Save registry file outside share as unprivileged user. For more information, see: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-3870 https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2019-3880 (* Security fix *) x/libva-2.4.1-x86_64-1.txz: Upgraded. x/pixman-0.38.2-x86_64-1.txz: Upgraded. xap/gimp-2.10.10-x86_64-1.txz: Upgraded. --- source/a/grub/grub.f2fs.patch | 1514 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1514 insertions(+) create mode 100644 source/a/grub/grub.f2fs.patch (limited to 'source/a/grub/grub.f2fs.patch') diff --git a/source/a/grub/grub.f2fs.patch b/source/a/grub/grub.f2fs.patch new file mode 100644 index 000000000..527715303 --- /dev/null +++ b/source/a/grub/grub.f2fs.patch @@ -0,0 +1,1514 @@ +From 71f9e4ac44142af52c3fc1860436cf9e432bf764 Mon Sep 17 00:00:00 2001 +From: Jaegeuk Kim +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 +Signed-off-by: Pete Batard +Signed-off-by: Daniel Kiper +Reviewed-by: Daniel Kiper +--- + 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 ++ * ++ * 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 . ++ */ ++ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++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 + + -- cgit v1.2.3-65-gdbad