Merge tag 'v3.18-rc4' into x86/cleanups, to refresh the tree before pulling new changes.

Signed-off-by: Ingo Molnar <mingo@kernel.org>

1 files changed, 15 insertions, 12 deletions

diff --git a/lib/idr.c b/lib/idr.c
index 39158abebad1..e654aebd5f80 100644
--- a/lib/idr.c
+++ b/lib/idr.c
@@ -590,26 +590,27 @@ static void __idr_remove_all(struct idr *idp)
         struct idr_layer **paa = &pa[0];
 
         n = idp->layers * IDR_BITS;
-        p = idp->top;
+        *paa = idp->top;
         RCU_INIT_POINTER(idp->top, NULL);
         max = idr_max(idp->layers);
 
         id = 0;
         while (id >= 0 && id <= max) {
+                p = *paa;
                 while (n > IDR_BITS && p) {
                         n -= IDR_BITS;
-                        *paa++ = p;
                         p = p->ary[(id >> n) & IDR_MASK];
+                        *++paa = p;
                 }
 
                 bt_mask = id;
                 id += 1 << n;
                 /* Get the highest bit that the above add changed from 0->1. */
                 while (n < fls(id ^ bt_mask)) {
-                        if (p)
-                                free_layer(idp, p);
+                        if (*paa)
+                                free_layer(idp, *paa);
                         n += IDR_BITS;
-                        p = *--paa;
+                        --paa;
                 }
         }
         idp->layers = 0;
@@ -625,7 +626,7 @@ static void __idr_remove_all(struct idr *idp)
  * idr_destroy().
  *
  * A typical clean-up sequence for objects stored in an idr tree will use
- * idr_for_each() to free all objects, if necessay, then idr_destroy() to
+ * idr_for_each() to free all objects, if necessary, then idr_destroy() to
  * free up the id mappings and cached idr_layers.
  */
 void idr_destroy(struct idr *idp)
@@ -692,15 +693,16 @@ int idr_for_each(struct idr *idp,
         struct idr_layer **paa = &pa[0];
 
         n = idp->layers * IDR_BITS;
-        p = rcu_dereference_raw(idp->top);
+        *paa = rcu_dereference_raw(idp->top);
         max = idr_max(idp->layers);
 
         id = 0;
         while (id >= 0 && id <= max) {
+                p = *paa;
                 while (n > 0 && p) {
                         n -= IDR_BITS;
-                        *paa++ = p;
                         p = rcu_dereference_raw(p->ary[(id >> n) & IDR_MASK]);
+                        *++paa = p;
                 }
 
                 if (p) {
@@ -712,7 +714,7 @@ int idr_for_each(struct idr *idp,
                 id += 1 << n;
                 while (n < fls(id)) {
                         n += IDR_BITS;
-                        p = *--paa;
+                        --paa;
                 }
         }
 
@@ -740,17 +742,18 @@ void *idr_get_next(struct idr *idp, int *nextidp)
         int n, max;
 
         /* find first ent */
-        p = rcu_dereference_raw(idp->top);
+        p = *paa = rcu_dereference_raw(idp->top);
         if (!p)
                 return NULL;
         n = (p->layer + 1) * IDR_BITS;
         max = idr_max(p->layer + 1);
 
         while (id >= 0 && id <= max) {
+                p = *paa;
                 while (n > 0 && p) {
                         n -= IDR_BITS;
-                        *paa++ = p;
                         p = rcu_dereference_raw(p->ary[(id >> n) & IDR_MASK]);
+                        *++paa = p;
                 }
 
                 if (p) {
@@ -768,7 +771,7 @@ void *idr_get_next(struct idr *idp, int *nextidp)
                 id = round_up(id + 1, 1 << n);
                 while (n < fls(id)) {
                         n += IDR_BITS;
-                        p = *--paa;
+                        --paa;
                 }
         }
         return NULL;