gfs2 iomap write support
Subsystems (2)
Andreas Gruenbacher
maintainerv10 cover gfs2 iomap write support
Here's another update of my gfs2 iomap write patches on top of:
git://git.infradead.org/users/hch/xfs.git gfs2-iomap
Changes since v9:
* Some more gfs2 iomap cleanups.
* Incorporate some feedback from Christoph.
Changes since v8:
* Rebase on top of Christoph's branch.
* New patch to add private pointer to struct iomap.
Changes since v7:
* Drop patch that allows to unconditionally mark the inode dirty in __generic_write_end and mark the inode dirty in iomap_write_inline_data instead.
* Call the page_write_end hook even for IOMAP_INLINE mappings.
* Drop patch "iomap: Put struct iomap_ops into struct iomap".
Significant changes since v6:
* Switch to Christoph's patch for splitting out __generic_write_end and put the inode-dirtying change in a separate commit.
* Switch froma mandatory write_end operation to an optional page_write_end hook.
* Add a patch to pass struct iomap_ops in struct iomap at the end for demonstration purposes.
Significant changes since v5:
* Initial gfs2 specific cleanups split off and posted separately.
* New patch for generic iomap inline data handling.
* Iomap write_begin operation removed.
These patches can be found here:
https://git.kernel.org/pub/scm/linux/kernel/git/gfs2/linux-gfs2.git/log/?h=iomap-write
Thanks,
Andreas
Andreas Gruenbacher (5):
gfs2: Further iomap cleanups
gfs2: iomap buffered write support
gfs2: gfs2_extent_length cleanup
gfs2: iomap direct I/O support
gfs2: Remove gfs2_write_{begin,end}
fs/gfs2/aops.c | 331 ++--------------------------------------- fs/gfs2/aops.h | 19 +++ fs/gfs2/bmap.c | 394 ++++++++++++++++++++++++++++++++++++++++--------- fs/gfs2/file.c | 166 +++++++++++++++++++-- 4 files changed, 510 insertions(+), 400 deletions(-) create mode 100644 fs/gfs2/aops.h
Signature · 1 line
2.17.1
Andreas Gruenbacher
maintainerPATCH v10 1/5 gfs2: Further iomap cleanups
In gfs2_iomap_alloc, set the type of newly allocated extents to IOMAP_MAPPED so that iomap_to_bh will set the bh states correctly:
otherwise, the bhs would not be marked as mapped, confusing __mpage_writepage. This means that we need to check for the IOMAP_F_NEW flag in fallocate_chunk now.
Further clean up gfs2_iomap_get and implement gfs2_stuffed_iomap here directly. For reads beyond the end of the file, return holes instead of failing with -ENOENT so that we can get rid of that special case in gfs2_block_map.
--- fs/gfs2/bmap.c | 74 ++++++++++++++++++++++++++++---------------------- fs/gfs2/file.c | 2 +- 2 files changed, 43 insertions(+), 33 deletions(-)
fs/gfs2/bmap.c +42 -32
@@ -750,6 +750,7 @@ static int gfs2_iomap_alloc(struct inode *inode, struct iomap *iomap, } }while (iomap->addr ==IOMAP_NULL_ADDR ); + iomap->type =IOMAP_MAPPED ; iomap->length = (u64 )dblks << inode->i_blkbits; ip->i_height = mp->mp_fheight;gfs2_add_inode_blocks (&ip->i_inode, alloced);
@@ -759,17 +760,6 @@ static int gfs2_iomap_alloc(struct inode *inode, struct iomap *iomap,return ret; } -static void gfs2_stuffed_iomap (struct inode *inode,struct iomap *iomap) -{ -struct gfs2_inode *ip =GFS2_I (inode); - - iomap->addr = (ip->i_no_addr << inode->i_blkbits) + -sizeof (struct gfs2_dinode ); - iomap->offset =0 ; - iomap->length =i_size_read (inode); - iomap->type =IOMAP_INLINE ; -} -#define IOMAP_F_GFS2_BOUNDARY IOMAP_F_PRIVATE/**
@@ -789,37 +779,61 @@ static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length, {struct gfs2_inode *ip =GFS2_I (inode);struct gfs2_sbd *sdp =GFS2_SB (inode); +loff_t size =i_size_read (inode);__be64 *ptr;sector_t lblock;sector_t lblock_stop;int ret;int eob;u64 len; -struct buffer_head *bh; +struct buffer_head *dibh, *bh;u8 height;if (!length)return -EINVAL ; +down_read (&ip->i_rw_mutex); + + ret =gfs2_meta_inode_buffer (ip, &dibh); +if (ret) + goto unlock; +if (gfs2_is_stuffed (ip)) { -if (flags &IOMAP_REPORT ) { -if (pos >=i_size_read (inode)) -return -ENOENT ; -gfs2_stuffed_iomap (inode, iomap); -return 0 ; +if (flags &IOMAP_WRITE ) { +loff_t max_size =gfs2_max_stuffed_size (ip); + +if (pos + length > max_size) + goto unstuff; + iomap->length = max_size; + }else { +if (pos >= size) { +if (flags &IOMAP_REPORT ) { + ret = -ENOENT ; + goto unlock; + }else { +/* report a hole */ + iomap->offset = pos; + iomap->length = length; + goto do_alloc; + } + } + iomap->length = size; } -BUG_ON (!(flags &IOMAP_WRITE )); + iomap->addr = (ip->i_no_addr << inode->i_blkbits) + +sizeof (struct gfs2_dinode ); + iomap->type =IOMAP_INLINE ; + goto unlock; } + +unstuff: lblock = pos >> inode->i_blkbits; iomap->offset = lblock << inode->i_blkbits; lblock_stop = (pos + length -1 ) >> inode->i_blkbits; len = lblock_stop - lblock +1 ; + iomap->length = len << inode->i_blkbits; -down_read (&ip->i_rw_mutex); - - ret =gfs2_meta_inode_buffer (ip, &mp->mp_bh[0 ]); -if (ret) - goto unlock; +get_bh (dibh); + mp->mp_bh[0 ] = dibh; height = ip->i_height;while ((lblock +1 ) * sdp->sd_sb.sb_bsize > sdp->sd_heightsize[height])
@@ -853,21 +867,23 @@ static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length, iomap->bdev = inode->i_sb->s_bdev; unlock:up_read (&ip->i_rw_mutex); +if (dibh) +brelse (dibh);return ret; do_alloc: iomap->addr =IOMAP_NULL_ADDR ; - iomap->length = len << inode->i_blkbits; iomap->type =IOMAP_HOLE ; - iomap->flags =0 ;if (flags &IOMAP_REPORT ) { -loff_t size =i_size_read (inode);if (pos >= size) ret = -ENOENT ;else if (height == ip->i_height) ret =gfs2_hole_size (inode, lblock, len, mp, iomap);else iomap->length = size - pos; + }else if (!(flags &IOMAP_WRITE )) { +if (pos < size && height == ip->i_height) + ret =gfs2_hole_size (inode, lblock, len, mp, iomap); } goto out; }
@@ -941,12 +957,6 @@ int gfs2_block_map(struct inode *inode, sector_t lblock, }else { ret =gfs2_iomap_get (inode, pos, length,0 , &iomap, &mp);release_metapath (&mp); - -/* Return unmapped buffer beyond the end of file. */ -if (ret == -ENOENT ) { - ret =0 ; - goto out; - } }if (ret) goto out;
fs/gfs2/file.c +1 -1
@@ -754,7 +754,7 @@ static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len,if (error) goto out; offset = iomap.offset + iomap.length; -if (iomap.type !=IOMAP_HOLE ) +if (!(iomap.flags &IOMAP_F_NEW ))continue ; error = sb_issue_zeroout(sb, iomap.addr >> inode->i_blkbits, iomap.length >> inode->i_blkbits,
Signature · 1 line
2.17.1
Andreas Gruenbacher
maintainerRe: [PATCH v10 1/5] gfs2: Further iomap cleanups
Quoted 50 lines · Andreas Gruenbacher
In
gfs2_iomap_alloc, set the type of newly allocated extents toIOMAP_MAPPEDso thatiomap_to_bhwill set the bh states correctly:
otherwise, the bhs would not be marked as mapped, confusing__mpage_writepage. This means that we need to check for theIOMAP_F_NEWflag infallocate_chunknow.Further clean up
gfs2_iomap_getand implementgfs2_stuffed_iomaphere directly. For reads beyond the end of the file, return holes instead of failing with-ENOENTso that we can get rid of that special case ingfs2_block_map.Signed-off-by Andreas Gruenbacher <[email protected]>--- fs/gfs2/bmap.c | 74 ++++++++++++++++++++++++++++---------------------- fs/gfs2/file.c | 2 +- 2 files changed, 43 insertions(+), 33 deletions(-)fs/gfs2/bmap.c +1
-11@@ -750,6 +750,7 @@ static int gfs2_iomap_alloc(struct inode *inode, struct iomap *iomap, } }while (iomap->addr ==IOMAP_NULL_ADDR ); + iomap->type =IOMAP_MAPPED ; iomap->length = (u64 )dblks << inode->i_blkbits; ip->i_height = mp->mp_fheight;gfs2_add_inode_blocks (&ip->i_inode, alloced);@@ -759,17 +760,6 @@ static int gfs2_iomap_alloc(struct inode *inode, struct iomap *iomap,return ret; } -static void gfs2_stuffed_iomap (struct inode *inode,struct iomap *iomap) -{ -struct gfs2_inode *ip =GFS2_I (inode); - - iomap->addr = (ip->i_no_addr << inode->i_blkbits) + -sizeof (struct gfs2_dinode ); - iomap->offset =0 ; - iomap->length =i_size_read (inode); - iomap->type =IOMAP_INLINE ; -} -#define IOMAP_F_GFS2_BOUNDARY IOMAP_F_PRIVATE/** @@ -789,37 +779,61 @@ static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length, {struct gfs2_inode *ip =GFS2_I (inode);
fs/gfs2/bmap.c static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length, · line 789
Quoted 10 lines
fs/gfs2/bmap.c +2
-1struct gfs2_sbd *sdp =GFS2_SB (inode); +loff_t size =i_size_read (inode);__be64 *ptr;sector_t lblock;sector_t lblock_stop;int ret;int eob;u64 len; -struct buffer_head *bh; +struct buffer_head *dibh, *bh;
This should be:
+ struct buffer_head *dibh = NULL, *bh;
Quoted 115 lines
fs/gfs2/bmap.c +39
-20u8 height;if (!length)return -EINVAL ; +down_read (&ip->i_rw_mutex); + + ret =gfs2_meta_inode_buffer (ip, &dibh); +if (ret) + goto unlock; +if (gfs2_is_stuffed (ip)) { -if (flags &IOMAP_REPORT ) { -if (pos >=i_size_read (inode)) -return -ENOENT ; -gfs2_stuffed_iomap (inode, iomap); -return 0 ; +if (flags &IOMAP_WRITE ) { +loff_t max_size =gfs2_max_stuffed_size (ip); + +if (pos + length > max_size) + goto unstuff; + iomap->length = max_size; + }else { +if (pos >= size) { +if (flags &IOMAP_REPORT ) { + ret = -ENOENT ; + goto unlock; + }else { +/* report a hole */ + iomap->offset = pos; + iomap->length = length; + goto do_alloc; + } + } + iomap->length = size; } -BUG_ON (!(flags &IOMAP_WRITE )); + iomap->addr = (ip->i_no_addr << inode->i_blkbits) + +sizeof (struct gfs2_dinode ); + iomap->type =IOMAP_INLINE ; + goto unlock; } + +unstuff: lblock = pos >> inode->i_blkbits; iomap->offset = lblock << inode->i_blkbits; lblock_stop = (pos + length -1 ) >> inode->i_blkbits; len = lblock_stop - lblock +1 ; + iomap->length = len << inode->i_blkbits; -down_read (&ip->i_rw_mutex); - - ret =gfs2_meta_inode_buffer (ip, &mp->mp_bh[0 ]); -if (ret) - goto unlock; +get_bh (dibh); + mp->mp_bh[0 ] = dibh; height = ip->i_height;while ((lblock +1 ) * sdp->sd_sb.sb_bsize > sdp->sd_heightsize[height])@@ -853,21 +867,23 @@ static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length, iomap->bdev = inode->i_sb->s_bdev; unlock:up_read (&ip->i_rw_mutex); +if (dibh) +brelse (dibh);return ret; do_alloc: iomap->addr =IOMAP_NULL_ADDR ; - iomap->length = len << inode->i_blkbits; iomap->type =IOMAP_HOLE ; - iomap->flags =0 ;if (flags &IOMAP_REPORT ) { -loff_t size =i_size_read (inode);if (pos >= size) ret = -ENOENT ;else if (height == ip->i_height) ret =gfs2_hole_size (inode, lblock, len, mp, iomap);else iomap->length = size - pos; + }else if (!(flags &IOMAP_WRITE )) { +if (pos < size && height == ip->i_height) + ret =gfs2_hole_size (inode, lblock, len, mp, iomap); } goto out; }@@ -941,12 +957,6 @@ int gfs2_block_map(struct inode *inode, sector_t lblock, }else { ret =gfs2_iomap_get (inode, pos, length,0 , &iomap, &mp);release_metapath (&mp); - -/* Return unmapped buffer beyond the end of file. */ -if (ret == -ENOENT ) { - ret =0 ; - goto out; - } }if (ret) goto out;fs/gfs2/file.c +1
-2@@ -754,7 +754,7 @@ static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len,if (error) goto out; offset = iomap.offset + iomap.length; -if (iomap.type !=IOMAP_HOLE ) +if (!(iomap.flags &IOMAP_F_NEW ))continue ; error = sb_issue_zeroout(sb, iomap.addr >> inode->i_blkbits, iomap.length >> inode->i_blkbits, --
Quoted 2 lines
2.17.1
Andreas
Andreas Gruenbacher
maintainerRe: [PATCH v10 1/5] gfs2: Further iomap cleanups
In reply to Andreas GruenbacherQuoted 92 lines · Andreas Gruenbacher
In
gfs2_iomap_alloc, set the type of newly allocated extents toIOMAP_MAPPEDso thatiomap_to_bhwill set the bh states correctly:
otherwise, the bhs would not be marked as mapped, confusing__mpage_writepage. This means that we need to check for theIOMAP_F_NEWflag infallocate_chunknow.Further clean up
gfs2_iomap_getand implementgfs2_stuffed_iomaphere directly. For reads beyond the end of the file, return holes instead of failing with-ENOENTso that we can get rid of that special case ingfs2_block_map.Signed-off-by Andreas Gruenbacher <[email protected]>--- fs/gfs2/bmap.c | 74 ++++++++++++++++++++++++++++---------------------- fs/gfs2/file.c | 2 +- 2 files changed, 43 insertions(+), 33 deletions(-)fs/gfs2/bmap.c +24
-17@@ -750,6 +750,7 @@ static int gfs2_iomap_alloc(struct inode *inode, struct iomap *iomap, } }while (iomap->addr ==IOMAP_NULL_ADDR ); + iomap->type =IOMAP_MAPPED ; iomap->length = (u64 )dblks << inode->i_blkbits; ip->i_height = mp->mp_fheight;gfs2_add_inode_blocks (&ip->i_inode, alloced);@@ -759,17 +760,6 @@ static int gfs2_iomap_alloc(struct inode *inode, struct iomap *iomap,return ret; } -static void gfs2_stuffed_iomap (struct inode *inode,struct iomap *iomap) -{ -struct gfs2_inode *ip =GFS2_I (inode); - - iomap->addr = (ip->i_no_addr << inode->i_blkbits) + -sizeof (struct gfs2_dinode ); - iomap->offset =0 ; - iomap->length =i_size_read (inode); - iomap->type =IOMAP_INLINE ; -} -#define IOMAP_F_GFS2_BOUNDARY IOMAP_F_PRIVATE/** @@ -789,37 +779,61 @@ static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length, {struct gfs2_inode *ip =GFS2_I (inode);struct gfs2_sbd *sdp =GFS2_SB (inode); +loff_t size =i_size_read (inode);__be64 *ptr;sector_t lblock;sector_t lblock_stop;int ret;int eob;u64 len; -struct buffer_head *bh; +struct buffer_head *dibh, *bh;u8 height;if (!length)return -EINVAL ; +down_read (&ip->i_rw_mutex); + + ret =gfs2_meta_inode_buffer (ip, &dibh); +if (ret) + goto unlock; +if (gfs2_is_stuffed (ip)) { -if (flags &IOMAP_REPORT ) { -if (pos >=i_size_read (inode)) -return -ENOENT ; -gfs2_stuffed_iomap (inode, iomap); -return 0 ; +if (flags &IOMAP_WRITE ) { +loff_t max_size =gfs2_max_stuffed_size (ip); + +if (pos + length > max_size) + goto unstuff; + iomap->length = max_size; + }else { +if (pos >= size) { +if (flags &IOMAP_REPORT ) { + ret = -ENOENT ; + goto unlock; + }else { +/* report a hole */ + iomap->offset = pos; + iomap->length = length;
fs/gfs2/bmap.c static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length, · line 825
Quoted 10 lines
fs/gfs2/bmap.c +8
-1+ goto do_alloc; + } + } + iomap->length = size; } -BUG_ON (!(flags &IOMAP_WRITE )); + iomap->addr = (ip->i_no_addr << inode->i_blkbits) + +sizeof (struct gfs2_dinode ); + iomap->type =IOMAP_INLINE ; + goto unlock;
To get things right even with the "iomap: direct I/O for inline data" patch just posted, we want to change the above to "goto out".
Quoted 73 lines
fs/gfs2/bmap.c +10
-14} + +unstuff: lblock = pos >> inode->i_blkbits; iomap->offset = lblock << inode->i_blkbits; lblock_stop = (pos + length -1 ) >> inode->i_blkbits; len = lblock_stop - lblock +1 ; + iomap->length = len << inode->i_blkbits; -down_read (&ip->i_rw_mutex); - - ret =gfs2_meta_inode_buffer (ip, &mp->mp_bh[0 ]); -if (ret) - goto unlock; +get_bh (dibh); + mp->mp_bh[0 ] = dibh; height = ip->i_height;while ((lblock +1 ) * sdp->sd_sb.sb_bsize > sdp->sd_heightsize[height])@@ -853,21 +867,23 @@ static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length, iomap->bdev = inode->i_sb->s_bdev; unlock:up_read (&ip->i_rw_mutex); +if (dibh) +brelse (dibh);return ret; do_alloc: iomap->addr =IOMAP_NULL_ADDR ; - iomap->length = len << inode->i_blkbits; iomap->type =IOMAP_HOLE ; - iomap->flags =0 ;if (flags &IOMAP_REPORT ) { -loff_t size =i_size_read (inode);if (pos >= size) ret = -ENOENT ;else if (height == ip->i_height) ret =gfs2_hole_size (inode, lblock, len, mp, iomap);else iomap->length = size - pos; + }else if (!(flags &IOMAP_WRITE )) { +if (pos < size && height == ip->i_height) + ret =gfs2_hole_size (inode, lblock, len, mp, iomap); } goto out; }@@ -941,12 +957,6 @@ int gfs2_block_map(struct inode *inode, sector_t lblock, }else { ret =gfs2_iomap_get (inode, pos, length,0 , &iomap, &mp);release_metapath (&mp); - -/* Return unmapped buffer beyond the end of file. */ -if (ret == -ENOENT ) { - ret =0 ; - goto out; - } }if (ret) goto out;fs/gfs2/file.c +1
-2@@ -754,7 +754,7 @@ static int fallocate_chunk(struct inode *inode, loff_t offset, loff_t len,if (error) goto out; offset = iomap.offset + iomap.length; -if (iomap.type !=IOMAP_HOLE ) +if (!(iomap.flags &IOMAP_F_NEW ))continue ; error = sb_issue_zeroout(sb, iomap.addr >> inode->i_blkbits, iomap.length >> inode->i_blkbits, --
Quoted 2 lines
2.17.1
Andreas
Andreas Gruenbacher
maintainerPATCH v10 2/5 gfs2: iomap buffered write support
In reply to Andreas GruenbacherWith the traditional page-based writes, blocks are allocated separately for each page written to. With iomap writes, we can allocate a lot more blocks at once, with a fraction of the allocation overhead for each page.
Split calculating the number of blocks that can be allocated at a given position (gfs2_alloc_size) off from gfs2_iomap_alloc: that size determines the number of blocks to allocate and reserve in the journal.
--- fs/gfs2/aops.c | 20 ++-- fs/gfs2/aops.h | 19 ++++ fs/gfs2/bmap.c | 298 ++++++++++++++++++++++++++++++++++++++++++++----- fs/gfs2/file.c | 44 +++++++- 4 files changed, 338 insertions(+), 43 deletions(-) create mode 100644 fs/gfs2/aops.h
fs/gfs2/aops.c +11 -9
@@ -22,6 +22,7 @@#include <linux/backing-dev.h> #include <linux/uio.h> #include <trace/events/writeback.h> +#include <linux/sched/signal.h> #include "gfs2.h" #include "incore.h"
@@ -36,10 +37,11 @@#include "super.h" #include "util.h" #include "glops.h" +#include "aops.h" -static void gfs2_page_add_databufs (struct gfs2_inode *ip,struct page *page, -unsigned int from,unsigned int len) +void gfs2_page_add_databufs (struct gfs2_inode *ip,struct page *page, +unsigned int from,unsigned int len) {struct buffer_head *head =page_buffers (page);unsigned int bsize = head->b_size;
@@ -462,7 +464,7 @@ static int gfs2_jdata_writepages(struct address_space *mapping,* Returns: errno */ -static int stuffed_readpage (struct gfs2_inode *ip,struct page *page) +int stuffed_readpage (struct gfs2_inode *ip,struct page *page) {struct buffer_head *dibh;u64 dsize =i_size_read (&ip->i_inode);
@@ -776,7 +778,7 @@ static int gfs2_write_begin(struct file *file, struct address_space *mapping,* adjust_fs_space - Adjusts the free space available due to gfs2_grow * @inode: the rindex inode */ -static void adjust_fs_space (struct inode *inode) +void adjust_fs_space (struct inode *inode) {struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;struct gfs2_inode *m_ip =GFS2_I (sdp->sd_statfs_inode);
@@ -822,11 +824,11 @@ static void adjust_fs_space(struct inode *inode)* This copies the data from the page into the inode block after * the inode data structure itself. * -* Returns: errno +* Returns: copied bytes or errno */ -static int gfs2_stuffed_write_end (struct inode *inode,struct buffer_head *dibh, -loff_t pos,unsigned copied, -struct page *page) +int gfs2_stuffed_write_end (struct inode *inode,struct buffer_head *dibh, +loff_t pos,unsigned copied, +struct page *page) {struct gfs2_inode *ip =GFS2_I (inode);u64 to = pos + copied;
@@ -865,7 +867,7 @@ static int gfs2_stuffed_write_end(struct inode *inode, struct buffer_head *dibh,* The main write_end function for GFS2. We just put our locking around the VFS * provided functions. * -* Returns: errno +* Returns: copied bytes or errno */ static int gfs2_write_end(struct file *file, struct address_space *mapping,
fs/gfs2/aops.h new file +19 -0
@@ -0,0 +1,19 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* +* Copyright (C) 2018 Red Hat, Inc. All rights reserved. +*/ + +#ifndef __AOPS_DOT_H__ +#define __AOPS_DOT_H__ + +#include "incore.h" + +extern int stuffed_readpage (struct gfs2_inode *ip,struct page *page); +extern int gfs2_stuffed_write_end (struct inode *inode,struct buffer_head *dibh, +loff_t pos,unsigned copied, +struct page *page); +extern void adjust_fs_space (struct inode *inode); +extern void gfs2_page_add_databufs (struct gfs2_inode *ip,struct page *page, +unsigned int from,unsigned int len); + +#endif /* __AOPS_DOT_H__ */
fs/gfs2/bmap.c +270 -28
401 lines not on this page · raw message
fs/gfs2/file.c +38 -6
72 lines not on this page · raw message
Signature · 1 line
2.17.1
Andreas Gruenbacher
maintainerPATCH v10 3/5 gfs2: gfs2_extent_length cleanup
In reply to Andreas GruenbacherNow that gfs2_extent_length is no longer used for determining the size of a hole and always with an upper size limit, the function can be simplified.
--- fs/gfs2/bmap.c | 24 ++++++++---------------- 1 file changed, 8 insertions(+), 16 deletions(-)
fs/gfs2/bmap.c +8 -16
@@ -406,22 +406,17 @@ static void release_metapath(struct metapath *mp)/** * gfs2_extent_length - Returns length of an extent of blocks -* @start: Start of the buffer -* @len: Length of the buffer in bytes -* @ptr: Current position in the buffer -* @limit: Max extent length to return (0 = unlimited) +* @bh: The metadata block +* @ptr: Current position in @bh +* @limit: Max extent length to return * @eob: Set to 1 if we hit "end of block" * -* If the first block is zero (unallocated) it will return the number of -* unallocated blocks in the extent, otherwise it will return the number -* of contiguous blocks in the extent. -* * Returns: The length of the extent (minimum of one block) */ -static inline unsigned int gfs2_extent_length (void *start,unsigned int len,__be64 *ptr,size_t limit,int *eob) +static inline unsigned int gfs2_extent_length (struct buffer_head *bh,__be64 *ptr,size_t limit,int *eob) { -const __be64 *end = (start + len); +const __be64 *end = (__be64 *)(bh->b_data + bh->b_size);const __be64 *first = ptr;u64 d =be64_to_cpu (*ptr);
@@ -430,14 +425,11 @@ static inline unsigned int gfs2_extent_length(void *start, unsigned int len, __b ptr++;if (ptr >= end)break ; -if (limit && --limit ==0 ) -break ; -if (d) - d++; + d++; }while (be64_to_cpu (*ptr) == d);if (ptr >= end) *eob =1 ; -return (ptr - first); +return ptr - first; } typedef const __be64 *(*gfs2_metadata_walker)(
@@ -893,7 +885,7 @@ static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length, goto do_alloc; bh = mp->mp_bh[ip->i_height -1 ]; - len =gfs2_extent_length (bh->b_data, bh->b_size, ptr, len, &eob); + len =gfs2_extent_length (bh, ptr, len, &eob); iomap->addr =be64_to_cpu (*ptr) << inode->i_blkbits; iomap->length = len << inode->i_blkbits;
Signature · 1 line
2.17.1
Andreas Gruenbacher
maintainerPATCH v10 4/5 gfs2: iomap direct I/O support
In reply to Andreas GruenbacherThe page unmapping previously done in gfs2_direct_IO is now done generically in iomap_dio_rw.
--- fs/gfs2/aops.c | 100 +----------------------------------- fs/gfs2/bmap.c | 10 +++- fs/gfs2/file.c | 136 +++++++++++++++++++++++++++++++++++++++++++++---- 3 files changed, 136 insertions(+), 110 deletions(-)
fs/gfs2/aops.c +2 -98
@@ -84,12 +84,6 @@ static int gfs2_get_block_noalloc(struct inode *inode, sector_t lblock,return 0 ; } -static int gfs2_get_block_direct (struct inode *inode,sector_t lblock, -struct buffer_head *bh_result,int create) -{ -return gfs2_block_map (inode, lblock, bh_result,0 ); -} -/** * gfs2_writepage_common - Common bits of writepage * @page: The page to be written
@@ -1024,96 +1018,6 @@ static void gfs2_invalidatepage(struct page *page, unsigned int offset,try_to_release_page (page,0 ); } -/** -* gfs2_ok_for_dio - check that dio is valid on this file -* @ip: The inode -* @offset: The offset at which we are reading or writing -* -* Returns: 0 (to ignore the i/o request and thus fall back to buffered i/o) -* 1 (to accept the i/o request) -*/ -static int gfs2_ok_for_dio (struct gfs2_inode *ip,loff_t offset) -{ -/* -* Should we return an error here? I can't see that O_DIRECT for -* a stuffed file makes any sense. For now we'll silently fall -* back to buffered I/O -*/ -if (gfs2_is_stuffed (ip)) -return 0 ; - -if (offset >=i_size_read (&ip->i_inode)) -return 0 ; -return 1 ; -} - - - -static ssize_t gfs2_direct_IO (struct kiocb *iocb,struct iov_iter *iter) -{ -struct file *file = iocb->ki_filp; -struct inode *inode = file->f_mapping->host; -struct address_space *mapping = inode->i_mapping; -struct gfs2_inode *ip =GFS2_I (inode); -loff_t offset = iocb->ki_pos; -struct gfs2_holder gh; -int rv; - -/* -* Deferred lock, even if its a write, since we do no allocation -* on this path. All we need change is atime, and this lock mode -* ensures that other nodes have flushed their buffered read caches -* (i.e. their page cache entries for this inode). We do not, -* unfortunately have the option of only flushing a range like -* the VFS does. -*/ -gfs2_holder_init (ip->i_gl,LM_ST_DEFERRED ,0 , &gh); - rv =gfs2_glock_nq (&gh); -if (rv) - goto out_uninit; - rv =gfs2_ok_for_dio (ip, offset); -if (rv !=1 ) - goto out;/* dio not valid, fall back to buffered i/o */ - -/* -* Now since we are holding a deferred (CW) lock at this point, you -* might be wondering why this is ever needed. There is a case however -* where we've granted a deferred local lock against a cached exclusive -* glock. That is ok provided all granted local locks are deferred, but -* it also means that it is possible to encounter pages which are -* cached and possibly also mapped. So here we check for that and sort -* them out ahead of the dio. The glock state machine will take care of -* everything else. -* -* If in fact the cached glock state (gl->gl_state) is deferred (CW) in -* the first place, mapping->nr_pages will always be zero. -*/ -if (mapping->nrpages) { -loff_t lstart = offset & ~(PAGE_SIZE -1 ); -loff_t len =iov_iter_count (iter); -loff_t end =PAGE_ALIGN (offset + len) -1 ; - - rv =0 ; -if (len ==0 ) - goto out; -if (test_and_clear_bit (GIF_SW_PAGED , &ip->i_flags)) -unmap_shared_mapping_range (ip->i_inode.i_mapping, offset, len); - rv =filemap_write_and_wait_range (mapping, lstart, end); -if (rv) - goto out; -if (iov_iter_rw (iter) ==WRITE ) -truncate_inode_pages_range (mapping, lstart, end); - } - - rv =__blockdev_direct_IO (iocb, inode, inode->i_sb->s_bdev, iter, - gfs2_get_block_direct,NULL ,NULL ,0 ); -out: -gfs2_glock_dq (&gh); -out_uninit: -gfs2_holder_uninit (&gh); -return rv; -} -/** * gfs2_releasepage - free the metadata associated with a page * @page: the page that's being released
@@ -1194,7 +1098,7 @@ static const struct address_space_operations gfs2_writeback_aops = { .bmap = gfs2_bmap, .invalidatepage = gfs2_invalidatepage, .releasepage = gfs2_releasepage, - .direct_IO = gfs2_direct_IO, + .direct_IO = noop_direct_IO, .migratepage = buffer_migrate_page, .is_partially_uptodate = block_is_partially_uptodate, .error_remove_page = generic_error_remove_page,
@@ -1211,7 +1115,7 @@ static const struct address_space_operations gfs2_ordered_aops = { .bmap = gfs2_bmap, .invalidatepage = gfs2_invalidatepage, .releasepage = gfs2_releasepage, - .direct_IO = gfs2_direct_IO, + .direct_IO = noop_direct_IO, .migratepage = buffer_migrate_page, .is_partially_uptodate = block_is_partially_uptodate, .error_remove_page = generic_error_remove_page,
fs/gfs2/bmap.c +8 -2
@@ -915,6 +915,9 @@ static int gfs2_iomap_get(struct inode *inode, loff_t pos, loff_t length, }else if (flags &IOMAP_WRITE ) {u64 alloc_size; +if (flags &IOMAP_DIRECT ) + goto out;/* (see gfs2_file_direct_write) */ + len =gfs2_alloc_size (inode, mp, len); alloc_size = len << inode->i_blkbits;if (alloc_size < iomap->length)
@@ -1082,11 +1085,14 @@ static int gfs2_iomap_begin(struct inode *inode, loff_t pos, loff_t length,int ret;trace_gfs2_iomap_start (ip, pos, length, flags); -if (flags &IOMAP_WRITE ) { +if ((flags &IOMAP_WRITE ) && !(flags &IOMAP_DIRECT )) { ret =gfs2_iomap_begin_write (inode, pos, length, flags, iomap); }else { ret =gfs2_iomap_get (inode, pos, length, flags, iomap, &mp);release_metapath (&mp); +if ((flags &IOMAP_WRITE ) && (flags &IOMAP_DIRECT ) && + iomap->type !=IOMAP_MAPPED ) + ret = -ENOTBLK ; }trace_gfs2_iomap_end (ip, iomap, ret);return ret;
@@ -1100,7 +1106,7 @@ static int gfs2_iomap_end(struct inode *inode, loff_t pos, loff_t length,struct gfs2_trans *tr = current->journal_info;struct buffer_head *dibh = iomap->private; -if (!(flags &IOMAP_WRITE )) +if ((flags & (IOMAP_WRITE |IOMAP_DIRECT )) !=IOMAP_WRITE ) goto out;if (iomap->type !=IOMAP_INLINE ) {
fs/gfs2/file.c +126 -10
181 lines not on this page · raw message
Signature · 1 line
2.17.1
Andreas Gruenbacher
maintainerPATCH v10 5/5 gfs2: Remove gfs2_write_{begin,end}
In reply to Andreas GruenbacherNow that generic_file_write_iter is no longer used, there are no remaining users of these address space operations.
--- fs/gfs2/aops.c | 213 ------------------------------------------------- 1 file changed, 213 deletions(-)
fs/gfs2/aops.c +0 -213
@@ -639,135 +639,6 @@ static int gfs2_readpages(struct file *file, struct address_space *mapping,return ret; } -/** -* gfs2_write_begin - Begin to write to a file -* @file: The file to write to -* @mapping: The mapping in which to write -* @pos: The file offset at which to start writing -* @len: Length of the write -* @flags: Various flags -* @pagep: Pointer to return the page -* @fsdata: Pointer to return fs data (unused by GFS2) -* -* Returns: errno -*/ - -static int gfs2_write_begin (struct file *file,struct address_space *mapping, -loff_t pos,unsigned len,unsigned flags, -struct page **pagep,void **fsdata) -{ -struct gfs2_inode *ip =GFS2_I (mapping->host); -struct gfs2_sbd *sdp =GFS2_SB (mapping->host); -struct gfs2_inode *m_ip =GFS2_I (sdp->sd_statfs_inode); -unsigned int data_blocks =0 , ind_blocks =0 , rblocks; -unsigned requested =0 ; -int alloc_required; -int error =0 ; -pgoff_t index = pos >>PAGE_SHIFT ; -unsigned from = pos & (PAGE_SIZE -1 ); -struct page *page; - -gfs2_holder_init (ip->i_gl,LM_ST_EXCLUSIVE ,0 , &ip->i_gh); - error =gfs2_glock_nq (&ip->i_gh); -if (unlikely (error)) - goto out_uninit; -if (&ip->i_inode == sdp->sd_rindex) { - error =gfs2_glock_nq_init (m_ip->i_gl,LM_ST_EXCLUSIVE , -GL_NOCACHE , &m_ip->i_gh); -if (unlikely (error)) { -gfs2_glock_dq (&ip->i_gh); - goto out_uninit; - } - } - - alloc_required =gfs2_write_alloc_required (ip, pos, len); - -if (alloc_required ||gfs2_is_jdata (ip)) -gfs2_write_calc_reserv (ip, len, &data_blocks, &ind_blocks); - -if (alloc_required) { -struct gfs2_alloc_parms ap = { .aflags =0 , }; - requested = data_blocks + ind_blocks; - ap.target = requested; - error =gfs2_quota_lock_check (ip, &ap); -if (error) - goto out_unlock; - - error =gfs2_inplace_reserve (ip, &ap); -if (error) - goto out_qunlock; - } - - rblocks =RES_DINODE + ind_blocks; -if (gfs2_is_jdata (ip)) - rblocks += data_blocks ? data_blocks :1 ; -if (ind_blocks || data_blocks) - rblocks +=RES_STATFS +RES_QUOTA ; -if (&ip->i_inode == sdp->sd_rindex) - rblocks +=2 *RES_STATFS ; -if (alloc_required) - rblocks +=gfs2_rg_blocks (ip, requested); - - error =gfs2_trans_begin (sdp, rblocks, -PAGE_SIZE /sdp->sd_sb.sb_bsize); -if (error) - goto out_trans_fail; - - error = -ENOMEM ; - flags |=AOP_FLAG_NOFS ; - page =grab_cache_page_write_begin (mapping, index, flags); - *pagep = page; -if (unlikely (!page)) - goto out_endtrans; - -if (gfs2_is_stuffed (ip)) { - error =0 ; -if (pos + len >gfs2_max_stuffed_size (ip)) { - error =gfs2_unstuff_dinode (ip, page); -if (error ==0 ) - goto prepare_write; - }else if (!PageUptodate (page)) { - error =stuffed_readpage (ip, page); - } - goto out; - } - -prepare_write: - error =__block_write_begin (page, from, len, gfs2_block_map); -out: -if (error ==0 ) -return 0 ; - -unlock_page (page); -put_page (page); - -gfs2_trans_end (sdp); -if (alloc_required) { -gfs2_inplace_release (ip); -if (pos + len > ip->i_inode.i_size) -gfs2_trim_blocks (&ip->i_inode); - } - goto out_qunlock; - -out_endtrans: -gfs2_trans_end (sdp); -out_trans_fail: -if (alloc_required) -gfs2_inplace_release (ip); -out_qunlock: -if (alloc_required) -gfs2_quota_unlock (ip); -out_unlock: -if (&ip->i_inode == sdp->sd_rindex) { -gfs2_glock_dq (&m_ip->i_gh); -gfs2_holder_uninit (&m_ip->i_gh); - } -gfs2_glock_dq (&ip->i_gh); -out_uninit: -gfs2_holder_uninit (&ip->i_gh); -return error; -} -/** * adjust_fs_space - Adjusts the free space available due to gfs2_grow * @inode: the rindex inode
@@ -848,84 +719,6 @@ int gfs2_stuffed_write_end(struct inode *inode, struct buffer_head *dibh,return copied; } -/** -* gfs2_write_end -* @file: The file to write to -* @mapping: The address space to write to -* @pos: The file position -* @len: The length of the data -* @copied: How much was actually copied by the VFS -* @page: The page that has been written -* @fsdata: The fsdata (unused in GFS2) -* -* The main write_end function for GFS2. We just put our locking around the VFS -* provided functions. -* -* Returns: copied bytes or errno -*/ - -static int gfs2_write_end (struct file *file,struct address_space *mapping, -loff_t pos,unsigned len,unsigned copied, -struct page *page,void *fsdata) -{ -struct inode *inode = page->mapping->host; -struct gfs2_inode *ip =GFS2_I (inode); -struct gfs2_sbd *sdp =GFS2_SB (inode); -struct gfs2_inode *m_ip =GFS2_I (sdp->sd_statfs_inode); -struct buffer_head *dibh; -int ret; -struct gfs2_trans *tr = current->journal_info; -BUG_ON (!tr); - -BUG_ON (gfs2_glock_is_locked_by_me (ip->i_gl) ==NULL ); - - ret =gfs2_meta_inode_buffer (ip, &dibh); -if (unlikely (ret)) - goto out; - -if (gfs2_is_stuffed (ip)) { - ret =gfs2_stuffed_write_end (inode, dibh, pos, copied, page); - page =NULL ; - goto out2; - } - -if (gfs2_is_jdata (ip)) -gfs2_page_add_databufs (ip, page, pos & ~PAGE_MASK , len); -else -gfs2_ordered_add_inode (ip); - - ret =generic_write_end (file, mapping, pos, len, copied, page, fsdata); - page =NULL ; -if (tr->tr_num_buf_new) -__mark_inode_dirty (inode,I_DIRTY_DATASYNC ); -else -gfs2_trans_add_meta (ip->i_gl, dibh); - -out2: -if (inode == sdp->sd_rindex) { -adjust_fs_space (inode); - sdp->sd_rindex_uptodate =0 ; - } - -brelse (dibh); -out: -if (page) { -unlock_page (page); -put_page (page); - } -gfs2_trans_end (sdp); -gfs2_inplace_release (ip); -if (ip->i_qadata && ip->i_qadata->qa_qd_num) -gfs2_quota_unlock (ip); -if (inode == sdp->sd_rindex) { -gfs2_glock_dq (&m_ip->i_gh); -gfs2_holder_uninit (&m_ip->i_gh); - } -gfs2_glock_dq (&ip->i_gh); -gfs2_holder_uninit (&ip->i_gh); -return ret; -} -/** * jdata_set_page_dirty - Page dirtying function * @page: The page to dirty
@@ -1093,8 +886,6 @@ static const struct address_space_operations gfs2_writeback_aops = { .writepages = gfs2_writepages, .readpage = gfs2_readpage, .readpages = gfs2_readpages, - .write_begin = gfs2_write_begin, - .write_end = gfs2_write_end, .bmap = gfs2_bmap, .invalidatepage = gfs2_invalidatepage, .releasepage = gfs2_releasepage,
@@ -1109,8 +900,6 @@ static const struct address_space_operations gfs2_ordered_aops = { .writepages = gfs2_writepages, .readpage = gfs2_readpage, .readpages = gfs2_readpages, - .write_begin = gfs2_write_begin, - .write_end = gfs2_write_end, .set_page_dirty = __set_page_dirty_buffers, .bmap = gfs2_bmap, .invalidatepage = gfs2_invalidatepage,
@@ -1126,8 +915,6 @@ static const struct address_space_operations gfs2_jdata_aops = { .writepages = gfs2_jdata_writepages, .readpage = gfs2_readpage, .readpages = gfs2_readpages, - .write_begin = gfs2_write_begin, - .write_end = gfs2_write_end, .set_page_dirty = jdata_set_page_dirty, .bmap = gfs2_bmap, .invalidatepage = gfs2_invalidatepage,
Signature · 1 line
2.17.1
----- Original Message -----
Quoted 3 lines
Here's another update of my gfs2 iomap write patches on top of:
git://git.infradead.org/users/hch/xfs.gitgfs2-iomap
Hi Andreas,
I've reviewed your patches and they look good to me. Go ahead and add my:
Bob Peterson