Merge git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client

Pull ceph updates from Sage Weil:
 "There are some updates and cleanups to the CRUSH placement code, a bug
  fix with incremental maps, several cleanups and fixes from Josh Durgin
  in the RBD block device code, a series of cleanups and bug fixes from
  Alex Elder in the messenger code, and some miscellaneous bounds
  checking and gfp cleanups/fixes."

Fix up trivial conflicts in net/ceph/{messenger.c,osdmap.c} due to the
networking people preferring "unsigned int" over just "unsigned".

* git://git.kernel.org/pub/scm/linux/kernel/git/sage/ceph-client: (45 commits)
  libceph: fix pg_temp updates
  libceph: avoid unregistering osd request when not registered
  ceph: add auth buf in prepare_write_connect()
  ceph: rename prepare_connect_authorizer()
  ceph: return pointer from prepare_connect_authorizer()
  ceph: use info returned by get_authorizer
  ceph: have get_authorizer methods return pointers
  ceph: ensure auth ops are defined before use
  ceph: messenger: reduce args to create_authorizer
  ceph: define ceph_auth_handshake type
  ceph: messenger: check return from get_authorizer
  ceph: messenger: rework prepare_connect_authorizer()
  ceph: messenger: check prepare_write_connect() result
  ceph: don't set WRITE_PENDING too early
  ceph: drop msgr argument from prepare_write_connect()
  ceph: messenger: send banner in process_connect()
  ceph: messenger: reset connection kvec caller
  libceph: don't reset kvec in prepare_write_banner()
  ceph: ignore preferred_osd field
  ceph: fully initialize new layout
  ...

1 files changed, 48 insertions, 76 deletions

diff --git a/net/ceph/crush/mapper.c b/net/ceph/crush/mapper.c
index 363f8f7e6c3..d7edc24333b 100644
--- a/net/ceph/crush/mapper.c
+++ b/net/ceph/crush/mapper.c
@@ -33,9 +33,9 @@
  * @type: storage ruleset type (user defined)
  * @size: output set size
  */
-int crush_find_rule(struct crush_map *map, int ruleset, int type, int size)
+int crush_find_rule(const struct crush_map *map, int ruleset, int type, int size)
 {
-        int i;
+        __u32 i;
 
         for (i = 0; i < map->max_rules; i++) {
                 if (map->rules[i] &&
@@ -73,7 +73,7 @@ static int bucket_perm_choose(struct crush_bucket *bucket,
         unsigned int i, s;
 
         /* start a new permutation if @x has changed */
-        if (bucket->perm_x != x || bucket->perm_n == 0) {
+        if (bucket->perm_x != (__u32)x || bucket->perm_n == 0) {
                 dprintk("bucket %d new x=%d\n", bucket->id, x);
                 bucket->perm_x = x;
 
@@ -153,8 +153,8 @@ static int bucket_list_choose(struct crush_bucket_list *bucket,
                         return bucket->h.items[i];
         }
 
-        BUG_ON(1);
-        return 0;
+        dprintk("bad list sums for bucket %d\n", bucket->h.id);
+        return bucket->h.items[0];
 }
 
 
@@ -220,7 +220,7 @@ static int bucket_tree_choose(struct crush_bucket_tree *bucket,
 static int bucket_straw_choose(struct crush_bucket_straw *bucket,
                                int x, int r)
 {
-        int i;
+        __u32 i;
         int high = 0;
         __u64 high_draw = 0;
         __u64 draw;
@@ -240,6 +240,7 @@ static int bucket_straw_choose(struct crush_bucket_straw *bucket,
 static int crush_bucket_choose(struct crush_bucket *in, int x, int r)
 {
         dprintk(" crush_bucket_choose %d x=%d r=%d\n", in->id, x, r);
+        BUG_ON(in->size == 0);
         switch (in->alg) {
         case CRUSH_BUCKET_UNIFORM:
                 return bucket_uniform_choose((struct crush_bucket_uniform *)in,
@@ -254,7 +255,7 @@ static int crush_bucket_choose(struct crush_bucket *in, int x, int r)
                 return bucket_straw_choose((struct crush_bucket_straw *)in,
                                            x, r);
         default:
-                BUG_ON(1);
+                dprintk("unknown bucket %d alg %d\n", in->id, in->alg);
                 return in->items[0];
         }
 }
@@ -263,7 +264,7 @@ static int crush_bucket_choose(struct crush_bucket *in, int x, int r)
  * true if device is marked "out" (failed, fully offloaded)
  * of the cluster
  */
-static int is_out(struct crush_map *map, __u32 *weight, int item, int x)
+static int is_out(const struct crush_map *map, const __u32 *weight, int item, int x)
 {
         if (weight[item] >= 0x10000)
                 return 0;
@@ -288,16 +289,16 @@ static int is_out(struct crush_map *map, __u32 *weight, int item, int x)
  * @recurse_to_leaf: true if we want one device under each item of given type
  * @out2: second output vector for leaf items (if @recurse_to_leaf)
  */
-static int crush_choose(struct crush_map *map,
+static int crush_choose(const struct crush_map *map,
                         struct crush_bucket *bucket,
-                        __u32 *weight,
+                        const __u32 *weight,
                         int x, int numrep, int type,
                         int *out, int outpos,
                         int firstn, int recurse_to_leaf,
                         int *out2)
 {
         int rep;
-        int ftotal, flocal;
+        unsigned int ftotal, flocal;
         int retry_descent, retry_bucket, skip_rep;
         struct crush_bucket *in = bucket;
         int r;
@@ -305,7 +306,7 @@ static int crush_choose(struct crush_map *map,
         int item = 0;
         int itemtype;
         int collide, reject;
-        const int orig_tries = 5; /* attempts before we fall back to search */
+        const unsigned int orig_tries = 5; /* attempts before we fall back to search */
 
         dprintk("CHOOSE%s bucket %d x %d outpos %d numrep %d\n", recurse_to_leaf ? "_LEAF" : "",
                 bucket->id, x, outpos, numrep);
@@ -326,7 +327,7 @@ static int crush_choose(struct crush_map *map,
                                 r = rep;
                                 if (in->alg == CRUSH_BUCKET_UNIFORM) {
                                         /* be careful */
-                                        if (firstn || numrep >= in->size)
+                                        if (firstn || (__u32)numrep >= in->size)
                                                 /* r' = r + f_total */
                                                 r += ftotal;
                                         else if (in->size % numrep == 0)
@@ -355,7 +356,11 @@ static int crush_choose(struct crush_map *map,
                                         item = bucket_perm_choose(in, x, r);
                                 else
                                         item = crush_bucket_choose(in, x, r);
-                                BUG_ON(item >= map->max_devices);
+                                if (item >= map->max_devices) {
+                                        dprintk("   bad item %d\n", item);
+                                        skip_rep = 1;
+                                        break;
+                                }
 
                                 /* desired type? */
                                 if (item < 0)
@@ -366,8 +371,12 @@ static int crush_choose(struct crush_map *map,
 
                                 /* keep going? */
                                 if (itemtype != type) {
-                                        BUG_ON(item >= 0 ||
-                                               (-1-item) >= map->max_buckets);
+                                        if (item >= 0 ||
+                                            (-1-item) >= map->max_buckets) {
+                                                dprintk("   bad item type %d\n", type);
+                                                skip_rep = 1;
+                                                break;
+                                        }
                                         in = map->buckets[-1-item];
                                         retry_bucket = 1;
                                         continue;
@@ -416,7 +425,7 @@ reject:
                                         if (collide && flocal < 3)
                                                 /* retry locally a few times */
                                                 retry_bucket = 1;
-                                        else if (flocal < in->size + orig_tries)
+                                        else if (flocal <= in->size + orig_tries)
                                                 /* exhaustive bucket search */
                                                 retry_bucket = 1;
                                         else if (ftotal < 20)
@@ -426,7 +435,7 @@ reject:
                                                 /* else give up */
                                                 skip_rep = 1;
                                         dprintk("  reject %d  collide %d  "
-                                                "ftotal %d  flocal %d\n",
+                                                "ftotal %u  flocal %u\n",
                                                 reject, collide, ftotal,
                                                 flocal);
                                 }
@@ -455,15 +464,12 @@ reject:
  * @x: hash input
  * @result: pointer to result vector
  * @result_max: maximum result size
- * @force: force initial replica choice; -1 for none
  */
-int crush_do_rule(struct crush_map *map,
+int crush_do_rule(const struct crush_map *map,
                   int ruleno, int x, int *result, int result_max,
-                  int force, __u32 *weight)
+                  const __u32 *weight)
 {
         int result_len;
-        int force_context[CRUSH_MAX_DEPTH];
-        int force_pos = -1;
         int a[CRUSH_MAX_SET];
         int b[CRUSH_MAX_SET];
         int c[CRUSH_MAX_SET];
@@ -474,66 +480,44 @@ int crush_do_rule(struct crush_map *map,
         int osize;
         int *tmp;
         struct crush_rule *rule;
-        int step;
+        __u32 step;
         int i, j;
         int numrep;
         int firstn;
 
-        BUG_ON(ruleno >= map->max_rules);
+        if ((__u32)ruleno >= map->max_rules) {
+                dprintk(" bad ruleno %d\n", ruleno);
+                return 0;
+        }
 
         rule = map->rules[ruleno];
         result_len = 0;
         w = a;
         o = b;
 
-        /*
-         * determine hierarchical context of force, if any.  note
-         * that this may or may not correspond to the specific types
-         * referenced by the crush rule.
-         */
-        if (force >= 0 &&
-            force < map->max_devices &&
-            map->device_parents[force] != 0 &&
-            !is_out(map, weight, force, x)) {
-                while (1) {
-                        force_context[++force_pos] = force;
-                        if (force >= 0)
-                                force = map->device_parents[force];
-                        else
-                                force = map->bucket_parents[-1-force];
-                        if (force == 0)
-                                break;
-                }
-        }
-
         for (step = 0; step < rule->len; step++) {
+                struct crush_rule_step *curstep = &rule->steps[step];
+
                 firstn = 0;
-                switch (rule->steps[step].op) {
+                switch (curstep->op) {
                 case CRUSH_RULE_TAKE:
-                        w[0] = rule->steps[step].arg1;
-
-                        /* find position in force_context/hierarchy */
-                        while (force_pos >= 0 &&
-                               force_context[force_pos] != w[0])
-                                force_pos--;
-                        /* and move past it */
-                        if (force_pos >= 0)
-                                force_pos--;
-
+                        w[0] = curstep->arg1;
                         wsize = 1;
                         break;
 
                 case CRUSH_RULE_CHOOSE_LEAF_FIRSTN:
                 case CRUSH_RULE_CHOOSE_FIRSTN:
                         firstn = 1;
+                        /* fall through */
                 case CRUSH_RULE_CHOOSE_LEAF_INDEP:
                 case CRUSH_RULE_CHOOSE_INDEP:
-                        BUG_ON(wsize == 0);
+                        if (wsize == 0)
+                                break;
 
                         recurse_to_leaf =
-                                rule->steps[step].op ==
+                                curstep->op ==
                                  CRUSH_RULE_CHOOSE_LEAF_FIRSTN ||
-                                rule->steps[step].op ==
+                                curstep->op ==
                                 CRUSH_RULE_CHOOSE_LEAF_INDEP;
 
                         /* reset output */
@@ -545,32 +529,18 @@ int crush_do_rule(struct crush_map *map,
                                  * basically, numrep <= 0 means relative to
                                  * the provided result_max
                                  */
-                                numrep = rule->steps[step].arg1;
+                                numrep = curstep->arg1;
                                 if (numrep <= 0) {
                                         numrep += result_max;
                                         if (numrep <= 0)
                                                 continue;
                                 }
                                 j = 0;
-                                if (osize == 0 && force_pos >= 0) {
-                                        /* skip any intermediate types */
-                                        while (force_pos &&
-                                               force_context[force_pos] < 0 &&
-                                               rule->steps[step].arg2 !=
-                                               map->buckets[-1 -
-                                               force_context[force_pos]]->type)
-                                                force_pos--;
-                                        o[osize] = force_context[force_pos];
-                                        if (recurse_to_leaf)
-                                                c[osize] = force_context[0];
-                                        j++;
-                                        force_pos--;
-                                }
                                 osize += crush_choose(map,
                                                       map->buckets[-1-w[i]],
                                                       weight,
                                                       x, numrep,
-                                                      rule->steps[step].arg2,
+                                                      curstep->arg2,
                                                       o+osize, j,
                                                       firstn,
                                                       recurse_to_leaf, c+osize);
@@ -597,7 +567,9 @@ int crush_do_rule(struct crush_map *map,
                         break;
 
                 default:
-                        BUG_ON(1);
+                        dprintk(" unknown op %d at step %d\n",
+                                curstep->op, step);
+                        break;
                 }
         }
         return result_len;