Vladimir prefers to postpone new features until 2.02 is out. From my side I think it is isolated enough and new code so low regression risk. Vladimir has the final word as maintainer :)
On Thu, Aug 4, 2016 at 8:06 PM, Jaegeuk Kim <jaeg...@kernel.org> wrote: > Hi Andrei, > > It's been sitting for a long long time. > May I ask whether or not there is any merging plan of this? > > Thanks, > > On Thu, Mar 03, 2016 at 01:36:53PM -0800, Jaegeuk Kim wrote: >> Change log from v7: >> - fix an offset bug in read_file >> >> -- >8 -- >> From d774cdecc2fee18ed44098c88d2a54d358bc04d3 Mon Sep 17 00:00:00 2001 >> From: Jaegeuk Kim <jaeg...@kernel.org> >> Date: Tue, 17 Nov 2015 12:45:13 -0800 >> Subject: [PATCH] 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 <jaeg...@kernel.org> >> --- >> Makefile.util.def | 7 + >> docs/grub.texi | 5 +- >> 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 +- >> 7 files changed, 1332 insertions(+), 4 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 db7e8ec..84627bb 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; >> @@ -766,6 +767,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 1df3db2..e5a80f3 100644 >> --- a/docs/grub.texi >> +++ b/docs/grub.texi >> @@ -360,7 +360,8 @@ blocklist notation. The currently supported filesystem >> types are @dfn{Amiga >> Fast FileSystem (AFFS)}, @dfn{AtheOS fs}, @dfn{BeFS}, >> @dfn{BtrFS} (including raid0, raid1, raid10, gzip and lzo), >> @dfn{cpio} (little- and big-endian bin, odc and newc variants), >> -@dfn{Linux ext2/ext3/ext4}, @dfn{DOS FAT12/FAT16/FAT32}, @dfn{exFAT}, >> @dfn{HFS}, >> +@dfn{Linux ext2/ext3/ext4}, @dfn{DOS FAT12/FAT16/FAT32}, @dfn{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}, >> @@ -5347,7 +5348,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 d9fa0e3..b585ade 100644 >> --- a/grub-core/Makefile.core.def >> +++ b/grub-core/Makefile.core.def >> @@ -1278,6 +1278,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..7fb256f >> --- /dev/null >> +++ b/grub-core/fs/f2fs.c >> @@ -0,0 +1,1289 @@ >> +/* >> + * f2fs.c - Flash-Friendly File System >> + * >> + * Written by Jaegeuk Kim <jaeg...@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) >> + >> +/* 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..e3e4109 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;; >> @@ -265,6 +265,10 @@ for >> ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + >> x"btrfs"*) >> FSLABEL="grub_;/testé莭莽😁киритi >> urewfceniuewruevrewnuuireurevueurnievrewfnerfcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvrevuurerejiremvreijnvcreivire >> nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoif";; >> >> + # 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éт ;/莭莽😁кир";; >> @@ -474,7 +478,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 +757,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.6.3 >> >> >> ------------------------------------------------------------------------------ >> Site24x7 APM Insight: Get Deep Visibility into Application Performance >> APM + Mobile APM + RUM: Monitor 3 App instances at just $35/Month >> Monitor end-to-end web transactions and take corrective actions now >> Troubleshoot faster and improve end-user experience. Signup Now! >> http://pubads.g.doubleclick.net/gampad/clk?id=272487151&iu=/4140 >> _______________________________________________ >> Linux-f2fs-devel mailing list >> linux-f2fs-de...@lists.sourceforge.net >> https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel _______________________________________________ Grub-devel mailing list Grub-devel@gnu.org https://lists.gnu.org/mailman/listinfo/grub-devel
