{
if (tgt->active == activate)
return;
-
+
tgt->active = activate;
lmv->desc.ld_active_tgt_count += (activate ? 1 : -1);
}
lmv_activate_target(lmv, tgt, activate);
EXIT;
-
+
out_lmv_lock:
spin_unlock(&lmv->lmv_lock);
return rc;
}
exp = class_conn2export(conn);
-
+
/* we don't want to actually do the underlying connections more than
* once, so keep track. */
lmv->refcount++;
for (i = 0, tgts = lmv->tgts; i < lmv->desc.ld_tgt_count; i++, tgts++) {
if (tgts->ltd_exp == NULL)
continue;
-
+
obd_set_info_async(tgts->ltd_exp, strlen("inter_mds"),
"inter_mds", 0, NULL, NULL);
}
}
if (change == 0)
RETURN(0);
-
+
if (lmv->connected == 0)
RETURN(0);
CERROR("target %s not set up\n", tgt->uuid.uuid);
RETURN(-EINVAL);
}
-
+
rc = obd_connect(&conn, mdc_obd, &lmv_mdc_uuid, &lmv->conn_data);
if (rc) {
CERROR("target %s connect error %d\n", tgt->uuid.uuid, rc);
}
}
- tgt->active = 1;
+ tgt->active = 1;
tgt->ltd_exp = mdc_exp;
lmv->desc.ld_active_tgt_count++;
md_init_ea_size(tgt->ltd_exp, lmv->max_easize,
lmv->max_def_easize, lmv->max_cookiesize);
-
+
CDEBUG(D_CONFIG, "connected to %s(%s) successfully (%d)\n",
mdc_obd->obd_name, mdc_obd->obd_uuid.uuid,
atomic_read(&obd->obd_refcount));
if (lmv->connected)
RETURN(0);
-
+
lmv_init_lock(lmv);
if (lmv->connected) {
lmv_init_unlock(lmv);
#endif
for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
- struct obd_device *mdc_obd;
-
+ struct obd_device *mdc_obd;
+
if (lmv->tgts[i].ltd_exp == NULL)
continue;
}
rc = 0;
}
-
+
lmv_activate_target(lmv, &lmv->tgts[i], 0);
lmv->tgts[i].ltd_exp = NULL;
}
if (lmv->desc.ld_tgt_count == 0)
RETURN(-ENOTTY);
-
+
for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
int err;
struct lmv_obd *lmv = &obd->u.lmv;
int i, rc = 0;
ENTRY;
-
+
for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
if (lmv->tgts[i].ltd_exp == NULL)
continue;
-
+
rc = obd_fid_init(lmv->tgts[i].ltd_exp);
if (rc)
RETURN(rc);
for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
if (lmv->tgts[i].ltd_exp == NULL)
continue;
-
+
rc = obd_fid_fini(lmv->tgts[i].ltd_exp);
if (rc)
break;
#ifdef LPROCFS
{
struct proc_dir_entry *entry;
-
- entry = create_proc_entry("target_obd_status", 0444,
+
+ entry = create_proc_entry("target_obd_status", 0444,
obd->obd_proc_entry);
if (entry != NULL) {
- entry->proc_fops = &lmv_proc_target_fops;
+ entry->proc_fops = &lmv_proc_target_fops;
entry->data = obd;
}
}
RETURN(0);
-out_free_datas:
+out_free_datas:
OBD_FREE(lmv->datas, lmv->datas_size);
lmv->datas = NULL;
out_free_tgts:
return rc;
}
-static int lmv_cleanup(struct obd_device *obd)
+static int lmv_cleanup(struct obd_device *obd)
{
struct lmv_obd *lmv = &obd->u.lmv;
ENTRY;
fld_client_fini(&lmv->lmv_fld);
OBD_FREE(lmv->datas, lmv->datas_size);
OBD_FREE(lmv->tgts, lmv->tgts_size);
-
+
RETURN(0);
}
struct obd_statfs *temp;
int rc = 0, i;
ENTRY;
-
+
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
OBD_ALLOC(temp, sizeof(*temp));
if (temp == NULL)
RETURN(-ENOMEM);
-
+
for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
if (lmv->tgts[i].ltd_exp == NULL)
continue;
RETURN(rc);
rc = md_getstatus(lmv->tgts[0].ltd_exp, fid);
-
+
RETURN(rc);
}
RETURN(rc);
i = lmv_fld_lookup(obd, fid);
+ if (i < 0)
+ RETURN(i);
+
LASSERT(i < lmv->desc.ld_tgt_count);
rc = md_getattr(lmv->tgts[i].ltd_exp, fid, valid,
ea_size, request);
if (rc)
RETURN(rc);
-
+
obj = lmv_obj_grab(obd, fid);
-
+
CDEBUG(D_OTHER, "GETATTR for "DFID3" %s\n",
PFID3(fid), obj ? "(splitted)" : "");
lmv_obj_put(obj);
RETURN(rc);
}
-
+
body = lustre_msg_buf((*request)->rq_repmsg, 0,
sizeof(*body));
LASSERT(body != NULL);
lmv_obj_lock(obj);
-
+
for (i = 0; i < obj->lo_objcount; i++) {
if (lmv->tgts[i].ltd_exp == NULL) {
/* skip master obj. */
if (lu_fid_eq(&obj->lo_fid, &obj->lo_inodes[i].li_fid))
continue;
-
+
body->size += obj->lo_inodes[i].li_size;
}
lmv_obj_unlock(obj);
lmv_obj_put(obj);
}
-
+
RETURN(rc);
}
static int lmv_change_cbdata(struct obd_export *exp,
- struct lu_fid *fid,
+ struct lu_fid *fid,
ldlm_iterator_t it,
void *data)
{
struct lmv_obd *lmv = &obd->u.lmv;
int i, rc;
ENTRY;
-
+
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
-
+
CDEBUG(D_OTHER, "CBDATA for "DFID3"\n", PFID3(fid));
/* with CMD every object can have two locks in different namespaces:
* space of mds storing inode */
for (i = 0; i < lmv->desc.ld_tgt_count; i++)
md_change_cbdata(lmv->tgts[i].ltd_exp, fid, it, data);
-
+
RETURN(0);
}
struct lmv_obd *lmv = &obd->u.lmv;
int rc, i;
ENTRY;
-
+
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
i = lmv_fld_lookup(obd, &op_data->fid1);
+ if (i < 0)
+ RETURN(i);
+
LASSERT(i < lmv->desc.ld_tgt_count);
CDEBUG(D_OTHER, "CLOSE "DFID3"\n", PFID3(&op_data->fid1));
rc = md_close(lmv->tgts[i].ltd_exp, op_data, och, request);
md.mea = NULL;
mealen = MEA_SIZE_LMV(lmv);
-
+
valid = OBD_MD_FLEASIZE | OBD_MD_FLDIREA | OBD_MD_MEA;
i = lmv_fld_lookup(obd, fid);
+ if (i < 0)
+ RETURN(i);
+
LASSERT(i < lmv->desc.ld_tgt_count);
-
+
/* time to update mea of parent fid */
rc = md_getattr(lmv->tgts[i].ltd_exp, fid, valid,
mealen, &req);
LASSERT(++loop <= 2);
obj = lmv_obj_grab(obd, &op_data->fid1);
if (obj) {
- mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
+ mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
op_data->name, op_data->namelen);
op_data->fid1 = obj->lo_inodes[mds].li_fid;
lmv_obj_put(obj);
CDEBUG(D_OTHER, "CREATE '%*s' on "DFID3"\n", op_data->namelen,
op_data->name, PFID3(&op_data->fid1));
-
+
mds = lmv_fld_lookup(obd, &op_data->fid1);
+ if (mds < 0)
+ RETURN(mds);
+
rc = md_create(lmv->tgts[mds].ltd_exp, op_data, data, datalen,
mode, uid, gid, rdev, cap_effective, request);
if (rc == 0) {
sizeof(*body));
if (body == NULL)
RETURN(-ENOMEM);
-
+
CDEBUG(D_OTHER, "created. "DFID3"\n", PFID3(&op_data->fid1));
} else if (rc == -ERESTART) {
/* directory got splitted. time to update local object and
struct lmv_obd *lmv = &obd->u.lmv;
int rc, mds;
ENTRY;
-
+
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
mds = lmv_fld_lookup(obd, &op_data->fid1);
+ if (mds < 0)
+ RETURN(mds);
rc = md_done_writing(lmv->tgts[mds].ltd_exp, op_data);
RETURN(rc);
}
OBD_ALLOC(op_data2, sizeof(*op_data2));
if (op_data2 == NULL)
RETURN(-ENOMEM);
-
+
LASSERT(mea != NULL);
for (i = 0; i < mea->mea_count; i++) {
memset(op_data2, 0, sizeof(*op_data2));
op_data2->fid1 = mea->mea_ids[i];
mds = lmv_fld_lookup(obd, &op_data2->fid1);
-
+ if (mds < 0)
+ RETURN(mds);
+
if (lmv->tgts[mds].ltd_exp == NULL)
continue;
- rc = md_enqueue(lmv->tgts[mds].ltd_exp, locktype, it,
- lockmode, op_data2, lockh + i, lmm, lmmsize,
+ rc = md_enqueue(lmv->tgts[mds].ltd_exp, locktype, it,
+ lockmode, op_data2, lockh + i, lmm, lmmsize,
cb_compl, cb_blocking, cb_data, 0);
-
+
CDEBUG(D_OTHER, "take lock on slave "DFID3" -> %d/%d\n",
PFID3(&mea->mea_ids[i]), rc, it->d.lustre.it_status);
if (rc)
req = (struct ptlrpc_request *)it->d.lustre.it_data;
ptlrpc_req_finished(req);
}
-
+
if (it->d.lustre.it_status)
GOTO(cleanup, rc = it->d.lustre.it_status);
}
-
+
OBD_FREE(op_data2, sizeof(*op_data2));
RETURN(0);
cleanup:
OBD_FREE(op_data2, sizeof(*op_data2));
-
+
/* drop all taken locks */
while (--i >= 0) {
if (lockh[i].cookie)
ptlrpc_req_finished(req);
i = lmv_fld_lookup(obd, &rdata.fid1);
- rc = md_enqueue(lmv->tgts[i].ltd_exp,
- lock_type, it, lock_mode, &rdata, lockh, lmm,
+ if (i < 0)
+ RETURN(i);
+ rc = md_enqueue(lmv->tgts[i].ltd_exp,
+ lock_type, it, lock_mode, &rdata, lockh, lmm,
lmmsize, cb_compl, cb_blocking, cb_data,
extra_lock_flags);
ldlm_lock_decref(&plock, pmode);
}
CDEBUG(D_OTHER, "ENQUEUE '%s' on "DFID3"\n", LL_IT2STR(it),
PFID3(&op_data->fid1));
-
+
mds = lmv_fld_lookup(obd, &op_data->fid1);
- rc = md_enqueue(lmv->tgts[mds].ltd_exp,
- lock_type, it, lock_mode, op_data, lockh, lmm,
+ if (mds < 0)
+ RETURN(mds);
+ rc = md_enqueue(lmv->tgts[mds].ltd_exp,
+ lock_type, it, lock_mode, op_data, lockh, lmm,
lmmsize, cb_compl, cb_blocking, cb_data,
extra_lock_flags);
if (rc == 0 && it->it_op == IT_OPEN)
struct mdt_body *body;
struct lmv_obj *obj;
ENTRY;
-
+
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
mds = lmv_fld_lookup(obd, fid);
+ if (mds < 0)
+ RETURN(mds);
repeat:
LASSERT(++loop <= 2);
obj = lmv_obj_grab(obd, fid);
if (obj) {
/* directory is splitted. look for right mds for this name */
- mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
+ mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
filename, namelen - 1);
rid = obj->lo_inodes[mds].li_fid;
lmv_obj_put(obj);
}
-
+
CDEBUG(D_OTHER, "getattr_lock for %*s on "DFID3" -> "DFID3"\n",
namelen, filename, PFID3(fid), PFID3(&rid));
mds = lmv_fld_lookup(obd, &rid);
+ if (mds < 0)
+ RETURN(mds);
+
rc = md_getattr_name(lmv->tgts[mds].ltd_exp,
&rid, filename, namelen,
valid, ea_size, request);
if (body->valid & OBD_MD_MDS) {
struct ptlrpc_request *req = NULL;
-
+
rid = body->fid1;
CDEBUG(D_OTHER, "request attrs for "DFID3"\n", PFID3(&rid));
+ /*
+ * XXX check for error.
+ */
mds = lmv_fld_lookup(obd, &rid);
- rc = md_getattr_name(lmv->tgts[mds].ltd_exp,
+ rc = md_getattr_name(lmv->tgts[mds].ltd_exp,
&rid, NULL, 1, valid, ea_size, &req);
ptlrpc_req_finished(*request);
*request = req;
struct lmv_obj *obj;
int rc, mds;
ENTRY;
-
+
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
/* usual link request */
obj = lmv_obj_grab(obd, &op_data->fid2);
if (obj) {
- rc = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
+ rc = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
op_data->name, op_data->namelen);
op_data->fid2 = obj->lo_inodes[rc].li_fid;
lmv_obj_put(obj);
}
mds = lmv_fld_lookup(obd, &op_data->fid2);
+ if (mds < 0)
+ RETURN(mds);
CDEBUG(D_OTHER,"link "DFID3":%*s to "DFID3"\n",
- PFID3(&op_data->fid2), op_data->namelen,
+ PFID3(&op_data->fid2), op_data->namelen,
op_data->name, PFID3(&op_data->fid1));
} else {
mds = lmv_fld_lookup(obd, &op_data->fid1);
-
+ if (mds < 0)
+ RETURN(mds);
+
/* request from MDS to acquire i_links for inode by fid1 */
CDEBUG(D_OTHER, "inc i_nlinks for "DFID3"\n",
PFID3(&op_data->fid1));
CDEBUG(D_OTHER, "forward to MDS #%u ("DFID3")\n",
mds, PFID3(&op_data->fid1));
rc = md_link(lmv->tgts[mds].ltd_exp, op_data, request);
-
+
RETURN(rc);
}
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
struct lmv_obj *obj;
- int rc, mds;
+ int rc, mds, mds2;
ENTRY;
CDEBUG(D_OTHER, "rename %*s in "DFID3" to %*s in "DFID3"\n",
PFID3(&op_data->fid2), PFID3(&op_data->fid1));
mds = lmv_fld_lookup(obd, &op_data->fid2);
+ if (mds < 0)
+ RETURN(mds);
- /*
+ /*
* target directory can be splitted, sowe should forward request
* to the right MDS.
*/
obj = lmv_obj_grab(obd, &op_data->fid2);
if (obj) {
- mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
+ mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)new, newlen);
op_data->fid2 = obj->lo_inodes[mds].li_fid;
CDEBUG(D_OTHER, "forward to MDS #%u ("DFID3")\n", mds,
* directory is already splitted, so we have to forward request
* to the right MDS.
*/
- mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
+ mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)old, oldlen);
op_data->fid1 = obj->lo_inodes[mds].li_fid;
CDEBUG(D_OTHER, "forward to MDS #%u ("DFID3")\n", mds,
* directory is already splitted, so we have to forward request
* to the right MDS.
*/
- mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
+ mds = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
(char *)new, newlen);
-
+
op_data->fid2 = obj->lo_inodes[mds].li_fid;
CDEBUG(D_OTHER, "forward to MDS #%u ("DFID3")\n", mds,
PFID3(&op_data->fid2));
lmv_obj_put(obj);
}
-
+
mds = lmv_fld_lookup(obd, &op_data->fid1);
+ if (mds < 0)
+ RETURN(mds);
+
request:
- if (mds != lmv_fld_lookup(obd, &op_data->fid2)) {
+ mds2 = lmv_fld_lookup(obd, &op_data->fid2);
+ if (mds2 < 0)
+ RETURN(mds2);
+
+ if (mds != mds2) {
CDEBUG(D_OTHER,"cross-node rename "DFID3"/%*s to "DFID3"/%*s\n",
PFID3(&op_data->fid1), oldlen, old, PFID3(&op_data->fid2),
newlen, new);
}
rc = md_rename(lmv->tgts[mds].ltd_exp, op_data, old, oldlen,
- new, newlen, request);
+ new, newlen, request);
RETURN(rc);
}
RETURN(rc);
obj = lmv_obj_grab(obd, &op_data->fid1);
-
+
CDEBUG(D_OTHER, "SETATTR for "DFID3", valid 0x%x%s\n",
PFID3(&op_data->fid1), iattr->ia_valid, obj ? ", splitted" : "");
-
+
if (obj) {
for (i = 0; i < obj->lo_objcount; i++) {
op_data->fid1 = obj->lo_inodes[i].li_fid;
-
+
mds = lmv_fld_lookup(obd, &op_data->fid1);
- rc = md_setattr(lmv->tgts[mds].ltd_exp,
+ if (mds < 0) {
+ rc = mds;
+ break;
+ }
+
+ rc = md_setattr(lmv->tgts[mds].ltd_exp,
op_data, iattr, ea, ealen, ea2,
ea2len, &req);
lmv_obj_put(obj);
} else {
mds = lmv_fld_lookup(obd, &op_data->fid1);
+ if (mds < 0)
+ RETURN(mds);
LASSERT(mds < lmv->desc.ld_tgt_count);
rc = md_setattr(lmv->tgts[mds].ltd_exp, op_data, iattr, ea,
- ealen, ea2, ea2len, request);
+ ealen, ea2, ea2len, request);
if (rc == 0) {
body = lustre_msg_buf((*request)->rq_repmsg, 0,
sizeof(*body));
RETURN(rc);
i = lmv_fld_lookup(obd, fid);
- rc = md_sync(lmv->tgts[i].ltd_exp,
+ if (i < 0)
+ RETURN(i);
+ rc = md_sync(lmv->tgts[i].ltd_exp,
fid, request);
RETURN(rc);
}
/* main purpose of LMV blocking ast is to remove splitted directory
- * LMV presentation object (struct lmv_obj) attached to the lock
+ * LMV presentation object (struct lmv_obj) attached to the lock
* being revoked. */
-int lmv_blocking_ast(struct ldlm_lock *lock,
+int lmv_blocking_ast(struct ldlm_lock *lock,
struct ldlm_lock_desc *desc,
void *data, int flag)
{
lock->l_resource->lr_name.name[3] == 1 ?
"LOOKUP" : "UPDATE",
lock->l_resource->lr_name.name[0],
- lock->l_resource->lr_name.name[1],
+ lock->l_resource->lr_name.name[1],
PFID3(&obj->lo_fid));
lmv_obj_put(obj);
}
RETURN(rc);
i = lmv_fld_lookup(obd, fid);
+ if (i < 0)
+ RETURN(i);
LASSERT(i < lmv->desc.ld_tgt_count);
CDEBUG(D_OTHER, "READPAGE at %llu from "DFID3"\n",
offset, PFID3(&rid));
offset -= obj->lo_inodes[i].li_size;
}
rid = obj->lo_inodes[i].li_fid;
-
+
lmv_obj_unlock(obj);
lmv_obj_put(obj);
-
+
CDEBUG(D_OTHER, "forward to "DFID3" with offset %lu\n",
PFID3(&rid), (unsigned long)offset);
}
i = lmv_fld_lookup(obd, &rid);
- rc = md_readpage(lmv->tgts[i].ltd_exp, &rid,
+ if (i < 0)
+ RETURN(i);
+ rc = md_readpage(lmv->tgts[i].ltd_exp, &rid,
offset, page, request);
-
+
if (rc == 0 && !lu_fid_eq(&rid, fid))
- /* this page isn't from master object. To avoid "." and ".."
+ /* this page isn't from master object. To avoid "." and ".."
* duplication in directory, we have to remove them from all
* slave objects */
lmv_remove_dots(page);
-
+
RETURN(rc);
}
OBD_ALLOC(op_data2, sizeof(*op_data2));
if (op_data2 == NULL)
RETURN(-ENOMEM);
-
+
LASSERT(mea != NULL);
for (i = 0; i < mea->mea_count; i++) {
memset(op_data2, 0, sizeof(*op_data2));
op_data2->fid1 = mea->mea_ids[i];
op_data2->create_mode = MDS_MODE_DONT_LOCK | S_IFDIR;
-
+
mds = lmv_fld_lookup(obd, &op_data2->fid1);
+ if (mds < 0)
+ RETURN(mds);
if (lmv->tgts[mds].ltd_exp == NULL)
continue;
rc = md_unlink(lmv->tgts[mds].ltd_exp,
op_data2, req);
-
+
CDEBUG(D_OTHER, "unlink slave "DFID3" -> %d\n",
PFID3(&mea->mea_ids[i]), rc);
-
+
if (*req) {
ptlrpc_req_finished(*req);
*req = NULL;
struct lmv_obd *lmv = &obd->u.lmv;
int rc, i = 0;
ENTRY;
-
+
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
if (op_data->namelen != 0) {
struct lmv_obj *obj;
-
+
obj = lmv_obj_grab(obd, &op_data->fid1);
if (obj) {
i = raw_name2idx(obj->lo_hashtype, obj->lo_objcount,
PFID3(&op_data->fid1));
}
i = lmv_fld_lookup(obd, &op_data->fid1);
+ if (i < 0)
+ RETURN(i);
rc = md_unlink(lmv->tgts[i].ltd_exp, op_data, request);
RETURN(rc);
}
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
-
+
/* getting rootid from first MDS. */
rc = obd_get_info(lmv->tgts[0].ltd_exp, keylen, key,
vallen, val);
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
-
+
LASSERT(*vallen == sizeof(__u32));
for (i = 0, tgts = lmv->tgts; i < lmv->desc.ld_tgt_count;
i++, tgts++) {
RETURN(rc);
}
if (((keylen == strlen("flush_cred") &&
- strcmp(key, "flush_cred") == 0)) ||
+ strcmp(key, "flush_cred") == 0)) ||
((keylen == strlen("crypto_type") &&
strcmp(key, "crypto_type") == 0))) {
int i;
if (!tgt->ltd_exp)
continue;
rc = obd_set_info_async(tgt->ltd_exp,
- keylen, key, vallen,
+ keylen, key, vallen,
val, set);
if (rc)
RETURN(rc);
RETURN(0);
}
-
+
if (keylen == strlen("ids") && memcmp(key, "ids", keylen) == 0) {
struct lu_fid *fid = (struct lu_fid *)val;
int i;
-
+
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
i = lmv_fld_lookup(obd, fid);
- rc = obd_set_info_async(lmv->tgts[i].ltd_exp,
+ if (i < 0)
+ RETURN(i);
+ rc = obd_set_info_async(lmv->tgts[i].ltd_exp,
keylen, key, vallen, val,
- set);
+ set);
RETURN(rc);
}
- if (keylen == strlen("chkconnect") &&
+ if (keylen == strlen("chkconnect") &&
memcmp(key, "chkconnect", keylen) == 0) {
rc = lmv_check_connect(obd);
RETURN(rc);
int mea_size, i;
ENTRY;
- mea_size = (sizeof(struct lu_fid) *
+ mea_size = (sizeof(struct lu_fid) *
lmv->desc.ld_tgt_count) + sizeof(struct lmv_stripe_md);
if (!lmmp)
RETURN(mea_size);
__u32 magic;
ENTRY;
- mea_size = sizeof(struct lu_fid) *
+ mea_size = sizeof(struct lu_fid) *
lmv->desc.ld_tgt_count + sizeof(struct lmv_stripe_md);
if (lsmp == NULL)
RETURN(rc);
LASSERT(oa != NULL);
-
+
if (ea == NULL) {
rc = lmv_obd_create_single(exp, oa, NULL, oti);
if (rc)
RETURN(rc);
} else
rc = 0;
-
+
if (*ea == NULL)
RETURN(-ENOMEM);
}
for (i = 0, c = 0; c < mea->mea_count && i < lmv->desc.ld_tgt_count; i++) {
struct lov_stripe_md obj_md;
struct lov_stripe_md *obj_mdp = &obj_md;
-
+
if (lmv->tgts[i].ltd_exp == NULL) {
/* this is "master" MDS */
mea->mea_master = i;
*/
LASSERT(oa->o_fid);
- /*
+ /*
* store cookie should be defined here for both cases (master
* object and not master), because master is already created.
*/
CDEBUG(D_OTHER, "%d dirobjects created\n",
(int)mea->mea_count);
-
+
RETURN(rc);
}
struct lmv_obd *lmv = &obd->u.lmv;
struct lmv_stripe_md *mea = (struct lmv_stripe_md *) ea;
int err;
-
+
LASSERT(oa != NULL);
LASSERT(ea != NULL);
LASSERT(pgarr != NULL);
oa->o_gr = id_gen(&mea->mea_ids[oa->o_mds]);
oa->o_id = id_ino(&mea->mea_ids[oa->o_mds]);
oa->o_valid = OBD_MD_FLID | OBD_MD_FLGROUP;
-
+
err = obd_brw(rw, lmv->tgts[oa->o_mds].ltd_exp,
oa, NULL, oa_bufs, pgarr, oti);
RETURN(err);
ENTRY;
LASSERT(fid != NULL);
-
+
for (i = 0; i < lmv->desc.ld_tgt_count; i++) {
if (!lmv->tgts[i].ltd_exp || !lmv->tgts[i].active)
continue;
-
+
err = md_cancel_unused(lmv->tgts[i].ltd_exp,
fid, flags, opaque);
if (!rc)
lvars.module_vars, LUSTRE_LMV_NAME, NULL);
if (rc)
kmem_cache_destroy(obj_cache);
-
+
return rc;
}
git://git.whamcloud.com / fs / lustre-release.git / commitdiff