LU-19852 lod: raidset aware stripe allocator

    3576: 			GOTO(out, rc = -ENOMEM);
    3577: 
    3578: repeat:
    3579: 		lod_getref(&d->lod_ost_descs);
    3580: 		/* XXX: support for non-0 files w/o objects */
>>> 3581: 		CDEBUG(D_OTHER, "tgt_count %d stripe_count %d\n",
    3582: 		       d->lod_ost_count, stripe_len);
    3583: 
    3584: 		if (lod_comp->llc_ostlist.op_array &&
    3585: 		    lod_comp->llc_ostlist.op_count) {
    3586: 			rc = lod_alloc_ost_list(env, lo, stripe, ost_indices,

    3166: 
    3167: /*
    3168:  * Arbitrary limit on the minimum size we will attempt to split up into
    3169:  * smaller chunks for ec computation.
    3170:  */
>>> 3171: #define EC_MIN_SPLIT_SIZE 4
    3172: /*
    3173:  * We have data consisting of 'total' stripes. Create a mapping where
    3174:  * we split this into smaller chunks based on what the
    3175:  * suggested / requested hint is.
    3176:  * Try to keep the sizes of the different buckets as equal as possible

    2196: 			CDEBUG(D_OTHER,
    2197: 			       "stripe_count=%d nfound=%d cur_weight=%llu rand=%llu total_weight=%llu\n",
    2198: 			       stripe_count, nfound, cur_weight, rand,
    2199: 			       total_weight);
    2200: 
>>> 2201: 			/* TODO: this check is wrong and can cause the qos
    2202: 			 * allocator to fail.the problem is that we do not
    2203: 			 * compute total_weight and cur_weight the same way
    2204: 			 * when OSTs are offline.
    2205: 			 * Very annoying since if OSTs are offline this will
    2206: 			 * fail, and fallback to rr quite often, making

    3184: 	fi
    3185: 
    3186: 	return 0
    3187: }
    3188: 
>>> 3189: test_27d() {
    3190: 	(( OSTCOUNT >= 6 )) || skip "needs >= 6 OSTs"
    3191: 	enable_ec
    3192: 
    3193: 	local tf=$DIR/$tfile
    3194: 

     404:  * IF we are computing the minimum stripe count for the data component
     405:  * and we are using the qos allocator we can include the cstripe count
     406:  * in the minimum and allow it to fail early if there are not enough
     407:  * OSTs available for both the data component and the ec component.
     408:  * For the RR allocator we do not have the initial loop to count the
>>>  409:  * total number of available OSTs so we can not do this optimization.
     410:  *
     411:  * Return: an acceptable stripe count depending on flag LOD_USES_DEFAULT_STRIPE:
     412:  *	   all stripes or 3/4 of stripes.  The code is written this way to avoid
     413:  *	   returning 0 for stripe_count < 4, like "stripe_count * 3 / 4" would
     414:  */

     425: 			return stripe_count + maybe_cstripe;
     426: 
     427: 		if (lod_comp->llc_pattern & LOV_PATTERN_OVERSTRIPING)
     428: 			return sc->esc_k0 + maybe_cstripe;
     429: 		else
>>>  430: 			return sc->esc_k0 * sc->esc_n0 +
     431: 			  sc->esc_k1 * sc->esc_n1;
     432: 	}
     433: 
     434: 	return (flags & LOD_USES_DEFAULT_STRIPE ?
     435: 		stripe_count - (stripe_count / 4) : stripe_count);

     939: 			sc->esc_n1 = 0;
     940: 		}
     941: 		stripe_count--;
     942: 	}
     943: 
>>>  944: 	if (stripe_count > nfound) {
     945: 		/* Resplit from scratch around the OST count we actually have */
     946: 		stripe_count = nfound;
     947: 		ec_split_stripes(stripe_count, suggested, sc);
     948: 	}
     949: 

    1216: 		if (!(lod_comp->llc_flags & LCME_FL_PARITY) &&
    1217: 		    (ec_raidset_count(sc) > 1) &&
    1218: 		    stripe_idx >= stripe_count_min) {
    1219: 			if (want_overstriping) {
    1220: 				stripe_idx = lod_ec_add_data(env, lo,
>>> 1221: 							     th,
    1222: 							     stripe_idx,
    1223: 							     lod_comp,
    1224: 							     stripe,
    1225: 							     ost_indices);
    1226: 			} else {

    1176: 							 stripe, ost_indices);
    1177: 		/*
    1178: 		 * EC-protected data component is short of unique OSTs.
    1179: 		 * With overstriping (-C) reuse OSTs from earlier raid
    1180: 		 * sets. Without it (-c), shrink the EC geometry by
>>> 1181: 		 * converting esc_k0 raidsets into esc_k1 until the
    1182: 		 * allocated OST count is enough — prefer a smaller
    1183: 		 * layout over failing create when OSTs are offline.
    1184: 		 */
    1185: 		if (!(lod_comp->llc_flags & LCME_FL_PARITY) &&
    1186: 		    (ec_raidset_count(sc) > 1) &&

     663: 	if (ost->ltd_statfs.os_state & OS_STATFS_DEGRADED && speed < 2) {
     664: 		CDEBUG(D_OTHER, "#%d: degraded\n", ost_idx);
     665: 		RETURN(rc);
     666: 	}
     667: 
>>>  668: 	if (lod_comp->llc_cstripe_count &&
     669: 	    (lag->lag_ost_avail <= 0 ||
     670: 	     lod_should_avoid_ost(lo, lag, ost_idx))) {
     671: 		CDEBUG(D_OTHER,
     672: 		       "Skip conflicting OST%d because we want unique OSTs for EC\n",
     673: 		       ost_idx);

    1821:  * i: data stripe index
    1822:  *
    1823:  * This function covnerts a data stripe index into which raid set
    1824:  * it belongs to.
    1825:  */
>>> 1826: static inline int sc_idx_to_raidset(struct ec_split_comp *sc, int i)
    1827: {
    1828: 	int total = (sc->esc_n0 * sc->esc_k0) + (sc->esc_n1 * sc->esc_k1);
    1829: 
    1830: 	if (!total)
    1831: 		return 0;