if (IS_ERR(obj))
RETURN(PTR_ERR(obj));
- is_dir = S_ISDIR(lu_object_attr(&obj->cmo_obj.mo_lu));
+ if (lu_object_exists(&obj->cmo_obj.mo_lu) > 0)
+ is_dir = S_ISDIR(lu_object_attr(&obj->cmo_obj.mo_lu));
+ else
+ /* XXX: is this correct? */
+ is_dir = 0;
+
OBD_ALLOC(name, ent->lde_namelen + 1);
if (!name)
GOTO(cleanup, rc = -ENOMEM);
-
+
memcpy(name, ent->lde_name, ent->lde_namelen);
rc = mdo_name_remove(env, md_object_next(mo),
name, is_dir);
if (rc)
GOTO(cleanup, rc);
- /* Because this ent will be transferred to slave MDS and
- * insert it there, so in the slave MDS, we should know whether
- * this object is dir or not, so use the highest bit of the hash
- * to indicate that (because we do not use highest bit of hash)
+ /*
+ * This ent will be transferred to slave MDS and insert it there, so in
+ * the slave MDS, we should know whether this object is dir or not, so
+ * use the highest bit of the hash to indicate that (because we do not
+ * use highest bit of hash).
*/
if (is_dir)
ent->lde_hash |= MAX_HASH_HIGHEST_BIT;
kmap(rdpg->rp_pages[0]);
dp = page_address(rdpg->rp_pages[0]);
for (ent = lu_dirent_start(dp); ent != NULL;
- ent = lu_dirent_next(ent)) {
+ ent = lu_dirent_next(ent)) {
if (ent->lde_hash < hash_end) {
rc = cmm_remove_dir_ent(env, mo, ent);
if (rc) {
ENTRY;
LASSERTF(rdpg->rp_npages == 1, "Now Only support split 1 page each time"
- "npages %d \n", rdpg->rp_npages);
- /* Read splitted page and send them to the slave master */
+ "npages %d\n", rdpg->rp_npages);
+
+ /* Read split page and send them to the slave master. */
do {
struct lu_dirpage *ldp;
__u32 len = 0;
RETURN(rc);
}
+
#define SPLIT_PAGE_COUNT 1
static int cmm_scan_and_split(const struct lu_env *env,
struct md_object *mo, struct md_attr *ma)
__free_pages(rdpg->rp_pages[i], 0);
if (rdpg->rp_pages)
OBD_FREE(rdpg->rp_pages, rdpg->rp_npages *
- sizeof rdpg->rp_pages[0]);
+ sizeof rdpg->rp_pages[0]);
free_rdpg:
if (rdpg)
OBD_FREE_PTR(rdpg);
/* step4: set mea to the master object */
rc = mo_xattr_set(env, md_object_next(mo), buf, MDS_LMV_MD_NAME, 0);
if (rc == -ERESTART)
- CWARN("Dir"DFID" has been split \n",
- PFID(lu_object_fid(&mo->mo_lu)));
+ CWARN("Dir "DFID" has been split\n",
+ PFID(lu_object_fid(&mo->mo_lu)));
cleanup:
if (ma->ma_lmv_size && ma->ma_lmv)
OBD_FREE(ma->ma_lmv, ma->ma_lmv_size);
space->lr_start = in->lr_start;
space->lr_end = space->lr_start +
- LUSTRE_SEQ_SUPER_WIDTH;
+ seq->lss_width;
} else {
/*
* Update super start by start from client's range. End
for (i = 0; i < hash_size; i++)
INIT_HLIST_HEAD(&cache->fci_hash_table[i]);
- CDEBUG(D_INFO|D_WARNING, "FLD cache: Size: %d, Threshold: %d\n",
+ CDEBUG(D_INFO|D_WARNING, "FLD cache - Size: %d, Threshold: %d\n",
cache_size, cache_threshold);
RETURN(cache);
{
struct fld_cache_entry *flde;
struct list_head *curr;
+ int num = 0;
ENTRY;
LASSERT(cache != NULL);
list_del_init(&flde->fce_lru);
cache->fci_cache_count--;
OBD_FREE_PTR(flde);
+ num++;
}
+ CDEBUG(D_INFO|D_WARNING, "FLD cache - Shrinked by "
+ "%d entries\n", num);
+
RETURN(0);
}
DLM_REPLY_REC_OFF,
sizeof(*mdt_body));
/* see if we got same inode, if not - return error */
- if(lu_fid_eq(&op_data->fid2, &mdt_body->fid1)) {
+ if (lu_fid_eq(&op_data->fid2, &mdt_body->fid1)) {
ll_finish_md_op_data(op_data);
op_data = NULL;
goto revalidate_finish;
ptlrpc_req_set_repsize(req, 2, size);
rc = ptlrpc_queue_wait(req);
- str = lustre_msg_string(req->rq_repmsg, REPLY_REC_OFF,
- data->ioc_plen1);
- if (!rc)
- rc = copy_to_user(data->ioc_pbuf1, str,data->ioc_plen1);
+ if (!rc) {
+ str = lustre_msg_string(req->rq_repmsg, REPLY_REC_OFF,
+ data->ioc_plen1);
+ rc = copy_to_user(data->ioc_pbuf1, str, data->ioc_plen1);
+ }
ptlrpc_req_finished(req);
out_catinfo:
obd_ioctl_freedata(buf, len);
struct obd_capa *ll_i2mdscapa(struct inode *inode)
{
- struct obd_capa *ocapa;
struct ll_inode_info *lli = ll_i2info(inode);
+ struct obd_capa *ocapa;
+ ENTRY;
- LASSERT(inode);
+ LASSERT(inode != NULL);
+
if ((ll_i2sbi(inode)->ll_flags & LL_SBI_MDS_CAPA) == 0)
- return NULL;
- ENTRY;
+ RETURN(NULL);
spin_lock(&capa_lock);
ocapa = capa_get(lli->lli_mds_capa);
spin_unlock(&capa_lock);
+
if (ocapa && !obd_capa_is_valid(ocapa)) {
DEBUG_CAPA(D_ERROR, &ocapa->c_capa, "invalid");
capa_put(ocapa);
{
LASSERT(i1 != NULL);
- if (!op_data)
+ if (op_data == NULL)
OBD_ALLOC_PTR(op_data);
- if (!op_data)
+
+ if (op_data == NULL)
return NULL;
ll_i2gids(op_data->suppgids, i1, i2);
struct md_op_data *op_data;
int err;
ENTRY;
+
CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
name->len, name->name, dir->i_ino, dir->i_generation, dir);
if (op_data == NULL)
RETURN(-ENOMEM);
- /* allocate new fid */
+ /* Allocate new fid. */
err = ll_fid_md_alloc(ll_i2sbi(dir), &op_data->fid2, &hint);
if (err) {
CERROR("can't allocate new fid, rc %d\n", err);
err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
current->fsuid, current->fsgid,
current->cap_effective, 0, &request);
+
ll_finish_md_op_data(op_data);
if (err == 0) {
ll_update_times(request, REPLY_REC_OFF, dir);
d_instantiate(dchild, inode);
}
}
- EXIT;
-out:
- ptlrpc_req_finished(request);
- return err;
+ if (request != NULL)
+ ptlrpc_req_finished(request);
+ RETURN(err);
}
static int ll_rmdir_generic(struct inode *dir, struct dentry *dparent,
int lmv_alloc_fid_for_split(struct obd_device *obd, struct lu_fid *pid,
struct md_op_data *op, struct lu_fid *fid)
{
- struct lmv_obj *obj;
struct lmv_obd *lmv = &obd->u.lmv;
+ struct lmv_obj *obj;
struct lu_fid *rpid;
mdsno_t mds;
int rc;
RETURN(rc);
}
-/* called in the case MDS returns -ERESTART on create on open, what means that
- * directory is split and its LMV presentation object has to be updated. */
+/*
+ * Called in the case MDS returns -ERESTART on create on open, what means that
+ * directory is split and its LMV presentation object has to be updated.
+ */
int lmv_handle_split(struct obd_export *exp, const struct lu_fid *fid)
{
struct obd_device *obd = exp->exp_obd;
obd_free_memmd(exp, (struct lov_stripe_md **)&md.mea);
+ EXIT;
cleanup:
if (req)
ptlrpc_req_finished(req);
- RETURN(rc);
+ return rc;
}
int lmv_create(struct obd_export *exp, struct md_op_data *op_data,
if (rc == 0) {
if (*request == NULL)
RETURN(rc);
- CDEBUG(D_OTHER, "created. "DFID"\n",
- PFID(&op_data->fid1));
+ CDEBUG(D_OTHER, "created. "DFID"\n", PFID(&op_data->fid1));
} else if (rc == -ERESTART) {
/*
- * Directory got split. time to update local object and repeat
+ * Directory got split. Time to update local object and repeat
* the request with proper MDS.
*/
rc = lmv_handle_split(exp, &op_data->fid1);
if (rc == 0) {
ptlrpc_req_finished(*request);
rc = lmv_alloc_fid_for_split(obd, &op_data->fid1,
- op_data, &op_data->fid2);
+ op_data, &op_data->fid2);
if (rc)
RETURN(rc);
goto repeat;
}
void mdc_readdir_pack(struct ptlrpc_request *req, int offset, __u64 pgoff,
- __u32 size, const struct lu_fid *fid,
- struct obd_capa *oc)
+ __u32 size, const struct lu_fid *fid, struct obd_capa *oc)
{
struct mdt_body *b;
{
struct mdt_rec_create *rec;
char *tmp;
- rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
+
+ rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*rec));
rec->cr_opcode = REINT_CREATE;
rec->cr_fsuid = uid;
if (data) {
tmp = lustre_msg_buf(req->rq_reqmsg, offset + 3, datalen);
- memcpy (tmp, data, datalen);
+ memcpy(tmp, data, datalen);
}
}
const void *data, int datalen, int mode, __u32 uid, __u32 gid,
__u32 cap_effective, __u64 rdev, struct ptlrpc_request **request)
{
- struct obd_device *obd = exp->exp_obd;
- struct ptlrpc_request *req;
int size[5] = { sizeof(struct ptlrpc_body),
sizeof(struct mdt_rec_create),
0, op_data->namelen + 1 };
+ struct obd_device *obd = exp->exp_obd;
int level, bufcount = 4, rc;
+ struct ptlrpc_request *req;
ENTRY;
if (op_data->mod_capa1)
if (req == NULL)
RETURN(-ENOMEM);
- /* mdc_create_pack fills msg->bufs[1] with name
- * and msg->bufs[2] with tgt, for symlinks or lov MD data */
+ /*
+ * mdc_create_pack() fills msg->bufs[1] with name and msg->bufs[2] with
+ * tgt, for symlinks or lov MD data.
+ */
mdc_create_pack(req, REQ_REC_OFF, op_data, data, datalen, mode, uid,
gid, cap_effective, rdev);
level = LUSTRE_IMP_FULL;
resend:
rc = mdc_reint(req, obd->u.cli.cl_rpc_lock, level);
+
/* Resend if we were told to. */
if (rc == -ERESTARTSYS) {
level = LUSTRE_IMP_RECOVER;
int mdc_sendpage(struct obd_export *exp, const struct lu_fid *fid,
const struct page *page, int offset)
{
+ int rc, size[3] = { sizeof(struct ptlrpc_body), sizeof(struct mdt_body) };
struct obd_import *imp = class_exp2cliimp(exp);
- struct ptlrpc_request *req = NULL;
struct ptlrpc_bulk_desc *desc = NULL;
- struct mdt_body *body;
- int rc, size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) };
+ struct ptlrpc_request *req = NULL;
ENTRY;
CDEBUG(D_INODE, "object: "DFID"\n", PFID(fid));
- req = ptlrpc_prep_req(imp, LUSTRE_MDS_VERSION, MDS_WRITEPAGE, 3, size,
- NULL);
+ req = ptlrpc_prep_req(imp, LUSTRE_MDS_VERSION, MDS_WRITEPAGE, 3,
+ size, NULL);
if (req == NULL)
GOTO(out, rc = -ENOMEM);
desc = ptlrpc_prep_bulk_imp(req, 1, BULK_GET_SOURCE, MDS_BULK_PORTAL);
if (desc == NULL)
GOTO(out, rc = -ENOMEM);
- /* NB req now owns desc and will free it when it gets freed */
- ptlrpc_prep_bulk_page(desc, (struct page*)page, 0, offset);
-
+
+ /* NB req now owns desc and will free it when it gets freed. */
+ ptlrpc_prep_bulk_page(desc, (struct page *)page, 0, offset);
mdc_readdir_pack(req, REQ_REC_OFF, 0, offset, fid, NULL);
ptlrpc_req_set_repsize(req, 2, size);
rc = ptlrpc_queue_wait(req);
+ EXIT;
out:
- ptlrpc_req_finished(req);
- RETURN(rc);
+ if (req != NULL)
+ ptlrpc_req_finished(req);
+ return rc;
}
EXPORT_SYMBOL(mdc_sendpage);
#endif
struct obd_capa *oc, __u64 offset, struct page *page,
struct ptlrpc_request **request)
{
+ int rc, size[3] = { sizeof(struct ptlrpc_body), sizeof(struct mdt_body) };
struct obd_import *imp = class_exp2cliimp(exp);
- struct ptlrpc_request *req = NULL;
struct ptlrpc_bulk_desc *desc = NULL;
+ struct ptlrpc_request *req = NULL;
struct mdt_body *body;
- int rc, size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) };
ENTRY;
CDEBUG(D_INODE, "object: "DFID"\n", PFID(fid));
- if (oc)
+ if (oc != NULL)
size[REQ_REC_OFF + 1] = sizeof(struct lustre_capa);
- req = ptlrpc_prep_req(imp, LUSTRE_MDS_VERSION, MDS_READPAGE, 3, size,
- NULL);
+
+ req = ptlrpc_prep_req(imp, LUSTRE_MDS_VERSION, MDS_READPAGE, 3,
+ size, NULL);
if (req == NULL)
GOTO(out, rc = -ENOMEM);
desc = ptlrpc_prep_bulk_imp(req, 1, BULK_PUT_SINK, MDS_BULK_PORTAL);
if (desc == NULL)
GOTO(out, rc = -ENOMEM);
- /* NB req now owns desc and will free it when it gets freed */
+ /* NB req now owns desc and will free it when it gets freed */
ptlrpc_prep_bulk_page(desc, page, 0, PAGE_CACHE_SIZE);
-
mdc_readdir_pack(req, REQ_REC_OFF, offset, PAGE_CACHE_SIZE, fid, oc);
ptlrpc_req_set_repsize(req, 2, size);
" (%ld expected)\n",
req->rq_bulk->bd_nob_transferred,
PAGE_CACHE_SIZE);
- GOTO (out, rc = -EPROTO);
+ GOTO(out, rc = -EPROTO);
}
}
STRIPES_PER_OBJ=${STRIPES_PER_OBJ:-$((OSTCOUNT -1))}
TIMEOUT=${TIMEOUT:-20}
PTLDEBUG=${PTLDEBUG:-0x33f0404}
-SUBSYSTEM=${SUBSYSTEM:- 0xffb7e3ff}
+SUBSYSTEM=${SUBSYSTEM:-0xffb7e3ff}
TMP=${TMP:-/tmp}
git://git.whamcloud.com / fs / lustre-release.git / commitdiff