Patched in Tegra support.

1 files changed, 30 insertions, 43 deletions

diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index 94ab2f80e7e..8ec5d86f173 100644
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -85,8 +85,7 @@ struct compressed_bio {
 static inline int compressed_bio_size(struct btrfs_root *root,
                                       unsigned long disk_size)
 {
-        u16 csum_size = btrfs_super_csum_size(root->fs_info->super_copy);
-
+        u16 csum_size = btrfs_super_csum_size(&root->fs_info->super_copy);
         return sizeof(struct compressed_bio) +
                 ((disk_size + root->sectorsize - 1) / root->sectorsize) *
                 csum_size;
@@ -120,10 +119,10 @@ static int check_compressed_csum(struct inode *inode,
                 page = cb->compressed_pages[i];
                 csum = ~(u32)0;
 
-                kaddr = kmap_atomic(page);
+                kaddr = kmap_atomic(page, KM_USER0);
                 csum = btrfs_csum_data(root, kaddr, csum, PAGE_CACHE_SIZE);
                 btrfs_csum_final(csum, (char *)&csum);
-                kunmap_atomic(kaddr);
+                kunmap_atomic(kaddr, KM_USER0);
 
                 if (csum != *cb_sum) {
                         printk(KERN_INFO "btrfs csum failed ino %llu "
@@ -226,8 +225,8 @@ out:
  * Clear the writeback bits on all of the file
  * pages for a compressed write
  */
-static noinline void end_compressed_writeback(struct inode *inode, u64 start,
-                                              unsigned long ram_size)
+static noinline int end_compressed_writeback(struct inode *inode, u64 start,
+                                             unsigned long ram_size)
 {
         unsigned long index = start >> PAGE_CACHE_SHIFT;
         unsigned long end_index = (start + ram_size - 1) >> PAGE_CACHE_SHIFT;
@@ -253,6 +252,7 @@ static noinline void end_compressed_writeback(struct inode *inode, u64 start,
                 index += ret;
         }
         /* the inode may be gone now */
+        return 0;
 }
 
 /*
@@ -391,21 +391,20 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
                          */
                         atomic_inc(&cb->pending_bios);
                         ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
-                        BUG_ON(ret); /* -ENOMEM */
+                        BUG_ON(ret);
 
                         if (!skip_sum) {
                                 ret = btrfs_csum_one_bio(root, inode, bio,
                                                          start, 1);
-                                BUG_ON(ret); /* -ENOMEM */
+                                BUG_ON(ret);
                         }
 
                         ret = btrfs_map_bio(root, WRITE, bio, 0, 1);
-                        BUG_ON(ret); /* -ENOMEM */
+                        BUG_ON(ret);
 
                         bio_put(bio);
 
                         bio = compressed_bio_alloc(bdev, first_byte, GFP_NOFS);
-                        BUG_ON(!bio);
                         bio->bi_private = cb;
                         bio->bi_end_io = end_compressed_bio_write;
                         bio_add_page(bio, page, PAGE_CACHE_SIZE, 0);
@@ -421,15 +420,15 @@ int btrfs_submit_compressed_write(struct inode *inode, u64 start,
         bio_get(bio);
 
         ret = btrfs_bio_wq_end_io(root->fs_info, bio, 0);
-        BUG_ON(ret); /* -ENOMEM */
+        BUG_ON(ret);
 
         if (!skip_sum) {
                 ret = btrfs_csum_one_bio(root, inode, bio, start, 1);
-                BUG_ON(ret); /* -ENOMEM */
+                BUG_ON(ret);
         }
 
         ret = btrfs_map_bio(root, WRITE, bio, 0, 1);
-        BUG_ON(ret); /* -ENOMEM */
+        BUG_ON(ret);
 
         bio_put(bio);
         return 0;
@@ -497,7 +496,7 @@ static noinline int add_ra_bio_pages(struct inode *inode,
                  * sure they map to this compressed extent on disk.
                  */
                 set_page_extent_mapped(page);
-                lock_extent(tree, last_offset, end);
+                lock_extent(tree, last_offset, end, GFP_NOFS);
                 read_lock(&em_tree->lock);
                 em = lookup_extent_mapping(em_tree, last_offset,
                                            PAGE_CACHE_SIZE);
@@ -507,7 +506,7 @@ static noinline int add_ra_bio_pages(struct inode *inode,
                     (last_offset + PAGE_CACHE_SIZE > extent_map_end(em)) ||
                     (em->block_start >> 9) != cb->orig_bio->bi_sector) {
                         free_extent_map(em);
-                        unlock_extent(tree, last_offset, end);
+                        unlock_extent(tree, last_offset, end, GFP_NOFS);
                         unlock_page(page);
                         page_cache_release(page);
                         break;
@@ -521,10 +520,10 @@ static noinline int add_ra_bio_pages(struct inode *inode,
                         if (zero_offset) {
                                 int zeros;
                                 zeros = PAGE_CACHE_SIZE - zero_offset;
-                                userpage = kmap_atomic(page);
+                                userpage = kmap_atomic(page, KM_USER0);
                                 memset(userpage + zero_offset, 0, zeros);
                                 flush_dcache_page(page);
-                                kunmap_atomic(userpage);
+                                kunmap_atomic(userpage, KM_USER0);
                         }
                 }
 
@@ -535,7 +534,7 @@ static noinline int add_ra_bio_pages(struct inode *inode,
                         nr_pages++;
                         page_cache_release(page);
                 } else {
-                        unlock_extent(tree, last_offset, end);
+                        unlock_extent(tree, last_offset, end, GFP_NOFS);
                         unlock_page(page);
                         page_cache_release(page);
                         break;
@@ -577,7 +576,6 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
         u64 em_start;
         struct extent_map *em;
         int ret = -ENOMEM;
-        int faili = 0;
         u32 *sums;
 
         tree = &BTRFS_I(inode)->io_tree;
@@ -589,8 +587,6 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
                                    page_offset(bio->bi_io_vec->bv_page),
                                    PAGE_CACHE_SIZE);
         read_unlock(&em_tree->lock);
-        if (!em)
-                return -EIO;
 
         compressed_len = em->block_len;
         cb = kmalloc(compressed_bio_size(root, compressed_len), GFP_NOFS);
@@ -627,13 +623,9 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
         for (pg_index = 0; pg_index < nr_pages; pg_index++) {
                 cb->compressed_pages[pg_index] = alloc_page(GFP_NOFS |
                                                               __GFP_HIGHMEM);
-                if (!cb->compressed_pages[pg_index]) {
-                        faili = pg_index - 1;
-                        ret = -ENOMEM;
+                if (!cb->compressed_pages[pg_index])
                         goto fail2;
-                }
         }
-        faili = nr_pages - 1;
         cb->nr_pages = nr_pages;
 
         add_ra_bio_pages(inode, em_start + em_len, cb);
@@ -667,7 +659,7 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
                         bio_get(comp_bio);
 
                         ret = btrfs_bio_wq_end_io(root->fs_info, comp_bio, 0);
-                        BUG_ON(ret); /* -ENOMEM */
+                        BUG_ON(ret);
 
                         /*
                          * inc the count before we submit the bio so
@@ -680,21 +672,19 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
                         if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {
                                 ret = btrfs_lookup_bio_sums(root, inode,
                                                         comp_bio, sums);
-                                BUG_ON(ret); /* -ENOMEM */
+                                BUG_ON(ret);
                         }
                         sums += (comp_bio->bi_size + root->sectorsize - 1) /
                                 root->sectorsize;
 
                         ret = btrfs_map_bio(root, READ, comp_bio,
                                             mirror_num, 0);
-                        if (ret)
-                                bio_endio(comp_bio, ret);
+                        BUG_ON(ret);
 
                         bio_put(comp_bio);
 
                         comp_bio = compressed_bio_alloc(bdev, cur_disk_byte,
                                                         GFP_NOFS);
-                        BUG_ON(!comp_bio);
                         comp_bio->bi_private = cb;
                         comp_bio->bi_end_io = end_compressed_bio_read;
 
@@ -705,25 +695,22 @@ int btrfs_submit_compressed_read(struct inode *inode, struct bio *bio,
         bio_get(comp_bio);
 
         ret = btrfs_bio_wq_end_io(root->fs_info, comp_bio, 0);
-        BUG_ON(ret); /* -ENOMEM */
+        BUG_ON(ret);
 
         if (!(BTRFS_I(inode)->flags & BTRFS_INODE_NODATASUM)) {
                 ret = btrfs_lookup_bio_sums(root, inode, comp_bio, sums);
-                BUG_ON(ret); /* -ENOMEM */
+                BUG_ON(ret);
         }
 
         ret = btrfs_map_bio(root, READ, comp_bio, mirror_num, 0);
-        if (ret)
-                bio_endio(comp_bio, ret);
+        BUG_ON(ret);
 
         bio_put(comp_bio);
         return 0;
 
 fail2:
-        while (faili >= 0) {
-                __free_page(cb->compressed_pages[faili]);
-                faili--;
-        }
+        for (pg_index = 0; pg_index < nr_pages; pg_index++)
+                free_page((unsigned long)cb->compressed_pages[pg_index]);
 
         kfree(cb->compressed_pages);
 fail1:
@@ -744,7 +731,7 @@ struct btrfs_compress_op *btrfs_compress_op[] = {
         &btrfs_lzo_compress,
 };
 
-void __init btrfs_init_compress(void)
+int __init btrfs_init_compress(void)
 {
         int i;
 
@@ -754,6 +741,7 @@ void __init btrfs_init_compress(void)
                 atomic_set(&comp_alloc_workspace[i], 0);
                 init_waitqueue_head(&comp_workspace_wait[i]);
         }
+        return 0;
 }
 
 /*
@@ -827,7 +815,6 @@ static void free_workspace(int type, struct list_head *workspace)
         btrfs_compress_op[idx]->free_workspace(workspace);
         atomic_dec(alloc_workspace);
 wake:
-        smp_mb();
         if (waitqueue_active(workspace_wait))
                 wake_up(workspace_wait);
 }
@@ -1003,9 +990,9 @@ int btrfs_decompress_buf2page(char *buf, unsigned long buf_start,
                 bytes = min(PAGE_CACHE_SIZE - *pg_offset,
                             PAGE_CACHE_SIZE - buf_offset);
                 bytes = min(bytes, working_bytes);
-                kaddr = kmap_atomic(page_out);
+                kaddr = kmap_atomic(page_out, KM_USER0);
                 memcpy(kaddr + *pg_offset, buf + buf_offset, bytes);
-                kunmap_atomic(kaddr);
+                kunmap_atomic(kaddr, KM_USER0);
                 flush_dcache_page(page_out);
 
                 *pg_offset += bytes;