{
struct obd_statfs *sfs = &tgt->ltd_statfs;
- if (((sfs->os_state & OS_STATE_ENOSPC) ||
- (!ltd->ltd_is_mdt && sfs->os_state & OS_STATE_ENOINO &&
+ if (((sfs->os_state & OS_STATFS_ENOSPC) ||
+ (!ltd->ltd_is_mdt && sfs->os_state & OS_STATFS_ENOINO &&
sfs->os_fprecreated == 0)))
return -ENOSPC;
/* If the OST is readonly then we can't allocate objects there */
- if (sfs->os_state & OS_STATE_READONLY)
+ if (sfs->os_state & OS_STATFS_READONLY)
return -EROFS;
/* object precreation is skipped on the OST with max_create_count=0 */
- if (!ltd->ltd_is_mdt && sfs->os_state & OS_STATE_NOPRECREATE)
+ if (!ltd->ltd_is_mdt && sfs->os_state & OS_STATFS_NOPRECREATE)
return -ENOBUFS;
return 0;
*/
static int lod_statfs_and_check(const struct lu_env *env, struct lod_device *d,
struct lu_tgt_descs *ltd,
- struct lu_tgt_desc *tgt)
+ struct lu_tgt_desc *tgt, __u64 reserve)
{
+ struct obd_statfs_info info = { 0 };
struct lov_desc *desc = <d->ltd_lov_desc;
int rc;
ENTRY;
LASSERT(d);
LASSERT(tgt);
- rc = dt_statfs(env, tgt->ltd_tgt, &tgt->ltd_statfs);
+ info.os_enable_pre = 1;
+ rc = dt_statfs_info(env, tgt->ltd_tgt, &tgt->ltd_statfs, &info);
if (rc && rc != -ENOTCONN)
CERROR("%s: statfs: rc = %d\n", lod2obd(d)->obd_name, rc);
return rc;
}
+ if (reserve &&
+ (reserve + (info.os_reserved_mb_low << 20) >
+ tgt->ltd_statfs.os_bavail * tgt->ltd_statfs.os_bsize))
+ return -ENOSPC;
+
/* check whether device has changed state (active, inactive) */
if (rc != 0 && tgt->ltd_active) {
/* turned inactive? */
ltd_foreach_tgt(ltd, tgt) {
avail = tgt->ltd_statfs.os_bavail;
- if (lod_statfs_and_check(env, lod, ltd, tgt))
+ if (lod_statfs_and_check(env, lod, ltd, tgt, 0))
continue;
if (tgt->ltd_statfs.os_bavail != avail)
for (i = 0; i < lqr->lqr_pool.op_count; i++) {
int next;
- if (!cfs_bitmap_check(ltd->ltd_tgt_bitmap,
- src_pool->op_array[i]))
+ if (!test_bit(src_pool->op_array[i],
+ ltd->ltd_tgt_bitmap))
continue;
tgt = LTD_TGT(ltd, src_pool->op_array[i]);
*/
o = lu_object_anon(env, nd, NULL);
if (IS_ERR(o))
- GOTO(out, dt = ERR_PTR(PTR_ERR(o)));
+ GOTO(out, dt = ERR_CAST(o));
n = lu_object_locate(o->lo_header, nd->ld_type);
if (unlikely(n == NULL)) {
bool used = false;
int i;
- if (!cfs_bitmap_check(lod->lod_ost_bitmap, index)) {
+ if (!test_bit(index, lod->lod_ost_bitmap)) {
QOS_DEBUG("OST%d: been used in conflicting mirror component\n",
index);
return true;
struct dt_object **stripe,
__u32 *ost_indices,
struct thandle *th,
- bool *overstriped)
+ bool *overstriped,
+ __u64 reserve)
{
struct lod_device *lod = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
struct lod_avoid_guide *lag = &lod_env_info(env)->lti_avoid;
ENTRY;
- rc = lod_statfs_and_check(env, lod, &lod->lod_ost_descs, ost);
+ rc = lod_statfs_and_check(env, lod, &lod->lod_ost_descs, ost, reserve);
if (rc)
RETURN(rc);
/*
* try to use another OSP if this one is degraded
*/
- if (ost->ltd_statfs.os_state & OS_STATE_DEGRADED && speed < 2) {
+ if (ost->ltd_statfs.os_state & OS_STATFS_DEGRADED && speed < 2) {
QOS_DEBUG("#%d: degraded\n", ost_idx);
RETURN(rc);
}
*/
static int lod_ost_alloc_rr(const struct lu_env *env, struct lod_object *lo,
struct dt_object **stripe, __u32 *ost_indices,
- int flags, struct thandle *th, int comp_idx)
+ int flags, struct thandle *th, int comp_idx,
+ __u64 reserve)
{
struct lod_layout_component *lod_comp;
struct lod_device *m = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
stripe_idx, array_idx, ost_idx);
if ((ost_idx == LOV_QOS_EMPTY) ||
- !cfs_bitmap_check(m->lod_ost_bitmap, ost_idx))
+ !test_bit(ost_idx, m->lod_ost_bitmap))
continue;
/* Fail Check before osc_precreate() is called
spin_unlock(&lqr->lqr_alloc);
rc = lod_check_and_reserve_ost(env, lo, lod_comp, ost_idx,
speed, &stripe_idx, stripe,
- ost_indices, th, &overstriped);
+ ost_indices, th, &overstriped,
+ reserve);
spin_lock(&lqr->lqr_alloc);
if (rc != 0 && OST_TGT(m, ost_idx)->ltd_connecting)
for (j = 0; j < pool->op_count; j++) {
mdt_idx = pool->op_array[j];
- if (!cfs_bitmap_check(ltd->ltd_tgt_bitmap, mdt_idx))
+ if (!test_bit(mdt_idx, ltd->ltd_tgt_bitmap))
continue;
mdt = LTD_TGT(ltd, mdt_idx);
stripe_idx, pool_idx, mdt_idx);
if (mdt_idx == LOV_QOS_EMPTY ||
- !cfs_bitmap_check(ltd->ltd_tgt_bitmap, mdt_idx))
+ !test_bit(mdt_idx, ltd->ltd_tgt_bitmap))
continue;
/* do not put >1 objects on one MDT */
}
/* try to use another OSP if this one is degraded */
- if (mdt->ltd_statfs.os_state & OS_STATE_DEGRADED &&
+ if (mdt->ltd_statfs.os_state & OS_STATFS_DEGRADED &&
!use_degraded) {
QOS_DEBUG("#%d: degraded\n", mdt_idx);
continue;
}
spin_unlock(&lqr->lqr_alloc);
- rc = obd_fid_alloc(env, mdt->ltd_exp, &fid, NULL);
+ rc = dt_fid_alloc(env, mdt->ltd_tgt, &fid, NULL, NULL);
if (rc < 0) {
QOS_DEBUG("#%d: alloc FID failed: %dl\n", mdt_idx, rc);
spin_lock(&lqr->lqr_alloc);
*/
static int lod_alloc_ost_list(const struct lu_env *env, struct lod_object *lo,
struct dt_object **stripe, __u32 *ost_indices,
- struct thandle *th, int comp_idx)
+ struct thandle *th, int comp_idx, __u64 reserve)
{
struct lod_layout_component *lod_comp;
struct lod_device *m = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
i++, array_idx = (array_idx + 1) % lod_comp->llc_stripe_count) {
__u32 ost_idx = lod_comp->llc_ostlist.op_array[array_idx];
- if (!cfs_bitmap_check(m->lod_ost_bitmap, ost_idx)) {
+ if (!test_bit(ost_idx, m->lod_ost_bitmap)) {
rc = -ENODEV;
break;
}
}
rc = lod_statfs_and_check(env, m, &m->lod_ost_descs,
- LTD_TGT(&m->lod_ost_descs, ost_idx));
+ LTD_TGT(&m->lod_ost_descs, ost_idx),
+ reserve);
if (rc < 0) /* this OSP doesn't feel well */
break;
static int lod_ost_alloc_specific(const struct lu_env *env,
struct lod_object *lo,
struct dt_object **stripe, __u32 *ost_indices,
- int flags, struct thandle *th, int comp_idx)
+ int flags, struct thandle *th, int comp_idx,
+ __u64 reserve)
{
struct lod_layout_component *lod_comp;
struct lod_device *m = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
i++, array_idx = (array_idx + 1) % ost_count) {
ost_idx = osts->op_array[array_idx];
- if (!cfs_bitmap_check(m->lod_ost_bitmap, ost_idx))
+ if (!test_bit(ost_idx, m->lod_ost_bitmap))
continue;
/* Fail Check before osc_precreate() is called
* start OST, then it can be skipped, otherwise skip it only
* if it is inactive/recovering/out-of-space." */
- rc = lod_statfs_and_check(env, m, &m->lod_ost_descs, tgt);
+ rc = lod_statfs_and_check(env, m, &m->lod_ost_descs,
+ tgt, reserve);
if (rc) {
/* this OSP doesn't feel well */
continue;
*/
static int lod_ost_alloc_qos(const struct lu_env *env, struct lod_object *lo,
struct dt_object **stripe, __u32 *ost_indices,
- int flags, struct thandle *th, int comp_idx)
+ int flags, struct thandle *th, int comp_idx,
+ __u64 reserve)
{
struct lod_layout_component *lod_comp;
struct lod_device *lod = lu2lod_dev(lo->ldo_obj.do_lu.lo_dev);
good_osts = 0;
/* Find all the OSTs that are valid stripe candidates */
for (i = 0; i < osts->op_count; i++) {
- if (!cfs_bitmap_check(lod->lod_ost_bitmap, osts->op_array[i]))
+ if (!test_bit(osts->op_array[i], lod->lod_ost_bitmap))
continue;
ost = OST_TGT(lod, osts->op_array[i]);
ost->ltd_qos.ltq_usable = 0;
- rc = lod_statfs_and_check(env, lod, &lod->lod_ost_descs, ost);
+ rc = lod_statfs_and_check(env, lod, &lod->lod_ost_descs,
+ ost, reserve);
if (rc) {
/* this OSP doesn't feel well */
continue;
}
- if (ost->ltd_statfs.os_state & OS_STATE_DEGRADED)
+ if (ost->ltd_statfs.os_state & OS_STATFS_DEGRADED)
continue;
/* Fail Check before osc_precreate() is called
good_mdts = 0;
/* Find all the MDTs that are valid stripe candidates */
for (i = 0; i < pool->op_count; i++) {
- if (!cfs_bitmap_check(ltd->ltd_tgt_bitmap, pool->op_array[i]))
+ if (!test_bit(pool->op_array[i], ltd->ltd_tgt_bitmap))
continue;
mdt = LTD_TGT(ltd, pool->op_array[i]);
if (rc)
continue;
- if (mdt->ltd_statfs.os_state & OS_STATE_DEGRADED)
+ if (mdt->ltd_statfs.os_state & OS_STATFS_DEGRADED)
continue;
mdt->ltd_qos.ltq_usable = 1;
if (lod_qos_is_tgt_used(env, mdt_idx, stripe_idx))
continue;
- rc2 = obd_fid_alloc(env, mdt->ltd_exp, &fid, NULL);
+ rc2 = dt_fid_alloc(env, mdt->ltd_tgt, &fid, NULL, NULL);
if (rc2 < 0) {
QOS_DEBUG("can't alloc FID on #%u: %d\n",
mdt_idx, rc2);
lag->lag_oaa_count = 0;
if (lag->lag_oss_avoid_array &&
lag->lag_oaa_size < lod->lod_ost_count) {
- OBD_FREE(lag->lag_oss_avoid_array,
- sizeof(__u32) * lag->lag_oaa_size);
+ OBD_FREE_PTR_ARRAY(lag->lag_oss_avoid_array, lag->lag_oaa_size);
lag->lag_oss_avoid_array = NULL;
lag->lag_oaa_size = 0;
}
* using OST count to allocate the array to store the OSS
* id.
*/
- OBD_ALLOC(new_oss, sizeof(*new_oss) * lod->lod_ost_count);
+ OBD_ALLOC_PTR_ARRAY(new_oss, lod->lod_ost_count);
if (!new_oss) {
CFS_FREE_BITMAP(bitmap);
return -ENOMEM;
*/
int lod_qos_prep_create(const struct lu_env *env, struct lod_object *lo,
struct lu_attr *attr, struct thandle *th,
- int comp_idx)
+ int comp_idx, __u64 reserve)
{
struct lod_layout_component *lod_comp;
struct lod_device *d = lu2lod_dev(lod2lu_obj(lo)->lo_dev);
if (stripe_len == 0)
GOTO(out, rc = -ERANGE);
lod_comp->llc_stripe_count = stripe_len;
- OBD_ALLOC(stripe, sizeof(stripe[0]) * stripe_len);
+ OBD_ALLOC_PTR_ARRAY(stripe, stripe_len);
if (stripe == NULL)
GOTO(out, rc = -ENOMEM);
- OBD_ALLOC(ost_indices, sizeof(*ost_indices) * stripe_len);
+ OBD_ALLOC_PTR_ARRAY(ost_indices, stripe_len);
if (!ost_indices)
GOTO(out, rc = -ENOMEM);
+repeat:
lod_getref(&d->lod_ost_descs);
/* XXX: support for non-0 files w/o objects */
CDEBUG(D_OTHER, "tgt_count %d stripe_count %d\n",
if (lod_comp->llc_ostlist.op_array &&
lod_comp->llc_ostlist.op_count) {
rc = lod_alloc_ost_list(env, lo, stripe, ost_indices,
- th, comp_idx);
+ th, comp_idx, reserve);
} else if (lod_comp->llc_stripe_offset == LOV_OFFSET_DEFAULT) {
/**
* collect OSTs and OSSs used in other mirrors whose
lod_collect_avoidance(lo, lag, comp_idx);
rc = lod_ost_alloc_qos(env, lo, stripe, ost_indices,
- flag, th, comp_idx);
+ flag, th, comp_idx, reserve);
if (rc == -EAGAIN)
rc = lod_ost_alloc_rr(env, lo, stripe,
ost_indices, flag, th,
- comp_idx);
+ comp_idx, reserve);
} else {
rc = lod_ost_alloc_specific(env, lo, stripe,
ost_indices, flag, th,
- comp_idx);
+ comp_idx, reserve);
}
put_ldts:
lod_putref(d, &d->lod_ost_descs);
for (i = 0; i < stripe_len; i++)
if (stripe[i] != NULL)
dt_object_put(env, stripe[i]);
+
+ /* In case there is no space on any OST, let's ignore
+ * the @reserve space to avoid an error at the init
+ * time, probably the actual IO will be less than the
+ * given @reserve space (aka extension_size). */
+ if (reserve) {
+ reserve = 0;
+ goto repeat;
+ }
lod_comp->llc_stripe_count = 0;
} else {
lod_comp->llc_stripe = stripe;
out:
if (rc < 0) {
if (stripe)
- OBD_FREE(stripe, sizeof(stripe[0]) * stripe_len);
+ OBD_FREE_PTR_ARRAY(stripe, stripe_len);
if (ost_indices)
- OBD_FREE(ost_indices,
- sizeof(*ost_indices) * stripe_len);
+ OBD_FREE_PTR_ARRAY(ost_indices, stripe_len);
}
RETURN(rc);
}
extent = &lod_comp->llc_extent;
QOS_DEBUG("comp[%d] %lld "DEXT"\n", i, size, PEXT(extent));
if (!lo->ldo_is_composite || size >= extent->e_start) {
- rc = lod_qos_prep_create(env, lo, attr, th, i);
+ rc = lod_qos_prep_create(env, lo, attr, th, i, 0);
if (rc)
break;
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff