Applied this as well.
--- a/fsck/main.c
+++ b/fsck/main.c
@@ -866,6 +866,12 @@ void f2fs_parse_options(int argc, char *argv[])
#endif /* WITH_INJECT */
}
+#if defined(__MINGW32__)
+ if (c.need_whint) {
+ MSG(0, "-H not supported for Windows\n");
+ err = EWRONG_OPT;
+ }
+#endif
if (err == NOERROR) {
add_default_options();
diff --git a/lib/libf2fs_io.c b/lib/libf2fs_io.c
index c40d826c41b4..1923c0b87dfc 100644
--- a/lib/libf2fs_io.c
+++ b/lib/libf2fs_io.c
@@ -609,7 +609,6 @@ enum rw_hint f2fs_io_type_to_rw_hint(int seg_type)
static int __dev_write(void *buf, __u64 offset, size_t len, enum rw_hint whint)
{
- bool set_whint = (c.need_whint && (c.whint != whint));
int fd;
fd = __get_device_fd(&offset);
@@ -619,7 +618,8 @@ static int __dev_write(void *buf, __u64 offset, size_t len,
enum rw_hint whint)
if (lseek(fd, (off_t)offset, SEEK_SET) < 0)
return -1;
- if (set_whint) {
+#if ! defined(__MINGW32__)
+ if (c.need_whint && (c.whint != whint)) {
u64 hint = whint;
int ret;
@@ -627,6 +627,7 @@ static int __dev_write(void *buf, __u64 offset, size_t len,
enum rw_hint whint)
if (ret != -1)
c.whint = whint;
}
+#endif
if (write(fd, buf, len) < 0)
return -1;
On 09/07, Jaegeuk Kim via Linux-f2fs-devel wrote:
> Applied this change for Android build.
>
> --- a/fsck/mount.c
> +++ b/fsck/mount.c
> @@ -4222,7 +4222,7 @@ int f2fs_sparse_initialize_meta(struct f2fs_sb_info
> *sbi)
> DBG(1, "\tSparse: filling sit area at block offset: 0x%08"PRIx64"
> len: %u\n",
> sit_seg_addr,
> sit_size);
> ret = dev_fill(NULL, sit_seg_addr * F2FS_BLKSIZE,
> - sit_size * F2FS_BLKSIZE);
> + sit_size * F2FS_BLKSIZE, WRITE_LIFE_NONE);
> if (ret) {
> MSG(1, "\tError: While zeroing out the sit area "
> "on disk!!!\n");
> @@ -4236,7 +4236,7 @@ int f2fs_sparse_initialize_meta(struct f2fs_sb_info
> *sbi)
> DBG(1, "\tSparse: filling nat area at block offset 0x%08"PRIx64" len:
> %u\n",
> nat_seg_addr,
> nat_size);
> ret = dev_fill(NULL, nat_seg_addr * F2FS_BLKSIZE,
> - nat_size * F2FS_BLKSIZE);
> + nat_size * F2FS_BLKSIZE, WRITE_LIFE_NONE);
> if (ret) {
> MSG(1, "\tError: While zeroing out the nat area "
> "on disk!!!\n");
> @@ -4248,7 +4248,7 @@ int f2fs_sparse_initialize_meta(struct f2fs_sb_info
> *sbi)
> DBG(1, "\tSparse: filling bitmap area at block offset 0x%08"PRIx64"
> len: %u\n",
> payload_addr, get_sb(cp_payload));
> ret = dev_fill(NULL, payload_addr * F2FS_BLKSIZE,
> - get_sb(cp_payload) * F2FS_BLKSIZE);
> + get_sb(cp_payload) * F2FS_BLKSIZE, WRITE_LIFE_NONE);
> if (ret) {
> MSG(1, "\tError: While zeroing out the nat/sit bitmap area "
> "on disk!!!\n");
> @@ -4260,7 +4260,7 @@ int f2fs_sparse_initialize_meta(struct f2fs_sb_info
> *sbi)
> DBG(1, "\tSparse: filling bitmap area at block offset 0x%08"PRIx64"
> len: %u\n",
> payload_addr, get_sb(cp_payload));
> ret = dev_fill(NULL, payload_addr * F2FS_BLKSIZE,
> - get_sb(cp_payload) * F2FS_BLKSIZE);
> + get_sb(cp_payload) * F2FS_BLKSIZE, WRITE_LIFE_NONE);
> if (ret) {
> MSG(1, "\tError: While zeroing out the nat/sit bitmap area "
> "on disk!!!\n");
> diff --git a/include/android_config.h b/include/android_config.h
> index 9c8b163dac22..f5cd4dea0c99 100644
> --- a/include/android_config.h
> +++ b/include/android_config.h
> @@ -1,9 +1,11 @@
> #if defined(__linux__)
> +#define HAVE_ARCH_STRUCT_FLOCK 1
> #define HAVE_BLK_ZONE_REP_V2 1
> #define HAVE_BYTESWAP_H 1
> #define HAVE_FCNTL_H 1
> #define HAVE_FALLOC_H 1
> #define HAVE_FSYNC 1
> +#define HAVE_LINUX_FCNTL_H 1
> #define HAVE_LINUX_HDREG_H 1
> #define HAVE_LINUX_LIMITS_H 1
> #define HAVE_LINUX_LOOP_H 1
>
> On 09/04, Daejun Park wrote:
> > This patch enables support for write hints by segment type.
> >
> > Signed-off-by: Daejun Park <[email protected]>
> > ---
> >
> > v2:
> > - Add -H option for write hint enabling.
> > - Keep last write hint to reduce fnctl call.
> >
> > configure.ac | 2 +
> > fsck/defrag.c | 5 +-
> > fsck/dir.c | 27 +++++++---
> > fsck/fsck.c | 24 +++++----
> > fsck/inject.c | 4 +-
> > fsck/main.c | 22 ++++++--
> > fsck/mount.c | 43 ++++++++-------
> > fsck/node.c | 11 ++--
> > fsck/resize.c | 37 +++++++------
> > fsck/segment.c | 21 +++++---
> > fsck/xattr.c | 6 ++-
> > include/f2fs_fs.h | 26 +++++++--
> > lib/libf2fs.c | 6 +--
> > lib/libf2fs_io.c | 117 ++++++++++++++++++++++++++++++----------
> > man/defrag.f2fs.8 | 6 +++
> > man/fsck.f2fs.8 | 6 +++
> > man/mkfs.f2fs.8 | 6 +++
> > man/resize.f2fs.8 | 6 +++
> > mkfs/f2fs_format.c | 52 ++++++++++--------
> > mkfs/f2fs_format_main.c | 9 +++-
> > 20 files changed, 309 insertions(+), 127 deletions(-)
> >
> > diff --git a/configure.ac b/configure.ac
> > index 21c6391..2053a65 100644
> > --- a/configure.ac
> > +++ b/configure.ac
> > @@ -139,6 +139,8 @@ AC_CHECK_HEADERS(m4_flatten([
> > fcntl.h
> > kernel/uapi/linux/blkzoned.h
> > linux/blkzoned.h
> > + linux/rw_hint.h
> > + linux/fcntl.h
> > linux/falloc.h
> > linux/fiemap.h
> > linux/fs.h
> > diff --git a/fsck/defrag.c b/fsck/defrag.c
> > index 361fe73..9889b70 100644
> > --- a/fsck/defrag.c
> > +++ b/fsck/defrag.c
> > @@ -23,12 +23,13 @@ static int migrate_block(struct f2fs_sb_info *sbi, u64
> > from, u64 to)
> > ret = dev_read_block(raw, from);
> > ASSERT(ret >= 0);
> >
> > + /* get segment type */
> > + se = get_seg_entry(sbi, GET_SEGNO(sbi, from));
> > /* write to */
> > - ret = dev_write_block(raw, to);
> > + ret = dev_write_block(raw, to, f2fs_io_type_to_rw_hint(se->type));
> > ASSERT(ret >= 0);
> >
> > /* update sit bitmap & valid_blocks && se->type */
> > - se = get_seg_entry(sbi, GET_SEGNO(sbi, from));
> > offset = OFFSET_IN_SEG(sbi, from);
> > type = se->type;
> > se->valid_blocks--;
> > diff --git a/fsck/dir.c b/fsck/dir.c
> > index 3fac850..4debda8 100644
> > --- a/fsck/dir.c
> > +++ b/fsck/dir.c
> > @@ -299,7 +299,9 @@ add_dentry:
> >
> > if (c.zoned_model == F2FS_ZONED_HM) {
> > if (datablk_alloced) {
> > - ret = dev_write_block(dentry_blk, dn.data_blkaddr);
> > + /* dentry uses hot data segment */
> > + ret = dev_write_block(dentry_blk, dn.data_blkaddr,
> > + f2fs_io_type_to_rw_hint(CURSEG_HOT_DATA));
> > } else {
> > ret = update_block(sbi, dentry_blk, &dn.data_blkaddr,
> > dn.node_blk);
> > @@ -309,7 +311,9 @@ add_dentry:
> > dn.ndirty = 1;
> > }
> > } else {
> > - ret = dev_write_block(dentry_blk, dn.data_blkaddr);
> > + /* dentry uses hot data segment */
> > + ret = dev_write_block(dentry_blk, dn.data_blkaddr,
> > + f2fs_io_type_to_rw_hint(CURSEG_HOT_DATA));
> > }
> > ASSERT(ret >= 0);
> >
> > @@ -336,8 +340,13 @@ add_dentry:
> > }
> >
> > if (dn.ndirty) {
> > + struct seg_entry *se;
> > +
> > + /* get segment type for rw hint */
> > + se = get_seg_entry(sbi, GET_SEGNO(sbi, dn.node_blkaddr));
> > ret = dn.alloced ?
> > - dev_write_block(dn.node_blk, dn.node_blkaddr) :
> > + dev_write_block(dn.node_blk, dn.node_blkaddr,
> > + f2fs_io_type_to_rw_hint(se->type)) :
> > update_block(sbi, dn.node_blk, &dn.node_blkaddr, NULL);
> > ASSERT(ret >= 0);
> > }
> > @@ -388,7 +397,8 @@ static void make_empty_dir(struct f2fs_sb_info *sbi,
> > struct f2fs_node *inode)
> > ret = reserve_new_block(sbi, &blkaddr, &sum, CURSEG_HOT_DATA, 0);
> > ASSERT(!ret);
> >
> > - ret = dev_write_block(dent_blk, blkaddr);
> > + ret = dev_write_block(dent_blk, blkaddr,
> > + f2fs_io_type_to_rw_hint(CURSEG_HOT_DATA));
> > ASSERT(ret >= 0);
> >
> > inode->i.i_addr[get_extra_isize(inode)] = cpu_to_le32(blkaddr);
> > @@ -424,7 +434,8 @@ static void page_symlink(struct f2fs_sb_info *sbi,
> > struct f2fs_node *inode,
> > ret = reserve_new_block(sbi, &blkaddr, &sum, CURSEG_WARM_DATA, 0);
> > ASSERT(!ret);
> >
> > - ret = dev_write_block(data_blk, blkaddr);
> > + ret = dev_write_block(data_blk, blkaddr,
> > + f2fs_io_type_to_rw_hint(CURSEG_WARM_DATA));
> > ASSERT(ret >= 0);
> >
> > inode->i.i_addr[get_extra_isize(inode)] = cpu_to_le32(blkaddr);
> > @@ -618,7 +629,8 @@ int convert_inline_dentry(struct f2fs_sb_info *sbi,
> > struct f2fs_node *node,
> > memcpy(dst.filename, src.filename, src.max * F2FS_SLOT_LEN);
> >
> > ret = datablk_alloced ?
> > - dev_write_block(dentry_blk, dn.data_blkaddr) :
> > + dev_write_block(dentry_blk, dn.data_blkaddr,
> > +
> > f2fs_io_type_to_rw_hint(CURSEG_HOT_DATA)) :
> > update_block(sbi, dentry_blk, &dn.data_blkaddr, NULL);
> > ASSERT(ret >= 0);
> >
> > @@ -818,7 +830,8 @@ int f2fs_create(struct f2fs_sb_info *sbi, struct dentry
> > *de)
> > update_nat_blkaddr(sbi, de->ino, de->ino, blkaddr);
> >
> > write_child_dir:
> > - ret = nodeblk_alloced ? dev_write_block(child, blkaddr) :
> > + ret = nodeblk_alloced ? dev_write_block(child, blkaddr,
> > + f2fs_io_type_to_rw_hint(CURSEG_HOT_NODE)) :
> > update_block(sbi, child, &blkaddr, NULL);
> > ASSERT(ret >= 0);
> >
> > diff --git a/fsck/fsck.c b/fsck/fsck.c
> > index a18bee9..e4d4aae 100644
> > --- a/fsck/fsck.c
> > +++ b/fsck/fsck.c
> > @@ -216,7 +216,7 @@ static int is_valid_ssa_node_blk(struct f2fs_sb_info
> > *sbi, u32 nid,
> > int ret2;
> >
> > ssa_blk = GET_SUM_BLKADDR(sbi, segno);
> > - ret2 = dev_write_block(sum_blk, ssa_blk);
> > + ret2 = dev_write_block(sum_blk, ssa_blk, WRITE_LIFE_NONE);
> > ASSERT(ret2 >= 0);
> > }
> > out:
> > @@ -350,7 +350,7 @@ static int is_valid_ssa_data_blk(struct f2fs_sb_info
> > *sbi, u32 blk_addr,
> > int ret2;
> >
> > ssa_blk = GET_SUM_BLKADDR(sbi, segno);
> > - ret2 = dev_write_block(sum_blk, ssa_blk);
> > + ret2 = dev_write_block(sum_blk, ssa_blk, WRITE_LIFE_NONE);
> > ASSERT(ret2 >= 0);
> > }
> > out:
> > @@ -2153,7 +2153,8 @@ int fsck_chk_orphan_node(struct f2fs_sb_info *sbi)
> > if (f2fs_dev_is_writable() && c.fix_on &&
> > entry_count != new_entry_count) {
> > F2FS_ORPHAN_BLOCK_FOOTER(new_blk)->entry_count =
> > cpu_to_le32(new_entry_count);
> > - ret = dev_write_block(new_blk, start_blk + i);
> > + ret = dev_write_block(new_blk, start_blk + i,
> > + WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > }
> > memset(orphan_blk, 0, F2FS_BLKSIZE);
> > @@ -2569,12 +2570,13 @@ static void fix_checkpoint(struct f2fs_sb_info *sbi)
> > if (sbi->cur_cp == 2)
> > cp_blk_no += 1 << get_sb(log_blocks_per_seg);
> >
> > - ret = dev_write_block(cp, cp_blk_no++);
> > + ret = dev_write_block(cp, cp_blk_no++, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> >
> > for (i = 0; i < get_sb(cp_payload); i++) {
> > ret = dev_write_block(((unsigned char *)cp) +
> > - (i + 1) * F2FS_BLKSIZE, cp_blk_no++);
> > + (i + 1) * F2FS_BLKSIZE, cp_blk_no++,
> > + WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > }
> >
> > @@ -2586,7 +2588,8 @@ static void fix_checkpoint(struct f2fs_sb_info *sbi)
> > if (!(flags & CP_UMOUNT_FLAG) && IS_NODESEG(i))
> > continue;
> >
> > - ret = dev_write_block(curseg->sum_blk, cp_blk_no++);
> > + ret = dev_write_block(curseg->sum_blk, cp_blk_no++,
> > + WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > }
> >
> > @@ -2597,7 +2600,7 @@ static void fix_checkpoint(struct f2fs_sb_info *sbi)
> > ret = f2fs_fsync_device();
> > ASSERT(ret >= 0);
> >
> > - ret = dev_write_block(cp, cp_blk_no++);
> > + ret = dev_write_block(cp, cp_blk_no++, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> >
> > ret = f2fs_fsync_device();
> > @@ -3328,9 +3331,11 @@ static int chk_and_fix_wp_with_sit(int UNUSED(i),
> > void *blkzone, void *opaque)
> > if (ret) {
> > u64 fill_sects = blk_zone_length(blkz) -
> > (blk_zone_wp_sector(blkz) - blk_zone_sector(blkz));
> > + struct seg_entry *se = get_seg_entry(sbi, wp_segno);
> > printf("[FSCK] Finishing zone failed: %s\n", dev->path);
> > ret = dev_fill(NULL, wp_block * F2FS_BLKSIZE,
> > - (fill_sects >> log_sectors_per_block) * F2FS_BLKSIZE);
> > + (fill_sects >> log_sectors_per_block) * F2FS_BLKSIZE,
> > + f2fs_io_type_to_rw_hint(se->type));
> > if (ret)
> > printf("[FSCK] Fill up zone failed: %s\n", dev->path);
> > }
> > @@ -3646,7 +3651,8 @@ int fsck_verify(struct f2fs_sb_info *sbi)
> > ssa_blk = GET_SUM_BLKADDR(sbi,
> > curseg->segno);
> > ret = dev_write_block(curseg->sum_blk,
> > - ssa_blk);
> > + ssa_blk,
> > + WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > }
> > if (c.roll_forward)
> > diff --git a/fsck/inject.c b/fsck/inject.c
> > index 9dc085f..e24f3f5 100644
> > --- a/fsck/inject.c
> > +++ b/fsck/inject.c
> > @@ -565,7 +565,7 @@ static int inject_nat(struct f2fs_sb_info *sbi, struct
> > inject_option *opt)
> > }
> > print_raw_nat_entry_info(ne);
> >
> > - ret = dev_write_block(nat_blk, blk_addr);
> > + ret = dev_write_block(nat_blk, blk_addr, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > /* restore NAT version bitmap */
> > if (is_set)
> > @@ -724,7 +724,7 @@ static int inject_ssa(struct f2fs_sb_info *sbi, struct
> > inject_option *opt)
> > print_sum_footer_info(footer);
> >
> > ssa_blkaddr = GET_SUM_BLKADDR(sbi, segno);
> > - ret = dev_write_block(sum_blk, ssa_blkaddr);
> > + ret = dev_write_block(sum_blk, ssa_blkaddr, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> >
> > out:
> > diff --git a/fsck/main.c b/fsck/main.c
> > index 8881936..43b807f 100644
> > --- a/fsck/main.c
> > +++ b/fsck/main.c
> > @@ -77,6 +77,7 @@ void fsck_usage()
> > MSG(0, " -d debug level [default:0]\n");
> > MSG(0, " -f check/fix entire partition\n");
> > MSG(0, " -g add default options\n");
> > + MSG(0, " -H support write hint\n");
> > MSG(0, " -l show superblock/checkpoint\n");
> > MSG(0, " -M show a file map\n");
> > MSG(0, " -O feature1[feature2,feature3,...] e.g. \"encrypt\"\n");
> > @@ -108,6 +109,7 @@ void dump_usage()
> > MSG(0, " -b blk_addr (in 4KB)\n");
> > MSG(0, " -r dump out from the root inode\n");
> > MSG(0, " -f do not prompt before dumping\n");
> > + MSG(0, " -H support write hint\n");
> > MSG(0, " -y alias for -f\n");
> > MSG(0, " -o dump inodes to the given path\n");
> > MSG(0, " -P preserve mode/owner/group for dumped inode\n");
> > @@ -122,6 +124,7 @@ void defrag_usage()
> > MSG(0, "\nUsage: defrag.f2fs [options] device\n");
> > MSG(0, "[options]:\n");
> > MSG(0, " -d debug level [default:0]\n");
> > + MSG(0, " -H support write hint\n");
> > MSG(0, " -s start block address [default: main_blkaddr]\n");
> > MSG(0, " -S sparse_mode\n");
> > MSG(0, " -l length [default:512 (2MB)]\n");
> > @@ -136,6 +139,7 @@ void resize_usage()
> > MSG(0, "\nUsage: resize.f2fs [options] device\n");
> > MSG(0, "[options]:\n");
> > MSG(0, " -d debug level [default:0]\n");
> > + MSG(0, " -H support write hint\n");
> > MSG(0, " -i extended node bitmap, node ratio is 20%% by default\n");
> > MSG(0, " -o overprovision percentage [default:auto]\n");
> > MSG(0, " -s safe resize (Does not resize metadata)\n");
> > @@ -246,7 +250,7 @@ void f2fs_parse_options(int argc, char *argv[])
> > }
> >
> > if (!strcmp("fsck.f2fs", prog)) {
> > - const char *option_string = ":aC:c:m:Md:fg:lO:p:q:StyV";
> > + const char *option_string = ":aC:c:m:Md:fg:HlO:p:q:StyV";
> > int opt = 0, val;
> > char *token;
> > struct option long_opt[] = {
> > @@ -295,6 +299,10 @@ void f2fs_parse_options(int argc, char *argv[])
> > MSG(0, "Info: Set conf for android\n");
> > }
> > break;
> > + case 'H':
> > + c.need_whint = true;
> > + c.whint = WRITE_LIFE_NOT_SET;
> > + break;
> > case 'l':
> > c.layout = 1;
> > break;
> > @@ -517,7 +525,7 @@ void f2fs_parse_options(int argc, char *argv[])
> > #endif
> > } else if (!strcmp("defrag.f2fs", prog)) {
> > #ifdef WITH_DEFRAG
> > - const char *option_string = "d:s:Sl:t:iV";
> > + const char *option_string = "d:Hs:Sl:t:iV";
> >
> > c.func = DEFRAG;
> > while ((option = getopt(argc, argv, option_string)) != EOF) {
> > @@ -533,6 +541,10 @@ void f2fs_parse_options(int argc, char *argv[])
> > MSG(0, "Info: Debug level = %d\n",
> > c.dbg_lv);
> > break;
> > + case 'H':
> > + c.need_whint = true;
> > + c.whint = WRITE_LIFE_NOT_SET;
> > + break;
> > case 's':
> > if (strncmp(optarg, "0x", 2))
> > ret = sscanf(optarg, "%"PRIu64"",
> > @@ -577,7 +589,7 @@ void f2fs_parse_options(int argc, char *argv[])
> > #endif
> > } else if (!strcmp("resize.f2fs", prog)) {
> > #ifdef WITH_RESIZE
> > - const char *option_string = "d:fst:io:V";
> > + const char *option_string = "d:fHst:io:V";
> >
> > c.func = RESIZE;
> > while ((option = getopt(argc, argv, option_string)) != EOF) {
> > @@ -597,6 +609,10 @@ void f2fs_parse_options(int argc, char *argv[])
> > c.force = 1;
> > MSG(0, "Info: Force to resize\n");
> > break;
> > + case 'H':
> > + c.need_whint = true;
> > + c.whint = WRITE_LIFE_NOT_SET;
> > + break;
> > case 's':
> > c.safe_resize = 1;
> > break;
> > diff --git a/fsck/mount.c b/fsck/mount.c
> > index dab0611..4bb1cde 100644
> > --- a/fsck/mount.c
> > +++ b/fsck/mount.c
> > @@ -889,7 +889,7 @@ void update_superblock(struct f2fs_super_block *sb, int
> > sb_mask)
> > memcpy(buf + F2FS_SUPER_OFFSET, sb, sizeof(*sb));
> > for (addr = SB0_ADDR; addr < SB_MAX_ADDR; addr++) {
> > if (SB_MASK(addr) & sb_mask) {
> > - ret = dev_write_block(buf, addr);
> > + ret = dev_write_block(buf, addr, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > }
> > }
> > @@ -1783,7 +1783,8 @@ void write_nat_bits(struct f2fs_sb_info *sbi,
> > DBG(1, "\tWriting NAT bits pages, at offset 0x%08x\n", blkaddr);
> >
> > for (i = 0; i < nat_bits_blocks; i++) {
> > - if (dev_write_block(nat_bits + i * F2FS_BLKSIZE, blkaddr + i))
> > + if (dev_write_block(nat_bits + i * F2FS_BLKSIZE, blkaddr + i,
> > + WRITE_LIFE_NONE))
> > ASSERT_MSG("\tError: write NAT bits to disk!!!\n");
> > }
> > MSG(0, "Info: Write valid nat_bits in checkpoint\n");
> > @@ -2155,7 +2156,8 @@ void update_sum_entry(struct f2fs_sb_info *sbi,
> > block_t blk_addr,
> > SUM_TYPE_DATA;
> >
> > /* write SSA all the time */
> > - ret = dev_write_block(sum_blk, GET_SUM_BLKADDR(sbi, segno));
> > + ret = dev_write_block(sum_blk, GET_SUM_BLKADDR(sbi, segno),
> > + WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> >
> > if (type == SEG_TYPE_NODE || type == SEG_TYPE_DATA ||
> > @@ -2262,7 +2264,7 @@ void rewrite_current_sit_page(struct f2fs_sb_info
> > *sbi,
> > {
> > block_t blk_addr = current_sit_addr(sbi, segno);
> >
> > - ASSERT(dev_write_block(sit_blk, blk_addr) >= 0);
> > + ASSERT(dev_write_block(sit_blk, blk_addr, WRITE_LIFE_NONE) >= 0);
> > }
> >
> > void check_block_count(struct f2fs_sb_info *sbi,
> > @@ -2552,7 +2554,7 @@ void update_nat_blkaddr(struct f2fs_sb_info *sbi,
> > nid_t ino,
> > entry->ino = cpu_to_le32(ino);
> > entry->block_addr = cpu_to_le32(newaddr);
> >
> > - ret = dev_write_block(nat_block, block_addr);
> > + ret = dev_write_block(nat_block, block_addr, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > update_cache:
> > if (c.func == FSCK)
> > @@ -2848,7 +2850,7 @@ next:
> > memcpy(&nat_block->entries[entry_off], &nat_in_journal(journal, i),
> > sizeof(struct f2fs_nat_entry));
> >
> > - ret = dev_write_block(nat_block, block_addr);
> > + ret = dev_write_block(nat_block, block_addr, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > i++;
> > goto next;
> > @@ -3028,7 +3030,8 @@ int find_next_free_block(struct f2fs_sb_info *sbi,
> > u64 *to, int left,
> > }
> >
> > ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno);
> > - ret = dev_write_block(curseg->sum_blk, ssa_blk);
> > + ret = dev_write_block(curseg->sum_blk, ssa_blk,
> > + WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> >
> > curseg->segno = segno;
> > @@ -3133,7 +3136,7 @@ void move_one_curseg_info(struct f2fs_sb_info *sbi,
> > u64 from, int left,
> >
> > /* update original SSA too */
> > ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno);
> > - ret = dev_write_block(curseg->sum_blk, ssa_blk);
> > + ret = dev_write_block(curseg->sum_blk, ssa_blk, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > bypass_ssa:
> > to = from;
> > @@ -3286,7 +3289,7 @@ void nullify_nat_entry(struct f2fs_sb_info *sbi, u32
> > nid)
> > FIX_MSG("Remove nid [0x%x] in NAT", nid);
> > }
> >
> > - ret = dev_write_block(nat_block, block_addr);
> > + ret = dev_write_block(nat_block, block_addr, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > free(nat_block);
> > }
> > @@ -3318,7 +3321,7 @@ void duplicate_checkpoint(struct f2fs_sb_info *sbi)
> > ASSERT(ret >= 0);
> >
> > ret = dev_write(buf, dst << F2FS_BLKSIZE_BITS,
> > - seg_size << F2FS_BLKSIZE_BITS);
> > + seg_size << F2FS_BLKSIZE_BITS, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> >
> > free(buf);
> > @@ -3383,7 +3386,7 @@ void write_checkpoint(struct f2fs_sb_info *sbi)
> > cp_blk_no += 1 << get_sb(log_blocks_per_seg);
> >
> > /* write the first cp */
> > - ret = dev_write_block(cp, cp_blk_no++);
> > + ret = dev_write_block(cp, cp_blk_no++, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> >
> > /* skip payload */
> > @@ -3399,13 +3402,15 @@ void write_checkpoint(struct f2fs_sb_info *sbi)
> > if (!(flags & CP_UMOUNT_FLAG) && IS_NODESEG(i))
> > continue;
> >
> > - ret = dev_write_block(curseg->sum_blk, cp_blk_no++);
> > + ret = dev_write_block(curseg->sum_blk, cp_blk_no++,
> > + WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> >
> > if (!(get_sb(feature) & F2FS_FEATURE_RO)) {
> > /* update original SSA too */
> > ssa_blk = GET_SUM_BLKADDR(sbi, curseg->segno);
> > - ret = dev_write_block(curseg->sum_blk, ssa_blk);
> > + ret = dev_write_block(curseg->sum_blk, ssa_blk,
> > + WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > }
> > }
> > @@ -3419,7 +3424,7 @@ void write_checkpoint(struct f2fs_sb_info *sbi)
> > ASSERT(ret >= 0);
> >
> > /* write the last cp */
> > - ret = dev_write_block(cp, cp_blk_no++);
> > + ret = dev_write_block(cp, cp_blk_no++, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> >
> > ret = f2fs_fsync_device();
> > @@ -3455,12 +3460,12 @@ void write_raw_cp_blocks(struct f2fs_sb_info *sbi,
> > cp_blkaddr += 1 << get_sb(log_blocks_per_seg);
> >
> > /* write the first cp block in this CP pack */
> > - ret = dev_write_block(cp, cp_blkaddr);
> > + ret = dev_write_block(cp, cp_blkaddr, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> >
> > /* write the second cp block in this CP pack */
> > cp_blkaddr += get_cp(cp_pack_total_block_count) - 1;
> > - ret = dev_write_block(cp, cp_blkaddr);
> > + ret = dev_write_block(cp, cp_blkaddr, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > }
> >
> > @@ -3695,6 +3700,7 @@ static int loop_node_chain_fix(block_t blkaddr_fast,
> > block_t blkaddr, struct f2fs_node *node_blk)
> > {
> > block_t blkaddr_entry, blkaddr_tmp;
> > + enum rw_hint whint;
> > int err;
> >
> > /* find the entry point of the looped node chain */
> > @@ -3722,10 +3728,11 @@ static int loop_node_chain_fix(block_t blkaddr_fast,
> >
> > /* fix the blkaddr of last node with NULL_ADDR. */
> > F2FS_NODE_FOOTER(node_blk)->next_blkaddr = NULL_ADDR;
> > + whint = f2fs_io_type_to_rw_hint(CURSEG_WARM_NODE);
> > if (IS_INODE(node_blk))
> > - err = write_inode(node_blk, blkaddr_tmp);
> > + err = write_inode(node_blk, blkaddr_tmp, whint);
> > else
> > - err = dev_write_block(node_blk, blkaddr_tmp);
> > + err = dev_write_block(node_blk, blkaddr_tmp, whint);
> > if (!err)
> > FIX_MSG("Fix looped node chain on blkaddr %u\n",
> > blkaddr_tmp);
> > diff --git a/fsck/node.c b/fsck/node.c
> > index 632151a..8d4479c 100644
> > --- a/fsck/node.c
> > +++ b/fsck/node.c
> > @@ -78,7 +78,7 @@ int f2fs_rebuild_qf_inode(struct f2fs_sb_info *sbi, int
> > qtype)
> > goto err_out;
> > }
> >
> > - ret = write_inode(raw_node, blkaddr);
> > + ret = write_inode(raw_node, blkaddr,
> > f2fs_io_type_to_rw_hint(CURSEG_HOT_NODE));
> > if (ret < 0) {
> > MSG(1, "\tError: While rebuilding the quota inode to disk!\n");
> > goto err_out;
> > @@ -282,8 +282,13 @@ int get_dnode_of_data(struct f2fs_sb_info *sbi, struct
> > dnode_of_data *dn,
> > /* Parent node has changed */
> > if (!parent_alloced)
> > ret = update_block(sbi, parent, &nblk[i - 1],
> > NULL);
> > - else
> > - ret = dev_write_block(parent, nblk[i - 1]);
> > + else {
> > + struct seg_entry *se;
> > +
> > + se = get_seg_entry(sbi, GET_SEGNO(sbi, nblk[i -
> > 1]));
> > + ret = dev_write_block(parent, nblk[i - 1],
> > +
> > f2fs_io_type_to_rw_hint(se->type));
> > + }
> > ASSERT(ret >= 0);
> >
> > /* Function new_node_blk get a new f2fs_node blk and
> > update*/
> > diff --git a/fsck/resize.c b/fsck/resize.c
> > index 049ddd3..9b3b071 100644
> > --- a/fsck/resize.c
> > +++ b/fsck/resize.c
> > @@ -189,7 +189,8 @@ static void migrate_main(struct f2fs_sb_info *sbi,
> > unsigned int offset)
> > ASSERT(ret >= 0);
> >
> > to = from + offset;
> > - ret = dev_write_block(raw, to);
> > + ret = dev_write_block(raw, to,
> > +
> > f2fs_io_type_to_rw_hint(se->type));
> > ASSERT(ret >= 0);
> >
> > get_sum_entry(sbi, from, &sum);
> > @@ -218,7 +219,8 @@ static void move_ssa(struct f2fs_sb_info *sbi, unsigned
> > int segno,
> > if (type < SEG_TYPE_MAX) {
> > int ret;
> >
> > - ret = dev_write_block(sum_blk, new_sum_blk_addr);
> > + ret = dev_write_block(sum_blk, new_sum_blk_addr,
> > + WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > DBG(1, "Write summary block: (%d) segno=%x/%x --> (%d) %x\n",
> > type, segno, GET_SUM_BLKADDR(sbi, segno),
> > @@ -252,7 +254,8 @@ static void migrate_ssa(struct f2fs_sb_info *sbi,
> > if (blkaddr < expand_sum_blkaddr) {
> > move_ssa(sbi, offset++, blkaddr++);
> > } else {
> > - ret = dev_write_block(zero_block, blkaddr++);
> > + ret = dev_write_block(zero_block, blkaddr++,
> > + WRITE_LIFE_NONE);
> > ASSERT(ret >=0);
> > }
> > }
> > @@ -261,7 +264,8 @@ static void migrate_ssa(struct f2fs_sb_info *sbi,
> > offset = MAIN_SEGS(sbi) - 1;
> > while (blkaddr >= new_sum_blkaddr) {
> > if (blkaddr >= expand_sum_blkaddr) {
> > - ret = dev_write_block(zero_block, blkaddr--);
> > + ret = dev_write_block(zero_block, blkaddr--,
> > + WRITE_LIFE_NONE);
> > ASSERT(ret >=0);
> > } else {
> > move_ssa(sbi, offset--, blkaddr--);
> > @@ -360,7 +364,7 @@ static void migrate_nat(struct f2fs_sb_info *sbi,
> > (block_off & ((1 << sbi->log_blocks_per_seg) -
> > 1)));
> >
> > /* new bitmap should be zeros */
> > - ret = dev_write_block(nat_block, block_addr);
> > + ret = dev_write_block(nat_block, block_addr, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > }
> > /* zero out newly assigned nids */
> > @@ -381,7 +385,7 @@ static void migrate_nat(struct f2fs_sb_info *sbi,
> > block_addr = (pgoff_t)(new_nat_blkaddr +
> > (seg_off << sbi->log_blocks_per_seg << 1) +
> > (block_off & ((1 << sbi->log_blocks_per_seg) -
> > 1)));
> > - ret = dev_write_block(nat_block, block_addr);
> > + ret = dev_write_block(nat_block, block_addr, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > DBG(3, "Write NAT: %lx\n", block_addr);
> > }
> > @@ -407,7 +411,8 @@ static void migrate_sit(struct f2fs_sb_info *sbi,
> >
> > /* initialize with zeros */
> > for (index = 0; index < sit_blks; index++) {
> > - ret = dev_write_block(sit_blk, get_newsb(sit_blkaddr) + index);
> > + ret = dev_write_block(sit_blk, get_newsb(sit_blkaddr) + index,
> > + WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > DBG(3, "Write zero sit: %x\n", get_newsb(sit_blkaddr) + index);
> > }
> > @@ -425,7 +430,8 @@ static void migrate_sit(struct f2fs_sb_info *sbi,
> >
> > if (ofs != pre_ofs) {
> > blk_addr = get_newsb(sit_blkaddr) + pre_ofs;
> > - ret = dev_write_block(sit_blk, blk_addr);
> > + ret = dev_write_block(sit_blk, blk_addr,
> > + WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > DBG(1, "Write valid sit: %x\n", blk_addr);
> >
> > @@ -439,7 +445,7 @@ static void migrate_sit(struct f2fs_sb_info *sbi,
> > se->valid_blocks);
> > }
> > blk_addr = get_newsb(sit_blkaddr) + ofs;
> > - ret = dev_write_block(sit_blk, blk_addr);
> > + ret = dev_write_block(sit_blk, blk_addr, WRITE_LIFE_NONE);
> > DBG(1, "Write valid sit: %x\n", blk_addr);
> > ASSERT(ret >= 0);
> >
> > @@ -558,12 +564,12 @@ static void rebuild_checkpoint(struct f2fs_sb_info
> > *sbi,
> > new_cp_blk_no += 1 << get_sb(log_blocks_per_seg);
> >
> > /* write first cp */
> > - ret = dev_write_block(new_cp, new_cp_blk_no++);
> > + ret = dev_write_block(new_cp, new_cp_blk_no++, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> >
> > memset(buf, 0, F2FS_BLKSIZE);
> > for (i = 0; i < get_newsb(cp_payload); i++) {
> > - ret = dev_write_block(buf, new_cp_blk_no++);
> > + ret = dev_write_block(buf, new_cp_blk_no++, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > }
> >
> > @@ -573,7 +579,7 @@ static void rebuild_checkpoint(struct f2fs_sb_info *sbi,
> > ret = dev_read_block(buf, orphan_blk_no++);
> > ASSERT(ret >= 0);
> >
> > - ret = dev_write_block(buf, new_cp_blk_no++);
> > + ret = dev_write_block(buf, new_cp_blk_no++, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > }
> >
> > @@ -581,12 +587,13 @@ static void rebuild_checkpoint(struct f2fs_sb_info
> > *sbi,
> > for (i = 0; i < NO_CHECK_TYPE; i++) {
> > struct curseg_info *curseg = CURSEG_I(sbi, i);
> >
> > - ret = dev_write_block(curseg->sum_blk, new_cp_blk_no++);
> > + ret = dev_write_block(curseg->sum_blk, new_cp_blk_no++,
> > + WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> > }
> >
> > /* write the last cp */
> > - ret = dev_write_block(new_cp, new_cp_blk_no++);
> > + ret = dev_write_block(new_cp, new_cp_blk_no++, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> >
> > /* Write nat bits */
> > @@ -595,7 +602,7 @@ static void rebuild_checkpoint(struct f2fs_sb_info *sbi,
> >
> > /* disable old checkpoint */
> > memset(buf, 0, F2FS_BLKSIZE);
> > - ret = dev_write_block(buf, old_cp_blk_no);
> > + ret = dev_write_block(buf, old_cp_blk_no, WRITE_LIFE_NONE);
> > ASSERT(ret >= 0);
> >
> > free(buf);
> > diff --git a/fsck/segment.c b/fsck/segment.c
> > index 9bea105..96de22a 100644
> > --- a/fsck/segment.c
> > +++ b/fsck/segment.c
> > @@ -322,12 +322,16 @@ static u64 f2fs_write_ex(struct f2fs_sb_info *sbi,
> > nid_t ino, u8 *buffer,
> > ASSERT(remained_blkentries > 0);
> >
> > if (!has_data) {
> > + struct seg_entry *se;
> > +
> > + se = get_seg_entry(sbi, GET_SEGNO(sbi,
> > dn.node_blkaddr));
> > dn.data_blkaddr = addr_type;
> > set_data_blkaddr(&dn);
> > idirty |= dn.idirty;
> > if (dn.ndirty) {
> > ret = dn.alloced ? dev_write_block(dn.node_blk,
> > - dn.node_blkaddr) :
> > + dn.node_blkaddr,
> > + f2fs_io_type_to_rw_hint(se->type)) :
> > update_block(sbi, dn.node_blk,
> > &dn.node_blkaddr, NULL);
> > ASSERT(ret >= 0);
> > @@ -365,7 +369,8 @@ static u64 f2fs_write_ex(struct f2fs_sb_info *sbi,
> > nid_t ino, u8 *buffer,
> >
> > if (c.zoned_model == F2FS_ZONED_HM) {
> > if (datablk_alloced) {
> > - ret = dev_write_block(wbuf, blkaddr);
> > + ret = dev_write_block(wbuf, blkaddr,
> > +
> > f2fs_io_type_to_rw_hint(CURSEG_WARM_DATA));
> > } else {
> > ret = update_block(sbi, wbuf, &blkaddr,
> > dn.node_blk);
> > @@ -375,7 +380,8 @@ static u64 f2fs_write_ex(struct f2fs_sb_info *sbi,
> > nid_t ino, u8 *buffer,
> > dn.ndirty = 1;
> > }
> > } else {
> > - ret = dev_write_block(wbuf, blkaddr);
> > + ret = dev_write_block(wbuf, blkaddr,
> > +
> > f2fs_io_type_to_rw_hint(CURSEG_WARM_DATA));
> > }
> > ASSERT(ret >= 0);
> >
> > @@ -386,8 +392,11 @@ static u64 f2fs_write_ex(struct f2fs_sb_info *sbi,
> > nid_t ino, u8 *buffer,
> >
> > dn.ofs_in_node++;
> > if ((--remained_blkentries == 0 || count == 0) && (dn.ndirty)) {
> > + struct seg_entry *se;
> > + se = get_seg_entry(sbi, GET_SEGNO(sbi,
> > dn.node_blkaddr));
> > ret = dn.alloced ?
> > - dev_write_block(dn.node_blk, dn.node_blkaddr) :
> > + dev_write_block(dn.node_blk, dn.node_blkaddr,
> > +
> > f2fs_io_type_to_rw_hint(se->type)) :
> > update_block(sbi, dn.node_blk,
> > &dn.node_blkaddr, NULL);
> > ASSERT(ret >= 0);
> > }
> > @@ -764,7 +773,7 @@ int update_block(struct f2fs_sb_info *sbi, void *buf,
> > u32 *blkaddr,
> > int ret, type;
> >
> > if (c.zoned_model != F2FS_ZONED_HM)
> > - return dev_write_block(buf, old_blkaddr);
> > + return dev_write_block(buf, old_blkaddr, WRITE_LIFE_NONE);
> >
> > /* update sit bitmap & valid_blocks && se->type for old block*/
> > se = get_seg_entry(sbi, GET_SEGNO(sbi, old_blkaddr));
> > @@ -784,7 +793,7 @@ int update_block(struct f2fs_sb_info *sbi, void *buf,
> > u32 *blkaddr,
> > ASSERT(0);
> > }
> >
> > - ret = dev_write_block(buf, new_blkaddr);
> > + ret = dev_write_block(buf, new_blkaddr, f2fs_io_type_to_rw_hint(type));
> > ASSERT(ret >= 0);
> >
> > *blkaddr = new_blkaddr;
> > diff --git a/fsck/xattr.c b/fsck/xattr.c
> > index 241e339..6373c06 100644
> > --- a/fsck/xattr.c
> > +++ b/fsck/xattr.c
> > @@ -95,6 +95,7 @@ void write_all_xattrs(struct f2fs_sb_info *sbi,
> > u64 inline_size = inline_xattr_size(&inode->i);
> > int ret;
> > bool xattrblk_alloced = false;
> > + struct seg_entry *se;
> >
> > memcpy(inline_xattr_addr(&inode->i), txattr_addr, inline_size);
> >
> > @@ -126,8 +127,9 @@ void write_all_xattrs(struct f2fs_sb_info *sbi,
> > xattr_addr = (void *)xattr_node;
> > memcpy(xattr_addr, txattr_addr + inline_size,
> > F2FS_BLKSIZE - sizeof(struct node_footer));
> > -
> > - ret = xattrblk_alloced ? dev_write_block(xattr_node, blkaddr) :
> > + se = get_seg_entry(sbi, GET_SEGNO(sbi, blkaddr));
> > + ret = xattrblk_alloced ? dev_write_block(xattr_node, blkaddr,
> > + f2fs_io_type_to_rw_hint(se->type)) :
> > update_block(sbi, xattr_node, &blkaddr, NULL);
> >
> > free_xattr_node:
> > diff --git a/include/f2fs_fs.h b/include/f2fs_fs.h
> > index 15a1c82..d1c656d 100644
> > --- a/include/f2fs_fs.h
> > +++ b/include/f2fs_fs.h
> > @@ -60,6 +60,19 @@
> > #include <linux/blkzoned.h>
> > #endif
> >
> > +#ifdef HAVE_LINUX_RW_HINT_H
> > +#include <linux/rw_hint.h>
> > +#else
> > +enum rw_hint {
> > + WRITE_LIFE_NOT_SET = 0,
> > + WRITE_LIFE_NONE,
> > + WRITE_LIFE_SHORT,
> > + WRITE_LIFE_MEDIUM,
> > + WRITE_LIFE_LONG,
> > + WRITE_LIFE_EXTREME
> > +};
> > +#endif
> > +
> > #ifdef HAVE_LIBSELINUX
> > #include <selinux/selinux.h>
> > #include <selinux/label.h>
> > @@ -1520,6 +1533,8 @@ struct f2fs_configuration {
> > time_t fixed_time;
> > int roll_forward;
> > bool need_fsync;
> > + bool need_whint;
> > + int whint;
> >
> > /* mkfs parameters */
> > int fake_seed;
> > @@ -1581,7 +1596,7 @@ extern unsigned int addrs_per_page(struct f2fs_inode
> > *, bool);
> > extern unsigned int f2fs_max_file_offset(struct f2fs_inode *);
> > extern __u32 f2fs_inode_chksum(struct f2fs_node *);
> > extern __u32 f2fs_checkpoint_chksum(struct f2fs_checkpoint *);
> > -extern int write_inode(struct f2fs_node *, u64);
> > +extern int write_inode(struct f2fs_node *, u64, enum rw_hint);
> >
> > extern int get_bits_in_byte(unsigned char n);
> > extern int test_and_set_bit_le(u32, u8 *);
> > @@ -1618,15 +1633,16 @@ extern int dev_readahead(__u64, size_t);
> > #else
> > extern int dev_readahead(__u64, size_t UNUSED(len));
> > #endif
> > -extern int dev_write(void *, __u64, size_t);
> > -extern int dev_write_block(void *, __u64);
> > +extern enum rw_hint f2fs_io_type_to_rw_hint(int);
> > +extern int dev_write(void *, __u64, size_t, enum rw_hint);
> > +extern int dev_write_block(void *, __u64, enum rw_hint);
> > extern int dev_write_dump(void *, __u64, size_t);
> > #if !defined(__MINGW32__)
> > extern int dev_write_symlink(char *, size_t);
> > #endif
> > /* All bytes in the buffer must be 0 use dev_fill(). */
> > -extern int dev_fill(void *, __u64, size_t);
> > -extern int dev_fill_block(void *, __u64);
> > +extern int dev_fill(void *, __u64, size_t, enum rw_hint);
> > +extern int dev_fill_block(void *, __u64, enum rw_hint);
> >
> > extern int dev_read_block(void *, __u64);
> > extern int dev_reada_block(__u64);
> > diff --git a/lib/libf2fs.c b/lib/libf2fs.c
> > index 1e0f422..ecd22d4 100644
> > --- a/lib/libf2fs.c
> > +++ b/lib/libf2fs.c
> > @@ -603,12 +603,12 @@ __u32 f2fs_checkpoint_chksum(struct f2fs_checkpoint
> > *cp)
> > return chksum;
> > }
> >
> > -int write_inode(struct f2fs_node *inode, u64 blkaddr)
> > +int write_inode(struct f2fs_node *inode, u64 blkaddr, enum rw_hint whint)
> > {
> > if (c.feature & F2FS_FEATURE_INODE_CHKSUM)
> > inode->i.i_inode_checksum =
> > cpu_to_le32(f2fs_inode_chksum(inode));
> > - return dev_write_block(inode, blkaddr);
> > + return dev_write_block(inode, blkaddr, whint);
> > }
> >
> > /*
> > @@ -1005,7 +1005,7 @@ int get_device_info(int i)
> > #endif
> >
> > if (!c.sparse_mode) {
> > - if (dev->zoned_model == F2FS_ZONED_HM && c.func == FSCK)
> > + if (dev->zoned_model == F2FS_ZONED_HM)
> > flags |= O_DSYNC;
> >
> > if (S_ISBLK(stat_buf->st_mode) &&
> > diff --git a/lib/libf2fs_io.c b/lib/libf2fs_io.c
> > index f39367a..c40d826 100644
> > --- a/lib/libf2fs_io.c
> > +++ b/lib/libf2fs_io.c
> > @@ -39,6 +39,11 @@
> > #include <inttypes.h>
> > #include "f2fs_fs.h"
> >
> > +#ifdef HAVE_LINUX_FCNTL_H
> > +#define HAVE_ARCH_STRUCT_FLOCK
> > +#include <linux/fcntl.h>
> > +#endif
> > +
> > struct f2fs_configuration c;
> >
> > #ifdef HAVE_SPARSE_SPARSE_H
> > @@ -553,11 +558,86 @@ int dev_readahead(__u64 offset, size_t UNUSED(len))
> > return 0;
> > #endif
> > }
> > +/*
> > + * Copied from fs/f2fs/segment.c
> > + */
> > +/*
> > + * This returns write hints for each segment type. This hints will be
> > + * passed down to block layer as below by default.
> > + *
> > + * User F2FS Block
> > + * ---- ---- -----
> > + * META WRITE_LIFE_NONE|REQ_META
> > + * HOT_NODE WRITE_LIFE_NONE
> > + * WARM_NODE WRITE_LIFE_MEDIUM
> > + * COLD_NODE WRITE_LIFE_LONG
> > + * ioctl(COLD) COLD_DATA WRITE_LIFE_EXTREME
> > + * extension list " "
> > + *
> > + * -- buffered io
> > + * COLD_DATA WRITE_LIFE_EXTREME
> > + * HOT_DATA WRITE_LIFE_SHORT
> > + * WARM_DATA WRITE_LIFE_NOT_SET
> > + *
> > + * -- direct io
> > + * WRITE_LIFE_EXTREME COLD_DATA WRITE_LIFE_EXTREME
> > + * WRITE_LIFE_SHORT HOT_DATA WRITE_LIFE_SHORT
> > + * WRITE_LIFE_NOT_SET WARM_DATA WRITE_LIFE_NOT_SET
> > + * WRITE_LIFE_NONE " WRITE_LIFE_NONE
> > + * WRITE_LIFE_MEDIUM " WRITE_LIFE_MEDIUM
> > + * WRITE_LIFE_LONG " WRITE_LIFE_LONG
> > + */
> > +enum rw_hint f2fs_io_type_to_rw_hint(int seg_type)
> > +{
> > + switch (seg_type) {
> > + case CURSEG_WARM_DATA:
> > + return WRITE_LIFE_NOT_SET;
> > + case CURSEG_HOT_DATA:
> > + return WRITE_LIFE_SHORT;
> > + case CURSEG_COLD_DATA:
> > + return WRITE_LIFE_EXTREME;
> > + case CURSEG_WARM_NODE:
> > + return WRITE_LIFE_MEDIUM;
> > + case CURSEG_HOT_NODE:
> > + return WRITE_LIFE_NONE;
> > + case CURSEG_COLD_NODE:
> > + return WRITE_LIFE_LONG;
> > + default:
> > + return WRITE_LIFE_NONE;
> > + }
> > +}
> >
> > -int dev_write(void *buf, __u64 offset, size_t len)
> > +static int __dev_write(void *buf, __u64 offset, size_t len, enum rw_hint
> > whint)
> > {
> > + bool set_whint = (c.need_whint && (c.whint != whint));
> > int fd;
> >
> > + fd = __get_device_fd(&offset);
> > + if (fd < 0)
> > + return fd;
> > +
> > + if (lseek(fd, (off_t)offset, SEEK_SET) < 0)
> > + return -1;
> > +
> > + if (set_whint) {
> > + u64 hint = whint;
> > + int ret;
> > +
> > + ret = fcntl(fd, F_SET_RW_HINT, &hint);
> > + if (ret != -1)
> > + c.whint = whint;
> > + }
> > +
> > + if (write(fd, buf, len) < 0)
> > + return -1;
> > +
> > + c.need_fsync = true;
> > +
> > + return 0;
> > +}
> > +
> > +int dev_write(void *buf, __u64 offset, size_t len, enum rw_hint whint)
> > +{
> > if (c.dry_run)
> > return 0;
> >
> > @@ -572,21 +652,12 @@ int dev_write(void *buf, __u64 offset, size_t len)
> > if (dcache_update_cache(buf, offset, len) < 0)
> > return -1;
> >
> > - fd = __get_device_fd(&offset);
> > - if (fd < 0)
> > - return fd;
> > -
> > - if (lseek(fd, (off_t)offset, SEEK_SET) < 0)
> > - return -1;
> > - if (write(fd, buf, len) < 0)
> > - return -1;
> > - c.need_fsync = true;
> > - return 0;
> > + return __dev_write(buf, offset, len, whint);
> > }
> >
> > -int dev_write_block(void *buf, __u64 blk_addr)
> > +int dev_write_block(void *buf, __u64 blk_addr, enum rw_hint whint)
> > {
> > - return dev_write(buf, blk_addr << F2FS_BLKSIZE_BITS, F2FS_BLKSIZE);
> > + return dev_write(buf, blk_addr << F2FS_BLKSIZE_BITS, F2FS_BLKSIZE,
> > whint);
> > }
> >
> > int dev_write_dump(void *buf, __u64 offset, size_t len)
> > @@ -608,32 +679,22 @@ int dev_write_symlink(char *buf, size_t len)
> > }
> > #endif
> >
> > -int dev_fill(void *buf, __u64 offset, size_t len)
> > +int dev_fill(void *buf, __u64 offset, size_t len, enum rw_hint whint)
> > {
> > - int fd;
> > -
> > if (c.sparse_mode)
> > return sparse_write_zeroed_blk(offset / F2FS_BLKSIZE,
> > len / F2FS_BLKSIZE);
> >
> > - fd = __get_device_fd(&offset);
> > - if (fd < 0)
> > - return fd;
> > -
> > /* Only allow fill to zero */
> > if (*((__u8*)buf))
> > return -1;
> > - if (lseek(fd, (off_t)offset, SEEK_SET) < 0)
> > - return -1;
> > - if (write(fd, buf, len) < 0)
> > - return -1;
> > - c.need_fsync = true;
> > - return 0;
> > +
> > + return __dev_write(buf, offset, len, whint);
> > }
> >
> > -int dev_fill_block(void *buf, __u64 blk_addr)
> > +int dev_fill_block(void *buf, __u64 blk_addr, enum rw_hint whint)
> > {
> > - return dev_fill(buf, blk_addr << F2FS_BLKSIZE_BITS, F2FS_BLKSIZE);
> > + return dev_fill(buf, blk_addr << F2FS_BLKSIZE_BITS, F2FS_BLKSIZE,
> > whint);
> > }
> >
> > int dev_read_block(void *buf, __u64 blk_addr)
> > diff --git a/man/defrag.f2fs.8 b/man/defrag.f2fs.8
> > index 34113de..fcbe3bc 100644
> > --- a/man/defrag.f2fs.8
> > +++ b/man/defrag.f2fs.8
> > @@ -18,6 +18,9 @@ defrag.f2fs \- relocate blocks in a given area to the
> > specified region
> > .I target block address
> > ]
> > [
> > +.B \-H
> > +]
> > +[
> > .B \-i
> > .I direction
> > ]
> > @@ -53,6 +56,9 @@ Specify the number of blocks to move.
> > .BI \-t " target block address"
> > Specify the destination block address.
> > .TP
> > +.BI \-H
> > +Specify support write hint.
> > +.TP
> > .BI \-i " direction"
> > Set the direction to left. If it is not set, the direction becomes right
> > by default.
> > diff --git a/man/fsck.f2fs.8 b/man/fsck.f2fs.8
> > index aff4ff2..e39a846 100644
> > --- a/man/fsck.f2fs.8
> > +++ b/man/fsck.f2fs.8
> > @@ -14,6 +14,9 @@ fsck.f2fs \- check a Linux F2FS file system
> > .I enable force fix
> > ]
> > [
> > +.B \-H
> > +]
> > +[
> > .B \-M
> > .I show file map
> > ]
> > @@ -48,6 +51,9 @@ module. It is disabled by default.
> > .BI \-f " enable force fix"
> > Enable to fix all the inconsistency in the partition.
> > .TP
> > +.BI \-H
> > +Specify support write hint.
> > +.TP
> > .BI \-M " show files map"
> > Enable to show all the filenames and inode numbers stored in the image
> > .TP
> > diff --git a/man/mkfs.f2fs.8 b/man/mkfs.f2fs.8
> > index 1f0c724..de885be 100644
> > --- a/man/mkfs.f2fs.8
> > +++ b/man/mkfs.f2fs.8
> > @@ -31,6 +31,9 @@ mkfs.f2fs \- create an F2FS file system
> > .I default-options
> > ]
> > [
> > +.B \-H
> > +]
> > +[
> > .B \-i
> > ]
> > [
> > @@ -152,6 +155,9 @@ The following values are supported:
> > Use default options for Android having "-d1 -f -w 4096 -R 0:0 -O encrypt
> > -O project_quota,extra_attr,{quota} -O verity".
> > .RE
> > .TP
> > +.BI \-H
> > +Specify support write hint.
> > +.TP
> > .BI \-i
> > Enable extended node bitmap.
> > .TP
> > diff --git a/man/resize.f2fs.8 b/man/resize.f2fs.8
> > index 3288760..d41ad79 100644
> > --- a/man/resize.f2fs.8
> > +++ b/man/resize.f2fs.8
> > @@ -18,6 +18,9 @@ resize.f2fs \- resize filesystem size
> > .I overprovision-ratio-percentage
> > ]
> > [
> > +.B \-H
> > +]
> > +[
> > .B \-i
> > ]
> > [
> > @@ -53,6 +56,9 @@ Specify the percentage of the volume that will be used as
> > overprovision area.
> > This area is hidden to users, and utilized by F2FS cleaner. If not
> > specified, the
> > best number will be assigned automatically according to the partition size.
> > .TP
> > +.BI \-H
> > +Specify support write hint.
> > +.TP
> > .BI \-i
> > Enable extended node bitmap.
> > .TP
> > diff --git a/mkfs/f2fs_format.c b/mkfs/f2fs_format.c
> > index 247a836..8960b71 100644
> > --- a/mkfs/f2fs_format.c
> > +++ b/mkfs/f2fs_format.c
> > @@ -640,7 +640,7 @@ static int f2fs_init_sit_area(void)
> >
> > DBG(1, "\tFilling sit area at offset 0x%08"PRIx64"\n", sit_seg_addr);
> > for (index = 0; index < (get_sb(segment_count_sit) / 2); index++) {
> > - if (dev_fill(zero_buf, sit_seg_addr, seg_size)) {
> > + if (dev_fill(zero_buf, sit_seg_addr, seg_size,
> > WRITE_LIFE_NONE)) {
> > MSG(1, "\tError: While zeroing out the sit area "
> > "on disk!!!\n");
> > free(zero_buf);
> > @@ -674,7 +674,7 @@ static int f2fs_init_nat_area(void)
> >
> > DBG(1, "\tFilling nat area at offset 0x%08"PRIx64"\n", nat_seg_addr);
> > for (index = 0; index < get_sb(segment_count_nat) / 2; index++) {
> > - if (dev_fill(nat_buf, nat_seg_addr, seg_size)) {
> > + if (dev_fill(nat_buf, nat_seg_addr, seg_size, WRITE_LIFE_NONE))
> > {
> > MSG(1, "\tError: While zeroing out the nat area "
> > "on disk!!!\n");
> > free(nat_buf);
> > @@ -855,14 +855,14 @@ static int f2fs_write_check_point_pack(void)
> >
> > DBG(1, "\tWriting main segments, cp at offset 0x%08"PRIx64"\n",
> > cp_seg_blk);
> > - if (dev_write_block(cp, cp_seg_blk)) {
> > + if (dev_write_block(cp, cp_seg_blk, WRITE_LIFE_NONE)) {
> > MSG(1, "\tError: While writing the cp to disk!!!\n");
> > goto free_cp_payload;
> > }
> >
> > for (i = 0; i < get_sb(cp_payload); i++) {
> > cp_seg_blk++;
> > - if (dev_fill_block(cp_payload, cp_seg_blk)) {
> > + if (dev_fill_block(cp_payload, cp_seg_blk, WRITE_LIFE_NONE)) {
> > MSG(1, "\tError: While zeroing out the sit bitmap area "
> > "on disk!!!\n");
> > goto free_cp_payload;
> > @@ -943,7 +943,7 @@ static int f2fs_write_check_point_pack(void)
> > cp_seg_blk++;
> > DBG(1, "\tWriting Segment summary for HOT/WARM/COLD_DATA, at offset
> > 0x%08"PRIx64"\n",
> > cp_seg_blk);
> > - if (dev_write_block(sum_compact, cp_seg_blk)) {
> > + if (dev_write_block(sum_compact, cp_seg_blk, WRITE_LIFE_NONE)) {
> > MSG(1, "\tError: While writing the sum_blk to disk!!!\n");
> > goto free_cp_payload;
> > }
> > @@ -957,7 +957,7 @@ static int f2fs_write_check_point_pack(void)
> > cp_seg_blk++;
> > DBG(1, "\tWriting Segment summary for HOT_NODE, at offset
> > 0x%08"PRIx64"\n",
> > cp_seg_blk);
> > - if (dev_write_block(sum, cp_seg_blk)) {
> > + if (dev_write_block(sum, cp_seg_blk, WRITE_LIFE_NONE)) {
> > MSG(1, "\tError: While writing the sum_blk to disk!!!\n");
> > goto free_cp_payload;
> > }
> > @@ -969,7 +969,7 @@ static int f2fs_write_check_point_pack(void)
> > cp_seg_blk++;
> > DBG(1, "\tWriting Segment summary for WARM_NODE, at offset
> > 0x%08"PRIx64"\n",
> > cp_seg_blk);
> > - if (dev_write_block(sum, cp_seg_blk)) {
> > + if (dev_write_block(sum, cp_seg_blk, WRITE_LIFE_NONE)) {
> > MSG(1, "\tError: While writing the sum_blk to disk!!!\n");
> > goto free_cp_payload;
> > }
> > @@ -980,7 +980,7 @@ static int f2fs_write_check_point_pack(void)
> > cp_seg_blk++;
> > DBG(1, "\tWriting Segment summary for COLD_NODE, at offset
> > 0x%08"PRIx64"\n",
> > cp_seg_blk);
> > - if (dev_write_block(sum, cp_seg_blk)) {
> > + if (dev_write_block(sum, cp_seg_blk, WRITE_LIFE_NONE)) {
> > MSG(1, "\tError: While writing the sum_blk to disk!!!\n");
> > goto free_cp_payload;
> > }
> > @@ -988,7 +988,7 @@ static int f2fs_write_check_point_pack(void)
> > /* cp page2 */
> > cp_seg_blk++;
> > DBG(1, "\tWriting cp page2, at offset 0x%08"PRIx64"\n", cp_seg_blk);
> > - if (dev_write_block(cp, cp_seg_blk)) {
> > + if (dev_write_block(cp, cp_seg_blk, WRITE_LIFE_NONE)) {
> > MSG(1, "\tError: While writing the cp to disk!!!\n");
> > goto free_cp_payload;
> > }
> > @@ -1011,7 +1011,8 @@ static int f2fs_write_check_point_pack(void)
> >
> > for (i = 0; i < nat_bits_blocks; i++) {
> > if (dev_write_block(nat_bits + i *
> > - F2FS_BLKSIZE, cp_seg_blk + i)) {
> > + F2FS_BLKSIZE, cp_seg_blk + i,
> > + WRITE_LIFE_NONE)) {
> > MSG(1, "\tError: write NAT bits to disk!!!\n");
> > goto free_cp_payload;
> > }
> > @@ -1029,14 +1030,14 @@ static int f2fs_write_check_point_pack(void)
> > cp_seg_blk = get_sb(segment0_blkaddr) + c.blks_per_seg;
> > DBG(1, "\tWriting cp page 1 of checkpoint pack 2, at offset
> > 0x%08"PRIx64"\n",
> > cp_seg_blk);
> > - if (dev_write_block(cp, cp_seg_blk)) {
> > + if (dev_write_block(cp, cp_seg_blk, WRITE_LIFE_NONE)) {
> > MSG(1, "\tError: While writing the cp to disk!!!\n");
> > goto free_cp_payload;
> > }
> >
> > for (i = 0; i < get_sb(cp_payload); i++) {
> > cp_seg_blk++;
> > - if (dev_fill_block(cp_payload, cp_seg_blk)) {
> > + if (dev_fill_block(cp_payload, cp_seg_blk, WRITE_LIFE_NONE)) {
> > MSG(1, "\tError: While zeroing out the sit bitmap area "
> > "on disk!!!\n");
> > goto free_cp_payload;
> > @@ -1048,7 +1049,7 @@ static int f2fs_write_check_point_pack(void)
> > get_sb(cp_payload) - 1);
> > DBG(1, "\tWriting cp page 2 of checkpoint pack 2, at offset
> > 0x%08"PRIx64"\n",
> > cp_seg_blk);
> > - if (dev_write_block(cp, cp_seg_blk)) {
> > + if (dev_write_block(cp, cp_seg_blk, WRITE_LIFE_NONE)) {
> > MSG(1, "\tError: While writing the cp to disk!!!\n");
> > goto free_cp_payload;
> > }
> > @@ -1082,7 +1083,7 @@ static int f2fs_write_super_block(void)
> > memcpy(zero_buff + F2FS_SUPER_OFFSET, sb, sizeof(*sb));
> > DBG(1, "\tWriting super block, at offset 0x%08x\n", 0);
> > for (index = 0; index < 2; index++) {
> > - if (dev_write_block(zero_buff, index)) {
> > + if (dev_write_block(zero_buff, index, WRITE_LIFE_NONE)) {
> > MSG(1, "\tError: While while writing super_blk "
> > "on disk!!! index : %d\n", index);
> > free(zero_buff);
> > @@ -1135,7 +1136,8 @@ static int f2fs_discard_obsolete_dnode(void)
> > memset(raw_node, 0, F2FS_BLKSIZE);
> >
> > DBG(1, "\tDiscard dnode, at offset 0x%08"PRIx64"\n", offset);
> > - if (dev_write_block(raw_node, offset)) {
> > + if (dev_write_block(raw_node, offset,
> > + f2fs_io_type_to_rw_hint(CURSEG_WARM_NODE)))
> > {
> > MSG(1, "\tError: While discarding direct node!!!\n");
> > free(raw_node);
> > return -1;
> > @@ -1256,7 +1258,8 @@ static block_t f2fs_add_default_dentry_root(void)
> > data_blkaddr = alloc_next_free_block(CURSEG_HOT_DATA);
> >
> > DBG(1, "\tWriting default dentry root, at offset 0x%x\n", data_blkaddr);
> > - if (dev_write_block(dent_blk, data_blkaddr)) {
> > + if (dev_write_block(dent_blk, data_blkaddr,
> > + f2fs_io_type_to_rw_hint(CURSEG_HOT_DATA))) {
> > MSG(1, "\tError: While writing the dentry_blk to disk!!!\n");
> > free(dent_blk);
> > return 0;
> > @@ -1301,7 +1304,8 @@ static int f2fs_write_root_inode(void)
> > F2FS_NODE_FOOTER(raw_node)->next_blkaddr = cpu_to_le32(node_blkaddr +
> > 1);
> >
> > DBG(1, "\tWriting root inode (hot node), offset 0x%x\n", node_blkaddr);
> > - if (write_inode(raw_node, node_blkaddr) < 0) {
> > + if (write_inode(raw_node, node_blkaddr,
> > + f2fs_io_type_to_rw_hint(CURSEG_HOT_NODE)) < 0) {
> > MSG(1, "\tError: While writing the raw_node to disk!!!\n");
> > free(raw_node);
> > return -1;
> > @@ -1377,7 +1381,8 @@ static int f2fs_write_default_quota(int qtype, __le32
> > raw_id)
> > for (i = 0; i < QUOTA_DATA; i++) {
> > blkaddr = alloc_next_free_block(CURSEG_HOT_DATA);
> >
> > - if (dev_write_block(filebuf + i * F2FS_BLKSIZE, blkaddr)) {
> > + if (dev_write_block(filebuf + i * F2FS_BLKSIZE, blkaddr,
> > + f2fs_io_type_to_rw_hint(CURSEG_HOT_DATA))) {
> > MSG(1, "\tError: While writing the quota_blk to
> > disk!!!\n");
> > free(filebuf);
> > return 0;
> > @@ -1439,7 +1444,8 @@ static int f2fs_write_qf_inode(int qtype)
> > cpu_to_le32(data_blkaddr + i);
> >
> > DBG(1, "\tWriting quota inode (hot node), offset 0x%x\n", node_blkaddr);
> > - if (write_inode(raw_node, node_blkaddr) < 0) {
> > + if (write_inode(raw_node, node_blkaddr,
> > + f2fs_io_type_to_rw_hint(CURSEG_HOT_NODE)) < 0) {
> > MSG(1, "\tError: While writing the raw_node to disk!!!\n");
> > free(raw_node);
> > return -1;
> > @@ -1476,7 +1482,7 @@ static int f2fs_update_nat_default(void)
> >
> > DBG(1, "\tWriting nat root, at offset 0x%08"PRIx64"\n",
> > nat_seg_blk_offset);
> > - if (dev_write_block(nat_blk, nat_seg_blk_offset)) {
> > + if (dev_write_block(nat_blk, nat_seg_blk_offset, WRITE_LIFE_NONE)) {
> > MSG(1, "\tError: While writing the nat_blk set0 to disk!\n");
> > free(nat_blk);
> > return -1;
> > @@ -1516,7 +1522,8 @@ static block_t f2fs_add_default_dentry_lpf(void)
> >
> > DBG(1, "\tWriting default dentry lost+found, at offset 0x%x\n",
> > data_blkaddr);
> > - if (dev_write_block(dent_blk, data_blkaddr)) {
> > + if (dev_write_block(dent_blk, data_blkaddr,
> > + f2fs_io_type_to_rw_hint(CURSEG_HOT_DATA))) {
> > MSG(1, "\tError While writing the dentry_blk to disk!!!\n");
> > free(dent_blk);
> > return 0;
> > @@ -1563,7 +1570,8 @@ static int f2fs_write_lpf_inode(void)
> >
> > DBG(1, "\tWriting lost+found inode (hot node), offset 0x%x\n",
> > node_blkaddr);
> > - if (write_inode(raw_node, node_blkaddr) < 0) {
> > + if (write_inode(raw_node, node_blkaddr,
> > + f2fs_io_type_to_rw_hint(CURSEG_HOT_NODE)) < 0) {
> > MSG(1, "\tError: While writing the raw_node to disk!!!\n");
> > err = -1;
> > goto exit;
> > diff --git a/mkfs/f2fs_format_main.c b/mkfs/f2fs_format_main.c
> > index c98e73c..d9cdd61 100644
> > --- a/mkfs/f2fs_format_main.c
> > +++ b/mkfs/f2fs_format_main.c
> > @@ -56,6 +56,7 @@ static void mkfs_usage()
> > MSG(0, " -E [hot file ext list] e.g. \"db\"\n");
> > MSG(0, " -f force overwrite of the existing filesystem\n");
> > MSG(0, " -g add default options\n");
> > + MSG(0, " -H support write hint\n");
> > MSG(0, " -i extended node bitmap, node ratio is 20%% by default\n");
> > MSG(0, " -l label\n");
> > MSG(0, " -U uuid\n");
> > @@ -173,7 +174,7 @@ static void add_default_options(void)
> >
> > static void f2fs_parse_options(int argc, char *argv[])
> > {
> > - static const char *option_string =
> > "qa:b:c:C:d:e:E:g:hil:mo:O:rR:s:S:z:t:T:U:Vfw:Z:";
> > + static const char *option_string =
> > "qa:b:c:C:d:e:E:g:hHil:mo:O:rR:s:S:z:t:T:U:Vfw:Z:";
> > static const struct option long_opts[] = {
> > { .name = "help", .has_arg = 0, .flag = NULL, .val = 'h' },
> > { .name = NULL, .has_arg = 0, .flag = NULL, .val = 0 }
> > @@ -228,6 +229,10 @@ static void f2fs_parse_options(int argc, char *argv[])
> > case 'h':
> > mkfs_usage();
> > break;
> > + case 'H':
> > + c.need_whint = true;
> > + c.whint = WRITE_LIFE_NOT_SET;
> > + break;
> > case 'i':
> > c.large_nat_bitmap = 1;
> > break;
> > @@ -475,7 +480,7 @@ int main(int argc, char *argv[])
> > }
> > /* wipe out other FS magics mostly first 4MB space */
> > for (i = 0; i < 1024; i++)
> > - if (dev_fill_block(zero_buf, i))
> > + if (dev_fill_block(zero_buf, i, WRITE_LIFE_NONE))
> > break;
> > free(zero_buf);
> > if (i != 1024) {
> > --
> > 2.25.1
>
>
> _______________________________________________
> 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
