Btrfs: Add zlib compression support

This is a large change for adding compression on reading and writing,
both for inline and regular extents.  It does some fairly large
surgery to the writeback paths.

Compression is off by default and enabled by mount -o compress.  Even
when the -o compress mount option is not used, it is possible to read
compressed extents off the disk.

If compression for a given set of pages fails to make them smaller, the
file is flagged to avoid future compression attempts later.

* While finding delalloc extents, the pages are locked before being sent down
to the delalloc handler.  This allows the delalloc handler to do complex things
such as cleaning the pages, marking them writeback and starting IO on their
behalf.

* Inline extents are inserted at delalloc time now.  This allows us to compress
the data before inserting the inline extent, and it allows us to insert
an inline extent that spans multiple pages.

* All of the in-memory extent representations (extent_map.c, ordered-data.c etc)
are changed to record both an in-memory size and an on disk size, as well
as a flag for compression.

From a disk format point of view, the extent pointers in the file are changed
to record the on disk size of a given extent and some encoding flags.
Space in the disk format is allocated for compression encoding, as well
as encryption and a generic 'other' field.  Neither the encryption or the
'other' field are currently used.

In order to limit the amount of data read for a single random read in the
file, the size of a compressed extent is limited to 128k.  This is a
software only limit, the disk format supports u64 sized compressed extents.

In order to limit the ram consumed while processing extents, the uncompressed
size of a compressed extent is limited to 256k.  This is a software only limit
and will be subject to tuning later.

Checksumming is still done on compressed extents, and it is done on the
uncompressed version of the data.  This way additional encodings can be
layered on without having to figure out which encoding to checksum.

Compression happens at delalloc time, which is basically singled threaded because
it is usually done by a single pdflush thread.  This makes it tricky to
spread the compression load across all the cpus on the box.  We'll have to
look at parallel pdflush walks of dirty inodes at a later time.

Decompression is hooked into readpages and it does spread across CPUs nicely.

Signed-off-by: Chris Mason <chris.mason@oracle.com>

1 files changed, 539 insertions, 45 deletions

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index bf4bed6ca4d6..9797592dc86b 100644
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -49,6 +49,7 @@
 #include "compat.h"
 #include "tree-log.h"
 #include "ref-cache.h"
+#include "compression.h"
 
 struct btrfs_iget_args {
         u64 ino;
@@ -83,6 +84,7 @@ static unsigned char btrfs_type_by_mode[S_IFMT >> S_SHIFT] = {
 };
 
 static void btrfs_truncate(struct inode *inode);
+static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end);
 
 /*
  * a very lame attempt at stopping writes when the FS is 85% full.  There
@@ -114,57 +116,374 @@ int btrfs_check_free_space(struct btrfs_root *root, u64 num_required,
 }
 
 /*
+ * this does all the hard work for inserting an inline extent into
+ * the btree.  The caller should have done a btrfs_drop_extents so that
+ * no overlapping inline items exist in the btree
+ */
+static int noinline insert_inline_extent(struct btrfs_trans_handle *trans,
+                                struct btrfs_root *root, struct inode *inode,
+                                u64 start, size_t size, size_t compressed_size,
+                                struct page **compressed_pages)
+{
+        struct btrfs_key key;
+        struct btrfs_path *path;
+        struct extent_buffer *leaf;
+        struct page *page = NULL;
+        char *kaddr;
+        unsigned long ptr;
+        struct btrfs_file_extent_item *ei;
+        int err = 0;
+        int ret;
+        size_t cur_size = size;
+        size_t datasize;
+        unsigned long offset;
+        int use_compress = 0;
+
+        if (compressed_size && compressed_pages) {
+                use_compress = 1;
+                cur_size = compressed_size;
+        }
+
+        path = btrfs_alloc_path(); if (!path)
+                return -ENOMEM;
+
+        btrfs_set_trans_block_group(trans, inode);
+
+        key.objectid = inode->i_ino;
+        key.offset = start;
+        btrfs_set_key_type(&key, BTRFS_EXTENT_DATA_KEY);
+        inode_add_bytes(inode, size);
+        datasize = btrfs_file_extent_calc_inline_size(cur_size);
+
+        inode_add_bytes(inode, size);
+        ret = btrfs_insert_empty_item(trans, root, path, &key,
+                                      datasize);
+        BUG_ON(ret);
+        if (ret) {
+                err = ret;
+                printk("got bad ret %d\n", ret);
+                goto fail;
+        }
+        leaf = path->nodes[0];
+        ei = btrfs_item_ptr(leaf, path->slots[0],
+                            struct btrfs_file_extent_item);
+        btrfs_set_file_extent_generation(leaf, ei, trans->transid);
+        btrfs_set_file_extent_type(leaf, ei, BTRFS_FILE_EXTENT_INLINE);
+        btrfs_set_file_extent_encryption(leaf, ei, 0);
+        btrfs_set_file_extent_other_encoding(leaf, ei, 0);
+        btrfs_set_file_extent_ram_bytes(leaf, ei, size);
+        ptr = btrfs_file_extent_inline_start(ei);
+
+        if (use_compress) {
+                struct page *cpage;
+                int i = 0;
+                while(compressed_size > 0) {
+                        cpage = compressed_pages[i];
+                        cur_size = min(compressed_size,
+                                       PAGE_CACHE_SIZE);
+
+                        kaddr = kmap(cpage);
+                        write_extent_buffer(leaf, kaddr, ptr, cur_size);
+                        kunmap(cpage);
+
+                        i++;
+                        ptr += cur_size;
+                        compressed_size -= cur_size;
+                }
+                btrfs_set_file_extent_compression(leaf, ei,
+                                                  BTRFS_COMPRESS_ZLIB);
+        } else {
+                page = find_get_page(inode->i_mapping,
+                                     start >> PAGE_CACHE_SHIFT);
+                btrfs_set_file_extent_compression(leaf, ei, 0);
+                kaddr = kmap_atomic(page, KM_USER0);
+                offset = start & (PAGE_CACHE_SIZE - 1);
+                write_extent_buffer(leaf, kaddr + offset, ptr, size);
+                kunmap_atomic(kaddr, KM_USER0);
+                page_cache_release(page);
+        }
+        btrfs_mark_buffer_dirty(leaf);
+        btrfs_free_path(path);
+
+        BTRFS_I(inode)->disk_i_size = inode->i_size;
+        btrfs_update_inode(trans, root, inode);
+        return 0;
+fail:
+        btrfs_free_path(path);
+        return err;
+}
+
+
+/*
+ * conditionally insert an inline extent into the file.  This
+ * does the checks required to make sure the data is small enough
+ * to fit as an inline extent.
+ */
+static int cow_file_range_inline(struct btrfs_trans_handle *trans,
+                                 struct btrfs_root *root,
+                                 struct inode *inode, u64 start, u64 end,
+                                 size_t compressed_size,
+                                 struct page **compressed_pages)
+{
+        u64 isize = i_size_read(inode);
+        u64 actual_end = min(end + 1, isize);
+        u64 inline_len = actual_end - start;
+        u64 aligned_end = (end + root->sectorsize - 1) &
+                        ~((u64)root->sectorsize - 1);
+        u64 hint_byte;
+        u64 data_len = inline_len;
+        int ret;
+
+        if (compressed_size)
+                data_len = compressed_size;
+
+        if (start > 0 ||
+            data_len >= BTRFS_MAX_INLINE_DATA_SIZE(root) ||
+            (!compressed_size &&
+            (actual_end & (root->sectorsize - 1)) == 0) ||
+            end + 1 < isize ||
+            data_len > root->fs_info->max_inline) {
+                return 1;
+        }
+
+        mutex_lock(&BTRFS_I(inode)->extent_mutex);
+        ret = btrfs_drop_extents(trans, root, inode, start,
+                                 aligned_end, aligned_end, &hint_byte);
+        BUG_ON(ret);
+
+        if (isize > actual_end)
+                inline_len = min_t(u64, isize, actual_end);
+        ret = insert_inline_extent(trans, root, inode, start,
+                                   inline_len, compressed_size,
+                                   compressed_pages);
+        BUG_ON(ret);
+        btrfs_drop_extent_cache(inode, start, aligned_end, 0);
+        mutex_unlock(&BTRFS_I(inode)->extent_mutex);
+        return 0;
+}
+
+/*
  * when extent_io.c finds a delayed allocation range in the file,
  * the call backs end up in this code.  The basic idea is to
  * allocate extents on disk for the range, and create ordered data structs
  * in ram to track those extents.
+ *
+ * locked_page is the page that writepage had locked already.  We use
+ * it to make sure we don't do extra locks or unlocks.
+ *
+ * *page_started is set to one if we unlock locked_page and do everything
+ * required to start IO on it.  It may be clean and already done with
+ * IO when we return.
  */
-static int cow_file_range(struct inode *inode, u64 start, u64 end)
+static int cow_file_range(struct inode *inode, struct page *locked_page,
+                          u64 start, u64 end, int *page_started)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
         struct btrfs_trans_handle *trans;
         u64 alloc_hint = 0;
         u64 num_bytes;
+        unsigned long ram_size;
+        u64 orig_start;
+        u64 disk_num_bytes;
         u64 cur_alloc_size;
         u64 blocksize = root->sectorsize;
-        u64 orig_num_bytes;
+        u64 actual_end;
         struct btrfs_key ins;
         struct extent_map *em;
         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
         int ret = 0;
+        struct page **pages = NULL;
+        unsigned long nr_pages;
+        unsigned long nr_pages_ret = 0;
+        unsigned long total_compressed = 0;
+        unsigned long total_in = 0;
+        unsigned long max_compressed = 128 * 1024;
+        unsigned long max_uncompressed = 256 * 1024;
+        int i;
+        int will_compress;
 
         trans = btrfs_join_transaction(root, 1);
         BUG_ON(!trans);
         btrfs_set_trans_block_group(trans, inode);
+        orig_start = start;
+
+        /*
+         * compression made this loop a bit ugly, but the basic idea is to
+         * compress some pages but keep the total size of the compressed
+         * extent relatively small.  If compression is off, this goto target
+         * is never used.
+         */
+again:
+        will_compress = 0;
+        nr_pages = (end >> PAGE_CACHE_SHIFT) - (start >> PAGE_CACHE_SHIFT) + 1;
+        nr_pages = min(nr_pages, (128 * 1024UL) / PAGE_CACHE_SIZE);
 
+        actual_end = min_t(u64, i_size_read(inode), end + 1);
+        total_compressed = actual_end - start;
+
+        /* we want to make sure that amount of ram required to uncompress
+         * an extent is reasonable, so we limit the total size in ram
+         * of a compressed extent to 256k
+         */
+        total_compressed = min(total_compressed, max_uncompressed);
         num_bytes = (end - start + blocksize) & ~(blocksize - 1);
         num_bytes = max(blocksize,  num_bytes);
-        orig_num_bytes = num_bytes;
+        disk_num_bytes = num_bytes;
+        total_in = 0;
+        ret = 0;
 
-        if (alloc_hint == EXTENT_MAP_INLINE)
-                goto out;
+        /* we do compression for mount -o compress and when the
+         * inode has not been flagged as nocompress
+         */
+        if (!btrfs_test_flag(inode, NOCOMPRESS) &&
+            btrfs_test_opt(root, COMPRESS)) {
+                WARN_ON(pages);
+                pages = kmalloc(sizeof(struct page *) * nr_pages, GFP_NOFS);
+
+                /* we want to make sure the amount of IO required to satisfy
+                 * a random read is reasonably small, so we limit the size
+                 * of a compressed extent to 128k
+                 */
+                ret = btrfs_zlib_compress_pages(inode->i_mapping, start,
+                                                total_compressed, pages,
+                                                nr_pages, &nr_pages_ret,
+                                                &total_in,
+                                                &total_compressed,
+                                                max_compressed);
+
+                if (!ret) {
+                        unsigned long offset = total_compressed &
+                                (PAGE_CACHE_SIZE - 1);
+                        struct page *page = pages[nr_pages_ret - 1];
+                        char *kaddr;
+
+                        /* zero the tail end of the last page, we might be
+                         * sending it down to disk
+                         */
+                        if (offset) {
+                                kaddr = kmap_atomic(page, KM_USER0);
+                                memset(kaddr + offset, 0,
+                                       PAGE_CACHE_SIZE - offset);
+                                kunmap_atomic(kaddr, KM_USER0);
+                        }
+                        will_compress = 1;
+                }
+        }
+        if (start == 0) {
+                /* lets try to make an inline extent */
+                if (ret || total_in < (end - start + 1)) {
+                        /* we didn't compress the entire range, try
+                         * to make an uncompressed inline extent.  This
+                         * is almost sure to fail, but maybe inline sizes
+                         * will get bigger later
+                         */
+                        ret = cow_file_range_inline(trans, root, inode,
+                                                    start, end, 0, NULL);
+                } else {
+                        ret = cow_file_range_inline(trans, root, inode,
+                                                    start, end,
+                                                    total_compressed, pages);
+                }
+                if (ret == 0) {
+                        extent_clear_unlock_delalloc(inode,
+                                                     &BTRFS_I(inode)->io_tree,
+                                                     start, end, NULL,
+                                                     1, 1, 1);
+                        *page_started = 1;
+                        ret = 0;
+                        goto free_pages_out;
+                }
+        }
+
+        if (will_compress) {
+                /*
+                 * we aren't doing an inline extent round the compressed size
+                 * up to a block size boundary so the allocator does sane
+                 * things
+                 */
+                total_compressed = (total_compressed + blocksize - 1) &
+                        ~(blocksize - 1);
+
+                /*
+                 * one last check to make sure the compression is really a
+                 * win, compare the page count read with the blocks on disk
+                 */
+                total_in = (total_in + PAGE_CACHE_SIZE - 1) &
+                        ~(PAGE_CACHE_SIZE - 1);
+                if (total_compressed >= total_in) {
+                        will_compress = 0;
+                } else {
+                        disk_num_bytes = total_compressed;
+                        num_bytes = total_in;
+                }
+        }
+        if (!will_compress && pages) {
+                /*
+                 * the compression code ran but failed to make things smaller,
+                 * free any pages it allocated and our page pointer array
+                 */
+                for (i = 0; i < nr_pages_ret; i++) {
+                        page_cache_release(pages[i]);
+                }
+                kfree(pages);
+                pages = NULL;
+                total_compressed = 0;
+                nr_pages_ret = 0;
+
+                /* flag the file so we don't compress in the future */
+                btrfs_set_flag(inode, NOCOMPRESS);
+        }
+
+        BUG_ON(disk_num_bytes >
+               btrfs_super_total_bytes(&root->fs_info->super_copy));
 
-        BUG_ON(num_bytes > btrfs_super_total_bytes(&root->fs_info->super_copy));
         mutex_lock(&BTRFS_I(inode)->extent_mutex);
         btrfs_drop_extent_cache(inode, start, start + num_bytes - 1, 0);
         mutex_unlock(&BTRFS_I(inode)->extent_mutex);
 
-        while(num_bytes > 0) {
-                cur_alloc_size = min(num_bytes, root->fs_info->max_extent);
+        while(disk_num_bytes > 0) {
+                unsigned long min_bytes;
+
+                /*
+                 * the max size of a compressed extent is pretty small,
+                 * make the code a little less complex by forcing
+                 * the allocator to find a whole compressed extent at once
+                 */
+                if (will_compress)
+                        min_bytes = disk_num_bytes;
+                else
+                        min_bytes = root->sectorsize;
+
+                cur_alloc_size = min(disk_num_bytes, root->fs_info->max_extent);
                 ret = btrfs_reserve_extent(trans, root, cur_alloc_size,
-                                           root->sectorsize, 0, alloc_hint,
+                                           min_bytes, 0, alloc_hint,
                                            (u64)-1, &ins, 1);
                 if (ret) {
                         WARN_ON(1);
-                        goto out;
+                        goto free_pages_out_fail;
                 }
                 em = alloc_extent_map(GFP_NOFS);
                 em->start = start;
-                em->len = ins.offset;
+
+                if (will_compress) {
+                        ram_size = num_bytes;
+                        em->len = num_bytes;
+                } else {
+                        /* ramsize == disk size */
+                        ram_size = ins.offset;
+                        em->len = ins.offset;
+                }
+
                 em->block_start = ins.objectid;
+                em->block_len = ins.offset;
                 em->bdev = root->fs_info->fs_devices->latest_bdev;
+
                 mutex_lock(&BTRFS_I(inode)->extent_mutex);
                 set_bit(EXTENT_FLAG_PINNED, &em->flags);
+
+                if (will_compress)
+                        set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
+
                 while(1) {
                         spin_lock(&em_tree->lock);
                         ret = add_extent_mapping(em_tree, em);
@@ -174,26 +493,95 @@ static int cow_file_range(struct inode *inode, u64 start, u64 end)
                                 break;
                         }
                         btrfs_drop_extent_cache(inode, start,
-                                                start + ins.offset - 1, 0);
+                                                start + ram_size - 1, 0);
                 }
                 mutex_unlock(&BTRFS_I(inode)->extent_mutex);
 
                 cur_alloc_size = ins.offset;
                 ret = btrfs_add_ordered_extent(inode, start, ins.objectid,
-                                               ins.offset, 0);
+                                               ram_size, cur_alloc_size, 0,
+                                               will_compress);
                 BUG_ON(ret);
-                if (num_bytes < cur_alloc_size) {
-                        printk("num_bytes %Lu cur_alloc %Lu\n", num_bytes,
+
+                if (disk_num_bytes < cur_alloc_size) {
+                        printk("num_bytes %Lu cur_alloc %Lu\n", disk_num_bytes,
                                cur_alloc_size);
                         break;
                 }
+
+                if (will_compress) {
+                        /*
+                         * we're doing compression, we and we need to
+                         * submit the compressed extents down to the device.
+                         *
+                         * We lock down all the file pages, clearing their
+                         * dirty bits and setting them writeback.  Everyone
+                         * that wants to modify the page will wait on the
+                         * ordered extent above.
+                         *
+                         * The writeback bits on the file pages are
+                         * cleared when the compressed pages are on disk
+                         */
+                        btrfs_end_transaction(trans, root);
+
+                        if (start <= page_offset(locked_page) &&
+                            page_offset(locked_page) < start + ram_size) {
+                                *page_started = 1;
+                        }
+
+                        extent_clear_unlock_delalloc(inode,
+                                                     &BTRFS_I(inode)->io_tree,
+                                                     start,
+                                                     start + ram_size - 1,
+                                                     NULL, 1, 1, 0);
+
+                        ret = btrfs_submit_compressed_write(inode, start,
+                                                 ram_size, ins.objectid,
+                                                 cur_alloc_size, pages,
+                                                 nr_pages_ret);
+
+                        BUG_ON(ret);
+                        trans = btrfs_join_transaction(root, 1);
+                        if (start + ram_size < end) {
+                                start += ram_size;
+                                alloc_hint = ins.objectid + ins.offset;
+                                /* pages will be freed at end_bio time */
+                                pages = NULL;
+                                goto again;
+                        } else {
+                                /* we've written everything, time to go */
+                                break;
+                        }
+                }
+                /* we're not doing compressed IO, don't unlock the first
+                 * page (which the caller expects to stay locked), don't
+                 * clear any dirty bits and don't set any writeback bits
+                 */
+                extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
+                                             start, start + ram_size - 1,
+                                             locked_page, 0, 0, 0);
+                disk_num_bytes -= cur_alloc_size;
                 num_bytes -= cur_alloc_size;
                 alloc_hint = ins.objectid + ins.offset;
                 start += cur_alloc_size;
         }
+
+        ret = 0;
 out:
         btrfs_end_transaction(trans, root);
+
         return ret;
+
+free_pages_out_fail:
+        extent_clear_unlock_delalloc(inode, &BTRFS_I(inode)->io_tree,
+                                     start, end, locked_page, 0, 0, 0);
+free_pages_out:
+        for (i = 0; i < nr_pages_ret; i++)
+                page_cache_release(pages[i]);
+        if (pages)
+                kfree(pages);
+
+        goto out;
 }
 
 /*
@@ -203,7 +591,8 @@ out:
  * If no cow copies or snapshots exist, we write directly to the existing
  * blocks on disk
  */
-static int run_delalloc_nocow(struct inode *inode, u64 start, u64 end)
+static int run_delalloc_nocow(struct inode *inode, struct page *locked_page,
+                              u64 start, u64 end, int *page_started)
 {
         u64 extent_start;
         u64 extent_end;
@@ -260,6 +649,11 @@ again:
                 extent_end = extent_start + extent_num_bytes;
                 err = 0;
 
+                if (btrfs_file_extent_compression(leaf, item) ||
+                    btrfs_file_extent_encryption(leaf,item) ||
+                    btrfs_file_extent_other_encoding(leaf, item))
+                        goto not_found;
+
                 if (loops && start != extent_start)
                         goto not_found;
 
@@ -284,7 +678,8 @@ again:
                 bytenr += btrfs_file_extent_offset(leaf, item);
                 extent_num_bytes = min(end + 1, extent_end) - start;
                 ret = btrfs_add_ordered_extent(inode, start, bytenr,
-                                                extent_num_bytes, 1);
+                                                extent_num_bytes,
+                                                extent_num_bytes, 1, 0);
                 if (ret) {
                         err = ret;
                         goto out;
@@ -300,7 +695,8 @@ again:
 not_found:
                 btrfs_end_transaction(trans, root);
                 btrfs_free_path(path);
-                return cow_file_range(inode, start, end);
+                return cow_file_range(inode, locked_page, start, end,
+                                      page_started);
         }
 out:
         WARN_ON(err);
@@ -312,16 +708,19 @@ out:
 /*
  * extent_io.c call back to do delayed allocation processing
  */
-static int run_delalloc_range(struct inode *inode, u64 start, u64 end)
+static int run_delalloc_range(struct inode *inode, struct page *locked_page,
+                              u64 start, u64 end, int *page_started)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
         int ret;
 
         if (btrfs_test_opt(root, NODATACOW) ||
             btrfs_test_flag(inode, NODATACOW))
-                ret = run_delalloc_nocow(inode, start, end);
+                ret = run_delalloc_nocow(inode, locked_page, start, end,
+                                         page_started);
         else
-                ret = cow_file_range(inode, start, end);
+                ret = cow_file_range(inode, locked_page, start, end,
+                                     page_started);
 
         return ret;
 }
@@ -383,7 +782,8 @@ int btrfs_clear_bit_hook(struct inode *inode, u64 start, u64 end,
  * we don't create bios that span stripes or chunks
  */
 int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
-                         size_t size, struct bio *bio)
+                         size_t size, struct bio *bio,
+                         unsigned long bio_flags)
 {
         struct btrfs_root *root = BTRFS_I(page->mapping->host)->root;
         struct btrfs_mapping_tree *map_tree;
@@ -413,7 +813,7 @@ int btrfs_merge_bio_hook(struct page *page, unsigned long offset,
  * are inserted into the btree
  */
 int __btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
-                          int mirror_num)
+                          int mirror_num, unsigned long bio_flags)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
         int ret = 0;
@@ -429,7 +829,7 @@ int __btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
  * or reading the csums from the tree before a read
  */
 int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
-                          int mirror_num)
+                          int mirror_num, unsigned long bio_flags)
 {
         struct btrfs_root *root = BTRFS_I(inode)->root;
         int ret = 0;
@@ -444,11 +844,17 @@ int btrfs_submit_bio_hook(struct inode *inode, int rw, struct bio *bio,
 
         if (!(rw & (1 << BIO_RW))) {
                 btrfs_lookup_bio_sums(root, inode, bio);
+
+                if (bio_flags & EXTENT_BIO_COMPRESSED) {
+                        return btrfs_submit_compressed_read(inode, bio,
+                                                    mirror_num, bio_flags);
+                }
+
                 goto mapit;
         }
         return btrfs_wq_submit_bio(BTRFS_I(inode)->root->fs_info,
                                    inode, rw, bio, mirror_num,
-                                   __btrfs_submit_bio_hook);
+                                   bio_flags, __btrfs_submit_bio_hook);
 mapit:
         return btrfs_map_bio(root, rw, bio, mirror_num, 0);
 }
@@ -539,7 +945,7 @@ out_page:
  * good idea.  This causes problems because we want to make sure COW
  * properly happens and the data=ordered rules are followed.
  *
- * In our case any range that doesn't have the EXTENT_ORDERED bit set
+ * In our case any range that doesn't have the ORDERED bit set
  * hasn't been properly setup for IO.  We kick off an async process
  * to fix it up.  The async helper will wait for ordered extents, set
  * the delalloc bit and make it safe to write the page.
@@ -632,10 +1038,21 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
         btrfs_set_file_extent_disk_bytenr(leaf, extent_item,
                                           ordered_extent->start);
         btrfs_set_file_extent_disk_num_bytes(leaf, extent_item,
-                                             ordered_extent->len);
+                                             ordered_extent->disk_len);
         btrfs_set_file_extent_offset(leaf, extent_item, 0);
+
+        if (test_bit(BTRFS_ORDERED_COMPRESSED, &ordered_extent->flags))
+                btrfs_set_file_extent_compression(leaf, extent_item, 1);
+        else
+                btrfs_set_file_extent_compression(leaf, extent_item, 0);
+        btrfs_set_file_extent_encryption(leaf, extent_item, 0);
+        btrfs_set_file_extent_other_encoding(leaf, extent_item, 0);
+
+        /* ram bytes = extent_num_bytes for now */
         btrfs_set_file_extent_num_bytes(leaf, extent_item,
                                         ordered_extent->len);
+        btrfs_set_file_extent_ram_bytes(leaf, extent_item,
+                                        ordered_extent->len);
         btrfs_mark_buffer_dirty(leaf);
 
         btrfs_drop_extent_cache(inode, ordered_extent->file_offset,
@@ -644,7 +1061,7 @@ static int btrfs_finish_ordered_io(struct inode *inode, u64 start, u64 end)
         mutex_unlock(&BTRFS_I(inode)->extent_mutex);
 
         ins.objectid = ordered_extent->start;
-        ins.offset = ordered_extent->len;
+        ins.offset = ordered_extent->disk_len;
         ins.type = BTRFS_EXTENT_ITEM_KEY;
         ret = btrfs_alloc_reserved_extent(trans, root, leaf->start,
                                           root->root_key.objectid,
@@ -714,6 +1131,7 @@ int btrfs_io_failed_hook(struct bio *failed_bio,
         int ret;
         int rw;
         u64 logical;
+        unsigned long bio_flags = 0;
 
         ret = get_state_private(failure_tree, start, &private);
         if (ret) {
@@ -738,6 +1156,8 @@ int btrfs_io_failed_hook(struct bio *failed_bio,
                 }
                 logical = start - em->start;
                 logical = em->block_start + logical;
+                if (test_bit(EXTENT_FLAG_COMPRESSED, &em->flags))
+                        bio_flags = EXTENT_BIO_COMPRESSED;
                 failrec->logical = logical;
                 free_extent_map(em);
                 set_extent_bits(failure_tree, start, end, EXTENT_LOCKED |
@@ -781,7 +1201,8 @@ int btrfs_io_failed_hook(struct bio *failed_bio,
                 rw = READ;
 
         BTRFS_I(inode)->io_tree.ops->submit_bio_hook(inode, rw, bio,
-                                                      failrec->last_mirror);
+                                                      failrec->last_mirror,
+                                                      bio_flags);
         return 0;
 }
 
@@ -1644,10 +2065,8 @@ search_again:
                                 item_end +=
                                     btrfs_file_extent_num_bytes(leaf, fi);
                         } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
-                                struct btrfs_item *item = btrfs_item_nr(leaf,
-                                                                path->slots[0]);
                                 item_end += btrfs_file_extent_inline_len(leaf,
-                                                                         item);
+                                                                         fi);
                         }
                         item_end--;
                 }
@@ -1715,7 +2134,14 @@ search_again:
                                 root_owner = btrfs_header_owner(leaf);
                         }
                 } else if (extent_type == BTRFS_FILE_EXTENT_INLINE) {
-                        if (!del_item) {
+                        /*
+                         * we can't truncate inline items that have had
+                         * special encodings
+                         */
+                        if (!del_item &&
+                            btrfs_file_extent_compression(leaf, fi) == 0 &&
+                            btrfs_file_extent_encryption(leaf, fi) == 0 &&
+                            btrfs_file_extent_other_encoding(leaf, fi) == 0) {
                                 u32 size = new_size - found_key.offset;
 
                                 if (root->ref_cows) {
@@ -1926,7 +2352,8 @@ static int btrfs_setattr(struct dentry *dentry, struct iattr *attr)
                         err = btrfs_insert_file_extent(trans, root,
                                                        inode->i_ino,
                                                        hole_start, 0, 0,
-                                                       hole_size, 0);
+                                                       hole_size, 0, hole_size,
+                                                       0, 0, 0);
                         btrfs_drop_extent_cache(inode, hole_start,
                                                 (u64)-1, 0);
                         btrfs_check_file(root, inode);
@@ -2894,11 +3321,50 @@ static int merge_extent_mapping(struct extent_map_tree *em_tree,
         start_diff = map_start - em->start;
         em->start = map_start;
         em->len = map_len;
-        if (em->block_start < EXTENT_MAP_LAST_BYTE)
+        if (em->block_start < EXTENT_MAP_LAST_BYTE &&
+            !test_bit(EXTENT_FLAG_COMPRESSED, &em->flags)) {
                 em->block_start += start_diff;
+                em->block_len -= start_diff;
+        }
         return add_extent_mapping(em_tree, em);
 }
 
+static noinline int uncompress_inline(struct btrfs_path *path,
+                                      struct inode *inode, struct page *page,
+                                      size_t pg_offset, u64 extent_offset,
+                                      struct btrfs_file_extent_item *item)
+{
+        int ret;
+        struct extent_buffer *leaf = path->nodes[0];
+        char *tmp;
+        size_t max_size;
+        unsigned long inline_size;
+        unsigned long ptr;
+
+        WARN_ON(pg_offset != 0);
+        max_size = btrfs_file_extent_ram_bytes(leaf, item);
+        inline_size = btrfs_file_extent_inline_item_len(leaf,
+                                        btrfs_item_nr(leaf, path->slots[0]));
+        tmp = kmalloc(inline_size, GFP_NOFS);
+        ptr = btrfs_file_extent_inline_start(item);
+
+        read_extent_buffer(leaf, tmp, ptr, inline_size);
+
+        max_size = min(PAGE_CACHE_SIZE, max_size);
+        ret = btrfs_zlib_decompress(tmp, page, extent_offset,
+                                    inline_size, max_size);
+        if (ret) {
+                char *kaddr = kmap_atomic(page, KM_USER0);
+                unsigned long copy_size = min_t(u64,
+                                  PAGE_CACHE_SIZE - pg_offset,
+                                  max_size - extent_offset);
+                memset(kaddr + pg_offset, 0, copy_size);
+                kunmap_atomic(kaddr, KM_USER0);
+        }
+        kfree(tmp);
+        return 0;
+}
+
 /*
  * a bit scary, this does extent mapping from logical file offset to the disk.
  * the ugly parts come from merging extents from the disk with the
@@ -2927,6 +3393,7 @@ struct extent_map *btrfs_get_extent(struct inode *inode, struct page *page,
         struct extent_map_tree *em_tree = &BTRFS_I(inode)->extent_tree;
         struct extent_io_tree *io_tree = &BTRFS_I(inode)->io_tree;
         struct btrfs_trans_handle *trans = NULL;
+        int compressed;
 
 again:
         spin_lock(&em_tree->lock);
@@ -2951,6 +3418,7 @@ again:
         em->bdev = root->fs_info->fs_devices->latest_bdev;
         em->start = EXTENT_MAP_HOLE;
         em->len = (u64)-1;
+        em->block_len = (u64)-1;
 
         if (!path) {
                 path = btrfs_alloc_path();
@@ -2983,6 +3451,7 @@ again:
 
         found_type = btrfs_file_extent_type(leaf, item);
         extent_start = found_key.offset;
+        compressed = btrfs_file_extent_compression(leaf, item);
         if (found_type == BTRFS_FILE_EXTENT_REG) {
                 extent_end = extent_start +
                        btrfs_file_extent_num_bytes(leaf, item);
@@ -3005,10 +3474,18 @@ again:
                         em->block_start = EXTENT_MAP_HOLE;
                         goto insert;
                 }
-                bytenr += btrfs_file_extent_offset(leaf, item);
-                em->block_start = bytenr;
                 em->start = extent_start;
                 em->len = extent_end - extent_start;
+                if (compressed) {
+                        set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
+                        em->block_start = bytenr;
+                        em->block_len = btrfs_file_extent_disk_num_bytes(leaf,
+                                                                         item);
+                } else {
+                        bytenr += btrfs_file_extent_offset(leaf, item);
+                        em->block_start = bytenr;
+                        em->block_len = em->len;
+                }
                 goto insert;
         } else if (found_type == BTRFS_FILE_EXTENT_INLINE) {
                 u64 page_start;
@@ -3018,8 +3495,7 @@ again:
                 size_t extent_offset;
                 size_t copy_size;
 
-                size = btrfs_file_extent_inline_len(leaf, btrfs_item_nr(leaf,
-                                                    path->slots[0]));
+                size = btrfs_file_extent_inline_len(leaf, item);
                 extent_end = (extent_start + size + root->sectorsize - 1) &
                         ~((u64)root->sectorsize - 1);
                 if (start < extent_start || start >= extent_end) {
@@ -3035,9 +3511,10 @@ again:
                 }
                 em->block_start = EXTENT_MAP_INLINE;
 
-                if (!page) {
+                if (!page || create) {
                         em->start = extent_start;
-                        em->len = size;
+                        em->len = (size + root->sectorsize - 1) &
+                        ~((u64)root->sectorsize - 1);
                         goto out;
                 }
 
@@ -3048,11 +3525,22 @@ again:
                 em->start = extent_start + extent_offset;
                 em->len = (copy_size + root->sectorsize - 1) &
                         ~((u64)root->sectorsize - 1);
-                map = kmap(page);
+                if (compressed)
+                        set_bit(EXTENT_FLAG_COMPRESSED, &em->flags);
                 ptr = btrfs_file_extent_inline_start(item) + extent_offset;
                 if (create == 0 && !PageUptodate(page)) {
-                        read_extent_buffer(leaf, map + pg_offset, ptr,
-                                           copy_size);
+                        if (btrfs_file_extent_compression(leaf, item) ==
+                            BTRFS_COMPRESS_ZLIB) {
+                                ret = uncompress_inline(path, inode, page,
+                                                        pg_offset,
+                                                        extent_offset, item);
+                                BUG_ON(ret);
+                        } else {
+                                map = kmap(page);
+                                read_extent_buffer(leaf, map + pg_offset, ptr,
+                                                   copy_size);
+                                kunmap(page);
+                        }
                         flush_dcache_page(page);
                 } else if (create && PageUptodate(page)) {
                         if (!trans) {
@@ -3063,11 +3551,12 @@ again:
                                 trans = btrfs_join_transaction(root, 1);
                                 goto again;
                         }
+                        map = kmap(page);
                         write_extent_buffer(leaf, map + pg_offset, ptr,
                                             copy_size);
+                        kunmap(page);
                         btrfs_mark_buffer_dirty(leaf);
                 }
-                kunmap(page);
                 set_extent_uptodate(io_tree, em->start,
                                     extent_map_end(em) - 1, GFP_NOFS);
                 goto insert;
@@ -3779,6 +4268,11 @@ static int btrfs_symlink(struct inode *dir, struct dentry *dentry,
         btrfs_set_file_extent_generation(leaf, ei, trans->transid);
         btrfs_set_file_extent_type(leaf, ei,
                                    BTRFS_FILE_EXTENT_INLINE);
+        btrfs_set_file_extent_encryption(leaf, ei, 0);
+        btrfs_set_file_extent_compression(leaf, ei, 0);
+        btrfs_set_file_extent_other_encoding(leaf, ei, 0);
+        btrfs_set_file_extent_ram_bytes(leaf, ei, name_len);
+
         ptr = btrfs_file_extent_inline_start(ei);
         write_extent_buffer(leaf, symname, ptr, name_len);
         btrfs_mark_buffer_dirty(leaf);