On tue, 18 Dec 2012 15:30:51 +0800, Liu Bo wrote:
> On Mon, Dec 17, 2012 at 11:13:25PM -0800, clinew@xxxxxxxxxxxxxxxxxx wrote:
>> From: Wade Cline <clinew@xxxxxxxxxxxxxxxxxx>
>>
>> v1 -> v2:
>> - Added Signed-off-by tag (it's kind of important).
>>
>> This patch is only an RFC. My internship is ending and I was hoping
>> to get some feedback and incorporate any suggestions people may
>> have before my internship ends along with life as we know it (this
>> Friday).
>>
>> The filesystem should mount/umount properly but tends towards the
>> explosive side when writes start happening. My current focus is on
>> checksumming issues and also an error when releasing extent buffers
>> when creating a large file with 'dd'... and probably any other
>> method. There's still a significant amount of work that needs to be
>> done before this should be incorporated into mainline.
>>
>> A couple of notes:
>> - Based off of Josef's btrfs-next branch, commit
>> 8d089a86e45b34d7bc534d955e9d8543609f7e42
>> - C99-style comments are "meta-comments" where I'd like more
>> feedback; they aren't permanent but make 'checkpatch' moan.
>> - extent_buffer allocation and freeing need their code paths
>> merged; they're currently in separate functions and are both
>> very ugly.
>> - The patch itself will eventually need to be broken down
>> into smaller pieces if at all possible...
>
> Could you please first elaborate why we need this subpagesize stuff and
> any user case in this patch's commit log?
> Or Am I missing something?
It is used on the machines on which the page size is larger than 4KB (Such as powerpc)
Thanks
Miao
>
> thanks,
> liubo
>
>>
>> Signed-off-by: Wade Cline <clinew@xxxxxxxxxxxxxxxxxx>
>> ---
>> fs/btrfs/ctree.h | 11 +-
>> fs/btrfs/disk-io.c | 110 +++++++--
>> fs/btrfs/extent_io.c | 632 ++++++++++++++++++++++++++++++++++++++-----
>> fs/btrfs/extent_io.h | 7 +
>> fs/btrfs/file.c | 9 +-
>> fs/btrfs/free-space-cache.c | 2 +
>> fs/btrfs/inode.c | 38 ++-
>> fs/btrfs/ioctl.c | 4 +-
>> 8 files changed, 709 insertions(+), 104 deletions(-)
>>
>> diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
>> index fbaaf20..c786a58 100644
>> --- a/fs/btrfs/ctree.h
>> +++ b/fs/btrfs/ctree.h
>> @@ -1938,14 +1938,19 @@ static inline void btrfs_set_token_##name(struct extent_buffer *eb, \
>> #define BTRFS_SETGET_HEADER_FUNCS(name, type, member, bits) \
>> static inline u##bits btrfs_##name(struct extent_buffer *eb) \
>> { \
>> - type *p = page_address(eb->pages[0]); \
>> - u##bits res = le##bits##_to_cpu(p->member); \
>> + type *p; \
>> + u##bits res; \
>> + \
>> + p = page_address(eb->pages[0]) + (eb->start & (PAGE_SIZE - 1)); \
>> + res = le##bits##_to_cpu(p->member); \
>> return res; \
>> } \
>> static inline void btrfs_set_##name(struct extent_buffer *eb, \
>> u##bits val) \
>> { \
>> - type *p = page_address(eb->pages[0]); \
>> + type *p; \
>> + \
>> + p = page_address(eb->pages[0]) + (eb->start & (PAGE_SIZE - 1)); \
>> p->member = cpu_to_le##bits(val); \
>> }
>>
>> diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
>> index f633af8..00b80b7 100644
>> --- a/fs/btrfs/disk-io.c
>> +++ b/fs/btrfs/disk-io.c
>> @@ -373,6 +373,24 @@ static int btree_read_extent_buffer_pages(struct btrfs_root *root,
>> WAIT_COMPLETE,
>> btree_get_extent, mirror_num);
>> if (!ret) {
>> + /*
>> + * I think that this is bad and should be moved
>> + * into btree_readpage_end_io_hook(), but that
>> + * it should apply to a single block at a time.
>> + * That may be difficult and would make the
>> + * function name a misnomer, but mostly I hate
>> + * the silly goto.
>> + */
>> + if (eb->len < PAGE_SIZE &&
>> + !extent_buffer_uptodate(eb)) {
>> + if (csum_tree_block(root, eb, 1)) {
>> + ret = -EIO;
>> + goto bad;
>> + } else {
>> + set_extent_buffer_uptodate(eb);
>> + }
>> + }
>> +
>> if (!verify_parent_transid(io_tree, eb,
>> parent_transid, 0))
>> break;
>> @@ -385,6 +403,7 @@ static int btree_read_extent_buffer_pages(struct btrfs_root *root,
>> * there is no reason to read the other copies, they won't be
>> * any less wrong.
>> */
>> +bad:
>> if (test_bit(EXTENT_BUFFER_CORRUPT, &eb->bflags))
>> break;
>>
>> @@ -416,29 +435,55 @@ static int btree_read_extent_buffer_pages(struct btrfs_root *root,
>> * checksum a dirty tree block before IO. This has extra checks to make sure
>> * we only fill in the checksum field in the first page of a multi-page block
>> */
>> -
>> -static int csum_dirty_buffer(struct btrfs_root *root, struct page *page)
>> +static int csum_dirty_buffer(struct btrfs_root *root, struct page *page,
>> + unsigned int offset, unsigned int len)
>> {
>> - struct extent_io_tree *tree;
>> u64 start = (u64)page->index << PAGE_CACHE_SHIFT;
>> u64 found_start;
>> struct extent_buffer *eb;
>>
>> - tree = &BTRFS_I(page->mapping->host)->io_tree;
>> + if (!PageUptodate(page)) {
>> + WARN_ON(1);
>> + return 0;
>> + }
>>
>> eb = (struct extent_buffer *)page->private;
>> - if (page != eb->pages[0])
>> - return 0;
>> + if (eb->len >= PAGE_SIZE) {
>> + if (eb->pages[0] != page)
>> + return 0;
>> + } else {
>> + start += offset;
>> + while (eb->start != start) {
>> + eb = eb->next;
>> + BUG_ON(!eb);
>> + }
>> +next:
>> + if (!test_bit(EXTENT_BUFFER_WRITEBACK, &eb->bflags))
>> + WARN_ON(1);
>> + if (!test_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags))
>> + WARN_ON(1);
>> + if (eb->pages[0] != page)
>> + WARN_ON(1);
>> + }
>> +
>> found_start = btrfs_header_bytenr(eb);
>> if (found_start != start) {
>> WARN_ON(1);
>> return 0;
>> }
>> - if (!PageUptodate(page)) {
>> - WARN_ON(1);
>> - return 0;
>> - }
>> +
>> csum_tree_block(root, eb, 0);
>> +
>> + if (eb->len < PAGE_SIZE) {
>> + len -= eb->len;
>> + BUG_ON(len & (eb->len - 1));
>> + if (len) {
>> + start += eb->len;
>> + eb = eb->next;
>> + goto next;
>> + }
>> + }
>> +
>> return 0;
>> }
>>
>> @@ -579,6 +624,19 @@ static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
>>
>> tree = &BTRFS_I(page->mapping->host)->io_tree;
>> eb = (struct extent_buffer *)page->private;
>> + if (eb->len < PAGE_SIZE) {
>> + /* Find the eb that tried to submit a read request. This is
>> + * a little bit funky. */
>> + do {
>> + if (!atomic_read(&eb->io_pages))
>> + continue;
>> + if (test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags) ||
>> + test_bit(EXTENT_BUFFER_WRITEBACK, &eb->bflags))
>> + continue;
>> + break;
>> + } while ((eb = eb->next));
>> + BUG_ON(!eb);
>> + }
>>
>> /* the pending IO might have been the only thing that kept this buffer
>> * in memory. Make sure we have a ref for all this other checks
>> @@ -615,8 +673,11 @@ static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
>> btrfs_set_buffer_lockdep_class(btrfs_header_owner(eb),
>> eb, found_level);
>>
>> - ret = csum_tree_block(root, eb, 1);
>> - if (ret) {
>> + /*
>> + * Subpagesize blocksize checksumming is currently done in
>> + * btree_read_extent_buffer_pages().
>> + */
>> + if (eb->len >= PAGE_SIZE && csum_tree_block(root, eb, 1)) {
>> ret = -EIO;
>> goto err;
>> }
>> @@ -631,8 +692,15 @@ static int btree_readpage_end_io_hook(struct page *page, u64 start, u64 end,
>> ret = -EIO;
>> }
>>
>> - if (!ret)
>> + /*
>> + * For subpagesize blocksize, only the page needs to be set
>> + * up-to-date; each extent_buffer is set up-to-date when it is
>> + * checksummed.
>> + */
>> + if (eb->len >= PAGE_SIZE)
>> set_extent_buffer_uptodate(eb);
>> + else
>> + SetPageUptodate(eb->pages[0]);
>> err:
>> if (test_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags)) {
>> clear_bit(EXTENT_BUFFER_READAHEAD, &eb->bflags);
>> @@ -828,7 +896,8 @@ static int btree_csum_one_bio(struct bio *bio)
>> WARN_ON(bio->bi_vcnt <= 0);
>> while (bio_index < bio->bi_vcnt) {
>> root = BTRFS_I(bvec->bv_page->mapping->host)->root;
>> - ret = csum_dirty_buffer(root, bvec->bv_page);
>> + ret = csum_dirty_buffer(root, bvec->bv_page, bvec->bv_offset,
>> + bvec->bv_len);
>> if (ret)
>> break;
>> bio_index++;
>> @@ -1007,9 +1076,13 @@ static int btree_set_page_dirty(struct page *page)
>> BUG_ON(!PagePrivate(page));
>> eb = (struct extent_buffer *)page->private;
>> BUG_ON(!eb);
>> - BUG_ON(!test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
>> - BUG_ON(!atomic_read(&eb->refs));
>> - btrfs_assert_tree_locked(eb);
>> + /* There doesn't seem to be a method for passing the correct eb
>> + * to this function, so no sanity checks for subpagesize blocksize. */
>> + if (eb->len >= PAGE_SIZE) {
>> + BUG_ON(!test_bit(EXTENT_BUFFER_DIRTY, &eb->bflags));
>> + BUG_ON(!atomic_read(&eb->refs));
>> + btrfs_assert_tree_locked(eb);
>> + }
>> #endif
>> return __set_page_dirty_nobuffers(page);
>> }
>> @@ -2400,11 +2473,14 @@ int open_ctree(struct super_block *sb,
>> goto fail_sb_buffer;
>> }
>>
>> +#if 0
>> + // Hmm. How to deal wth this for subpagesize blocksize?
>> if (sectorsize != PAGE_SIZE) {
>> printk(KERN_WARNING "btrfs: Incompatible sector size(%lu) "
>> "found on %s\n", (unsigned long)sectorsize, sb->s_id);
>> goto fail_sb_buffer;
>> }
>> +#endif
>>
>> mutex_lock(&fs_info->chunk_mutex);
>> ret = btrfs_read_sys_array(tree_root);
>> diff --git a/fs/btrfs/extent_io.c b/fs/btrfs/extent_io.c
>> index 1b319df..c1e052e 100644
>> --- a/fs/btrfs/extent_io.c
>> +++ b/fs/btrfs/extent_io.c
>> @@ -2519,7 +2519,7 @@ static int submit_extent_page(int rw, struct extent_io_tree *tree,
>> int contig = 0;
>> int this_compressed = bio_flags & EXTENT_BIO_COMPRESSED;
>> int old_compressed = prev_bio_flags & EXTENT_BIO_COMPRESSED;
>> - size_t page_size = min_t(size_t, size, PAGE_CACHE_SIZE);
>> + size_t bio_size = min_t(size_t, size, PAGE_CACHE_SIZE);
>>
>> if (bio_ret && *bio_ret) {
>> bio = *bio_ret;
>> @@ -2530,8 +2530,8 @@ static int submit_extent_page(int rw, struct extent_io_tree *tree,
>> sector;
>>
>> if (prev_bio_flags != bio_flags || !contig ||
>> - merge_bio(tree, page, offset, page_size, bio, bio_flags) ||
>> - bio_add_page(bio, page, page_size, offset) < page_size) {
>> + merge_bio(tree, page, offset, bio_size, bio, bio_flags) ||
>> + bio_add_page(bio, page, bio_size, offset) < bio_size) {
>> ret = submit_one_bio(rw, bio, mirror_num,
>> prev_bio_flags);
>> if (ret < 0)
>> @@ -2550,7 +2550,7 @@ static int submit_extent_page(int rw, struct extent_io_tree *tree,
>> if (!bio)
>> return -ENOMEM;
>>
>> - bio_add_page(bio, page, page_size, offset);
>> + bio_add_page(bio, page, bio_size, offset);
>> bio->bi_end_io = end_io_func;
>> bio->bi_private = tree;
>>
>> @@ -3168,14 +3168,28 @@ static void end_bio_extent_buffer_writepage(struct bio *bio, int err)
>> int uptodate = err == 0;
>> struct bio_vec *bvec = bio->bi_io_vec + bio->bi_vcnt - 1;
>> struct extent_buffer *eb;
>> + unsigned int offset;
>> + unsigned int bv_len;
>> + u64 start;
>> int done;
>>
>> do {
>> struct page *page = bvec->bv_page;
>> + offset = bvec->bv_offset;
>> + bv_len = bvec->bv_len;
>> + start = ((u64)page->index << PAGE_CACHE_SHIFT) + offset;
>>
>> bvec--;
>> eb = (struct extent_buffer *)page->private;
>> BUG_ON(!eb);
>> + if (eb->len < PAGE_SIZE) {
>> + while (eb->start != start) {
>> + eb = eb->next;
>> + BUG_ON(!eb);
>> + }
>> + }
>> +
>> +next_eb:
>> done = atomic_dec_and_test(&eb->io_pages);
>>
>> if (!uptodate || test_bit(EXTENT_BUFFER_IOERR, &eb->bflags)) {
>> @@ -3184,12 +3198,50 @@ static void end_bio_extent_buffer_writepage(struct bio *bio, int err)
>> SetPageError(page);
>> }
>>
>> - end_page_writeback(page);
>> + if (eb->len >= PAGE_SIZE) {
>> + end_page_writeback(page);
>>
>> - if (!done)
>> - continue;
>> + if (!done)
>> + continue;
>>
>> - end_extent_buffer_writeback(eb);
>> + end_extent_buffer_writeback(eb);
>> + } else {
>> + /* Sanity checks. */
>> + if (!test_bit(EXTENT_BUFFER_WRITEBACK, &eb->bflags))
>> + WARN_ON(1);
>> +
>> + /* Ensure I/O page count is zero. */
>> + if (!done)
>> + WARN_ON(1);
>> +
>> + /* Clear the extent buffer's writeback flag. */
>> + end_extent_buffer_writeback(eb);
>> +
>> + /*
>> + * See if any other extent buffers exists within the
>> + * page.
>> + */
>> + bv_len -= eb->len;
>> + BUG_ON(bv_len & (eb->len - 1));
>> + if (bv_len) {
>> + eb = eb->next;
>> + goto next_eb;
>> + }
>> +
>> + /* Clear the page writeback flag. */
>> + eb = (struct extent_buffer *)page->private;
>> + BUG_ON(!eb); /* Can this even happen? */
>> + do {
>> + if (!eb) {
>> + end_page_writeback(page);
>> + break;
>> + }
>> + if (test_bit(EXTENT_BUFFER_WRITEBACK,
>> + &eb->bflags))
>> + break;
>> + eb = eb->next;
>> + } while (1);
>> + }
>> } while (bvec >= bio->bi_io_vec);
>>
>> bio_put(bio);
>> @@ -3202,7 +3254,8 @@ static int write_one_eb(struct extent_buffer *eb,
>> struct extent_page_data *epd)
>> {
>> struct block_device *bdev = fs_info->fs_devices->latest_bdev;
>> - u64 offset = eb->start;
>> + u64 start = eb->start;
>> + unsigned long offset = eb->start & (PAGE_CACHE_SIZE - 1);
>> unsigned long i, num_pages;
>> unsigned long bio_flags = 0;
>> int rw = (epd->sync_io ? WRITE_SYNC : WRITE);
>> @@ -3219,10 +3272,10 @@ static int write_one_eb(struct extent_buffer *eb,
>>
>> clear_page_dirty_for_io(p);
>> set_page_writeback(p);
>> - ret = submit_extent_page(rw, eb->tree, p, offset >> 9,
>> - PAGE_CACHE_SIZE, 0, bdev, &epd->bio,
>> - -1, end_bio_extent_buffer_writepage,
>> - 0, epd->bio_flags, bio_flags);
>> + ret = submit_extent_page(rw, eb->tree, p, start >> 9, eb->len,
>> + offset, bdev, &epd->bio, -1,
>> + end_bio_extent_buffer_writepage, 0,
>> + epd->bio_flags, bio_flags);
>> epd->bio_flags = bio_flags;
>> if (ret) {
>> set_bit(EXTENT_BUFFER_IOERR, &eb->bflags);
>> @@ -3232,7 +3285,7 @@ static int write_one_eb(struct extent_buffer *eb,
>> ret = -EIO;
>> break;
>> }
>> - offset += PAGE_CACHE_SIZE;
>> + start += PAGE_CACHE_SIZE;
>> update_nr_written(p, wbc, 1);
>> unlock_page(p);
>> }
>> @@ -3252,7 +3305,7 @@ int btree_write_cache_pages(struct address_space *mapping,
>> {
>> struct extent_io_tree *tree = &BTRFS_I(mapping->host)->io_tree;
>> struct btrfs_fs_info *fs_info = BTRFS_I(mapping->host)->root->fs_info;
>> - struct extent_buffer *eb, *prev_eb = NULL;
>> + struct extent_buffer *eb, *next, *prev_eb = NULL;
>> struct extent_page_data epd = {
>> .bio = NULL,
>> .tree = tree,
>> @@ -3326,17 +3379,41 @@ retry:
>> spin_unlock(&mapping->private_lock);
>> continue;
>> }
>> + prev_eb = eb;
>> +
>> +next_eb:
>> + next = eb->next;
>>
>> ret = atomic_inc_not_zero(&eb->refs);
>> - spin_unlock(&mapping->private_lock);
>> - if (!ret)
>> - continue;
>> + if (eb->len >= PAGE_SIZE) {
>> + spin_unlock(&mapping->private_lock);
>> + if (!ret)
>> + continue;
>> + } else {
>> + if (!ret)
>> + goto inc_eb;
>> + spin_unlock(&mapping->private_lock);
>> +
>> + if (!test_bit(EXTENT_BUFFER_DIRTY,
>> + &eb->bflags)) {
>> + spin_lock(&mapping->private_lock);
>> + atomic_dec(&eb->refs);
>> + ret = 0;
>> + goto inc_eb;
>> + }
>> + }
>>
>> - prev_eb = eb;
>> ret = lock_extent_buffer_for_io(eb, fs_info, &epd);
>> if (!ret) {
>> + if (!(eb->len >= PAGE_SIZE))
>> + spin_lock(&mapping->private_lock);
>> +
>> free_extent_buffer(eb);
>> - continue;
>> +
>> + if (eb->len >= PAGE_SIZE)
>> + continue;
>> + else
>> + goto inc_eb;
>> }
>>
>> ret = write_one_eb(eb, fs_info, wbc, &epd);
>> @@ -3345,8 +3422,26 @@ retry:
>> free_extent_buffer(eb);
>> break;
>> }
>> +
>> + if (eb->len >= PAGE_SIZE) {
>> + free_extent_buffer(eb);
>> + goto written;
>> + }
>> +
>> + if (next)
>> + spin_lock(&mapping->private_lock);
>> free_extent_buffer(eb);
>>
>> +inc_eb:
>> + if (!next) {
>> + if (spin_is_locked(&mapping->private_lock))
>> + spin_unlock(&mapping->private_lock);
>> + goto written;
>> + }
>> + eb = next;
>> + goto next_eb;
>> +
>> +written:
>> /*
>> * the filesystem may choose to bump up nr_to_write.
>> * We have to make sure to honor the new nr_to_write
>> @@ -4000,6 +4095,18 @@ static void __free_extent_buffer(struct extent_buffer *eb)
>> kmem_cache_free(extent_buffer_cache, eb);
>> }
>>
>> +/* Helper function to free extent buffers when there are multiple
>> + * extent buffers per page. */
>> +static void __free_extent_buffers(struct extent_buffer *eb)
>> +{
>> + struct extent_buffer *next;
>> +
>> + do {
>> + next = eb->next;
>> + __free_extent_buffer(eb);
>> + } while ((eb = next));
>> +}
>> +
>> static struct extent_buffer *__alloc_extent_buffer(struct extent_io_tree *tree,
>> u64 start,
>> unsigned long len,
>> @@ -4017,6 +4124,7 @@ static struct extent_buffer *__alloc_extent_buffer(struct extent_io_tree *tree,
>> eb->len = len;
>> eb->tree = tree;
>> eb->bflags = 0;
>> + eb->next = NULL;
>> rwlock_init(&eb->lock);
>> atomic_set(&eb->write_locks, 0);
>> atomic_set(&eb->read_locks, 0);
>> @@ -4054,6 +4162,62 @@ static struct extent_buffer *__alloc_extent_buffer(struct extent_io_tree *tree,
>> return eb;
>> }
>>
>> +/* Allocates an array of extent buffers for the specified page.
>> + * Should be called with the mapping's spin lock set. */
>> +static struct extent_buffer *__alloc_extent_buffers(struct extent_io_tree *tree,
>> + struct page *page,
>> + gfp_t mask)
>> +{
>> + u32 blocksize_bits;
>> + struct btrfs_inode *inode;
>> + struct extent_buffer *eb_head;
>> + struct extent_buffer *eb_cur;
>> + u64 start;
>> + unsigned long len;
>> + int i;
>> +
>> + /* Initialize variables. */
>> + inode = BTRFS_I(tree->mapping->host);
>> + blocksize_bits = inode->vfs_inode.i_sb->s_blocksize_bits;
>> +
>> + /* Calculate extent buffer dimensions. */
>> + start = page->index << PAGE_CACHE_SHIFT;
>> + len = inode->root->leafsize;
>> +
>> + /* Allocate the head extent buffer. */
>> + eb_head = __alloc_extent_buffer(tree, start, len, GFP_NOFS);
>> + if (!eb_head) {
>> + WARN_ON(1);
>> + return NULL;
>> + }
>> + start += len;
>> + eb_head->pages[0] = page;
>> + eb_cur = eb_head;
>> +
>> + /* Allocate the other extent buffers. */
>> + for (i = 1; i < (PAGE_CACHE_SIZE >> blocksize_bits); i++) {
>> + eb_cur->next = __alloc_extent_buffer(tree, start, len,
>> + GFP_NOFS);
>> + if (!eb_cur->next) {
>> + WARN_ON(1);
>> + goto free_ebs;
>> + }
>> + start += len;
>> + eb_cur = eb_cur->next;
>> + eb_cur->pages[0] = page;
>> + }
>> +
>> + /* Return the extent buffer head. */
>> + return eb_head;
>> +
>> +free_ebs:
>> + /* Free each extent buffer. */
>> + // TODO: Implement.
>> + pr_crit(KERN_CRIT "HACK: Need to implement this...\n");
>> + WARN_ON(1);
>> + return NULL;
>> +}
>> +
>> struct extent_buffer *btrfs_clone_extent_buffer(struct extent_buffer *src)
>> {
>> unsigned long i;
>> @@ -4170,12 +4334,121 @@ static void btrfs_release_extent_buffer_page(struct extent_buffer *eb,
>> }
>>
>> /*
>> + * Frees the page if all extent buffers belonging to the page are not
>> + * referernced. The extent buffers themselves must be free afterwards, too...
>> + * ret: 0 if the page did not need to be freed; 1 if the page was freed.
>> + */
>> +static int btrfs_release_extent_buffers_page(struct extent_buffer *eb,
>> + struct extent_buffer **eb_head)
>> +{
>> + struct extent_buffer *eb_cur;
>> + struct extent_buffer *eb_temp;
>> + struct page *page;
>> + int mapped = !test_bit(EXTENT_BUFFER_DUMMY, &eb->bflags);
>> + int ret = 0;
>> +
>> + if (extent_buffer_under_io(eb))
>> + BUG_ON(1);
>> +
>> + // ...is this even possible?
>> + if (!num_extent_pages(eb->start, eb->len)) {
>> + WARN_ON(1);
>> + return ret;
>> + }
>> +
>> + page = extent_buffer_page(eb, 0);
>> + if (page && mapped) {
>> + spin_lock(&page->mapping->private_lock);
>> + /*
>> + * We do this since we'll remove the pages after we've
>> + * removed the eb from the radix tree, so we could race
>> + * and have this page now attached to the new eb. So
>> + * only clear page_private if it's still connected to
>> + * this eb.
>> + */
>> + if (!PagePrivate(page)) {
>> + spin_unlock(&page->mapping->private_lock);
>> + } else {
>> + /* Find the page eb corresponding to our eb. */
>> + eb_cur = (struct extent_buffer *)page->private;
>> + while (eb_cur->start != eb->start) {
>> + eb_cur = eb_cur->next;
>> + BUG_ON(!eb_cur);
>> + }
>> +
>> + /* See if a new eb has been attached to the page. */
>> + if (eb_cur != eb) {
>> + spin_unlock(&page->mapping->private_lock);
>> + ret = 1;
>> + goto page_release;
>> + }
>> +
>> + /* See if any other extent_buffer is using the page. */
>> + eb_cur = (struct extent_buffer *)page->private;
>> + do {
>> + /* Check for any other references on the eb. */
>> + spin_lock(&eb_cur->refs_lock);
>> + if (!atomic_dec_and_test(&eb_cur->refs)) {
>> + atomic_inc(&eb_cur->refs);
>> + spin_unlock(&eb_cur->refs_lock);
>> + eb_temp = eb_cur;
>> + eb_cur = (struct extent_buffer *)
>> + page->private;
>> + while (eb_cur != eb_temp) {
>> + atomic_inc(&eb_cur->refs);
>> + eb_cur = eb_cur->next;
>> + }
>> + spin_unlock(
>> + &page->mapping->private_lock);
>> + goto page_release;
>> + }
>> + spin_unlock(&eb_cur->refs_lock);
>> + } while ((eb_cur = eb_cur->next) != NULL);
>> +
>> + /* Sanity checks. */
>> + eb_cur = (struct extent_buffer *)page->private;
>> + do {
>> + BUG_ON(extent_buffer_under_io(eb_cur));
>> + } while ((eb_cur = eb_cur->next) != NULL);
>> + BUG_ON(PageDirty(page));
>> + BUG_ON(PageWriteback(page));
>> + /*
>> + * We need to make sure we haven't been attached
>> + * to a new eb.
>> + */
>> + eb_cur = (struct extent_buffer *)page->private;
>> + *eb_head = eb_cur;
>> + eb_temp = NULL;
>> + ClearPagePrivate(page);
>> + set_page_private(page, 0);
>> + /* One for the page private. */
>> + page_cache_release(page);
>> + ret = 1;
>> + spin_unlock(&page->mapping->private_lock);
>> + }
>> + }
>> +
>> +page_release:
>> + if (page) {
>> + /* One for when we alloced the page */
>> + page_cache_release(page);
>> + }
>> + return ret;
>> +}
>> +
>> +/*
>> * Helper for releasing the extent buffer.
>> */
>> static inline void btrfs_release_extent_buffer(struct extent_buffer *eb)
>> {
>> - btrfs_release_extent_buffer_page(eb, 0);
>> - __free_extent_buffer(eb);
>> + if (eb->len >= PAGE_SIZE) {
>> + btrfs_release_extent_buffer_page(eb, 0);
>> + __free_extent_buffer(eb);
>> + } else {
>> + struct extent_buffer *eb_head;
>> + if (btrfs_release_extent_buffers_page(eb, &eb_head))
>> + __free_extent_buffers(eb_head);
>> + }
>> }
>>
>> static void check_buffer_tree_ref(struct extent_buffer *eb)
>> @@ -4222,16 +4495,153 @@ static void mark_extent_buffer_accessed(struct extent_buffer *eb)
>> struct extent_buffer *alloc_extent_buffer(struct extent_io_tree *tree,
>> u64 start, unsigned long len)
>> {
>> - unsigned long num_pages = num_extent_pages(start, len);
>> - unsigned long i;
>> - unsigned long index = start >> PAGE_CACHE_SHIFT;
>> + /* Allocate a new extent_buffer depending on blocksize*/
>> + if (len < PAGE_CACHE_SIZE)
>> + return alloc_extent_buffer_multiple(tree, start, len);
>> + return alloc_extent_buffer_single(tree, start, len);
>> +}
>> +
>> +struct extent_buffer *alloc_extent_buffer_multiple(struct extent_io_tree *tree,
>> + u64 start,
>> + unsigned long len) {
>> +
>> + struct address_space *mapping;
>> + u32 blocksize_bits;
>> + struct btrfs_inode *btrfs_inode;
>> + struct extent_buffer *eb_cur;
>> + struct extent_buffer *eb_head;
>> + struct extent_buffer *exists;
>> + unsigned long index;
>> + struct page *page;
>> + int ret;
>> +
>> + /* Initialize variables. */
>> + btrfs_inode = BTRFS_I(tree->mapping->host);
>> + blocksize_bits = btrfs_inode->vfs_inode.i_sb->s_blocksize_bits;
>> +
>> + /* Sanity checks. */
>> + WARN_ON(num_extent_pages(start, len) > 1);
>> +
>> + /* See if the extent_buffer already exists in the radix tree. */
>> + rcu_read_lock();
>> + eb_cur = radix_tree_lookup(&tree->buffer, start >> blocksize_bits);
>> + if (eb_cur && atomic_inc_not_zero(&eb_cur->refs)) {
>> + rcu_read_unlock();
>> + mark_extent_buffer_accessed(eb_cur);
>> + return eb_cur;
>> + }
>> + rcu_read_unlock();
>> +
>> + /* Find the page in the mapping. */
>> + index = start >> PAGE_CACHE_SHIFT;
>> + mapping = tree->mapping;
>> + page = find_or_create_page(mapping, index, GFP_NOFS);
>> + if (!page) {
>> + WARN_ON(1);
>> + return NULL;
>> + }
>> +
>> + /* Allocate each extent buffer for the page. */
>> + eb_head = __alloc_extent_buffers(tree, page, GFP_NOFS);
>> + if (!eb_head) {
>> + WARN_ON(1);
>> + return NULL;
>> + }
>> +
>> + /* See if extent buffers have already been allocated for
>> + * this page. */
>> + spin_lock(&mapping->private_lock);
>> + if (PagePrivate(page)) {
>> + /*
>> + * We could have already allocated an eb for this page
>> + * and attached one so lets see if we can get a ref on
>> + * the existing eb, and if we can we know it's good and
>> + * we can just return that one, else we know we can just
>> + * overwrite page->private.
>> + */
>> + eb_cur = (struct extent_buffer *)page->private;
>> + while (eb_cur->start != start) {
>> + eb_cur = eb_cur->next;
>> + BUG_ON(!eb_cur);
>> + }
>> + check_buffer_tree_ref(eb_cur);
>> + spin_unlock(&mapping->private_lock);
>> + unlock_page(page);
>> + mark_extent_buffer_accessed(eb_cur);
>> + __free_extent_buffers(eb_head);
>> + return eb_cur;
>> + }
>> +
>> + /* Bind the extent buffer to the page. */
>> + attach_extent_buffer_page(eb_head, page);
>> + spin_unlock(&mapping->private_lock);
>> + WARN_ON(PageDirty(page));
>> + mark_page_accessed(page);
>> +
>> +again:
>> + /* Set eb_cur to the buffer added. */
>> + eb_cur = eb_head;
>> + while (start != eb_cur->start) {
>> + eb_cur = eb_cur->next;
>> + BUG_ON(!eb_cur);
>> + }
>> +
>> + /* Preload the radix tree. */
>> + ret = radix_tree_preload(GFP_NOFS & ~__GFP_HIGHMEM);
>> + if (ret) {
>> + WARN_ON(1);
>> + return NULL;
>> + }
>> +
>> + /* Add the extent buffer to the radix tree. */
>> + spin_lock(&tree->buffer_lock);
>> + ret = radix_tree_insert(&tree->buffer,
>> + eb_cur->start >> blocksize_bits,
>> + eb_cur);
>> + if (ret == -EEXIST) {
>> + exists = radix_tree_lookup(&tree->buffer,
>> + eb_cur->start >> blocksize_bits);
>> + if (exists->start != start)
>> + BUG_ON(1);
>> + if (!atomic_inc_not_zero(&exists->refs)) {
>> + spin_unlock(&tree->buffer_lock);
>> + radix_tree_preload_end();
>> + exists = NULL;
>> + goto again;
>> + }
>> + spin_unlock(&tree->buffer_lock);
>> + radix_tree_preload_end();
>> + mark_extent_buffer_accessed(exists);
>> + WARN_ON(!atomic_dec_and_test(&eb_cur->refs));
>> + btrfs_release_extent_buffer(eb_cur);
>> + return exists;
>> + }
>> +
>> + /* Set the extent buffer's tree-reference bits. */
>> + check_buffer_tree_ref(eb_cur);
>> + spin_unlock(&tree->buffer_lock);
>> + radix_tree_preload_end();
>> +
>> + /* Not quite sure what this does. */
>> + SetPageChecked(eb_head->pages[0]);
>> + unlock_page(eb_head->pages[0]);
>> +
>> + return eb_cur;
>> +}
>> +
>> +struct extent_buffer *alloc_extent_buffer_single(struct extent_io_tree *tree,
>> + u64 start, unsigned long len) {
>> + struct address_space *mapping = tree->mapping;
>> struct extent_buffer *eb;
>> struct extent_buffer *exists = NULL;
>> + unsigned long i;
>> + unsigned long index = start >> PAGE_CACHE_SHIFT;
>> + unsigned long num_pages = num_extent_pages(start, len);
>> struct page *p;
>> - struct address_space *mapping = tree->mapping;
>> int uptodate = 1;
>> int ret;
>>
>> + /* See if the extent_buffer already exists */
>> rcu_read_lock();
>> eb = radix_tree_lookup(&tree->buffer, start >> PAGE_CACHE_SHIFT);
>> if (eb && atomic_inc_not_zero(&eb->refs)) {
>> @@ -4350,9 +4760,17 @@ struct extent_buffer *find_extent_buffer(struct extent_io_tree *tree,
>> u64 start, unsigned long len)
>> {
>> struct extent_buffer *eb;
>> + struct btrfs_inode *btrfs_inode = BTRFS_I(tree->mapping->host);
>> + u32 blocksize_bits = btrfs_inode->vfs_inode.i_sb->s_blocksize_bits;
>>
>> rcu_read_lock();
>> - eb = radix_tree_lookup(&tree->buffer, start >> PAGE_CACHE_SHIFT);
>> + // This branch needs to be fixed when the allocation code is merged.
>> + // Seriously.
>> + if (blocksize_bits >= PAGE_CACHE_SHIFT)
>> + eb = radix_tree_lookup(&tree->buffer,
>> + start >> PAGE_CACHE_SHIFT);
>> + else
>> + eb = radix_tree_lookup(&tree->buffer, start >> blocksize_bits);
>> if (eb && atomic_inc_not_zero(&eb->refs)) {
>> rcu_read_unlock();
>> mark_extent_buffer_accessed(eb);
>> @@ -4371,9 +4789,25 @@ static inline void btrfs_release_extent_buffer_rcu(struct rcu_head *head)
>> __free_extent_buffer(eb);
>> }
>>
>> -/* Expects to have eb->eb_lock already held */
>> +/*
>> + * The RCU head must point to the first extent buffer belonging to a page.
>> + */
>> +static inline void btrfs_release_extent_buffers_rcu(struct rcu_head *head)
>> +{
>> + struct extent_buffer *eb =
>> + container_of(head, struct extent_buffer, rcu_head);
>> +
>> + do {
>> + call_rcu(&eb->rcu_head, btrfs_release_extent_buffer_rcu);
>> + } while ((eb = eb->next));
>> +}
>> +
>> +/* Expects to have eb->refs_lock already held */
>> static int release_extent_buffer(struct extent_buffer *eb, gfp_t mask)
>> {
>> + struct btrfs_inode *btrfs_inode = BTRFS_I(eb->tree->mapping->host);
>> + u32 blocksize_bits = btrfs_inode->vfs_inode.i_sb->s_blocksize_bits;
>> +
>> WARN_ON(atomic_read(&eb->refs) == 0);
>> if (atomic_dec_and_test(&eb->refs)) {
>> if (test_bit(EXTENT_BUFFER_DUMMY, &eb->bflags)) {
>> @@ -4381,17 +4815,35 @@ static int release_extent_buffer(struct extent_buffer *eb, gfp_t mask)
>> } else {
>> struct extent_io_tree *tree = eb->tree;
>>
>> + /* Dumb hack to make releasing the page easier. */
>> + if (eb->len < PAGE_SIZE)
>> + atomic_inc(&eb->refs);
>> +
>> spin_unlock(&eb->refs_lock);
>>
>> + // This also needs to be fixed when allocation code is
>> + // merged.
>> spin_lock(&tree->buffer_lock);
>> - radix_tree_delete(&tree->buffer,
>> - eb->start >> PAGE_CACHE_SHIFT);
>> + if (eb->len >= PAGE_SIZE)
>> + radix_tree_delete(&tree->buffer,
>> + eb->start >> blocksize_bits);
>> + else
>> + radix_tree_delete(&tree->buffer,
>> + eb->start >> blocksize_bits);
>> spin_unlock(&tree->buffer_lock);
>> }
>>
>> /* Should be safe to release our pages at this point */
>> - btrfs_release_extent_buffer_page(eb, 0);
>> - call_rcu(&eb->rcu_head, btrfs_release_extent_buffer_rcu);
>> + if (eb->len >= PAGE_SIZE) {
>> + btrfs_release_extent_buffer_page(eb, 0);
>> + call_rcu(&eb->rcu_head,
>> + btrfs_release_extent_buffer_rcu);
>> + } else {
>> + struct extent_buffer *eb_head;
>> + if (btrfs_release_extent_buffers_page(eb, &eb_head))
>> + btrfs_release_extent_buffers_rcu(
>> + &eb_head->rcu_head);
>> + }
>> return 1;
>> }
>> spin_unlock(&eb->refs_lock);
>> @@ -4482,6 +4934,11 @@ int set_extent_buffer_dirty(struct extent_buffer *eb)
>>
>> for (i = 0; i < num_pages; i++)
>> set_page_dirty(extent_buffer_page(eb, i));
>> + /* Run an additional sanity check here instead of
>> + * in btree_set_page_dirty() since we can't get the eb there for
>> + * subpage blocksize. */
>> + if (eb->len < PAGE_SIZE)
>> + btrfs_assert_tree_locked(eb);
>> return was_dirty;
>> }
>>
>> @@ -4503,11 +4960,14 @@ int clear_extent_buffer_uptodate(struct extent_buffer *eb)
>> unsigned long num_pages;
>>
>> clear_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
>> - num_pages = num_extent_pages(eb->start, eb->len);
>> - for (i = 0; i < num_pages; i++) {
>> - page = extent_buffer_page(eb, i);
>> - if (page)
>> - ClearPageUptodate(page);
>> + /* Ignore the page's uptodate flag forsubpage blocksize. */
>> + if (eb->len >= PAGE_SIZE) {
>> + num_pages = num_extent_pages(eb->start, eb->len);
>> + for (i = 0; i < num_pages; i++) {
>> + page = extent_buffer_page(eb, i);
>> + if (page)
>> + ClearPageUptodate(page);
>> + }
>> }
>> return 0;
>> }
>> @@ -4518,11 +4978,16 @@ int set_extent_buffer_uptodate(struct extent_buffer *eb)
>> struct page *page;
>> unsigned long num_pages;
>>
>> + /* Set extent buffer up-to-date. */
>> set_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
>> - num_pages = num_extent_pages(eb->start, eb->len);
>> - for (i = 0; i < num_pages; i++) {
>> - page = extent_buffer_page(eb, i);
>> - SetPageUptodate(page);
>> +
>> + /* Set pages up-to-date. */
>> + if (eb->len >= PAGE_CACHE_SIZE) {
>> + num_pages = num_extent_pages(eb->start, eb->len);
>> + for (i = 0; i < num_pages; i++) {
>> + page = extent_buffer_page(eb, i);
>> + SetPageUptodate(page);
>> + }
>> }
>> return 0;
>> }
>> @@ -4606,7 +5071,7 @@ int read_extent_buffer_pages(struct extent_io_tree *tree,
>> }
>> }
>> if (all_uptodate) {
>> - if (start_i == 0)
>> + if (start_i == 0 && eb->len >= PAGE_SIZE)
>> set_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
>> goto unlock_exit;
>> }
>> @@ -4693,7 +5158,7 @@ int map_private_extent_buffer(struct extent_buffer *eb, unsigned long start,
>> unsigned long *map_start,
>> unsigned long *map_len)
>> {
>> - size_t offset = start & (PAGE_CACHE_SIZE - 1);
>> + size_t offset;
>> char *kaddr;
>> struct page *p;
>> size_t start_offset = eb->start & ((u64)PAGE_CACHE_SIZE - 1);
>> @@ -4709,6 +5174,9 @@ int map_private_extent_buffer(struct extent_buffer *eb, unsigned long start,
>> *map_start = 0;
>> } else {
>> offset = 0;
>> + // I'm pretty sure that this is a) just plain wrong and
>> + // b) will never realistically execute; not entirely sure,
>> + // though...
>> *map_start = ((u64)i << PAGE_CACHE_SHIFT) - start_offset;
>> }
>>
>> @@ -4722,7 +5190,7 @@ int map_private_extent_buffer(struct extent_buffer *eb, unsigned long start,
>> p = extent_buffer_page(eb, i);
>> kaddr = page_address(p);
>> *map = kaddr + offset;
>> - *map_len = PAGE_CACHE_SIZE - offset;
>> + *map_len = (PAGE_CACHE_SIZE - offset) & (eb->len - 1);
>> return 0;
>> }
>>
>> @@ -4996,6 +5464,7 @@ void memmove_extent_buffer(struct extent_buffer *dst, unsigned long dst_offset,
>> int try_release_extent_buffer(struct page *page, gfp_t mask)
>> {
>> struct extent_buffer *eb;
>> + int ret;
>>
>> /*
>> * We need to make sure noboody is attaching this page to an eb right
>> @@ -5010,30 +5479,61 @@ int try_release_extent_buffer(struct page *page, gfp_t mask)
>> eb = (struct extent_buffer *)page->private;
>> BUG_ON(!eb);
>>
>> - /*
>> - * This is a little awful but should be ok, we need to make sure that
>> - * the eb doesn't disappear out from under us while we're looking at
>> - * this page.
>> - */
>> - spin_lock(&eb->refs_lock);
>> - if (atomic_read(&eb->refs) != 1 || extent_buffer_under_io(eb)) {
>> - spin_unlock(&eb->refs_lock);
>> + if (eb->len >= PAGE_SIZE) {
>> + /*
>> + * This is a little awful but should be ok, we need to make
>> + * sure that the eb doesn't disappear out from under us while
>> + * we're looking at this page.
>> + */
>> + spin_lock(&eb->refs_lock);
>> + if (atomic_read(&eb->refs) != 1 || extent_buffer_under_io(eb)) {
>> + spin_unlock(&eb->refs_lock);
>> + spin_unlock(&page->mapping->private_lock);
>> + return 0;
>> + }
>> spin_unlock(&page->mapping->private_lock);
>> - return 0;
>> - }
>> - spin_unlock(&page->mapping->private_lock);
>>
>> - if ((mask & GFP_NOFS) == GFP_NOFS)
>> - mask = GFP_NOFS;
>> + if ((mask & GFP_NOFS) == GFP_NOFS)
>> + mask = GFP_NOFS;
>>
>> - /*
>> - * If tree ref isn't set then we know the ref on this eb is a real ref,
>> - * so just return, this page will likely be freed soon anyway.
>> - */
>> - if (!test_and_clear_bit(EXTENT_BUFFER_TREE_REF, &eb->bflags)) {
>> - spin_unlock(&eb->refs_lock);
>> - return 0;
>> - }
>> + /*
>> + * If tree ref isn't set then we know the ref on this eb is a
>> + * real ref, so just return, this page will likely be freed
>> + * soon anyway.
>> + */
>> + if (!test_and_clear_bit(EXTENT_BUFFER_TREE_REF, &eb->bflags)) {
>> + spin_unlock(&eb->refs_lock);
>> + return 0;
>> + }
>>
>> - return release_extent_buffer(eb, mask);
>> + return release_extent_buffer(eb, mask);
>> + } else {
>> + ret = 0;
>> + do {
>> + spin_lock(&eb->refs_lock);
>> + if (atomic_read(&eb->refs) != 1 ||
>> + extent_buffer_under_io(eb)) {
>> + spin_unlock(&eb->refs_lock);
>> + continue;
>> + }
>> + spin_unlock(&page->mapping->private_lock);
>> +
>> + if ((mask & GFP_NOFS) == GFP_NOFS)
>> + mask = GFP_NOFS;
>> +
>> + if (!test_and_clear_bit(EXTENT_BUFFER_TREE_REF,
>> + &eb->bflags)) {
>> + spin_unlock(&eb->refs_lock);
>> + spin_lock(&page->mapping->private_lock);
>> + continue;
>> + }
>> +
>> + /* No idea what to do with the 'ret' here. */
>> + ret |= release_extent_buffer(eb, mask);
>> +
>> + spin_lock(&page->mapping->private_lock);
>> + } while ((eb = eb->next) != NULL);
>> + spin_unlock(&page->mapping->private_lock);
>> + return ret;
>> + }
>> }
>> diff --git a/fs/btrfs/extent_io.h b/fs/btrfs/extent_io.h
>> index 2eacfab..955ef5e 100644
>> --- a/fs/btrfs/extent_io.h
>> +++ b/fs/btrfs/extent_io.h
>> @@ -163,6 +163,9 @@ struct extent_buffer {
>> wait_queue_head_t lock_wq;
>> struct page *inline_pages[INLINE_EXTENT_BUFFER_PAGES];
>> struct page **pages;
>> +
>> + /* Acyclic linked list of extent_buffers belonging to a single page. */
>> + struct extent_buffer *next;
>> };
>>
>> static inline void extent_set_compress_type(unsigned long *bio_flags,
>> @@ -270,6 +273,10 @@ void set_page_extent_mapped(struct page *page);
>>
>> struct extent_buffer *alloc_extent_buffer(struct extent_io_tree *tree,
>> u64 start, unsigned long len);
>> +struct extent_buffer *alloc_extent_buffer_single(struct extent_io_tree *tree,
>> + u64 start, unsigned long len);
>> +struct extent_buffer *alloc_extent_buffer_multiple(struct extent_io_tree *tree,
>> + u64 start, unsigned long len);
>> struct extent_buffer *alloc_dummy_extent_buffer(u64 start, unsigned long len);
>> struct extent_buffer *btrfs_clone_extent_buffer(struct extent_buffer *src);
>> struct extent_buffer *find_extent_buffer(struct extent_io_tree *tree,
>> diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c
>> index 3bff4d4..8745289 100644
>> --- a/fs/btrfs/file.c
>> +++ b/fs/btrfs/file.c
>> @@ -1340,7 +1340,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
>> }
>>
>> ret = btrfs_delalloc_reserve_space(inode,
>> - num_pages << PAGE_CACHE_SHIFT);
>> + write_bytes);
>> if (ret)
>> break;
>>
>> @@ -1354,7 +1354,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
>> force_page_uptodate);
>> if (ret) {
>> btrfs_delalloc_release_space(inode,
>> - num_pages << PAGE_CACHE_SHIFT);
>> + write_bytes);
>> break;
>> }
>>
>> @@ -1392,8 +1392,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
>> spin_unlock(&BTRFS_I(inode)->lock);
>> }
>> btrfs_delalloc_release_space(inode,
>> - (num_pages - dirty_pages) <<
>> - PAGE_CACHE_SHIFT);
>> + write_bytes - copied);
>> }
>>
>> if (copied > 0) {
>> @@ -1402,7 +1401,7 @@ static noinline ssize_t __btrfs_buffered_write(struct file *file,
>> NULL);
>> if (ret) {
>> btrfs_delalloc_release_space(inode,
>> - dirty_pages << PAGE_CACHE_SHIFT);
>> + copied);
>> btrfs_drop_pages(pages, num_pages);
>> break;
>> }
>> diff --git a/fs/btrfs/free-space-cache.c b/fs/btrfs/free-space-cache.c
>> index 59ea2e4..1c0e254 100644
>> --- a/fs/btrfs/free-space-cache.c
>> +++ b/fs/btrfs/free-space-cache.c
>> @@ -960,6 +960,8 @@ int __btrfs_write_out_cache(struct btrfs_root *root, struct inode *inode,
>>
>> if (block_group)
>> start = block_group->key.objectid;
>> + else // Hmm I don't recall putting this here.
>> + start = (u64)-1;
>>
>> while (block_group && (start < block_group->key.objectid +
>> block_group->key.offset)) {
>> diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
>> index 3368c10..11ff3dd 100644
>> --- a/fs/btrfs/inode.c
>> +++ b/fs/btrfs/inode.c
>> @@ -2040,22 +2040,38 @@ static int btrfs_writepage_end_io_hook(struct page *page, u64 start, u64 end,
>> struct btrfs_root *root = BTRFS_I(inode)->root;
>> struct btrfs_ordered_extent *ordered_extent = NULL;
>> struct btrfs_workers *workers;
>> + u64 block_size = 1 << inode->i_blkbits;
>> + u64 io_size;
>> +
>> + if (block_size >= PAGE_CACHE_SIZE)
>> + io_size = end - start + 1;
>> + else
>> + io_size = block_size;
>>
>> trace_btrfs_writepage_end_io_hook(page, start, end, uptodate);
>>
>> ClearPagePrivate2(page);
>> - if (!btrfs_dec_test_ordered_pending(inode, &ordered_extent, start,
>> - end - start + 1, uptodate))
>> - return 0;
>> -
>> - ordered_extent->work.func = finish_ordered_fn;
>> - ordered_extent->work.flags = 0;
>> -
>> - if (btrfs_is_free_space_inode(inode))
>> - workers = &root->fs_info->endio_freespace_worker;
>> - else
>> - workers = &root->fs_info->endio_write_workers;
>> - btrfs_queue_worker(workers, &ordered_extent->work);
>> +next_block:
>> + if (btrfs_dec_test_ordered_pending(inode, &ordered_extent, start,
>> + io_size, uptodate)) {
>> + ordered_extent->work.func = finish_ordered_fn;
>> + ordered_extent->work.flags = 0;
>> +
>> + if (btrfs_is_free_space_inode(inode))
>> + workers = &root->fs_info->endio_freespace_worker;
>> + else
>> + workers = &root->fs_info->endio_write_workers;
>> + btrfs_queue_worker(workers, &ordered_extent->work);
>> + }
>> +
>> + // I think that writes are always block-size granularity.
>> + if (block_size < PAGE_CACHE_SIZE)
>> + BUG_ON(start & (io_size - 1)); // Welp, one way to make sure...
>> + start += io_size;
>> + if (start < end)
>> + goto next_block;
>> + // We overshot. I'm pretty sure that this is terrible.
>> + BUG_ON(start != (end + 1));
>>
>> return 0;
>> }
>> diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
>> index 657d83c..c0269df 100644
>> --- a/fs/btrfs/ioctl.c
>> +++ b/fs/btrfs/ioctl.c
>> @@ -3937,8 +3937,8 @@ long btrfs_ioctl(struct file *file, unsigned int
>> return btrfs_ioctl_qgroup_create(file, argp);
>> case BTRFS_IOC_QGROUP_LIMIT:
>> return btrfs_ioctl_qgroup_limit(file, argp);
>> - case BTRFS_IOC_DEV_REPLACE:
>> - return btrfs_ioctl_dev_replace(root, argp);
>> + //case BTRFS_IOC_DEV_REPLACE:
>> +// return btrfs_ioctl_dev_replace(root, argp);
>> }
>>
>> return -ENOTTY;
>> --
>> 1.7.1
>>
>> --
>> To unsubscribe from this list: send the line "unsubscribe linux-btrfs" in
>> the body of a message to majordomo@xxxxxxxxxxxxxxx
>> More majordomo info at http://vger.kernel.org/majordomo-info.html
> --
> To unsubscribe from this list: send the line "unsubscribe linux-btrfs" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at http://vger.kernel.org/majordomo-info.html
>
--
To unsubscribe from this list: send the line "unsubscribe linux-btrfs" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
