fs: allow short direct-io reads to be completed via buffered IO V2
Subsystems (8)
PATCH 1/6 fs: allow short direct-io reads to be completed via buffered IO V2
V1->V2: Check to see if our current ppos is >= i_size after a short DIO read, just in case it was actually a short read and we need to just return.
This is similar to what already happens in the write case. If we have a short read while doing O_DIRECT, instead of just returning, fallthrough and try to read the rest via buffered IO. BTRFS needs this because if we encounter a compressed or inline extent during DIO, we need to fallback on buffered. If the extent is compressed we need to read the entire thing into memory and de-compress it into the users pages. I have tested this with fsx and everything works great. Thanks,
--- mm/filemap.c | 36 +++++++++++++++++++++++++++++++----- 1 files changed, 31 insertions(+), 5 deletions(-)
mm/filemap.c +31 -5
@@ -1263,7 +1263,7 @@ generic_file_aio_read(struct kiocb *iocb, const struct iovec *iov, {struct file *filp = iocb->ki_filp;ssize_t retval; -unsigned long seg; +unsigned long seg =0 ;size_t count;loff_t *ppos = &iocb->ki_pos;
@@ -1290,21 +1290,47 @@ generic_file_aio_read(struct kiocb *iocb, const struct iovec *iov, retval = mapping->a_ops->direct_IO (READ , iocb, iov, pos, nr_segs); } -if (retval >0 ) +if (retval >0 ) { *ppos = pos + retval; -if (retval) { + count -= retval; + } + +/* +* Btrfs can have a short DIO read if we encounter +* compressed extents, so if there was an error, or if +* we've already read everything we wanted to, or if +* there was a short read because we hit EOF, go ahead +* and return. Otherwise fallthrough to buffered io for +* the rest of the read. +*/ +if (retval <0 || !count || *ppos >= size) {file_accessed (filp); goto out; } } } + count = retval;for (seg =0 ; seg < nr_segs; seg++) {read_descriptor_t desc; +loff_t offset =0 ; + +/* +* If we did a short DIO read we need to skip the section of the +* iov that we've already read data into. +*/ +if (count) { +if (count > iov[seg].iov_len) { + count -= iov[seg].iov_len; +continue ; + } + offset = count; + count =0 ; + } desc.written =0 ; - desc.arg.buf = iov[seg].iov_base; - desc.count = iov[seg].iov_len; + desc.arg.buf = iov[seg].iov_base + offset; + desc.count = iov[seg].iov_len - offset;if (desc.count ==0 )continue ; desc.error =0 ;
Signature · 1 line
1.6.6.1
PATCH 2/6 direct-io: add a hook for the fs to provide its own submit_bio function V3
V1->V2:
-Changed dio_end_io to EXPORT_SYMBOL_GPL
-Removed the own_submit blockdev dio helper
-Removed the boundary change
V2->V3
-Made it so we keep track of what the current logical offset in the file we have a BIO setup for so we can pass it into the submit_io hook.
Because BTRFS can do RAID and such, we need our own submit hook so we can setup the bio's in the correct fashion, and handle checksum errors properly. So there are a few changes here
1) The submit_io hook. This is straightforward, just call this instead of submit_bio.
2) Allow the fs to return -ENOTBLK for reads. Usually this has only worked for writes, since writes can fallback onto buffered IO. But BTRFS needs the option of falling back on buffered IO if it encounters a compressed extent, since we need to read the entire extent in and decompress it. So if we get -ENOTBLK back from get_block we'll return back and fallback on buffered just like the write case.
I've tested these changes with fsx and everything seems to work. Thanks,
--- fs/direct-io.c | 33 ++++++++++++++++++++++++++++----- include/linux/fs.h | 11 ++++++++--- 2 files changed, 36 insertions(+), 8 deletions(-)
fs/direct-io.c +28 -5
@@ -82,6 +82,8 @@ struct dio {int reap_counter;/* rate limit reaping */ get_block_t *get_block;/* block mapping function */ dio_iodone_t *end_io;/* IO completion function */ +dio_submit_t *submit_io;/* IO submition function */ +loff_t logical_offset_in_bio;/* current first logical block in bio */ sector_t final_block_in_bio;/* current final block in bio + 1 */ sector_t next_block_for_io;/* next block to be put under IO, in dio_blocks units */
@@ -96,6 +98,7 @@ struct dio {unsigned cur_page_offset;/* Offset into it, in bytes */ unsigned cur_page_len;/* Nr of bytes at cur_page_offset */ sector_t cur_page_block;/* Where it starts */ +loff_t cur_page_fs_offset;/* Offset in file */ /* BIO completion state */ spinlock_t bio_lock;/* protects BIO fields below */
@@ -300,6 +303,17 @@ static void dio_bio_end_io(struct bio *bio, int error)spin_unlock_irqrestore (&dio->bio_lock, flags); } +void dio_end_io (struct bio *bio,int error) +{ +struct dio *dio = bio->bi_private; + +if (dio->is_async) +dio_bio_end_aio (bio, error); +else +dio_bio_end_io (bio, error); +} +EXPORT_SYMBOL_GPL (dio_end_io); +static int dio_bio_alloc (struct dio *dio,struct block_device *bdev,sector_t first_sector,int nr_vecs)
@@ -316,6 +330,7 @@ dio_bio_alloc(struct dio *dio, struct block_device *bdev, bio->bi_end_io = dio_bio_end_io; dio->bio = bio; + dio->logical_offset_in_bio = dio->cur_page_fs_offset;return 0 ; }
@@ -340,10 +355,15 @@ static void dio_bio_submit(struct dio *dio)if (dio->is_async && dio->rw ==READ )bio_set_pages_dirty (bio); -submit_bio (dio->rw, bio); +if (!dio->submit_io) +submit_bio (dio->rw, bio); +else + dio->submit_io (dio->rw, bio, dio->inode, + dio->logical_offset_in_bio); dio->bio =NULL ; dio->boundary =0 ; + dio->logical_offset_in_bio =0 ; }/*
@@ -701,6 +721,7 @@ submit_page_section(struct dio *dio, struct page *page, dio->cur_page_offset = offset; dio->cur_page_len = len; dio->cur_page_block = blocknr; + dio->cur_page_fs_offset = dio->block_in_file << dio->blkbits; out:return ret; }
@@ -935,7 +956,7 @@ static ssize_t direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode, const struct iovec *iov, loff_t offset, unsigned long nr_segs, unsigned blkbits, get_block_t get_block, dio_iodone_t end_io, - struct dio *dio) + dio_submit_t submit_io, struct dio *dio) { unsigned long user_addr;unsigned long flags;
@@ -952,6 +973,7 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode, dio->get_block = get_block; dio->end_io = end_io; + dio->submit_io = submit_io; dio->final_block_in_bio =-1 ; dio->next_block_for_io =-1 ;
@@ -1008,7 +1030,7 @@ direct_io_worker(int rw, struct kiocb *iocb, struct inode *inode, } }/* end iovec loop */ -if (ret == -ENOTBLK && (rw &WRITE )) { +if (ret == -ENOTBLK ) {/* * The remaining part of the request will be * be handled by buffered I/O when we return
@@ -1110,7 +1132,7 @@ ssize_t __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode, struct block_device *bdev, const struct iovec *iov, loff_t offset, unsigned long nr_segs, get_block_t get_block, dio_iodone_t end_io, - int flags) + dio_submit_t submit_io, int flags) { int seg;size_t size;
@@ -1197,7 +1219,8 @@ __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode, (end > i_size_read(inode))); retval =direct_io_worker (rw, iocb, inode, iov, offset, - nr_segs, blkbits, get_block, end_io, dio); + nr_segs, blkbits, get_block, end_io, + submit_io, dio);/* * In case of error extending write may have instantiated a few
include/linux/fs.h +8 -3
@@ -2250,10 +2250,15 @@ static inline int xip_truncate_page(struct address_space *mapping, loff_t from)#endif #ifdef CONFIG_BLOCK +struct bio ; +typedef void (dio_submit_t )(int rw,struct bio *bio,struct inode *inode, +loff_t file_offset); +void dio_end_io (struct bio *bio,int error); +ssize_t __blockdev_direct_IO (int rw,struct kiocb *iocb,struct inode *inode,struct block_device *bdev,const struct iovec *iov,loff_t offset,unsigned long nr_segs,get_block_t get_block,dio_iodone_t end_io, -int lock_type); +dio_submit_t submit_io,int lock_type);enum { /* need locking between buffered and direct access */
@@ -2269,7 +2274,7 @@ static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb, dio_iodone_t end_io) {return __blockdev_direct_IO (rw, iocb, inode, bdev, iov, offset, - nr_segs, get_block, end_io, + nr_segs, get_block, end_io,NULL ,DIO_LOCKING |DIO_SKIP_HOLES ); }
@@ -2279,7 +2284,7 @@ static inline ssize_t blockdev_direct_IO_no_locking(int rw, struct kiocb *iocb, dio_iodone_t end_io) {return __blockdev_direct_IO (rw, iocb, inode, bdev, iov, offset, - nr_segs, get_block, end_io,0 ); + nr_segs, get_block, end_io,NULL ,0 ); }#endif
Signature · 1 line
1.6.6.1
Re: [PATCH 2/6] direct-io: add a hook for the fs to provide its own submit_bio function V3
Review
Quoted 4 lines · Josef Bacik
V1->V2:(quoted diff) +0
-3-Changed dio_end_io to EXPORT_SYMBOL_GPL -Removed the own_submit blockdev dio helper -Removed the boundary change
patch version changelogs go below the --- header so they don't go into the commit message. Also makes reading the patch description a lot easier. Also applies to all the other patches in the series.
fs/direct-io.c static void dio_bio_end_io(struct bio *bio, int error) · line 315
Quoted 10 lines
fs/direct-io.c +10
-0+void dio_end_io (struct bio *bio,int error) +{ +struct dio *dio = bio->bi_private; + +if (dio->is_async) +dio_bio_end_aio (bio, error); +else +dio_bio_end_io (bio, error); +} +EXPORT_SYMBOL_GPL (dio_end_io);
This one needs a good kerneldoc comment.
fs/direct-io.c static void dio_bio_submit(struct dio *dio) · line 362
Quoted 6 lines
fs/direct-io.c +5
-1-submit_bio (dio->rw, bio); +if (!dio->submit_io) +submit_bio (dio->rw, bio); +else + dio->submit_io (dio->rw, bio, dio->inode, + dio->logical_offset_in_bio);
'd reverse the if condition - no need for an inversion here.
if (dio->submit_io) {
dio->submit_io(dio->rw, bio, dio->inode,
dio->logical_offset_in_bio);
} else {
submit_bio(dio->rw, bio);
}PATCH 3/6 direct-io: do not merge logically non-contiguous requests
In reply to Josef BacikBtrfs cannot handle having logically non-contiguous requests submitted. For example if you have
Logical: [0-4095][HOLE][8192-12287] Physical: [0-4095] [4096-8191]
Normally the DIO code would put these into the same BIO's. The problem is we need to know exactly what offset is associated with what BIO so we can do our checksumming and unlocking properly, so putting them in the same BIO doesn't work. So add another check where we submit the current BIO if the physical blocks are not contigous OR the logical blocks are not contiguous.
--- fs/direct-io.c | 7 ++++++- 1 files changed, 6 insertions(+), 1 deletions(-)
fs/direct-io.c +6 -1
@@ -623,10 +623,15 @@ static int dio_send_cur_page(struct dio *dio)int ret =0 ;if (dio->bio) { +loff_t cur_offset = dio->block_in_file << dio->blkbits; +loff_t bio_next_offset = dio->logical_offset_in_bio + + dio->bio->bi_size; +/* * See whether this new request is contiguous with the old */ -if (dio->final_block_in_bio != dio->cur_page_block) +if (dio->final_block_in_bio != dio->cur_page_block || + cur_offset != bio_next_offset)dio_bio_submit (dio);/* * Submit now if the underlying fs is about to perform a
Signature · 1 line
1.6.6.1
Re: [PATCH 3/6] direct-io: do not merge logically non-contiguous requests
Quoted 11 lines · Josef Bacik
Btrfs cannot handle having logically non-contiguous requests submitted. For example if you have
Logical: [0-4095][HOLE][8192-12287] Physical: [0-4095] [4096-8191]Normally the DIO code would put these into the same BIO's. The problem is we need to know exactly what offset is associated with what BIO so we can do our checksumming and unlocking properly, so putting them in the same BIO doesn't work. So add another check where we submit the current BIO if the physical blocks are not contigous OR the logical blocks are not contiguous.
This gets us slightly less optimal I/O patters for other filesystems in this case. But it's probably corner case enough to not care and make it the default.
But please make the comment in the comment as verbose as the commit message so that people understand why we're doing this when reading the code in a few years.
Re: [PATCH 3/6] direct-io: do not merge logically non-contiguous requests
Quoted 13 lines · Christoph Hellwig
Quoted 11 lines · Josef Bacik
Btrfs cannot handle having logically non-contiguous requests submitted. For example if you have
Logical: [0-4095][HOLE][8192-12287] Physical: [0-4095] [4096-8191]Normally the DIO code would put these into the same BIO's. The problem is we need to know exactly what offset is associated with what BIO so we can do our checksumming and unlocking properly, so putting them in the same BIO doesn't work. So add another check where we submit the current BIO if the physical blocks are not contigous OR the logical blocks are not contiguous.
Quoted 8 lines
This gets us slightly less optimal I/O patters for other filesystems in this case. But it's probably corner case enough to not care and make it the default.
But please make the comment in the comment as verbose as the commit message so that people understand why we're doing this when reading the code in a few years.
So after I sent this I thought that maybe I could make that test _only_ if we provide submit_bio, that way it only affects btrfs and not everybody else, would you prefer I do something like that? I will make the commit log a bit more verbose. Thanks,
Josef
Re: [PATCH 3/6] direct-io: do not merge logically non-contiguous requests
Quoted 4 lines · Josef Bacik
So after I sent this I thought that maybe I could make that test _only_ if we provide
submit_bio, that way it only affects btrfs and not everybody else, would you prefer I do something like that? I will make the commit log a bit more verbose. Thanks,
Again, I think it's not really worth optimizing for. Just document very clearly why it's there.
PATCH 4/6 fs: kill blockdev_direct_IO_no_locking
In reply to Josef BacikChristoph said he'd rather everybody use __blockdev_direct_IO directly instead of having a bunch of random helper functions, so thats what this patch does. It's a basic change, I've tested it with xfstests on ext4 and xfs. Thanks,
--- fs/block_dev.c | 5 +++-- fs/ext4/inode.c | 8 ++++---- fs/gfs2/aops.c | 6 +++--- fs/ocfs2/aops.c | 8 +++----- fs/xfs/linux-2.6/xfs_aops.c | 7 +++---- include/linux/fs.h | 9 --------- 6 files changed, 16 insertions(+), 27 deletions(-)
fs/block_dev.c +3 -2
@@ -172,8 +172,9 @@ blkdev_direct_IO(int rw, struct kiocb *iocb, const struct iovec *iov,struct file *file = iocb->ki_filp;struct inode *inode = file->f_mapping->host; -return blockdev_direct_IO_no_locking (rw, iocb, inode,I_BDEV (inode), - iov, offset, nr_segs, blkdev_get_blocks,NULL ); +return __blockdev_direct_IO (rw, iocb, inode,I_BDEV (inode), iov, + offset, nr_segs, blkdev_get_blocks,NULL , +NULL ,0 ); }int __sync_blockdev (struct block_device *bdev,int wait)
fs/ext4/inode.c +4 -4
@@ -3494,10 +3494,10 @@ static ssize_t ext4_ind_direct_IO(int rw, struct kiocb *iocb, retry:if (rw ==READ &&ext4_should_dioread_nolock (inode)) - ret =blockdev_direct_IO_no_locking (rw, iocb, inode, - inode->i_sb->s_bdev, iov, - offset, nr_segs, - ext4_get_block,NULL ); + ret =__blockdev_direct_IO (rw, iocb, inode, + inode->i_sb->s_bdev, iov, offset, + nr_segs, ext4_get_block,NULL ,NULL , +0 );else ret = blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
fs/gfs2/aops.c +3 -3
@@ -1039,9 +1039,9 @@ static ssize_t gfs2_direct_IO(int rw, struct kiocb *iocb,if (rv !=1 ) goto out;/* dio not valid, fall back to buffered i/o */ - rv =blockdev_direct_IO_no_locking (rw, iocb, inode, inode->i_sb->s_bdev, - iov, offset, nr_segs, - gfs2_get_block_direct,NULL ); + rv =__blockdev_direct_IO (rw, iocb, inode, inode->i_sb->s_bdev, + iov, offset, nr_segs, gfs2_get_block_direct, +NULL ,NULL ,0 ); out:gfs2_glock_dq_m (1 , &gh);gfs2_holder_uninit (&gh);
fs/ocfs2/aops.c +3 -5
@@ -669,11 +669,9 @@ static ssize_t ocfs2_direct_IO(int rw,if (i_size_read (inode) <= offset)return 0 ; - ret =blockdev_direct_IO_no_locking (rw, iocb, inode, - inode->i_sb->s_bdev, iov, offset, - nr_segs, - ocfs2_direct_IO_get_blocks, - ocfs2_dio_end_io); + ret =__blockdev_direct_IO (rw, iocb, inode, inode->i_sb->s_bdev, iov, + offset, nr_segs, ocfs2_direct_IO_get_blocks, + ocfs2_dio_end_io,NULL ,0 );mlog_exit (ret);return ret;
fs/xfs/linux-2.6/xfs_aops.c +3 -4
@@ -1617,10 +1617,9 @@ xfs_vm_direct_IO( iocb->private =xfs_alloc_ioend (inode, rw ==WRITE ?IOMAP_UNWRITTEN :IOMAP_READ ); - ret =blockdev_direct_IO_no_locking (rw, iocb, inode, bdev, iov, - offset, nr_segs, - xfs_get_blocks_direct, - xfs_end_io_direct); + ret =__blockdev_direct_IO (rw, iocb, inode, bdev, iov, offset, nr_segs, + xfs_get_blocks_direct, xfs_end_io_direct, +NULL ,0 );if (unlikely (ret != -EIOCBQUEUED && iocb->private))xfs_destroy_ioend (iocb->private);
include/linux/fs.h +0 -9
@@ -2277,15 +2277,6 @@ static inline ssize_t blockdev_direct_IO(int rw, struct kiocb *iocb, nr_segs, get_block, end_io,NULL , DIO_LOCKING | DIO_SKIP_HOLES); } - -static inline ssize_t blockdev_direct_IO_no_locking (int rw,struct kiocb *iocb, -struct inode *inode,struct block_device *bdev,const struct iovec *iov, -loff_t offset,unsigned long nr_segs,get_block_t get_block, -dio_iodone_t end_io) -{ -return __blockdev_direct_IO (rw, iocb, inode, bdev, iov, offset, - nr_segs, get_block, end_io,NULL ,0 ); -}#endif extern const struct file_operations generic_ro_fops;
Signature · 1 line
1.6.6.1
Re: [PATCH 4/6] fs: kill blockdev_direct_IO_no_locking
Quoted 5 lines · Josef Bacik
Christoph said he'd rather everybody use
__blockdev_direct_IOdirectly instead of having a bunch of random helper functions, so thats what this patch does. It's a basic change, I've tested it with xfstests on ext4 and xfs. Thanks,Signed-off-by Josef Bacik <[email protected]>
Ok,
PATCH 5/6 Btrfs: add basic DIO read/write support V6
In reply to Josef BacikV1->V2
-Use __blockdev_direct_IO instead of helper
-Use KM_IRQ0 for kmap instead of KM_USER0
V2->V3
-Update the submit function to work with my submit hook changes -Add DIO write support
V3->V4
-Use local_irq_save/restore around the KM_IRQ0 kmaps
V4->V5
-Use ordered extents for the DIO stuff so we do the completion properly -Don't lock for the entire time we do __blockdev_direct_IO, unlock READs in the completion handler, and unlock WRITEs after we add the ordered extent -Add ENOSPC handling
V5->V6
-Make sure to allocate a new extent if we are in NOCOW mode and theres a hole -Fix it so we unlock the range if we didnt read/write anything
This provides basic DIO support for reads only. It does not do any of the work to recover from mismatching checksums, that will come later. A few design changes have been made from Jim's code (sorry Jim!)
1) Use the generic direct-io code. Jim originally re-wrote all the generic DIO code in order to account for all of BTRFS's oddities, but thanks to that work it seems like the best bet is to just ignore compression and such and just opt to fallback on buffered IO.
2) Fallback on buffered IO for compressed or inline extents. Jim's code did it's own buffering to make dio with compressed extents work. Now we just fallback onto normal buffered IO.
3) Lock the entire range during DIO. I originally had it so we would lock the extents as get_block was called, and then unlock them as the endio function was called, which worked great, but if we ever had an error in the submit_io hook, we could have locked an extent that would never be submitted for IO, so we wouldn't be able to unlock it, so this solution fixed that problem and made it a bit cleaner.
I've tested this with fsx and everything works great. This patch depends on my dio and filemap.c patches to work. Thanks,
--- fs/btrfs/ctree.h | 2 + fs/btrfs/file-item.c | 25 ++- fs/btrfs/file.c | 69 +++++++- fs/btrfs/inode.c | 486 ++++++++++++++++++++++++++++++++++++++++++++--- fs/btrfs/ordered-data.c | 75 +++++++- fs/btrfs/ordered-data.h | 9 +- 6 files changed, 630 insertions(+), 36 deletions(-)
fs/btrfs/ctree.h +2 -0
@@ -2257,6 +2257,8 @@ int btrfs_del_csums(struct btrfs_trans_handle *trans, struct btrfs_root *root, u64 bytenr, u64 len);int btrfs_lookup_bio_sums (struct btrfs_root *root,struct inode *inode,struct bio *bio,u32 *dst); +int btrfs_lookup_bio_sums_dio (struct btrfs_root *root,struct inode *inode, +struct bio *bio,u64 logical_offset,u32 *dst); int btrfs_insert_file_extent(struct btrfs_trans_handle *trans, struct btrfs_root *root, u64 objectid, u64 pos,
fs/btrfs/file-item.c +21 -4
@@ -149,13 +149,14 @@ int btrfs_lookup_file_extent(struct btrfs_trans_handle *trans, } -int btrfs_lookup_bio_sums (struct btrfs_root *root,struct inode *inode, -struct bio *bio,u32 *dst) +static int __btrfs_lookup_bio_sums (struct btrfs_root *root, +struct inode *inode,struct bio *bio, +u64 logical_offset,u32 *dst,int dio) {u32 sum;struct bio_vec *bvec = bio->bi_io_vec;int bio_index =0 ; -u64 offset; +u64 offset =0 ;u64 item_start_offset =0 ;u64 item_last_offset =0 ;u64 disk_bytenr;
@@ -174,8 +175,11 @@ int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,WARN_ON (bio->bi_vcnt <=0 ); disk_bytenr = (u64 )bio->bi_sector <<9 ; +if (dio) + offset = logical_offset;while (bio_index < bio->bi_vcnt) { - offset =page_offset (bvec->bv_page) + bvec->bv_offset; +if (!dio) + offset =page_offset (bvec->bv_page) + bvec->bv_offset; ret =btrfs_find_ordered_sum (inode, offset, disk_bytenr, &sum);if (ret ==0 ) goto found;
@@ -238,6 +242,7 @@ found:else set_state_private (io_tree, offset, sum); disk_bytenr += bvec->bv_len; + offset += bvec->bv_len; bio_index++; bvec++; }
@@ -245,6 +250,18 @@ found:return 0 ; } +int btrfs_lookup_bio_sums (struct btrfs_root *root,struct inode *inode, +struct bio *bio,u32 *dst) +{ +return __btrfs_lookup_bio_sums (root, inode, bio,0 , dst,0 ); +} + +int btrfs_lookup_bio_sums_dio (struct btrfs_root *root,struct inode *inode, +struct bio *bio,u64 offset,u32 *dst) +{ +return __btrfs_lookup_bio_sums (root, inode, bio, offset, dst,1 ); +} +int btrfs_lookup_csums_range (struct btrfs_root *root,u64 start,u64 end,struct list_head *list) {
fs/btrfs/file.c +65 -4
103 lines not on this page · raw message
fs/btrfs/inode.c +462 -24
508 lines not on this page · raw message
fs/btrfs/ordered-data.c +72 -3
111 lines not on this page · raw message
fs/btrfs/ordered-data.h +8 -1
@@ -72,6 +72,8 @@ struct btrfs_ordered_sum {#define BTRFS_ORDERED_PREALLOC 4/* set when writing to prealloced extent */ +#define BTRFS_ORDERED_DIRECT 5/* set when we're doing DIO with this extent */ +struct btrfs_ordered_extent {/* logical offset in the file */ u64 file_offset;
@@ -140,7 +142,9 @@ int btrfs_dec_test_ordered_pending(struct inode *inode,struct btrfs_ordered_extent **cached, u64 file_offset, u64 io_size);int btrfs_add_ordered_extent (struct inode *inode,u64 file_offset, -u64 start,u64 len,u64 disk_len,int tyep); +u64 start,u64 len,u64 disk_len,int type); +int btrfs_add_ordered_extent_dio (struct inode *inode,u64 file_offset, +u64 start,u64 len,u64 disk_len,int type);int btrfs_add_ordered_sum (struct inode *inode,struct btrfs_ordered_extent *entry,struct btrfs_ordered_sum *sum);
@@ -151,6 +155,9 @@ void btrfs_start_ordered_extent(struct inode *inode,int btrfs_wait_ordered_range (struct inode *inode,u64 start,u64 len);struct btrfs_ordered_extent *btrfs_lookup_first_ordered_extent (struct inode * inode,u64 file_offset); +struct btrfs_ordered_extent *btrfs_lookup_ordered_range (struct inode *inode, +u64 file_offset, +u64 len);int btrfs_ordered_update_i_size (struct inode *inode,u64 offset,struct btrfs_ordered_extent *ordered);int btrfs_find_ordered_sum (struct inode *inode,u64 offset,u64 disk_bytenr,u32 *sum);
Signature · 1 line
1.6.6.1
PATCH 6/6 Btrfs: do aio_write instead of write V2
In reply to Josef BacikV1->V2
-Fix some things that git rebase screwed up -Use iov_iter_count() instead of count in a few places -Update pos if we had a short read/write
In order for AIO to work, we need to implement aio_write. This patch converts our btrfs_file_write to btrfs_aio_write. I've tested this with xfstests and nothing broke, and the AIO stuff magically started working. Thanks,
--- fs/btrfs/extent_io.c | 11 +++- fs/btrfs/file.c | 152 +++++++++++++++++++++++--------------------------- 2 files changed, 80 insertions(+), 83 deletions(-)
fs/btrfs/extent_io.c +10 -1
@@ -2020,6 +2020,7 @@ static int __extent_read_full_page(struct extent_io_tree *tree,sector_t sector;struct extent_map *em;struct block_device *bdev; +struct btrfs_ordered_extent *ordered;int ret;int nr =0 ;size_t page_offset =0 ;
@@ -2031,7 +2032,15 @@ static int __extent_read_full_page(struct extent_io_tree *tree,set_page_extent_mapped (page); end = page_end; -lock_extent (tree, start, end,GFP_NOFS ); +while (1 ) { +lock_extent (tree, start, end,GFP_NOFS ); + ordered =btrfs_lookup_ordered_extent (inode, start); +if (!ordered) +break ; +unlock_extent (tree, start, end,GFP_NOFS ); +btrfs_start_ordered_extent (inode, ordered,1 ); +btrfs_put_ordered_extent (ordered); + }if (page->index == last_byte >>PAGE_CACHE_SHIFT ) {char *userpage;
fs/btrfs/file.c +70 -82
246 lines not on this page · raw message
Signature · 1 line
1.6.6.1