void lmv_activate_target(struct lmv_obd *lmv, struct lmv_tgt_desc *tgt,
int activate)
{
- if (tgt->ltd_active == activate)
- return;
+ if (tgt->ltd_active == activate)
+ return;
- tgt->ltd_active = activate;
- lmv->desc.ld_active_tgt_count += (activate ? 1 : -1);
+ tgt->ltd_active = activate;
+ lmv->lmv_mdt_descs.ltd_lmv_desc.ld_active_tgt_count +=
+ (activate ? 1 : -1);
tgt->ltd_exp->exp_obd->obd_inactive = !activate;
}
tgt->ltd_active = 1;
tgt->ltd_exp = mdc_exp;
- lmv->desc.ld_active_tgt_count++;
+ lmv->lmv_mdt_descs.ltd_lmv_desc.ld_active_tgt_count++;
md_init_ea_size(tgt->ltd_exp, lmv->max_easize, lmv->max_def_easize);
- rc = lqos_add_tgt(&lmv->lmv_qos, tgt);
+ rc = lu_qos_add_tgt(&lmv->lmv_qos, tgt);
if (rc) {
obd_disconnect(mdc_exp);
RETURN(rc);
static void lmv_del_target(struct lmv_obd *lmv, struct lu_tgt_desc *tgt)
{
LASSERT(tgt);
- lqos_del_tgt(&lmv->lmv_qos, tgt);
- lu_tgt_descs_del(&lmv->lmv_mdt_descs, tgt);
+ ltd_del_tgt(&lmv->lmv_mdt_descs, tgt);
OBD_FREE_PTR(tgt);
}
struct lmv_obd *lmv = &obd->u.lmv;
struct lmv_tgt_desc *tgt;
struct lu_tgt_descs *ltd = &lmv->lmv_mdt_descs;
- int orig_tgt_count = 0;
int rc = 0;
ENTRY;
tgt->ltd_active = 0;
mutex_lock(<d->ltd_mutex);
- rc = lu_tgt_descs_add(ltd, tgt);
- if (!rc && index >= lmv->desc.ld_tgt_count) {
- orig_tgt_count = lmv->desc.ld_tgt_count;
- lmv->desc.ld_tgt_count = index + 1;
- }
+ rc = ltd_add_tgt(ltd, tgt);
mutex_unlock(<d->ltd_mutex);
if (rc)
RETURN(0);
rc = lmv_connect_mdc(obd, tgt);
- if (rc != 0) {
- mutex_lock(<d->ltd_mutex);
- lmv->desc.ld_tgt_count = orig_tgt_count;
- memset(tgt, 0, sizeof(*tgt));
- mutex_unlock(<d->ltd_mutex);
- } else {
+ if (!rc) {
int easize = sizeof(struct lmv_stripe_md) +
- lmv->desc.ld_tgt_count * sizeof(struct lu_fid);
+ lmv->lmv_mdt_count * sizeof(struct lu_fid);
+
lmv_init_ea_size(obd->obd_self_export, easize, 0);
}
if (lmv->connected)
GOTO(unlock, rc = 0);
- if (lmv->desc.ld_tgt_count == 0) {
+ if (!lmv->lmv_mdt_count) {
CERROR("%s: no targets configured: rc = -EINVAL\n",
obd->obd_name);
GOTO(unlock, rc = -EINVAL);
}
lmv->connected = 1;
- easize = lmv_mds_md_size(lmv->desc.ld_tgt_count, LMV_MAGIC);
+ easize = lmv_mds_md_size(lmv->lmv_mdt_count, LMV_MAGIC);
lmv_init_ea_size(obd->obd_self_export, easize, 0);
EXIT;
unlock:
if (!tgt->ltd_exp)
continue;
- --lmv->desc.ld_active_tgt_count;
+ --lmv->lmv_mdt_descs.ltd_lmv_desc.ld_active_tgt_count;
obd_disconnect(tgt->ltd_exp);
}
struct lmv_obd *lmv = &obddev->u.lmv;
struct lu_tgt_desc *tgt = NULL;
int set = 0;
- __u32 count = lmv->desc.ld_tgt_count;
+ __u32 count = lmv->lmv_mdt_count;
int rc = 0;
ENTRY;
__u32 index;
memcpy(&index, data->ioc_inlbuf2, sizeof(__u32));
- if (index >= count)
+
+ if (index >= lmv->lmv_mdt_descs.ltd_tgts_size)
RETURN(-ENODEV);
tgt = lmv_tgt(lmv, index);
struct obd_quotactl *oqctl;
if (qctl->qc_valid == QC_MDTIDX) {
- if (count <= qctl->qc_idx)
- RETURN(-EINVAL);
-
tgt = lmv_tgt(lmv, qctl->qc_idx);
- if (!tgt || !tgt->ltd_exp)
- RETURN(-EINVAL);
} else if (qctl->qc_valid == QC_UUID) {
lmv_foreach_tgt(lmv, tgt) {
if (!obd_uuid_equals(&tgt->ltd_uuid,
RETURN(-EINVAL);
}
- if (tgt->ltd_index >= count)
- RETURN(-EAGAIN);
+ if (!tgt || !tgt->ltd_exp)
+ RETURN(-EINVAL);
- LASSERT(tgt != NULL && tgt->ltd_exp != NULL);
OBD_ALLOC_PTR(oqctl);
if (!oqctl)
RETURN(-ENOMEM);
ENTRY;
- if (lmv->desc.ld_tgt_count == 1)
+ if (lmv->lmv_mdt_count == 1)
RETURN(0);
lum = op_data->op_data;
RETURN(-EINVAL);
}
- obd_str2uuid(&lmv->desc.ld_uuid, desc->ld_uuid.uuid);
- lmv->desc.ld_tgt_count = 0;
- lmv->desc.ld_active_tgt_count = 0;
- lmv->desc.ld_qos_maxage = LMV_DESC_QOS_MAXAGE_DEFAULT;
+ obd_str2uuid(&lmv->lmv_mdt_descs.ltd_lmv_desc.ld_uuid,
+ desc->ld_uuid.uuid);
+ lmv->lmv_mdt_descs.ltd_lmv_desc.ld_tgt_count = 0;
+ lmv->lmv_mdt_descs.ltd_lmv_desc.ld_active_tgt_count = 0;
+ lmv->lmv_mdt_descs.ltd_lmv_desc.ld_qos_maxage =
+ LMV_DESC_QOS_MAXAGE_DEFAULT;
lmv->max_def_easize = 0;
lmv->max_easize = 0;
spin_lock_init(&lmv->lmv_lock);
- /* Set up allocation policy (QoS and RR) */
- INIT_LIST_HEAD(&lmv->lmv_qos.lq_svr_list);
- init_rwsem(&lmv->lmv_qos.lq_rw_sem);
- lmv->lmv_qos.lq_dirty = 1;
- lmv->lmv_qos.lq_reset = 1;
- /* Default priority is toward free space balance */
- lmv->lmv_qos.lq_prio_free = 232;
- /* Default threshold for rr (roughly 17%) */
- lmv->lmv_qos.lq_threshold_rr = 43;
-
- lu_qos_rr_init(&lmv->lmv_qos.lq_rr);
-
/*
* initialize rr_index to lower 32bit of netid, so that client
* can distribute subdirs evenly from the beginning.
if (rc)
CERROR("Can't init FLD, err %d\n", rc);
- rc = lu_tgt_descs_init(&lmv->lmv_mdt_descs);
+ rc = lu_tgt_descs_init(&lmv->lmv_mdt_descs, true);
if (rc)
CWARN("%s: error initialize target table: rc = %d\n",
obd->obd_name, rc);
if (flags & OBD_STATFS_FOR_MDT0)
return 0;
- if (lmv->lmv_statfs_start || lmv->desc.ld_tgt_count == 1)
+ if (lmv->lmv_statfs_start || lmv->lmv_mdt_count == 1)
return lmv->lmv_statfs_start;
/* choose initial MDT for this client */
/* We dont need a full 64-bit modulus, just enough
* to distribute the requests across MDTs evenly.
*/
- lmv->lmv_statfs_start =
- (u32)lnet_id.nid % lmv->desc.ld_tgt_count;
+ lmv->lmv_statfs_start = (u32)lnet_id.nid %
+ lmv->lmv_mdt_count;
break;
}
}
/* distribute statfs among MDTs */
idx = lmv_select_statfs_mdt(lmv, flags);
- for (i = 0; i < lmv->desc.ld_tgt_count; i++, idx++) {
- idx = idx % lmv->desc.ld_tgt_count;
+ for (i = 0; i < lmv->lmv_mdt_descs.ltd_tgts_size; i++, idx++) {
+ idx = idx % lmv->lmv_mdt_descs.ltd_tgts_size;
tgt = lmv_tgt(lmv, idx);
if (!tgt || !tgt->ltd_exp)
continue;
int rc;
if (ktime_get_seconds() - tgt->ltd_statfs_age <
- obd->u.lmv.desc.ld_qos_maxage)
+ obd->u.lmv.lmv_mdt_descs.ltd_lmv_desc.ld_qos_maxage)
return 0;
rc = obd_statfs_async(tgt->ltd_exp, &oinfo, 0, NULL);
ENTRY;
- if (!lqos_is_usable(&lmv->lmv_qos, lmv->desc.ld_active_tgt_count))
+ if (!ltd_qos_is_usable(&lmv->lmv_mdt_descs))
RETURN(ERR_PTR(-EAGAIN));
down_write(&lmv->lmv_qos.lq_rw_sem);
- if (!lqos_is_usable(&lmv->lmv_qos, lmv->desc.ld_active_tgt_count))
+ if (!ltd_qos_is_usable(&lmv->lmv_mdt_descs))
GOTO(unlock, tgt = ERR_PTR(-EAGAIN));
- rc = lqos_calc_penalties(&lmv->lmv_qos, &lmv->lmv_mdt_descs,
- lmv->desc.ld_active_tgt_count,
- lmv->desc.ld_qos_maxage, true);
+ rc = ltd_qos_penalties_calc(&lmv->lmv_mdt_descs);
if (rc)
GOTO(unlock, tgt = ERR_PTR(rc));
continue;
tgt->ltd_qos.ltq_usable = 1;
- lqos_calc_weight(tgt);
+ lu_tgt_qos_weight_calc(tgt);
total_weight += tgt->ltd_qos.ltq_weight;
}
continue;
*mdt = tgt->ltd_index;
- lqos_recalc_weight(&lmv->lmv_qos, &lmv->lmv_mdt_descs, tgt,
- lmv->desc.ld_active_tgt_count,
- &total_weight);
+ ltd_qos_update(&lmv->lmv_mdt_descs, tgt, &total_weight);
GOTO(unlock, rc = 0);
}
ENTRY;
spin_lock(&lmv->lmv_qos.lq_rr.lqr_alloc);
- for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- index = (i + lmv->lmv_qos_rr_index) % lmv->desc.ld_tgt_count;
+ for (i = 0; i < lmv->lmv_mdt_descs.ltd_tgts_size; i++) {
+ index = (i + lmv->lmv_qos_rr_index) %
+ lmv->lmv_mdt_descs.ltd_tgts_size;
tgt = lmv_tgt(lmv, index);
if (!tgt || !tgt->ltd_exp || !tgt->ltd_active)
continue;
*mdt = tgt->ltd_index;
- lmv->lmv_qos_rr_index = (*mdt + 1) % lmv->desc.ld_tgt_count;
+ lmv->lmv_qos_rr_index = (*mdt + 1) %
+ lmv->lmv_mdt_descs.ltd_tgts_size;
spin_unlock(&lmv->lmv_qos.lq_rr.lqr_alloc);
RETURN(tgt);
ENTRY;
- if (!lmv->desc.ld_active_tgt_count)
+ if (!lmv->lmv_mdt_descs.ltd_lmv_desc.ld_active_tgt_count)
RETURN(-EIO);
if (lmv_dir_bad_hash(op_data->op_mea1))
exp->exp_connect_data = *(struct obd_connect_data *)val;
RETURN(rc);
} else if (KEY_IS(KEY_TGT_COUNT)) {
- *((int *)val) = lmv->desc.ld_tgt_count;
+ *((int *)val) = lmv->lmv_mdt_descs.ltd_tgts_size;
RETURN(0);
}
struct obd_device *obddev = class_exp2obd(exp);
struct ptlrpc_request_set *set = _set;
struct lmv_obd *lmv = &obddev->u.lmv;
- int tgt_count = lmv->desc.ld_tgt_count;
+ int tgt_count = lmv->lmv_mdt_count;
struct lu_tgt_desc *tgt;
struct fid_array *fat, **fas = NULL;
int i, rc, **rcs = NULL;
* since this can be easily found, and only try others if that fails.
*/
for (i = 0, index = lmv_fid2tgt_index(lmv, fid);
- i < lmv->desc.ld_tgt_count;
- i++, index = (index + 1) % lmv->desc.ld_tgt_count) {
+ i < lmv->lmv_mdt_descs.ltd_tgts_size;
+ i++, index = (index + 1) % lmv->lmv_mdt_descs.ltd_tgts_size) {
if (index < 0) {
CDEBUG(D_HA, "%s: "DFID" is inaccessible: rc = %d\n",
obd->obd_name, PFID(fid), index);