add md_get_info() for obd_connect_data.
other capability related small fixes.
OBD_CONNECT_ACL | OBD_CONNECT_XATTR | \
OBD_CONNECT_IBITS | OBD_CONNECT_JOIN | \
OBD_CONNECT_NODEVOH | OBD_CONNECT_ATTRFID | \
- OBD_CONNECT_LCL_CLIENT | OBD_CONNECT_RMT_CLIENT)
+ OBD_CONNECT_LCL_CLIENT | \
+ OBD_CONNECT_RMT_CLIENT | \
+ OBD_CONNECT_MDS_CAPA | OBD_CONNECT_OSS_CAPA)
#define OST_CONNECT_SUPPORTED (OBD_CONNECT_SRVLOCK | OBD_CONNECT_GRANT | \
OBD_CONNECT_REQPORTAL | OBD_CONNECT_VERSION | \
OBD_CONNECT_TRUNCLOCK | OBD_CONNECT_INDEX | \
- OBD_CONNECT_BRW_SIZE | OBD_CONNECT_QUOTA64)
+ OBD_CONNECT_BRW_SIZE | OBD_CONNECT_QUOTA64 | \
+ OBD_CONNECT_OSS_CAPA)
#define ECHO_CONNECT_SUPPORTED (0)
#define MGS_CONNECT_SUPPORTED (OBD_CONNECT_VERSION)
OBD_CAPA_FL_NEW = 1,
OBD_CAPA_FL_EXPIRED = 1<<1,
OBD_CAPA_FL_ROOT = 1<<2,
- OBD_CAPA_FL_SPLIT = 1<<3
};
static inline __u64 capa_opc(struct lustre_capa *capa)
static inline int obd_capa_is_valid(struct obd_capa *oc)
{
- return !!((oc)->c_flags & (OBD_CAPA_FL_NEW | OBD_CAPA_FL_EXPIRED));
+ return !((oc)->c_flags & (OBD_CAPA_FL_NEW | OBD_CAPA_FL_EXPIRED));
}
static inline void obd_capa_set_new(struct obd_capa *oc)
oc->c_flags |= OBD_CAPA_FL_ROOT;
}
-static inline int obd_capa_is_split(struct obd_capa *oc)
-{
- return !!((oc)->c_flags & OBD_CAPA_FL_SPLIT);
-}
-
-static inline void obd_capa_set_split(struct obd_capa *oc)
-{
- oc->c_flags |= OBD_CAPA_FL_SPLIT;
-}
-
static inline struct obd_capa *alloc_capa(int site)
{
#ifdef __KERNEL__
#define KEY_INIT_RECOV_BACKUP "init_recov_bk"
#define KEY_FLUSH_CTX "flush_ctx"
#define KEY_CAPA_KEY "capa_key"
+#define KEY_CONN_DATA "conn_data"
+#define KEY_MAX_EASIZE "max_easize"
struct lu_context;
rc = ldlm_lock_match(obddev->obd_namespace, LDLM_FL_BLOCK_GRANTED,
&res_id, LDLM_IBITS, &policy, LCK_CR, &lockh);
if (!rc) {
- llu_prepare_md_op_data(&op_data, inode, NULL, NULL, 0, 0);
+ llu_prep_md_op_data(&op_data, inode, NULL, NULL, 0, 0);
rc = md_enqueue(sbi->ll_md_exp, LDLM_IBITS, &it, LCK_CR,
&op_data, &lockh, NULL, 0,
}
}
-void llu_prepare_md_op_data(struct md_op_data *op_data,
- struct inode *i1,
- struct inode *i2,
- const char *name,
- int namelen,
- int mode)
+void llu_prep_md_op_data(struct md_op_data *op_data, struct inode *i1,
+ struct inode *i2, const char *name, int namelen,
+ int mode)
{
- LASSERT(op_data);
LASSERT(i1 != NULL || i2 != NULL);
+ LASSERT(op_data);
memset(op_data, 0, sizeof(*op_data));
if (i1) {
op_data->mod_time = CURRENT_TIME;
}
+void llu_finish_md_op_data(struct md_op_data *op_data)
+{
+ OBD_FREE_PTR(op_data);
+}
+
void obdo_refresh_inode(struct inode *dst,
struct obdo *src,
obd_flag valid)
extern struct fssw_ops llu_fssw_ops;
/* file.c */
-void llu_prepare_md_op_data(struct md_op_data *op_data,
- struct inode *i1,
- struct inode *i2,
- const char *name,
- int namelen,
- int mode);
+void llu_prep_md_op_data(struct md_op_data *op_data, struct inode *i1,
+ struct inode *i2, const char *name, int namelen,
+ int mode);
+void llu_finish_md_op_data(struct md_op_data *op_data);
int llu_create(struct inode *dir, struct pnode_base *pnode, int mode);
int llu_local_open(struct llu_inode_info *lli, struct lookup_intent *it);
int llu_iop_open(struct pnode *pnode, int flags, mode_t mode);
it->it_op_release = ll_intent_release;
}
- llu_prepare_md_op_data(&op_data, pnode->p_parent->p_base->pb_ino,
- pb->pb_ino, pb->pb_name.name, pb->pb_name.len,0);
+ llu_prep_md_op_data(&op_data, pnode->p_parent->p_base->pb_ino,
+ pb->pb_ino, pb->pb_name.name, pb->pb_name.len,0);
rc = md_intent_lock(exp, &op_data, NULL, 0, it, flags,
&req, llu_md_blocking_ast,
icbd.icbd_child = pnode;
icbd.icbd_parent = parent;
- llu_prepare_md_op_data(&op_data, parent, NULL,
- pnode->p_base->pb_name.name,
- pnode->p_base->pb_name.len, flags);
+ llu_prep_md_op_data(&op_data, parent, NULL,
+ pnode->p_base->pb_name.name,
+ pnode->p_base->pb_name.len, flags);
/* allocate new fid for child */
if (it->it_op & IT_CREAT ||
int rc;
ENTRY;
- llu_prepare_md_op_data(op_data, inode, NULL, NULL, 0, 0);
+ llu_prep_md_op_data(op_data, inode, NULL, NULL, 0, 0);
rc = md_setattr(sbi->ll_md_exp, op_data, NULL, 0, NULL, 0, &request);
- OBD_FREE_PTR(op_data);
if (rc) {
ptlrpc_req_finished(request);
if (llu_i2stat(dir)->st_nlink >= EXT2_LINK_MAX)
RETURN(err);
- llu_prepare_md_op_data(&op_data, dir, NULL, name, len, 0);
+ llu_prep_md_op_data(&op_data, dir, NULL, name, len, 0);
/* allocate new fid */
err = llu_fid_md_alloc(sbi, &op_data.fid2, &hint);
case S_IFBLK:
case S_IFIFO:
case S_IFSOCK:
- llu_prepare_md_op_data(&op_data, dir, NULL,
- pno->p_base->pb_name.name,
- pno->p_base->pb_name.len,
- 0);
+ llu_prep_md_op_data(&op_data, dir, NULL,
+ pno->p_base->pb_name.name,
+ pno->p_base->pb_name.len, 0);
/* allocate new fid */
err = llu_fid_md_alloc(sbi, &op_data.fid2, &hint);
if (err) {
LASSERT(dir);
liblustre_wait_event(0);
- llu_prepare_md_op_data(&op_data, src, dir, name, namelen, 0);
+ llu_prep_md_op_data(&op_data, src, dir, name, namelen, 0);
rc = md_link(llu_i2sbi(src)->ll_md_exp, &op_data, &request);
ptlrpc_req_finished(request);
liblustre_wait_event(0);
LASSERT(target);
liblustre_wait_event(0);
- llu_prepare_md_op_data(&op_data, dir, NULL, name, len, 0);
+ llu_prep_md_op_data(&op_data, dir, NULL, name, len, 0);
rc = md_unlink(llu_i2sbi(dir)->ll_md_exp, &op_data, &request);
if (!rc)
rc = llu_objects_destroy(request, dir);
LASSERT(tgt);
liblustre_wait_event(0);
- llu_prepare_md_op_data(&op_data, src, tgt, NULL, 0, 0);
+ llu_prep_md_op_data(&op_data, src, tgt, NULL, 0, 0);
rc = md_rename(llu_i2sbi(src)->ll_md_exp, &op_data,
oldname, oldnamelen, newname, newnamelen,
&request);
if (st->st_nlink >= EXT2_LINK_MAX)
RETURN(err);
- llu_prepare_md_op_data(&op_data, dir, NULL, name, len, 0);
+ llu_prep_md_op_data(&op_data, dir, NULL, name, len, 0);
/* allocate new fid */
err = llu_fid_md_alloc(llu_i2sbi(dir), &op_data.fid2, &hint);
(long long)llu_i2stat(dir)->st_ino,
llu_i2info(dir)->lli_st_generation, dir);
- llu_prepare_md_op_data(&op_data, dir, NULL, name, len, S_IFDIR);
+ llu_prep_md_op_data(&op_data, dir, NULL, name, len, S_IFDIR);
rc = md_unlink(llu_i2sbi(dir)->ll_md_exp, &op_data, &request);
ptlrpc_req_finished(request);
struct lov_user_md lum, *lump = (struct lov_user_md *)arg;
int rc = 0;
- llu_prepare_md_op_data(&op_data, ino, NULL, NULL, 0, 0);
+ llu_prep_md_op_data(&op_data, ino, NULL, NULL, 0, 0);
LASSERT(sizeof(lum) == sizeof(*lump));
LASSERT(sizeof(lum.lmm_objects[0]) ==
lli2->lli_symlink_name = NULL;
ino->i_private = lli2;
- llu_prepare_md_op_data(&data, NULL, ino, NULL, 0, O_RDWR);
+ llu_prep_md_op_data(&data, NULL, ino, NULL, 0, O_RDWR);
rc = md_enqueue(sbi->ll_md_exp, LDLM_IBITS, &oit, LCK_CR, &data,
&lockh, lum, lum_size, ldlm_completion_ast,
parent = de->d_parent->d_inode;
- OBD_ALLOC_PTR(op_data);
- if (op_data == NULL)
- RETURN(-ENOMEM);
-
if (it->it_op & IT_CREAT) {
/*
* Allocate new fid for case of create or open(O_CREAT). In both
.ph_cname = &de->d_name,
.ph_opc = LUSTRE_OPC_CREATE };
- ll_prepare_md_op_data(op_data, parent, NULL,
- de->d_name.name, de->d_name.len, 0);
+ op_data = ll_prep_md_op_data(NULL, parent, NULL,
+ de->d_name.name, de->d_name.len, 0);
+ if (op_data == NULL)
+ RETURN(-ENOMEM);
rc = ll_fid_md_alloc(ll_i2sbi(parent), &op_data->fid2,
&hint);
if (rc) {
LBUG();
}
} else {
- ll_prepare_md_op_data(op_data, parent, de->d_inode,
- de->d_name.name, de->d_name.len, 0);
+ op_data = ll_prep_md_op_data(NULL, parent, de->d_inode,
+ de->d_name.name, de->d_name.len, 0);
+ if (op_data == NULL)
+ RETURN(-ENOMEM);
}
if ((it->it_op == IT_OPEN) && de->d_inode) {
if it would be, we'll reopen the open request to
MDS later during file open path */
up(&lli->lli_och_sem);
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
RETURN(1);
} else {
up(&lli->lli_och_sem);
&req, ll_md_blocking_ast, 0);
it->it_flags &= ~O_CHECK_STALE;
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
/* If req is NULL, then md_intent_lock only tried to do a lock match;
* if all was well, it will return 1 if it found locks, 0 otherwise. */
if (req == NULL && rc >= 0) {
it = &lookup_it;
}
- OBD_ALLOC_PTR(op_data);
+ /* do real lookup here */
+ op_data = ll_prep_md_op_data(NULL, parent, NULL,
+ de->d_name.name, de->d_name.len, 0);
if (op_data == NULL)
RETURN(-ENOMEM);
-
- /* do real lookup here */
- ll_prepare_md_op_data(op_data, parent, NULL,
- de->d_name.name, de->d_name.len, 0);
if (it->it_op & IT_CREAT) {
/*
sizeof(*mdt_body));
/* see if we got same inode, if not - return error */
if(lu_fid_eq(&op_data->fid2, &mdt_body->fid1)) {
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
+ op_data = NULL;
goto revalidate_finish;
}
ll_intent_release(it);
}
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
GOTO(out, rc = 0);
}
struct ptlrpc_request *request;
struct md_op_data *op_data;
- OBD_ALLOC_PTR(op_data);
+ op_data = ll_prep_md_op_data(NULL, dir, NULL, NULL, 0, 0);
if (op_data == NULL)
return ERR_PTR(-ENOMEM);
- ll_prepare_md_op_data(op_data, dir, NULL, NULL, 0, 0);
-
rc = md_enqueue(ll_i2sbi(dir)->ll_md_exp, LDLM_IBITS, &it,
LCK_CR, op_data, &lockh, NULL, 0,
ldlm_completion_ast, ll_md_blocking_ast, dir,
0);
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
request = (struct ptlrpc_request *)it.d.lustre.it_data;
if (request)
struct md_op_data *op_data;
int rc = 0;
- OBD_ALLOC_PTR(op_data);
- if (op_data == NULL)
- RETURN(-ENOMEM);
-
LASSERT(sizeof(lum) == sizeof(*lump));
LASSERT(sizeof(lum.lmm_objects[0]) ==
sizeof(lump->lmm_objects[0]));
lustre_swab_lov_user_md(&lum);
/* swabbing is done in lov_setstripe() on server side */
- ll_prepare_md_op_data(op_data, inode, NULL, NULL, 0, 0);
+ op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0);
+ if (op_data == NULL)
+ RETURN(-ENOMEM);
rc = md_setattr(sbi->ll_md_exp, op_data, &lum,
sizeof(lum), NULL, 0, &request);
ll_finish_md_op_data(op_data);
if (rc != -EPERM && rc != -EACCES)
CERROR("md_setattr fails: rc = %d\n", rc);
}
- OBD_FREE_PTR(op_data);
ptlrpc_req_finished(request);
RETURN(rc);
}
struct lustre_handle *fh)
{
op_data->fid1 = ll_i2info(inode)->lli_fid;
+ op_data->mod_capa1 = ll_i2mdscapa(inode);
op_data->attr.ia_atime = inode->i_atime;
op_data->attr.ia_mtime = inode->i_mtime;
op_data->attr.ia_ctime = inode->i_ctime;
rc = md_close(md_exp, op_data, och, &req);
ll_finish_md_op_data(op_data);
- OBD_FREE_PTR(op_data);
if (rc == -EAGAIN) {
/* This close must have closed the epoch. */
LASSERT(epoch_close);
if (!parent)
RETURN(-ENOENT);
- OBD_ALLOC_PTR(op_data);
- if (op_data == NULL)
- RETURN(-ENOMEM);
-
/* Usually we come here only for NFSD, and we want open lock.
But we can also get here with pre 2.6.15 patchless kernels, and in
that case that lock is also ok */
if (!lmm && !lmmsize)
itp->it_flags |= MDS_OPEN_LOCK;
- ll_prepare_md_op_data(op_data, parent->d_inode, NULL,
- name, len, O_RDWR);
+ op_data = ll_prep_md_op_data(NULL, parent->d_inode, NULL, name, len,
+ O_RDWR);
+ if (op_data == NULL)
+ RETURN(-ENOMEM);
rc = md_enqueue(sbi->ll_md_exp, LDLM_IBITS, itp, LCK_PW, op_data,
&lockh, lmm, lmmsize, ldlm_completion_ast,
ll_md_blocking_ast, NULL, 0);
ll_finish_md_op_data(op_data);
- OBD_FREE_PTR(op_data);
if (rc < 0) {
CERROR("lock enqueue: err: %d\n", rc);
RETURN(rc);
tail_inode = tail_dentry->d_inode;
tail_parent = tail_dentry->d_parent->d_inode;
- OBD_ALLOC_PTR(op_data);
- if (op_data == NULL) {
+ op_data = ll_prep_md_op_data(NULL, head_inode, tail_parent,
+ tail_dentry->d_name.name,
+ tail_dentry->d_name.len, 0);
+ if (op_data == NULL)
RETURN(-ENOMEM);
- }
-
- ll_prepare_md_op_data(op_data, head_inode, tail_parent,
- tail_dentry->d_name.name,
- tail_dentry->d_name.len, 0);
rc = md_enqueue(ll_i2mdexp(head_inode), LDLM_IBITS, &oit, LCK_PW,
op_data, &lockh, &tsize, 0, ldlm_completion_ast,
ll_md_blocking_ast, &hsize, 0);
+ ll_finish_md_op_data(op_data);
if (rc < 0)
GOTO(out, rc);
}
ll_release_openhandle(head_filp->f_dentry, &oit);
out:
- if (op_data)
- OBD_FREE_PTR(op_data);
ll_intent_release(&oit);
RETURN(rc);
}
struct lookup_intent oit = { .it_op = IT_GETATTR };
struct md_op_data *op_data;
- OBD_ALLOC_PTR(op_data);
+ /* Call getattr by fid, so do not provide name at all. */
+ op_data = ll_prep_md_op_data(NULL, dentry->d_parent->d_inode,
+ dentry->d_inode, NULL, 0, 0);
if (op_data == NULL)
RETURN(-ENOMEM);
-
- /* Call getattr by fid, so do not provide name at all. */
- ll_prepare_md_op_data(op_data, dentry->d_parent->d_inode,
- dentry->d_inode, NULL, 0, 0);
it->it_flags |= O_CHECK_STALE;
rc = md_intent_lock(exp, op_data, NULL, 0,
/* we are not interested in name
based lookup */
&oit, 0, &req,
ll_md_blocking_ast, 0);
+ ll_finish_md_op_data(op_data);
it->it_flags &= ~ O_CHECK_STALE;
- OBD_FREE_PTR(op_data);
if (rc < 0) {
rc = ll_inode_revalidate_fini(inode, rc);
GOTO (out, rc);
static int inode_have_md_lock(struct inode *inode, __u64 inodebits)
{
struct obd_export *exp = ll_i2mdexp(inode);
- struct lustre_handle lockh;
- struct ldlm_res_id res_id = { .name = {0} };
ldlm_policy_data_t policy = { .l_inodebits = {inodebits}};
- int flags, rc;
+ struct lustre_handle lockh;
+ int flags = LDLM_FL_BLOCK_GRANTED|LDLM_FL_CBPENDING|LDLM_FL_TEST_LOCK;
+ int rc;
ENTRY;
- res_id.name[0] = inode->i_ino;
- res_id.name[1] = inode->i_generation;
-
- CDEBUG(D_SEC, "trying to match res "LPU64"\n", res_id.name[0]);
-
- flags = LDLM_FL_BLOCK_GRANTED | LDLM_FL_CBPENDING | LDLM_FL_TEST_LOCK;
- rc = ldlm_lock_match(exp->exp_obd->obd_namespace, flags, &res_id,
- LDLM_IBITS, &policy, LCK_CR|LCK_CW|LCK_PR, &lockh);
+ rc = md_lock_match(exp, flags, ll_inode2fid(inode),
+ LDLM_IBITS, &policy, LCK_CR|LCK_CW|LCK_PR, &lockh);
RETURN(rc);
}
!ll_have_md_lock(ocapa->u.cli.inode,
MDS_INODELOCK_LOOKUP) &&
!obd_capa_is_root(ocapa)) {
- /* fid capa without LOOKUP lock won't renew,
+ /* MDS capa without LOOKUP lock won't renew,
* move to idle list (except root fid) */
DEBUG_CAPA(D_SEC, &ocapa->c_capa,
"skip renewal for");
struct obd_capa *ll_i2mdscapa(struct inode *inode)
{
struct obd_capa *ocapa;
+ struct ll_inode_info *lli = ll_i2info(inode);
+ ENTRY;
LASSERT(inode);
if ((ll_i2sbi(inode)->ll_flags & LL_SBI_MDS_CAPA) == 0)
- return NULL;
+ RETURN(NULL);
spin_lock(&capa_lock);
- ocapa = capa_get(ll_i2info(inode)->lli_mds_capa);
+ 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");
atomic_set(&ll_capa_debug, 0);
}
- return ocapa;
+ RETURN(ocapa);
}
static inline int do_add_mds_capa(struct inode *inode, struct obd_capa **pcapa)
obd_capa_clear_new(ocapa);
obd_capa_set_valid(ocapa);
- DEBUG_CAPA(D_SEC, &ocapa->c_capa, "add fid");
+ DEBUG_CAPA(D_SEC, &ocapa->c_capa, "add MDS");
} else {
if (ocapa->c_capa.lc_expiry == old->c_capa.lc_expiry) {
rc = -EEXIST;
obd_capa_set_valid(old);
spin_unlock(&old->c_lock);
- DEBUG_CAPA(D_SEC, &old->c_capa, "update fid");
+ DEBUG_CAPA(D_SEC, &old->c_capa, "update MDS");
}
free_capa(ocapa);
INIT_LIST_HEAD(&ocapa->u.cli.lli_list);
obd_capa_set_valid(ocapa);
- DEBUG_CAPA(D_SEC, capa, "add oss");
+ DEBUG_CAPA(D_SEC, capa, "add OSS");
} else {
if (old->c_capa.lc_expiry == capa->lc_expiry) {
rc = -EEXIST;
obd_capa_set_valid(old);
spin_unlock(&old->c_lock);
- DEBUG_CAPA(D_SEC, capa, "update oss");
+ DEBUG_CAPA(D_SEC, capa, "update OSS");
}
free_capa(ocapa);
if (oa)
obdo_free(oa);
if (op_data)
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
return rc;
}
ll_pack_inode2opdata(inode, op_data, &och->och_fh);
rc = md_done_writing(ll_i2sbi(inode)->ll_md_exp, op_data, och);
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
if (rc == -EAGAIN) {
/* MDS has instructed us to obtain Size-on-MDS attribute from
* OSTs and send setattr to back to MDS. */
int ll_process_config(struct lustre_cfg *lcfg);
int ll_ioctl_getfacl(struct inode *inode, struct rmtacl_ioctl_data *ioc);
int ll_ioctl_setfacl(struct inode *inode, struct rmtacl_ioctl_data *ioc);
-void ll_prepare_md_op_data(struct md_op_data *op_data, struct inode *i1,
- struct inode *i2, const char *name, int namelen,
- int mode);
+struct md_op_data *ll_prep_md_op_data(struct md_op_data *op_data,
+ struct inode *i1, struct inode *i2,
+ const char *name, int namelen,
+ int mode);
void ll_finish_md_op_data(struct md_op_data *op_data);
/* llite/llite_nfs.c */
struct ll_sb_info *sbi = ll_s2sbi(sb);
struct obd_device *obd;
struct lu_fid rootfid;
- struct obd_capa *pc = NULL;
+ struct obd_capa *oc = NULL;
struct obd_statfs osfs;
struct ptlrpc_request *request = NULL;
struct lustre_handle dt_conn = {0, };
struct lustre_handle md_conn = {0, };
struct obd_connect_data *data = NULL;
struct lustre_md lmd;
- int err;
+ int size, err;
ENTRY;
obd = class_name2obd(md);
/* indicate the features supported by this client */
data->ocd_connect_flags = OBD_CONNECT_IBITS | OBD_CONNECT_NODEVOH |
OBD_CONNECT_ACL | OBD_CONNECT_JOIN |
- OBD_CONNECT_ATTRFID | OBD_CONNECT_VERSION;/* |
- OBD_CONNECT_MDS_CAPA | OBD_CONNECT_OSS_CAPA;*/
+ OBD_CONNECT_ATTRFID | OBD_CONNECT_VERSION |
+ OBD_CONNECT_MDS_CAPA | OBD_CONNECT_OSS_CAPA;
data->ocd_ibits_known = MDS_INODELOCK_FULL;
data->ocd_version = LUSTRE_VERSION_CODE;
if (err)
GOTO(out_md, err);
+ size = sizeof(*data);
+ err = obd_get_info(sbi->ll_md_exp, strlen(KEY_CONN_DATA), KEY_CONN_DATA,
+ &size, data);
+ if (err) {
+ CERROR("Get connect data failed: %d \n", err);
+ GOTO(out_md, err);
+ }
+
LASSERT(osfs.os_bsize);
sb->s_blocksize = osfs.os_bsize;
sb->s_blocksize_bits = log2(osfs.os_bsize);
}
if (data->ocd_connect_flags & OBD_CONNECT_MDS_CAPA) {
- CDEBUG(D_SEC, "client enabled fid capa!\n");
+ CDEBUG(D_SEC, "client enabled MDS capability!\n");
sbi->ll_flags |= LL_SBI_MDS_CAPA;
}
if (data->ocd_connect_flags & OBD_CONNECT_OSS_CAPA) {
- CDEBUG(D_SEC, "client enabled oss capa!\n");
+ CDEBUG(D_SEC, "client enabled OSS capability!\n");
sbi->ll_flags |= LL_SBI_OSS_CAPA;
}
GOTO(out_dt, err);
}
- err = md_getstatus(sbi->ll_md_exp, &rootfid, &pc);
+ err = md_getstatus(sbi->ll_md_exp, &rootfid, &oc);
if (err) {
CERROR("cannot mds_connect: rc = %d\n", err);
GOTO(out_dt_fid, err);
/* make root inode
* XXX: move this to after cbd setup? */
- err = md_getattr(sbi->ll_md_exp, &rootfid, pc,
- OBD_MD_FLGETATTR | OBD_MD_FLBLOCKS |
+ err = md_getattr(sbi->ll_md_exp, &rootfid, oc,
+ OBD_MD_FLGETATTR | OBD_MD_FLBLOCKS | OBD_MD_FLMDSCAPA |
(sbi->ll_flags & LL_SBI_ACL ? OBD_MD_FLACL : 0),
0, &request);
+ if (oc)
+ free_capa(oc);
if (err) {
CERROR("md_getattr failed for root: rc = %d\n", err);
- if (pc)
- free_capa(pc);
GOTO(out_dt, err);
}
&lmd);
if (err) {
CERROR("failed to understand root inode md: rc = %d\n", err);
- if (pc)
- free_capa(pc);
ptlrpc_req_finished (request);
GOTO(out_dt, err);
}
- if (pc) {
- obd_capa_set_root(pc);
- lmd.mds_capa = pc;
- lmd.body->valid |= OBD_MD_FLMDSCAPA;
- }
+ if (lmd.mds_capa)
+ obd_capa_set_root(lmd.mds_capa);
LASSERT(fid_is_sane(&sbi->ll_root_fid));
root = ll_iget(sb, ll_fid_build_ino(sbi, &sbi->ll_root_fid), &lmd);
ptlrpc_req_finished(request);
int rc;
ENTRY;
- ll_prepare_md_op_data(op_data, inode, NULL, NULL, 0, 0);
+ op_data = ll_prep_md_op_data(op_data, inode, NULL, NULL, 0, 0);
rc = md_setattr(sbi->ll_md_exp, op_data, NULL, 0, NULL, 0, &request);
if (rc) {
ptlrpc_req_finished(request);
if (op_data) {
if (op_data->ioepoch)
rc = ll_setattr_done_writing(inode, op_data);
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
}
return rc;
}
}
LASSERT(fid_seq(&lli->lli_fid) != 0);
+
+ if (body->valid & OBD_MD_FLMDSCAPA) {
+ LASSERT(md->mds_capa);
+ ll_add_capa(inode, md->mds_capa);
+ }
+ if (body->valid & OBD_MD_FLOSSCAPA) {
+ LASSERT(md->oss_capa);
+ ll_add_capa(inode, md->oss_capa);
+ }
}
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0))
if (!oinfo.oi_oa)
RETURN(-ENOMEM);
- OBD_ALLOC_PTR(op_data);
+ op_data = ll_prep_md_op_data(NULL, inode, NULL, NULL, 0, 0);
if (op_data == NULL)
RETURN(-ENOMEM);
- ll_prepare_md_op_data(op_data, inode, NULL, NULL, 0, 0);
-
((struct ll_iattr *)&op_data->attr)->ia_attr_flags = flags;
op_data->attr.ia_valid |= ATTR_ATTR_FLAG;
rc = md_setattr(sbi->ll_md_exp, op_data,
NULL, 0, NULL, 0, &req);
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
ptlrpc_req_finished(req);
if (rc || lsm == NULL) {
obdo_free(oinfo.oi_oa);
}
/* this function prepares md_op_data hint for passing ot down to MD stack. */
-void ll_prepare_md_op_data(struct md_op_data *op_data, struct inode *i1,
- struct inode *i2, const char *name, int namelen,
- int mode)
+struct md_op_data *
+ll_prep_md_op_data(struct md_op_data *op_data, struct inode *i1,
+ struct inode *i2, const char *name, int namelen, int mode)
{
LASSERT(i1 != NULL);
- LASSERT(op_data != NULL);
+
+ if (!op_data)
+ OBD_ALLOC_PTR(op_data);
+ if (!op_data)
+ return NULL;
ll_i2gids(op_data->suppgids, i1, i2);
op_data->fid1 = ll_i2info(i1)->lli_fid;
op_data->fsuid = current->fsuid;
op_data->fsgid = current->fsgid;
op_data->cap = current->cap_effective;
+
+ return op_data;
}
void ll_finish_md_op_data(struct md_op_data *op_data)
{
capa_put(op_data->mod_capa1);
capa_put(op_data->mod_capa2);
+ OBD_FREE_PTR(op_data);
}
int ll_ioctl_getfacl(struct inode *inode, struct rmtacl_ioctl_data *ioc)
icbd.icbd_childp = &dentry;
icbd.icbd_parent = parent;
- OBD_ALLOC_PTR(op_data);
- if (op_data == NULL)
- RETURN(ERR_PTR(-ENOMEM));
-
/* prepare operatoin hint first */
- ll_prepare_md_op_data(op_data, parent, NULL, dentry->d_name.name,
- dentry->d_name.len, lookup_flags);
+ op_data = ll_prep_md_op_data(NULL, parent, NULL, dentry->d_name.name,
+ dentry->d_name.len, lookup_flags);
+ if (op_data == NULL)
+ RETURN(ERR_PTR(-ENOMEM));
/* allocate new fid for child */
if (it->it_op & IT_CREAT ||
rc = md_intent_lock(ll_i2mdexp(parent), op_data, NULL, 0, it,
lookup_flags, &req, ll_md_blocking_ast, 0);
- OBD_FREE_PTR(op_data);
-
+ ll_finish_md_op_data(op_data);
if (rc < 0)
GOTO(out, retval = ERR_PTR(rc));
case S_IFBLK:
case S_IFIFO:
case S_IFSOCK:
- OBD_ALLOC_PTR(op_data);
+ op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name,
+ name->len, 0);
if (op_data == NULL)
RETURN(-ENOMEM);
- ll_prepare_md_op_data(op_data, dir, NULL, name->name,
- name->len, 0);
err = ll_fid_md_alloc(sbi, &op_data->fid2, &hint);
- if (err)
+ if (err) {
+ ll_finish_md_op_data(op_data);
break;
+ }
err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
current->fsuid, current->fsgid,
current->cap_effective, rdev, &request);
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
if (err)
break;
ll_update_times(request, REPLY_REC_OFF, dir);
name->len, name->name, dir->i_ino, dir->i_generation,
dir, tgt);
- OBD_ALLOC_PTR(op_data);
+ op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name, name->len, 0);
if (op_data == NULL)
RETURN(-ENOMEM);
-
- ll_prepare_md_op_data(op_data, dir, NULL,
- name->name, name->len, 0);
/* allocate new fid */
err = ll_fid_md_alloc(ll_i2sbi(dir), &op_data->fid2, &hint);
tgt, strlen(tgt) + 1, S_IFLNK | S_IRWXUGO,
current->fsuid, current->fsgid, current->cap_effective,
0, &request);
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
if (err == 0) {
ll_update_times(request, REPLY_REC_OFF, dir);
src->i_ino, src->i_generation, src, dir->i_ino,
dir->i_generation, dir, name->len, name->name);
- OBD_ALLOC_PTR(op_data);
+ op_data = ll_prep_md_op_data(NULL, src, dir, name->name, name->len, 0);
if (op_data == NULL)
RETURN(-ENOMEM);
- ll_prepare_md_op_data(op_data, src, dir, name->name,
- name->len, 0);
err = md_link(sbi->ll_md_exp, op_data, &request);
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
if (err == 0)
ll_update_times(request, REPLY_REC_OFF, dir);
mode = (mode & (S_IRWXUGO|S_ISVTX) & ~current->fs->umask) | S_IFDIR;
- OBD_ALLOC_PTR(op_data);
+ op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name, name->len, 0);
if (op_data == NULL)
RETURN(-ENOMEM);
- ll_prepare_md_op_data(op_data, dir, NULL,
- name->name, name->len, 0);
/* allocate new fid */
err = ll_fid_md_alloc(ll_i2sbi(dir), &op_data->fid2, &hint);
err = md_create(sbi->ll_md_exp, op_data, NULL, 0, mode,
current->fsuid, current->fsgid,
current->cap_effective, 0, &request);
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
ll_update_times(request, REPLY_REC_OFF, dir);
if (!err && dchild) {
err = ll_prep_inode(&inode, request, REPLY_REC_OFF,
}
}
- OBD_ALLOC_PTR(op_data);
+ op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name, name->len,
+ S_IFDIR);
if (op_data == NULL)
RETURN(-ENOMEM);
-
- ll_prepare_md_op_data(op_data, dir, NULL, name->name,
- name->len, S_IFDIR);
rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
if (rc == 0)
ll_update_times(request, REPLY_REC_OFF, dir);
ptlrpc_req_finished(request);
CDEBUG(D_VFSTRACE, "VFS Op:name=%.*s,dir=%lu/%u(%p)\n",
name->len, name->name, dir->i_ino, dir->i_generation, dir);
- OBD_ALLOC_PTR(op_data);
+ op_data = ll_prep_md_op_data(NULL, dir, NULL, name->name, name->len, 0);
if (op_data == NULL)
RETURN(-ENOMEM);
-
- ll_prepare_md_op_data(op_data, dir, NULL, name->name, name->len, 0);
rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
if (rc)
GOTO(out, rc);
src->i_ino, src->i_generation, src, tgt_name->len,
tgt_name->name, tgt->i_ino, tgt->i_generation, tgt);
- OBD_ALLOC_PTR(op_data);
+ op_data = ll_prep_md_op_data(NULL, src, tgt, NULL, 0, 0);
if (op_data == NULL)
RETURN(-ENOMEM);
-
- ll_prepare_md_op_data(op_data, src, tgt, NULL, 0, 0);
err = md_rename(sbi->ll_md_exp, op_data,
src_name->name, src_name->len,
tgt_name->name, tgt_name->len, &request);
- OBD_FREE_PTR(op_data);
+ ll_finish_md_op_data(op_data);
if (!err) {
ll_update_times(request, REPLY_REC_OFF, src);
ll_update_times(request, REPLY_REC_OFF, tgt);
RETURN(0);
}
RETURN(-EINVAL);
- } else if (keylen >= strlen("max_easize") && !strcmp(key, "max_easize")) {
-
+ } else if (KEY_IS(KEY_MAX_EASIZE) || KEY_IS(KEY_CONN_DATA)) {
rc = lmv_check_connect(obd);
if (rc)
RETURN(rc);
size[DLM_INTENT_REC_OFF] = sizeof(struct mdt_body);
size[DLM_INTENT_REC_OFF + 1] = op_data->mod_capa1 ?
sizeof(struct lustre_capa) : 0;
+ if (op_data->mod_capa1)
+ valid |= OBD_MD_FLMDSCAPA;
size[DLM_INTENT_REC_OFF + 2] = op_data->namelen + 1;
if (it->it_op & IT_GETATTR)
capa = lustre_unpack_capa(req->rq_repmsg, reply_off++);
if (capa == NULL) {
- CERROR("Missing/short client fid capa\n");
+ CERROR("Missing/short MDS capability\n");
RETURN(-EPROTO);
}
capa = lustre_unpack_capa(req->rq_repmsg, reply_off++);
if (capa == NULL) {
- CERROR("Missing/short client oss capa\n");
+ CERROR("Missing/short OSS capability\n");
RETURN(-EPROTO);
}
}
* of fields. This issue will be fixed later when client gets awar of RPC
* layouts. --umka
*/
-static
-int mdc_getattr_common(struct obd_export *exp, unsigned int ea_size,
- unsigned int acl_size, struct ptlrpc_request *req)
+static int mdc_getattr_common(struct obd_export *exp, unsigned int ea_size,
+ unsigned int acl_size, int mdscapa,
+ struct ptlrpc_request *req)
{
struct mdt_body *body;
void *eadata;
int size[5] = { sizeof(struct ptlrpc_body),
- sizeof(*body) };
- int bufcount = 2, rc;
+ sizeof(*body),
+ ea_size,
+ acl_size };
+ int offset, rc;
ENTRY;
/* Request message already built. */
- if (ea_size != 0) {
- size[bufcount++] = ea_size;
+ if (ea_size)
CDEBUG(D_INODE, "reserved %u bytes for MD/symlink in packet\n",
ea_size);
- }
-
- if (acl_size) {
- size[bufcount++] = acl_size;
+ if (acl_size)
CDEBUG(D_INODE, "reserved %u bytes for ACL\n", acl_size);
- }
+ if (mdscapa)
+ size[REPLY_REC_OFF + 2] = sizeof(struct lustre_capa);
- size[bufcount++] = sizeof(struct lustre_capa);
- ptlrpc_req_set_repsize(req, bufcount, size);
+ ptlrpc_req_set_repsize(req, 5, size);
rc = ptlrpc_queue_wait(req);
if (rc != 0)
CDEBUG(D_NET, "mode: %o\n", body->mode);
- LASSERT_REPSWAB(req, REPLY_REC_OFF + 1);
+ offset = REPLY_REC_OFF + 1;
+ LASSERT_REPSWAB(req, offset);
if (body->eadatasize != 0) {
/* reply indicates presence of eadata; check it's there... */
- eadata = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1,
+ eadata = lustre_msg_buf(req->rq_repmsg, offset++,
body->eadatasize);
if (eadata == NULL) {
CERROR ("Missing/short eadata\n");
}
if (body->valid & OBD_MD_FLMODEASIZE) {
- if (exp->exp_obd->u.cli.cl_max_mds_easize < body->max_mdsize)
- exp->exp_obd->u.cli.cl_max_mds_easize =
- body->max_mdsize;
- if (exp->exp_obd->u.cli.cl_max_mds_cookiesize <
- body->max_cookiesize)
- exp->exp_obd->u.cli.cl_max_mds_cookiesize =
- body->max_cookiesize;
+ struct client_obd *cli = &exp->exp_obd->u.cli;
+
+ if (cli->cl_max_mds_easize < body->max_mdsize)
+ cli->cl_max_mds_easize = body->max_mdsize;
+ if (cli->cl_max_mds_cookiesize < body->max_cookiesize)
+ cli->cl_max_mds_cookiesize = body->max_cookiesize;
+ }
+
+ offset += !!body->aclsize;
+
+ if (body->valid & OBD_MD_FLMDSCAPA) {
+ struct lustre_capa *capa;
+
+ LASSERT(mdscapa);
+ capa = lustre_unpack_capa(req->rq_repmsg, offset++);
+ if (capa == NULL) {
+ CERROR("Missing/short client MDS capability\n");
+ RETURN(-EPROTO);
+ }
}
RETURN (0);
if (valid & OBD_MD_FLACL)
acl_size = LUSTRE_POSIX_ACL_MAX_SIZE;
- rc = mdc_getattr_common(exp, ea_size, acl_size, req);
+ rc = mdc_getattr_common(exp, ea_size, acl_size,
+ !!(valid & OBD_MD_FLMDSCAPA), req);
if (rc != 0) {
ptlrpc_req_finished (req);
req = NULL;
memcpy(lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF + 2, namelen),
filename, namelen);
- rc = mdc_getattr_common(exp, ea_size, 0, req);
+ rc = mdc_getattr_common(exp, ea_size, 0, !!(valid & OBD_MD_FLMDSCAPA),
+ req);
if (rc != 0) {
ptlrpc_req_finished (req);
req = NULL;
struct obd_export *md_exp,
struct lustre_md *md)
{
- int rc = 0;
+ int rc;
ENTRY;
LASSERT(md);
LASSERT_REPSWABBED(req, offset);
offset++;
- if (!(md->body->valid & OBD_MD_FLEASIZE) &&
- !(md->body->valid & OBD_MD_FLDIREA))
- RETURN(0);
-
if (md->body->valid & OBD_MD_FLEASIZE) {
int lmmsize;
struct lov_mds_md *lmm;
LASSERT(S_ISREG(md->body->mode));
if (md->body->eadatasize == 0) {
- CERROR ("OBD_MD_FLEASIZE set, but eadatasize 0\n");
+ CERROR("OBD_MD_FLEASIZE set, but eadatasize 0\n");
RETURN(-EPROTO);
}
lmmsize = md->body->eadatasize;
RETURN(rc);
LASSERT (rc >= sizeof (*md->lsm));
- rc = 0;
-
offset++;
} else if (md->body->valid & OBD_MD_FLDIREA) {
int lmvsize;
LASSERT(S_ISDIR(md->body->mode));
if (md->body->eadatasize == 0) {
- RETURN(0);
+ CERROR("OBD_MD_FLEASIZE set, but eadatasize 0\n");
+ RETURN(-EPROTO);
}
if (md->body->valid & OBD_MD_MEA) {
lmvsize = md->body->eadatasize;
LASSERT (rc >= sizeof (*md->mea));
}
- rc = 0;
- offset ++;
+ offset++;
}
+ rc = 0;
/* for ACL, it's possible that FLACL is set but aclsize is zero. only
* when aclsize != 0 there's an actual segment for ACL in reply
* buffer. */
if ((md->body->valid & OBD_MD_FLACL) && md->body->aclsize) {
- rc = mdc_unpack_acl(dt_exp, req, md, offset);
+ rc = mdc_unpack_acl(dt_exp, req, md, offset++);
if (rc)
GOTO(out, rc);
- offset++;
}
/* remote permission */
if (md->body->valid & OBD_MD_FLRMTPERM) {
- md->remote_perm = lustre_msg_buf(req->rq_repmsg, offset,
+ md->remote_perm = lustre_msg_buf(req->rq_repmsg, offset++,
sizeof(struct mdt_remote_perm));
LASSERT(md->remote_perm);
- offset++;
}
if (md->body->valid & OBD_MD_FLMDSCAPA) {
- struct obd_capa *oc = mdc_unpack_capa(req, offset);
+ struct obd_capa *oc = mdc_unpack_capa(req, offset++);
if (IS_ERR(oc))
GOTO(out, rc = PTR_ERR(oc));
md->mds_capa = oc;
- offset++;
}
if (md->body->valid & OBD_MD_FLOSSCAPA) {
- struct obd_capa *oc = mdc_unpack_capa(req, offset);
+ struct obd_capa *oc = mdc_unpack_capa(req, offset++);
if (IS_ERR(oc))
GOTO(out, rc = PTR_ERR(oc));
md->oss_capa = oc;
- offset++;
}
EXIT;
{
int rc = -EINVAL;
- if (keylen == strlen("max_easize") &&
- memcmp(key, "max_easize", strlen("max_easize")) == 0) {
+ if (KEY_IS(KEY_MAX_EASIZE)) {
int mdsize, *max_easize;
if (*vallen != sizeof(int))
*max_easize = exp->exp_obd->u.cli.cl_max_mds_easize;
RETURN(0);
}
+ if (KEY_IS(KEY_CONN_DATA)) {
+ struct obd_import *imp = class_exp2cliimp(exp);
+ struct obd_connect_data *data = val;
+
+ if (*vallen != sizeof(*data))
+ RETURN(-EINVAL);
+
+ *data = imp->imp_connect_data;
+ RETURN(0);
+ }
+
RETURN(rc);
}
capa->lc_flags |= CAPA_FL_SHORT_EXPIRY;
if (lu_fid_eq(&capa->lc_fid, &mdd->mdd_root_fid))
capa->lc_flags |= CAPA_FL_ROOT;
- capa->lc_flags = ls->ls_capa_alg << 23;
+ capa->lc_flags = ls->ls_capa_alg << 24;
/* TODO: get right permission here after remote uid landing */
ocapa = capa_lookup(capa);
buffer = req_capsule_server_get(pill, &RMF_ACL);
/* mdt_getattr_lock only */
rc = mdt_pack_remote_perm(info, o, buffer);
- if (rc) {
+ if (rc)
RETURN(rc);
- } else {
- repbody->valid |= OBD_MD_FLRMTPERM;
- repbody->aclsize = sizeof(struct mdt_remote_perm);
- }
+ repbody->valid |= OBD_MD_FLRMTPERM;
+ repbody->aclsize = sizeof(struct mdt_remote_perm);
}
#ifdef CONFIG_FS_POSIX_ACL
else if ((req->rq_export->exp_connect_flags & OBD_CONNECT_ACL) &&
}
#endif
- if (mdt->mdt_opts.mo_mds_capa) {
+ if ((reqbody->valid & OBD_MD_FLMDSCAPA) && mdt->mdt_opts.mo_mds_capa) {
struct lustre_capa *capa;
spin_lock(&capa_lock);
rc = mo_capa_get(ctxt, next, capa);
if (rc)
RETURN(rc);
- else
- repbody->valid |= OBD_MD_FLMDSCAPA;
+ repbody->valid |= OBD_MD_FLMDSCAPA;
}
RETURN(rc);
static int mdt_renew_capa(struct mdt_thread_info *info)
{
struct mdt_device *mdt = info->mti_mdt;
- struct mdt_object *obj;
+ struct mdt_object *obj = info->mti_object;
struct mdt_body *body;
- struct lustre_capa *capa;
+ struct lustre_capa *capa;
int rc;
+ ENTRY;
body = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
LASSERT(body);
info->mti_capa_key = *red_capa_key(mdt);
spin_unlock(&capa_lock);
- obj = mdt_object_find(info->mti_ctxt, info->mti_mdt, &capa->lc_fid,
- capa);
- if (!IS_ERR(obj))
- rc = PTR_ERR(obj);
-
+ *capa = obj->mot_header.loh_capa;
/* TODO: add capa check */
rc = mo_capa_get(info->mti_ctxt, mdt_object_child(obj), capa);
if (rc)
sizeof(*repbody));
memcpy(&repbody->oa, &body->oa, sizeof(body->oa));
if (body->oa.o_valid & OBD_MD_FLOSSCAPA)
- capa = lustre_unpack_capa(req->rq_repmsg, REQ_REC_OFF + 1);
+ capa = lustre_unpack_capa(req->rq_reqmsg, REQ_REC_OFF + 1);
req->rq_status = obd_destroy(exp, &body->oa, NULL, oti, NULL, capa);
RETURN(0);
}
}
snprintf(filepnm, sizeof(filepnm) - 1, "%s/%s", mntpt, CAPA_KEYS);
- ret = iam_creat(filepnm, FMT_LFIX, L_BLOCK_SIZE, 1, 1, 4);
+ ret = touch_file(filepnm);
if (ret) {
goto out_umount;
}
git://git.whamcloud.com / fs / lustre-release.git / commitdiff