new APIs to allocate buffer-cache with user specific flag
Subsystems (3)
v2 cover new APIs to allocate buffer-cache with user specific flag
Hello,
This patch try to solve problem that a long-lasting page caches of ext4 superblock and journaling of superblock disturb page migration.
I've been testing CMA feature on my ARM-based platform
and found that two page caches cannot be migrated.
They are page caches of superblock of ext4 filesystem and its journaling data.
Current ext4 reads superblock with sb_bread() that allocates page from movable area. But the problem is that ext4 hold the page until it is unmounted. If root filesystem is ext4 the page cannot be migrated forever. And also the journaling data for the superblock cannot be migreated.
I introduce a new API that allocates page cache with specific flag passed by an argument. The API user can set flag to zero if the user wants to allocate page cache from non-movable area.
It is useful for ext4/ext3 and others that want to hold page cache for a long time.
I have 3 patchs:
1. Patch 1/3: introduce a new API that create page cache with allocation flag
2. Patch 2/3: have ext4 use the new API to read superblock
3. Patch 3/3: have jbd/jbd2 use the new API to make journaling of superblock
This patchset is based on linux-next-20140814.
Thanks a lot.
Gioh Kim (3):
fs/buffer.c: allocate buffer cache with user specific flag
ext4: allocate buffer-cache for superblock in non-movable area jbd-jbd2-allocate-buffer-cache-for-superblock-inode-.patch
fs/buffer.c | 52 +++++++++++++++++++++++++++++--------------- fs/ext4/super.c | 6 ++--- fs/jbd/journal.c | 2 - fs/jbd2/journal.c | 2 - include/linux/buffer_head.h | 12 +++++++++- 5 files changed, 51 insertions(+), 23 deletions(-)
PATCH v2 1/3 fs/buffer.c: allocate buffer cache with user specific flag
A buffer cache is allocated from movable area because it is referred for a while and released soon. But some filesystems are taking buffer cache for a long time and it can disturb page migration.
A new API should be introduced to allocate buffer cache with user specific flag.
For instance if user set flag to zero, buffer cache is allocated from non-movable area.
--- fs/buffer.c | 52 +++++++++++++++++++++++++++++-------------- include/linux/buffer_head.h | 12 +++++++++- 2 files changed, 46 insertions(+), 18 deletions(-)
fs/buffer.c +35 -17
@@ -993,7 +993,7 @@ init_page_buffers(struct page *page, struct block_device *bdev,*/ static int grow_dev_page (struct block_device *bdev,sector_t block, -pgoff_t index,int size,int sizebits) +pgoff_t index,int size,int sizebits,gfp_t gfp) {struct inode *inode = bdev->bd_inode;struct page *page;
@@ -1002,10 +1002,10 @@ grow_dev_page(struct block_device *bdev, sector_t block,int ret =0 ;/* Will call free_more_memory() */ gfp_t gfp_mask; - gfp_mask =mapping_gfp_mask (inode->i_mapping) & ~__GFP_FS; - gfp_mask |= __GFP_MOVABLE; + gfp_mask = (mapping_gfp_mask (inode->i_mapping) & ~__GFP_FS) | gfp; +/* -* XXX: __getblk_slow() can not really deal with failure and +* XXX: __getblk_gfp() can not really deal with failure and * will endlessly loop on improvised global reclaim. Prefer * looping in the allocator rather than here, at least that * code knows what it's doing.
@@ -1058,7 +1058,7 @@ failed:* that page was dirty, the buffers are set dirty also. */ static int -grow_buffers (struct block_device *bdev,sector_t block,int size) +grow_buffers (struct block_device *bdev,sector_t block,int size,gfp_t gfp) {pgoff_t index;int sizebits;
@@ -1085,11 +1085,12 @@ grow_buffers(struct block_device *bdev, sector_t block, int size) }/* Create a page with the proper size buffers.. */ -return grow_dev_page (bdev, block, index, size, sizebits); +return grow_dev_page (bdev, block, index, size, sizebits, gfp); } -static struct buffer_head * -__getblk_slow (struct block_device *bdev,sector_t block,int size) +struct buffer_head * +__getblk_gfp (struct block_device *bdev,sector_t block, +unsigned size,gfp_t gfp) {/* Size must be multiple of hard sectorsize */ if (unlikely(size & (bdev_logical_block_size(bdev)-1) ||
@@ -1111,13 +1112,14 @@ __getblk_slow(struct block_device *bdev, sector_t block, int size)if (bh)return bh; - ret =grow_buffers (bdev, block, size); + ret =grow_buffers (bdev, block, size, gfp);if (ret <0 )return NULL ;if (ret ==0 )free_more_memory (); } } +EXPORT_SYMBOL (__getblk_gfp);/* * The relationship between dirty buffers and dirty pages:
@@ -1381,12 +1383,7 @@ EXPORT_SYMBOL(__find_get_block);struct buffer_head *__getblk (struct block_device *bdev,sector_t block,unsigned size) { -struct buffer_head *bh =__find_get_block (bdev, block, size); - -might_sleep (); -if (bh ==NULL ) - bh =__getblk_slow (bdev, block, size); -return bh; +return __getblk_gfp (bdev, block, size, __GFP_MOVABLE); }EXPORT_SYMBOL (__getblk);
@@ -1410,18 +1407,39 @@ EXPORT_SYMBOL(__breadahead);* @size: size (in bytes) to read * * Reads a specified block, and returns buffer head that contains it. +* The page cache is allocated from movable area so that it can be migrated. * It returns NULL if the block was unreadable. */ struct buffer_head *__bread (struct block_device *bdev,sector_t block,unsigned size) { -struct buffer_head *bh =__getblk (bdev, block, size); +return __bread_gfp (bdev, block, size, __GFP_MOVABLE); +} +EXPORT_SYMBOL (__bread); + +/** +* __bread_gfp() - reads a specified block and returns the bh +* @bdev: the block_device to read from +* @block: number of block +* @size: size (in bytes) to read +* @gfp: page allocation flag +* +* Reads a specified block, and returns buffer head that contains it. +* The page cache can be allocated from non-movable area +* not to prevent page migration if you set gfp to zero. +* It returns NULL if the block was unreadable. +*/ +struct buffer_head * +__bread_gfp (struct block_device *bdev,sector_t block, +unsigned size,gfp_t gfp) +{ +struct buffer_head *bh =__getblk_gfp (bdev, block, size, gfp);if (likely (bh) && !buffer_uptodate (bh)) bh =__bread_slow (bh);return bh; } -EXPORT_SYMBOL (__bread); +EXPORT_SYMBOL (__bread_gfp);/* * invalidate_bh_lrus() is called rarely - but not only at unmount.
include/linux/buffer_head.h +11 -1
@@ -177,10 +177,14 @@ struct buffer_head *__find_get_block(struct block_device *bdev, sector_t block, unsigned size);struct buffer_head *__getblk (struct block_device *bdev,sector_t block,unsigned size); +struct buffer_head *__getblk_gfp (struct block_device *bdev,sector_t block, +unsigned size,gfp_t gfp);void __brelse (struct buffer_head *);void __bforget (struct buffer_head *);void __breadahead (struct block_device *,sector_t block,unsigned int size);struct buffer_head *__bread (struct block_device *,sector_t block,unsigned size); +struct buffer_head *__bread_gfp (struct block_device *, +sector_t block,unsigned size,gfp_t gfp);void invalidate_bh_lrus (void );struct buffer_head *alloc_buffer_head (gfp_t gfp_flags);void free_buffer_head (struct buffer_head * bh);
@@ -295,7 +299,13 @@ static inline void bforget(struct buffer_head *bh)static inline struct buffer_head *sb_bread (struct super_block *sb,sector_t block) { -return __bread (sb->s_bdev, block, sb->s_blocksize); +return __bread_gfp (sb->s_bdev, block, sb->s_blocksize, __GFP_MOVABLE); +} + +static inline struct buffer_head * +sb_bread_gfp (struct super_block *sb,sector_t block,gfp_t gfp) +{ +return __bread_gfp (sb->s_bdev, block, sb->s_blocksize, gfp); } static inline void
--
1.7.9.5
PATCH v2 2/3 ext4: allocate buffer-cache for superblock in non-movable area
In reply to Gioh KimA buffer-cache for superblock is disturbing page migration, because the buffer-cache is not released until unmount. The buffer-cache must be allocated from non-movable area.
--- fs/ext4/super.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
fs/ext4/super.c +3 -3
@@ -3435,7 +3435,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) logical_sb_block = sb_block; } -if (!(bh =sb_bread (sb, logical_sb_block))) { +if (!(bh =sb_bread_gfp (sb, logical_sb_block,0 ))) {ext4_msg (sb,KERN_ERR ,"unable to read superblock" ); goto out_fail; }
@@ -3645,7 +3645,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)brelse (bh); logical_sb_block = sb_block *EXT4_MIN_BLOCK_SIZE ; offset =do_div (logical_sb_block, blocksize); - bh =sb_bread (sb, logical_sb_block); + bh =sb_bread_gfp (sb, logical_sb_block,0 );if (!bh) {ext4_msg (sb,KERN_ERR ,"Can't read superblock on 2nd try" );
@@ -3867,7 +3867,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent)for (i =0 ; i < db_count; i++) { block =descriptor_loc (sb, logical_sb_block, i); - sbi->s_group_desc[i] =sb_bread (sb, block); + sbi->s_group_desc[i] =sb_bread_gfp (sb, block,0 );if (!sbi->s_group_desc[i]) {ext4_msg (sb,KERN_ERR ,"can't read group descriptor %d" , i);
--
1.7.9.5
PATCH v2 3/3 jbd/jbd2: allocate buffer-cache for superblock inode in non-movable area
In reply to Gioh KimA long-lasting buffer-cache can distrub page migration so that it must be allocated from non-movable area.
The journal_init_inode is creating a buffer-cache for superblock journaling. The superblock exists until system shutdown so that the buffer-cache for the superblock would also exist for a long time
and it can distrub page migration.
This patch make the buffer-cache be allocated from non-movable area not to distrub page migration.
--- fs/jbd/journal.c | 2 +- fs/jbd2/journal.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
fs/jbd/journal.c +1 -1
@@ -886,7 +886,7 @@ journal_t * journal_init_inode (struct inode *inode) goto out_err; } - bh =__getblk (journal->j_dev, blocknr, journal->j_blocksize); + bh =__getblk_gfp (journal->j_dev, blocknr, journal->j_blocksize,0 );if (!bh) { printk(KERN_ERR "%s: Cannot get buffer for journal superblock\n",
fs/jbd2/journal.c +1 -1
@@ -1237,7 +1237,7 @@ journal_t * jbd2_journal_init_inode (struct inode *inode) goto out_err; } - bh =__getblk (journal->j_dev, blocknr, journal->j_blocksize); + bh =__getblk_gfp (journal->j_dev, blocknr, journal->j_blocksize,0 );if (!bh) { printk(KERN_ERR "%s: Cannot get buffer for journal superblock\n",
--
1.7.9.5
Jan Kara
reviewerRe: [PATCHv2 1/3] fs/buffer.c: allocate buffer cache with user specific flag
In reply to Gioh KimHello,
Quoted 30 lines · Gioh Kim
A buffer cache is allocated from movable area because it is referred for a while and released soon. But some filesystems are taking buffer cache for a long time and it can disturb page migration.
A new API should be introduced to allocate buffer cache with user specific flag.
For instance if user set flag to zero, buffer cache is allocated from non-movable area.Signed-off-by Gioh Kim <[email protected]>--- fs/buffer.c | 52 +++++++++++++++++++++++++++++-------------- include/linux/buffer_head.h | 12 +++++++++- 2 files changed, 46 insertions(+), 18 deletions(-)fs/buffer.c +1
-1@@ -993,7 +993,7 @@ init_page_buffers(struct page *page, struct block_device *bdev,*/ static int grow_dev_page (struct block_device *bdev,sector_t block, -pgoff_t index,int size,int sizebits) +pgoff_t index,int size,int sizebits,gfp_t gfp) {struct inode *inode = bdev->bd_inode;struct page *page;
fs/buffer.c grow_dev_page(struct block_device *bdev, sector_t block, · line 1006
Quoted 7 lines
fs/buffer.c +2
-2@@ -1002,10 +1002,10 @@ grow_dev_page(struct block_device *bdev, sector_t block,int ret =0 ;/* Will call free_more_memory() */ gfp_t gfp_mask; - gfp_mask =mapping_gfp_mask (inode->i_mapping) & ~__GFP_FS; - gfp_mask |= __GFP_MOVABLE; + gfp_mask = (mapping_gfp_mask (inode->i_mapping) & ~__GFP_FS) | gfp; +
Hum, it seems a bit misleading that the 'gfp' flags are just or-ed tomapping_gfp_mask(inode->i_mapping). Usually, passed gfp mask is just directly used. There are also interfaces like pagecache_get_page() which play more complex tricks with mapping_gfp_mask(). This would be yet another convention which I don't think is desirable. I know Andrew suggested what you wrote so I guess I have to settle this with him. Andrew?
Quoted 50 lines
fs/buffer.c +8
-6/* -* XXX: __getblk_slow() can not really deal with failure and +* XXX: __getblk_gfp() can not really deal with failure and * will endlessly loop on improvised global reclaim. Prefer * looping in the allocator rather than here, at least that * code knows what it's doing. @@ -1058,7 +1058,7 @@ failed:* that page was dirty, the buffers are set dirty also. */ static int -grow_buffers (struct block_device *bdev,sector_t block,int size) +grow_buffers (struct block_device *bdev,sector_t block,int size,gfp_t gfp) {pgoff_t index;int sizebits;@@ -1085,11 +1085,12 @@ grow_buffers(struct block_device *bdev, sector_t block, int size) }/* Create a page with the proper size buffers.. */ -return grow_dev_page (bdev, block, index, size, sizebits); +return grow_dev_page (bdev, block, index, size, sizebits, gfp); } -static struct buffer_head * -__getblk_slow (struct block_device *bdev,sector_t block,int size) +struct buffer_head * +__getblk_gfp (struct block_device *bdev,sector_t block, +unsigned size,gfp_t gfp) {/* Size must be multiple of hard sectorsize */ if (unlikely(size & (bdev_logical_block_size(bdev)-1) ||@@ -1111,13 +1112,14 @@ __getblk_slow(struct block_device *bdev, sector_t block, int size)if (bh)return bh; - ret =grow_buffers (bdev, block, size); + ret =grow_buffers (bdev, block, size, gfp);if (ret <0 )return NULL ;if (ret ==0 )free_more_memory (); } } +EXPORT_SYMBOL (__getblk_gfp);/* * The relationship between dirty buffers and dirty pages: @@ -1381,12 +1383,7 @@ EXPORT_SYMBOL(__find_get_block);struct buffer_head *__getblk (struct block_device *bdev,sector_t block,unsigned size)
fs/buffer.c EXPORT_SYMBOL(__find_get_block); · line 1388
Quoted 10 lines
fs/buffer.c +1
-6{ -struct buffer_head *bh =__find_get_block (bdev, block, size); - -might_sleep (); -if (bh ==NULL ) - bh =__getblk_slow (bdev, block, size); -return bh; +return __getblk_gfp (bdev, block, size, __GFP_MOVABLE); }EXPORT_SYMBOL (__getblk);
Why did you remove the __find_get_block() call? That looks like a bug.
Quoted 64 lines
fs/buffer.c +23
-2@@ -1410,18 +1407,39 @@ EXPORT_SYMBOL(__breadahead);* @size: size (in bytes) to read * * Reads a specified block, and returns buffer head that contains it. +* The page cache is allocated from movable area so that it can be migrated. * It returns NULL if the block was unreadable. */ struct buffer_head *__bread (struct block_device *bdev,sector_t block,unsigned size) { -struct buffer_head *bh =__getblk (bdev, block, size); +return __bread_gfp (bdev, block, size, __GFP_MOVABLE); +} +EXPORT_SYMBOL (__bread); + +/** +* __bread_gfp() - reads a specified block and returns the bh +* @bdev: the block_device to read from +* @block: number of block +* @size: size (in bytes) to read +* @gfp: page allocation flag +* +* Reads a specified block, and returns buffer head that contains it. +* The page cache can be allocated from non-movable area +* not to prevent page migration if you set gfp to zero. +* It returns NULL if the block was unreadable. +*/ +struct buffer_head * +__bread_gfp (struct block_device *bdev,sector_t block, +unsigned size,gfp_t gfp) +{ +struct buffer_head *bh =__getblk_gfp (bdev, block, size, gfp);if (likely (bh) && !buffer_uptodate (bh)) bh =__bread_slow (bh);return bh; } -EXPORT_SYMBOL (__bread); +EXPORT_SYMBOL (__bread_gfp);/* * invalidate_bh_lrus() is called rarely - but not only at unmount. include/linux/buffer_head.h +4
-0@@ -177,10 +177,14 @@ struct buffer_head *__find_get_block(struct block_device *bdev, sector_t block, unsigned size);struct buffer_head *__getblk (struct block_device *bdev,sector_t block,unsigned size); +struct buffer_head *__getblk_gfp (struct block_device *bdev,sector_t block, +unsigned size,gfp_t gfp);void __brelse (struct buffer_head *);void __bforget (struct buffer_head *);void __breadahead (struct block_device *,sector_t block,unsigned int size);struct buffer_head *__bread (struct block_device *,sector_t block,unsigned size); +struct buffer_head *__bread_gfp (struct block_device *, +sector_t block,unsigned size,gfp_t gfp);void invalidate_bh_lrus (void );struct buffer_head *alloc_buffer_head (gfp_t gfp_flags);void free_buffer_head (struct buffer_head * bh);@@ -295,7 +299,13 @@ static inline void bforget(struct buffer_head *bh)static inline struct buffer_head *sb_bread (struct super_block *sb,sector_t block)
include/linux/buffer_head.h static inline void bforget(struct buffer_head *bh) · line 309
Quoted 10 lines
include/linux/buffer_head.h +7
-1{ -return __bread (sb->s_bdev, block, sb->s_blocksize); +return __bread_gfp (sb->s_bdev, block, sb->s_blocksize, __GFP_MOVABLE); +} + +static inline struct buffer_head * +sb_bread_gfp (struct super_block *sb,sector_t block,gfp_t gfp) +{ +return __bread_gfp (sb->s_bdev, block, sb->s_blocksize, gfp); }
I think Andrew was suggesting to provide sb_bread_unmovable() andsb_getblk_unmovable() which would set appropriately. It is then more obvious what are filesystems trying to do when using those functions...
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Re: [PATCHv2 1/3] fs/buffer.c: allocate buffer cache with user specific flag
2014-08-19 오후 10:03, Jan Kara 쓴 글:
Quoted 36 lines
Hello,
Quoted 33 lines · Gioh Kim
A buffer cache is allocated from movable area because it is referred for a while and released soon. But some filesystems are taking buffer cache for a long time and it can disturb page migration.
A new API should be introduced to allocate buffer cache with user specific flag.
For instance if user set flag to zero, buffer cache is allocated from non-movable area.Signed-off-by Gioh Kim <[email protected]>--- fs/buffer.c | 52 +++++++++++++++++++++++++++++-------------- include/linux/buffer_head.h | 12 +++++++++- 2 files changed, 46 insertions(+), 18 deletions(-)fs/buffer.c +1
-1@@ -993,7 +993,7 @@ init_page_buffers(struct page *page, struct block_device *bdev,*/ static int grow_dev_page (struct block_device *bdev,sector_t block, -pgoff_t index,int size,int sizebits) +pgoff_t index,int size,int sizebits,gfp_t gfp) {struct inode *inode = bdev->bd_inode;struct page *page;@@ -1002,10 +1002,10 @@ grow_dev_page(struct block_device *bdev, sector_t block,int ret =0 ;/* Will call free_more_memory() */ gfp_t gfp_mask;
Quoted 10 lines
fs/buffer.c grow_dev_page(struct block_device *bdev, sector_t block, · line 1006
Quoted 4 lines
fs/buffer.c +2
-2- gfp_mask =mapping_gfp_mask (inode->i_mapping) & ~__GFP_FS; - gfp_mask |= __GFP_MOVABLE; + gfp_mask = (mapping_gfp_mask (inode->i_mapping) & ~__GFP_FS) | gfp; +Hum, it seems a bit misleading that the 'gfp' flags are just or-ed to
mapping_gfp_mask(inode->i_mapping). Usually, passed gfp mask is just directly used. There are also interfaces likepagecache_get_page()which play more complex tricks withmapping_gfp_mask(). This would be yet another convention which I don't think is desirable. I know Andrew suggested what you wrote so I guess I have to settle this with him. Andrew?
I don't know mapping_gfp_mask(). I just add gfp at the original code. Whould you tell me why it is undesirable?
Quoted 132 lines
Quoted 51 lines
fs/buffer.c +8
-6/* -* XXX: __getblk_slow() can not really deal with failure and +* XXX: __getblk_gfp() can not really deal with failure and * will endlessly loop on improvised global reclaim. Prefer * looping in the allocator rather than here, at least that * code knows what it's doing. @@ -1058,7 +1058,7 @@ failed:* that page was dirty, the buffers are set dirty also. */ static int -grow_buffers (struct block_device *bdev,sector_t block,int size) +grow_buffers (struct block_device *bdev,sector_t block,int size,gfp_t gfp) {pgoff_t index;int sizebits;@@ -1085,11 +1085,12 @@ grow_buffers(struct block_device *bdev, sector_t block, int size) }/* Create a page with the proper size buffers.. */ -return grow_dev_page (bdev, block, index, size, sizebits); +return grow_dev_page (bdev, block, index, size, sizebits, gfp); } -static struct buffer_head * -__getblk_slow (struct block_device *bdev,sector_t block,int size) +struct buffer_head * +__getblk_gfp (struct block_device *bdev,sector_t block, +unsigned size,gfp_t gfp) {/* Size must be multiple of hard sectorsize */ if (unlikely(size & (bdev_logical_block_size(bdev)-1) ||@@ -1111,13 +1112,14 @@ __getblk_slow(struct block_device *bdev, sector_t block, int size)if (bh)return bh; - ret =grow_buffers (bdev, block, size); + ret =grow_buffers (bdev, block, size, gfp);if (ret <0 )return NULL ;if (ret ==0 )free_more_memory (); } } +EXPORT_SYMBOL (__getblk_gfp);/* * The relationship between dirty buffers and dirty pages: @@ -1381,12 +1383,7 @@ EXPORT_SYMBOL(__find_get_block);struct buffer_head *__getblk (struct block_device *bdev,sector_t block,unsigned size)fs/buffer.c EXPORT_SYMBOL(__find_get_block); · line 1388
Quoted 10 lines
fs/buffer.c +1
-6{ -struct buffer_head *bh =__find_get_block (bdev, block, size); - -might_sleep (); -if (bh ==NULL ) - bh =__getblk_slow (bdev, block, size); -return bh; +return __getblk_gfp (bdev, block, size, __GFP_MOVABLE); }EXPORT_SYMBOL (__getblk);Why did you remove the
__find_get_block()call? That looks like a bug.Quoted 69 lines
fs/buffer.c +23
-2@@ -1410,18 +1407,39 @@ EXPORT_SYMBOL(__breadahead);* @size: size (in bytes) to read * * Reads a specified block, and returns buffer head that contains it. +* The page cache is allocated from movable area so that it can be migrated. * It returns NULL if the block was unreadable. */ struct buffer_head *__bread (struct block_device *bdev,sector_t block,unsigned size) { -struct buffer_head *bh =__getblk (bdev, block, size); +return __bread_gfp (bdev, block, size, __GFP_MOVABLE); +} +EXPORT_SYMBOL (__bread); + +/** +* __bread_gfp() - reads a specified block and returns the bh +* @bdev: the block_device to read from +* @block: number of block +* @size: size (in bytes) to read +* @gfp: page allocation flag +* +* Reads a specified block, and returns buffer head that contains it. +* The page cache can be allocated from non-movable area +* not to prevent page migration if you set gfp to zero. +* It returns NULL if the block was unreadable. +*/ +struct buffer_head * +__bread_gfp (struct block_device *bdev,sector_t block, +unsigned size,gfp_t gfp) +{ +struct buffer_head *bh =__getblk_gfp (bdev, block, size, gfp);if (likely (bh) && !buffer_uptodate (bh)) bh =__bread_slow (bh);return bh; } -EXPORT_SYMBOL (__bread); +EXPORT_SYMBOL (__bread_gfp);/* * invalidate_bh_lrus() is called rarely - but not only at unmount. include/linux/buffer_head.h +7
-1@@ -177,10 +177,14 @@ struct buffer_head *__find_get_block(struct block_device *bdev, sector_t block, unsigned size);struct buffer_head *__getblk (struct block_device *bdev,sector_t block,unsigned size); +struct buffer_head *__getblk_gfp (struct block_device *bdev,sector_t block, +unsigned size,gfp_t gfp);void __brelse (struct buffer_head *);void __bforget (struct buffer_head *);void __breadahead (struct block_device *,sector_t block,unsigned int size);struct buffer_head *__bread (struct block_device *,sector_t block,unsigned size); +struct buffer_head *__bread_gfp (struct block_device *, +sector_t block,unsigned size,gfp_t gfp);void invalidate_bh_lrus (void );struct buffer_head *alloc_buffer_head (gfp_t gfp_flags);void free_buffer_head (struct buffer_head * bh);@@ -295,7 +299,13 @@ static inline void bforget(struct buffer_head *bh)static inline struct buffer_head *sb_bread (struct super_block *sb,sector_t block) { -return __bread (sb->s_bdev, block, sb->s_blocksize); +return __bread_gfp (sb->s_bdev, block, sb->s_blocksize, __GFP_MOVABLE); +} +
Quoted 8 lines
include/linux/buffer_head.h static inline void bforget(struct buffer_head *bh) · line 309
Quoted 5 lines
include/linux/buffer_head.h +4
-0+static inline struct buffer_head * +sb_bread_gfp (struct super_block *sb,sector_t block,gfp_t gfp) +{ +return __bread_gfp (sb->s_bdev, block, sb->s_blocksize, gfp); }I think Andrew was suggesting to provide
sb_bread_unmovable()andsb_getblk_unmovable()which would set appropriately. It is then more obvious what are filesystems trying to do when using those functions...
I think the common interface is important.
If sb_getblk_unmovable() is obvious for the filesystem,
I will add some codes for getblk_unmovable() which calling __getblk_gfp(), and sb_bread_unmovable() calling __bread_gfp().
If so, sb_bread_gfp is not necessary.
It might be like followings:
fs/buffer.c +8 -2
@@ -1088,7 +1088,7 @@ grow_buffers(struct block_device *bdev, sector_t block, int sizreturn grow_dev_page (bdev, block, index, size, sizebits, gfp); } -struct buffer_head * +static struct buffer_head *__getblk_gfp (struct block_device *bdev,sector_t block,unsigned size,gfp_t gfp) {
@@ -1119,7 +1119,13 @@ __getblk_gfp(struct block_device *bdev, sector_t block,free_more_memory (); } } -EXPORT_SYMBOL (__getblk_gfp); + +struct buffer_head *getblk_unmovable (struct block_device *bdev,sector_t block, +unsigned size) +{ +return __getblk_gfp (bdev, block, size,0 ); +} +EXPORT_SYMBOL (getblk_unmovable);/* * The relationship between dirty buffers and dirty pages:
include/linux/buffer_head.h +4 -4
@@ -177,8 +177,8 @@ struct buffer_head *__find_get_block(struct block_device *bdev, s unsigned size);struct buffer_head *__getblk (struct block_device *bdev,sector_t block,unsigned size); -struct buffer_head *__getblk_gfp (struct block_device *bdev,sector_t block, -unsigned size,gfp_t gfp); +struct buffer_head *getblk_unmovable (struct block_device *bdev,sector_t block, +unsigned size);void __brelse (struct buffer_head *);void __bforget (struct buffer_head *);void __breadahead (struct block_device *,sector_t block,unsigned int size);
@@ -303,9 +303,9 @@ sb_bread(struct super_block *sb, sector_t block) }static inline struct buffer_head * -sb_bread_gfp (struct super_block *sb,sector_t block,gfp_t gfp) +sb_bread_unmovable (struct super_block *sb,sector_t block) { -return __bread_gfp (sb->s_bdev, block, sb->s_blocksize, gfp); +return __bread_gfp (sb->s_bdev, block, sb->s_blocksize,0 ); } static inline void
Is it better?
Thank you for your advice.
--
To unsubscribe from this list: send the line "unsubscribe linux-ext4" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Jan Kara
reviewerRe: [PATCHv2 1/3] fs/buffer.c: allocate buffer cache with user specific flag
Quoted 50 lines · Gioh Kim
2014-08-19 오후 10:03, Jan Kara 쓴 글:
Quoted 36 lines
Hello,
Quoted 33 lines · Gioh Kim
A buffer cache is allocated from movable area because it is referred for a while and released soon. But some filesystems are taking buffer cache for a long time and it can disturb page migration.
A new API should be introduced to allocate buffer cache with user specific flag.
For instance if user set flag to zero, buffer cache is allocated from non-movable area.Signed-off-by Gioh Kim <[email protected]>--- fs/buffer.c | 52 +++++++++++++++++++++++++++++-------------- include/linux/buffer_head.h | 12 +++++++++- 2 files changed, 46 insertions(+), 18 deletions(-)fs/buffer.c +1
-1@@ -993,7 +993,7 @@ init_page_buffers(struct page *page, struct block_device *bdev,*/ static int grow_dev_page (struct block_device *bdev,sector_t block, -pgoff_t index,int size,int sizebits) +pgoff_t index,int size,int sizebits,gfp_t gfp) {struct inode *inode = bdev->bd_inode;struct page *page;@@ -1002,10 +1002,10 @@ grow_dev_page(struct block_device *bdev, sector_t block,int ret =0 ;/* Will call free_more_memory() */ gfp_t gfp_mask;Quoted 10 lines
fs/buffer.c grow_dev_page(struct block_device *bdev, sector_t block, · line 1006
Quoted 4 lines
fs/buffer.c +2
-2- gfp_mask =mapping_gfp_mask (inode->i_mapping) & ~__GFP_FS; - gfp_mask |= __GFP_MOVABLE; + gfp_mask = (mapping_gfp_mask (inode->i_mapping) & ~__GFP_FS) | gfp; +Hum, it seems a bit misleading that the 'gfp' flags are just or-ed to
mapping_gfp_mask(inode->i_mapping). Usually, passed gfp mask is just directly used. There are also interfaces likepagecache_get_page()which play more complex tricks withmapping_gfp_mask(). This would be yet another convention which I don't think is desirable. I know Andrew suggested what you wrote so I guess I have to settle this with him. Andrew?
Quoted 2 lines
I don't know
mapping_gfp_mask(). I just add gfp at the original code. Whould you tell me why it is undesirable?
Well, it's not that mapping_gfp_mask() would be undesirable. It's that
the interface where you pass in gfp mask but it gets silently combined with another gfp mask seems a bit error prone to me. So would prefer grow_dev_page() to just use the gfp mask passed and then do something like:
struct buffer_head *getblk_unmovable(struct block_device *bdev, sector_t block,
unsigned size)
{
return __getblk_gfp(bdev, block, size,
mapping_gfp_mask(bdev->bd_inode->i_mapping));
}
And similarly in getblk() and other places. But before you go and do this, I'd like Andrew to say what he thinks about it because maybe he had a good reason why he wanted it the way you've implemented it.
Quoted 6 lines
Quoted 6 lines
Quoted 6 lines
fs/buffer.c +0
-2@@ -1381,12 +1383,7 @@ EXPORT_SYMBOL(__find_get_block);struct buffer_head *__getblk (struct block_device *bdev,sector_t block,unsigned size) { -struct buffer_head *bh =__find_get_block (bdev, block, size); -
Quoted 8 lines
Quoted 8 lines
fs/buffer.c EXPORT_SYMBOL(__find_get_block); · line 1388
Quoted 7 lines
fs/buffer.c +1
-4-might_sleep (); -if (bh ==NULL ) - bh =__getblk_slow (bdev, block, size); -return bh; +return __getblk_gfp (bdev, block, size, __GFP_MOVABLE); }EXPORT_SYMBOL (__getblk);Why did you remove the
__find_get_block()call? That looks like a bug.
I'm not sure if you didn't miss this comment....
Quoted 63 lines
I think the common interface is important.
If
sb_getblk_unmovable()is obvious for the filesystem,
I will add some codes forgetblk_unmovable()which calling__getblk_gfp(), andsb_bread_unmovable()calling__bread_gfp().
If so,sb_bread_gfpis not necessary.It might be like followings:
fs/buffer.c +8
-2@@ -1088,7 +1088,7 @@ grow_buffers(struct block_device *bdev, sector_t block, int sizreturn grow_dev_page (bdev, block, index, size, sizebits, gfp); } -struct buffer_head * +static struct buffer_head *__getblk_gfp (struct block_device *bdev,sector_t block,unsigned size,gfp_t gfp) {@@ -1119,7 +1119,13 @@ __getblk_gfp(struct block_device *bdev, sector_t block,free_more_memory (); } } -EXPORT_SYMBOL (__getblk_gfp); + +struct buffer_head *getblk_unmovable (struct block_device *bdev,sector_t block, +unsigned size) +{ +return __getblk_gfp (bdev, block, size,0 ); +} +EXPORT_SYMBOL (getblk_unmovable);/* * The relationship between dirty buffers and dirty pages: include/linux/buffer_head.h +4
-4@@ -177,8 +177,8 @@ struct buffer_head *__find_get_block(struct block_device *bdev, s unsigned size);struct buffer_head *__getblk (struct block_device *bdev,sector_t block,unsigned size); -struct buffer_head *__getblk_gfp (struct block_device *bdev,sector_t block, -unsigned size,gfp_t gfp); +struct buffer_head *getblk_unmovable (struct block_device *bdev,sector_t block, +unsigned size);void __brelse (struct buffer_head *);void __bforget (struct buffer_head *);void __breadahead (struct block_device *,sector_t block,unsigned int size);@@ -303,9 +303,9 @@ sb_bread(struct super_block *sb, sector_t block) }static inline struct buffer_head * -sb_bread_gfp (struct super_block *sb,sector_t block,gfp_t gfp) +sb_bread_unmovable (struct super_block *sb,sector_t block) { -return __bread_gfp (sb->s_bdev, block, sb->s_blocksize, gfp); +return __bread_gfp (sb->s_bdev, block, sb->s_blocksize,0 ); }
Quoted 1 line
Is it better?
Yes, this is what I meant.
Honza
Signature · 6 lines
Jan Kara <[email protected]> SUSE Labs, CR -- To unsubscribe from this list: send the line "unsubscribe linux-ext4" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
Re: [PATCHv2 1/3] fs/buffer.c: allocate buffer cache with user specific flag
Quoted 15 lines
Quoted 15 lines
Quoted 15 lines
Quoted 4 lines
(quoted diff) +0
-0@@ -1381,12 +1383,7 @@ EXPORT_SYMBOL(__find_get_block); struct buffer_head * __getblk(struct block_device *bdev, sector_t block, unsigned size)Review EXPORT_SYMBOL(__find_get_block); · line 1388
Quoted 10 lines
(quoted diff) +1
-6{ - struct buffer_head *bh = __find_get_block(bdev, block, size); - - might_sleep(); - if (bh == NULL) - bh = __getblk_slow(bdev, block, size); - return bh; + return __getblk_gfp(bdev, block, size, __GFP_MOVABLE); } EXPORT_SYMBOL(__getblk);Why did you remove the
__find_get_block()call? That looks like a bug.
Quoted 1 line
I'm not sure if you didn't miss this comment....
I'm sorry I missed it.
I think calling __find_get_block() in __getblk_gfp() can replace it. I'm not sure about it.
If anybody disagree with it, I'll change it as the original code.
Jan Kara
reviewerRe: [PATCHv2 1/3] fs/buffer.c: allocate buffer cache with user specific flag
Quoted 15 lines · Gioh Kim
Quoted 15 lines
Quoted 15 lines
Quoted 15 lines
Quoted 4 lines
(quoted diff) +0
-0@@ -1381,12 +1383,7 @@ EXPORT_SYMBOL(__find_get_block); struct buffer_head * __getblk(struct block_device *bdev, sector_t block, unsigned size)Review EXPORT_SYMBOL(__find_get_block); · line 1388
Quoted 10 lines
(quoted diff) +1
-6{ - struct buffer_head *bh = __find_get_block(bdev, block, size); - - might_sleep(); - if (bh == NULL) - bh = __getblk_slow(bdev, block, size); - return bh; + return __getblk_gfp(bdev, block, size, __GFP_MOVABLE); } EXPORT_SYMBOL(__getblk);Why did you remove the
__find_get_block()call? That looks like a bug.
Quoted 7 lines
Quoted 1 line
I'm not sure if you didn't miss this comment....
I'm sorry I missed it.
I think calling__find_get_block()in__getblk_gfp()can replace it. I'm not sure about it.If anybody disagree with it, I'll change it as the original code.
OK, I see. Thanks for explanation. I agree we can remove__find_get_block() from __getblk() but please make this change a separate patch and also please put the might_sleep() check __getblk_gfp().
Honza
Signature · 2 lines
Jan Kara <[email protected]> SUSE Labs, CR
Re: [PATCHv2 1/3] fs/buffer.c: allocate buffer cache with user specific flag
2014-08-21 오전 7:02, Jan Kara 쓴 글:
Quoted 22 lines · Gioh Kim
Quoted 21 lines
Quoted 15 lines
Quoted 15 lines
Quoted 15 lines
Quoted 4 lines
(quoted diff) +0
-0@@ -1381,12 +1383,7 @@ EXPORT_SYMBOL(__find_get_block); struct buffer_head * __getblk(struct block_device *bdev, sector_t block, unsigned size)Review EXPORT_SYMBOL(__find_get_block); · line 1388
Quoted 10 lines
(quoted diff) +1
-6{ - struct buffer_head *bh = __find_get_block(bdev, block, size); - - might_sleep(); - if (bh == NULL) - bh = __getblk_slow(bdev, block, size); - return bh; + return __getblk_gfp(bdev, block, size, __GFP_MOVABLE); } EXPORT_SYMBOL(__getblk);Why did you remove the
__find_get_block()call? That looks like a bug.Quoted 1 line
I'm not sure if you didn't miss this comment....
I'm sorry I missed it.
I think calling__find_get_block()in__getblk_gfp()can replace it. I'm not sure about it.
Quoted 7 lines
Quoted 1 line
If anybody disagree with it, I'll change it as the original code.
OK, I see. Thanks for explanation. I agree we can remove
__find_get_block()from__getblk()but please make this change a separate patch and also please put themight_sleep()check__getblk_gfp().Honza
I got it.
I'm going to report v3 patch that reverts __getblk() and adds sb_bread_unmovable(), if Andrew give me a feedback about the other codes.
I can wait ;-)
--
To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html