Btrfs: add support for multiple csum algorithms

This patch gives us the space we will need in order to have different csum
algorithims at some point in the future.  We save the csum algorithim type
in the superblock, and use those instead of define's.

Signed-off-by: Josef Bacik <jbacik@redhat.com>

5 files changed, 81 insertions, 38 deletions

diff --git a/fs/btrfs/ctree.h b/fs/btrfs/ctree.h
index b5af1fc77c5d..6d8350332b1d 100644
--- a/fs/btrfs/ctree.h
+++ b/fs/btrfs/ctree.h
@@ -109,8 +109,14 @@ struct btrfs_ordered_sum;
 
 /* 32 bytes in various csum fields */
 #define BTRFS_CSUM_SIZE 32
+
+/* csum types */
+#define BTRFS_CSUM_TYPE_CRC32   0
+
+static int btrfs_csum_sizes[] = { 4, 0 };
+
 /* four bytes for CRC32 */
-#define BTRFS_CRC32_SIZE 4
+//#define BTRFS_CRC32_SIZE 4
 #define BTRFS_EMPTY_DIR_SIZE 0
 
 #define BTRFS_FT_UNKNOWN        0
@@ -308,6 +314,7 @@ struct btrfs_super_block {
         __le64 compat_flags;
         __le64 compat_ro_flags;
         __le64 incompat_flags;
+        __le16 csum_type;
         u8 root_level;
         u8 chunk_root_level;
         u8 log_root_level;
@@ -1483,6 +1490,7 @@ BTRFS_SETGET_STACK_FUNCS(root_last_snapshot, struct btrfs_root_item,
                          last_snapshot, 64);
 
 /* struct btrfs_super_block */
+
 BTRFS_SETGET_STACK_FUNCS(super_bytenr, struct btrfs_super_block, bytenr, 64);
 BTRFS_SETGET_STACK_FUNCS(super_flags, struct btrfs_super_block, flags, 64);
 BTRFS_SETGET_STACK_FUNCS(super_generation, struct btrfs_super_block,
@@ -1524,6 +1532,15 @@ BTRFS_SETGET_STACK_FUNCS(super_compat_ro_flags, struct btrfs_super_block,
                          compat_flags, 64);
 BTRFS_SETGET_STACK_FUNCS(super_incompat_flags, struct btrfs_super_block,
                          incompat_flags, 64);
+BTRFS_SETGET_STACK_FUNCS(super_csum_type, struct btrfs_super_block,
+                         csum_type, 16);
+
+static inline int btrfs_super_csum_size(struct btrfs_super_block *s)
+{
+        int t = btrfs_super_csum_type(s);
+        BUG_ON(t >= ARRAY_SIZE(btrfs_csum_sizes));
+        return btrfs_csum_sizes[t];
+}
 
 static inline unsigned long btrfs_leaf_data(struct extent_buffer *l)
 {
diff --git a/fs/btrfs/disk-io.c b/fs/btrfs/disk-io.c
index dfd5ba05ce45..3eb7c2576fe5 100644
--- a/fs/btrfs/disk-io.c
+++ b/fs/btrfs/disk-io.c
@@ -176,7 +176,9 @@ void btrfs_csum_final(u32 crc, char *result)
 static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
                            int verify)
 {
-        char result[BTRFS_CRC32_SIZE];
+        u16 csum_size =
+                btrfs_super_csum_size(&root->fs_info->super_copy);
+        char *result = NULL;
         unsigned long len;
         unsigned long cur_len;
         unsigned long offset = BTRFS_CSUM_SIZE;
@@ -186,6 +188,7 @@ static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
         unsigned long map_len;
         int err;
         u32 crc = ~(u32)0;
+        unsigned long inline_result;
 
         len = buf->len - offset;
         while(len > 0) {
@@ -204,25 +207,37 @@ static int csum_tree_block(struct btrfs_root *root, struct extent_buffer *buf,
                 offset += cur_len;
                 unmap_extent_buffer(buf, map_token, KM_USER0);
         }
+        if (csum_size > sizeof(inline_result)) {
+                result = kzalloc(csum_size * sizeof(char), GFP_NOFS);
+                if (!result)
+                        return 1;
+        } else {
+                result = (char *)&inline_result;
+        }
+
         btrfs_csum_final(crc, result);
 
         if (verify) {
                 /* FIXME, this is not good */
-                if (memcmp_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE)) {
+                if (memcmp_extent_buffer(buf, result, 0, csum_size)) {
                         u32 val;
                         u32 found = 0;
-                        memcpy(&found, result, BTRFS_CRC32_SIZE);
+                        memcpy(&found, result, csum_size);
 
-                        read_extent_buffer(buf, &val, 0, BTRFS_CRC32_SIZE);
+                        read_extent_buffer(buf, &val, 0, csum_size);
                         printk("btrfs: %s checksum verify failed on %llu "
                                "wanted %X found %X level %d\n",
                                root->fs_info->sb->s_id,
                                buf->start, val, found, btrfs_header_level(buf));
+                        if (result != (char *)&inline_result)
+                                kfree(result);
                         return 1;
                 }
         } else {
-                write_extent_buffer(buf, result, 0, BTRFS_CRC32_SIZE);
+                write_extent_buffer(buf, result, 0, csum_size);
         }
+        if (result != (char *)&inline_result)
+                kfree(result);
         return 0;
 }
 
diff --git a/fs/btrfs/file-item.c b/fs/btrfs/file-item.c
index f76378831407..234ed441736c 100644
--- a/fs/btrfs/file-item.c
+++ b/fs/btrfs/file-item.c
@@ -24,9 +24,9 @@
 #include "transaction.h"
 #include "print-tree.h"
 
-#define MAX_CSUM_ITEMS(r) ((((BTRFS_LEAF_DATA_SIZE(r) - \
-                               sizeof(struct btrfs_item) * 2) / \
-                               BTRFS_CRC32_SIZE) - 1))
+#define MAX_CSUM_ITEMS(r,size) ((((BTRFS_LEAF_DATA_SIZE(r) - \
+                                   sizeof(struct btrfs_item) * 2) / \
+                                  size) - 1))
 int btrfs_insert_file_extent(struct btrfs_trans_handle *trans,
                              struct btrfs_root *root,
                              u64 objectid, u64 pos,
@@ -83,6 +83,8 @@ struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
         struct btrfs_csum_item *item;
         struct extent_buffer *leaf;
         u64 csum_offset = 0;
+        u16 csum_size =
+                btrfs_super_csum_size(&root->fs_info->super_copy);
         int csums_in_item;
 
         file_key.objectid = objectid;
@@ -105,7 +107,7 @@ struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
                 csum_offset = (offset - found_key.offset) >>
                                 root->fs_info->sb->s_blocksize_bits;
                 csums_in_item = btrfs_item_size_nr(leaf, path->slots[0]);
-                csums_in_item /= BTRFS_CRC32_SIZE;
+                csums_in_item /= csum_size;
 
                 if (csum_offset >= csums_in_item) {
                         ret = -EFBIG;
@@ -114,7 +116,7 @@ struct btrfs_csum_item *btrfs_lookup_csum(struct btrfs_trans_handle *trans,
         }
         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
         item = (struct btrfs_csum_item *)((unsigned char *)item +
-                                          csum_offset * BTRFS_CRC32_SIZE);
+                                          csum_offset * csum_size);
         return item;
 fail:
         if (ret > 0)
@@ -150,6 +152,8 @@ int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
         u64 item_start_offset = 0;
         u64 item_last_offset = 0;
         u32 diff;
+        u16 csum_size =
+                btrfs_super_csum_size(&root->fs_info->super_copy);
         int ret;
         struct btrfs_path *path;
         struct btrfs_csum_item *item = NULL;
@@ -195,7 +199,7 @@ int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
                         item_size = btrfs_item_size_nr(path->nodes[0],
                                                        path->slots[0]);
                         item_last_offset = item_start_offset +
-                                (item_size / BTRFS_CRC32_SIZE) *
+                                (item_size / csum_size) *
                                 root->sectorsize;
                         item = btrfs_item_ptr(path->nodes[0], path->slots[0],
                                               struct btrfs_csum_item);
@@ -206,11 +210,11 @@ int btrfs_lookup_bio_sums(struct btrfs_root *root, struct inode *inode,
                  */
                 diff = offset - item_start_offset;
                 diff = diff / root->sectorsize;
-                diff = diff * BTRFS_CRC32_SIZE;
+                diff = diff * csum_size;
 
                 read_extent_buffer(path->nodes[0], &sum,
                                    ((unsigned long)item) + diff,
-                                   BTRFS_CRC32_SIZE);
+                                   csum_size);
 found:
                 set_state_private(io_tree, offset, sum);
                 bio_index++;
@@ -383,6 +387,8 @@ int btrfs_csum_file_blocks(struct btrfs_trans_handle *trans,
         char *eb_token;
         unsigned long map_len;
         unsigned long map_start;
+        u16 csum_size =
+                btrfs_super_csum_size(&root->fs_info->super_copy);
 
         path = btrfs_alloc_path();
         BUG_ON(!path);
@@ -408,7 +414,8 @@ again:
                 /* we found one, but it isn't big enough yet */
                 leaf = path->nodes[0];
                 item_size = btrfs_item_size_nr(leaf, path->slots[0]);
-                if ((item_size / BTRFS_CRC32_SIZE) >= MAX_CSUM_ITEMS(root)) {
+                if ((item_size / csum_size) >=
+                    MAX_CSUM_ITEMS(root, csum_size)) {
                         /* already at max size, make a new one */
                         goto insert;
                 }
@@ -441,7 +448,7 @@ again:
          */
         btrfs_release_path(root, path);
         ret = btrfs_search_slot(trans, root, &file_key, path,
-                                BTRFS_CRC32_SIZE, 1);
+                                csum_size, 1);
         if (ret < 0)
                 goto fail_unlock;
         if (ret == 0) {
@@ -457,14 +464,14 @@ again:
                         root->fs_info->sb->s_blocksize_bits;
         if (btrfs_key_type(&found_key) != BTRFS_CSUM_ITEM_KEY ||
             found_key.objectid != objectid ||
-            csum_offset >= MAX_CSUM_ITEMS(root)) {
+            csum_offset >= MAX_CSUM_ITEMS(root, csum_size)) {
                 goto insert;
         }
         if (csum_offset >= btrfs_item_size_nr(leaf, path->slots[0]) /
-            BTRFS_CRC32_SIZE) {
-                u32 diff = (csum_offset + 1) * BTRFS_CRC32_SIZE;
+            csum_size) {
+                u32 diff = (csum_offset + 1) * csum_size;
                 diff = diff - btrfs_item_size_nr(leaf, path->slots[0]);
-                if (diff != BTRFS_CRC32_SIZE)
+                if (diff != csum_size)
                         goto insert;
                 ret = btrfs_extend_item(trans, root, path, diff);
                 BUG_ON(ret);
@@ -479,10 +486,10 @@ insert:
                 tmp -= offset & ~((u64)root->sectorsize -1);
                 tmp >>= root->fs_info->sb->s_blocksize_bits;
                 tmp = max((u64)1, tmp);
-                tmp = min(tmp, (u64)MAX_CSUM_ITEMS(root));
-                ins_size = BTRFS_CRC32_SIZE * tmp;
+                tmp = min(tmp, (u64)MAX_CSUM_ITEMS(root, csum_size));
+                ins_size = csum_size * tmp;
         } else {
-                ins_size = BTRFS_CRC32_SIZE;
+                ins_size = csum_size;
         }
         ret = btrfs_insert_empty_item(trans, root, path, &file_key,
                                       ins_size);
@@ -497,7 +504,7 @@ csum:
         item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
         ret = 0;
         item = (struct btrfs_csum_item *)((unsigned char *)item +
-                                          csum_offset * BTRFS_CRC32_SIZE);
+                                          csum_offset * csum_size);
 found:
         item_end = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_csum_item);
         item_end = (struct btrfs_csum_item *)((unsigned char *)item_end +
@@ -508,14 +515,14 @@ found:
 next_sector:
 
         if (!eb_token ||
-           (unsigned long)item  + BTRFS_CRC32_SIZE >= map_start + map_len) {
+           (unsigned long)item + csum_size >= map_start + map_len) {
                 int err;
 
                 if (eb_token)
                         unmap_extent_buffer(leaf, eb_token, KM_USER1);
                 eb_token = NULL;
                 err = map_private_extent_buffer(leaf, (unsigned long)item,
-                                                BTRFS_CRC32_SIZE,
+                                                csum_size,
                                                 &eb_token, &eb_map,
                                                 &map_start, &map_len, KM_USER1);
                 if (err)
@@ -523,17 +530,17 @@ next_sector:
         }
         if (eb_token) {
                 memcpy(eb_token + ((unsigned long)item & (PAGE_CACHE_SIZE - 1)),
-                       &sector_sum->sum, BTRFS_CRC32_SIZE);
+                       &sector_sum->sum, csum_size);
         } else {
                 write_extent_buffer(leaf, &sector_sum->sum,
-                                    (unsigned long)item, BTRFS_CRC32_SIZE);
+                                    (unsigned long)item, csum_size);
         }
 
         total_bytes += root->sectorsize;
         sector_sum++;
         if (total_bytes < sums->len) {
                 item = (struct btrfs_csum_item *)((char *)item +
-                                                  BTRFS_CRC32_SIZE);
+                                                  csum_size);
                 if (item < item_end && offset + PAGE_CACHE_SIZE ==
                     sector_sum->offset) {
                             offset = sector_sum->offset;
@@ -577,7 +584,8 @@ int btrfs_csum_truncate(struct btrfs_trans_handle *trans,
         new_item_span = isize - key.offset;
         blocks = (new_item_span + root->sectorsize - 1) >>
                 root->fs_info->sb->s_blocksize_bits;
-        new_item_size = blocks * BTRFS_CRC32_SIZE;
+        new_item_size = blocks *
+                btrfs_super_csum_size(&root->fs_info->super_copy);
         if (new_item_size >= btrfs_item_size_nr(leaf, slot))
                 return 0;
         ret = btrfs_truncate_item(trans, root, path, new_item_size, 1);
diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
index caea9eed9d62..b4da53d55c82 100644
--- a/fs/btrfs/ioctl.c
+++ b/fs/btrfs/ioctl.c
@@ -714,7 +714,8 @@ static long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
         u64 len = olen;
         u64 bs = root->fs_info->sb->s_blocksize;
         u64 hint_byte;
-
+        u16 csum_size =
+                btrfs_super_csum_size(&root->fs_info->super_copy);
         /*
          * TODO:
          * - split compressed inline extents.  annoying: we need to
@@ -964,7 +965,7 @@ static long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                         int coff, clen;
 
                         size = btrfs_item_size_nr(leaf, slot);
-                        coverslen = (size / BTRFS_CRC32_SIZE) <<
+                        coverslen = (size / csum_size) <<
                                 root->fs_info->sb->s_blocksize_bits;
                         printk("csums for %llu~%llu\n",
                                key.offset, coverslen);
@@ -981,12 +982,12 @@ static long btrfs_ioctl_clone(struct file *file, unsigned long srcfd,
                         if (off > key.offset)
                                 coff = ((off - key.offset) >>
                                         root->fs_info->sb->s_blocksize_bits) *
-                                        BTRFS_CRC32_SIZE;
+                                        csum_size;
                         clen = size - coff;
                         if (key.offset + coverslen > off+len)
                                 clen -= ((key.offset+coverslen-off-len) >>
                                          root->fs_info->sb->s_blocksize_bits) *
-                                        BTRFS_CRC32_SIZE;
+                                        csum_size;
                         printk(" will dup %d~%d of %d\n",
                                coff, clen, size);
 
diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 4fcfc8b1189b..c766649ad453 100644
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -929,13 +929,15 @@ static noinline int replay_one_csum(struct btrfs_trans_handle *trans,
         int ret;
         u32 item_size = btrfs_item_size_nr(eb, slot);
         u64 cur_offset;
+        u16 csum_size =
+                btrfs_super_csum_size(&root->fs_info->super_copy);
         unsigned long file_bytes;
         struct btrfs_ordered_sum *sums;
         struct btrfs_sector_sum *sector_sum;
         struct inode *inode;
         unsigned long ptr;
 
-        file_bytes = (item_size / BTRFS_CRC32_SIZE) * root->sectorsize;
+        file_bytes = (item_size / csum_size) * root->sectorsize;
         inode = read_one_inode(root, key->objectid);
         if (!inode) {
                 return -EIO;
@@ -959,10 +961,10 @@ static noinline int replay_one_csum(struct btrfs_trans_handle *trans,
         ptr = btrfs_item_ptr_offset(eb, slot);
         while(item_size > 0) {
                 sector_sum->offset = cur_offset;
-                read_extent_buffer(eb, &sector_sum->sum, ptr, BTRFS_CRC32_SIZE);
+                read_extent_buffer(eb, &sector_sum->sum, ptr, csum_size);
                 sector_sum++;
-                item_size -= BTRFS_CRC32_SIZE;
-                ptr += BTRFS_CRC32_SIZE;
+                item_size -= csum_size;
+                ptr += csum_size;
                 cur_offset += root->sectorsize;
         }