From mboxrd@z Thu Jan 1 00:00:00 1970 From: jim owens Subject: [PATCH dio.c V2 1/6] Btrfs: fix indents and checkpatch issues in dio.c. Date: Wed, 03 Mar 2010 13:54:49 -0500 Message-ID: <4B8EB079.1050200@gmail.com> Mime-Version: 1.0 Content-Type: text/plain; charset=ISO-8859-1 To: linux-btrfs Return-path: List-ID: Signed-off-by: jim owens --- fs/btrfs/dio.c | 247 ++++++++++++++++++++++++++++++++------------------------ 1 files changed, 142 insertions(+), 105 deletions(-) diff --git a/fs/btrfs/dio.c b/fs/btrfs/dio.c index 3315cc9..84277a9 100644 --- a/fs/btrfs/dio.c +++ b/fs/btrfs/dio.c @@ -74,7 +74,7 @@ struct btrfs_dio_extcb { struct btrfs_diocb *diocb; struct extent_map *em; /* chunk stripe map for this extent */ - /* active_umc points at diocb.umc in submit and extcb.umc in completion */ + /* active_umc is diocb.umc in submit and extcb.umc in completion */ struct btrfs_dio_user_mem_control *active_umc; struct btrfs_dio_user_mem_control umc; struct extent_buffer *leaf; @@ -106,7 +106,7 @@ struct btrfs_dio_extcb { int bo_used; /* order[] bio entries in use */ int bo_now; /* order[bo_now] being completed */ - int bo_bvn; /* order[bo_now] bi_io_vec being completed */ + int bo_bvn; /* order[bo_now] bi_io_vec */ int bo_frag; /* bv_len unfinished on error */ struct page *csum_pg1; /* temp read area for unaligned I/O */ @@ -120,6 +120,7 @@ struct btrfs_dio_extcb { /* single master control for user's directIO request */ struct btrfs_diocb { + /* coordinate all submit, I/O interrupt, reaping, completion threads */ spinlock_t diolock; struct kiocb *kiocb; struct inode *inode; @@ -128,7 +129,7 @@ struct btrfs_diocb { u64 lockstart; u64 lockend; u64 begin; /* original beginning file position */ - u64 terminate; /* fpos after failed submit/completion */ + u64 terminate; /* fpos after submit/completion */ struct btrfs_dio_user_mem_control umc; struct workspace *workspace; @@ -160,8 +161,9 @@ static void btrfs_dio_bi_end_io(struct bio *bio, int error); static void btrfs_dio_write(struct btrfs_diocb *diocb); static void btrfs_dio_read(struct btrfs_diocb *diocb); static int btrfs_dio_new_extcb(struct btrfs_dio_extcb **alloc_extcb, - struct btrfs_diocb *diocb, struct extent_map *em); -static void btrfs_dio_eof_tail(u32 *filetail, int eof, struct btrfs_diocb *diocb); + struct btrfs_diocb *diocb, struct extent_map *em); +static void btrfs_dio_eof_tail(u32 *filetail, int eof, + struct btrfs_diocb *diocb); static int btrfs_dio_compressed_read(struct btrfs_diocb *diocb, struct extent_map *lem, u64 data_len); static int btrfs_dio_extent_read(struct btrfs_diocb *diocb, @@ -184,7 +186,8 @@ static int btrfs_dio_not_aligned(unsigned long iomask, u32 testlen, struct btrfs_dio_user_mem_control *umc); static void btrfs_dio_put_user_bvec(struct bio_vec *uv, struct btrfs_dio_user_mem_control *umc); -static void btrfs_dio_release_unused_pages(struct btrfs_dio_user_mem_control *umc); +static void btrfs_dio_release_unused_pages( + struct btrfs_dio_user_mem_control *umc); static void btrfs_dio_skip_user_mem(struct btrfs_dio_user_mem_control *umc, u32 skip_len); static int btrfs_dio_get_next_out(struct bio_vec *ovec, @@ -200,8 +203,10 @@ static int btrfs_dio_drop_workbuf(struct btrfs_dio_extcb *extcb); static void btrfs_dio_complete_bios(struct btrfs_diocb *diocb); static int btrfs_dio_new_bio(struct btrfs_dio_extcb *extcb, int dvn); static void btrfs_dio_submit_bio(struct btrfs_dio_extcb *extcb, int dvn); -static int btrfs_dio_add_user_pages(u64 *dev_left, struct btrfs_dio_extcb *extcb, int dvn); -static int btrfs_dio_add_temp_pages(u64 *dev_left, struct btrfs_dio_extcb *extcb, int dvn); +static int btrfs_dio_add_user_pages(u64 *dev_left, + struct btrfs_dio_extcb *extcb, int dvn); +static int btrfs_dio_add_temp_pages(u64 *dev_left, + struct btrfs_dio_extcb *extcb, int dvn); static int btrfs_dio_hole_read(struct btrfs_diocb *diocb, u64 hole_len); static int btrfs_dio_inline_read(struct btrfs_diocb *diocb, u64 *data_len); static int btrfs_dio_read_csum(struct btrfs_dio_extcb *extcb); @@ -222,7 +227,7 @@ ssize_t btrfs_direct_IO(int rw, struct kiocb *kiocb, /* traditional 512-byte device sector alignment is the * minimum required. if they have a larger sector disk * (possibly multiple sizes in the filesystem) and need - * a larger alignment for this I/O, we just fail later. + * a larger alignment for this I/O, we just fail later. */ if (offset & 511) return -EINVAL; @@ -231,7 +236,8 @@ ssize_t btrfs_direct_IO(int rw, struct kiocb *kiocb, * allow 0-length vectors which are questionable but seem legal. */ for (seg = 0; seg < nr_segs; seg++) { - if (iov[seg].iov_len && ((unsigned long)iov[seg].iov_base & 511)) + if (iov[seg].iov_len && + ((unsigned long)iov[seg].iov_base & 511)) return -EINVAL; if (iov[seg].iov_len & 511) return -EINVAL; @@ -251,7 +257,7 @@ ssize_t btrfs_direct_IO(int rw, struct kiocb *kiocb, diocb->rw = rw; diocb->kiocb = kiocb; - diocb->start = offset; + diocb->start = offset; diocb->begin = offset; diocb->terminate = offset + done; diocb->inode = inode; @@ -292,7 +298,7 @@ ssize_t btrfs_direct_IO(int rw, struct kiocb *kiocb, */ static void btrfs_dio_reaper(struct btrfs_work *work) { - struct btrfs_diocb *diocb = + struct btrfs_diocb *diocb = container_of(work, struct btrfs_diocb, reaper); use_mm(diocb->user_mm); @@ -317,12 +323,12 @@ static void btrfs_dio_reaper(struct btrfs_work *work) */ static void btrfs_dio_aio_submit(struct btrfs_work *work) { - struct btrfs_diocb *diocb = + struct btrfs_diocb *diocb = container_of(work, struct btrfs_diocb, submit); ssize_t done; use_mm(diocb->user_mm); - + if (diocb->rw == READ) btrfs_dio_read(diocb); else @@ -378,7 +384,7 @@ static void btrfs_dio_free_diocb(struct btrfs_diocb *diocb) /* must be called with diocb->diolock held. * performs "all bios are done for extcb" processing * to prevent submit/reap thread race - */ + */ static void btrfs_dio_extcb_biodone(struct btrfs_dio_extcb *extcb) { struct btrfs_diocb *diocb = extcb->diocb; @@ -431,18 +437,19 @@ static void btrfs_dio_read(struct btrfs_diocb *diocb) int err = 0; int loop = 0; - /* expand lock region to include what we read to validate checksum */ + /* expand lock region to include what we read to validate checksum */ diocb->lockstart = diocb->start & ~(diocb->blocksize-1); diocb->lockend = ALIGN(diocb->terminate, diocb->blocksize) - 1; getlock: mutex_lock(&diocb->inode->i_mutex); - + /* ensure writeout and btree update on everything * we might read for checksum or compressed extents */ data_len = diocb->lockend + 1 - diocb->lockstart; - err = btrfs_wait_ordered_range(diocb->inode, diocb->lockstart, data_len); + err = btrfs_wait_ordered_range(diocb->inode, + diocb->lockstart, data_len); if (err) { diocb->error = err; mutex_unlock(&diocb->inode->i_mutex); @@ -469,28 +476,31 @@ getlock: struct extent_map *em; u64 len = data_len; - em = btrfs_get_extent(diocb->inode, NULL, 0, diocb->start, len, 0); + em = btrfs_get_extent(diocb->inode, NULL, 0, + diocb->start, len, 0); if (!em) { err = -EIO; goto fail; } - /* must be problem flushing ordered data with btree not updated */ + /* problem flushing ordered data with btree not updated */ if (test_bit(EXTENT_FLAG_VACANCY, &em->flags)) { - printk(KERN_ERR "btrfs directIO extent map incomplete ino %lu " + printk(KERN_ERR + "btrfs directIO extent map incomplete ino %lu " "extent start %llu len %llu\n", diocb->inode->i_ino, diocb->start, len); err = -EIO; goto fail; } - + if (em->block_start == EXTENT_MAP_INLINE) { /* ugly stuff because inline can exist in a large file * with other extents if a hole immediately follows. * the inline might end short of the btrfs block with * an implied hole that we need to zero here. */ - u64 expected = min(diocb->start + len, em->start + em->len); + u64 expected = min(diocb->start + len, + em->start + em->len); err = btrfs_dio_inline_read(diocb, &len); if (!err && expected > diocb->start) { data_len -= len; @@ -500,17 +510,18 @@ getlock: } else { len = min(len, em->len - (diocb->start - em->start)); if (test_bit(EXTENT_FLAG_PREALLOC, &em->flags) || - em->block_start == EXTENT_MAP_HOLE) { + em->block_start == EXTENT_MAP_HOLE) { err = btrfs_dio_hole_read(diocb, len); - } else if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) { - if (diocb->lockstart > em->start || diocb->lockend < - em->start + em->len - 1) { - /* lock everything we must read to inflate */ + } else if (test_bit(EXTENT_FLAG_COMPRESSED, + &em->flags)) { + if (diocb->lockstart > em->start || + diocb->lockend < em->start + em->len - 1) { + /* lock everything we read to inflate */ unlock_extent(io_tree, diocb->lockstart, diocb->lockend, GFP_NOFS); diocb->lockstart = em->start; diocb->lockend = max(diocb->lockend, - em->start + em->len - 1); + em->start + em->len - 1); free_extent_map(em); goto getlock; } @@ -536,18 +547,19 @@ fail: * need to unlock the unprocessed remainder */ if (diocb->lockstart <= diocb->lockend) - unlock_extent(io_tree, diocb->lockstart, diocb->lockend, GFP_NOFS); + unlock_extent(io_tree, diocb->lockstart, + diocb->lockend, GFP_NOFS); } static int btrfs_dio_new_extcb(struct btrfs_dio_extcb **alloc_extcb, - struct btrfs_diocb *diocb, struct extent_map *em) + struct btrfs_diocb *diocb, struct extent_map *em) { int devices = btrfs_map_stripe_count(em); struct btrfs_dio_extcb *extcb; extcb = kzalloc(sizeof(*extcb) + sizeof(struct btrfs_dio_dev) * devices, GFP_NOFS); - if (!extcb) + if (!extcb) return -ENOMEM; extcb->em = em; @@ -585,7 +597,7 @@ static int btrfs_dio_compressed_read(struct btrfs_diocb *diocb, int err; struct btrfs_dio_extcb *extcb; - /* get single extent map with device raid layout for compressed data */ + /* get single extent map with device raid layout for compressed data */ read_lock(&em_tree->lock); em = lookup_extent_mapping(em_tree, compressed_start, compressed_len); read_unlock(&em_tree->lock); @@ -617,14 +629,15 @@ static int btrfs_dio_compressed_read(struct btrfs_diocb *diocb, /* read entire compressed extent into temp pages, * it must all fit in one extcb for us to inflate */ - err = btrfs_dio_read_stripes(extcb, &compressed_start, &compressed_len, 1); + err = btrfs_dio_read_stripes(extcb, &compressed_start, + &compressed_len, 1); if (compressed_len && !err) err = -EIO; if (!err) diocb->start += data_len; /* adjust diocb->iov and diocb->iov_left to account - * for uncompressed size so we start the next extent + * for uncompressed size so we start the next extent * at the proper point in user memory */ btrfs_dio_skip_user_mem(&diocb->umc, data_len); @@ -647,12 +660,13 @@ static int btrfs_dio_compressed_read(struct btrfs_diocb *diocb, * and memcpy to user on completion the part that does not match * the users I/O alignment (for now always 511) */ -static void btrfs_dio_eof_tail(u32 *filetail, int eof, struct btrfs_diocb *diocb) +static void btrfs_dio_eof_tail(u32 *filetail, int eof, + struct btrfs_diocb *diocb) { if (eof) *filetail &= 511; else - *filetail = 0; /* aligned direct to user memory */ + *filetail = 0; /* aligned direct to user memory */ } /* called with a hard-sector bounded file byte data start/len @@ -691,7 +705,7 @@ static int btrfs_dio_extent_read(struct btrfs_diocb *diocb, struct btrfs_dio_extcb *extcb; u64 filelen = 0; - /* get device extent map for next contiguous chunk */ + /* get device extent map for next contiguous chunk */ read_lock(&em_tree->lock); em = lookup_extent_mapping(em_tree, data_start, data_len); read_unlock(&em_tree->lock); @@ -729,14 +743,14 @@ static int btrfs_dio_extent_read(struct btrfs_diocb *diocb, * but file tail can be 1-byte aligned. since we need * to have a temp page for checksum, we put the tail in * that page and copy it to user memory on completion so - * post-xfer-memory looks the same as compressed or inline + * post-xfer-memory looks the same as compressed or inline */ data_len -= csum_after + filetail; filelen = data_len; if (data_len) { /* add_user_pages submits must be done using diocb */ extcb->active_umc = &diocb->umc; - err = btrfs_dio_read_stripes(extcb, + err = btrfs_dio_read_stripes(extcb, &data_start, &data_len, 0); filelen -= data_len; if (err) @@ -767,11 +781,13 @@ static int btrfs_dio_extent_read(struct btrfs_diocb *diocb, (diocb->blocksize - 1); data_len -= align_size; if (csum && filetail) - csum_after = diocb->blocksize - filetail; + csum_after = diocb->blocksize - + filetail; else csum_after = 0; if (filetail) - btrfs_dio_eof_tail(&filetail, eof, diocb); + btrfs_dio_eof_tail(&filetail, + eof, diocb); } extcb->csum_pg2 = extcb->csum_pg1; @@ -783,8 +799,9 @@ static int btrfs_dio_extent_read(struct btrfs_diocb *diocb, extcb->filetail = 0; goto fail; } - /* must skip area we will copy into on completion */ - btrfs_dio_skip_user_mem(&diocb->umc, extcb->filetail); + /* must skip area we copy into on completion */ + btrfs_dio_skip_user_mem(&diocb->umc, + extcb->filetail); extcb->beforetail = filelen; } data_len += csum_after + filetail; @@ -838,7 +855,7 @@ static void btfrs_dio_unplug(struct btrfs_dio_extcb *extcb) btrfs_dio_submit_bio(extcb, dvn); if (extcb->diodev[dvn].unplug) { struct backing_dev_info *bdi = blk_get_backing_dev_info( - btrfs_map_stripe_bdev(extcb->em, dvn)); + btrfs_map_stripe_bdev(extcb->em, dvn)); if (bdi && bdi->unplug_io_fn) bdi->unplug_io_fn(bdi, NULL); } @@ -864,7 +881,8 @@ retry: dvn = stripe_info.stripe_index; extcb->diodev[dvn].physical = stripe_info.phys_offset + - btrfs_map_stripe_physical(extcb->em, stripe_info.stripe_index); + btrfs_map_stripe_physical(extcb->em, + stripe_info.stripe_index); /* device start and length may not be sector aligned or * user memory address/length vectors may not be aligned @@ -872,11 +890,12 @@ retry: * we might have different size devices in the filesystem, * so retry all copies to see if any meet the alignment. */ - iomask = bdev_logical_block_size(btrfs_map_stripe_bdev(extcb->em, dvn)) - 1; - if ((extcb->diodev[dvn].physical & iomask) || (dev_left & iomask) || - (!temp_pages && - btrfs_dio_not_aligned(iomask, (u32)dev_left, - &extcb->diocb->umc))) { + iomask = bdev_logical_block_size( + btrfs_map_stripe_bdev(extcb->em, dvn)) - 1; + if ((extcb->diodev[dvn].physical & iomask) || + (dev_left & iomask) || (!temp_pages && + btrfs_dio_not_aligned(iomask, (u32)dev_left, + &extcb->diocb->umc))) { if (mirror < btrfs_map_num_copies(extcb->em)) { mirror++; goto retry; @@ -955,10 +974,12 @@ static void btrfs_dio_put_next_in(struct bio_vec *vec, extcb->bo_bvn--; } else { extcb->bo_now--; - extcb->bo_bvn = extcb->order[extcb->bo_now]->bi_vcnt - 1; + extcb->bo_bvn = extcb->order[extcb->bo_now]-> + bi_vcnt - 1; } - bv_len = extcb->order[extcb->bo_now]->bi_io_vec[extcb->bo_bvn].bv_len; + bv_len = extcb->order[extcb->bo_now]-> + bi_io_vec[extcb->bo_bvn].bv_len; if (vec->bv_len < bv_len) { extcb->bo_frag = vec->bv_len; vec->bv_len = 0; @@ -977,14 +998,15 @@ static int btrfs_dio_inflate_next_in(struct bio_vec *ivec, btrfs_dio_get_next_in(ivec, extcb); return 0; } - + static int btrfs_dio_inline_next_in(struct bio_vec *ivec, struct btrfs_inflate *icb) { struct btrfs_dio_extcb *extcb = container_of(icb, struct btrfs_dio_extcb, icb); - access_extent_buffer_page(ivec, extcb->leaf, extcb->iostart, extcb->iolen); + access_extent_buffer_page(ivec, extcb->leaf, + extcb->iostart, extcb->iolen); extcb->iostart += ivec->bv_len; extcb->iolen -= ivec->bv_len; return 0; @@ -1031,7 +1053,7 @@ static int btrfs_dio_get_user_bvec(struct bio_vec *uv, } else { /* unaligned user vectors may have multiple page releasers so * we must increment ref count now to prevent premature release - */ + */ get_page(uv->bv_page); } @@ -1081,7 +1103,7 @@ static void btrfs_dio_put_user_bvec(struct bio_vec *uv, umc->remaining += uv->bv_len; umc->todo += uv->bv_len; if (umc->work_iov.iov_len == uv->bv_len || - uv->bv_offset + uv->bv_len == PAGE_SIZE) { + uv->bv_offset + uv->bv_len == PAGE_SIZE) { umc->next_user_page--; umc->user_pages_left++; } else { @@ -1091,7 +1113,8 @@ static void btrfs_dio_put_user_bvec(struct bio_vec *uv, } /* error processing only, release unused user pages */ -static void btrfs_dio_release_unused_pages(struct btrfs_dio_user_mem_control *umc) +static void btrfs_dio_release_unused_pages( + struct btrfs_dio_user_mem_control *umc) { while (umc->user_pages_left) { page_cache_release(umc->pagelist[umc->next_user_page]); @@ -1147,8 +1170,7 @@ static void btrfs_dio_release_bios(struct btrfs_dio_extcb *extcb, int dirty) for (pn = 0; pn < bio->bi_vcnt; pn++) { struct page *page = bvec[pn].bv_page; if (dirty && !PageCompound(page) && - page != extcb->csum_pg1 && - page != extcb->csum_pg2) + page != extcb->csum_pg1 && page != extcb->csum_pg2) set_page_dirty_lock(page); page_cache_release(page); } @@ -1168,7 +1190,8 @@ static void btrfs_dio_read_done(struct btrfs_dio_extcb *extcb) char *filetail; char *out; - extcb->error = btrfs_dio_get_user_bvec(&uv, extcb->active_umc); + extcb->error = btrfs_dio_get_user_bvec(&uv, + extcb->active_umc); if (extcb->error) { extcb->filestart -= extcb->active_umc->todo; goto fail; @@ -1190,7 +1213,7 @@ fail: * all-or-nothing as partial result from zlib is likely garbage. * we don't retry if decompression fails, the assumption is * all mirrors are trash because we had valid checksums. - */ + */ static void btrfs_dio_decompress(struct btrfs_dio_extcb *extcb) { u32 len = extcb->icb.out_len; @@ -1203,7 +1226,8 @@ static void btrfs_dio_decompress(struct btrfs_dio_extcb *extcb) struct bio_vec uv; char *out; - extcb->error = btrfs_dio_get_user_bvec(&uv, &extcb->umc); + extcb->error = btrfs_dio_get_user_bvec(&uv, + &extcb->umc); if (extcb->error) goto fail; out = kmap_atomic(uv.bv_page, KM_USER0); @@ -1311,8 +1335,8 @@ static void btrfs_dio_complete_bios(struct btrfs_diocb *diocb) if (!err2) err2 = btrfs_dio_get_workbuf(extcb); - if (!err2 && !(BTRFS_I(diocb->inode)->flags - & BTRFS_INODE_NODATASUM)) { + if (!err2 && !(BTRFS_I(diocb->inode)-> + flags & BTRFS_INODE_NODATASUM)) { err2 = btrfs_dio_read_csum(extcb); if (extcb->retry_bio) { btrfs_dio_drop_workbuf(extcb); @@ -1384,9 +1408,9 @@ static void btrfs_dio_submit_bio(struct btrfs_dio_extcb *extcb, int dvn) * bio is full or device read/write length remaining is 0. * spans memory segments in multiple io vectors that can * begin and end on non-page (but sector-size aligned) boundaries. - */ -static int btrfs_dio_add_user_pages(u64 *dev_left, struct btrfs_dio_extcb *extcb, - int dvn) + */ +static int btrfs_dio_add_user_pages(u64 *dev_left, + struct btrfs_dio_extcb *extcb, int dvn) { extcb->active_umc->todo = *dev_left; while (extcb->diodev[dvn].vecs && *dev_left) { @@ -1411,8 +1435,8 @@ static int btrfs_dio_add_user_pages(u64 *dev_left, struct btrfs_dio_extcb *extcb } /* submit kernel temporary pages for compressed read */ -static int btrfs_dio_add_temp_pages(u64 *dev_left, struct btrfs_dio_extcb *extcb, - int dvn) +static int btrfs_dio_add_temp_pages(u64 *dev_left, + struct btrfs_dio_extcb *extcb, int dvn) { while (extcb->diodev[dvn].vecs && *dev_left) { unsigned int pglen = min_t(long, *dev_left, PAGE_SIZE); @@ -1475,13 +1499,15 @@ static int btrfs_dio_inline_read(struct btrfs_diocb *diocb, u64 *data_len) path = btrfs_alloc_path(); - err = btrfs_lookup_file_extent(NULL, root, path, objectid, diocb->start, 0); + err = btrfs_lookup_file_extent(NULL, root, path, objectid, + diocb->start, 0); if (err) { if (err < 0) goto notfound; - err= -EDOM; + err = -EDOM; if (path->slots[0] == 0) { - printk(KERN_ERR "btrfs directIO inline extent leaf not found ino %lu\n", + printk(KERN_ERR + "btrfs directIO inline not found ino %lu\n", diocb->inode->i_ino); goto fail; } @@ -1493,11 +1519,11 @@ static int btrfs_dio_inline_read(struct btrfs_diocb *diocb, u64 *data_len) struct btrfs_file_extent_item); btrfs_item_key_to_cpu(leaf, &found_key, path->slots[0]); if (found_key.objectid != objectid || - btrfs_key_type(&found_key) != BTRFS_EXTENT_DATA_KEY || - btrfs_file_extent_type(leaf, item) != BTRFS_FILE_EXTENT_INLINE) { - printk(KERN_ERR "btrfs directIO inline extent leaf mismatch ino %lu\n", - diocb->inode->i_ino); - err= -EDOM; + btrfs_key_type(&found_key) != BTRFS_EXTENT_DATA_KEY || + btrfs_file_extent_type(leaf, item) != BTRFS_FILE_EXTENT_INLINE) { + printk(KERN_ERR "btrfs directIO inline leaf mismatch ino %lu\n", + diocb->inode->i_ino); + err = -EDOM; goto fail; } @@ -1505,10 +1531,10 @@ static int btrfs_dio_inline_read(struct btrfs_diocb *diocb, u64 *data_len) /* uncompressed size */ size = btrfs_file_extent_inline_len(leaf, item); if (diocb->start < extent_start) { - printk(KERN_ERR "btrfs directIO inline extent range mismatch ino %lu" + printk(KERN_ERR "btrfs directIO inline range mismatch ino %lu" " fpos %lld found start %lld size %ld\n", - diocb->inode->i_ino,diocb->start,extent_start,size); - err= -EDOM; + diocb->inode->i_ino, diocb->start, extent_start, size); + err = -EDOM; goto fail; } @@ -1525,8 +1551,7 @@ static int btrfs_dio_inline_read(struct btrfs_diocb *diocb, u64 *data_len) size = min_t(u64, *data_len, size); *data_len = size; - if (btrfs_file_extent_compression(leaf, item) == - BTRFS_COMPRESS_ZLIB) { + if (btrfs_file_extent_compression(leaf, item) == BTRFS_COMPRESS_ZLIB) { struct btrfs_dio_extcb *extcb; extcb = kzalloc(sizeof(*extcb), GFP_NOFS); @@ -1555,7 +1580,7 @@ static int btrfs_dio_inline_read(struct btrfs_diocb *diocb, u64 *data_len) extcb->icb.get_next_in = btrfs_dio_inline_next_in; extcb->icb.get_next_out = btrfs_dio_get_next_out; extcb->icb.done_with_out = btrfs_dio_done_with_out; - /* NULL icb.workspace so btrfs_zlib_inflate allocates workspace */ + /* NULL icb.workspace so btrfs_zlib_inflate allocs workspace */ extcb->leaf = leaf; @@ -1615,13 +1640,15 @@ notfound: static int btrfs_dio_read_csum(struct btrfs_dio_extcb *extcb) { struct bio_vec ivec; - struct btrfs_root *root = BTRFS_I(extcb->diocb->inode)->root->fs_info->csum_root; + struct btrfs_root *root = + BTRFS_I(extcb->diocb->inode)->root->fs_info->csum_root; u32 iolen_per_csum_buf = extcb->diocb->blocksize * (extcb->tmpbuf_size / btrfs_super_csum_size(&root->fs_info->super_copy)); if (extcb->iolen & (extcb->diocb->blocksize - 1)) { - printk(KERN_WARNING "btrfs directIO unaligned checksum for ino %lu\n", - extcb->diocb->inode->i_ino); + printk(KERN_WARNING + "btrfs directIO unaligned checksum for ino %lu\n", + extcb->diocb->inode->i_ino); extcb->iolen &= ~(extcb->diocb->blocksize - 1); } @@ -1633,11 +1660,14 @@ static int btrfs_dio_read_csum(struct btrfs_dio_extcb *extcb) u32 csum; int err; - err = btrfs_lookup_csums_range(root, extcb->iostart, end, NULL, fs_csum); + err = btrfs_lookup_csums_range(root, extcb->iostart, end, + NULL, fs_csum); if (err) { - printk(KERN_ERR "btrfs directIO csum lookup failed ino %lu " + printk(KERN_ERR + "btrfs directIO csum lookup failed ino %lu " "extent start %llu end %llu\n", - extcb->diocb->inode->i_ino, extcb->iostart, end); + extcb->diocb->inode->i_ino, + extcb->iostart, end); return err; } @@ -1647,7 +1677,7 @@ static int btrfs_dio_read_csum(struct btrfs_dio_extcb *extcb) /* each checksum block is a filesystem block and on the * same device, but user memory can be 512 byte aligned * so we have to be able to span multiple pages here - */ + */ csum = ~(u32)0; while (csum_len) { char *in; @@ -1657,7 +1687,8 @@ static int btrfs_dio_read_csum(struct btrfs_dio_extcb *extcb) btrfs_dio_get_next_in(&ivec, extcb); cl = min_t(size_t, ivec.bv_len, csum_len); in = kmap_atomic(ivec.bv_page, KM_USER0); - csum = btrfs_csum_data(root, in + ivec.bv_offset, csum, cl); + csum = btrfs_csum_data(root, + in + ivec.bv_offset, csum, cl); kunmap_atomic(in, KM_USER0); ivec.bv_offset += cl; ivec.bv_len -= cl; @@ -1666,7 +1697,8 @@ static int btrfs_dio_read_csum(struct btrfs_dio_extcb *extcb) btrfs_csum_final(csum, (char *)&csum); if (csum != *fs_csum) { - printk(KERN_WARNING "btrfs directIO csum failed ino %lu " + printk(KERN_WARNING + "btrfs directIO csum failed ino %lu " "block %llu csum %u wanted %u\n", extcb->diocb->inode->i_ino, extcb->iostart, csum, *fs_csum); @@ -1695,9 +1727,11 @@ static int btrfs_dio_read_csum(struct btrfs_dio_extcb *extcb) if (!extcb->iolen && extcb->filetail) { extcb->filestart += extcb->filetail; } else { - extcb->filestart += extcb->diocb->blocksize; + extcb->filestart += + extcb->diocb->blocksize; /* 1st extent can start inside block */ - extcb->filestart &= ~(extcb->diocb->blocksize -1); + extcb->filestart &= + ~(extcb->diocb->blocksize - 1); } } len -= extcb->diocb->blocksize; @@ -1748,7 +1782,8 @@ static int btrfs_dio_retry_block(struct btrfs_dio_extcb *extcb) if (extcb->compressed || !good) return -EIO; /* no checksum, return partial success of i/o from device */ - if (BTRFS_I(extcb->diocb->inode)->flags & BTRFS_INODE_NODATASUM) { + if (BTRFS_I(extcb->diocb->inode)-> + flags & BTRFS_INODE_NODATASUM) { extcb->filestart += good; return -EIO; } @@ -1850,14 +1885,14 @@ static int btrfs_dio_read_retry(struct btrfs_dio_extcb *extcb) extcb->error = 0; if (extcb->retry_csum) { - struct btrfs_root *root = BTRFS_I(extcb->diocb->inode)-> - root->fs_info->csum_root; + struct btrfs_root *root = + BTRFS_I(extcb->diocb->inode)->root->fs_info->csum_root; struct bio_vec *retry = extcb->retry_bio->bi_io_vec; char *new; u32 csum = ~0; size_t csum_len = extcb->retry_len; - /* blocksize can exceed page size */ + /* blocksize can exceed page size */ while (csum_len) { size_t cl = min_t(size_t, retry->bv_len, csum_len); new = kmap_atomic(retry->bv_page, KM_USER0); @@ -1884,7 +1919,7 @@ static int btrfs_dio_read_retry(struct btrfs_dio_extcb *extcb) offset = extcb->retry_start & (extcb->diocb->blocksize-1); retry->bv_offset += offset; retry->bv_len -= offset; - + bad.bv_len = 0; while (bad_len) { size_t cl; @@ -1893,7 +1928,8 @@ static int btrfs_dio_read_retry(struct btrfs_dio_extcb *extcb) if (bad.bv_len == 0) btrfs_dio_get_next_in(&bad, extcb); - cl = min_t(size_t, bad_len, min(bad.bv_len, retry->bv_len)); + cl = min_t(size_t, bad_len, + min(bad.bv_len, retry->bv_len)); new = kmap_atomic(retry->bv_page, KM_USER0); out = kmap_atomic(bad.bv_page, KM_USER1); memcpy(out + bad.bv_offset, new + retry->bv_offset, cl); @@ -1909,7 +1945,7 @@ static int btrfs_dio_read_retry(struct btrfs_dio_extcb *extcb) bad_len -= cl; } - /* record unfinished part of unaligned user memory for next retry */ + /* record unfinished part of user memory for next retry */ btrfs_dio_put_next_in(&bad, extcb); } @@ -1923,11 +1959,12 @@ static int btrfs_dio_read_retry(struct btrfs_dio_extcb *extcb) extcb->filestart += extcb->filetail; } else { extcb->filestart += extcb->diocb->blocksize; - extcb->filestart &= ~(extcb->diocb->blocksize -1); + extcb->filestart &= + ~(extcb->diocb->blocksize - 1); } } return 0; - } + } /* we are still processing bad bios from I/O submit */ extcb->retry_start += extcb->diocb->blocksize; @@ -1939,7 +1976,7 @@ static int btrfs_dio_read_retry(struct btrfs_dio_extcb *extcb) return btrfs_dio_retry_block(extcb); /* continue scan with next bio */ - if (extcb->compressed) /* uncompressed copy already incremented bo_now */ + if (extcb->compressed) /* uncompressed copy incremented bo_now */ extcb->bo_now++; return btrfs_dio_bad_bio_scan(extcb); } -- 1.6.3.3