1 files changed, 64 insertions, 47 deletions

diff --git a/fs/btrfs/tests/qgroup-tests.c b/fs/btrfs/tests/qgroup-tests.c
index 8aa4ded31326..57a12c0d680b 100644
--- a/fs/btrfs/tests/qgroup-tests.c
+++ b/fs/btrfs/tests/qgroup-tests.c
@@ -16,6 +16,7 @@
  * Boston, MA 021110-1307, USA.
  */
 
+#include <linux/types.h>
 #include "btrfs-tests.h"
 #include "../ctree.h"
 #include "../transaction.h"
@@ -216,7 +217,8 @@ static int remove_extent_ref(struct btrfs_root *root, u64 bytenr,
         return ret;
 }
 
-static int test_no_shared_qgroup(struct btrfs_root *root)
+static int test_no_shared_qgroup(struct btrfs_root *root,
+                u32 sectorsize, u32 nodesize)
 {
         struct btrfs_trans_handle trans;
         struct btrfs_fs_info *fs_info = root->fs_info;
@@ -227,7 +229,7 @@ static int test_no_shared_qgroup(struct btrfs_root *root)
         btrfs_init_dummy_trans(&trans);
 
         test_msg("Qgroup basic add\n");
-        ret = btrfs_create_qgroup(NULL, fs_info, 5);
+        ret = btrfs_create_qgroup(NULL, fs_info, BTRFS_FS_TREE_OBJECTID);
         if (ret) {
                 test_msg("Couldn't create a qgroup %d\n", ret);
                 return ret;
@@ -238,18 +240,19 @@ static int test_no_shared_qgroup(struct btrfs_root *root)
          * we can only call btrfs_qgroup_account_extent() directly to test
          * quota.
          */
-        ret = btrfs_find_all_roots(&trans, fs_info, 4096, 0, &old_roots);
+        ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &old_roots);
         if (ret) {
                 ulist_free(old_roots);
                 test_msg("Couldn't find old roots: %d\n", ret);
                 return ret;
         }
 
-        ret = insert_normal_tree_ref(root, 4096, 4096, 0, 5);
+        ret = insert_normal_tree_ref(root, nodesize, nodesize, 0,
+                                BTRFS_FS_TREE_OBJECTID);
         if (ret)
                 return ret;
 
-        ret = btrfs_find_all_roots(&trans, fs_info, 4096, 0, &new_roots);
+        ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &new_roots);
         if (ret) {
                 ulist_free(old_roots);
                 ulist_free(new_roots);
@@ -257,32 +260,33 @@ static int test_no_shared_qgroup(struct btrfs_root *root)
                 return ret;
         }
 
-        ret = btrfs_qgroup_account_extent(&trans, fs_info, 4096, 4096,
-                                          old_roots, new_roots);
+        ret = btrfs_qgroup_account_extent(&trans, fs_info, nodesize,
+                                          nodesize, old_roots, new_roots);
         if (ret) {
                 test_msg("Couldn't account space for a qgroup %d\n", ret);
                 return ret;
         }
 
-        if (btrfs_verify_qgroup_counts(fs_info, 5, 4096, 4096)) {
+        if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FS_TREE_OBJECTID,
+                                nodesize, nodesize)) {
                 test_msg("Qgroup counts didn't match expected values\n");
                 return -EINVAL;
         }
         old_roots = NULL;
         new_roots = NULL;
 
-        ret = btrfs_find_all_roots(&trans, fs_info, 4096, 0, &old_roots);
+        ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &old_roots);
         if (ret) {
                 ulist_free(old_roots);
                 test_msg("Couldn't find old roots: %d\n", ret);
                 return ret;
         }
 
-        ret = remove_extent_item(root, 4096, 4096);
+        ret = remove_extent_item(root, nodesize, nodesize);
         if (ret)
                 return -EINVAL;
 
-        ret = btrfs_find_all_roots(&trans, fs_info, 4096, 0, &new_roots);
+        ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &new_roots);
         if (ret) {
                 ulist_free(old_roots);
                 ulist_free(new_roots);
@@ -290,14 +294,14 @@ static int test_no_shared_qgroup(struct btrfs_root *root)
                 return ret;
         }
 
-        ret = btrfs_qgroup_account_extent(&trans, fs_info, 4096, 4096,
-                                          old_roots, new_roots);
+        ret = btrfs_qgroup_account_extent(&trans, fs_info, nodesize,
+                                          nodesize, old_roots, new_roots);
         if (ret) {
                 test_msg("Couldn't account space for a qgroup %d\n", ret);
                 return -EINVAL;
         }
 
-        if (btrfs_verify_qgroup_counts(fs_info, 5, 0, 0)) {
+        if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FS_TREE_OBJECTID, 0, 0)) {
                 test_msg("Qgroup counts didn't match expected values\n");
                 return -EINVAL;
         }
@@ -310,7 +314,8 @@ static int test_no_shared_qgroup(struct btrfs_root *root)
  * right, also remove one of the roots and make sure the exclusive count is
  * adjusted properly.
  */
-static int test_multiple_refs(struct btrfs_root *root)
+static int test_multiple_refs(struct btrfs_root *root,
+                u32 sectorsize, u32 nodesize)
 {
         struct btrfs_trans_handle trans;
         struct btrfs_fs_info *fs_info = root->fs_info;
@@ -322,25 +327,29 @@ static int test_multiple_refs(struct btrfs_root *root)
 
         test_msg("Qgroup multiple refs test\n");
 
-        /* We have 5 created already from the previous test */
-        ret = btrfs_create_qgroup(NULL, fs_info, 256);
+        /*
+         * We have BTRFS_FS_TREE_OBJECTID created already from the
+         * previous test.
+         */
+        ret = btrfs_create_qgroup(NULL, fs_info, BTRFS_FIRST_FREE_OBJECTID);
         if (ret) {
                 test_msg("Couldn't create a qgroup %d\n", ret);
                 return ret;
         }
 
-        ret = btrfs_find_all_roots(&trans, fs_info, 4096, 0, &old_roots);
+        ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &old_roots);
         if (ret) {
                 ulist_free(old_roots);
                 test_msg("Couldn't find old roots: %d\n", ret);
                 return ret;
         }
 
-        ret = insert_normal_tree_ref(root, 4096, 4096, 0, 5);
+        ret = insert_normal_tree_ref(root, nodesize, nodesize, 0,
+                                BTRFS_FS_TREE_OBJECTID);
         if (ret)
                 return ret;
 
-        ret = btrfs_find_all_roots(&trans, fs_info, 4096, 0, &new_roots);
+        ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &new_roots);
         if (ret) {
                 ulist_free(old_roots);
                 ulist_free(new_roots);
@@ -348,30 +357,32 @@ static int test_multiple_refs(struct btrfs_root *root)
                 return ret;
         }
 
-        ret = btrfs_qgroup_account_extent(&trans, fs_info, 4096, 4096,
-                                          old_roots, new_roots);
+        ret = btrfs_qgroup_account_extent(&trans, fs_info, nodesize,
+                                          nodesize, old_roots, new_roots);
         if (ret) {
                 test_msg("Couldn't account space for a qgroup %d\n", ret);
                 return ret;
         }
 
-        if (btrfs_verify_qgroup_counts(fs_info, 5, 4096, 4096)) {
+        if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FS_TREE_OBJECTID,
+                                       nodesize, nodesize)) {
                 test_msg("Qgroup counts didn't match expected values\n");
                 return -EINVAL;
         }
 
-        ret = btrfs_find_all_roots(&trans, fs_info, 4096, 0, &old_roots);
+        ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &old_roots);
         if (ret) {
                 ulist_free(old_roots);
                 test_msg("Couldn't find old roots: %d\n", ret);
                 return ret;
         }
 
-        ret = add_tree_ref(root, 4096, 4096, 0, 256);
+        ret = add_tree_ref(root, nodesize, nodesize, 0,
+                        BTRFS_FIRST_FREE_OBJECTID);
         if (ret)
                 return ret;
 
-        ret = btrfs_find_all_roots(&trans, fs_info, 4096, 0, &new_roots);
+        ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &new_roots);
         if (ret) {
                 ulist_free(old_roots);
                 ulist_free(new_roots);
@@ -379,35 +390,38 @@ static int test_multiple_refs(struct btrfs_root *root)
                 return ret;
         }
 
-        ret = btrfs_qgroup_account_extent(&trans, fs_info, 4096, 4096,
-                                          old_roots, new_roots);
+        ret = btrfs_qgroup_account_extent(&trans, fs_info, nodesize,
+                                          nodesize, old_roots, new_roots);
         if (ret) {
                 test_msg("Couldn't account space for a qgroup %d\n", ret);
                 return ret;
         }
 
-        if (btrfs_verify_qgroup_counts(fs_info, 5, 4096, 0)) {
+        if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FS_TREE_OBJECTID,
+                                        nodesize, 0)) {
                 test_msg("Qgroup counts didn't match expected values\n");
                 return -EINVAL;
         }
 
-        if (btrfs_verify_qgroup_counts(fs_info, 256, 4096, 0)) {
+        if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FIRST_FREE_OBJECTID,
+                                        nodesize, 0)) {
                 test_msg("Qgroup counts didn't match expected values\n");
                 return -EINVAL;
         }
 
-        ret = btrfs_find_all_roots(&trans, fs_info, 4096, 0, &old_roots);
+        ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &old_roots);
         if (ret) {
                 ulist_free(old_roots);
                 test_msg("Couldn't find old roots: %d\n", ret);
                 return ret;
         }
 
-        ret = remove_extent_ref(root, 4096, 4096, 0, 256);
+        ret = remove_extent_ref(root, nodesize, nodesize, 0,
+                                BTRFS_FIRST_FREE_OBJECTID);
         if (ret)
                 return ret;
 
-        ret = btrfs_find_all_roots(&trans, fs_info, 4096, 0, &new_roots);
+        ret = btrfs_find_all_roots(&trans, fs_info, nodesize, 0, &new_roots);
         if (ret) {
                 ulist_free(old_roots);
                 ulist_free(new_roots);
@@ -415,19 +429,21 @@ static int test_multiple_refs(struct btrfs_root *root)
                 return ret;
         }
 
-        ret = btrfs_qgroup_account_extent(&trans, fs_info, 4096, 4096,
-                                          old_roots, new_roots);
+        ret = btrfs_qgroup_account_extent(&trans, fs_info, nodesize,
+                                          nodesize, old_roots, new_roots);
         if (ret) {
                 test_msg("Couldn't account space for a qgroup %d\n", ret);
                 return ret;
         }
 
-        if (btrfs_verify_qgroup_counts(fs_info, 256, 0, 0)) {
+        if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FIRST_FREE_OBJECTID,
+                                        0, 0)) {
                 test_msg("Qgroup counts didn't match expected values\n");
                 return -EINVAL;
         }
 
-        if (btrfs_verify_qgroup_counts(fs_info, 5, 4096, 4096)) {
+        if (btrfs_verify_qgroup_counts(fs_info, BTRFS_FS_TREE_OBJECTID,
+                                        nodesize, nodesize)) {
                 test_msg("Qgroup counts didn't match expected values\n");
                 return -EINVAL;
         }
@@ -435,13 +451,13 @@ static int test_multiple_refs(struct btrfs_root *root)
         return 0;
 }
 
-int btrfs_test_qgroups(void)
+int btrfs_test_qgroups(u32 sectorsize, u32 nodesize)
 {
         struct btrfs_root *root;
         struct btrfs_root *tmp_root;
         int ret = 0;
 
-        root = btrfs_alloc_dummy_root();
+        root = btrfs_alloc_dummy_root(sectorsize, nodesize);
         if (IS_ERR(root)) {
                 test_msg("Couldn't allocate root\n");
                 return PTR_ERR(root);
@@ -468,7 +484,8 @@ int btrfs_test_qgroups(void)
          * Can't use bytenr 0, some things freak out
          * *cough*backref walking code*cough*
          */
-        root->node = alloc_test_extent_buffer(root->fs_info, 4096);
+        root->node = alloc_test_extent_buffer(root->fs_info, nodesize,
+                                        nodesize);
         if (!root->node) {
                 test_msg("Couldn't allocate dummy buffer\n");
                 ret = -ENOMEM;
@@ -476,16 +493,16 @@ int btrfs_test_qgroups(void)
         }
         btrfs_set_header_level(root->node, 0);
         btrfs_set_header_nritems(root->node, 0);
-        root->alloc_bytenr += 8192;
+        root->alloc_bytenr += 2 * nodesize;
 
-        tmp_root = btrfs_alloc_dummy_root();
+        tmp_root = btrfs_alloc_dummy_root(sectorsize, nodesize);
         if (IS_ERR(tmp_root)) {
                 test_msg("Couldn't allocate a fs root\n");
                 ret = PTR_ERR(tmp_root);
                 goto out;
         }
 
-        tmp_root->root_key.objectid = 5;
+        tmp_root->root_key.objectid = BTRFS_FS_TREE_OBJECTID;
         root->fs_info->fs_root = tmp_root;
         ret = btrfs_insert_fs_root(root->fs_info, tmp_root);
         if (ret) {
@@ -493,14 +510,14 @@ int btrfs_test_qgroups(void)
                 goto out;
         }
 
-        tmp_root = btrfs_alloc_dummy_root();
+        tmp_root = btrfs_alloc_dummy_root(sectorsize, nodesize);
         if (IS_ERR(tmp_root)) {
                 test_msg("Couldn't allocate a fs root\n");
                 ret = PTR_ERR(tmp_root);
                 goto out;
         }
 
-        tmp_root->root_key.objectid = 256;
+        tmp_root->root_key.objectid = BTRFS_FIRST_FREE_OBJECTID;
         ret = btrfs_insert_fs_root(root->fs_info, tmp_root);
         if (ret) {
                 test_msg("Couldn't insert fs root %d\n", ret);
@@ -508,10 +525,10 @@ int btrfs_test_qgroups(void)
         }
 
         test_msg("Running qgroup tests\n");
-        ret = test_no_shared_qgroup(root);
+        ret = test_no_shared_qgroup(root, sectorsize, nodesize);
         if (ret)
                 goto out;
-        ret = test_multiple_refs(root);
+        ret = test_multiple_refs(root, sectorsize, nodesize);
 out:
         btrfs_free_dummy_root(root);
         return ret;