augmented rbtree: add comments for RB_DECLARE_CALLBACKS macro

Patch series "make RB_DECLARE_CALLBACKS more generic", v3.

These changes are intended to make the RB_DECLARE_CALLBACKS macro more
generic (allowing the aubmented subtree information to be a struct instead
of a scalar).

I have verified the compiled lib/interval_tree.o and mm/mmap.o files to
check that they didn't change.  This held as expected for interval_tree.o;
mmap.o did have some changes which could be reverted by marking
__vma_link_rb as noinline.  I did not add such a change to the patchset; I
felt it was reasonable enough to leave the inlining decision up to the
compiler.

This patch (of 3):

Add a short comment summarizing the arguments to RB_DECLARE_CALLBACKS.
The arguments are also now capitalized.  This copies the style of the
INTERVAL_TREE_DEFINE macro.

No functional changes in this commit, only comments and capitalization.

Link: http://lkml.kernel.org/r/20190703040156.56953-2-walken@google.com
Signed-off-by: Michel Lespinasse <walken@google.com>
Acked-by: Davidlohr Bueso <dbueso@suse.de>
Acked-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: David Howells <dhowells@redhat.com>
Cc: Uladzislau Rezki <urezki@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/include/linux/rbtree_augmented.h b/include/linux/rbtree_augmented.h
index 179faab29f52b318e57ac47691f329e19fe288ff..97994160008223030d8581ba014338fd3b6a0e29 100644 (file)
--- a/include/linux/rbtree_augmented.h
+++ b/include/linux/rbtree_augmented.h
@@ -60,39 +60,51 @@ rb_insert_augmented_cached(struct rb_node *node,
        rb_insert_augmented(node, &root->rb_root, augment);
 }
 
-#define RB_DECLARE_CALLBACKS(rbstatic, rbname, rbstruct, rbfield,      \
-                            rbtype, rbaugmented, rbcompute)            \
+/*
+ * Template for declaring augmented rbtree callbacks
+ *
+ * RBSTATIC:    'static' or empty
+ * RBNAME:      name of the rb_augment_callbacks structure
+ * RBSTRUCT:    struct type of the tree nodes
+ * RBFIELD:     name of struct rb_node field within RBSTRUCT
+ * RBTYPE:      type of the RBAUGMENTED field
+ * RBAUGMENTED: name of RBTYPE field within RBSTRUCT holding data for subtree
+ * RBCOMPUTE:   name of function that recomputes the RBAUGMENTED data
+ */
+
+#define RB_DECLARE_CALLBACKS(RBSTATIC, RBNAME, RBSTRUCT, RBFIELD,      \
+                            RBTYPE, RBAUGMENTED, RBCOMPUTE)            \
 static inline void                                                     \
-rbname ## _propagate(struct rb_node *rb, struct rb_node *stop)         \
+RBNAME ## _propagate(struct rb_node *rb, struct rb_node *stop)         \
 {                                                                      \
        while (rb != stop) {                                            \
-               rbstruct *node = rb_entry(rb, rbstruct, rbfield);       \
-               rbtype augmented = rbcompute(node);                     \
-               if (node->rbaugmented == augmented)                     \
+               RBSTRUCT *node = rb_entry(rb, RBSTRUCT, RBFIELD);       \
+               RBTYPE augmented = RBCOMPUTE(node);                     \
+               if (node->RBAUGMENTED == augmented)                     \
                        break;                                          \
-               node->rbaugmented = augmented;                          \
-               rb = rb_parent(&node->rbfield);                         \
+               node->RBAUGMENTED = augmented;                          \
+               rb = rb_parent(&node->RBFIELD);                         \
        }                                                               \
 }                                                                      \
 static inline void                                                     \
-rbname ## _copy(struct rb_node *rb_old, struct rb_node *rb_new)                \
+RBNAME ## _copy(struct rb_node *rb_old, struct rb_node *rb_new)                \
 {                                                                      \
-       rbstruct *old = rb_entry(rb_old, rbstruct, rbfield);            \
-       rbstruct *new = rb_entry(rb_new, rbstruct, rbfield);            \
-       new->rbaugmented = old->rbaugmented;                            \
+       RBSTRUCT *old = rb_entry(rb_old, RBSTRUCT, RBFIELD);            \
+       RBSTRUCT *new = rb_entry(rb_new, RBSTRUCT, RBFIELD);            \
+       new->RBAUGMENTED = old->RBAUGMENTED;                            \
 }                                                                      \
 static void                                                            \
-rbname ## _rotate(struct rb_node *rb_old, struct rb_node *rb_new)      \
+RBNAME ## _rotate(struct rb_node *rb_old, struct rb_node *rb_new)      \
 {                                                                      \
-       rbstruct *old = rb_entry(rb_old, rbstruct, rbfield);            \
-       rbstruct *new = rb_entry(rb_new, rbstruct, rbfield);            \
-       new->rbaugmented = old->rbaugmented;                            \
-       old->rbaugmented = rbcompute(old);                              \
+       RBSTRUCT *old = rb_entry(rb_old, RBSTRUCT, RBFIELD);            \
+       RBSTRUCT *new = rb_entry(rb_new, RBSTRUCT, RBFIELD);            \
+       new->RBAUGMENTED = old->RBAUGMENTED;                            \
+       old->RBAUGMENTED = RBCOMPUTE(old);                              \
 }                                                                      \
-rbstatic const struct rb_augment_callbacks rbname = {                  \
-       .propagate = rbname ## _propagate,                              \
-       .copy = rbname ## _copy,                                        \
-       .rotate = rbname ## _rotate                                     \
+RBSTATIC const struct rb_augment_callbacks RBNAME = {                  \
+       .propagate = RBNAME ## _propagate,                              \
+       .copy = RBNAME ## _copy,                                        \
+       .rotate = RBNAME ## _rotate                                     \
 };
 
 

diff --git a/tools/include/linux/rbtree_augmented.h b/tools/include/linux/rbtree_augmented.h
index 467a3eefe1d2e080e181c725a4ea26e6b2c164f6..de3a480204ba075946b5b0f7ec602a28e80b47d7 100644 (file)
--- a/tools/include/linux/rbtree_augmented.h
+++ b/tools/include/linux/rbtree_augmented.h
@@ -62,39 +62,51 @@ rb_insert_augmented_cached(struct rb_node *node,
        rb_insert_augmented(node, &root->rb_root, augment);
 }
 
-#define RB_DECLARE_CALLBACKS(rbstatic, rbname, rbstruct, rbfield,      \
-                            rbtype, rbaugmented, rbcompute)            \
+/*
+ * Template for declaring augmented rbtree callbacks
+ *
+ * RBSTATIC:    'static' or empty
+ * RBNAME:      name of the rb_augment_callbacks structure
+ * RBSTRUCT:    struct type of the tree nodes
+ * RBFIELD:     name of struct rb_node field within RBSTRUCT
+ * RBTYPE:      type of the RBAUGMENTED field
+ * RBAUGMENTED: name of RBTYPE field within RBSTRUCT holding data for subtree
+ * RBCOMPUTE:   name of function that recomputes the RBAUGMENTED data
+ */
+
+#define RB_DECLARE_CALLBACKS(RBSTATIC, RBNAME, RBSTRUCT, RBFIELD,      \
+                            RBTYPE, RBAUGMENTED, RBCOMPUTE)            \
 static inline void                                                     \
-rbname ## _propagate(struct rb_node *rb, struct rb_node *stop)         \
+RBNAME ## _propagate(struct rb_node *rb, struct rb_node *stop)         \
 {                                                                      \
        while (rb != stop) {                                            \
-               rbstruct *node = rb_entry(rb, rbstruct, rbfield);       \
-               rbtype augmented = rbcompute(node);                     \
-               if (node->rbaugmented == augmented)                     \
+               RBSTRUCT *node = rb_entry(rb, RBSTRUCT, RBFIELD);       \
+               RBTYPE augmented = RBCOMPUTE(node);                     \
+               if (node->RBAUGMENTED == augmented)                     \
                        break;                                          \
-               node->rbaugmented = augmented;                          \
-               rb = rb_parent(&node->rbfield);                         \
+               node->RBAUGMENTED = augmented;                          \
+               rb = rb_parent(&node->RBFIELD);                         \
        }                                                               \
 }                                                                      \
 static inline void                                                     \
-rbname ## _copy(struct rb_node *rb_old, struct rb_node *rb_new)                \
+RBNAME ## _copy(struct rb_node *rb_old, struct rb_node *rb_new)                \
 {                                                                      \
-       rbstruct *old = rb_entry(rb_old, rbstruct, rbfield);            \
-       rbstruct *new = rb_entry(rb_new, rbstruct, rbfield);            \
-       new->rbaugmented = old->rbaugmented;                            \
+       RBSTRUCT *old = rb_entry(rb_old, RBSTRUCT, RBFIELD);            \
+       RBSTRUCT *new = rb_entry(rb_new, RBSTRUCT, RBFIELD);            \
+       new->RBAUGMENTED = old->RBAUGMENTED;                            \
 }                                                                      \
 static void                                                            \
-rbname ## _rotate(struct rb_node *rb_old, struct rb_node *rb_new)      \
+RBNAME ## _rotate(struct rb_node *rb_old, struct rb_node *rb_new)      \
 {                                                                      \
-       rbstruct *old = rb_entry(rb_old, rbstruct, rbfield);            \
-       rbstruct *new = rb_entry(rb_new, rbstruct, rbfield);            \
-       new->rbaugmented = old->rbaugmented;                            \
-       old->rbaugmented = rbcompute(old);                              \
+       RBSTRUCT *old = rb_entry(rb_old, RBSTRUCT, RBFIELD);            \
+       RBSTRUCT *new = rb_entry(rb_new, RBSTRUCT, RBFIELD);            \
+       new->RBAUGMENTED = old->RBAUGMENTED;                            \
+       old->RBAUGMENTED = RBCOMPUTE(old);                              \
 }                                                                      \
-rbstatic const struct rb_augment_callbacks rbname = {                  \
-       .propagate = rbname ## _propagate,                              \
-       .copy = rbname ## _copy,                                        \
-       .rotate = rbname ## _rotate                                     \
+RBSTATIC const struct rb_augment_callbacks RBNAME = {                  \
+       .propagate = RBNAME ## _propagate,                              \
+       .copy = RBNAME ## _copy,                                        \
+       .rotate = RBNAME ## _rotate                                     \
 };