F2FS support
PATCH 1/1 F2FS support
* Makefile.util.def: Add f2fs.c.
* doc/grub.texi: Add f2fs description.
* grub-core/Makefile.core.def: Add f2fs module.
* grub-core/fs/f2fs.c: New file.
* tests/f2fs_test.in: New file.
* tests/util/grub-fs-tester.in: Add f2fs requirements.
--- ChangeLog-2015 | 11 + Makefile.util.def | 7 + docs/grub.texi | 5 +- grub-core/Makefile.core.def | 5 + grub-core/fs/f2fs.c | 1321 ++++++++++++++++++++++++++++++++++++++++++ po/exclude.pot | 1 + tests/f2fs_test.in | 19 + tests/util/grub-fs-tester.in | 14 +- 8 files changed, 1378 insertions(+), 5 deletions(-) create mode 100644 grub-core/fs/f2fs.c create mode 100644 tests/f2fs_test.in
ChangeLog-2015 +11 -0
@@ -1,3 +1,14 @@ +2015-03-12 Jaegeuk Kim <[email protected]> + + F2FS support. + + * Makefile.util.def: Add f2fs.c. + * doc/grub.texi: Add f2fs description. + * grub-core/Makefile.core.def: Add f2fs module. + * grub-core/fs/f2fs.c: New file. + * tests/f2fs_test.in: New file. + * tests/util/grub-fs-tester.in: Add f2fs requirements. + 2015-01-23 Vladimir Serbinenko <[email protected]> * tests/file_filter/file: Really add missing file.
Makefile.util.def +7 -0
@@ -98,6 +98,7 @@ library = { common = grub-core/fs/newc.c; common = grub-core/fs/ext2.c; common = grub-core/fs/fat.c; + common = grub-core/fs/f2fs.c; common = grub-core/fs/exfat.c; common = grub-core/fs/fshelp.c; common = grub-core/fs/hfs.c;
@@ -767,6 +768,12 @@ script = { script = { testcase; + name = f2fs_test; + common = tests/f2fs_test.in; +}; + +script = { + testcase; name = nilfs2_test; common = tests/nilfs2_test.in; };
docs/grub.texi +3 -2
@@ -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{f2fs}, +@dfn{exFAT}, @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},
@@ -5289,7 +5290,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
grub-core/Makefile.core.def +5 -0
@@ -1281,6 +1281,11 @@ module = { }; module = { + name = f2fs; + common = fs/f2fs.c; +}; + +module = { name = exfat; common = fs/exfat.c; };
grub-core/fs/f2fs.c new file +1321 -0
1,321 lines not on this page · raw message
po/exclude.pot +1 -0
@@ -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 ""
tests/f2fs_test.in new file +19 -0
@@ -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
tests/util/grub-fs-tester.in +11 -3
@@ -36,7 +36,7 @@ case x"$fs" in MINLOGSECSIZE=8 # OS LIMITATION: It could go up to 32768 but Linux rejects sector sizes > 4096 MAXLOGSECSIZE=12;; - xxfs) + xxfs|xf2fs) MINLOGSECSIZE=9 # OS LIMITATION: GNU/Linux doesn't accept > 4096 MAXLOGSECSIZE=12;;
@@ -135,6 +135,10 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + fi MAXBLKSIZE=4096 ;; + xf2fs) + MINBLKSIZE=$SECSIZE + # OS Limitation: GNU/Linux doesn't accept > 4096 + MAXBLKSIZE=4096;; xsquash*) MINBLKSIZE=4096 MAXBLKSIZE=1048576;;
@@ -256,7 +260,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: btrfs label is at most 512 UTF-16 chars + x"f2fs") + FSLABEL="grub_;/testjaegeuk kim f2fsaskdfjkasdlfajskdfjaksdjfkjaskjkjkzjkjckzjvkcjkjkjekqjkwejkqwrlkasdfjksadjflaskdhzxhvjzxchvjzkxchvjkhakjsdhfjkhqjkwehrjkhasjkdfhjkashdfjkhjzkxhcjkvzhxcjkvhzxjchvkzhxckjvhjzkxchvjkhzjkxchvjkzhxckjvhzkxjchvkjzxhckjvzxcjkvhjzxkchkvjhzxkjcvhjkhjkahsjkdhkjqhwekrjhakjsdfhkjashdkjzhxcvjkhzxcvzxcvggggggggggf";; # FS LIMITATION: exfat is at most 15 UTF-16 chars x"exfat") FSLABEL="géт ;/莭莽😁кир";;
@@ -466,7 +472,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"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;;
@@ -745,6 +751,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)
Signature · 13 lines
2.1.1 ------------------------------------------------------------------------------ Dive into the World of Parallel Programming The Go Parallel Website, sponsored by Intel and developed in partnership with Slashdot Media, is your hub for all things parallel software development, from weekly thought leadership blogs to news, videos, case studies, tutorials and more. Take a look and join the conversation now. http://goparallel.sourceforge.net/ _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
В Tue, 24 Mar 2015 01:19:00 -0700
Jaegeuk Kim <[email protected]> пишет:
Quoted 7 lines
* Makefile.util.def: Add
f2fs.c.
* doc/grub.texi: Add f2fs description.
* grub-core/Makefile.core.def: Add f2fs module.
*grub-core/fs/f2fs.c: New file.
* tests/f2fs_test.in: New file.
* tests/util/grub-fs-tester.in: Add f2fs requirements.
It's not the most useful commit message. Better would be short explanation of use cases and intended platforms. I'm curious here - F2FS is intended for raw flash access, on which platform(s) grub has access to such devices?
ChangeLog-2015
Quoted 2 lines
ChangeLog-2015 +0
-0
We do not use ChangeLog any more, it is autogenerated from commits. This file is legacy before this change, do not change it.
Quoted 42 lines
grub-core/fs/f2fs.c new file +36
-0@@ -0,0 +1,1321 @@ +/* +* f2fs.c - Flash-Friendly File System +* +* Written by Jaegeuk Kim <[email protected]> +* +* 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 + +/* byte-size offset */
grub-core/fs/f2fs.c line 46
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+#define F2FS_SUPER_OFFSET 1024 + +/* 12 bits for 4096 bytes */ +#define F2FS_MAX_LOG_SECTOR_SIZE 12 + +/* 9 bits for 512 bytes */ +#define F2FS_MIN_LOG_SECTOR_SIZE 9 + +/* support only 4KB block */ +#define F2FS_BLKSIZE 4096
(2 << F2FS_BLK_BITS)?
grub-core/fs/f2fs.c line 48
Quoted 2 lines
grub-core/fs/f2fs.c new file +2
-0+#define F2FS_BLK_BITS 12 +#define F2FS_BLK_SEC_BITS (3)
It is confusing to have some defines parenthesized and some not. Could it be unified somehow?
Also this can be computed from F2FS_BLK_BITS and GRUB_DISK_SECTOR_BITS
- one magic number less.
...
grub-core/fs/f2fs.c line 218
Quoted 3 lines
grub-core/fs/f2fs.c new file +3
-0+struct grub_f2fs_inline_dentry +{ +grub_uint8_t dentry_bitmap[INLINE_DENTRY_BITMAP_SIZE ];
This is cast to grub_uint32_t everywhere. Can it be non-multiple of 4 bytes? If not, may be just define as such?
grub-core/fs/f2fs.c line 225
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+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 ];
ditto
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+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 ; +
...
grub-core/fs/f2fs.c line 79
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+ +#define ver_after (a, b) (typecheck (unsigned long long, a) && \ + typecheck (unsigned long long, b) && \ + ((long long)((a) - (b)) > 0)) +
Where typecheck definition comes from?
...
grub-core/fs/f2fs.c line 328
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+ +static inline int +__test_bit (int nr,grub_uint32_t *addr) +{ +return 1UL & (addr[nr /32 ] >> (nr & (31 )));
Extra parenthesis (31)
grub-core/fs/f2fs.c
Quoted 2 lines
grub-core/fs/f2fs.c new file +2
-0+} +
It is used for dentry_bitmap which is kept in LE format and not converted as far as I can tell. This needs fixing for BE systems. Linux kernel is explicitly using test_bit_le here. This will also work for inode flags (just skip explicit conversion).
There are two functions with more or less identical names. May be make them
grub_f2fs_test_bit_le32grub_f2fs_test_bit
As a general comment - marking non-modified arguments as const everywhere would be good.
grub-core/fs/f2fs.c line 334
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+static inline char * +__inline_addr (struct grub_f2fs_inode *inode) +{ +return (char *)&(inode->i_addr[1 ]);
Redundant parens around inode->
grub-core/fs/f2fs.c line 338
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+} + +static inline grub_uint64_t +__i_size (struct grub_f2fs_inode *inode)
Could we make it grub_f2fs_file_size or similar? i_size really does not tell much outside of linux kernel.
Quoted 29 lines
grub-core/fs/f2fs.c new file +29
-0+{ +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_uint64_t ckpt_version =grub_le_to_cpu64 (ckpt->checkpoint_ver); +grub_uint32_t start_addr = data->cp_blkaddr; + +if (!(ckpt_version &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; +
grub-core/fs/f2fs.c line 377
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+return __start_cp_addr (data) + +grub_le_to_cpu32 (ckpt->cp_pack_total_block_count) + - (base +1 ) + type; +} + +static inline int +__ckpt_flag_set (struct grub_f2fs_checkpoint *ckpt,unsigned int f) +{ +grub_uint32_t ckpt_flags =grub_le_to_cpu32 (ckpt->ckpt_flags); +return ckpt_flags & f;
All flags are constant so you can simply do
ckpt->ckpt_flags & grub_cpu_to_le32_compile_time (FLAG)
in place to avoid extra calls. This makes function redundant.
grub-core/fs/f2fs.c line 385
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+} + +static inline int +__inode_flag_set (struct grub_f2fs_inode *inode,int flag) +{ +grub_uint32_t i_flags =grub_le_to_cpu32 (inode->i_flags); +return __test_bit (flag, &i_flags); +}
grub_f2fs_test_bit_le32?
grub-core/fs/f2fs.c line 429
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+ +/* +* CRC32 +*/ +#define CRCPOLY_LE 0xedb88320 + +static inline grub_uint32_t +grub_f2fs_cal_crc32 (grub_uint32_t crc,void *buf,int len)
Why crc is parameter here? This function is used exactly once with fixed value for initial crc.
Quoted 18 lines
grub-core/fs/f2fs.c new file +18
-0+{ +int i; +unsigned char *p = (unsigned char *)buf; + +while (len--) + { + 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,int len) +{ +grub_uint32_t cal_crc =0 ; +
grub-core/fs/f2fs.c line 457
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ cal_crc =grub_f2fs_cal_crc32 (F2FS_SUPER_MAGIC , 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; +char *addr = (char *)p;
Why cast? We are not going to modify it, right?
grub-core/fs/f2fs.c line 469
Quoted 12 lines
grub-core/fs/f2fs.c new file +12
-0+ + addr += (nr >>3 ); + mask =1 << (7 - (nr &0x07 )); +return (mask & *addr) !=0 ; +} + +static int +grub_f2fs_sanity_check_sb (struct grub_f2fs_superblock *sb) +{ +unsigned int blocksize; + +if (F2FS_SUPER_MAGIC !=grub_le_to_cpu32 (sb->magic))
sb->magic != grub_cpu_to_le32_compile_time (F2FS_SUPER_MAGIC)
grub-core/fs/f2fs.c line 473
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+return -1 ; + + blocksize =1 <<grub_le_to_cpu32 (sb->log_blocksize); +if (blocksize !=F2FS_BLKSIZE )
sb->log_blksize != grub_cpu_to_le32_compile_time (F2FS_BLK_BITS)
grub-core/fs/f2fs.c line 483
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+return -1 ; + +if (grub_le_to_cpu32 (sb->log_sectorsize) >F2FS_MAX_LOG_SECTOR_SIZE ) +return -1 ; + +if (grub_le_to_cpu32 (sb->log_sectorsize) <F2FS_MIN_LOG_SECTOR_SIZE ) +return -1 ; + +if (grub_le_to_cpu32 (sb->log_sectors_per_block) + +grub_le_to_cpu32 (sb->log_sectorsize) !=F2FS_MAX_LOG_SECTOR_SIZE )
Should not it be F2FS_BLKSIZE? At least it sounds logical. Also please convert log_sectorsize just once.
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+return -1 ; + +return 0 ; +} + +static grub_err_t +grub_f2fs_read_sb (struct grub_f2fs_data *data,int block)
grub-core/fs/f2fs.c line 500
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+{ +grub_disk_t disk = data->disk; +grub_uint64_t offset; +grub_err_t err; + +if (block ==0 ) + offset =F2FS_SUPER_OFFSET ; +else + offset =F2FS_BLKSIZE +F2FS_SUPER_OFFSET ; +
Please name it "secondary" or similar instead of "block" to avoid confusion. You do not really want to read arbitrary block, right?
offset = F2FS_SUPER_OFFEST;
if (secondary)
offset += F2FS_BLKSIZE;
Quoted 28 lines
grub-core/fs/f2fs.c new file +28
-0+/* Read first super block. */ + err =grub_disk_read (disk, offset >>GRUB_DISK_SECTOR_BITS ,0 , +sizeof (data->sblock), &data->sblock); +if (err) +return err; + +if (grub_f2fs_sanity_check_sb (&data->sblock)) + err =GRUB_ERR_BAD_FS ; + +return err; +} + +static void * +validate_checkpoint (struct grub_f2fs_data *data,grub_uint32_t cp_addr, +grub_uint64_t *version) +{ +void *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 ; +
grub-core/fs/f2fs.c line 538
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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 >=F2FS_BLKSIZE ) + goto invalid_cp1; + + crc = *(grub_uint32_t *)((char *)cp_block + crc_offset);
Is unaligned access possible here? If yes, it probably should be grub_get_unaligned32.
grub-core/fs/f2fs.c line 541
Quoted 3 lines
grub-core/fs/f2fs.c new file +3
-0+if (!grub_f2fs_crc_valid (crc, cp_block, crc_offset)) + goto invalid_cp1; +
Should not CRC be converted from LE?
Quoted 9 lines
grub-core/fs/f2fs.c new file +9
-0+ 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 ; +
grub-core/fs/f2fs.c line 560
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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 >=F2FS_BLKSIZE ) + goto invalid_cp2; + + crc = *(grub_uint32_t *)((char *)cp_block + crc_offset);
Ditto alignment.
Quoted 1 line
+ if (!grub_f2fs_crc_valid (crc,
cp_block,crc_offset))
Ditto endianness.
Quoted 49 lines
grub-core/fs/f2fs.c new file +49
-0+ 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
grub-core/fs/f2fs.c line 620
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+return grub_error (GRUB_ERR_BAD_FS ,"no checkpoints\n" ); + +grub_memcpy (&data->ckpt, cur_page,F2FS_BLKSIZE ); + +grub_free (cp1); +grub_free (cp2); +return 0 ; +} + +static int
static grub_error_t
grub-core/fs/f2fs.c line 633
Quoted 13 lines
grub-core/fs/f2fs.c new file +13
-0+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 ))
As mentioned, use grub_cpu_to_leXX_compile_time to avoid run time conversion.
Quoted 18 lines
grub-core/fs/f2fs.c new file +18
-0+ 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; +} +
...
Quoted 40 lines
grub-core/fs/f2fs.c new file +40
-0+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_flag_set (inode,FI_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 ;
grub-core/fs/f2fs.c line 760
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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 ];
That does not fit. You declared offset and noffset as arrays of four elements and pass arrays of four elements; here is out of bound access already.
Quoted 43 lines
grub-core/fs/f2fs.c new file +43
-0+ 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 +load_nat_info (struct grub_f2fs_data *data) +{ +void *version_bitmap; +grub_err_t err;
grub-core/fs/f2fs.c line 813
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ + data->nat_bitmap =grub_malloc (__nat_bitmap_size (data)); +if (!data->nat_bitmap) +return grub_errno; + + version_bitmap =__nat_bitmap_ptr (data); + +/* copy version bitmap */ +grub_memcpy (data->nat_bitmap, version_bitmap,__nat_bitmap_size (data)); +
Any reason to actually copy it? Why is it not possible to just set pointer to source, which is available all the time anyway?
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+ err =get_nat_journal (data); +if (err) +grub_free (data->nat_bitmap); + +return err; +} + +static grub_err_t
grub-core/fs/f2fs.c line 831
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+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);
Is struct grub_f2fs_node guaranteed to always have the same size as F2FS block? Then adding char [F2FS_BLKSIZE] to union to make it obvious is better and ensures that it will always be at least this size.
Quoted 11 lines
grub-core/fs/f2fs.c new file +11
-0+} + +static struct grub_f2fs_data * +grub_f2fs_mount (grub_disk_t disk) +{ +struct grub_f2fs_data *data; +grub_err_t err; + + data =grub_zalloc (sizeof (*data)); +if (!data) +return NULL ;
grub-core/fs/f2fs.c line 852
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ + data->disk = disk; + + err =grub_f2fs_read_sb (data,0 ); +if (err) + { + err =grub_f2fs_read_sb (data,1 ); +if (err) + { +grub_error (GRUB_ERR_BAD_FS ,"not a F2FS filesystem" );
May be mentioning that superblock could not be read? In another place you already tell that checkpoints could not be found. It helps to troubleshoot issues.
Quoted 22 lines
grub-core/fs/f2fs.c new file +22
-0+ 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; + + err =load_nat_info (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;
grub-core/fs/f2fs.c line 884
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ + err =grub_f2fs_read_node (data, data->root_ino, data->inode); +if (err) + goto fail; + +return data; + +fail: +if (data) +grub_free (data->nat_bitmap);
Double free after load_nat_info failure. Assuming that we do need to allocate anything at all (see above).
grub-core/fs/f2fs.c line 891
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+grub_free (data); +return NULL ; +} + +/* guarantee inline_data was handled by caller */ +static grub_disk_addr_t +grub_f2fs_read_block (grub_fshelp_node_t node,grub_disk_addr_t block_ofs)
You have grub_f2fs_read_block and grub_f2fs_block_read. Could we make them more different and self-explaining? In particular, this one does not read anything, it returns disk address. grub_f2fs_map_file_block?
grub-core/fs/f2fs.c line 895
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+{ +struct grub_f2fs_data *data = node->data; +struct grub_f2fs_inode *inode = &node->inode.i; +grub_uint32_t offset[4 ], noffset[4 ], nids[4 ];
See above about overflow in grub_get_inode_path.
Quoted 31 lines
grub-core/fs/f2fs.c new file +31
-0+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; +} +
...
Quoted 15 lines
grub-core/fs/f2fs.c new file +15
-0+ +static char * +grub_f2fs_read_symlink (grub_fshelp_node_t node) +{ +char *symlink; +struct grub_fshelp_node *diro = node; + +if (!diro->inode_read) + { +grub_f2fs_read_node (diro->data, diro->ino, &diro->inode); +if (grub_errno) +return 0 ; + } + + symlink =grub_malloc (__i_size (&diro->inode.i) +1 );
grub-core/fs/f2fs.c line 981
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+if (!symlink) +return 0 ; + +grub_f2fs_read_file (diro,0 ,0 ,0 ,__i_size (&diro->inode.i), symlink); +if (grub_errno) + { +grub_free (symlink); +return 0 ; + } +
What about short read? Is this an error or not?
grub-core/fs/f2fs.c line 994
Quoted 13 lines
grub-core/fs/f2fs.c new file +13
-0+ symlink[__i_size (&diro->inode.i)] ='\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[F2FS_NAME_LEN +1 ];
Could we avoid large stack allocations?
grub-core/fs/f2fs.c line 999
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+enum grub_fshelp_filetype type =GRUB_FSHELP_UNKNOWN ; +enum FILE_TYPE ftype; +int name_len; + +if (__test_bit (i, ctx->bitmap) ==0 )
grub_f2fs_test_bit_le32?
Quoted 33 lines
grub-core/fs/f2fs.c new file +33
-0+ { + i++; +continue ; + } + + ftype = ctx->dentry[i].file_type; + name_len =grub_le_to_cpu16 (ctx->dentry[i].name_len); +grub_memcpy (filename, ctx->filename[i], name_len); + filename[name_len] ='\0' ; + + fdiro =grub_malloc (sizeof (struct grub_fshelp_node )); +if (!fdiro) +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 ; + +if (ctx->hook (filename, type, fdiro, ctx->hook_data)) +return 1 ; + + i += (name_len +F2FS_SLOT_LEN -1 ) /F2FS_SLOT_LEN ; + } +return 0 ; +} +
...
Quoted 41 lines
grub-core/fs/f2fs.c new file +41
-0+ +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_flag_set (inode,FI_INLINE_DENTRY )) +return grub_f2fs_iterate_inline_dir (inode, &ctx); + +while (fpos <__i_size (inode)) + { +struct grub_f2fs_dentry_block *de_blk; +char *buf; + + 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 ; + }
grub-core/fs/f2fs.c line 1098
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ + de_blk = (struct grub_f2fs_dentry_block *) buf; + + ctx.bitmap = (grub_uint32_t *) de_blk->dentry_bitmap; + ctx.dentry = de_blk->dentry; + ctx.filename = de_blk->filename; + ctx.max =NR_DENTRY_IN_BLOCK ; + +if (grub_f2fs_check_dentries (&ctx)) +return 1 ;
memory leak
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+ +grub_free (buf); + + fpos +=F2FS_BLKSIZE ; + } +return 0 ; +} +
...
Quoted 19 lines
grub-core/fs/f2fs.c new file +19
-0+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 );
grub-core/fs/f2fs.c line 1161
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+if (grub_errno) + goto fail; + +grub_f2fs_iterate_dir (fdiro, grub_f2fs_dir_iter, &ctx); + +fail: +if (fdiro != &ctx.data->diropen) +grub_free (fdiro); +if (ctx.data) +grub_free (ctx.data->nat_bitmap);
Triple free :)
Quoted 23 lines
grub-core/fs/f2fs.c new file +23
-0+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 ; + +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)
grub-core/fs/f2fs.c line 1194
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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,F2FS_BLKSIZE );
sizeof (*data->inode)? Or they can be different?
grub-core/fs/f2fs.c line 1207
Quoted 13 lines
grub-core/fs/f2fs.c new file +13
-0+grub_free (fdiro); + + file->size =__i_size (&(data->inode->i)); + file->data = data; + file->offset =0 ; + +return 0 ; + +fail: +if (fdiro != &data->diropen) +grub_free (fdiro); +if (data) +grub_free (data->nat_bitmap);
Again.
Quoted 14 lines
grub-core/fs/f2fs.c new file +14
-0+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,
grub-core/fs/f2fs.c line 1231
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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; + +if (data) +grub_free (data->nat_bitmap);
Again.
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+grub_free (data); + +grub_dl_unref (my_mod); + +return GRUB_ERR_NONE ; +} + +static grub_err_t +grub_f2fs_label (grub_device_t device,char **label) +{
grub-core/fs/f2fs.c line 1251
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+struct grub_f2fs_data *data; +grub_disk_t disk = device->disk; + +grub_dl_ref (my_mod); + + data =grub_f2fs_mount (disk); +if (data) + { + *label =grub_zalloc (sizeof (data->sblock.volume_name)); + grub_utf16_to_utf8 ((grub_uint8_t *) (*label),
malloc failure check?
grub-core/fs/f2fs.c line 1252
Quoted 1 line
grub-core/fs/f2fs.c new file +1
-0+ data->sblock.volume_name, 512);
Where 512 comes from? Should it not be sizeof
(data->sblock.volume_name) as well?
grub-core/fs/f2fs.c line 1258
Quoted 6 lines
grub-core/fs/f2fs.c new file +6
-0+ } +else + *label =NULL ; + +if (data) +grub_free (data->nat_bitmap);
Again.
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+grub_free (data); +grub_dl_unref (my_mod); +return grub_errno; +} +
...
Quoted 25 lines
tests/util/grub-fs-tester.in +5
-1@@ -36,7 +36,7 @@ case x"$fs" in MINLOGSECSIZE=8 # OS LIMITATION: It could go up to 32768 but Linux rejects sector sizes > 4096 MAXLOGSECSIZE=12;; - xxfs) + xxfs|xf2fs) MINLOGSECSIZE=9 # OS LIMITATION: GNU/Linux doesn't accept > 4096 MAXLOGSECSIZE=12;;@@ -135,6 +135,10 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + fi MAXBLKSIZE=4096 ;; + xf2fs) + MINBLKSIZE=$SECSIZE + # OS Limitation: GNU/Linux doesn't accept > 4096 + MAXBLKSIZE=4096;; xsquash*) MINBLKSIZE=4096 MAXBLKSIZE=1048576;;
tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + · line 263
Quoted 5 lines
tests/util/grub-fs-tester.in +1
-1@@ -256,7 +260,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: btrfs label is at most 512 UTF-16 chars
F2FS, not btrfs
tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + · line 265
Quoted 2 lines
tests/util/grub-fs-tester.in +2
-0+ x"f2fs") + FSLABEL="grub_;/testjaegeuk kim
Could you leave initial part in place? This includes some funny UNICODE characters for a reason, actually. Unless this is not possible with f2fs?
f2fsaskdfjkasdlfajskdfjaksdjfkjaskjkjkzjkjckzjvkcjkjkjekqjkwejkqwrlkasdfjksadjflaskdhzxhvjzxchvjzkxchvjkhakjsdhfjkhqjkwehrjkhasjkdfhjkashdfjkhjzkxhcjkvzhxcjkvhzxjchvkzhxckjvhjzkxchvjkhzjkxchvjkzhxckjvhzkxjchvkjzxhckjvzxcjkvhjzxkchkvjhzxkjcvhjkhjkahsjkdhkjqhwekrjhakjsdfhkjashdkjzhxcvjkhzxcvzxcvggggggggggf";;
Quoted 13 lines
tests/util/grub-fs-tester.in +1
-1# FS LIMITATION: exfat is at most 15 UTF-16 chars x"exfat") FSLABEL="géт ;/莭莽😁кир";;@@ -466,7 +472,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"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;;
tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + · line 758
Quoted 8 lines
tests/util/grub-fs-tester.in +2
-0@@ -745,6 +751,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)
_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
Hi Andrei,
Quoted 11 lines · Andrei Borzenkov
В Tue, 24 Mar 2015 01:19:00 -0700
Jaegeuk Kim <[email protected]> пишет:Quoted 7 lines
* Makefile.util.def: Add
f2fs.c.
* doc/grub.texi: Add f2fs description.
* grub-core/Makefile.core.def: Add f2fs module.
*grub-core/fs/f2fs.c: New file.
* tests/f2fs_test.in: New file.
* tests/util/grub-fs-tester.in: Add f2fs requirements.
Quoted 4 lines
It's not the most useful commit message. Better would be short explanation of use cases and intended platforms. I'm curious here - F2FS is intended for raw flash access, on which platform(s) grub has access to such devices?
I just followed the commit convention in grub.git. Anyway I'll add some description in v2.
F2FS is *not* intended for raw flash, for general block device such as SSD, eMMC, and SD cards.
Please refer the following documents.
http://en.wikipedia.org/wiki/F2FS
Thank you for the detailed review.
I'll fix them and send v2.
Sincerely yours,
Quoted 1,081 lines
ChangeLog-2015
Quoted 3 lines
ChangeLog-2015 +0
-0We do not use ChangeLog any more, it is autogenerated from commits. This file is legacy before this change, do not change it.
Quoted 42 lines
grub-core/fs/f2fs.c new file +36
-0@@ -0,0 +1,1321 @@ +/* +* f2fs.c - Flash-Friendly File System +* +* Written by Jaegeuk Kim <[email protected]> +* +* 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 + +/* byte-size offset */ grub-core/fs/f2fs.c line 46
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+#define F2FS_SUPER_OFFSET 1024 + +/* 12 bits for 4096 bytes */ +#define F2FS_MAX_LOG_SECTOR_SIZE 12 + +/* 9 bits for 512 bytes */ +#define F2FS_MIN_LOG_SECTOR_SIZE 9 + +/* support only 4KB block */ +#define F2FS_BLKSIZE 4096(2 <<
F2FS_BLK_BITS)?grub-core/fs/f2fs.c line 48
Quoted 2 lines
grub-core/fs/f2fs.c new file +2
-0+#define F2FS_BLK_BITS 12 +#define F2FS_BLK_SEC_BITS (3)It is confusing to have some defines parenthesized and some not. Could it be unified somehow?
Also this can be computed from
F2FS_BLK_BITSandGRUB_DISK_SECTOR_BITS
- one magic number less....
grub-core/fs/f2fs.c line 218
Quoted 3 lines
grub-core/fs/f2fs.c new file +3
-0+struct grub_f2fs_inline_dentry +{ +grub_uint8_t dentry_bitmap[INLINE_DENTRY_BITMAP_SIZE ];This is cast to
grub_uint32_teverywhere. Can it be non-multiple of 4 bytes? If not, may be just define as such?grub-core/fs/f2fs.c line 225
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+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 ];ditto
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+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 ; +...
grub-core/fs/f2fs.c line 79
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+ +#define ver_after (a, b) (typecheck (unsigned long long, a) && \ + typecheck (unsigned long long, b) && \ + ((long long)((a) - (b)) > 0)) +Where typecheck definition comes from?
...
grub-core/fs/f2fs.c line 328
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+ +static inline int +__test_bit (int nr,grub_uint32_t *addr) +{ +return 1UL & (addr[nr /32 ] >> (nr & (31 )));Extra parenthesis (31)
grub-core/fs/f2fs.c
Quoted 2 lines
grub-core/fs/f2fs.c new file +2
-0+} +It is used for
dentry_bitmapwhich is kept in LE format and not converted as far as I can tell. This needs fixing for BE systems. Linux kernel is explicitly usingtest_bit_lehere. This will also work for inode flags (just skip explicit conversion).There are two functions with more or less identical names. May be make them
grub_f2fs_test_bit_le32grub_f2fs_test_bitAs a general comment - marking non-modified arguments as const everywhere would be good.
grub-core/fs/f2fs.c line 334
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+static inline char * +__inline_addr (struct grub_f2fs_inode *inode) +{ +return (char *)&(inode->i_addr[1 ]);Redundant parens around inode->
grub-core/fs/f2fs.c line 338
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+} + +static inline grub_uint64_t +__i_size (struct grub_f2fs_inode *inode)Could we make it
grub_f2fs_file_sizeor similar?i_sizereally does not tell much outside of linux kernel.Quoted 29 lines
grub-core/fs/f2fs.c new file +29
-0+{ +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_uint64_t ckpt_version =grub_le_to_cpu64 (ckpt->checkpoint_ver); +grub_uint32_t start_addr = data->cp_blkaddr; + +if (!(ckpt_version &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; +grub-core/fs/f2fs.c line 377
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+return __start_cp_addr (data) + +grub_le_to_cpu32 (ckpt->cp_pack_total_block_count) + - (base +1 ) + type; +} + +static inline int +__ckpt_flag_set (struct grub_f2fs_checkpoint *ckpt,unsigned int f) +{ +grub_uint32_t ckpt_flags =grub_le_to_cpu32 (ckpt->ckpt_flags); +return ckpt_flags & f;All flags are constant so you can simply do
ckpt->ckpt_flags&grub_cpu_to_le32_compile_time(FLAG)in place to avoid extra calls. This makes function redundant.
grub-core/fs/f2fs.c line 385
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+} + +static inline int +__inode_flag_set (struct grub_f2fs_inode *inode,int flag) +{ +grub_uint32_t i_flags =grub_le_to_cpu32 (inode->i_flags); +return __test_bit (flag, &i_flags); +}
grub_f2fs_test_bit_le32?grub-core/fs/f2fs.c line 429
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+ +/* +* CRC32 +*/ +#define CRCPOLY_LE 0xedb88320 + +static inline grub_uint32_t +grub_f2fs_cal_crc32 (grub_uint32_t crc,void *buf,int len)Why crc is parameter here? This function is used exactly once with fixed value for initial crc.
Quoted 18 lines
grub-core/fs/f2fs.c new file +18
-0+{ +int i; +unsigned char *p = (unsigned char *)buf; + +while (len--) + { + 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,int len) +{ +grub_uint32_t cal_crc =0 ; +grub-core/fs/f2fs.c line 457
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ cal_crc =grub_f2fs_cal_crc32 (F2FS_SUPER_MAGIC , 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; +char *addr = (char *)p;Why cast? We are not going to modify it, right?
grub-core/fs/f2fs.c line 469
Quoted 12 lines
grub-core/fs/f2fs.c new file +12
-0+ + addr += (nr >>3 ); + mask =1 << (7 - (nr &0x07 )); +return (mask & *addr) !=0 ; +} + +static int +grub_f2fs_sanity_check_sb (struct grub_f2fs_superblock *sb) +{ +unsigned int blocksize; + +if (F2FS_SUPER_MAGIC !=grub_le_to_cpu32 (sb->magic))
sb->magic!=grub_cpu_to_le32_compile_time(F2FS_SUPER_MAGIC)grub-core/fs/f2fs.c line 473
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+return -1 ; + + blocksize =1 <<grub_le_to_cpu32 (sb->log_blocksize); +if (blocksize !=F2FS_BLKSIZE )
sb->log_blksize!=grub_cpu_to_le32_compile_time(F2FS_BLK_BITS)grub-core/fs/f2fs.c line 483
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+return -1 ; + +if (grub_le_to_cpu32 (sb->log_sectorsize) >F2FS_MAX_LOG_SECTOR_SIZE ) +return -1 ; + +if (grub_le_to_cpu32 (sb->log_sectorsize) <F2FS_MIN_LOG_SECTOR_SIZE ) +return -1 ; + +if (grub_le_to_cpu32 (sb->log_sectors_per_block) + +grub_le_to_cpu32 (sb->log_sectorsize) !=F2FS_MAX_LOG_SECTOR_SIZE )Should not it be
F2FS_BLKSIZE? At least it sounds logical. Also please convertlog_sectorsizejust once.Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+return -1 ; + +return 0 ; +} + +static grub_err_t +grub_f2fs_read_sb (struct grub_f2fs_data *data,int block)grub-core/fs/f2fs.c line 500
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+{ +grub_disk_t disk = data->disk; +grub_uint64_t offset; +grub_err_t err; + +if (block ==0 ) + offset =F2FS_SUPER_OFFSET ; +else + offset =F2FS_BLKSIZE +F2FS_SUPER_OFFSET ; +Please name it "secondary" or similar instead of "block" to avoid confusion. You do not really want to read arbitrary block, right?
offset =
F2FS_SUPER_OFFEST;
if (secondary)
offset +=F2FS_BLKSIZE;Quoted 28 lines
grub-core/fs/f2fs.c new file +28
-0+/* Read first super block. */ + err =grub_disk_read (disk, offset >>GRUB_DISK_SECTOR_BITS ,0 , +sizeof (data->sblock), &data->sblock); +if (err) +return err; + +if (grub_f2fs_sanity_check_sb (&data->sblock)) + err =GRUB_ERR_BAD_FS ; + +return err; +} + +static void * +validate_checkpoint (struct grub_f2fs_data *data,grub_uint32_t cp_addr, +grub_uint64_t *version) +{ +void *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 ; +grub-core/fs/f2fs.c line 538
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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 >=F2FS_BLKSIZE ) + goto invalid_cp1; + + crc = *(grub_uint32_t *)((char *)cp_block + crc_offset);Is unaligned access possible here? If yes, it probably should be
grub_get_unaligned32.grub-core/fs/f2fs.c line 541
Quoted 3 lines
grub-core/fs/f2fs.c new file +3
-0+if (!grub_f2fs_crc_valid (crc, cp_block, crc_offset)) + goto invalid_cp1; +Should not CRC be converted from LE?
Quoted 9 lines
grub-core/fs/f2fs.c new file +9
-0+ 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 ; +grub-core/fs/f2fs.c line 560
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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 >=F2FS_BLKSIZE ) + goto invalid_cp2; + + crc = *(grub_uint32_t *)((char *)cp_block + crc_offset);Ditto alignment.
Quoted 1 line
+ if (!grub_f2fs_crc_valid (crc,
cp_block,crc_offset))Ditto endianness.
Quoted 49 lines
grub-core/fs/f2fs.c new file +49
-0+ 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 grub-core/fs/f2fs.c line 620
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+return grub_error (GRUB_ERR_BAD_FS ,"no checkpoints\n" ); + +grub_memcpy (&data->ckpt, cur_page,F2FS_BLKSIZE ); + +grub_free (cp1); +grub_free (cp2); +return 0 ; +} + +static intstatic
grub_error_tgrub-core/fs/f2fs.c line 633
Quoted 13 lines
grub-core/fs/f2fs.c new file +13
-0+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 ))As mentioned, use
grub_cpu_to_leXX_compile_timeto avoid run time conversion.Quoted 18 lines
grub-core/fs/f2fs.c new file +18
-0+ 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; +} +...
Quoted 40 lines
grub-core/fs/f2fs.c new file +40
-0+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_flag_set (inode,FI_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 ;grub-core/fs/f2fs.c line 760
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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 ];That does not fit. You declared offset and noffset as arrays of four elements and pass arrays of four elements; here is out of bound access already.
Quoted 43 lines
grub-core/fs/f2fs.c new file +43
-0+ 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 +load_nat_info (struct grub_f2fs_data *data) +{ +void *version_bitmap; +grub_err_t err;grub-core/fs/f2fs.c line 813
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ + data->nat_bitmap =grub_malloc (__nat_bitmap_size (data)); +if (!data->nat_bitmap) +return grub_errno; + + version_bitmap =__nat_bitmap_ptr (data); + +/* copy version bitmap */ +grub_memcpy (data->nat_bitmap, version_bitmap,__nat_bitmap_size (data)); +Any reason to actually copy it? Why is it not possible to just set pointer to source, which is available all the time anyway?
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+ err =get_nat_journal (data); +if (err) +grub_free (data->nat_bitmap); + +return err; +} + +static grub_err_tgrub-core/fs/f2fs.c line 831
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+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);Is struct
grub_f2fs_nodeguaranteed to always have the same size as F2FS block? Then adding char [F2FS_BLKSIZE] to union to make it obvious is better and ensures that it will always be at least this size.Quoted 11 lines
grub-core/fs/f2fs.c new file +11
-0+} + +static struct grub_f2fs_data * +grub_f2fs_mount (grub_disk_t disk) +{ +struct grub_f2fs_data *data; +grub_err_t err; + + data =grub_zalloc (sizeof (*data)); +if (!data) +return NULL ;grub-core/fs/f2fs.c line 852
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ + data->disk = disk; + + err =grub_f2fs_read_sb (data,0 ); +if (err) + { + err =grub_f2fs_read_sb (data,1 ); +if (err) + { +grub_error (GRUB_ERR_BAD_FS ,"not a F2FS filesystem" );May be mentioning that superblock could not be read? In another place you already tell that checkpoints could not be found. It helps to troubleshoot issues.
Quoted 22 lines
grub-core/fs/f2fs.c new file +22
-0+ 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; + + err =load_nat_info (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;grub-core/fs/f2fs.c line 884
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ + err =grub_f2fs_read_node (data, data->root_ino, data->inode); +if (err) + goto fail; + +return data; + +fail: +if (data) +grub_free (data->nat_bitmap);Double free after
load_nat_infofailure. Assuming that we do need to allocate anything at all (see above).grub-core/fs/f2fs.c line 891
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+grub_free (data); +return NULL ; +} + +/* guarantee inline_data was handled by caller */ +static grub_disk_addr_t +grub_f2fs_read_block (grub_fshelp_node_t node,grub_disk_addr_t block_ofs)You have
grub_f2fs_read_blockandgrub_f2fs_block_read. Could we make them more different and self-explaining? In particular, this one does not read anything, it returns disk address.grub_f2fs_map_file_block?grub-core/fs/f2fs.c line 895
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+{ +struct grub_f2fs_data *data = node->data; +struct grub_f2fs_inode *inode = &node->inode.i; +grub_uint32_t offset[4 ], noffset[4 ], nids[4 ];See above about overflow in
grub_get_inode_path.Quoted 31 lines
grub-core/fs/f2fs.c new file +31
-0+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; +} +...
Quoted 15 lines
grub-core/fs/f2fs.c new file +15
-0+ +static char * +grub_f2fs_read_symlink (grub_fshelp_node_t node) +{ +char *symlink; +struct grub_fshelp_node *diro = node; + +if (!diro->inode_read) + { +grub_f2fs_read_node (diro->data, diro->ino, &diro->inode); +if (grub_errno) +return 0 ; + } + + symlink =grub_malloc (__i_size (&diro->inode.i) +1 );grub-core/fs/f2fs.c line 981
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+if (!symlink) +return 0 ; + +grub_f2fs_read_file (diro,0 ,0 ,0 ,__i_size (&diro->inode.i), symlink); +if (grub_errno) + { +grub_free (symlink); +return 0 ; + } +What about short read? Is this an error or not?
grub-core/fs/f2fs.c line 994
Quoted 13 lines
grub-core/fs/f2fs.c new file +13
-0+ symlink[__i_size (&diro->inode.i)] ='\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[F2FS_NAME_LEN +1 ];Could we avoid large stack allocations?
grub-core/fs/f2fs.c line 999
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+enum grub_fshelp_filetype type =GRUB_FSHELP_UNKNOWN ; +enum FILE_TYPE ftype; +int name_len; + +if (__test_bit (i, ctx->bitmap) ==0 )
grub_f2fs_test_bit_le32?Quoted 33 lines
grub-core/fs/f2fs.c new file +33
-0+ { + i++; +continue ; + } + + ftype = ctx->dentry[i].file_type; + name_len =grub_le_to_cpu16 (ctx->dentry[i].name_len); +grub_memcpy (filename, ctx->filename[i], name_len); + filename[name_len] ='\0' ; + + fdiro =grub_malloc (sizeof (struct grub_fshelp_node )); +if (!fdiro) +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 ; + +if (ctx->hook (filename, type, fdiro, ctx->hook_data)) +return 1 ; + + i += (name_len +F2FS_SLOT_LEN -1 ) /F2FS_SLOT_LEN ; + } +return 0 ; +} +...
Quoted 41 lines
grub-core/fs/f2fs.c new file +41
-0+ +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_flag_set (inode,FI_INLINE_DENTRY )) +return grub_f2fs_iterate_inline_dir (inode, &ctx); + +while (fpos <__i_size (inode)) + { +struct grub_f2fs_dentry_block *de_blk; +char *buf; + + 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 ; + }grub-core/fs/f2fs.c line 1098
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ + de_blk = (struct grub_f2fs_dentry_block *) buf; + + ctx.bitmap = (grub_uint32_t *) de_blk->dentry_bitmap; + ctx.dentry = de_blk->dentry; + ctx.filename = de_blk->filename; + ctx.max =NR_DENTRY_IN_BLOCK ; + +if (grub_f2fs_check_dentries (&ctx)) +return 1 ;memory leak
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+ +grub_free (buf); + + fpos +=F2FS_BLKSIZE ; + } +return 0 ; +} +...
Quoted 19 lines
grub-core/fs/f2fs.c new file +19
-0+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 );grub-core/fs/f2fs.c line 1161
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+if (grub_errno) + goto fail; + +grub_f2fs_iterate_dir (fdiro, grub_f2fs_dir_iter, &ctx); + +fail: +if (fdiro != &ctx.data->diropen) +grub_free (fdiro); +if (ctx.data) +grub_free (ctx.data->nat_bitmap);Triple free :)
Quoted 23 lines
grub-core/fs/f2fs.c new file +23
-0+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 ; + +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)grub-core/fs/f2fs.c line 1194
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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,F2FS_BLKSIZE );sizeof (
*data->inode)? Or they can be different?grub-core/fs/f2fs.c line 1207
Quoted 13 lines
grub-core/fs/f2fs.c new file +13
-0+grub_free (fdiro); + + file->size =__i_size (&(data->inode->i)); + file->data = data; + file->offset =0 ; + +return 0 ; + +fail: +if (fdiro != &data->diropen) +grub_free (fdiro); +if (data) +grub_free (data->nat_bitmap);Again.
Quoted 14 lines
grub-core/fs/f2fs.c new file +14
-0+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,grub-core/fs/f2fs.c line 1231
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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; + +if (data) +grub_free (data->nat_bitmap);Again.
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+grub_free (data); + +grub_dl_unref (my_mod); + +return GRUB_ERR_NONE ; +} + +static grub_err_t +grub_f2fs_label (grub_device_t device,char **label) +{grub-core/fs/f2fs.c line 1251
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+struct grub_f2fs_data *data; +grub_disk_t disk = device->disk; + +grub_dl_ref (my_mod); + + data =grub_f2fs_mount (disk); +if (data) + { + *label =grub_zalloc (sizeof (data->sblock.volume_name)); + grub_utf16_to_utf8 ((grub_uint8_t *) (*label),malloc failure check?
grub-core/fs/f2fs.c line 1252
Quoted 1 line
grub-core/fs/f2fs.c new file +1
-0+ data->sblock.volume_name, 512);Where 512 comes from? Should it not be sizeof
(data->sblock.volume_name) as well?grub-core/fs/f2fs.c line 1258
Quoted 6 lines
grub-core/fs/f2fs.c new file +6
-0+ } +else + *label =NULL ; + +if (data) +grub_free (data->nat_bitmap);Again.
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+grub_free (data); +grub_dl_unref (my_mod); +return grub_errno; +} +...
Quoted 25 lines
tests/util/grub-fs-tester.in +5
-1@@ -36,7 +36,7 @@ case x"$fs" in MINLOGSECSIZE=8 # OS LIMITATION: It could go up to 32768 but Linux rejects sector sizes > 4096 MAXLOGSECSIZE=12;; - xxfs) + xxfs|xf2fs) MINLOGSECSIZE=9 # OS LIMITATION: GNU/Linux doesn't accept > 4096 MAXLOGSECSIZE=12;;@@ -135,6 +135,10 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + fi MAXBLKSIZE=4096 ;; + xf2fs) + MINBLKSIZE=$SECSIZE + # OS Limitation: GNU/Linux doesn't accept > 4096 + MAXBLKSIZE=4096;; xsquash*) MINBLKSIZE=4096 MAXBLKSIZE=1048576;;tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + · line 263
Quoted 5 lines
tests/util/grub-fs-tester.in +1
-1@@ -256,7 +260,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: btrfs label is at most 512 UTF-16 charsF2FS, not btrfs
tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + · line 265
Quoted 2 lines
tests/util/grub-fs-tester.in +2
-0+ x"f2fs") + FSLABEL="grub_;/testjaegeuk kimCould you leave initial part in place? This includes some funny UNICODE characters for a reason, actually. Unless this is not possible with f2fs?
f2fsaskdfjkasdlfajskdfjaksdjfkjaskjkjkzjkjckzjvkcjkjkjekqjkwejkqwrlkasdfjksadjflaskdhzxhvjzxchvjzkxchvjkhakjsdhfjkhqjkwehrjkhasjkdfhjkashdfjkhjzkxhcjkvzhxcjkvhzxjchvkzhxckjvhjzkxchvjkhzjkxchvjkzhxckjvhzkxjchvkjzxhckjvzxcjkvhjzxkchkvjhzxkjcvhjkhjkahsjkdhkjqhwekrjhakjsdfhkjashdkjzhxcvjkhzxcvzxcvggggggggggf";;
Quoted 13 lines
tests/util/grub-fs-tester.in +1
-1# FS LIMITATION: exfat is at most 15 UTF-16 chars x"exfat") FSLABEL="géт ;/莭莽😁кир";;@@ -466,7 +472,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"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;;@@ -745,6 +751,8 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
Quoted 8 lines
tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + · line 758
Quoted 8 lines
tests/util/grub-fs-tester.in +2
-0MOUNTDEVICE="/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)
_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
В Sat, 28 Mar 2015 13:43:18 -0700
Jaegeuk Kim <[email protected]> пишет:
Quoted 14 lines
Hi Andrei,
Quoted 11 lines · Andrei Borzenkov
В Tue, 24 Mar 2015 01:19:00 -0700
Jaegeuk Kim <[email protected]> пишет:Quoted 7 lines
* Makefile.util.def: Add
f2fs.c.
* doc/grub.texi: Add f2fs description.
* grub-core/Makefile.core.def: Add f2fs module.
*grub-core/fs/f2fs.c: New file.
* tests/f2fs_test.in: New file.
* tests/util/grub-fs-tester.in: Add f2fs requirements.
Quoted 6 lines
Quoted 4 lines
It's not the most useful commit message. Better would be short explanation of use cases and intended platforms. I'm curious here - F2FS is intended for raw flash access, on which platform(s) grub has access to such devices?
I just followed the commit convention in grub.git.
It has changed meanwhile. We are using normal git conventions now.
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+static grub_err_t +grub_f2fs_read_sb (struct grub_f2fs_data *data,int block) +{ +grub_disk_t disk = data->disk; +grub_uint64_t offset; +grub_err_t err; + +if (block ==0 )
Quoted 8 lines
Quoted 8 lines
grub-core/fs/f2fs.c line 500
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+ offset =F2FS_SUPER_OFFSET ; + else + offset =F2FS_BLKSIZE +F2FS_SUPER_OFFSET ; +Please name it "secondary" or similar instead of "block" to avoid confusion. You do not really want to read arbitrary block, right?
Actually it makes more sense just to pass offset directly to eliminate useless computation.
_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
Hi Andrei,
Quoted 3 lines · Andrei Borzenkov
В Tue, 24 Mar 2015 01:19:00 -0700
Jaegeuk Kim <[email protected]> пишет:
...
Quoted 21 lines
grub-core/fs/f2fs.c line 46
Quoted 11 lines
grub-core/fs/f2fs.c new file +11
-0+/* byte-size offset */ +#define F2FS_SUPER_OFFSET 1024 + +/* 12 bits for 4096 bytes */ +#define F2FS_MAX_LOG_SECTOR_SIZE 12 + +/* 9 bits for 512 bytes */ +#define F2FS_MIN_LOG_SECTOR_SIZE 9 + +/* support only 4KB block */ +#define F2FS_BLKSIZE 4096(2 <<
F2FS_BLK_BITS)?grub-core/fs/f2fs.c line 48
Quoted 2 lines
grub-core/fs/f2fs.c new file +2
-0+#define F2FS_BLK_BITS 12 +#define F2FS_BLK_SEC_BITS (3)It is confusing to have some defines parenthesized and some not. Could it be unified somehow?
Quoted 2 lines
Also this can be computed from
F2FS_BLK_BITSandGRUB_DISK_SECTOR_BITS
- one magic number less.
Fixed.
Quoted 8 lines
...
grub-core/fs/f2fs.c line 218
Quoted 3 lines
grub-core/fs/f2fs.c new file +3
-0+struct grub_f2fs_inline_dentry +{ +grub_uint8_t dentry_bitmap[INLINE_DENTRY_BITMAP_SIZE ];This is cast to
grub_uint32_teverywhere. Can it be non-multiple of 4 bytes? If not, may be just define as such?
I remained this, since this can be non-multiple of 4 bytes.
Quoted 6 lines
Quoted 6 lines
grub-core/fs/f2fs.c new file +5
-0+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 ; +
...
Quoted 7 lines
grub-core/fs/f2fs.c line 79
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+ +#define ver_after (a, b) (typecheck (unsigned long long, a) && \ + typecheck (unsigned long long, b) && \ + ((long long)((a) - (b)) > 0)) +Where typecheck definition comes from?
Removed this.
Quoted 8 lines
...
grub-core/fs/f2fs.c line 328
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+ +static inline int +__test_bit (int nr,grub_uint32_t *addr) +{ +return 1UL & (addr[nr /32 ] >> (nr & (31 )));Extra parenthesis (31)
Fixed.
Quoted 9 lines
Review
Quoted 3 lines
(quoted diff) +2
-0+} +It is used for
dentry_bitmapwhich is kept in LE format and not converted as far as I can tell. This needs fixing for BE systems. Linux kernel is explicitly usingtest_bit_lehere. This will also work for inode flags (just skip explicit conversion).
Quoted 8 lines
There are two functions with more or less identical names. May be make them
grub_f2fs_test_bit_le32grub_f2fs_test_bitAs a general comment - marking non-modified arguments as const everywhere would be good.
I added:grub_f2fs_general_test_bitgrub_f2fs_test_bit
Both of them keep bit streams without endian conversion, and the difference is beyond handling the order of bit stream indices.
Quoted 6 lines
grub-core/fs/f2fs.c line 334
Quoted 5 lines
grub-core/fs/f2fs.c new file +4
-0+static inline char * +__inline_addr (struct grub_f2fs_inode *inode) +{ +return (char *)&(inode->i_addr[1 ]);Redundant parens around inode->
Fixed.
Quoted 8 lines
grub-core/fs/f2fs.c line 338
Quoted 5 lines
grub-core/fs/f2fs.c new file +4
-0+} + +static inline grub_uint64_t +__i_size (struct grub_f2fs_inode *inode)Could we make it
grub_f2fs_file_sizeor similar?i_sizereally does not tell much outside of linux kernel.
Changed to grub_f2fs_file_size.
Quoted 43 lines
Quoted 30 lines
grub-core/fs/f2fs.c new file +29
-0+{ +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_uint64_t ckpt_version =grub_le_to_cpu64 (ckpt->checkpoint_ver); +grub_uint32_t start_addr = data->cp_blkaddr; + +if (!(ckpt_version &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; +grub-core/fs/f2fs.c line 377
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+return __start_cp_addr (data) + +grub_le_to_cpu32 (ckpt->cp_pack_total_block_count) + - (base +1 ) + type; +} + +static inline int +__ckpt_flag_set (struct grub_f2fs_checkpoint *ckpt,unsigned int f) +{ +grub_uint32_t ckpt_flags =grub_le_to_cpu32 (ckpt->ckpt_flags); +return ckpt_flags & f;All flags are constant so you can simply do
Quoted 3 lines
ckpt->ckpt_flags&grub_cpu_to_le32_compile_time(FLAG)in place to avoid extra calls. This makes function redundant.
Fixed.
Quoted 5 lines
grub-core/fs/f2fs.c line 381
Quoted 5 lines
grub-core/fs/f2fs.c new file +4
-0+} + +static inline int +__inode_flag_set (struct grub_f2fs_inode *inode,int flag)
Fixed to refer i_inline. This was a bug.
...
Quoted 9 lines
grub-core/fs/f2fs.c line 429
Quoted 6 lines
+ * CRC32
+ */grub-core/fs/f2fs.c new file +4
-0+#define CRCPOLY_LE 0xedb88320 + +static inline grub_uint32_t +grub_f2fs_cal_crc32 (grub_uint32_t crc,void *buf,int len)Why crc is parameter here? This function is used exactly once with fixed value for initial crc.
Fixed.
Quoted 23 lines
Quoted 23 lines
grub-core/fs/f2fs.c new file +22
-0+{ +int i; +unsigned char *p = (unsigned char *)buf; + +while (len--) + { + 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,int len) +{ +grub_uint32_t cal_crc =0 ; + + cal_crc =grub_f2fs_cal_crc32 (F2FS_SUPER_MAGIC , buf, len); + +return (cal_crc == blk_crc) ?1 :0 ; +}
Quoted 8 lines
grub-core/fs/f2fs.c line 457
Quoted 6 lines
grub-core/fs/f2fs.c new file +6
-0+ +static inline int +grub_f2fs_test_bit (grub_uint32_t nr,const char *p) +{ +int mask; +char *addr = (char *)p;Why cast? We are not going to modify it, right?
Right.
Quoted 15 lines
grub-core/fs/f2fs.c line 469
Quoted 13 lines
grub-core/fs/f2fs.c new file +12
-0+ + addr += (nr >>3 ); + mask =1 << (7 - (nr &0x07 )); +return (mask & *addr) !=0 ; +} + +static int +grub_f2fs_sanity_check_sb (struct grub_f2fs_superblock *sb) +{ +unsigned int blocksize; + +if (F2FS_SUPER_MAGIC !=grub_le_to_cpu32 (sb->magic))
sb->magic!=grub_cpu_to_le32_compile_time(F2FS_SUPER_MAGIC)
Fixed.
Quoted 7 lines
grub-core/fs/f2fs.c line 473
Quoted 5 lines
grub-core/fs/f2fs.c new file +4
-0+return -1 ; + + blocksize =1 <<grub_le_to_cpu32 (sb->log_blocksize); +if (blocksize !=F2FS_BLKSIZE )
sb->log_blksize!=grub_cpu_to_le32_compile_time(F2FS_BLK_BITS)
Fixed.
Quoted 14 lines
grub-core/fs/f2fs.c line 483
Quoted 11 lines
grub-core/fs/f2fs.c new file +10
-0+return -1 ; + +if (grub_le_to_cpu32 (sb->log_sectorsize) >F2FS_MAX_LOG_SECTOR_SIZE ) +return -1 ; + +if (grub_le_to_cpu32 (sb->log_sectorsize) <F2FS_MIN_LOG_SECTOR_SIZE ) +return -1 ; + +if (grub_le_to_cpu32 (sb->log_sectors_per_block) + +grub_le_to_cpu32 (sb->log_sectorsize) !=F2FS_MAX_LOG_SECTOR_SIZE )Should not it be
F2FS_BLKSIZE? At least it sounds logical. Also please convertlog_sectorsizejust once.
Fixed.
Quoted 22 lines
Quoted 8 lines
grub-core/fs/f2fs.c new file +7
-0+return -1 ; + +return 0 ; +} + +static grub_err_t +grub_f2fs_read_sb (struct grub_f2fs_data *data,int block)grub-core/fs/f2fs.c line 500
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+{ +grub_disk_t disk = data->disk; +grub_uint64_t offset; +grub_err_t err; + +if (block ==0 ) + offset =F2FS_SUPER_OFFSET ; +else + offset =F2FS_BLKSIZE +F2FS_SUPER_OFFSET ; +Please name it "secondary" or similar instead of "block" to avoid confusion. You do not really want to read arbitrary block, right?
Quoted 3 lines
offset =
F2FS_SUPER_OFFEST;
if (secondary)
offset +=F2FS_BLKSIZE;
Fixed as your latest comment.
Quoted 34 lines
Quoted 34 lines
grub-core/fs/f2fs.c new file +33
-0+/* Read first super block. */ + err =grub_disk_read (disk, offset >>GRUB_DISK_SECTOR_BITS ,0 , +sizeof (data->sblock), &data->sblock); +if (err) +return err; + +if (grub_f2fs_sanity_check_sb (&data->sblock)) + err =GRUB_ERR_BAD_FS ; + +return err; +} + +static void * +validate_checkpoint (struct grub_f2fs_data *data,grub_uint32_t cp_addr, +grub_uint64_t *version) +{ +void *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;
Quoted 8 lines
grub-core/fs/f2fs.c line 538
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+ crc_offset =grub_le_to_cpu32 (cp_block->checksum_offset); +if (crc_offset >=F2FS_BLKSIZE ) + goto invalid_cp1; + + crc = *(grub_uint32_t *)((char *)cp_block + crc_offset);Is unaligned access possible here? If yes, it probably should be
grub_get_unaligned32.
No. It was hard-coded as 4092 from mkfs.
Quoted 6 lines
grub-core/fs/f2fs.c line 541
Quoted 4 lines
grub-core/fs/f2fs.c new file +3
-0+if (!grub_f2fs_crc_valid (crc, cp_block, crc_offset)) + goto invalid_cp1; +Should not CRC be converted from LE?
Fixed.
Quoted 79 lines
Quoted 10 lines
grub-core/fs/f2fs.c new file +9
-0+ 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 ; +grub-core/fs/f2fs.c line 560
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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 >=F2FS_BLKSIZE ) + goto invalid_cp2; + + crc = *(grub_uint32_t *)((char *)cp_block + crc_offset);Ditto alignment.
Quoted 1 line
+ if (!grub_f2fs_crc_valid (crc,
cp_block,crc_offset))Ditto endianness.
Quoted 53 lines
grub-core/fs/f2fs.c new file +53
-0+ 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\n" ); + +grub_memcpy (&data->ckpt, cur_page,F2FS_BLKSIZE ); +
Quoted 8 lines
grub-core/fs/f2fs.c line 620
Quoted 6 lines
grub-core/fs/f2fs.c new file +6
-0+grub_free (cp1); +grub_free (cp2); +return 0 ; +} + +static intstatic
grub_error_t
Fixed.
Quoted 17 lines
Quoted 4 lines
grub-core/fs/f2fs.c new file +3
-0+get_nat_journal (struct grub_f2fs_data *data) +{ +grub_uint32_t block;grub-core/fs/f2fs.c line 633
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+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 ))As mentioned, use
grub_cpu_to_leXX_compile_timeto avoid run time conversion.
Fixed.
Quoted 66 lines
Quoted 19 lines
grub-core/fs/f2fs.c new file +18
-0+ 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; +} +...
Quoted 46 lines
grub-core/fs/f2fs.c new file +46
-0+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_flag_set (inode,FI_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) + {
Quoted 8 lines
grub-core/fs/f2fs.c line 760
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+ offset[n++] =NODE_IND1_BLOCK ; + noffset[n] =3 ; + offset[n++] = block / direct_blks; + noffset[n] =4 + offset[n -1 ];That does not fit. You declared offset and noffset as arrays of four elements and pass arrays of four elements; here is out of bound access already.
It is not out of bound access, since it decreases *block* at every condition checks.
This function should hit only one of if {} conditions.
Quoted 49 lines
Quoted 49 lines
grub-core/fs/f2fs.c new file +48
-0+ 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 +load_nat_info (struct grub_f2fs_data *data) +{ +void *version_bitmap; +grub_err_t err; + + data->nat_bitmap =grub_malloc (__nat_bitmap_size (data)); +if (!data->nat_bitmap) +return grub_errno; +
Quoted 8 lines
grub-core/fs/f2fs.c line 813
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+ version_bitmap =__nat_bitmap_ptr (data); + +/* copy version bitmap */ +grub_memcpy (data->nat_bitmap, version_bitmap,__nat_bitmap_size (data)); +Any reason to actually copy it? Why is it not possible to just set pointer to source, which is available all the time anyway?
Fixed not to allocate and copying this.
Quoted 15 lines
Quoted 15 lines
grub-core/fs/f2fs.c new file +14
-0+ err =get_nat_journal (data); +if (err) +grub_free (data->nat_bitmap); + +return err; +} + +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);
Quoted 8 lines
grub-core/fs/f2fs.c line 831
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+if (!blkaddr) +return grub_errno; + +return grub_f2fs_block_read (data, blkaddr, np);Is struct
grub_f2fs_nodeguaranteed to always have the same size as F2FS block? Then adding char [F2FS_BLKSIZE] to union to make it obvious is better and ensures that it will always be at least this size.
Fixed.
Quoted 18 lines
Quoted 18 lines
grub-core/fs/f2fs.c new file +17
-0+} + +static struct grub_f2fs_data * +grub_f2fs_mount (grub_disk_t disk) +{ +struct grub_f2fs_data *data; +grub_err_t err; + + data =grub_zalloc (sizeof (*data)); +if (!data) +return NULL ; + + data->disk = disk; + + err =grub_f2fs_read_sb (data,0 ); +if (err) + {
Quoted 8 lines
grub-core/fs/f2fs.c line 852
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+ err =grub_f2fs_read_sb (data,1 ); +if (err) + { +grub_error (GRUB_ERR_BAD_FS ,"not a F2FS filesystem" );May be mentioning that superblock could not be read? In another place you already tell that checkpoints could not be found. It helps to troubleshoot issues.
Fixed.
Quoted 28 lines
Quoted 28 lines
grub-core/fs/f2fs.c new file +27
-0+ 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; + + err =load_nat_info (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; +
Quoted 8 lines
grub-core/fs/f2fs.c line 884
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+return data; + +fail: +if (data) +grub_free (data->nat_bitmap);Double free after
load_nat_infofailure. Assuming that we do need to allocate anything at all (see above).
Removed all grub_frees.
Quoted 12 lines
grub-core/fs/f2fs.c line 891
Quoted 8 lines
grub-core/fs/f2fs.c new file +7
-0+grub_free (data); +return NULL ; +} + +/* guarantee inline_data was handled by caller */ +static grub_disk_addr_t +grub_f2fs_read_block (grub_fshelp_node_t node,grub_disk_addr_t block_ofs)You have
grub_f2fs_read_blockandgrub_f2fs_block_read. Could we make them more different and self-explaining? In particular, this one does not read anything, it returns disk address.grub_f2fs_map_file_block?
Good suggestion.
Changed to grub_f2fs_get_block.
Quoted 7 lines
grub-core/fs/f2fs.c line 895
Quoted 5 lines
grub-core/fs/f2fs.c new file +4
-0+{ +struct grub_f2fs_data *data = node->data; +struct grub_f2fs_inode *inode = &node->inode.i; +grub_uint32_t offset[4 ], noffset[4 ], nids[4 ];See above about overflow in
grub_get_inode_path.
No error.
Quoted 52 lines
Quoted 32 lines
grub-core/fs/f2fs.c new file +31
-0+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; +} +...
Quoted 19 lines
grub-core/fs/f2fs.c new file +19
-0+ +static char * +grub_f2fs_read_symlink (grub_fshelp_node_t node) +{ +char *symlink; +struct grub_fshelp_node *diro = node; + +if (!diro->inode_read) + { +grub_f2fs_read_node (diro->data, diro->ino, &diro->inode); +if (grub_errno) +return 0 ; + } + + symlink =grub_malloc (__i_size (&diro->inode.i) +1 ); +if (!symlink) +return 0 ; + +grub_f2fs_read_file (diro,0 ,0 ,0 ,__i_size (&diro->inode.i), symlink);
Quoted 8 lines
grub-core/fs/f2fs.c line 981
Quoted 6 lines
grub-core/fs/f2fs.c new file +6
-0+if (grub_errno) + { +grub_free (symlink); +return 0 ; + } +What about short read? Is this an error or not?
What is short read?
When I refer the other filesystem, it seems that it doesn't need to return errors.
Quoted 16 lines
Quoted 4 lines
grub-core/fs/f2fs.c new file +3
-0+ symlink[__i_size (&diro->inode.i)] ='\0' ; +return symlink; +}grub-core/fs/f2fs.c line 994
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ +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[F2FS_NAME_LEN +1 ];Could we avoid large stack allocations?
Fixed to allocate dynamically.
Quoted 88 lines
grub-core/fs/f2fs.c line 999
Quoted 6 lines
grub-core/fs/f2fs.c new file +5
-0+enum grub_fshelp_filetype type =GRUB_FSHELP_UNKNOWN ; +enum FILE_TYPE ftype; +int name_len; + +if (__test_bit (i, ctx->bitmap) ==0 )
grub_f2fs_test_bit_le32?Quoted 33 lines
grub-core/fs/f2fs.c new file +33
-0+ { + i++; +continue ; + } + + ftype = ctx->dentry[i].file_type; + name_len =grub_le_to_cpu16 (ctx->dentry[i].name_len); +grub_memcpy (filename, ctx->filename[i], name_len); + filename[name_len] ='\0' ; + + fdiro =grub_malloc (sizeof (struct grub_fshelp_node )); +if (!fdiro) +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 ; + +if (ctx->hook (filename, type, fdiro, ctx->hook_data)) +return 1 ; + + i += (name_len +F2FS_SLOT_LEN -1 ) /F2FS_SLOT_LEN ; + } +return 0 ; +} +...
Quoted 45 lines
grub-core/fs/f2fs.c new file +45
-0+ +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_flag_set (inode,FI_INLINE_DENTRY )) +return grub_f2fs_iterate_inline_dir (inode, &ctx); + +while (fpos <__i_size (inode)) + { +struct grub_f2fs_dentry_block *de_blk; +char *buf; + + 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 = (grub_uint32_t *) de_blk->dentry_bitmap;
Quoted 8 lines
grub-core/fs/f2fs.c line 1098
Quoted 6 lines
grub-core/fs/f2fs.c new file +6
-0+ ctx.dentry = de_blk->dentry; + ctx.filename = de_blk->filename; + ctx.max =NR_DENTRY_IN_BLOCK ; + +if (grub_f2fs_check_dentries (&ctx)) +return 1 ;memory leak
Fixed.
Quoted 33 lines
Quoted 9 lines
grub-core/fs/f2fs.c new file +8
-0+ +grub_free (buf); + + fpos +=F2FS_BLKSIZE ; + } +return 0 ; +} +...
Quoted 23 lines
grub-core/fs/f2fs.c new file +23
-0+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);
Quoted 8 lines
grub-core/fs/f2fs.c line 1161
Quoted 6 lines
grub-core/fs/f2fs.c new file +6
-0+ +fail: +if (fdiro != &ctx.data->diropen) +grub_free (fdiro); +if (ctx.data) +grub_free (ctx.data->nat_bitmap);Triple free :)
Removed nat_bitmap entirely. :)
Quoted 27 lines
Quoted 27 lines
grub-core/fs/f2fs.c new file +26
-0+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 ; + +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)
Quoted 8 lines
grub-core/fs/f2fs.c line 1194
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+ { +grub_f2fs_read_node (data, fdiro->ino, &fdiro->inode); +if (grub_errno) + goto fail; + } + +grub_memcpy (data->inode, &fdiro->inode,F2FS_BLKSIZE );sizeof (
*data->inode)? Or they can be different?
Not a big deal. Fixed.
Quoted 58 lines
Quoted 4 lines
grub-core/fs/f2fs.c new file +3
-0+grub_free (fdiro); + + file->size =__i_size (&(data->inode->i));grub-core/fs/f2fs.c line 1207
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ file->data = data; + file->offset =0 ; + +return 0 ; + +fail: +if (fdiro != &data->diropen) +grub_free (fdiro); +if (data) +grub_free (data->nat_bitmap);Again.
Quoted 14 lines
grub-core/fs/f2fs.c new file +14
-0+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,grub-core/fs/f2fs.c line 1231
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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; + +if (data) +grub_free (data->nat_bitmap);Again.
Quoted 14 lines
grub-core/fs/f2fs.c new file +14
-0+grub_free (data); + +grub_dl_unref (my_mod); + +return GRUB_ERR_NONE ; +} + +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);
Quoted 8 lines
grub-core/fs/f2fs.c line 1251
Quoted 6 lines
grub-core/fs/f2fs.c new file +6
-0+ + data =grub_f2fs_mount (disk); +if (data) + { + *label =grub_zalloc (sizeof (data->sblock.volume_name)); + grub_utf16_to_utf8 ((grub_uint8_t *) (*label),malloc failure check?
Fxied.
Quoted 5 lines
grub-core/fs/f2fs.c line 1252
Quoted 2 lines
grub-core/fs/f2fs.c new file +1
-0+ data->sblock.volume_name, 512);Where 512 comes from? Should it not be sizeof
(data->sblock.volume_name) as well?
Fixed regarding to mkfs.f2fs handling.
Quoted 49 lines
grub-core/fs/f2fs.c line 1258
Quoted 7 lines
grub-core/fs/f2fs.c new file +6
-0+ } +else + *label =NULL ; + +if (data) +grub_free (data->nat_bitmap);Again.
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+grub_free (data); +grub_dl_unref (my_mod); +return grub_errno; +} +...
Quoted 25 lines
tests/util/grub-fs-tester.in +5
-1@@ -36,7 +36,7 @@ case x"$fs" in MINLOGSECSIZE=8 # OS LIMITATION: It could go up to 32768 but Linux rejects sector sizes > 4096 MAXLOGSECSIZE=12;; - xxfs) + xxfs|xf2fs) MINLOGSECSIZE=9 # OS LIMITATION: GNU/Linux doesn't accept > 4096 MAXLOGSECSIZE=12;;@@ -135,6 +135,10 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + fi MAXBLKSIZE=4096 ;; + xf2fs) + MINBLKSIZE=$SECSIZE + # OS Limitation: GNU/Linux doesn't accept > 4096 + MAXBLKSIZE=4096;; xsquash*) MINBLKSIZE=4096 MAXBLKSIZE=1048576;;tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + · line 263
Quoted 5 lines
tests/util/grub-fs-tester.in +1
-1@@ -256,7 +260,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: btrfs label is at most 512 UTF-16 charsF2FS, not btrfs
Quoted 6 lines
tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + · line 265
Quoted 2 lines
tests/util/grub-fs-tester.in +2
-0+ x"f2fs") + FSLABEL="grub_;/testjaegeuk kimCould you leave initial part in place? This includes some funny UNICODE characters for a reason, actually. Unless this is not possible with f2fs?
I found that mkfs.f2fs doesn't handle utf conversion correctly. So, for now, I'd like to add just few characters.
Please, v2 patch.
Thanks,
Quoted 15 lines
f2fsaskdfjkasdlfajskdfjaksdjfkjaskjkjkzjkjckzjvkcjkjkjekqjkwejkqwrlkasdfjksadjflaskdhzxhvjzxchvjzkxchvjkhakjsdhfjkhqjkwehrjkhasjkdfhjkashdfjkhjzkxhcjkvzhxcjkvhzxjchvkzhxckjvhjzkxchvjkhzjkxchvjkzhxckjvhzkxjchvkjzxhckjvzxcjkvhjzxkchkvjhzxkjcvhjkhjkahsjkdhkjqhwekrjhakjsdfhkjashdkjzhxcvjkhzxcvzxcvggggggggggf";;
Quoted 13 lines
tests/util/grub-fs-tester.in +1
-1# FS LIMITATION: exfat is at most 15 UTF-16 chars x"exfat") FSLABEL="géт ;/莭莽😁кир";;@@ -466,7 +472,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"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;;@@ -745,6 +751,8 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
Quoted 8 lines
tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + · line 758
Quoted 8 lines
tests/util/grub-fs-tester.in +2
-0MOUNTDEVICE="/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)
_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
"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 changes:
* Makefile.util.def: Add f2fs.c.
* doc/grub.texi: Add f2fs description.
* grub-core/Makefile.core.def: Add f2fs module.
* grub-core/fs/f2fs.c: New file.
* tests/f2fs_test.in: New file.
* tests/util/grub-fs-tester.in: Add f2fs requirements.
--- Makefile.util.def | 7 + docs/grub.texi | 5 +- grub-core/Makefile.core.def | 5 + grub-core/fs/f2fs.c | 1308 ++++++++++++++++++++++++++++++++++++++++++ po/exclude.pot | 1 + tests/f2fs_test.in | 19 + tests/util/grub-fs-tester.in | 15 +- 7 files changed, 1355 insertions(+), 5 deletions(-) create mode 100644 grub-core/fs/f2fs.c create mode 100644 tests/f2fs_test.in
Makefile.util.def +7 -0
@@ -98,6 +98,7 @@ library = { common = grub-core/fs/newc.c; common = grub-core/fs/ext2.c; common = grub-core/fs/fat.c; + common = grub-core/fs/f2fs.c; common = grub-core/fs/exfat.c; common = grub-core/fs/fshelp.c; common = grub-core/fs/hfs.c;
@@ -767,6 +768,12 @@ script = { script = { testcase; + name = f2fs_test; + common = tests/f2fs_test.in; +}; + +script = { + testcase; name = nilfs2_test; common = tests/nilfs2_test.in; };
docs/grub.texi +3 -2
@@ -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{f2fs}, +@dfn{exFAT}, @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},
@@ -5289,7 +5290,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
grub-core/Makefile.core.def +5 -0
@@ -1281,6 +1281,11 @@ module = { }; module = { + name = f2fs; + common = fs/f2fs.c; +}; + +module = { name = exfat; common = fs/exfat.c; };
grub-core/fs/f2fs.c new file +1308 -0
1,308 lines not on this page · raw message
po/exclude.pot +1 -0
@@ -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 ""
tests/f2fs_test.in new file +19 -0
@@ -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
tests/util/grub-fs-tester.in +12 -3
@@ -36,7 +36,7 @@ case x"$fs" in MINLOGSECSIZE=8 # OS LIMITATION: It could go up to 32768 but Linux rejects sector sizes > 4096 MAXLOGSECSIZE=12;; - xxfs) + xxfs|xf2fs) MINLOGSECSIZE=9 # OS LIMITATION: GNU/Linux doesn't accept > 4096 MAXLOGSECSIZE=12;;
@@ -135,6 +135,10 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + fi MAXBLKSIZE=4096 ;; + xf2fs) + MINBLKSIZE=$SECSIZE + # OS Limitation: GNU/Linux doesn't accept > 4096 + MAXBLKSIZE=4096;; xsquash*) MINBLKSIZE=4096 MAXBLKSIZE=1048576;;
@@ -256,7 +260,10 @@ 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 + # TODO: seems that mkfs.f2fs doesn't handle encoding stuffs correctly + x"f2fs") + FSLABEL="grub_test:no utf16";; # FS LIMITATION: exfat is at most 15 UTF-16 chars x"exfat") FSLABEL="géт ;/莭莽😁кир";;
@@ -466,7 +473,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"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;;
@@ -745,6 +752,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)
Signature · 13 lines
2.1.1 ------------------------------------------------------------------------------ Dive into the World of Parallel Programming The Go Parallel Website, sponsored by Intel and developed in partnership with Slashdot Media, is your hub for all things parallel software development, from weekly thought leadership blogs to news, videos, case studies, tutorials and more. Take a look and join the conversation now. http://goparallel.sourceforge.net/ _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Hi folks,
Any comments on this patch?
Thanks,
Quoted 1,526 lines · Jaegeuk Kim
"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.gitThis patch changes:
* Makefile.util.def: Add
f2fs.c.
* doc/grub.texi: Add f2fs description.
* grub-core/Makefile.core.def: Add f2fs module.
*grub-core/fs/f2fs.c: New file.
* tests/f2fs_test.in: New file.
* tests/util/grub-fs-tester.in: Add f2fs requirements.Signed-off-by Jaegeuk Kim <[email protected]>--- Makefile.util.def | 7 + docs/grub.texi | 5 +- grub-core/Makefile.core.def | 5 + grub-core/fs/f2fs.c | 1308 ++++++++++++++++++++++++++++++++++++++++++ po/exclude.pot | 1 + tests/f2fs_test.in | 19 + tests/util/grub-fs-tester.in | 15 +- 7 files changed, 1355 insertions(+), 5 deletions(-) create mode 100644 grub-core/fs/f2fs.c create mode 100644 tests/f2fs_test.inMakefile.util.def +7
-0@@ -98,6 +98,7 @@ library = { common = grub-core/fs/newc.c; common = grub-core/fs/ext2.c; common = grub-core/fs/fat.c; + common = grub-core/fs/f2fs.c; common = grub-core/fs/exfat.c; common = grub-core/fs/fshelp.c; common = grub-core/fs/hfs.c;@@ -767,6 +768,12 @@ script = { script = { testcase; + name = f2fs_test; + common = tests/f2fs_test.in; +}; + +script = { + testcase; name = nilfs2_test; common = tests/nilfs2_test.in; };docs/grub.texi +3
-2@@ -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{f2fs}, +@dfn{exFAT}, @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},@@ -5289,7 +5290,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 usegrub-core/Makefile.core.def +5
-0@@ -1281,6 +1281,11 @@ module = { }; module = { + name = f2fs; + common = fs/f2fs.c; +}; + +module = { name = exfat; common = fs/exfat.c; };grub-core/fs/f2fs.c new file +1308
-0@@ -0,0 +1,1308 @@ +/* +* f2fs.c - Flash-Friendly File System +* +* Written by Jaegeuk Kim <[email protected]> +* +* 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 + +/* byte-size offset */ +#define F2FS_SUPER_OFFSET 1024 + +/* 12 bits for 4096 bytes */ +#define F2FS_MAX_LOG_SECTOR_SIZE 12 + +/* 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 13 +#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 9 +#define NAT_ENTRY_PER_BLOCK (F2FS_BLKSIZE / NAT_ENTRY_SIZE) + +#define ver_after (a, b) ((long long)((a) - (b)) > 0) + +#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) + +enum + { +FI_INLINE_XATTR =9 , +FI_INLINE_DATA =10 , +FI_INLINE_DENTRY =11 , +FI_DATA_EXIST =18 , + }; + +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[512 ]; +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_uint32_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_generic_test_bit (int nr,const grub_uint32_t *addr) +{ +return 1UL & (addr[nr /32 ] >> (nr &31 )); +} + +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_uint64_t ckpt_version =grub_le_to_cpu64 (ckpt->checkpoint_ver); +grub_uint32_t start_addr = data->cp_blkaddr; + +if (!(ckpt_version &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 int +__inode_inline_set (struct grub_f2fs_inode *inode,int flag) +{ +return inode->i_inline & flag; +} + +static inline grub_uint32_t +__nat_bitmap_size (struct grub_f2fs_data *data) +{ +struct grub_f2fs_checkpoint *ckpt = &data->ckpt; + +return grub_le_to_cpu32 (ckpt->nat_ver_bitmap_bytesize); +} + +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 i) +{ +if (i) +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, 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) !=0 ; +} + +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_MAX_LOG_SECTOR_SIZE ) +return -1 ; + +if (log_sectorsize <F2FS_MIN_LOG_SECTOR_SIZE ) +return -1 ; + +if (log_sectors_per_block + log_sectorsize !=F2FS_MAX_LOG_SECTOR_SIZE ) +return -1 ; + +return 0 ; +} + +static grub_err_t +grub_f2fs_read_sb (struct grub_f2fs_data *data,grub_uint64_t offset) +{ +grub_disk_t disk = data->disk; +grub_err_t err; + +/* Read first super block. */ + err =grub_disk_read (disk, offset >>GRUB_DISK_SECTOR_BITS ,0 , +sizeof (data->sblock), &data->sblock); +if (err) +return err; + +if (grub_f2fs_sanity_check_sb (&data->sblock)) + err =GRUB_ERR_BAD_FS ; + +return err; +} + +static void * +validate_checkpoint (struct grub_f2fs_data *data,grub_uint32_t cp_addr, +grub_uint64_t *version) +{ +void *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 >=F2FS_BLKSIZE ) + goto invalid_cp1; + + crc =grub_le_to_cpu32 (*(grub_uint32_t *)((char *)cp_block + crc_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 >=F2FS_BLKSIZE ) + goto invalid_cp2; + + crc =grub_le_to_cpu32 (*(grub_uint32_t *)((char *)cp_block + crc_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\n" ); + +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_inline_set (inode,FI_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_zalloc (sizeof (*data)); +if (!data) +return NULL ; + + data->disk = disk; + + err =grub_f2fs_read_sb (data,F2FS_SUPER_OFFSET ); +if (err) + { + err =grub_f2fs_read_sb (data,F2FS_BLKSIZE +F2FS_SUPER_OFFSET ); +if (err) + { +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_inline_set (&node->inode.i,FI_INLINE_DATA )) + { +if (pos > filesize || filesize >MAX_INLINE_DATA ) + { +grub_error (GRUB_ERR_OUT_OF_RANGE , +N_ ("attempt to read past the end of file" )); +return -1 ; + } +if (pos + len > filesize) + len = filesize - pos; + +grub_memcpy (buf + pos, 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_generic_test_bit (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_zalloc (name_len +1 ); +if (!filename) +return 0 ; + +grub_memcpy (filename, ctx->filename[i], name_len); + + 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 = (grub_uint32_t *) 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_inline_set (inode,FI_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 = (grub_uint32_t *) 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 ; + +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); + + file->size =grub_f2fs_file_size (&(data->inode->i)); + file->data = data; + file->offset =0 ; + +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 void +grub_f2fs_unicode_to_ascii (grub_uint8_t *out_buf,grub_uint16_t *in_buf) +{ +grub_uint16_t *pchTempPtr = in_buf; +grub_uint8_t *pwTempPtr = out_buf; + +while (*pchTempPtr !='\0' ) + { + *pwTempPtr = (grub_uint8_t) *pchTempPtr; + pchTempPtr++; + pwTempPtr++; + } + *pwTempPtr ='\0' ; +return ; +} + +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 =grub_zalloc (sizeof (data->sblock.volume_name)); +if (*label) +grub_f2fs_unicode_to_ascii ((grub_uint8_t *) (*label), + 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); +}po/exclude.pot +1
-0@@ -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 ""tests/f2fs_test.in new file +19
-0@@ -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" f2fstests/util/grub-fs-tester.in +12
-3@@ -36,7 +36,7 @@ case x"$fs" in MINLOGSECSIZE=8 # OS LIMITATION: It could go up to 32768 but Linux rejects sector sizes > 4096 MAXLOGSECSIZE=12;; - xxfs) + xxfs|xf2fs) MINLOGSECSIZE=9 # OS LIMITATION: GNU/Linux doesn't accept > 4096 MAXLOGSECSIZE=12;;@@ -135,6 +135,10 @@ for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + fi MAXBLKSIZE=4096 ;; + xf2fs) + MINBLKSIZE=$SECSIZE + # OS Limitation: GNU/Linux doesn't accept > 4096 + MAXBLKSIZE=4096;; xsquash*) MINBLKSIZE=4096 MAXBLKSIZE=1048576;;@@ -256,7 +260,10 @@ 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 + # TODO: seems that mkfs.f2fs doesn't handle encoding stuffs correctly + x"f2fs") + FSLABEL="grub_test:no utf16";; # FS LIMITATION: exfat is at most 15 UTF-16 chars x"exfat") FSLABEL="géт ;/莭莽😁кир";;@@ -466,7 +473,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"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;;@@ -745,6 +752,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)Signature · 13 lines
2.1.1 ------------------------------------------------------------------------------ Dive into the World of Parallel Programming The Go Parallel Website, sponsored by Intel and developed in partnership with Slashdot Media, is your hub for all things parallel software development, from weekly thought leadership blogs to news, videos, case studies, tutorials and more. Take a look and join the conversation now. http://goparallel.sourceforge.net/ _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
В Wed, 29 Apr 2015 13:48:21 -0700
Jaegeuk Kim <[email protected]> пишет:
Quoted 4 lines
Hi folks,
Any comments on this patch?
Sorry, still did not get around, hopefully someone beats me :)
_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
Sorry for delay.
В Fri, 3 Apr 2015 15:49:08 -0700
Jaegeuk Kim <[email protected]> пишет:
Quoted 10 lines
This patch changes:
* Makefile.util.def: Add
f2fs.c.
* doc/grub.texi: Add f2fs description.
* grub-core/Makefile.core.def: Add f2fs module.
*grub-core/fs/f2fs.c: New file.
* tests/f2fs_test.in: New file.
* tests/util/grub-fs-tester.in: Add f2fs requirements.
Drop file list, it is available from git.
...
Quoted 6 lines
grub-core/fs/f2fs.c new file +1
-0+
...
Quoted 1 line
+#define
JENTRY_SIZE13
sizeof (struct grub_f2fs_nat_jent), right?
...
grub-core/fs/f2fs.c
Quoted 2 lines
grub-core/fs/f2fs.c new file +2
-0+ +#define NAT_ENTRY_SIZE 9
That's sizeof (struct grub_f2fs_nat_entry)?
...
Quoted 1 line
+#define
ver_after(a, b) ((long long)((a) - (b)) > 0)
This macro is not used anywhere
grub-core/fs/f2fs.c line 81
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+#define F2FS_NAME_LEN 255 +#define F2FS_SLOT_LEN 8 +#define NR_DENTRY_IN_BLOCK 214 +#define SIZE_OF_DIR_ENTRY 11/* by byte */
sizeof (struct grub_f2fs_dir_entry)?
...
grub-core/fs/f2fs.c line 122
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+enum + { +FI_INLINE_XATTR =9 , +FI_INLINE_DATA =10 , +FI_INLINE_DENTRY =11 , +FI_DATA_EXIST =18 , + }; +
This does not match subsequent usage; you use them with i_inline, not i_flags.
...
grub-core/fs/f2fs.c line 332
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+ +static inline int +grub_generic_test_bit (int nr,const grub_uint32_t *addr) +{ +return 1UL & (addr[nr /32 ] >> (nr &31 )); +} +
This is used only in grub_f2fs_check_dentries() with on-disk bitmap. On-disk bitmap is little-endian; code is wrong on big-endian system.
Also dentry_bitmap is not multiple of 4 bytes as you replied earlier. You should rather compute correct byte address instead and make all parameters grub_uint8_t *. This will also avoid all those casts later.
That's really just
grub_uint8_t *addr;
byte = nr >> 3;
#ifdef WORDS_BIGENDIAN
byte ^= 3;
#endif
return addr[byte] & (1 << nr & 7);
...
grub-core/fs/f2fs.c line 380
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+ +static inline int +__inode_inline_set (struct grub_f2fs_inode *inode,int flag) +{ +return inode->i_inline & flag; +} +
Function is completely redundant if you really want to check i_inline; just use it directly. Then definition of flags is wrong.
If you mean inode->i_flags (as implied by passed flag values) this should obviously be (1 << flag) as adjusted by system byte order.
Out of curiosity - it appears those flags are present in both i_inline and i_flags; which one is authoritative?
grub-core/fs/f2fs.c line 387
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+static inline grub_uint32_t +__nat_bitmap_size (struct grub_f2fs_data *data) +{ +struct grub_f2fs_checkpoint *ckpt = &data->ckpt; + +return grub_le_to_cpu32 (ckpt->nat_ver_bitmap_bytesize); +}
This function is not used anywhere.
...
grub-core/fs/f2fs.c line 405
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+ +static inline grub_uint32_t +__get_node_id (struct grub_f2fs_node *rn,int off,int i) +{ +if (i)
Judging by usage something like "first" would probably be more appropriate.
grub-core/fs/f2fs.c line 413
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+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, blkaddr << F2FS_BLK_SEC_BITS,
I suspect coverity will complain about overflow here; cast of blkaddr to grub_disk_addr_t should silence it.
Quoted 3 lines
grub-core/fs/f2fs.c new file +3
-0+ 0, F2FS_BLKSIZE, buf); +} +
...
grub-core/fs/f2fs.c
Quoted 2 lines
grub-core/fs/f2fs.c new file +2
-0+ +static grub_err_t
Not sure if it is needed here; see comment below at caller.
grub-core/fs/f2fs.c line 492
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+grub_f2fs_read_sb (struct grub_f2fs_data *data, grub_uint64_t offset) +{ +grub_disk_t disk = data->disk; +grub_err_t err; + +/* Read first super block. */ + err = grub_disk_read (disk, offset >> GRUB_DISK_SECTOR_BITS, 0,
Make parameter grub_disk_addr_t and compute it in caller. It is constant, there is no need to compute it at run time.
Quoted 26 lines
grub-core/fs/f2fs.c new file +26
-0+ sizeof (data->sblock), &data->sblock); +if (err) +return err; + +if (grub_f2fs_sanity_check_sb (&data->sblock)) + err =GRUB_ERR_BAD_FS ; + +return err; +} + +static void * +validate_checkpoint (struct grub_f2fs_data *data,grub_uint32_t cp_addr, +grub_uint64_t *version) +{ +void *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 ; +
grub-core/fs/f2fs.c line 528
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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 >=F2FS_BLKSIZE ) + goto invalid_cp1; + + crc =grub_le_to_cpu32 (*(grub_uint32_t *)((char *)cp_block + crc_offset));
I understand that it /should/ be hardcoded to 4092, but then please either check that crc_offset *is* 4092 before or use grub_get_unaligned. Otherwise it crashes on archs that do not support unaligned access.
Quoted 12 lines
grub-core/fs/f2fs.c new file +12
-0+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 ; +
grub-core/fs/f2fs.c line 550
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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 >=F2FS_BLKSIZE ) + goto invalid_cp2; + + crc =grub_le_to_cpu32 (*(grub_uint32_t *)((char *)cp_block + crc_offset));
Ditto.
Quoted 41 lines
grub-core/fs/f2fs.c new file +41
-0+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;
grub-core/fs/f2fs.c line 601
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ } + +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\n" );
Trailing "\n" is not needed.
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+ +grub_memcpy (&data->ckpt, cur_page,F2FS_BLKSIZE ); + +grub_free (cp1); +grub_free (cp2); +return 0 ; +} +
...
grub-core/fs/f2fs.c line 807
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+ +static struct grub_f2fs_data * +grub_f2fs_mount (grub_disk_t disk) +{ +struct grub_f2fs_data *data; +grub_err_t err; + + data =grub_zalloc (sizeof (*data));
Is it needed to be zalloc? Structure is large and it runs every time file is accessed. Most of it is immediately overwritten, may be explicitly initialize what remains?
grub-core/fs/f2fs.c line 816
Quoted 9 lines
grub-core/fs/f2fs.c new file +9
-0+if (!data) +return NULL ; + + data->disk = disk; + + err =grub_f2fs_read_sb (data,F2FS_SUPER_OFFSET ); +if (err) + { + err =grub_f2fs_read_sb (data,F2FS_BLKSIZE +F2FS_SUPER_OFFSET );
As mentioned just compute disk address here, it is static.
grub-core/fs/f2fs.c line 822
Quoted 6 lines
grub-core/fs/f2fs.c new file +6
-0+if (err) + { +grub_error (GRUB_ERR_BAD_FS ,"not a F2FS filesystem (no superblock)" ); + goto fail; + } + }
You should check for err != GRUB_ERR_BAD_FS here, otherwise error from grub_disk_read is lost. Alternatively just return 0/1 from read_sb, so that
if (grub_f2fs_read_sb)
if (grub_f2fs_read_sb)
if (grub_errno == GRUB_ERR_NONE)
grub_error (GRUB_ERR_BAD_FS, ...)
goto failQuoted 33 lines
grub-core/fs/f2fs.c new file +33
-0+ + 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 ; +} +
...
grub-core/fs/f2fs.c line 899
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+ +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);
Why extra parens?
grub-core/fs/f2fs.c line 903
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+grub_off_t filesize =grub_f2fs_file_size (inode); +char *inline_addr =__inline_addr (inode); + +if (__inode_inline_set (&node->inode.i,FI_INLINE_DATA ))
Just inode, you already have it.
grub-core/fs/f2fs.c line 908
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+ { +if (pos > filesize || filesize >MAX_INLINE_DATA ) + { +grub_error (GRUB_ERR_OUT_OF_RANGE , +N_ ("attempt to read past the end of file" ));
If filesize > MAX_INLINE_DATA at this point we really deal with corrupted filesystem so this should be GRUB_ERR_BAD_FS.
grub-core/fs/f2fs.c line 911
Quoted 3 lines
grub-core/fs/f2fs.c new file +3
-0+return -1 ; + } +if (pos + len > filesize)
len > filesize - pos is probably more coverity-friendly.
Quoted 13 lines
grub-core/fs/f2fs.c new file +13
-0+ len = filesize - pos; + +grub_memcpy (buf + pos, 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 ); +} +
...
Quoted 14 lines
grub-core/fs/f2fs.c new file +14
-0+ +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;
grub-core/fs/f2fs.c line 978
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ +if (grub_generic_test_bit (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_zalloc (name_len +1 );
It is overwritten on next line, do you really need grub_zalloc only for the trailing zero?
Quoted 33 lines
grub-core/fs/f2fs.c new file +33
-0+if (!filename) +return 0 ; + +grub_memcpy (filename, ctx->filename[i], name_len); + + 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 ; +} +
...
grub-core/fs/f2fs.c line 1221
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ +static void +grub_f2fs_unicode_to_ascii (grub_uint8_t *out_buf,grub_uint16_t *in_buf) +{ +grub_uint16_t *pchTempPtr = in_buf; +grub_uint8_t *pwTempPtr = out_buf; + +while (*pchTempPtr !='\0' ) + { + *pwTempPtr = (grub_uint8_t) *pchTempPtr;
This is not byte order safe and it does not convert to ASCII as name suggests. If you are going to convert to 8 bit encoding why not simply use grub_utf16_to_utf8?
Quoted 12 lines
grub-core/fs/f2fs.c new file +12
-0+ pchTempPtr++; + pwTempPtr++; + } + *pwTempPtr ='\0' ; +return ; +} + +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-core/fs/f2fs.c line 1243
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ +grub_dl_ref (my_mod); + + data =grub_f2fs_mount (disk); +if (data) + { + *label =grub_zalloc (sizeof (data->sblock.volume_name)); +if (*label) +grub_f2fs_unicode_to_ascii ((grub_uint8_t *) (*label), + data->sblock.volume_name);
See above.
grub-core/fs/f2fs.c line 1252
Quoted 9 lines
grub-core/fs/f2fs.c new file +9
-0+ } +else + *label =NULL ; + +grub_free (data); +grub_dl_unref (my_mod); +return grub_errno; +} +
...
_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
В Sat, 2 May 2015 20:15:45 +0300
Andrei Borzenkov <[email protected]> пишет:
Quoted 15 lines
grub-core/fs/f2fs.c line 332
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+ +static inline int +grub_generic_test_bit (int nr,const grub_uint32_t *addr) +{ +return 1UL & (addr[nr /32 ] >> (nr &31 )); +} +This is used only in
grub_f2fs_check_dentries()with on-disk bitmap. On-disk bitmap is little-endian; code is wrong on big-endian system.Also
dentry_bitmapis not multiple of 4 bytes as you replied earlier. You should rather compute correct byte address instead and make all parametersgrub_uint8_t*. This will also avoid all those casts later.
Quoted 8 lines
That's really just
grub_uint8_t*addr;byte = nr >> 3;
#ifdefWORDS_BIGENDIAN
byte ^= 3;
#endif
Scratch it. We do know that byte order is LE so it is fixed. Sorry.
Quoted 2 lines
return addr[byte] & (1 << nr & 7);
_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
Quoted 5 lines
grub_uint8_t*addr;byte = nr >> 3;
#ifdefWORDS_BIGENDIAN
#ifdef GRUB_CPU_WORDS_BIGENDIAN actually
Also in general it's very good idea to check on big-endian machines.
We don't add __ prefix to function names.
Quoted 6 lines · Vladimir 'φ-coder/phcoder' Serbinenko
Quoted 5 lines
grub_uint8_t*addr;byte = nr >> 3;
#ifdefWORDS_BIGENDIAN#ifdef
GRUB_CPU_WORDS_BIGENDIANactually
It is not needed at all. on-disk format is fixed and little endian. Sorry for confusion.
Hello,
Change log from v2:
o Enhance the code quality suggested by Andrei
Sorry for the long delay.
Could you please check this patch?
Thank you so much,
--- >& ---
From 2c0e1d33533fc9fb2686f0e2c17efca11ce57e2f Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
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
--- Makefile.util.def | 7 + docs/grub.texi | 5 +- grub-core/Makefile.core.def | 5 + grub-core/fs/f2fs.c | 1291 ++++++++++++++++++++++++++++++++++++++++++ po/exclude.pot | 1 + tests/f2fs_test.in | 19 + tests/util/grub-fs-tester.in | 11 +- 7 files changed, 1335 insertions(+), 4 deletions(-) create mode 100644 grub-core/fs/f2fs.c create mode 100644 tests/f2fs_test.in
Makefile.util.def +7 -0
@@ -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; };
docs/grub.texi +3 -2
@@ -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
grub-core/Makefile.core.def +5 -0
@@ -1278,6 +1278,11 @@ module = { }; module = { + name = f2fs; + common = fs/f2fs.c; +}; + +module = { name = fshelp; common = fs/fshelp.c; };
grub-core/fs/f2fs.c new file +1291 -0
1,291 lines not on this page · raw message
po/exclude.pot +1 -0
@@ -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 ""
tests/f2fs_test.in new file +19 -0
@@ -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
tests/util/grub-fs-tester.in +9 -2
@@ -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,11 @@ 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 + # TODO: seems that mkfs.f2fs doesn't handle encoding stuffs correctly + x"f2fs") + FSLABEL="grub_test:no utf16";; + # FS LIMITATION: exfat is at most 15 UTF-16 chars x"exfat") FSLABEL="géт ;/莭莽😁кир";;
@@ -474,7 +479,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 +758,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)
Signature · 8 lines
2.4.9 (Apple Git-60) ------------------------------------------------------------------------------ _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
20.11.2015 00:28, Jaegeuk Kim пишет:
Quoted 10 lines
Hello,
Change log from v2:
o Enhance the code quality suggested by AndreiSorry for the long delay.
Could you please check this patch?Thank you so much,
Thank you for continuing to work on it!
...
grub-core/fs/f2fs.c line 332
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+ +static inline int +grub_generic_test_bit (int nr,const grub_uint32_t *addr) +{ +return 1UL & (addr[nr /32 ] >> (nr &31 )); +} +
As already discussed this code is wrong on big-endian platform. On-disk bitmap is little-endian and kernel explicitly uses test_bit_le() here.
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+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);
grub-core/fs/f2fs.c line 352
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+} + +static inline grub_uint32_t +__start_cp_addr (struct grub_f2fs_data *data) +{ +struct grub_f2fs_checkpoint *ckpt = &data->ckpt; +grub_uint64_t ckpt_version =grub_le_to_cpu64 (ckpt->checkpoint_ver); +grub_uint32_t start_addr = data->cp_blkaddr; + +if (!(ckpt_version &1 ))
This can use grub_cpu_to_le64_compile_time (1)
...
grub-core/fs/f2fs.c line 443
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-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) !=0 ;
This is really just "return mask & *p".
Quoted 13 lines
grub-core/fs/f2fs.c new file +13
-0+} + +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 ; +
grub-core/fs/f2fs.c line 466
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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_MAX_LOG_SECTOR_SIZE ) +return -1 ; + +if (log_sectorsize <F2FS_MIN_LOG_SECTOR_SIZE ) +return -1 ; + +if (log_sectors_per_block + log_sectorsize !=F2FS_MAX_LOG_SECTOR_SIZE )
This sounds like it should actually be F2FS_BLK_BITS; at least assuming that F2FS_MAX_LOG_SECTOR_SIZE may differ from F2FS_BLK_BITS.
...
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+ +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)
grub-core/fs/f2fs.c line 889
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+{ +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 (pos > filesize || filesize >MAX_INLINE_DATA ) + { +grub_error (GRUB_ERR_BAD_FS ,"corrupted inline_data: need fsck" );
Sorry for confusion, my fault. pos > filesize was OK, but filesize > MAX_INLINE_DATA not.
...
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+ +/* TODO: mkfs.f2fs stores label in a wrong way. Should be fixed. */ +static void +grub_f2fs_unicode_to_ascii (grub_uint8_t *out_buf,grub_uint16_t *in_buf) +{ +grub_uint16_t *pchTempPtr = in_buf; +grub_uint8_t *pwTempPtr = out_buf;
grub-core/fs/f2fs.c line 1210
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ +while (*pchTempPtr !='\0' ) + { + *pwTempPtr = (grub_uint8_t) *pchTempPtr; + pchTempPtr++; + pwTempPtr++; + } + *pwTempPtr ='\0' ; +return ; +}
Sorry, I do not see how it can work on both big and little endian platforms. What byte order is used for on-disk label? Why cannot you use grub_utf16_to_utf8 as I asked last time?
Also please add bundary check, do not rely on correct content.
_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
Thank you for the review.
Quoted 16 lines · Andrei Borzenkov
20.11.2015 00:28, Jaegeuk Kim пишет:
Quoted 10 lines
Hello,
Change log from v2:
o Enhance the code quality suggested by AndreiSorry for the long delay.
Could you please check this patch?Thank you so much,
Thank you for continuing to work on it!
...
Quoted 10 lines
grub-core/fs/f2fs.c line 332
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+ +static inline int +grub_generic_test_bit (int nr,const grub_uint32_t *addr) +{ +return 1UL & (addr[nr /32 ] >> (nr &31 )); +} +As already discussed this code is wrong on big-endian platform. On-disk bitmap is little-endian and kernel explicitly uses
test_bit_le()here.
Got it.
Quoted 15 lines
Quoted 15 lines
grub-core/fs/f2fs.c new file +14
-0+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)
Quoted 8 lines
grub-core/fs/f2fs.c line 352
Quoted 6 lines
grub-core/fs/f2fs.c new file +6
-0+{ +struct grub_f2fs_checkpoint *ckpt = &data->ckpt; +grub_uint64_t ckpt_version =grub_le_to_cpu64 (ckpt->checkpoint_ver); +grub_uint32_t start_addr = data->cp_blkaddr; + +if (!(ckpt_version &1 ))This can use
grub_cpu_to_le64_compile_time(1)
Done.
Quoted 13 lines
...
grub-core/fs/f2fs.c line 443
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-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) !=0 ;This is really just "return mask & *p".
Okay.
Quoted 19 lines
Quoted 19 lines
grub-core/fs/f2fs.c new file +18
-0+} + +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_MAX_LOG_SECTOR_SIZE ) +return -1 ;
Quoted 9 lines
grub-core/fs/f2fs.c line 466
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+ +if (log_sectorsize <F2FS_MIN_LOG_SECTOR_SIZE ) +return -1 ; + +if (log_sectors_per_block + log_sectorsize !=F2FS_MAX_LOG_SECTOR_SIZE )This sounds like it should actually be
F2FS_BLK_BITS; at least assuming thatF2FS_MAX_LOG_SECTOR_SIZEmay differ fromF2FS_BLK_BITS.
Yup. In order to avoid confusion, I removed F2FS_MAX_LOG_SECTOR_SIZE.
Quoted 13 lines
...
Quoted 11 lines
grub-core/fs/f2fs.c new file +11
-0+ +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 )
Quoted 8 lines
grub-core/fs/f2fs.c line 889
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+ { +if (pos > filesize || filesize >MAX_INLINE_DATA ) + { +grub_error (GRUB_ERR_BAD_FS ,"corrupted inline_data: need fsck" );Sorry for confusion, my fault. pos > filesize was OK, but filesize >
MAX_INLINE_DATAnot.
If filesize is over MAX_INLINE_DATA, this file is corrupted as well. It will cause boundary violation during memcpy below.
Quoted 25 lines
...
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+ +/* TODO: mkfs.f2fs stores label in a wrong way. Should be fixed. */ +static void +grub_f2fs_unicode_to_ascii (grub_uint8_t *out_buf,grub_uint16_t *in_buf) +{ +grub_uint16_t *pchTempPtr = in_buf; +grub_uint8_t *pwTempPtr = out_buf;grub-core/fs/f2fs.c line 1210
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ +while (*pchTempPtr !='\0' ) + { + *pwTempPtr = (grub_uint8_t) *pchTempPtr; + pchTempPtr++; + pwTempPtr++; + } + *pwTempPtr ='\0' ; +return ; +}Sorry, I do not see how it can work on both big and little endian platforms. What byte order is used for on-disk label? Why cannot you use
grub_utf16_to_utf8as I asked last time?
Quoted 1 line
Also please add bundary check, do not rely on correct content.
Got it. I refactored this here and in f2fs-tools as well. Could you check v4?
Thanks,
Quoted 8 lines
------------------------------------------------------------------------------
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
------------------------------------------------------------------------------
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Change log from v3:
o add grub_test_bit_le()
o fix label handling with utf16
o change some minor concerns
-- >8 --
From 4ab813c29851113da04d9ca84670219434ee570e Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
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
--- Makefile.util.def | 7 + docs/grub.texi | 5 +- grub-core/Makefile.core.def | 5 + grub-core/fs/f2fs.c | 1291 ++++++++++++++++++++++++++++++++++++++++++ po/exclude.pot | 1 + tests/f2fs_test.in | 19 + tests/util/grub-fs-tester.in | 10 +- 7 files changed, 1334 insertions(+), 4 deletions(-) create mode 100644 grub-core/fs/f2fs.c create mode 100644 tests/f2fs_test.in
Makefile.util.def +7 -0
@@ -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; };
docs/grub.texi +3 -2
@@ -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
grub-core/Makefile.core.def +5 -0
@@ -1278,6 +1278,11 @@ module = { }; module = { + name = f2fs; + common = fs/f2fs.c; +}; + +module = { name = fshelp; common = fs/fshelp.c; };
grub-core/fs/f2fs.c new file +1291 -0
1,291 lines not on this page · raw message
po/exclude.pot +1 -0
@@ -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 ""
tests/f2fs_test.in new file +19 -0
@@ -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
tests/util/grub-fs-tester.in +8 -2
@@ -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)
Signature · 7 lines
2.5.4 (Apple Git-61) ------------------------------------------------------------------------------ _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
15.12.2015 03:34, Jaegeuk Kim пишет:
Quoted 2 lines
Change log from v3:
o addgrub_test_bit_le()
...
grub-core/fs/f2fs.c line 331
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+ +static inline int +grub_f2fs_test_bit_le (int nr,const grub_uint8_t *addr) +{ +const grub_int32_t *p = (const grub_int32_t *)addr; + + nr = nr ^0 ;
It does nothing.
grub-core/fs/f2fs.c line 334
Quoted 3 lines
grub-core/fs/f2fs.c new file +3
-0+ +return p[nr >>5 ] & (1 << (nr &31 )); +}
Well, you still miss the point - if you are working with integers you must shift differently depending on whether we are running big or little endian.
But as I mentioned before, we know that bitmap is little endian so we can work with bytes and be independent of byte order. Could you test if this works for you:
static inline intgrub_f2fs_test_bit_le (int nr, const grub_uint8_t *addr) {
return addr[nr >> 3] & (1 << (nr & 7));
}
------------------------------------------------------------------------------
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Quoted 5 lines · Andrei Borzenkov
15.12.2015 03:34, Jaegeuk Kim пишет:
Quoted 2 lines
Change log from v3:
o addgrub_test_bit_le()...
Quoted 9 lines
grub-core/fs/f2fs.c line 331
Quoted 7 lines
grub-core/fs/f2fs.c new file +7
-0+ +static inline int +grub_f2fs_test_bit_le (int nr,const grub_uint8_t *addr) +{ +const grub_int32_t *p = (const grub_int32_t *)addr; + + nr = nr ^0 ;It does nothing.
Ah, right.
Quoted 8 lines
grub-core/fs/f2fs.c line 334
Quoted 4 lines
grub-core/fs/f2fs.c new file +3
-0+ +return p[nr >>5 ] & (1 << (nr &31 )); +}Well, you still miss the point - if you are working with integers you must shift differently depending on whether we are running big or little endian.
I just thought that it would be okay to bypass 32bits and then check its target location, since we know it is LE.
Indeed, I was wrong that your concern was this line will be converted to BE when CPU loads this 32-bit value.
Quoted 9 lines
But as I mentioned before, we know that bitmap is little endian so we can work with bytes and be independent of byte order. Could you test if this works for you:
static inline int
grub_f2fs_test_bit_le(int nr, constgrub_uint8_t*addr) {
return addr[nr >> 3] & (1 << (nr & 7));
}
Actually, I tested this before, but I got somehow failure, so tried this one. Once I've checked bitmap contents in more details, I realized that this should be a correct way; I confirmed that this has no problem.
I'll send another patch.
Thank you so much,
------------------------------------------------------------------------------
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Change log from v4:
o fix grub_test_bit_le()
-- >8 --
From c507937c6e1f74ea0f5b75bab4bbb983334d9581 Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
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
--- Makefile.util.def | 7 + docs/grub.texi | 5 +- grub-core/Makefile.core.def | 5 + grub-core/fs/f2fs.c | 1287 ++++++++++++++++++++++++++++++++++++++++++ po/exclude.pot | 1 + tests/f2fs_test.in | 19 + tests/util/grub-fs-tester.in | 10 +- 7 files changed, 1330 insertions(+), 4 deletions(-) create mode 100644 grub-core/fs/f2fs.c create mode 100644 tests/f2fs_test.in
Makefile.util.def +7 -0
@@ -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; };
docs/grub.texi +3 -2
@@ -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
grub-core/Makefile.core.def +5 -0
@@ -1278,6 +1278,11 @@ module = { }; module = { + name = f2fs; + common = fs/f2fs.c; +}; + +module = { name = fshelp; common = fs/fshelp.c; };
grub-core/fs/f2fs.c new file +1287 -0
1,287 lines not on this page · raw message
po/exclude.pot +1 -0
@@ -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 ""
tests/f2fs_test.in new file +19 -0
@@ -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
tests/util/grub-fs-tester.in +8 -2
@@ -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)
Signature · 8 lines
2.5.4 (Apple Git-61) ------------------------------------------------------------------------------ _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
I've tried to compile this for ARM(using gcc 5.2.0) and there are a few warnings:
In file included from grub/include/grub/file.h:22:0,
from grub/grub-core/fs/f2fs.c:22:
grub/grub-core/fs/f2fs.c: In function 'validate_checkpoint':grub/grub-core/fs/f2fs.c:509:28: error: cast increases required alignment of target type [-Werror=cast-align]
crc = grub_le_to_cpu32 (*(grub_uint32_t *)((char *)cp_block +
crc_offset));
^
grub/include/grub/types.h:239:48: note: in definition of macro
'grub_le_to_cpu32'
# define grub_le_to_cpu32(x) ((grub_uint32_t) (x))
^
grub/grub-core/fs/f2fs.c:531:28: error: cast increases required alignment
of target type [-Werror=cast-align]
crc = grub_le_to_cpu32 (*(grub_uint32_t *)((char *)cp_block +
crc_offset));
^
grub/include/grub/types.h:239:48: note: in definition of macro
'grub_le_to_cpu32'
# define grub_le_to_cpu32(x) ((grub_uint32_t) (x))Quoted 1,527 lines · Jaegeuk Kim
Change log from v4:
o fixgrub_test_bit_le()-- >8 --
Fromc507937c6e1f74ea0f5b75bab4bbb983334d9581Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
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.gitSigned-off-by Jaegeuk Kim <[email protected]>--- Makefile.util.def | 7 + docs/grub.texi | 5 +- grub-core/Makefile.core.def | 5 + grub-core/fs/f2fs.c | 1287 ++++++++++++++++++++++++++++++++++++++++++ po/exclude.pot | 1 + tests/f2fs_test.in | 19 + tests/util/grub-fs-tester.in | 10 +- 7 files changed, 1330 insertions(+), 4 deletions(-) create mode 100644 grub-core/fs/f2fs.c create mode 100644 tests/f2fs_test.inMakefile.util.def +7
-0@@ -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; };docs/grub.texi +0
-0@@ -360,7 +360,8 @@ blocklist notation. The currently supported filesystemtypes 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},docs/grub.texi +0
-0@@ -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),docs/grub.texi +1
-1-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 systemto use
grub-core/Makefile.core.def +5
-0@@ -1278,6 +1278,11 @@ module = { }; module = { + name = f2fs; + common = fs/f2fs.c; +}; + +module = { name = fshelp; common = fs/fshelp.c; };grub-core/fs/f2fs.c new file +39
-0@@ -0,0 +1,1287 @@ +/* +* f2fs.c - Flash-Friendly File System +* +* Written by Jaegeuk Kim <[email protected]> +* +* 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 + +/* byte-size offset */ +#define F2FS_SUPER_OFFSET ((grub_disk_addr_t)1024) +#define F2FS_SUPER_OFFSET0 (F2FS_SUPER_OFFSET >>
GRUB_DISK_SECTOR_BITS)grub-core/fs/f2fs.c new file +43
-0+#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)/ \
grub-core/fs/f2fs.c new file +4
-0+ BITS_PER_BYTE) +#define SIZE_OF_RESERVED (F2FS_BLKSIZE - ((SIZE_OF_DIR_ENTRY + \ + F2FS_SLOT_LEN) * \ + NR_DENTRY_IN_BLOCK +
SIZE_OF_DENTRY_BITMAP))grub-core/fs/f2fs.c new file +2
-0+ +#define F2FS_INLINE_XATTR_ADDRS 50/* 200 bytes for inline xattrs */
grub-core/fs/f2fs.c new file +3
-0+#define DEF_ADDRS_PER_INODE 923/* Address Pointers in an Inode */ + +#define ADDRS_PER_BLOCK 1018/* Address Pointers in a Direct Block */
grub-core/fs/f2fs.c new file +26
-0+#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 */
+#defineF2FS_INLINE_DOTS0x10/* file having implicit dot
dentries */grub-core/fs/f2fs.c new file +157
-0+ +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-core/fs/f2fs.c new file +85
-0+ }; +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);grub-core/fs/f2fs.c new file +35
-0+} + +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)
grub-core/fs/f2fs.c new file +30
-0+{ +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_tlen)grub-core/fs/f2fs.c new file +52
-0+{ +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);grub-core/fs/f2fs.c new file +32
-0+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) +{ +void *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 (*(grub_uint32_t *)((char *)cp_block +
crc_offset));grub-core/fs/f2fs.c new file +22
-0+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 (*(grub_uint32_t *)((char *)cp_block +
crc_offset));grub-core/fs/f2fs.c new file +93
-0+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_tnid)
grub-core/fs/f2fs.c new file +10
-0+{ +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);
grub-core/fs/f2fs.c new file +253
-0+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 (pos > filesize || filesize >MAX_INLINE_DATA ) + { + grub_error (GRUB_ERR_BAD_FS, "corrupted inline_data: needfsck");
grub-core/fs/f2fs.c new file +181
-0+return -1 ; + } +if (len > filesize - pos) + len = filesize - pos; + +grub_memcpy (buf + pos, 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_filetypefiletype,
grub-core/fs/f2fs.c new file +219
-0+ 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 ; + +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); + + file->size =grub_f2fs_file_size (&(data->inode->i)); + file->data = data; + file->offset =0 ; + +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); +}po/exclude.pot +1
-0@@ -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 ""tests/f2fs_test.in new file +19
-0@@ -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" f2fstests/util/grub-fs-tester.in +0
-0@@ -142,7 +142,7 @@ for((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
xsquash*) MINBLKSIZE=4096 MAXBLKSIZE=1048576;;tests/util/grub-fs-tester.in +1
-1- 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é莭莽😁киритiurewfceniuewruevrewnuuireurevueurnievrewfnerfcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvrevuurerejiremvreijnvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoif";;
tests/util/grub-fs-tester.in +3
-0+ # FS LIMITATION: f2fs label is at most 512 UTF-16 chars + x"f2fs") + FSLABEL="grub_;/testé䏌䐓䏕киритiurewfceniuewruewnuuireurevueurnievrewfnerfcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvrevuurerejiremvreijnvvcreivirenverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoirvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoircreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoifoiq";;
tests/util/grub-fs-tester.in +1
-0+ # 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" \
tests/util/grub-fs-tester.in +1
-1- | 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}" ;;tests/util/grub-fs-tester.in +2
-0+ xf2fs) + "mkfs.f2fs" -l "$FSLABEL" -q "${LODEVICES[0]}" ;; xnilfs2) "mkfs.nilfs2" -L "$FSLABEL" -b $BLKSIZE -q"${LODEVICES[0]}" ;; xext2_old)
Quoted 9 lines
--
2.5.4 (Apple Git-61)_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
Change log from v5:
o fix build warning for ARM, reported by Michael Zimmermann
Thanks to Michael for testing this patch.
-- >8 --
From 284fd66662a6d5e07770cc021c8f59b538471c35 Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
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
--- Makefile.util.def | 7 + docs/grub.texi | 5 +- grub-core/Makefile.core.def | 5 + grub-core/fs/f2fs.c | 1288 ++++++++++++++++++++++++++++++++++++++++++ po/exclude.pot | 1 + tests/f2fs_test.in | 19 + tests/util/grub-fs-tester.in | 10 +- 7 files changed, 1331 insertions(+), 4 deletions(-) create mode 100644 grub-core/fs/f2fs.c create mode 100644 tests/f2fs_test.in
Makefile.util.def +7 -0
@@ -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; };
docs/grub.texi +3 -2
@@ -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
grub-core/Makefile.core.def +5 -0
@@ -1278,6 +1278,11 @@ module = { }; module = { + name = f2fs; + common = fs/f2fs.c; +}; + +module = { name = fshelp; common = fs/fshelp.c; };
grub-core/fs/f2fs.c new file +1288 -0
1,288 lines not on this page · raw message
po/exclude.pot +1 -0
@@ -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 ""
tests/f2fs_test.in new file +19 -0
@@ -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
tests/util/grub-fs-tester.in +8 -2
@@ -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)
Signature · 13 lines
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=267308311&iu=/4140 _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
08.01.2016 22:41, Jaegeuk Kim пишет:
Quoted 27 lines
Change log from v5:
o fix build warning for ARM, reported by Michael ZimmermannThanks to Michael for testing this patch.
-- >8 --
From284fd66662a6d5e07770cc021c8f59b538471c35Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
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.
Quoted 5 lines
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
Sorry for delay. I'm fine with it (with single nitpick, see below); Vladimir has final word whether this can be committed.
...
grub-core/fs/f2fs.c line 886
Quoted 12 lines
grub-core/fs/f2fs.c new file +12
-0+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 (pos > filesize || filesize >MAX_INLINE_DATA )
GRUB checks that pos < filesize before calling into fs so this is redundant. And filesize check is static so can be done in ->open.
------------------------------------------------------------------------------
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 [email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Hi Andrei,
I'll send v7 which addresses your comment.
Thanks,
Quoted 38 lines · Andrei Borzenkov
08.01.2016 22:41, Jaegeuk Kim пишет:
Quoted 27 lines
Change log from v5:
o fix build warning for ARM, reported by Michael ZimmermannThanks to Michael for testing this patch.
-- >8 --
From284fd66662a6d5e07770cc021c8f59b538471c35Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
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.
Quoted 5 lines
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.gitSorry for delay. I'm fine with it (with single nitpick, see below); Vladimir has final word whether this can be committed.
...
Quoted 15 lines
grub-core/fs/f2fs.c line 886
Quoted 12 lines
grub-core/fs/f2fs.c new file +12
-0+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 (pos > filesize || filesize >MAX_INLINE_DATA )GRUB checks that pos < filesize before calling into fs so this is redundant. And filesize check is static so can be done in ->open.
_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
Chang log from v6:
o remove redundant filesize check in ->read
o check consistency in ->open regarding to inline_data
-- >8 --
From 51c120612fdbc4bc315e9c4c6e91ca888c3f3596 Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
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
--- 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
Makefile.util.def +7 -0
@@ -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; };
docs/grub.texi +3 -2
@@ -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
grub-core/Makefile.core.def +5 -0
@@ -1278,6 +1278,11 @@ module = { }; module = { + name = f2fs; + common = fs/f2fs.c; +}; + +module = { name = fshelp; common = fs/fshelp.c; };
grub-core/fs/f2fs.c new file +1289 -0
1,289 lines not on this page · raw message
po/exclude.pot +1 -0
@@ -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 ""
tests/f2fs_test.in new file +19 -0
@@ -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
tests/util/grub-fs-tester.in +8 -2
@@ -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)
Signature · 13 lines
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 [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
[2.02] Re: [f2fs-dev] [PATCH v7] F2FS support
ACK from my side. It is leaf code that does not affect anything so should not cause any regression.
22.02.2016 21:25, Jaegeuk Kim пишет:
Quoted 1,475 lines
Chang log from v6:
o remove redundant filesize check in ->read
o check consistency in ->open regarding toinline_data-- >8 --
From51c120612fdbc4bc315e9c4c6e91ca888c3f3596Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
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.gitSigned-off-by Jaegeuk Kim <[email protected]>--- 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.inMakefile.util.def +7
-0@@ -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; };docs/grub.texi +3
-2@@ -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 usegrub-core/Makefile.core.def +5
-0@@ -1278,6 +1278,11 @@ module = { }; module = { + name = f2fs; + common = fs/f2fs.c; +}; + +module = { name = fshelp; common = fs/fshelp.c; };grub-core/fs/f2fs.c new file +1289
-0@@ -0,0 +1,1289 @@ +/* +* f2fs.c - Flash-Friendly File System +* +* Written by Jaegeuk Kim <[email protected]> +* +* 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 + pos, 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); +}po/exclude.pot +1
-0@@ -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 ""tests/f2fs_test.in new file +19
-0@@ -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" f2fstests/util/grub-fs-tester.in +6
-2@@ -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;;
tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + · line 764
Quoted 8 lines
tests/util/grub-fs-tester.in +2
-0@@ -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)
_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
Re: [2.02] Re: [f2fs-dev] [PATCH v7] F2FS support
I found a bug in the 'grub_f2fs_read_file' function. It fails when the file position is not 0. to fix it:
- grub_memcpy (buf + pos, inline_addr + pos, len);
+ grub_memcpy (buf, inline_addr + pos, len);
Michael
Quoted 1,541 lines · Andrei Borzenkov
ACK from my side. It is leaf code that does not affect anything so should not cause any regression.
22.02.2016 21:25, Jaegeuk Kim пишет:
Quoted 11 lines
Chang log from v6:
o remove redundant filesize check in ->read
o check consistency in ->open regarding toinline_data-- >8 --
From51c120612fdbc4bc315e9c4c6e91ca888c3f3596Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
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
Quoted 3 lines
into Linux kernel v3.8 in 2013.
The motive for F2FS was to build a file system that from the start,
takes into
Quoted 1 line
account the characteristics of NAND flash memory-based storage devices
(such as
Quoted 3 lines
solid-state disks, eMMC, and SD cards).
F2FS was designed on a basis of a log-structured file system approach,
which
Quoted 1 line
remedies some known issues of the older log structured file systems,
such as
Quoted 1 line
the snowball effect of wandering trees and high cleaning overhead. In
addition,
Quoted 1 line
since a NAND-based storage device shows different characteristics
according to
Quoted 1 line
its internal geometry or flash memory management scheme (such as the
Flash
Quoted 2 lines
Translation Layer or FTL), it supports various parameters not only for configuring on-disk layout, but also for selecting allocation and
cleaning
Quoted 7 lines
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.gitQuoted 6 lines
Signed-off-by Jaegeuk Kim <[email protected]>--- Makefile.util.def | 7 + docs/grub.texi | 5 +- grub-core/Makefile.core.def | 5 + grub-core/fs/f2fs.c | 1289++++++++++++++++++++++++++++++++++++++++++
docs/grub.texi blocklist notation. The currently supported
Quoted 37 lines
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.inMakefile.util.def +7
-0@@ -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; };docs/grub.texi +0
-0@@ -360,7 +360,8 @@ blocklist notation. The currently supportedfilesystem types are @dfn{Amiga
docs/grub.texi blocklist notation. The currently supported filesystem types are @dfn{Amiga
Quoted 4 lines
docs/grub.texi +0
-1Fast 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},
docs/grub.texi blocklist notation. The currently supported filesystem types are @dfn{Amiga
Quoted 3 lines
docs/grub.texi +2
-0+@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-chunkfiles),
docs/grub.texi NTFS, JFS, UDF, HFS+, exFAT, long filenames in
Quoted 3 lines
docs/grub.texi +0
-0@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 inFAT, Joliet part of
docs/grub.texi NTFS, JFS, UDF, HFS+, exFAT, long filenames in · line 5349
Quoted 2 lines
docs/grub.texi +0
-0ISO9660 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,
docs/grub.texi NTFS, JFS, UDF, HFS+, exFAT, long filenames in · line 5350
Quoted 1 line
docs/grub.texi +0
-0minix2, minix3, ROMFS, ReiserFS, XFS, ext2, ext3, ext4, FAT (shortnames),
docs/grub.texi NTFS, JFS, UDF, HFS+, exFAT, long filenames in FAT, Joliet part of
Quoted 3 lines
docs/grub.texi +1
-1-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 legacycharset
docs/grub.texi NTFS, JFS, UDF, HFS+, exFAT, long filenames in · line 5353
Quoted 1 line
docs/grub.texi +0
-0but as long as the charset used is superset of ASCII you should be ableto
docs/grub.texi NTFS, JFS, UDF, HFS+, exFAT, long filenames in · line 5354
Quoted 1 line
docs/grub.texi +0
-0access ASCII-named files. And it's recommended to configure your systemto use
Quoted 47 lines
grub-core/Makefile.core.def +5
-0@@ -1278,6 +1278,11 @@ module = { }; module = { + name = f2fs; + common = fs/f2fs.c; +}; + +module = { name = fshelp; common = fs/fshelp.c; };grub-core/fs/f2fs.c new file +25
-0@@ -0,0 +1,1289 @@ +/* +* f2fs.c - Flash-Friendly File System +* +* Written by Jaegeuk Kim <[email protected]> +* +* 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> grub-core/fs/f2fs.c line 35
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+#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 */
grub-core/fs/f2fs.c
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+#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)Quoted 33 lines
grub-core/fs/f2fs.c new file +33
-0+#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)grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ +#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) / \grub-core/fs/f2fs.c
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+ BITS_PER_BYTE) +#define SIZE_OF_RESERVED (F2FS_BLKSIZE - ((SIZE_OF_DIR_ENTRY + \ + F2FS_SLOT_LEN) * \ + NR_DENTRY_IN_BLOCK +
SIZE_OF_DENTRY_BITMAP))grub-core/fs/f2fs.c line 89
Quoted 2 lines
grub-core/fs/f2fs.c new file +2
-0+ +#define F2FS_INLINE_XATTR_ADDRS 50/* 200 bytes for inline xattrs */
grub-core/fs/f2fs.c
Quoted 3 lines
grub-core/fs/f2fs.c new file +3
-0+#define DEF_ADDRS_PER_INODE 923/* Address Pointers in an Inode */ + +#define ADDRS_PER_BLOCK 1018/* Address Pointers in a Direct Block */
Quoted 16 lines
grub-core/fs/f2fs.c new file +16
-0+#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) * \grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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 */
grub-core/fs/f2fs.c line 119
Quoted 1 line
grub-core/fs/f2fs.c new file +1
-0+#define F2FS_INLINE_DOTS 0x10/* file having implicit dot dentries */
Quoted 147 lines
grub-core/fs/f2fs.c new file +147
-0+ +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-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+}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 */
Quoted 75 lines
grub-core/fs/f2fs.c new file +75
-0+ }; +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 )))grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+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);Quoted 25 lines
grub-core/fs/f2fs.c new file +25
-0+} + +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; +} +grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+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_tblkaddr, void *buf)
Quoted 20 lines
grub-core/fs/f2fs.c new file +20
-0+{ +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--)grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ { + 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_tlen)Quoted 17 lines
grub-core/fs/f2fs.c new file +17
-0+{ +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; +}grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ +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))Quoted 15 lines
grub-core/fs/f2fs.c new file +15
-0+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 ;grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-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);Quoted 129 lines
grub-core/fs/f2fs.c new file +129
-0+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 grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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);grub-core/fs/f2fs.c
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+ +fail: +grub_free (buf); +return err; +} + +static grub_uint32_t +get_blkaddr_from_nat_journal (struct grub_f2fs_data *data,
grub_uint32_tnid)grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+{ +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);
Quoted 194 lines
grub-core/fs/f2fs.c new file +194
-0+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; +grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+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)Quoted 217 lines
grub-core/fs/f2fs.c new file +217
-0+{ +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 + pos, 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);grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+if (ret) +return 1 ; + + fpos +=F2FS_BLKSIZE ; + } +return 0 ; +} + +static int +grub_f2fs_dir_iter (const char *filename, enum grub_fshelp_filetypefiletype,
Quoted 83 lines
grub-core/fs/f2fs.c new file +83
-0+ 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-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ +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)Quoted 56 lines
grub-core/fs/f2fs.c new file +56
-0+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_tgrub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+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);Quoted 12 lines
grub-core/fs/f2fs.c new file +12
-0+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-core/fs/f2fs.c line 1259
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+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",
Quoted 47 lines
grub-core/fs/f2fs.c new file +42
-0+ 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); +}po/exclude.pot +0
-0po/exclude.pot msgstr "" · line 1219
Quoted 6 lines
po/exclude.pot +1
-0@@ -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"
tests/util/grub-fs-tester.in for
Quoted 31 lines
po/exclude.pot +0
-0msgstr ""tests/f2fs_test.in new file +19
-0@@ -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" f2fstests/util/grub-fs-tester.in +0
-0@@ -142,7 +142,7 @@ for((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
tests/util/grub-fs-tester.in for
Quoted 9 lines
tests/util/grub-fs-tester.in +1
-1xsquash*) 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 +
tests/util/grub-fs-tester.in for · line 266
Quoted 2 lines
tests/util/grub-fs-tester.in +0
-0x"btrfs"*) FSLABEL="grub_;/testé莭莽😁киритiurewfceniuewruevrewnuuireurevueurnievrewfnerfcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvrevuurerejiremvreijnvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoif";;
tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + · line 271
Quoted 4 lines
tests/util/grub-fs-tester.in +3
-0+ # FS LIMITATION: f2fs label is at most 512 UTF-16 chars + x"f2fs") +FSLABEL="grub_;/testé䏌䐓䏕киритiurewfceniuewruewnuuireurevueurnievrewfnerfcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvrevuurerejiremvreijnvvcreivire
nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoirvcreivire
nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoircreivire
nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoifoiq";;tests/util/grub-fs-tester.in for
Quoted 5 lines
tests/util/grub-fs-tester.in +1
-0+ # 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 +
tests/util/grub-fs-tester.in for · line 478
Quoted 1 line
tests/util/grub-fs-tester.in +0
-0# FIXME: Not sure about BtrFS, NTFS, JFS, AFS, UDF and SFS.Check it.
tests/util/grub-fs-tester.in for · line 479
Quoted 1 line
tests/util/grub-fs-tester.in +0
-0# FS LIMITATION: as far as I know those FS don't store their lastmodification date.
tests/util/grub-fs-tester.in for · line 480
Quoted 1 line
tests/util/grub-fs-tester.in +0
-0x"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;;tests/util/grub-fs-tester.in for
Quoted 1 line
tests/util/grub-fs-tester.in +0
-0@@ -753,6 +757,8 @@ for((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
Quoted 7 lines
tests/util/grub-fs-tester.in +2
-0MOUNTDEVICE="/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]}" ;;
Quoted 9 lines
tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + · line 764
Quoted 2 lines
tests/util/grub-fs-tester.in +0
-0xext2_old)_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
Re: [2.02] Re: [f2fs-dev] [PATCH v7] F2FS support
Review
Quoted 4 lines · Michael Zimmermann
I found a bug in the '
grub_f2fs_read_file' function. It fails when the file position is not 0. to fix it:(quoted diff) +1
-1- grub_memcpy (buf + pos, inline_addr + pos, len); + grub_memcpy (buf, inline_addr + pos, len);
Oops.
Thank you for taking a look at this.
Thanks,
Quoted 1,557 lines
Michael
Quoted 1,550 lines · Andrei Borzenkov
ACK from my side. It is leaf code that does not affect anything so should not cause any regression.
22.02.2016 21:25, Jaegeuk Kim пишет:
Quoted 11 lines
Chang log from v6:
o remove redundant filesize check in ->read
o check consistency in ->open regarding toinline_data-- >8 --
From51c120612fdbc4bc315e9c4c6e91ca888c3f3596Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
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
Quoted 3 lines
into Linux kernel v3.8 in 2013.
The motive for F2FS was to build a file system that from the start,
takes into
Quoted 1 line
account the characteristics of NAND flash memory-based storage devices
(such as
Quoted 3 lines
solid-state disks, eMMC, and SD cards).
F2FS was designed on a basis of a log-structured file system approach,
which
Quoted 1 line
remedies some known issues of the older log structured file systems,
such as
Quoted 1 line
the snowball effect of wandering trees and high cleaning overhead. In
addition,
Quoted 1 line
since a NAND-based storage device shows different characteristics
according to
Quoted 1 line
its internal geometry or flash memory management scheme (such as the
Flash
Quoted 2 lines
Translation Layer or FTL), it supports various parameters not only for configuring on-disk layout, but also for selecting allocation and
cleaning
Quoted 7 lines
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.gitQuoted 6 lines
Signed-off-by Jaegeuk Kim <[email protected]>--- Makefile.util.def | 7 + docs/grub.texi | 5 +- grub-core/Makefile.core.def | 5 + grub-core/fs/f2fs.c | 1289++++++++++++++++++++++++++++++++++++++++++
docs/grub.texi blocklist notation. The currently supported
Quoted 37 lines
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.inMakefile.util.def +7
-0@@ -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; };docs/grub.texi +0
-0@@ -360,7 +360,8 @@ blocklist notation. The currently supportedfilesystem types are @dfn{Amiga
docs/grub.texi blocklist notation. The currently supported filesystem types are @dfn{Amiga
Quoted 4 lines
docs/grub.texi +0
-1Fast 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},
docs/grub.texi blocklist notation. The currently supported filesystem types are @dfn{Amiga
Quoted 3 lines
docs/grub.texi +2
-0+@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-chunkfiles),
docs/grub.texi NTFS, JFS, UDF, HFS+, exFAT, long filenames in
Quoted 3 lines
docs/grub.texi +0
-0@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 inFAT, Joliet part of
docs/grub.texi NTFS, JFS, UDF, HFS+, exFAT, long filenames in · line 5349
Quoted 2 lines
docs/grub.texi +0
-0ISO9660 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,
docs/grub.texi NTFS, JFS, UDF, HFS+, exFAT, long filenames in · line 5350
Quoted 1 line
docs/grub.texi +0
-0minix2, minix3, ROMFS, ReiserFS, XFS, ext2, ext3, ext4, FAT (shortnames),
docs/grub.texi NTFS, JFS, UDF, HFS+, exFAT, long filenames in FAT, Joliet part of
Quoted 3 lines
docs/grub.texi +1
-1-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 legacycharset
docs/grub.texi NTFS, JFS, UDF, HFS+, exFAT, long filenames in · line 5353
Quoted 1 line
docs/grub.texi +0
-0but as long as the charset used is superset of ASCII you should be ableto
docs/grub.texi NTFS, JFS, UDF, HFS+, exFAT, long filenames in · line 5354
Quoted 1 line
docs/grub.texi +0
-0access ASCII-named files. And it's recommended to configure your systemto use
Quoted 47 lines
grub-core/Makefile.core.def +5
-0@@ -1278,6 +1278,11 @@ module = { }; module = { + name = f2fs; + common = fs/f2fs.c; +}; + +module = { name = fshelp; common = fs/fshelp.c; };grub-core/fs/f2fs.c new file +25
-0@@ -0,0 +1,1289 @@ +/* +* f2fs.c - Flash-Friendly File System +* +* Written by Jaegeuk Kim <[email protected]> +* +* 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> grub-core/fs/f2fs.c line 35
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+#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 */
grub-core/fs/f2fs.c
Quoted 5 lines
grub-core/fs/f2fs.c new file +5
-0+#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)Quoted 33 lines
grub-core/fs/f2fs.c new file +33
-0+#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)grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ +#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) / \grub-core/fs/f2fs.c
Quoted 4 lines
grub-core/fs/f2fs.c new file +4
-0+ BITS_PER_BYTE) +#define SIZE_OF_RESERVED (F2FS_BLKSIZE - ((SIZE_OF_DIR_ENTRY + \ + F2FS_SLOT_LEN) * \ + NR_DENTRY_IN_BLOCK +
SIZE_OF_DENTRY_BITMAP))grub-core/fs/f2fs.c line 89
Quoted 2 lines
grub-core/fs/f2fs.c new file +2
-0+ +#define F2FS_INLINE_XATTR_ADDRS 50/* 200 bytes for inline xattrs */
grub-core/fs/f2fs.c
Quoted 3 lines
grub-core/fs/f2fs.c new file +3
-0+#define DEF_ADDRS_PER_INODE 923/* Address Pointers in an Inode */ + +#define ADDRS_PER_BLOCK 1018/* Address Pointers in a Direct Block */
Quoted 16 lines
grub-core/fs/f2fs.c new file +16
-0+#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) * \grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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 */
grub-core/fs/f2fs.c line 119
Quoted 1 line
grub-core/fs/f2fs.c new file +1
-0+#define F2FS_INLINE_DOTS 0x10/* file having implicit dot dentries */
Quoted 147 lines
grub-core/fs/f2fs.c new file +147
-0+ +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-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+}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 */
Quoted 75 lines
grub-core/fs/f2fs.c new file +75
-0+ }; +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 )))grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+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);Quoted 25 lines
grub-core/fs/f2fs.c new file +25
-0+} + +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; +} +grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+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_tblkaddr, void *buf)
Quoted 20 lines
grub-core/fs/f2fs.c new file +20
-0+{ +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--)grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ { + 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_tlen)Quoted 17 lines
grub-core/fs/f2fs.c new file +17
-0+{ +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; +}grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ +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))Quoted 15 lines
grub-core/fs/f2fs.c new file +15
-0+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 ;grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-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);Quoted 129 lines
grub-core/fs/f2fs.c new file +129
-0+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 grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ 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);grub-core/fs/f2fs.c
Quoted 8 lines
grub-core/fs/f2fs.c new file +8
-0+ +fail: +grub_free (buf); +return err; +} + +static grub_uint32_t +get_blkaddr_from_nat_journal (struct grub_f2fs_data *data,
grub_uint32_tnid)grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+{ +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);
Quoted 194 lines
grub-core/fs/f2fs.c new file +194
-0+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; +grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+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)Quoted 217 lines
grub-core/fs/f2fs.c new file +217
-0+{ +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 + pos, 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);grub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+if (ret) +return 1 ; + + fpos +=F2FS_BLKSIZE ; + } +return 0 ; +} + +static int +grub_f2fs_dir_iter (const char *filename, enum grub_fshelp_filetypefiletype,
Quoted 83 lines
grub-core/fs/f2fs.c new file +83
-0+ 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-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+ +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)Quoted 56 lines
grub-core/fs/f2fs.c new file +56
-0+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_tgrub-core/fs/f2fs.c
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+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);Quoted 12 lines
grub-core/fs/f2fs.c new file +12
-0+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-core/fs/f2fs.c line 1259
Quoted 10 lines
grub-core/fs/f2fs.c new file +10
-0+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",
Quoted 47 lines
grub-core/fs/f2fs.c new file +42
-0+ 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); +}po/exclude.pot +0
-0po/exclude.pot msgstr "" · line 1219
Quoted 6 lines
po/exclude.pot +1
-0@@ -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"
tests/util/grub-fs-tester.in for
Quoted 31 lines
po/exclude.pot +0
-0msgstr ""tests/f2fs_test.in new file +19
-0@@ -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" f2fstests/util/grub-fs-tester.in +0
-0@@ -142,7 +142,7 @@ for((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
tests/util/grub-fs-tester.in for
Quoted 9 lines
tests/util/grub-fs-tester.in +1
-1xsquash*) 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 +
tests/util/grub-fs-tester.in for · line 266
Quoted 2 lines
tests/util/grub-fs-tester.in +0
-0x"btrfs"*) FSLABEL="grub_;/testé莭莽😁киритiurewfceniuewruevrewnuuireurevueurnievrewfnerfcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvrevuurerejiremvreijnvcreivire nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoif";;
tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + · line 271
Quoted 4 lines
tests/util/grub-fs-tester.in +3
-0+ # FS LIMITATION: f2fs label is at most 512 UTF-16 chars + x"f2fs") +FSLABEL="grub_;/testé䏌䐓䏕киритiurewfceniuewruewnuuireurevueurnievrewfnerfcnevirivinrewvnirewnivrewiuvcrewvnuewvrrrewniuerwreiuviurewiuviurewnuvewnvrenurnunuvrevuurerejiremvreijnvvcreivire
nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoirvcreivire
nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoircreivire
nverivnreivrevnureiorfnfrvoeoiroireoireoifrefoieroifoireoifoiq";;tests/util/grub-fs-tester.in for
Quoted 5 lines
tests/util/grub-fs-tester.in +1
-0+ # 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 +
tests/util/grub-fs-tester.in for · line 478
Quoted 1 line
tests/util/grub-fs-tester.in +0
-0# FIXME: Not sure about BtrFS, NTFS, JFS, AFS, UDF and SFS.Check it.
tests/util/grub-fs-tester.in for · line 479
Quoted 1 line
tests/util/grub-fs-tester.in +0
-0# FS LIMITATION: as far as I know those FS don't store their lastmodification date.
tests/util/grub-fs-tester.in for · line 480
Quoted 1 line
tests/util/grub-fs-tester.in +0
-0x"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;;tests/util/grub-fs-tester.in for
Quoted 1 line
tests/util/grub-fs-tester.in +0
-0@@ -753,6 +757,8 @@ for((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE +
Quoted 7 lines
tests/util/grub-fs-tester.in +2
-0MOUNTDEVICE="/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]}" ;;
tests/util/grub-fs-tester.in for ((LOGSECSIZE=MINLOGSECSIZE;LOGSECSIZE<=MAXLOGSECSIZE;LOGSECSIZE=LOGSECSIZE + · line 764
Quoted 2 lines
tests/util/grub-fs-tester.in +0
-0xext2_old)_______________________________________________
Grub-devel mailing list
[email protected]
https://lists.gnu.org/mailman/listinfo/grub-devel
------------------------------------------------------------------------------
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 [email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Re: [2.02] Re: [f2fs-dev] [PATCH v8] F2FS support
In reply to Andrei BorzenkovChange log from v7:
- fix an offset bug in read_file
-- >8 --
From d774cdecc2fee18ed44098c88d2a54d358bc04d3 Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
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
--- 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
Makefile.util.def +7 -0
@@ -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; };
docs/grub.texi +3 -2
@@ -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
grub-core/Makefile.core.def +5 -0
@@ -1278,6 +1278,11 @@ module = { }; module = { + name = f2fs; + common = fs/f2fs.c; +}; + +module = { name = fshelp; common = fs/fshelp.c; };
grub-core/fs/f2fs.c new file +1289 -0
1,289 lines not on this page · raw message
po/exclude.pot +1 -0
@@ -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 ""
tests/f2fs_test.in new file +19 -0
@@ -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
tests/util/grub-fs-tester.in +8 -2
@@ -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)
Signature · 7 lines
2.6.3 _______________________________________________ Grub-devel mailing list [email protected] https://lists.gnu.org/mailman/listinfo/grub-devel
Re: [f2fs-dev] [2.02] Re: [PATCH v8] F2FS support
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,
Quoted 1,495 lines · Jaegeuk Kim
Change log from v7:
- fix an offset bug inread_file-- >8 --
Fromd774cdecc2fee18ed44098c88d2a54d358bc04d3Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
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.gitSigned-off-by Jaegeuk Kim <[email protected]>--- 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.inMakefile.util.def +7
-0@@ -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; };docs/grub.texi +3
-2@@ -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 usegrub-core/Makefile.core.def +5
-0@@ -1278,6 +1278,11 @@ module = { }; module = { + name = f2fs; + common = fs/f2fs.c; +}; + +module = { name = fshelp; common = fs/fshelp.c; };grub-core/fs/f2fs.c new file +1289
-0@@ -0,0 +1,1289 @@ +/* +* f2fs.c - Flash-Friendly File System +* +* Written by Jaegeuk Kim <[email protected]> +* +* 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); +}po/exclude.pot +1
-0@@ -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 ""tests/f2fs_test.in new file +19
-0@@ -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" f2fstests/util/grub-fs-tester.in +8
-2@@ -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)Signature · 13 lines
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 [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
------------------------------------------------------------------------------
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel