f2fs: check the use of macros on block counts and addresses
Subsystems (2)
Jaegeuk Kim
maintainerPATCH 1/4 f2fs: check the use of macros on block counts and addresses
This patch cleans up the existing and new macros for readability.
Rule is like this.
,-----------------------------------------> MAX_BLKADDR -,
| ,------------- TOTAL_BLKS ----------------------------,
| | |
| ,- seg0_blkaddr ,----- sit/nat/ssa/main blkaddress |block | | (SEG0_BLKADDR) | | | | (e.g., MAIN_BLKADDR) |
address 0..x................ a b c d .............................
| |
global seg# 0...................... m .............................
| | |
| `------- MAIN_SEGS -----------'
`-------------- TOTAL_SEGS ---------------------------'
| |seg# 0..........xx..................
= Note =
o GET_SEGNO_FROM_SEG0 : blk address -> global segno
o GET_SEGNO : blk address -> segno
o START_BLOCK : segno -> starting block address
--- fs/f2fs/checkpoint.c | 5 ++-- fs/f2fs/debug.c | 20 ++++++------- fs/f2fs/gc.c | 7 ++--- fs/f2fs/recovery.c | 8 ++--- fs/f2fs/segment.c | 85 +++++++++++++++++++++++----------------------------- fs/f2fs/segment.h | 44 +++++++++++++-------------- 6 files changed, 77 insertions(+), 92 deletions(-)
fs/f2fs/checkpoint.c +2 -3
@@ -98,7 +98,7 @@ static inline block_t get_max_meta_blks(struct f2fs_sb_info *sbi, int type)case META_CP :return 0 ;case META_POR : -return SM_I (sbi)->seg0_blkaddr +TOTAL_BLKS (sbi); +return MAX_BLKADDR (sbi);default :BUG (); }
@@ -113,7 +113,6 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, int typestruct page *page;block_t blkno = start;block_t max_blks =get_max_meta_blks (sbi, type); -block_t min_blks =SM_I (sbi)->seg0_blkaddr;struct f2fs_io_info fio = { .type =META ,
@@ -146,7 +145,7 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, int typecase META_POR :if (unlikely (blkno >= max_blks)) goto out; -if (unlikely (blkno < min_blks)) +if (unlikely (blkno <SEG0_BLKADDR (sbi))) goto out; blk_addr = blkno;break ;
fs/f2fs/debug.c +10 -10
@@ -93,7 +93,7 @@ static void update_sit_info(struct f2fs_sb_info *sbi) total_vblocks =0 ; blks_per_sec = sbi->segs_per_sec * (1 << sbi->log_blocks_per_seg); hblks_per_sec = blks_per_sec /2 ; -for (segno =0 ; segno <TOTAL_SEGS (sbi); segno += sbi->segs_per_sec) { +for (segno =0 ; segno <MAIN_SEGS (sbi); segno += sbi->segs_per_sec) { vblocks =get_valid_blocks (sbi, segno, sbi->segs_per_sec); dist =abs (vblocks - hblks_per_sec); bimodal += dist * dist;
@@ -103,7 +103,7 @@ static void update_sit_info(struct f2fs_sb_info *sbi) ndirty++; } } - dist =TOTAL_SECS (sbi) * hblks_per_sec * hblks_per_sec /100 ; + dist =MAIN_SECS (sbi) * hblks_per_sec * hblks_per_sec /100 ; si->bimodal = bimodal / dist;if (si->dirty_count) si->avg_vblocks = total_vblocks / ndirty;
@@ -131,17 +131,17 @@ static void update_mem_info(struct f2fs_sb_info *sbi)/* build sit */ si->base_mem +=sizeof (struct sit_info ); - si->base_mem +=TOTAL_SEGS (sbi) *sizeof (struct seg_entry ); - si->base_mem +=f2fs_bitmap_size (TOTAL_SEGS (sbi)); - si->base_mem +=2 *SIT_VBLOCK_MAP_SIZE *TOTAL_SEGS (sbi); + si->base_mem +=MAIN_SEGS (sbi) *sizeof (struct seg_entry ); + si->base_mem +=f2fs_bitmap_size (MAIN_SEGS (sbi)); + si->base_mem +=2 *SIT_VBLOCK_MAP_SIZE *MAIN_SEGS (sbi);if (sbi->segs_per_sec >1 ) - si->base_mem +=TOTAL_SECS (sbi) *sizeof (struct sec_entry ); + si->base_mem +=MAIN_SECS (sbi) *sizeof (struct sec_entry ); si->base_mem +=__bitmap_size (sbi,SIT_BITMAP );/* build free segmap */ si->base_mem +=sizeof (struct free_segmap_info ); - si->base_mem +=f2fs_bitmap_size (TOTAL_SEGS (sbi)); - si->base_mem +=f2fs_bitmap_size (TOTAL_SECS (sbi)); + si->base_mem +=f2fs_bitmap_size (MAIN_SEGS (sbi)); + si->base_mem +=f2fs_bitmap_size (MAIN_SECS (sbi));/* build curseg */ si->base_mem +=sizeof (struct curseg_info ) *NR_CURSEG_TYPE ;
@@ -149,8 +149,8 @@ static void update_mem_info(struct f2fs_sb_info *sbi)/* build dirty segmap */ si->base_mem +=sizeof (struct dirty_seglist_info ); - si->base_mem +=NR_DIRTY_TYPE *f2fs_bitmap_size (TOTAL_SEGS (sbi)); - si->base_mem +=f2fs_bitmap_size (TOTAL_SECS (sbi)); + si->base_mem +=NR_DIRTY_TYPE *f2fs_bitmap_size (MAIN_SEGS (sbi)); + si->base_mem +=f2fs_bitmap_size (MAIN_SECS (sbi));/* build nm */ si->base_mem +=sizeof (struct f2fs_nm_info );
fs/f2fs/gc.c +3 -4
@@ -193,7 +193,7 @@ static unsigned int check_bg_victims(struct f2fs_sb_info *sbi)* selected by background GC before. * Those segments guarantee they have small valid blocks. */ -for_each_set_bit (secno, dirty_i->victim_secmap,TOTAL_SECS (sbi)) { +for_each_set_bit (secno, dirty_i->victim_secmap,MAIN_SECS (sbi)) {if (sec_usage_check (sbi, secno))continue ;clear_bit (secno, dirty_i->victim_secmap);
@@ -281,9 +281,8 @@ static int get_victim_by_default(struct f2fs_sb_info *sbi,unsigned long cost;unsigned int segno; - segno =find_next_bit (p.dirty_segmap, -TOTAL_SEGS (sbi), p.offset); -if (segno >=TOTAL_SEGS (sbi)) { + segno =find_next_bit (p.dirty_segmap,MAIN_SEGS (sbi), p.offset); +if (segno >=MAIN_SEGS (sbi)) {if (sbi->last_victim[p.gc_mode]) { sbi->last_victim[p.gc_mode] =0 ; p.offset =0 ;
fs/f2fs/recovery.c +3 -5
@@ -173,8 +173,7 @@ static int find_fsync_dnodes(struct f2fs_sb_info *sbi, struct list_head *head)while (1 ) {struct fsync_inode_entry *entry; -if (blkaddr <SM_I (sbi)->main_blkaddr || - blkaddr >= (SM_I (sbi)->seg0_blkaddr +TOTAL_BLKS (sbi))) +if (blkaddr <MAIN_BLKADDR (sbi) || blkaddr >=MAX_BLKADDR (sbi))return 0 ; page =get_meta_page_ra (sbi, blkaddr);
@@ -434,8 +433,7 @@ static int recover_data(struct f2fs_sb_info *sbi,while (1 ) {struct fsync_inode_entry *entry; -if (blkaddr <SM_I (sbi)->main_blkaddr || - blkaddr >= (SM_I (sbi)->seg0_blkaddr +TOTAL_BLKS (sbi))) +if (blkaddr <MAIN_BLKADDR (sbi) || blkaddr >=MAX_BLKADDR (sbi))break ; page =get_meta_page_ra (sbi, blkaddr);
@@ -525,7 +523,7 @@ out:/* truncate meta pages to be used by the recovery */ truncate_inode_pages_range (META_MAPPING (sbi), -SM_I (sbi)->main_blkaddr <<PAGE_CACHE_SHIFT ,-1 ); +MAIN_BLKADDR (sbi) <<PAGE_CACHE_SHIFT ,-1 );if (err) {truncate_inode_pages_final (NODE_MAPPING (sbi));
fs/f2fs/segment.c +38 -47
260 lines not on this page · raw message
fs/f2fs/segment.h +21 -23
80 lines not on this page · raw message
Signature · 9 lines
1.9.3 (Apple Git-50) ------------------------------------------------------------------------------ Meet PCI DSS 3.0 Compliance Requirements with EventLog Analyzer Achieve PCI DSS 3.0 Compliant Status with Out-of-the-box PCI DSS Reports Are you Audit-Ready for PCI DSS 3.0 Compliance? Download White paper Comply to PCI DSS 3.0 Requirement 10 and 11.5 with EventLog Analyzer http://pubads.g.doubleclick.net/gampad/clk?id=154622311&iu=/4140/ostg.clktrk
Jaegeuk Kim
maintainerPATCH 2/4 f2fs: support atomic_write feature for database
This patch introduces a very limited functionality for atomic write support. In order to support atomic write, this patch adds two ioctls:
o F2FS_IOC_ATOMIC_WRITE
o F2FS_IOC_ATOMIC_COMMIT
For F2FS_IOC_ATOMIC_WRITE, this patch introduces a data structure to communicate with applications.
struct atmoic_w {
u64 aid; /* atomic write id */
const char __user *buf; /* user data */
u64 count; /* size to update */
u64 pos; /* file offset */
};This is almost same as write() system call, and application can easily submit any atomic data by calling
f2fs_ioctl(fd, F2FS_IOC_ATOMIC_WRITE, struct atomic_w *);
Then, data's page indices are recorded in the linked list, atomic_range list. Later, f2fs_ioctl(fd, F2FS_IOC_ATOMIC_COMMIT, aid) trigger will flush all the previous atomic data to the storage, which will be shown all or nothing by f2fs recovery procedure.
--- fs/f2fs/data.c | 7 ++++-- fs/f2fs/f2fs.h | 23 +++++++++++++++--- fs/f2fs/file.c | 55 ++++++++++++++++++++++++++++++++++++++++++ fs/f2fs/gc.c | 2 +- fs/f2fs/inode.c | 4 ++++ fs/f2fs/segment.c | 71 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/f2fs/segment.h | 12 ++++++++-- fs/f2fs/super.c | 1 + 8 files changed, 167 insertions(+), 8 deletions(-)
fs/f2fs/data.c +5 -2
@@ -14,6 +14,7 @@#include <linux/mpage.h> #include <linux/aio.h> #include <linux/writeback.h> +#include <linux/mount.h> #include <linux/backing-dev.h> #include <linux/blkdev.h> #include <linux/bio.h>
@@ -934,7 +935,6 @@ skip_write: wbc->pages_skipped +=get_dirty_pages (inode);return 0 ; } -static void f2fs_write_failed (struct address_space *mapping,loff_t to) {struct inode *inode = mapping->host;
@@ -1052,7 +1052,10 @@ static int f2fs_write_end(struct file *file,trace_f2fs_write_end (inode, pos, len, copied); -set_page_dirty (page); +if (is_inode_flag_set (F2FS_I (inode),FI_ATOMIC_FILE )) +get_page (page); +else +set_page_dirty (page);if (pos + copied >i_size_read (inode)) {i_size_write (inode, pos + copied);
fs/f2fs/f2fs.h +20 -3
@@ -192,8 +192,19 @@ static inline bool __has_cursum_space(struct f2fs_summary_block *sum, int size,/* * ioctl commands */ -#define F2FS_IOC_GETFLAGS FS_IOC_GETFLAGS -#define F2FS_IOC_SETFLAGS FS_IOC_SETFLAGS +#define F2FS_IOC_GETFLAGS FS_IOC_GETFLAGS +#define F2FS_IOC_SETFLAGS FS_IOC_SETFLAGS + +#define F2FS_IOCTL_MAGIC 0xf5 +#define F2FS_IOC_ATOMIC_WRITE _IOW(F2FS_IOCTL_MAGIC, 1, struct atomic_w) +#define F2FS_IOC_ATOMIC_COMMIT _IOW(F2FS_IOCTL_MAGIC, 2, u64) + +struct atomic_w { +u64 aid;/* atomic write id */ +const char __user *buf;/* user data */ +u64 count;/* size to update */ +u64 pos;/* file offset */ +};#if defined(__KERNEL__) && defined(CONFIG_COMPAT )/*
@@ -263,6 +274,8 @@ struct f2fs_inode_info {unsigned long long xattr_ver;/* cp version of xattr modification */ struct extent_info ext;/* in-memory extent cache entry */ struct dir_inode_entry *dirty_dir;/* the pointer of dirty dir */ + +struct list_head atomic_pages;/* atomic page indexes */ }; static inline void get_extent_info(struct extent_info *ext,
@@ -1051,7 +1064,8 @@ enum {FI_INLINE_DATA ,/* used for inline data*/ FI_APPEND_WRITE ,/* inode has appended data */ FI_UPDATE_WRITE ,/* inode has in-place-update data */ - FI_NEED_IPU, /* used fo ipu for fdatasync */ +FI_NEED_IPU ,/* used for ipu for fdatasync */ + FI_ATOMIC_FILE, /* used for atomic writes support */ };static inline void set_inode_flag (struct f2fs_inode_info *fi,int flag)
@@ -1274,6 +1288,8 @@ void destroy_node_manager_caches(void);/* * segment.c */ +void prepare_atomic_pages (struct inode *,struct atomic_w *); +void commit_atomic_pages (struct inode *,u64 ,bool );void f2fs_balance_fs (struct f2fs_sb_info *);void f2fs_balance_fs_bg (struct f2fs_sb_info *);int f2fs_issue_flush (struct f2fs_sb_info *);
@@ -1355,6 +1371,7 @@ int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *, u64, u64);/* * gc.c */ +void move_data_page (struct inode *,struct page *,int );int start_gc_thread (struct f2fs_sb_info *);void stop_gc_thread (struct f2fs_sb_info *);block_t start_bidx_of_node (unsigned int ,struct f2fs_inode_info *);
fs/f2fs/file.c +55 -0
67 lines not on this page · raw message
fs/f2fs/gc.c +1 -1
@@ -520,7 +520,7 @@ static int check_dnode(struct f2fs_sb_info *sbi, struct f2fs_summary *sum,return 1 ; } -static void move_data_page (struct inode *inode,struct page *page,int gc_type) +void move_data_page (struct inode *inode,struct page *page,int gc_type) {struct f2fs_io_info fio = { .type =DATA ,
fs/f2fs/inode.c +4 -0
@@ -269,6 +269,10 @@ void f2fs_evict_inode(struct inode *inode)struct f2fs_sb_info *sbi =F2FS_I_SB (inode);nid_t xnid =F2FS_I (inode)->i_xattr_nid; +/* some remained atomic pages should discarded */ +if (is_inode_flag_set (F2FS_I (inode),FI_ATOMIC_FILE )) +commit_atomic_pages (inode,0 , true); +trace_f2fs_evict_inode (inode);truncate_inode_pages_final (&inode->i_data);
fs/f2fs/segment.c +71 -0
91 lines not on this page · raw message
fs/f2fs/segment.h +10 -2
@@ -175,6 +175,13 @@ struct segment_allocation {void (*allocate_segment)(struct f2fs_sb_info *,int ,bool ); }; +struct atomic_range { +struct list_head list; +u64 aid; +pgoff_t start; +pgoff_t end; +}; +struct sit_info {const struct segment_allocation *s_ops;
@@ -502,9 +509,10 @@ static inline bool need_inplace_update(struct inode *inode) {struct f2fs_sb_info *sbi =F2FS_I_SB (inode);unsigned int policy =SM_I (sbi)->ipu_policy; +struct f2fs_inode_info *fi =F2FS_I (inode);/* IPU can be done only for the user data */ -if (S_ISDIR (inode->i_mode)) +if (S_ISDIR (inode->i_mode) ||is_inode_flag_set (fi,FI_ATOMIC_FILE ))return false;if (policy & (0x1 <<F2FS_IPU_FORCE ))
@@ -520,7 +528,7 @@ static inline bool need_inplace_update(struct inode *inode)/* this is only set during fdatasync */ if (policy & (0x1 <<F2FS_IPU_FSYNC ) && -is_inode_flag_set (F2FS_I (inode),FI_NEED_IPU )) +is_inode_flag_set (fi,FI_NEED_IPU ))return true;return false;
fs/f2fs/super.c +1 -0
@@ -373,6 +373,7 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb) fi->i_advise =0 ;rwlock_init (&fi->ext.ext_lock);init_rwsem (&fi->i_sem); +INIT_LIST_HEAD (&fi->atomic_pages);set_inode_flag (fi,FI_NEW_INODE );
Signature · 9 lines
1.9.3 (Apple Git-50) ------------------------------------------------------------------------------ Meet PCI DSS 3.0 Compliance Requirements with EventLog Analyzer Achieve PCI DSS 3.0 Compliant Status with Out-of-the-box PCI DSS Reports Are you Audit-Ready for PCI DSS 3.0 Compliance? Download White paper Comply to PCI DSS 3.0 Requirement 10 and 11.5 with EventLog Analyzer http://pubads.g.doubleclick.net/gampad/clk?id=154622311&iu=/4140/ostg.clktrk
Jaegeuk Kim
maintainerRe: [PATCH 2/4 v2] f2fs: support atomic_write feature for database
Change log from v1:
o change data structures to fix race conditions
This patch introduces a very limited functionality for atomic write support. In order to support atomic write, this patch adds two ioctls:
o F2FS_IOC_ATOMIC_WRITE
o F2FS_IOC_ATOMIC_COMMIT
For F2FS_IOC_ATOMIC_WRITE, this patch introduces a data structure to communicate with applications.
struct atmoic_w {
u64 aid; /* atomic write id */
const char __user *buf; /* user data */
u64 count; /* size to update */
u64 pos; /* file offset */
};This is almost same as write() system call, and application can easily submit any atomic data by calling
f2fs_ioctl(fd, F2FS_IOC_ATOMIC_WRITE, struct atomic_w *);
Then, data's page indices are recorded in the linked list, atomic_range list. Later, f2fs_ioctl(fd, F2FS_IOC_ATOMIC_COMMIT, aid) trigger will flush all the previous atomic data to the storage, which will be shown all or nothing by f2fs recovery procedure.
--- fs/f2fs/data.c | 6 +++- fs/f2fs/f2fs.h | 25 +++++++++++-- fs/f2fs/file.c | 55 ++++++++++++++++++++++++++++ fs/f2fs/inode.c | 4 +++ fs/f2fs/segment.c | 106 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/f2fs/segment.h | 11 ++++-- fs/f2fs/super.c | 3 ++ 7 files changed, 204 insertions(+), 6 deletions(-)
fs/f2fs/data.c +5 -1
@@ -14,6 +14,7 @@#include <linux/mpage.h> #include <linux/aio.h> #include <linux/writeback.h> +#include <linux/mount.h> #include <linux/backing-dev.h> #include <linux/blkdev.h> #include <linux/bio.h>
@@ -1052,7 +1053,10 @@ static int f2fs_write_end(struct file *file,trace_f2fs_write_end (inode, pos, len, copied); -set_page_dirty (page); +if (is_inode_flag_set (F2FS_I (inode),FI_ATOMIC_FILE )) +prepare_atomic_page (inode, page); +else +set_page_dirty (page);if (pos + copied >i_size_read (inode)) {i_size_write (inode, pos + copied);
fs/f2fs/f2fs.h +22 -3
@@ -192,8 +192,19 @@ static inline bool __has_cursum_space(struct f2fs_summary_block *sum, int size,/* * ioctl commands */ -#define F2FS_IOC_GETFLAGS FS_IOC_GETFLAGS -#define F2FS_IOC_SETFLAGS FS_IOC_SETFLAGS +#define F2FS_IOC_GETFLAGS FS_IOC_GETFLAGS +#define F2FS_IOC_SETFLAGS FS_IOC_SETFLAGS + +#define F2FS_IOCTL_MAGIC 0xf5 +#define F2FS_IOC_ATOMIC_WRITE _IOW(F2FS_IOCTL_MAGIC, 1, struct atomic_w) +#define F2FS_IOC_ATOMIC_COMMIT _IOW(F2FS_IOCTL_MAGIC, 2, u64) + +struct atomic_w { +u64 aid;/* atomic write id */ +const char __user *buf;/* user data */ +u64 count;/* size to update */ +u64 pos;/* file offset */ +};#if defined(__KERNEL__) && defined(CONFIG_COMPAT )/*
@@ -263,6 +274,10 @@ struct f2fs_inode_info {unsigned long long xattr_ver;/* cp version of xattr modification */ struct extent_info ext;/* in-memory extent cache entry */ struct dir_inode_entry *dirty_dir;/* the pointer of dirty dir */ + +struct list_head atomic_pages;/* atomic page indexes */ +spinlock_t atomic_lock;/* lock for atomic pages */ +struct radix_tree_root atomic_root;/* root of the atomic pages */ }; static inline void get_extent_info(struct extent_info *ext,
@@ -1051,7 +1066,8 @@ enum {FI_INLINE_DATA ,/* used for inline data*/ FI_APPEND_WRITE ,/* inode has appended data */ FI_UPDATE_WRITE ,/* inode has in-place-update data */ - FI_NEED_IPU, /* used fo ipu for fdatasync */ +FI_NEED_IPU ,/* used for ipu for fdatasync */ + FI_ATOMIC_FILE, /* used for atomic writes support */ };static inline void set_inode_flag (struct f2fs_inode_info *fi,int flag)
@@ -1275,6 +1291,9 @@ void destroy_node_manager_caches(void);/* * segment.c */ +void register_atomic_pages (struct inode *,struct atomic_w *); +void prepare_atomic_page (struct inode *,struct page *); +void commit_atomic_pages (struct inode *,u64 ,bool );void f2fs_balance_fs (struct f2fs_sb_info *);void f2fs_balance_fs_bg (struct f2fs_sb_info *);int f2fs_issue_flush (struct f2fs_sb_info *);
fs/f2fs/file.c +55 -0
67 lines not on this page · raw message
fs/f2fs/inode.c +4 -0
@@ -269,6 +269,10 @@ void f2fs_evict_inode(struct inode *inode)struct f2fs_sb_info *sbi =F2FS_I_SB (inode);nid_t xnid =F2FS_I (inode)->i_xattr_nid; +/* some remained atomic pages should discarded */ +if (is_inode_flag_set (F2FS_I (inode),FI_ATOMIC_FILE )) +commit_atomic_pages (inode,0 , true); +trace_f2fs_evict_inode (inode);truncate_inode_pages_final (&inode->i_data);
fs/f2fs/segment.c +106 -0
130 lines not on this page · raw message
fs/f2fs/segment.h +9 -2
@@ -175,6 +175,12 @@ struct segment_allocation {void (*allocate_segment)(struct f2fs_sb_info *,int ,bool ); }; +struct atomic_pages { +struct list_head list; +u64 aid; +struct page *page; +}; +struct sit_info {const struct segment_allocation *s_ops;
@@ -502,9 +508,10 @@ static inline bool need_inplace_update(struct inode *inode) {struct f2fs_sb_info *sbi =F2FS_I_SB (inode);unsigned int policy =SM_I (sbi)->ipu_policy; +struct f2fs_inode_info *fi =F2FS_I (inode);/* IPU can be done only for the user data */ -if (S_ISDIR (inode->i_mode)) +if (S_ISDIR (inode->i_mode) ||is_inode_flag_set (fi,FI_ATOMIC_FILE ))return false;if (policy & (0x1 <<F2FS_IPU_FORCE ))
@@ -520,7 +527,7 @@ static inline bool need_inplace_update(struct inode *inode)/* this is only set during fdatasync */ if (policy & (0x1 <<F2FS_IPU_FSYNC ) && -is_inode_flag_set (F2FS_I (inode),FI_NEED_IPU )) +is_inode_flag_set (fi,FI_NEED_IPU ))return true;return false;
fs/f2fs/super.c +3 -0
@@ -373,6 +373,9 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb) fi->i_advise =0 ;rwlock_init (&fi->ext.ext_lock);init_rwsem (&fi->i_sem); +INIT_LIST_HEAD (&fi->atomic_pages); +spin_lock_init (&fi->atomic_lock); +INIT_RADIX_TREE (&fi->atomic_root,GFP_ATOMIC );set_inode_flag (fi,FI_NEW_INODE );
Signature · 9 lines
2.1.1 ------------------------------------------------------------------------------ Meet PCI DSS 3.0 Compliance Requirements with EventLog Analyzer Achieve PCI DSS 3.0 Compliant Status with Out-of-the-box PCI DSS Reports Are you Audit-Ready for PCI DSS 3.0 Compliance? Download White paper Comply to PCI DSS 3.0 Requirement 10 and 11.5 with EventLog Analyzer http://pubads.g.doubleclick.net/gampad/clk?id=154622311&iu=/4140/ostg.clktrk
Jaegeuk Kim
maintainerRe: [f2fs-dev] [PATCH 2/4 v2] f2fs: support atomic_write feature for database
Change log from v2:
o change naming and add one more api
Quoted 1 line
From
148ec45e541b2d2b37b90f27286a3ee484866679Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
Date: Thu, 25 Sep 2014 21:54:45 -0700
Subject: [PATCH] f2fs: support atomic operations for database
This patch introduces a very limited functionality for atomic write support. In order to support atomic write, this patch adds two ioctls:
o F2FS_IOC_DB_OPEN
o F2FS_IOC_COMMIT
The database engine should be aware of the following sequence.
1. open
-> ioctl(F2FS_IOC_DB_OPEN);
2. writes
: all the written data will be treated as atomic pages.
3. commit
-> ioctl(F2FS_IOC_COMMIT);
: this flushes all the data blocks to the disk, which will be shown all or nothing by f2fs recovery procedure.
The IO pattens should be:
CP | D D D D D D | FSYNC | D D D D | FSYNC ...
While supporting atomic writes for main database file, we can keep its journal data temporarily in the page cache by the following sequence.
1. open
-> ioctl(F2FS_IOC_JOURNAL_OPEN);
2. writes
: keep all the data in the page cache.
3. flush to the database file with atomic writes
a. ioctl(F2FS_IOC_DB_OPEN);
b. writes
c. ioctl(F2FS_IOC_COMMIT);
4. close
-> drop the cached data
--- fs/f2fs/data.c | 9 ++++++- fs/f2fs/f2fs.h | 27 ++++++++++++++++--- fs/f2fs/file.c | 55 ++++++++++++++++++++++++++++++++++++++ fs/f2fs/inline.c | 3 +++ fs/f2fs/inode.c | 4 +++ fs/f2fs/segment.c | 79 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/f2fs/segment.h | 10 +++++-- fs/f2fs/super.c | 2 ++ 8 files changed, 183 insertions(+), 6 deletions(-)
fs/f2fs/data.c +8 -1
@@ -14,6 +14,7 @@#include <linux/mpage.h> #include <linux/aio.h> #include <linux/writeback.h> +#include <linux/mount.h> #include <linux/backing-dev.h> #include <linux/blkdev.h> #include <linux/bio.h>
@@ -1052,7 +1053,10 @@ static int f2fs_write_end(struct file *file,trace_f2fs_write_end (inode, pos, len, copied); -set_page_dirty (page); +if (f2fs_is_db_file (inode)) +register_db_page (inode, page); +else +set_page_dirty (page);if (pos + copied >i_size_read (inode)) {i_size_write (inode, pos + copied);
@@ -1116,6 +1120,9 @@ static void f2fs_invalidate_data_page(struct page *page, unsigned int offset,if (offset %PAGE_CACHE_SIZE || length !=PAGE_CACHE_SIZE )return ; +if (f2fs_is_db_file (inode)) +invalidate_db_page (inode, page); +if (PageDirty (page))inode_dec_dirty_pages (inode);ClearPagePrivate (page);
fs/f2fs/f2fs.h +24 -3
@@ -192,8 +192,13 @@ static inline bool __has_cursum_space(struct f2fs_summary_block *sum, int size,/* * ioctl commands */ -#define F2FS_IOC_GETFLAGS FS_IOC_GETFLAGS -#define F2FS_IOC_SETFLAGS FS_IOC_SETFLAGS +#define F2FS_IOC_GETFLAGS FS_IOC_GETFLAGS +#define F2FS_IOC_SETFLAGS FS_IOC_SETFLAGS + +#define F2FS_IOCTL_MAGIC 0xf5 +#define F2FS_IOC_DB_OPEN _IO(F2FS_IOCTL_MAGIC, 1) +#define F2FS_IOC_JOURNAL_OPEN _IO(F2FS_IOCTL_MAGIC, 2) +#define F2FS_IOC_COMMIT _IO(F2FS_IOCTL_MAGIC, 3)#if defined(__KERNEL__) && defined(CONFIG_COMPAT )/*
@@ -263,6 +268,9 @@ struct f2fs_inode_info {unsigned long long xattr_ver;/* cp version of xattr modification */ struct extent_info ext;/* in-memory extent cache entry */ struct dir_inode_entry *dirty_dir;/* the pointer of dirty dir */ + +struct list_head db_pages;/* atomic page indexes */ +struct mutex db_lock;/* lock for atomic pages */ }; static inline void get_extent_info(struct extent_info *ext,
@@ -1051,7 +1059,9 @@ enum {FI_INLINE_DATA ,/* used for inline data*/ FI_APPEND_WRITE ,/* inode has appended data */ FI_UPDATE_WRITE ,/* inode has in-place-update data */ - FI_NEED_IPU, /* used fo ipu for fdatasync */ +FI_NEED_IPU ,/* used for ipu for fdatasync */ +FI_DB_FILE ,/* indicate database file */ + FI_JOURNAL_FILE, /* indicate journal file */ };static inline void set_inode_flag (struct f2fs_inode_info *fi,int flag)
@@ -1111,6 +1121,14 @@ static inline int f2fs_has_inline_xattr(struct inode *inode)return is_inode_flag_set (F2FS_I (inode),FI_INLINE_XATTR ); } +static inline bool f2fs_is_db_file (struct inode *inode) +{ +if (is_inode_flag_set (F2FS_I (inode),FI_DB_FILE ) || +is_inode_flag_set (F2FS_I (inode),FI_JOURNAL_FILE )) +return true; +return false; +} +static inline unsigned int addrs_per_inode (struct f2fs_inode_info *fi) {if (f2fs_has_inline_xattr (&fi->vfs_inode))
@@ -1275,6 +1293,9 @@ void destroy_node_manager_caches(void);/* * segment.c */ +void register_db_page (struct inode *,struct page *); +void invalidate_db_page (struct inode *,struct page *); +void commit_db_pages (struct inode *,bool );void f2fs_balance_fs (struct f2fs_sb_info *);void f2fs_balance_fs_bg (struct f2fs_sb_info *);int f2fs_issue_flush (struct f2fs_sb_info *);
fs/f2fs/file.c +55 -0
67 lines not on this page · raw message
fs/f2fs/inline.c +3 -0
@@ -21,6 +21,9 @@ bool f2fs_may_inline(struct inode *inode)if (!test_opt (F2FS_I_SB (inode),INLINE_DATA ))return false; +if (is_inode_flag_set (F2FS_I (inode),FI_DB_FILE )) +return false; + nr_blocks =F2FS_I (inode)->i_xattr_nid ?3 :2 ;if (inode->i_blocks > nr_blocks)return false;
fs/f2fs/inode.c +4 -0
@@ -269,6 +269,10 @@ void f2fs_evict_inode(struct inode *inode)struct f2fs_sb_info *sbi =F2FS_I_SB (inode);nid_t xnid =F2FS_I (inode)->i_xattr_nid; +/* some remained atomic pages should discarded */ +if (f2fs_is_db_file (inode)) +commit_db_pages (inode, true); +trace_f2fs_evict_inode (inode);truncate_inode_pages_final (&inode->i_data);
fs/f2fs/segment.c +79 -0
103 lines not on this page · raw message
fs/f2fs/segment.h +8 -2
@@ -175,6 +175,11 @@ struct segment_allocation {void (*allocate_segment)(struct f2fs_sb_info *,int ,bool ); }; +struct db_pages { +struct list_head list; +struct page *page; +}; +struct sit_info {const struct segment_allocation *s_ops;
@@ -502,9 +507,10 @@ static inline bool need_inplace_update(struct inode *inode) {struct f2fs_sb_info *sbi =F2FS_I_SB (inode);unsigned int policy =SM_I (sbi)->ipu_policy; +struct f2fs_inode_info *fi =F2FS_I (inode);/* IPU can be done only for the user data */ -if (S_ISDIR (inode->i_mode)) +if (S_ISDIR (inode->i_mode) ||is_inode_flag_set (fi,FI_DB_FILE ))return false;if (policy & (0x1 <<F2FS_IPU_FORCE ))
@@ -520,7 +526,7 @@ static inline bool need_inplace_update(struct inode *inode)/* this is only set during fdatasync */ if (policy & (0x1 <<F2FS_IPU_FSYNC ) && -is_inode_flag_set (F2FS_I (inode),FI_NEED_IPU )) +is_inode_flag_set (fi,FI_NEED_IPU ))return true;return false;
fs/f2fs/super.c +2 -0
@@ -373,6 +373,8 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb) fi->i_advise =0 ;rwlock_init (&fi->ext.ext_lock);init_rwsem (&fi->i_sem); +INIT_LIST_HEAD (&fi->db_pages); +mutex_init (&fi->db_lock);set_inode_flag (fi,FI_NEW_INODE );
Signature · 1 line
2.1.1
Jaegeuk Kim
maintainerPATCH 3/4 f2fs: clean up f2fs_ioctl functions
In reply to Jaegeuk KimThis patch cleans up f2fs_ioctl functions for better readability.
--- fs/f2fs/file.c | 168 ++++++++++++++++++++++++++++++--------------------------- 1 file changed, 90 insertions(+), 78 deletions(-)
fs/f2fs/file.c +90 -78
@@ -805,6 +805,93 @@ static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags)return flags &F2FS_OTHER_FLMASK ; } +static int f2fs_ioc_getflags (struct file *filp,unsigned long arg) +{ +struct inode *inode =file_inode (filp); +struct f2fs_inode_info *fi =F2FS_I (inode); +unsigned int flags = fi->i_flags &FS_FL_USER_VISIBLE ; +return put_user (flags, (int __user *)arg); +} + +static int f2fs_ioc_setflags (struct file *filp,unsigned long arg) +{ +struct inode *inode =file_inode (filp); +struct f2fs_inode_info *fi =F2FS_I (inode); +unsigned int flags = fi->i_flags &FS_FL_USER_VISIBLE ; +unsigned int oldflags; +int ret; + + ret =mnt_want_write_file (filp); +if (ret) +return ret; + +if (!inode_owner_or_capable (inode)) { + ret = -EACCES ; + goto out; + } + +if (get_user (flags, (int __user *)arg)) { + ret = -EFAULT ; + goto out; + } + + flags =f2fs_mask_flags (inode->i_mode, flags); + +mutex_lock (&inode->i_mutex); + + oldflags = fi->i_flags; + +if ((flags ^ oldflags) & (FS_APPEND_FL |FS_IMMUTABLE_FL )) { +if (!capable (CAP_LINUX_IMMUTABLE )) { +mutex_unlock (&inode->i_mutex); + ret = -EPERM ; + goto out; + } + } + + flags = flags &FS_FL_USER_MODIFIABLE ; + flags |= oldflags & ~FS_FL_USER_MODIFIABLE ; + fi->i_flags = flags; +mutex_unlock (&inode->i_mutex); + +f2fs_set_inode_flags (inode); + inode->i_ctime =CURRENT_TIME ; +mark_inode_dirty (inode); +out: +mnt_drop_write_file (filp); +return ret; +} + +static int f2fs_ioc_fitrim (struct file *filp,unsigned long arg) +{ +struct inode *inode =file_inode (filp); +struct super_block *sb = inode->i_sb; +struct request_queue *q =bdev_get_queue (sb->s_bdev); +struct fstrim_range range; +int ret; + +if (!capable (CAP_SYS_ADMIN )) +return -EPERM ; + +if (!blk_queue_discard (q)) +return -EOPNOTSUPP ; + +if (copy_from_user (&range, (struct fstrim_range __user *)arg, +sizeof (range))) +return -EFAULT ; + + range.minlen =max ((unsigned int )range.minlen, + q->limits.discard_granularity); + ret =f2fs_trim_fs (F2FS_SB (sb), &range); +if (ret <0 ) +return ret; + +if (copy_to_user ((struct fstrim_range __user *)arg, &range, +sizeof (range))) +return -EFAULT ; +return 0 ; +} +static int f2fs_ioc_atomic_write (struct file *filp,unsigned long arg) {struct inode *inode =file_inode (filp);
@@ -858,92 +945,17 @@ static int f2fs_ioc_atomic_commit(struct file *filp, unsigned long arg)long f2fs_ioctl (struct file *filp,unsigned int cmd,unsigned long arg) { -struct inode *inode =file_inode (filp); -struct f2fs_inode_info *fi =F2FS_I (inode); -unsigned int flags; -int ret; -switch (cmd) {case F2FS_IOC_GETFLAGS : - flags = fi->i_flags &FS_FL_USER_VISIBLE ; -return put_user (flags, (int __user *) arg); +return f2fs_ioc_getflags (filp, arg);case F2FS_IOC_SETFLAGS : - { -unsigned int oldflags; - - ret =mnt_want_write_file (filp); -if (ret) -return ret; - -if (!inode_owner_or_capable (inode)) { - ret = -EACCES ; - goto out; - } - -if (get_user (flags, (int __user *) arg)) { - ret = -EFAULT ; - goto out; - } - - flags =f2fs_mask_flags (inode->i_mode, flags); - -mutex_lock (&inode->i_mutex); - - oldflags = fi->i_flags; - -if ((flags ^ oldflags) & (FS_APPEND_FL |FS_IMMUTABLE_FL )) { -if (!capable (CAP_LINUX_IMMUTABLE )) { -mutex_unlock (&inode->i_mutex); - ret = -EPERM ; - goto out; - } - } - - flags = flags &FS_FL_USER_MODIFIABLE ; - flags |= oldflags & ~FS_FL_USER_MODIFIABLE ; - fi->i_flags = flags; -mutex_unlock (&inode->i_mutex); - -f2fs_set_inode_flags (inode); - inode->i_ctime =CURRENT_TIME ; -mark_inode_dirty (inode); -out: -mnt_drop_write_file (filp); -return ret; - } +return f2fs_ioc_setflags (filp, arg);case F2FS_IOC_ATOMIC_WRITE :return f2fs_ioc_atomic_write (filp, arg);case F2FS_IOC_ATOMIC_COMMIT :return f2fs_ioc_atomic_commit (filp, arg);case FITRIM : - { -struct super_block *sb = inode->i_sb; -struct request_queue *q =bdev_get_queue (sb->s_bdev); -struct fstrim_range range; -int ret =0 ; - -if (!capable (CAP_SYS_ADMIN )) -return -EPERM ; - -if (!blk_queue_discard (q)) -return -EOPNOTSUPP ; - -if (copy_from_user (&range, (struct fstrim_range __user *)arg, -sizeof (range))) -return -EFAULT ; - - range.minlen =max ((unsigned int )range.minlen, - q->limits.discard_granularity); - ret =f2fs_trim_fs (F2FS_SB (sb), &range); -if (ret <0 ) -return ret; - -if (copy_to_user ((struct fstrim_range __user *)arg, &range, -sizeof (range))) -return -EFAULT ; - -return 0 ; - } +return f2fs_ioc_fitrim (filp, arg);default :return -ENOTTY ; }
Signature · 9 lines
1.9.3 (Apple Git-50) ------------------------------------------------------------------------------ Meet PCI DSS 3.0 Compliance Requirements with EventLog Analyzer Achieve PCI DSS 3.0 Compliant Status with Out-of-the-box PCI DSS Reports Are you Audit-Ready for PCI DSS 3.0 Compliance? Download White paper Comply to PCI DSS 3.0 Requirement 10 and 11.5 with EventLog Analyzer http://pubads.g.doubleclick.net/gampad/clk?id=154622311&iu=/4140/ostg.clktrk
Jaegeuk Kim
maintainerPATCH 4/4 f2fs: call f2fs_unlock_op after error was handled
In reply to Jaegeuk KimThis patch relocates f2fs_unlock_op in every directory operations to be called after any error was processed.
Otherwise, the checkpoint can be entered with valid node ids without its dentry when -ENOSPC is occurred.
--- fs/f2fs/f2fs.h | 1 + fs/f2fs/inode.c | 23 +++++++++++++++++++++++ fs/f2fs/namei.c | 32 +++++++++++--------------------- 3 files changed, 35 insertions(+), 21 deletions(-)
fs/f2fs/f2fs.h +1 -0
@@ -1208,6 +1208,7 @@ void update_inode(struct inode *, struct page *);void update_inode_page (struct inode *);int f2fs_write_inode (struct inode *,struct writeback_control *);void f2fs_evict_inode (struct inode *); +void handle_failed_inode (struct inode *);/* * namei.c
fs/f2fs/inode.c +23 -0
@@ -310,3 +310,26 @@ no_delete: out_clear:clear_inode (inode); } + +/* caller should call f2fs_lock_op() */ +void handle_failed_inode (struct inode *inode) +{ +struct f2fs_sb_info *sbi =F2FS_I_SB (inode); + +clear_nlink (inode); +make_bad_inode (inode); +unlock_new_inode (inode); + +i_size_write (inode,0 ); +if (F2FS_HAS_BLOCKS (inode)) +f2fs_truncate (inode); + +remove_inode_page (inode); +stat_dec_inline_inode (inode); + +alloc_nid_failed (sbi, inode->i_ino); +f2fs_unlock_op (sbi); + +/* iput will drop the inode object */ +iput (inode); +}
fs/f2fs/namei.c +11 -21
@@ -123,9 +123,9 @@ static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,f2fs_lock_op (sbi); err =f2fs_add_link (dentry, inode); -f2fs_unlock_op (sbi);if (err) goto out; +f2fs_unlock_op (sbi);alloc_nid_done (sbi, ino);
@@ -133,9 +133,7 @@ static int f2fs_create(struct inode *dir, struct dentry *dentry, umode_t mode,unlock_new_inode (inode);return 0 ; out: -clear_nlink (inode); -iget_failed (inode); -alloc_nid_failed (sbi, ino); +handle_failed_inode (inode);return err; }
@@ -154,15 +152,16 @@ static int f2fs_link(struct dentry *old_dentry, struct inode *dir,set_inode_flag (F2FS_I (inode),FI_INC_LINK );f2fs_lock_op (sbi); err =f2fs_add_link (dentry, inode); -f2fs_unlock_op (sbi);if (err) goto out; +f2fs_unlock_op (sbi);d_instantiate (dentry, inode);return 0 ; out:clear_inode_flag (F2FS_I (inode),FI_INC_LINK );iput (inode); +f2fs_unlock_op (sbi);return err; }
@@ -253,9 +252,9 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry,f2fs_lock_op (sbi); err =f2fs_add_link (dentry, inode); -f2fs_unlock_op (sbi);if (err) goto out; +f2fs_unlock_op (sbi); err =page_symlink (inode, symname, symlen);alloc_nid_done (sbi, inode->i_ino);
@@ -264,9 +263,7 @@ static int f2fs_symlink(struct inode *dir, struct dentry *dentry,unlock_new_inode (inode);return err; out: -clear_nlink (inode); -iget_failed (inode); -alloc_nid_failed (sbi, inode->i_ino); +handle_failed_inode (inode);return err; }
@@ -290,9 +287,9 @@ static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)set_inode_flag (F2FS_I (inode),FI_INC_LINK );f2fs_lock_op (sbi); err =f2fs_add_link (dentry, inode); -f2fs_unlock_op (sbi);if (err) goto out_fail; +f2fs_unlock_op (sbi);alloc_nid_done (sbi, inode->i_ino);
@@ -303,9 +300,7 @@ static int f2fs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) out_fail:clear_inode_flag (F2FS_I (inode),FI_INC_LINK ); -clear_nlink (inode); -iget_failed (inode); -alloc_nid_failed (sbi, inode->i_ino); +handle_failed_inode (inode);return err; }
@@ -338,18 +333,16 @@ static int f2fs_mknod(struct inode *dir, struct dentry *dentry,f2fs_lock_op (sbi); err =f2fs_add_link (dentry, inode); -f2fs_unlock_op (sbi);if (err) goto out; +f2fs_unlock_op (sbi);alloc_nid_done (sbi, inode->i_ino);d_instantiate (dentry, inode);unlock_new_inode (inode);return 0 ; out: -clear_nlink (inode); -iget_failed (inode); -alloc_nid_failed (sbi, inode->i_ino); +handle_failed_inode (inode);return err; }
@@ -677,10 +670,7 @@ static int f2fs_tmpfile(struct inode *dir, struct dentry *dentry, umode_t mode) release_out:release_orphan_inode (sbi); out: -f2fs_unlock_op (sbi); -clear_nlink (inode); -iget_failed (inode); -alloc_nid_failed (sbi, inode->i_ino); +handle_failed_inode (inode);return err; }
Signature · 9 lines
1.9.3 (Apple Git-50) ------------------------------------------------------------------------------ Meet PCI DSS 3.0 Compliance Requirements with EventLog Analyzer Achieve PCI DSS 3.0 Compliant Status with Out-of-the-box PCI DSS Reports Are you Audit-Ready for PCI DSS 3.0 Compliance? Download White paper Comply to PCI DSS 3.0 Requirement 10 and 11.5 with EventLog Analyzer http://pubads.g.doubleclick.net/gampad/clk?id=154622311&iu=/4140/ostg.clktrk
Hi Jaegeuk,
Quoted 24 lines
-----Original Message-----
From: Jaegeuk Kim [mailto:[email protected]]
Sent: Friday, September 26, 2014 12:55 PM
To: [email protected]; [email protected]; [email protected]
Cc: Jaegeuk Kim
Subject: [f2fs-dev] [PATCH 1/4] f2fs: check the use of macros on block counts and addressesThis patch cleans up the existing and new macros for readability.
Rule is like this.
,-----------------------------------------> MAX_BLKADDR -, | ,------------- TOTAL_BLKS ----------------------------, | | | | ,- seg0_blkaddr ,----- sit/nat/ssa/main blkaddress |block | | (
SEG0_BLKADDR) | | | | (e.g.,MAIN_BLKADDR) |
address 0..x................ a b c d .............................
| |
global seg# 0...................... m .............................| | | | `------- MAIN_SEGS -----------' `-------------- TOTAL_SEGS ---------------------------' | |
Quoted 8 lines
seg# 0..........xx..................
= Note =
oGET_SEGNO_FROM_SEG0: blk address -> global segno
oGET_SEGNO: blk address -> segno
oSTART_BLOCK: segno -> starting block addressSigned-off-by Jaegeuk Kim <[email protected]>
Looks good!
I see SM_I(sbi)->segment_count in check_seg_range/check_block_count still not be instead with TOTAL_SEGS(sbi), how about insteading these together?
Regards,
Yu