verity: create a regular trie when depth=0

dm-bht.c

  /*
  * Copyright (C) 2010 The Chromium OS Authors <chromium-os-dev@chromium.org>
  *
  * Device-Mapper block hash tree interface.
  * See Documentation/device-mapper/dm-bht.txt for details.
  *
  * This file is released under the GPL.
  */
 
 #include <asm/atomic.h>
@@ skipping 247 matching lines @@
 
         /* Configure the tree */
         bht->block_count = block_count;
         DMDEBUG("Setting block_count %u", block_count);
         if (block_count == 0) {
                 DMERR("block_count must be non-zero");
                 status = -EINVAL;
                 goto bad_block_count;
         }
 
-        bht->depth = depth;  /* assignment below */
-        DMDEBUG("Setting depth %u", depth);
-        if (!depth || depth > UINT_MAX / sizeof(struct dm_bht_level)) {
-                DMERR("bht depth is invalid: %u", depth);
-                status = -EINVAL;
-                goto bad_depth;
-        }
-
-        /* Allocate levels. Each level of the tree may have an arbitrary number
-         * of dm_bht_entry structs.  Each entry contains node_count nodes.
-         * Each node in the tree is a cryptographic digest of either node_count
-         * nodes on the subsequent level or of a specific block on disk.
-         */
-        bht->levels = (struct dm_bht_level *)
-                        kcalloc(depth, sizeof(struct dm_bht_level), GFP_KERNEL);
-        if (!bht->levels) {
-                DMERR("failed to allocate tree levels");
-                status = -ENOMEM;
-                goto bad_level_alloc;
-        }
-
         /* Each dm_bht_entry->nodes is one page.  The node code tracks
          * how many nodes fit into one entry where a node is a single
          * hash (message digest).
          */
         bht->node_count_shift = fls(PAGE_SIZE / bht->digest_size) - 1;
         /* Round down to the nearest power of two.  This makes indexing
          * into the tree much less painful.
          */
         bht->node_count = 1 << bht->node_count_shift;
 
         /* This is unlikely to happen, but with 64k pages, who knows. */
         if (bht->node_count > UINT_MAX / bht->digest_size) {
                 DMERR("node_count * hash_len exceeds UINT_MAX!");
                 status = -EINVAL;
                 goto bad_node_count;
         }
+
+        /* if depth == 0, create a "regular" trie with a single root block */
+        if (depth == 0)
+                depth = DIV_ROUND_UP(fls(block_count - 1),
+                                     bht->node_count_shift);
+        if (depth > UINT_MAX / sizeof(struct dm_bht_level)) {
+                DMERR("bht depth is invalid: %u", depth);
+                status = -EINVAL;
+                goto bad_depth;
+        }
+        DMDEBUG("Setting depth to %u.", depth);
+        bht->depth = depth;
+
         /* Ensure that we can safely shift by this value. */
         if (depth * bht->node_count_shift >= sizeof(unsigned int) * 8) {
                 DMERR("specified depth and node_count_shift is too large");
                 status = -EINVAL;
                 goto bad_node_count;
         }
 
+        /* Allocate levels. Each level of the tree may have an arbitrary number
+         * of dm_bht_entry structs.  Each entry contains node_count nodes.
+         * Each node in the tree is a cryptographic digest of either node_count
+         * nodes on the subsequent level or of a specific block on disk.
+         */
+        bht->levels = (struct dm_bht_level *)
+                        kcalloc(depth, sizeof(struct dm_bht_level), GFP_KERNEL);
+        if (!bht->levels) {
+                DMERR("failed to allocate tree levels");
+                status = -ENOMEM;
+                goto bad_level_alloc;
+        }
+
         /* Setup callback stubs */
         bht->read_cb = &dm_bht_read_callback_stub;
         bht->write_cb = &dm_bht_write_callback_stub;
 
         status = dm_bht_initialize_entries(bht);
         if (status)
                 goto bad_entries_alloc;
 
         return 0;
 
 bad_entries_alloc:
         while (bht->depth-- > 0)
                 kfree(bht->levels[bht->depth].entries);
+        kfree(bht->levels);
 bad_node_count:
-        kfree(bht->levels);
 bad_level_alloc:
 bad_block_count:
 bad_depth:
         kfree(bht->root_digest);
 bad_root_digest_alloc:
 bad_digest_len:
         for (cpu = 0; cpu < nr_cpu_ids; ++cpu)
                 if (bht->hash_desc[cpu].tfm)
                         crypto_free_hash(bht->hash_desc[cpu].tfm);
 bad_hash_alg:
@@ skipping 848 matching lines @@
         if (!bht->root_digest) {
                 DMERR("no root digest exists to export");
                 if (available > 0)
                         *hexdigest = 0;
                 return -1;
         }
         dm_bht_bin_to_hex(bht->root_digest, hexdigest, bht->digest_size);
         return 0;
 }
 EXPORT_SYMBOL(dm_bht_root_hexdigest);