radix-tree: improve dump output
authorMatthew Wilcox <willy@infradead.org>
Wed, 14 Dec 2016 23:08:43 +0000 (15:08 -0800)
committerLinus Torvalds <torvalds@linux-foundation.org>
Thu, 15 Dec 2016 00:04:10 +0000 (16:04 -0800)
Print the indices of the entries as unsigned (instead of signed)
integers and print the parent node of each entry to help navigate around
larger trees where the layout is not quite so obvious.  Print the
indices covered by a node.  Rearrange the order of fields printed so the
indices and parents line up for each type of entry.

Link: http://lkml.kernel.org/r/1480369871-5271-53-git-send-email-mawilcox@linuxonhyperv.com
Signed-off-by: Matthew Wilcox <willy@infradead.org>
Tested-by: Kirill A. Shutemov <kirill.shutemov@linux.intel.com>
Cc: Konstantin Khlebnikov <koct9i@gmail.com>
Cc: Ross Zwisler <ross.zwisler@linux.intel.com>
Cc: Matthew Wilcox <mawilcox@microsoft.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
lib/radix-tree.c

index 368052ac468a2bc375aadf758b051db944553ff5..dbf4e8c8e100235d74a970143d92d44316f4b818 100644 (file)
@@ -214,15 +214,29 @@ radix_tree_find_next_bit(struct radix_tree_node *node, unsigned int tag,
        return RADIX_TREE_MAP_SIZE;
 }
 
        return RADIX_TREE_MAP_SIZE;
 }
 
+/*
+ * The maximum index which can be stored in a radix tree
+ */
+static inline unsigned long shift_maxindex(unsigned int shift)
+{
+       return (RADIX_TREE_MAP_SIZE << shift) - 1;
+}
+
+static inline unsigned long node_maxindex(struct radix_tree_node *node)
+{
+       return shift_maxindex(node->shift);
+}
+
 #ifndef __KERNEL__
 static void dump_node(struct radix_tree_node *node, unsigned long index)
 {
        unsigned long i;
 
 #ifndef __KERNEL__
 static void dump_node(struct radix_tree_node *node, unsigned long index)
 {
        unsigned long i;
 
-       pr_debug("radix node: %p offset %d tags %lx %lx %lx shift %d count %d exceptional %d parent %p\n",
-               node, node->offset,
+       pr_debug("radix node: %p offset %d indices %lu-%lu parent %p tags %lx %lx %lx shift %d count %d exceptional %d\n",
+               node, node->offset, index, index | node_maxindex(node),
+               node->parent,
                node->tags[0][0], node->tags[1][0], node->tags[2][0],
                node->tags[0][0], node->tags[1][0], node->tags[2][0],
-               node->shift, node->count, node->exceptional, node->parent);
+               node->shift, node->count, node->exceptional);
 
        for (i = 0; i < RADIX_TREE_MAP_SIZE; i++) {
                unsigned long first = index | (i << node->shift);
 
        for (i = 0; i < RADIX_TREE_MAP_SIZE; i++) {
                unsigned long first = index | (i << node->shift);
@@ -230,14 +244,16 @@ static void dump_node(struct radix_tree_node *node, unsigned long index)
                void *entry = node->slots[i];
                if (!entry)
                        continue;
                void *entry = node->slots[i];
                if (!entry)
                        continue;
-               if (is_sibling_entry(node, entry)) {
-                       pr_debug("radix sblng %p offset %ld val %p indices %ld-%ld\n",
-                                       entry, i,
-                                       *(void **)entry_to_node(entry),
-                                       first, last);
+               if (entry == RADIX_TREE_RETRY) {
+                       pr_debug("radix retry offset %ld indices %lu-%lu parent %p\n",
+                                       i, first, last, node);
                } else if (!radix_tree_is_internal_node(entry)) {
                } else if (!radix_tree_is_internal_node(entry)) {
-                       pr_debug("radix entry %p offset %ld indices %ld-%ld\n",
-                                       entry, i, first, last);
+                       pr_debug("radix entry %p offset %ld indices %lu-%lu parent %p\n",
+                                       entry, i, first, last, node);
+               } else if (is_sibling_entry(node, entry)) {
+                       pr_debug("radix sblng %p offset %ld indices %lu-%lu parent %p val %p\n",
+                                       entry, i, first, last, node,
+                                       *(void **)entry_to_node(entry));
                } else {
                        dump_node(entry_to_node(entry), first);
                }
                } else {
                        dump_node(entry_to_node(entry), first);
                }
@@ -455,19 +471,6 @@ int radix_tree_maybe_preload_order(gfp_t gfp_mask, int order)
        return __radix_tree_preload(gfp_mask, nr_nodes);
 }
 
        return __radix_tree_preload(gfp_mask, nr_nodes);
 }
 
-/*
- * The maximum index which can be stored in a radix tree
- */
-static inline unsigned long shift_maxindex(unsigned int shift)
-{
-       return (RADIX_TREE_MAP_SIZE << shift) - 1;
-}
-
-static inline unsigned long node_maxindex(struct radix_tree_node *node)
-{
-       return shift_maxindex(node->shift);
-}
-
 static unsigned radix_tree_load_root(struct radix_tree_root *root,
                struct radix_tree_node **nodep, unsigned long *maxindex)
 {
 static unsigned radix_tree_load_root(struct radix_tree_root *root,
                struct radix_tree_node **nodep, unsigned long *maxindex)
 {