OBD_CONNECT_MDS_CAPA |
OBD_CONNECT_OSS_CAPA |
OBD_CONNECT_IBITS |
- OBD_CONNECT_MDS_MDS;
+ OBD_CONNECT_MDS_MDS |
+ OBD_CONNECT_FID;
rc = obd_connect(env, conn, mdc, &mdc->obd_uuid, ocd);
OBD_FREE_PTR(ocd);
if (rc) {
mci = mdc_info_get(env);
req = mci->mci_req;
LASSERT(req);
- body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*body));
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
LASSERT(body);
mdc_body2attr(body, ma);
struct lustre_capa *capa;
/* create for cross-ref will fetch mds capa from remote obj */
- capa = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1,
- sizeof(*capa));
+ capa = req_capsule_server_get(&req->rq_pill, &RMF_CAPA1);
LASSERT(capa != NULL);
LASSERT(ma->ma_capa != NULL);
*ma->ma_capa = *capa;
RETURN(-EPROTO);
}
- lov = lustre_swab_repbuf(req, REPLY_REC_OFF + 1,
- body->eadatasize, NULL);
- if (lov == NULL) {
- CERROR("Can't unpack MDS EA data\n");
+ lov = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD,
+ body->eadatasize);
+ if (lov == NULL)
RETURN(-EPROTO);
- }
LASSERT(ma->ma_lmm != NULL);
LASSERT(ma->ma_lmm_size >= body->eadatasize);
RETURN(-EPROTO);
}
- cookie = lustre_msg_buf(req->rq_repmsg,
- REPLY_REC_OFF + 2, body->aclsize);
- if (cookie == NULL) {
- CERROR("Can't unpack unlink cookie data\n");
+ cookie = req_capsule_server_sized_get(&req->rq_pill, &RMF_ACL,
+ body->aclsize);
+ if (cookie == NULL)
RETURN(-EPROTO);
- }
LASSERT(ma->ma_cookie != NULL);
LASSERT(ma->ma_cookie_size == body->aclsize);
rc = md_is_subdir(mc->mc_desc.cl_exp, lu_object_fid(&mo->mo_lu),
fid, &mci->mci_req);
if (rc == 0 || rc == -EREMOTE) {
- body = lustre_msg_buf(mci->mci_req->rq_repmsg, REPLY_REC_OFF,
- sizeof(*body));
+ body = req_capsule_server_get(&mci->mci_req->rq_pill,
+ &RMF_MDT_BODY);
LASSERT(body->valid & OBD_MD_FLID);
CDEBUG(D_INFO, "Remote mdo_is_subdir(), new src "DFID"\n",
site = req->rq_export->exp_obd->obd_lu_dev->ld_site;
LASSERT(site != NULL);
- rc = req_capsule_pack(&info->sti_pill);
+ rc = req_capsule_server_pack(info->sti_pill);
if (rc)
RETURN(err_serious(rc));
- opc = req_capsule_client_get(&info->sti_pill,
- &RMF_SEQ_OPC);
+ opc = req_capsule_client_get(info->sti_pill, &RMF_SEQ_OPC);
if (opc != NULL) {
- out = req_capsule_server_get(&info->sti_pill,
- &RMF_SEQ_RANGE);
+ out = req_capsule_server_get(info->sti_pill, &RMF_SEQ_RANGE);
if (out == NULL)
RETURN(err_serious(-EPROTO));
if (lustre_msg_get_flags(req->rq_reqmsg) & MSG_REPLAY) {
- in = req_capsule_client_get(&info->sti_pill,
+ in = req_capsule_client_get(info->sti_pill,
&RMF_SEQ_RANGE);
LASSERT(!range_is_zero(in) && range_is_sane(in));
static void seq_thread_info_init(struct ptlrpc_request *req,
struct seq_thread_info *info)
{
- int i;
-
- /* Mark rep buffer as req-layout stuff expects */
- for (i = 0; i < ARRAY_SIZE(info->sti_rep_buf_size); i++)
- info->sti_rep_buf_size[i] = -1;
-
+ info->sti_pill = &req->rq_pill;
/* Init request capsule */
- req_capsule_init(&info->sti_pill, req, RCL_SERVER,
- info->sti_rep_buf_size);
-
- req_capsule_set(&info->sti_pill, &RQF_SEQ_QUERY);
+ req_capsule_init(info->sti_pill, req, RCL_SERVER);
+ req_capsule_set(info->sti_pill, &RQF_SEQ_QUERY);
}
static void seq_thread_info_fini(struct seq_thread_info *info)
{
- req_capsule_fini(&info->sti_pill);
+ req_capsule_fini(info->sti_pill);
}
static int seq_handle(struct ptlrpc_request *req)
*/
int seq_query(struct com_thread_info *info)
{
- return seq_handle(info->cti_pill.rc_req);
+ return seq_handle(info->cti_pill->rc_req);
}
EXPORT_SYMBOL(seq_query);
#ifdef __KERNEL__
struct seq_thread_info {
+ struct req_capsule *sti_pill;
struct txn_param sti_txn;
- struct req_capsule sti_pill;
struct lu_range sti_space;
- int sti_rep_buf_size[REQ_MAX_FIELD_NR];
struct lu_buf sti_buf;
};
#include <lustre_fid.h>
/*
- * Sequence space, starts from 0x400 to have first 0x400 sequences used for
- * special purposes. This means that if we have seq-with 10000 fids, we have
- * ~10M fids reserved for special purposes (igifs, etc.).
+ * Sequence space, starts from 0x100000000ULL to have first 0x100000000ULL
+ * sequences used for special purposes.
+ * Those fids are reserved for special purposes (igifs, etc.).
*/
const struct lu_range LUSTRE_SEQ_SPACE_RANGE = {
- (0x400),
+ (0x100000000ULL),
((__u64)~0ULL)
};
EXPORT_SYMBOL(LUSTRE_SEQ_SPACE_RANGE);
struct lu_range *output, __u32 opc,
const char *opcname)
{
- int rc, size[3] = { sizeof(struct ptlrpc_body),
- sizeof(__u32),
- sizeof(struct lu_range) };
- struct obd_export *exp = seq->lcs_exp;
+ struct obd_export *exp = seq->lcs_exp;
struct ptlrpc_request *req;
- struct lu_range *out, *in;
- struct req_capsule pill;
- __u32 *op;
+ struct lu_range *out, *in;
+ __u32 *op;
+ int rc;
ENTRY;
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
- SEQ_QUERY, 3, size, NULL);
+ req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), &RQF_SEQ_QUERY,
+ LUSTRE_MDS_VERSION, SEQ_QUERY);
if (req == NULL)
RETURN(-ENOMEM);
- req_capsule_init(&pill, req, RCL_CLIENT, NULL);
- req_capsule_set(&pill, &RQF_SEQ_QUERY);
-
/* Init operation code */
- op = req_capsule_client_get(&pill, &RMF_SEQ_OPC);
+ op = req_capsule_client_get(&req->rq_pill, &RMF_SEQ_OPC);
*op = opc;
/* Zero out input range, this is not recovery yet. */
- in = req_capsule_client_get(&pill, &RMF_SEQ_RANGE);
+ in = req_capsule_client_get(&req->rq_pill, &RMF_SEQ_RANGE);
if (input != NULL)
*in = *input;
else
range_zero(in);
- size[1] = sizeof(struct lu_range);
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
if (seq->lcs_type == LUSTRE_SEQ_METADATA) {
req->rq_request_portal = (opc == SEQ_ALLOC_SUPER) ?
if (rc)
GOTO(out_req, rc);
- out = req_capsule_server_get(&pill, &RMF_SEQ_RANGE);
+ out = req_capsule_server_get(&req->rq_pill, &RMF_SEQ_RANGE);
*output = *out;
if (!range_is_sane(output)) {
EXIT;
out_req:
- req_capsule_fini(&pill);
ptlrpc_req_finished(req);
return rc;
}
site = req->rq_export->exp_obd->obd_lu_dev->ld_site;
- rc = req_capsule_pack(&info->fti_pill);
+ rc = req_capsule_server_pack(info->fti_pill);
if (rc)
RETURN(err_serious(rc));
- opc = req_capsule_client_get(&info->fti_pill, &RMF_FLD_OPC);
+ opc = req_capsule_client_get(info->fti_pill, &RMF_FLD_OPC);
if (opc != NULL) {
- in = req_capsule_client_get(&info->fti_pill, &RMF_FLD_MDFLD);
+ in = req_capsule_client_get(info->fti_pill, &RMF_FLD_MDFLD);
if (in == NULL)
RETURN(err_serious(-EPROTO));
- out = req_capsule_server_get(&info->fti_pill, &RMF_FLD_MDFLD);
+ out = req_capsule_server_get(info->fti_pill, &RMF_FLD_MDFLD);
if (out == NULL)
RETURN(err_serious(-EPROTO));
*out = *in;
static void fld_thread_info_init(struct ptlrpc_request *req,
struct fld_thread_info *info)
{
- int i;
-
info->fti_flags = lustre_msg_get_flags(req->rq_reqmsg);
- /* Mark rep buffer as req-layout stuff expects. */
- for (i = 0; i < ARRAY_SIZE(info->fti_rep_buf_size); i++)
- info->fti_rep_buf_size[i] = -1;
-
+ info->fti_pill = &req->rq_pill;
/* Init request capsule. */
- req_capsule_init(&info->fti_pill, req, RCL_SERVER,
- info->fti_rep_buf_size);
-
- req_capsule_set(&info->fti_pill, &RQF_FLD_QUERY);
+ req_capsule_init(info->fti_pill, req, RCL_SERVER);
+ req_capsule_set(info->fti_pill, &RQF_FLD_QUERY);
}
static void fld_thread_info_fini(struct fld_thread_info *info)
{
- req_capsule_fini(&info->fti_pill);
+ req_capsule_fini(info->fti_pill);
}
static int fld_handle(struct ptlrpc_request *req)
*/
int fld_query(struct com_thread_info *info)
{
- return fld_handle(info->cti_pill.rc_req);
+ return fld_handle(info->cti_pill->rc_req);
}
EXPORT_SYMBOL(fld_query);
#ifdef __KERNEL__
struct fld_thread_info {
- struct req_capsule fti_pill;
- int fti_rep_buf_size[REQ_MAX_FIELD_NR];
- __u64 fti_key;
- __u64 fti_rec;
- __u32 fti_flags;
+ struct req_capsule *fti_pill;
+ __u64 fti_key;
+ __u64 fti_rec;
+ __u32 fti_flags;
};
int fld_index_init(struct lu_server_fld *fld,
static int fld_client_rpc(struct obd_export *exp,
struct md_fld *mf, __u32 fld_op)
{
- int size[3] = { sizeof(struct ptlrpc_body),
- sizeof(__u32),
- sizeof(struct md_fld) };
struct ptlrpc_request *req;
- struct req_capsule pill;
- struct md_fld *pmf;
- __u32 *op;
- int rc;
+ struct md_fld *pmf;
+ __u32 *op;
+ int rc;
ENTRY;
LASSERT(exp != NULL);
- req = ptlrpc_prep_req(class_exp2cliimp(exp),
- LUSTRE_MDS_VERSION,
- FLD_QUERY, 3, size,
- NULL);
+ req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), &RQF_FLD_QUERY,
+ LUSTRE_MDS_VERSION, FLD_QUERY);
if (req == NULL)
RETURN(-ENOMEM);
- req_capsule_init(&pill, req, RCL_CLIENT, NULL);
- req_capsule_set(&pill, &RQF_FLD_QUERY);
-
- op = req_capsule_client_get(&pill, &RMF_FLD_OPC);
+ op = req_capsule_client_get(&req->rq_pill, &RMF_FLD_OPC);
*op = fld_op;
- pmf = req_capsule_client_get(&pill, &RMF_FLD_MDFLD);
+ pmf = req_capsule_client_get(&req->rq_pill, &RMF_FLD_MDFLD);
*pmf = *mf;
- size[1] = sizeof(struct md_fld);
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
req->rq_request_portal = FLD_REQUEST_PORTAL;
if (fld_op != FLD_LOOKUP)
if (rc)
GOTO(out_req, rc);
- pmf = req_capsule_server_get(&pill, &RMF_FLD_MDFLD);
+ pmf = req_capsule_server_get(&req->rq_pill, &RMF_FLD_MDFLD);
if (pmf == NULL)
GOTO(out_req, rc = -EFAULT);
*mf = *pmf;
EXIT;
out_req:
- req_capsule_fini(&pill);
ptlrpc_req_finished(req);
return rc;
}
__u64 la_valid; /* valid bits */
};
-
/*
* Layer in the layered object.
*/
#define OBD_CONNECT_LRU_RESIZE 0x02000000ULL /* Lru resize feature. */
#define OBD_CONNECT_MDS_MDS 0x04000000ULL /* MDS-MDS connection*/
#define OBD_CONNECT_REAL 0x08000000ULL /* real connection */
+#define OBD_CONNECT_FID 0x10000000ULL /* FID is supported by server */
#define OBD_CONNECT_CKSUM 0x20000000ULL /* support several cksum algos */
/* also update obd_connect_names[] for lprocfs_rd_connect_flags()
OBD_CONNECT_RMT_CLIENT | \
OBD_CONNECT_MDS_CAPA | OBD_CONNECT_OSS_CAPA | \
OBD_CONNECT_MDS_MDS | OBD_CONNECT_CANCELSET | \
+ OBD_CONNECT_FID | \
LRU_RESIZE_CONNECT_FLAG)
#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_OSS_CAPA | OBD_CONNECT_CANCELSET | \
+ OBD_CONNECT_FID | \
LRU_RESIZE_CONNECT_FLAG)
#define ECHO_CONNECT_SUPPORTED (0)
-#define MGS_CONNECT_SUPPORTED (OBD_CONNECT_VERSION)
+#define MGS_CONNECT_SUPPORTED (OBD_CONNECT_VERSION | OBD_CONNECT_FID)
#define MAX_QUOTA_COUNT32 (0xffffffffULL)
MDS_QUOTACHECK = 47,
MDS_QUOTACTL = 48,
MDS_GETXATTR = 49,
- MDS_SETXATTR = 50,
+ MDS_SETXATTR = 50, /* obsolete, now it's MDS_REINT op */
MDS_WRITEPAGE = 51,
MDS_IS_SUBDIR = 52,
MDS_LAST_OPC
REINT_UNLINK = 4,
REINT_RENAME = 5,
REINT_OPEN = 6,
+ REINT_SETXATTR = 7,
+// REINT_CLOSE = 8,
+// REINT_WRITE = 9,
REINT_MAX
} mds_reint_t, mdt_reint_t;
__u64 ctime;
__u64 blocks; /* XID, in the case of MDS_READPAGE */
__u64 ioepoch;
+ __u64 ino; /* for 1.6 compatibility */
__u32 fsuid;
__u32 fsgid;
__u32 capability;
__u32 flags; /* from vfs for pin/unpin, MDS_BFLAG for close */
__u32 rdev;
__u32 nlink; /* #bytes to read in the case of MDS_READPAGE */
+ __u32 generation; /* for 1.6 compatibility */
__u32 suppgid;
__u32 eadatasize;
__u32 aclsize;
__u32 max_mdsize;
- __u32 max_cookiesize; /* also fix lustre_swab_mdt_body */
+ __u32 max_cookiesize;
+ __u32 padding_4; /* also fix lustre_swab_mdt_body */
};
struct mds_body {
__u32 sa_fsgid;
__u32 sa_cap;
__u32 sa_suppgid;
- __u32 sa_mode;
+ __u32 sa_padding_1;
struct lu_fid sa_fid;
__u64 sa_valid;
+ __u32 sa_uid;
+ __u32 sa_gid;
__u64 sa_size;
__u64 sa_blocks;
__u64 sa_mtime;
__u64 sa_atime;
__u64 sa_ctime;
- __u32 sa_uid;
- __u32 sa_gid;
__u32 sa_attr_flags;
- __u32 sa_padding; /* also fix lustre_swab_mds_rec_setattr */
+ __u32 sa_mode;
+ __u32 sa_padding_2;
+ __u32 sa_padding_3;
+ __u32 sa_padding_4;
+ __u32 sa_padding_5;
};
extern void lustre_swab_mdt_rec_setattr (struct mdt_rec_setattr *sa);
__u32 cr_fsuid;
__u32 cr_fsgid;
__u32 cr_cap;
- __u32 cr_flags; /* for use with open */
- __u32 cr_mode;
- struct lustre_handle cr_old_handle; /* u64 handle in case of open replay */
+ __u32 cr_suppgid1;
+ __u32 cr_suppgid2;
struct lu_fid cr_fid1;
struct lu_fid cr_fid2;
+ struct lustre_handle cr_old_handle; /* u64 handle in case of open replay */
__u64 cr_time;
__u64 cr_rdev;
__u64 cr_ioepoch;
- __u32 cr_suppgid1;
- __u32 cr_suppgid2;
+ __u64 cr_padding_1; /* pad for 64 bits*/
+ __u32 cr_mode;
__u32 cr_bias;
- __u32 cr_padding_1; /* pad for 64 bits*/
+ __u32 cr_flags; /* for use with open */
+ __u32 cr_padding_2;
+ __u32 cr_padding_3;
+ __u32 cr_padding_4;
};
extern void lustre_swab_mdt_rec_create (struct mdt_rec_create *cr);
struct lu_fid lk_fid1;
struct lu_fid lk_fid2;
__u64 lk_time;
+ __u64 lk_padding_1;
+ __u64 lk_padding_2;
+ __u64 lk_padding_3;
+ __u64 lk_padding_4;
__u32 lk_bias;
- __u32 lk_padding_2; /* also fix lustre_swab_mds_rec_link */
- __u32 lk_padding_3; /* also fix lustre_swab_mds_rec_link */
- __u32 lk_padding_4; /* also fix lustre_swab_mds_rec_link */
+ __u32 lk_padding_5;
+ __u32 lk_padding_6;
+ __u32 lk_padding_7;
+ __u32 lk_padding_8;
+ __u32 lk_padding_9;
};
-extern void lustre_swab_mdt_rec_link (struct mdt_rec_link *lk);
-
struct mds_rec_unlink {
__u32 ul_opcode;
__u32 ul_fsuid;
__u32 ul_fsuid;
__u32 ul_fsgid;
__u32 ul_cap;
- __u32 ul_suppgid;
- __u32 ul_mode;
+ __u32 ul_suppgid1;
+ __u32 ul_suppgid2;
struct lu_fid ul_fid1;
struct lu_fid ul_fid2;
__u64 ul_time;
+ __u64 ul_padding_2;
+ __u64 ul_padding_3;
+ __u64 ul_padding_4;
+ __u64 ul_padding_5;
__u32 ul_bias;
- __u32 ul_padding_2; /* also fix lustre_swab_mds_rec_unlink */
- __u32 ul_padding_3; /* also fix lustre_swab_mds_rec_unlink */
- __u32 ul_padding_4; /* also fix lustre_swab_mds_rec_unlink */
+ __u32 ul_mode;
+ __u32 ul_padding_6;
+ __u32 ul_padding_7;
+ __u32 ul_padding_8;
+ __u32 ul_padding_9;
};
-extern void lustre_swab_mdt_rec_unlink (struct mdt_rec_unlink *ul);
-
struct mds_rec_rename {
__u32 rn_opcode;
__u32 rn_fsuid;
struct lu_fid rn_fid1;
struct lu_fid rn_fid2;
__u64 rn_time;
- __u32 rn_mode; /* cross-ref rename has mode */
+ __u64 rn_padding_1;
+ __u64 rn_padding_2;
+ __u64 rn_padding_3;
+ __u64 rn_padding_4;
__u32 rn_bias; /* some operation flags */
- __u32 rn_padding_3; /* also fix lustre_swab_mdt_rec_rename */
- __u32 rn_padding_4; /* also fix lustre_swab_mdt_rec_rename */
-};
-
-extern void lustre_swab_mdt_rec_rename (struct mdt_rec_rename *rn);
+ __u32 rn_mode; /* cross-ref rename has mode */
+ __u32 rn_padding_5;
+ __u32 rn_padding_6;
+ __u32 rn_padding_7;
+ __u32 rn_padding_8;
+};
+
+struct mdt_rec_setxattr {
+ __u32 sx_opcode;
+ __u32 sx_fsuid;
+ __u32 sx_fsgid;
+ __u32 sx_cap;
+ __u32 sx_suppgid1;
+ __u32 sx_suppgid2;
+ struct lu_fid sx_fid;
+ __u64 sx_padding_1; /* These three members are lu_fid size */
+ __u32 sx_padding_2;
+ __u32 sx_padding_3;
+ __u64 sx_valid;
+ __u64 sx_padding_4;
+ __u64 sx_padding_5;
+ __u64 sx_padding_6;
+ __u64 sx_padding_7;
+ __u32 sx_size;
+ __u32 sx_flags;
+ __u32 sx_padding_8;
+ __u32 sx_padding_9;
+ __u32 sx_padding_10;
+ __u32 sx_padding_11;
+};
+
+struct mdt_rec_reint {
+ __u32 rr_opcode;
+ __u32 rr_fsuid;
+ __u32 rr_fsgid;
+ __u32 rr_cap;
+ __u32 rr_suppgid1;
+ __u32 rr_suppgid2;
+ struct lu_fid rr_fid1;
+ struct lu_fid rr_fid2;
+ __u64 rr_mtime;
+ __u64 rr_atime;
+ __u64 rr_ctime;
+ __u64 rr_size;
+ __u64 rr_blocks;
+ __u32 rr_bias;
+ __u32 rr_mode;
+ __u32 rr_padding_1; /* also fix lustre_swab_mdt_rec_reint */
+ __u32 rr_padding_2; /* also fix lustre_swab_mdt_rec_reint */
+ __u32 rr_padding_3; /* also fix lustre_swab_mdt_rec_reint */
+ __u32 rr_padding_4; /* also fix lustre_swab_mdt_rec_reint */
+};
+
+extern void lustre_swab_mdt_rec_reint(struct mdt_rec_reint *rr);
-/* begin adding MDT by huanghua@clusterfs.com */
struct lmv_desc {
__u32 ld_tgt_count; /* how many MDS's */
__u32 ld_active_tgt_count; /* how many active */
};
extern void lustre_swab_lmv_desc (struct lmv_desc *ld);
-/* end adding MDT by huanghua@clusterfs.com */
struct md_fld {
seqno_t mf_seq;
LCFG_LOV_ADD_INA = 0x00ce013,
LCFG_ADD_MDC = 0x00cf014,
LCFG_DEL_MDC = 0x00cf015,
- LCFG_SPTLRPC_CONF = 0x00cf016,
+ LCFG_SPTLRPC_CONF = 0x00ce016,
};
struct lustre_cfg_bufs {
ldlm_policy_data_t *policy, int *flags,
void *lvb, __u32 lvb_len, void *lvb_swabber,
struct lustre_handle *lockh, int async);
-struct ptlrpc_request *ldlm_prep_enqueue_req(struct obd_export *exp,
- int bufcount, int *size,
- struct list_head *head, int count);
-struct ptlrpc_request *ldlm_prep_elc_req(struct obd_export *exp, int version,
- int opc, int bufcount, int *size,
- int bufoff, int canceloff,
- struct list_head *cancels, int count);
+int ldlm_prep_enqueue_req(struct obd_export *exp,
+ struct ptlrpc_request *req,
+ struct list_head *cancels,
+ int count);
+int ldlm_prep_elc_req(struct obd_export *exp,
+ struct ptlrpc_request *req,
+ int version, int opc, int canceloff,
+ struct list_head *cancels, int count);
int ldlm_handle_enqueue0(struct ldlm_namespace *ns, struct ptlrpc_request *req,
const struct ldlm_request *dlm_req,
const struct ldlm_callback_suite *cbs);
ldlm_mode_t mode, int lock_flags,
int cancel_flags, void *opaque);
int ldlm_cli_cancel_list(struct list_head *head, int count,
- struct ptlrpc_request *req, int off, int flags);
+ struct ptlrpc_request *req, int flags);
/* mds/handler.c */
/* This has to be here because recursive inclusion sucks. */
/*
* for req-layout interface.
*/
- struct req_capsule cti_pill;
+ struct req_capsule *cti_pill;
};
enum {
#include <lustre_import.h>
#include <lprocfs_status.h>
#include <lu_object.h>
+#include <lustre_req_layout.h>
/* MD flags we _always_ use */
#define PTLRPC_MD_OPTIONS 0
struct ptlrpc_request_pool *rq_pool; /* Pool if request from
preallocated list */
struct lu_context rq_session;
+
+ /* request format */
+ struct req_capsule rq_pill;
};
static inline void ptlrpc_close_replay_seq(struct ptlrpc_request *req)
void ptlrpc_add_rqs_to_pool(struct ptlrpc_request_pool *pool, int num_rq);
struct ptlrpc_request_pool *ptlrpc_init_rq_pool(int, int,
void (*populate_pool)(struct ptlrpc_request_pool *, int));
+struct ptlrpc_request *ptlrpc_request_alloc(struct obd_import *imp,
+ const struct req_format *format);
+struct ptlrpc_request *ptlrpc_request_alloc_pool(struct obd_import *imp,
+ struct ptlrpc_request_pool *,
+ const struct req_format *format);
+void ptlrpc_request_free(struct ptlrpc_request *request);
+int ptlrpc_request_pack(struct ptlrpc_request *request,
+ __u32 version, int opcode);
+struct ptlrpc_request *ptlrpc_request_alloc_pack(struct obd_import *imp,
+ const struct req_format *format,
+ __u32 version, int opcode);
+int ptlrpc_request_bufs_pack(struct ptlrpc_request *request,
+ __u32 version, int opcode, char **bufs,
+ struct ptlrpc_cli_ctx *ctx);
struct ptlrpc_request *ptlrpc_prep_req(struct obd_import *imp, __u32 version,
int opcode, int count, int *lengths,
char **bufs);
struct ptlrpc_request *ptlrpc_prep_req_pool(struct obd_import *imp,
__u32 version, int opcode,
int count, int *lengths, char **bufs,
- struct ptlrpc_request_pool *pool,
- struct ptlrpc_cli_ctx *ctx);
+ struct ptlrpc_request_pool *pool);
void ptlrpc_free_req(struct ptlrpc_request *request);
void ptlrpc_req_finished(struct ptlrpc_request *request);
void ptlrpc_req_finished_with_imp_lock(struct ptlrpc_request *request);
void lustre_msg_set_transno(struct lustre_msg *msg, __u64 transno);
void lustre_msg_set_status(struct lustre_msg *msg, __u32 status);
void lustre_msg_set_conn_cnt(struct lustre_msg *msg, __u32 conn_cnt);
+void ptlrpc_req_set_repsize(struct ptlrpc_request *req, int count, int *sizes);
+void ptlrpc_request_set_replen(struct ptlrpc_request *req);
static inline void
lustre_shrink_reply(struct ptlrpc_request *req, int segment,
}
}
-static inline void
-ptlrpc_req_set_repsize(struct ptlrpc_request *req, int count, int *lens)
-{
- req->rq_replen = lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens);
- if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
- req->rq_reqmsg->lm_repsize = req->rq_replen;
-}
-
/* ldlm/ldlm_lib.c */
int client_obd_setup(struct obd_device *obddev, struct lustre_cfg *lcfg);
int client_obd_cleanup(struct obd_device *obddev);
RCL_NR
};
+/* Maximal number of fields (buffers) in a request message. */
+#define REQ_MAX_FIELD_NR 9
+
struct req_capsule {
struct ptlrpc_request *rc_req;
const struct req_format *rc_fmt;
__u32 rc_swabbed;
enum req_location rc_loc;
- int *rc_area;
-};
-
-enum {
- /*
- * Maximal number of fields (buffers) in a request message.
- */
- REQ_MAX_FIELD_NR = 8
+ int rc_area[RCL_NR][REQ_MAX_FIELD_NR];
};
#if !defined(__REQ_LAYOUT_USER__)
#include <lustre_net.h>
void req_capsule_init(struct req_capsule *pill, struct ptlrpc_request *req,
- enum req_location location, int *area);
+ enum req_location location);
void req_capsule_fini(struct req_capsule *pill);
void req_capsule_set(struct req_capsule *pill, const struct req_format *fmt);
-int req_capsule_pack(struct req_capsule *pill);
+void req_capsule_init_area(struct req_capsule *pill);
+int req_capsule_filled_sizes(struct req_capsule *pill, enum req_location loc);
+int req_capsule_server_pack(struct req_capsule *pill);
void *req_capsule_client_get(struct req_capsule *pill,
const struct req_msg_field *field);
+void *req_capsule_client_swab_get(struct req_capsule *pill,
+ const struct req_msg_field *field,
+ void (*swabber)(void*));
+void *req_capsule_client_sized_get(struct req_capsule *pill,
+ const struct req_msg_field *field,
+ int len);
void *req_capsule_server_get(struct req_capsule *pill,
const struct req_msg_field *field);
+void *req_capsule_server_sized_get(struct req_capsule *pill,
+ const struct req_msg_field *field,
+ int len);
+void *req_capsule_server_swab_get(struct req_capsule *pill,
+ const struct req_msg_field *field,
+ void *swabber);
const void *req_capsule_other_get(struct req_capsule *pill,
const struct req_msg_field *field);
-void req_capsule_set_size(const struct req_capsule *pill,
+void req_capsule_set_size(struct req_capsule *pill,
const struct req_msg_field *field,
enum req_location loc, int size);
int req_capsule_get_size(const struct req_capsule *pill,
int req_capsule_field_present(const struct req_capsule *pill,
const struct req_msg_field *field,
enum req_location loc);
-
-int req_capsule_shrink(const struct req_capsule *pill,
- const struct req_msg_field *field,
- const unsigned int newlen,
- const int adjust,
- const int move_data);
+void req_capsule_shrink(struct req_capsule *pill,
+ const struct req_msg_field *field,
+ unsigned int newlen,
+ enum req_location loc);
int req_layout_init(void);
void req_layout_fini(void);
/* __REQ_LAYOUT_USER__ */
#endif
+extern const struct req_format RQF_OBD_PING;
+extern const struct req_format RQF_SEC_CTX;
+/* MGS req_format */
+extern const struct req_format RQF_MGS_TARGET_REG;
+extern const struct req_format RQF_MGS_SET_INFO;
+/* fid/fld req_format */
extern const struct req_format RQF_SEQ_QUERY;
extern const struct req_format RQF_FLD_QUERY;
-extern const struct req_format RQF_MDS_GETSTATUS;
+/* MDS req_format */
+extern const struct req_format RQF_MDS_CONNECT;
+extern const struct req_format RQF_MDS_DISCONNECT;
extern const struct req_format RQF_MDS_STATFS;
+extern const struct req_format RQF_MDS_GETSTATUS;
extern const struct req_format RQF_MDS_SYNC;
extern const struct req_format RQF_MDS_GETXATTR;
-extern const struct req_format RQF_MDS_SETXATTR;
extern const struct req_format RQF_MDS_GETATTR;
+/*
+ * This is format of direct (non-intent) MDS_GETATTR_NAME request.
+ */
+extern const struct req_format RQF_MDS_GETATTR_NAME;
extern const struct req_format RQF_MDS_CLOSE;
extern const struct req_format RQF_MDS_PIN;
+extern const struct req_format RQF_MDS_UNPIN;
extern const struct req_format RQF_MDS_CONNECT;
extern const struct req_format RQF_MDS_DISCONNECT;
extern const struct req_format RQF_MDS_SET_INFO;
extern const struct req_format RQF_MDS_WRITEPAGE;
extern const struct req_format RQF_MDS_IS_SUBDIR;
extern const struct req_format RQF_MDS_DONE_WRITING;
-
-/*
- * This is format of direct (non-intent) MDS_GETATTR_NAME request.
- */
-extern const struct req_format RQF_MDS_GETATTR_NAME;
extern const struct req_format RQF_MDS_REINT;
extern const struct req_format RQF_MDS_REINT_CREATE;
extern const struct req_format RQF_MDS_REINT_CREATE_RMT_ACL;
extern const struct req_format RQF_MDS_REINT_LINK;
extern const struct req_format RQF_MDS_REINT_RENAME;
extern const struct req_format RQF_MDS_REINT_SETATTR;
+extern const struct req_format RQF_MDS_REINT_SETXATTR;
+extern const struct req_format RQF_MDS_QUOTACHECK;
+extern const struct req_format RQF_MDS_QUOTACTL;
+extern const struct req_format RQF_MDS_QUOTA_DQACQ;
+extern const struct req_format RQF_QC_CALLBACK;
+/* OST req_format */
+extern const struct req_format RQF_OST_CONNECT;
+extern const struct req_format RQF_OST_DISCONNECT;
+extern const struct req_format RQF_OST_QUOTACHECK;
+extern const struct req_format RQF_OST_QUOTACTL;
+extern const struct req_format RQF_OST_GETATTR;
+extern const struct req_format RQF_OST_SETATTR;
+extern const struct req_format RQF_OST_CREATE;
+extern const struct req_format RQF_OST_PUNCH;
+extern const struct req_format RQF_OST_SYNC;
+extern const struct req_format RQF_OST_DESTROY;
+extern const struct req_format RQF_OST_BRW;
+extern const struct req_format RQF_OST_STATFS;
+extern const struct req_format RQF_OST_SET_INFO;
+extern const struct req_format RQF_OST_GET_INFO;
+
+/* LDLM req_format */
extern const struct req_format RQF_LDLM_ENQUEUE;
+extern const struct req_format RQF_LDLM_ENQUEUE_LVB;
+extern const struct req_format RQF_LDLM_CONVERT;
extern const struct req_format RQF_LDLM_INTENT;
extern const struct req_format RQF_LDLM_INTENT_GETATTR;
extern const struct req_format RQF_LDLM_INTENT_OPEN;
extern const struct req_format RQF_LDLM_INTENT_CREATE;
extern const struct req_format RQF_LDLM_INTENT_UNLINK;
+extern const struct req_format RQF_LDLM_CANCEL;
+extern const struct req_format RQF_LDLM_CALLBACK;
+extern const struct req_format RQF_LDLM_CP_CALLBACK;
+extern const struct req_format RQF_LDLM_BL_CALLBACK;
+extern const struct req_format RQF_LDLM_GL_CALLBACK;
+/* LOG req_format */
+extern const struct req_format RQF_LOG_CANCEL;
+extern const struct req_format RQF_LLOG_CATINFO;
+extern const struct req_format RQF_LLOG_ORIGIN_HANDLE_CREATE;
+extern const struct req_format RQF_LLOG_ORIGIN_HANDLE_DESTROY;
+extern const struct req_format RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK;
+extern const struct req_format RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK;
+extern const struct req_format RQF_LLOG_ORIGIN_HANDLE_READ_HEADER;
+extern const struct req_format RQF_LLOG_ORIGIN_CONNECT;
extern const struct req_msg_field RMF_PTLRPC_BODY;
extern const struct req_msg_field RMF_MDT_BODY;
extern const struct req_msg_field RMF_CONNECT_DATA;
extern const struct req_msg_field RMF_DLM_REQ;
extern const struct req_msg_field RMF_DLM_REP;
+extern const struct req_msg_field RMF_DLM_LVB;
extern const struct req_msg_field RMF_LDLM_INTENT;
extern const struct req_msg_field RMF_MDT_MD;
-extern const struct req_msg_field RMF_REC_CREATE;
-extern const struct req_msg_field RMF_REC_LINK;
-extern const struct req_msg_field RMF_REC_UNLINK;
-extern const struct req_msg_field RMF_REC_RENAME;
-extern const struct req_msg_field RMF_REC_SETATTR;
+extern const struct req_msg_field RMF_REC_REINT;
+extern const struct req_msg_field RMF_REC_JOINFILE;
extern const struct req_msg_field RMF_EADATA;
extern const struct req_msg_field RMF_ACL;
extern const struct req_msg_field RMF_LOGCOOKIES;
-extern const struct req_msg_field RMF_REINT_OPC;
extern const struct req_msg_field RMF_CAPA1;
extern const struct req_msg_field RMF_CAPA2;
+extern const struct req_msg_field RMF_OBD_QUOTACHECK;
+extern const struct req_msg_field RMF_OBD_QUOTACTL;
+extern const struct req_msg_field RMF_QUNIT_DATA;
+extern const struct req_msg_field RMF_STRING;
/* seq-mgr fields */
extern const struct req_msg_field RMF_SEQ_OPC;
extern const struct req_msg_field RMF_FLD_OPC;
extern const struct req_msg_field RMF_FLD_MDFLD;
+extern const struct req_msg_field RMF_LLOGD_BODY;
+extern const struct req_msg_field RMF_LLOG_LOG_HDR;
+extern const struct req_msg_field RMF_LLOGD_CONN_BODY;
+
+extern const struct req_msg_field RMF_MGS_TARGET_INFO;
+extern const struct req_msg_field RMF_MGS_SEND_PARAM;
+
+extern const struct req_msg_field RMF_OST_BODY;
+extern const struct req_msg_field RMF_OBD_IOOBJ;
+extern const struct req_msg_field RMF_OBD_ID;
+extern const struct req_msg_field RMF_NIOBUF_REMOTE;
+
#endif /* _LUSTRE_REQ_LAYOUT_H__ */
int (*m_init_ea_size)(struct obd_export *, int, int, int);
int (*m_get_lustre_md)(struct obd_export *, struct ptlrpc_request *,
- int, struct obd_export *, struct obd_export *,
+ struct obd_export *, struct obd_export *,
struct lustre_md *);
int (*m_free_lustre_md)(struct obd_export *, struct lustre_md *);
static inline int md_get_lustre_md(struct obd_export *exp,
struct ptlrpc_request *req,
- int offset, struct obd_export *dt_exp,
+ struct obd_export *dt_exp,
struct obd_export *md_exp,
struct lustre_md *md)
{
ENTRY;
EXP_CHECK_MD_OP(exp, get_lustre_md);
EXP_MD_COUNTER_INCREMENT(exp, get_lustre_md);
- RETURN(MDP(exp->exp_obd, get_lustre_md)(exp, req, offset,
- dt_exp, md_exp, md));
+ RETURN(MDP(exp->exp_obd, get_lustre_md)(exp, req, dt_exp, md_exp, md));
}
static inline int md_free_lustre_md(struct obd_export *exp,
struct obd_export *export = NULL;
struct obd_import *revimp;
struct lustre_handle conn;
+ struct lustre_handle *tmp;
struct obd_uuid tgtuuid;
struct obd_uuid cluuid;
struct obd_uuid remote_uuid;
- char *str, *tmp;
+ char *str;
int rc = 0;
int initial_conn = 0;
- struct obd_connect_data *data;
- int size[2] = { sizeof(struct ptlrpc_body), sizeof(*data) };
+ struct obd_connect_data *data, *tmpdata;
ENTRY;
OBD_RACE(OBD_FAIL_TGT_CONN_RACE);
- lustre_set_req_swabbed(req, REQ_REC_OFF);
- str = lustre_msg_string(req->rq_reqmsg, REQ_REC_OFF, sizeof(tgtuuid)-1);
+ str = req_capsule_client_get(&req->rq_pill, &RMF_TGTUUID);
if (str == NULL) {
DEBUG_REQ(D_ERROR, req, "bad target UUID for connect");
GOTO(out, rc = -EINVAL);
}
- obd_str2uuid (&tgtuuid, str);
+ obd_str2uuid(&tgtuuid, str);
target = class_uuid2obd(&tgtuuid);
if (!target)
target = class_name2obd(str);
Really, class_uuid2obd should take the ref. */
targref = class_incref(target);
- lustre_set_req_swabbed(req, REQ_REC_OFF + 1);
- str = lustre_msg_string(req->rq_reqmsg, REQ_REC_OFF + 1,
- sizeof(cluuid) - 1);
+
+ str = req_capsule_client_get(&req->rq_pill, &RMF_CLUUID);
if (str == NULL) {
DEBUG_REQ(D_ERROR, req, "bad client UUID for connect");
GOTO(out, rc = -EINVAL);
}
- obd_str2uuid (&cluuid, str);
+ obd_str2uuid(&cluuid, str);
/* XXX extract a nettype and format accordingly */
switch (sizeof(lnet_nid_t)) {
LBUG();
}
- tmp = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF + 2, sizeof conn);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_CONN);
if (tmp == NULL)
GOTO(out, rc = -EPROTO);
- memcpy(&conn, tmp, sizeof conn);
-
- data = lustre_swab_reqbuf(req, REQ_REC_OFF + 3, sizeof(*data),
- lustre_swab_connect);
+ conn = *tmp;
+ data = req_capsule_client_get(&req->rq_pill, &RMF_CONNECT_DATA);
if (!data)
GOTO(out, rc = -EPROTO);
- rc = lustre_pack_reply(req, 2, size, NULL);
+ rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out, rc);
OBD_OCD_VERSION_MINOR(data->ocd_version),
OBD_OCD_VERSION_PATCH(data->ocd_version),
OBD_OCD_VERSION_FIX(data->ocd_version));
- data = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF,
- offsetof(typeof(*data),
- ocd_version) +
- sizeof(data->ocd_version));
+ data = req_capsule_server_sized_get(&req->rq_pill,
+ &RMF_CONNECT_DATA,
+ offsetof(typeof(*data), ocd_version) +
+ sizeof(data->ocd_version));
if (data) {
data->ocd_connect_flags = OBD_CONNECT_VERSION;
data->ocd_version = LUSTRE_VERSION_CODE;
if (export == NULL) {
if (target->obd_recovering) {
+ cfs_time_t t;
+
+ t = cfs_timer_deadline(&target->obd_recovery_timer);
+ t = cfs_time_sub(t, cfs_time_current());
CERROR("%s: denying connection for new client %s (%s): "
"%d clients in recovery for %lds\n",
target->obd_name,
libcfs_nid2str(req->rq_peer.nid), cluuid.uuid,
target->obd_recoverable_clients,
- cfs_duration_sec(cfs_time_sub(cfs_timer_deadline(&target->obd_recovery_timer),
- cfs_time_current())));
+ cfs_duration_sec(t));
rc = -EBUSY;
} else {
dont_check_exports:
GOTO(out, rc);
/* Return only the parts of obd_connect_data that we understand, so the
* client knows that we don't understand the rest. */
- if (data)
- memcpy(lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF,
- sizeof(*data)),
- data, sizeof(*data));
-
+ if (data) {
+ tmpdata = req_capsule_server_get(&req->rq_pill,
+ &RMF_CONNECT_DATA);
+ //data->ocd_connect_flags &= OBD_CONNECT_SUPPORTED;
+ *tmpdata = *data;
+ }
+
/* If all else goes well, this is our RPC return code. */
req->rq_status = 0;
wake_up(&target->obd_next_transno_waitq);
}
spin_unlock_bh(&target->obd_processing_task_lock);
- memcpy(&conn,
- lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF + 2, sizeof conn),
- sizeof conn);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_CONN);
+ conn = *tmp;
if (export->exp_imp_reverse != NULL) {
/* destroyed import can be still referenced in ctxt */
int rc;
ENTRY;
- rc = lustre_pack_reply(req, 1, NULL, NULL);
+ rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
RETURN(rc);
int target_handle_ping(struct ptlrpc_request *req)
{
obd_ping(req->rq_export);
- return lustre_pack_reply(req, 1, NULL, NULL);
+ return req_capsule_server_pack(&req->rq_pill);
}
void target_committed_to_req(struct ptlrpc_request *req)
struct obd_quotactl *oqctl;
struct client_obd *cli = &req->rq_export->exp_obd->u.cli;
- oqctl = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*oqctl),
- lustre_swab_obd_quotactl);
- if (oqctl == NULL) {
- CERROR("Can't unpack obd_quotactl\n");
+ oqctl = req_capsule_client_get(&req->rq_pill, &RMF_OBD_QUOTACTL);
+ if (oqctl == NULL)
RETURN(-EPROTO);
- }
cli->cl_qchk_stat = oqctl->qc_stat;
void* rep;
struct qunit_data_old *qdata_old;
int rc = 0;
- int repsize[2] = { sizeof(struct ptlrpc_body),
- sizeof(struct qunit_data) };
ENTRY;
- rc = lustre_pack_reply(req, 2, repsize, NULL);
- if (rc)
+ rc = req_capsule_server_pack(&req->rq_pill);
+ if (rc) {
+ CERROR("packing reply failed!: rc = %d\n", rc);
RETURN(rc);
+ }
LASSERT(req->rq_export);
if ((req->rq_export->exp_connect_flags & OBD_CONNECT_QUOTA64) &&
!OBD_FAIL_CHECK(OBD_FAIL_QUOTA_QD_COUNT_32BIT)) {
CDEBUG(D_QUOTA, "qd_count is 64bit!\n");
- rep = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF,
- sizeof(struct qunit_data));
+ rep = req_capsule_server_get(&req->rq_pill,
+ &RMF_QUNIT_DATA);
LASSERT(rep);
- qdata = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*qdata),
- lustre_swab_qdata);
+ qdata = req_capsule_client_swab_get(&req->rq_pill,
+ &RMF_QUNIT_DATA,
+ (void*)lustre_swab_qdata);
} else {
CDEBUG(D_QUOTA, "qd_count is 32bit!\n");
- rep = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF,
- sizeof(struct qunit_data_old));
+ rep = req_capsule_server_get(&req->rq_pill, &RMF_QUNIT_DATA);
LASSERT(rep);
- qdata_old = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*qdata_old),
- lustre_swab_qdata_old);
+ qdata_old = req_capsule_client_swab_get(&req->rq_pill,
+ &RMF_QUNIT_DATA,
+ (void*)lustre_swab_qdata_old);
qdata = lustre_quota_old_to_new(qdata_old);
}
- if (qdata == NULL) {
- CERROR("Can't unpack qunit_data\n");
+ if (qdata == NULL)
RETURN(-EPROTO);
- }
/* we use the observer */
LASSERT(obd->obd_observer && obd->obd_observer->obd_observer);
/* the qd_count might be changed in lqc_handler */
if ((req->rq_export->exp_connect_flags & OBD_CONNECT_QUOTA64) &&
!OBD_FAIL_CHECK(OBD_FAIL_QUOTA_QD_COUNT_32BIT)) {
- memcpy(rep,qdata,sizeof(*qdata));
+ memcpy(rep, qdata, sizeof(*qdata));
} else {
qdata_old = lustre_quota_new_to_old(qdata);
- memcpy(rep,qdata_old,sizeof(*qdata_old));
+ memcpy(rep, qdata_old, sizeof(*qdata_old));
}
req->rq_status = rc;
rc = ptlrpc_reply(req);
void *data, int flag)
{
struct ldlm_cb_set_arg *arg = data;
- struct ldlm_request *body;
- struct ptlrpc_request *req;
- int size[] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body),
- [DLM_LOCKREQ_OFF] = sizeof(*body) };
- int instant_cancel = 0, rc;
+ struct ldlm_request *body;
+ struct ptlrpc_request *req;
+ int instant_cancel = 0;
+ int rc = 0;
ENTRY;
- if (flag == LDLM_CB_CANCELING) {
+ if (flag == LDLM_CB_CANCELING)
/* Don't need to do anything here. */
RETURN(0);
- }
LASSERT(lock);
LASSERT(data != NULL);
ldlm_lock_dump(D_ERROR, lock, 0);
}
- req = ptlrpc_prep_req(lock->l_export->exp_imp_reverse,
- LUSTRE_DLM_VERSION, LDLM_BL_CALLBACK, 2, size,
- NULL);
+ req = ptlrpc_request_alloc_pack(lock->l_export->exp_imp_reverse,
+ &RQF_LDLM_BL_CALLBACK,
+ LUSTRE_DLM_VERSION, LDLM_BL_CALLBACK);
if (req == NULL)
RETURN(-ENOMEM);
if (lock->l_flags & LDLM_FL_CANCEL_ON_BLOCK)
instant_cancel = 1;
- body = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF, sizeof(*body));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
body->lock_handle[0] = lock->l_remote_handle;
body->lock_desc = *desc;
body->lock_flags |= (lock->l_flags & LDLM_AST_FLAGS);
LDLM_DEBUG(lock, "server preparing blocking AST");
- ptlrpc_req_set_repsize(req, 1, NULL);
+ ptlrpc_request_set_replen(req);
if (instant_cancel) {
unlock_res(lock->l_resource);
ldlm_lock_cancel(lock);
int ldlm_server_completion_ast(struct ldlm_lock *lock, int flags, void *data)
{
struct ldlm_cb_set_arg *arg = data;
- struct ldlm_request *body;
- struct ptlrpc_request *req;
- struct timeval granted_time;
- long total_enqueue_wait;
- int size[3] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body),
- [DLM_LOCKREQ_OFF] = sizeof(*body) };
- int rc, buffers = 2, instant_cancel = 0;
+ struct ldlm_request *body;
+ struct ptlrpc_request *req;
+ struct timeval granted_time;
+ long total_enqueue_wait;
+ int instant_cancel = 0;
+ int rc = 0;
ENTRY;
LASSERT(lock != NULL);
LDLM_ERROR(lock, "enqueue wait took %luus from %lu",
total_enqueue_wait, lock->l_enqueued_time.tv_sec);
+ req = ptlrpc_request_alloc(lock->l_export->exp_imp_reverse,
+ &RQF_LDLM_CP_CALLBACK);
+ if (req == NULL)
+ RETURN(-ENOMEM);
+
lock_res_and_lock(lock);
- if (lock->l_resource->lr_lvb_len) {
- size[DLM_REQ_REC_OFF] = lock->l_resource->lr_lvb_len;
- buffers = 3;
- }
+ if (lock->l_resource->lr_lvb_len)
+ req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_CLIENT,
+ lock->l_resource->lr_lvb_len);
unlock_res_and_lock(lock);
- req = ptlrpc_prep_req(lock->l_export->exp_imp_reverse,
- LUSTRE_DLM_VERSION, LDLM_CP_CALLBACK, buffers,
- size, NULL);
- if (req == NULL)
- RETURN(-ENOMEM);
+ rc = ptlrpc_request_pack(req, LUSTRE_DLM_VERSION, LDLM_CP_CALLBACK);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
req->rq_async_args.pointer_arg[0] = arg;
req->rq_async_args.pointer_arg[1] = lock;
req->rq_interpret_reply = ldlm_cb_interpret;
req->rq_no_resend = 1;
+ body = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
- body = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF, sizeof(*body));
body->lock_handle[0] = lock->l_remote_handle;
body->lock_flags = flags;
ldlm_lock2desc(lock, &body->lock_desc);
+ if (lock->l_resource->lr_lvb_len) {
+ void *lvb = req_capsule_client_get(&req->rq_pill, &RMF_DLM_LVB);
- if (buffers == 3) {
- void *lvb;
-
- lvb = lustre_msg_buf(req->rq_reqmsg, DLM_REQ_REC_OFF,
- lock->l_resource->lr_lvb_len);
lock_res_and_lock(lock);
memcpy(lvb, lock->l_resource->lr_lvb_data,
lock->l_resource->lr_lvb_len);
LDLM_DEBUG(lock, "server preparing completion AST (after %ldus wait)",
total_enqueue_wait);
- ptlrpc_req_set_repsize(req, 1, NULL);
-
+ ptlrpc_request_set_replen(req);
req->rq_send_state = LUSTRE_IMP_FULL;
req->rq_timeout = ldlm_get_rq_timeout(ldlm_timeout, obd_timeout);
int ldlm_server_glimpse_ast(struct ldlm_lock *lock, void *data)
{
- struct ldlm_resource *res = lock->l_resource;
- struct ldlm_request *body;
+ struct ldlm_resource *res = lock->l_resource;
+ struct ldlm_request *body;
struct ptlrpc_request *req;
- int size[] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body),
- [DLM_LOCKREQ_OFF] = sizeof(*body) };
- int rc = 0;
+ int rc;
ENTRY;
LASSERT(lock != NULL);
- req = ptlrpc_prep_req(lock->l_export->exp_imp_reverse,
- LUSTRE_DLM_VERSION, LDLM_GL_CALLBACK, 2, size,
- NULL);
+ req = ptlrpc_request_alloc_pack(lock->l_export->exp_imp_reverse,
+ &RQF_LDLM_GL_CALLBACK,
+ LUSTRE_DLM_VERSION, LDLM_GL_CALLBACK);
+
if (req == NULL)
RETURN(-ENOMEM);
- body = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF, sizeof(*body));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
body->lock_handle[0] = lock->l_remote_handle;
ldlm_lock2desc(lock, &body->lock_desc);
lock_res_and_lock(lock);
- size[REPLY_REC_OFF] = lock->l_resource->lr_lvb_len;
+ req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER,
+ lock->l_resource->lr_lvb_len);
unlock_res_and_lock(lock);
res = lock->l_resource;
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
+
req->rq_send_state = LUSTRE_IMP_FULL;
req->rq_timeout = ldlm_get_rq_timeout(ldlm_timeout, obd_timeout);
#define lu_time_stamp_get() time(NULL)
#endif
-static void ldlm_svc_get_eopc(struct ldlm_request *dlm_req,
+static void ldlm_svc_get_eopc(const struct ldlm_request *dlm_req,
struct lprocfs_stats *srv_stats)
{
int lock_type = 0, op = 0;
const struct ldlm_callback_suite *cbs)
{
struct ldlm_reply *dlm_rep;
- int size[3] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body),
- [DLM_LOCKREPLY_OFF] = sizeof(*dlm_rep) };
- int rc = 0;
__u32 flags;
ldlm_error_t err = ELDLM_OK;
struct ldlm_lock *lock = NULL;
void *cookie = NULL;
+ int rc = 0;
ENTRY;
LDLM_DEBUG_NOLOCK("server-side enqueue handler START");
* local_lock_enqueue by the policy function. */
cookie = req;
} else {
- int buffers = 2;
-
lock_res_and_lock(lock);
if (lock->l_resource->lr_lvb_len) {
- size[DLM_REPLY_REC_OFF] = lock->l_resource->lr_lvb_len;
- buffers = 3;
+ req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB,
+ RCL_SERVER,
+ lock->l_resource->lr_lvb_len);
}
unlock_res_and_lock(lock);
if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR))
GOTO(out, rc = -ENOMEM);
- rc = lustre_pack_reply(req, buffers, size, NULL);
+ rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out, rc);
}
if (err)
GOTO(out, err);
- dlm_rep = lustre_msg_buf(req->rq_repmsg, DLM_LOCKREPLY_OFF,
- sizeof(*dlm_rep));
+ dlm_rep = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP);
dlm_rep->lock_flags = flags;
ldlm_lock2desc(lock, &dlm_rep->lock_desc);
LDLM_ERROR(lock, "sync lock");
if (dlm_req->lock_flags & LDLM_FL_HAS_INTENT) {
struct ldlm_intent *it;
- it = lustre_msg_buf(req->rq_reqmsg,
- DLM_INTENT_IT_OFF,
- sizeof(*it));
+
+ it = req_capsule_client_get(&req->rq_pill,
+ &RMF_LDLM_INTENT);
if (it != NULL) {
CERROR("This is intent %s ("LPU64")\n",
ldlm_it2str(it->opc), it->opc);
lock_res_and_lock(lock);
if (rc == 0) {
- size[DLM_REPLY_REC_OFF] = lock->l_resource->lr_lvb_len;
- if (size[DLM_REPLY_REC_OFF] > 0) {
- void *lvb = lustre_msg_buf(req->rq_repmsg,
- DLM_REPLY_REC_OFF,
- size[DLM_REPLY_REC_OFF]);
+ if (lock->l_resource->lr_lvb_len > 0) {
+ void *lvb;
+
+ lvb = req_capsule_server_get(&req->rq_pill,
+ &RMF_DLM_LVB);
LASSERTF(lvb != NULL, "req %p, lock %p\n",
req, lock);
memcpy(lvb, lock->l_resource->lr_lvb_data,
- size[DLM_REPLY_REC_OFF]);
+ lock->l_resource->lr_lvb_len);
}
} else {
ldlm_resource_unlink_lock(lock);
ldlm_blocking_callback blocking_callback,
ldlm_glimpse_callback glimpse_callback)
{
- int rc;
struct ldlm_request *dlm_req;
struct ldlm_callback_suite cbs = {
.lcs_completion = completion_callback,
.lcs_blocking = blocking_callback,
.lcs_glimpse = glimpse_callback
};
+ int rc;
- dlm_req = lustre_swab_reqbuf(req, DLM_LOCKREQ_OFF,
- sizeof *dlm_req, lustre_swab_ldlm_request);
+ dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
if (dlm_req != NULL) {
rc = ldlm_handle_enqueue0(req->rq_export->exp_obd->obd_namespace,
req, dlm_req, &cbs);
} else {
- CERROR ("Can't unpack dlm_req\n");
rc = -EFAULT;
}
return rc;
struct ldlm_reply *dlm_rep;
struct ldlm_lock *lock;
int rc;
- int size[2] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body),
- [DLM_LOCKREPLY_OFF] = sizeof(*dlm_rep) };
ENTRY;
if (req->rq_export && req->rq_export->exp_ldlm_stats)
lprocfs_counter_incr(req->rq_export->exp_ldlm_stats,
LDLM_CONVERT - LDLM_FIRST_OPC);
- rc = lustre_pack_reply(req, 2, size, NULL);
+ rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
RETURN(rc);
- dlm_rep = lustre_msg_buf(req->rq_repmsg, DLM_LOCKREPLY_OFF,
- sizeof(*dlm_rep));
+ dlm_rep = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP);
dlm_rep->lock_flags = dlm_req->lock_flags;
lock = ldlm_handle2lock(&dlm_req->lock_handle[0]);
int rc;
struct ldlm_request *dlm_req;
- dlm_req = lustre_swab_reqbuf(req, DLM_LOCKREQ_OFF, sizeof *dlm_req,
- lustre_swab_ldlm_request);
+ dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
if (dlm_req != NULL) {
rc = ldlm_handle_convert0(req, dlm_req);
} else {
int rc;
ENTRY;
- dlm_req = lustre_swab_reqbuf(req, DLM_LOCKREQ_OFF, sizeof(*dlm_req),
- lustre_swab_ldlm_request);
+ dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
if (dlm_req == NULL) {
- CERROR("bad request buffer for cancel\n");
+ CDEBUG(D_INFO, "bad request buffer for cancel\n");
RETURN(-EFAULT);
}
lprocfs_counter_incr(req->rq_export->exp_ldlm_stats,
LDLM_CANCEL - LDLM_FIRST_OPC);
- rc = lustre_pack_reply(req, 1, NULL, NULL);
+ rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
RETURN(rc);
}
if (lock->l_lvb_len) {
- void *lvb;
- lvb = lustre_swab_reqbuf(req, DLM_REQ_REC_OFF, lock->l_lvb_len,
- lock->l_lvb_swabber);
- if (lvb == NULL) {
+ if (req_capsule_get_size(&req->rq_pill, &RMF_DLM_LVB,
+ RCL_CLIENT) < lock->l_lvb_len) {
LDLM_ERROR(lock, "completion AST did not contain "
"expected LVB!");
} else {
+ void *lvb = req_capsule_client_swab_get(&req->rq_pill,
+ &RMF_DLM_LVB,
+ (void *)lock->l_lvb_swabber);
memcpy(lock->l_lvb_data, lvb, lock->l_lvb_len);
}
}
#endif
}
+/* TODO: handle requests in a similar way as MDT: see mdt_handle_common() */
static int ldlm_callback_handler(struct ptlrpc_request *req)
{
struct ldlm_namespace *ns;
* incoming request message body, but I am responsible for the
* message buffers. */
+ req_capsule_init(&req->rq_pill, req, RCL_SERVER);
+
if (req->rq_export == NULL) {
struct ldlm_request *dlm_req;
libcfs_id2str(req->rq_peer),
lustre_msg_get_handle(req->rq_reqmsg)->cookie);
- dlm_req = lustre_swab_reqbuf(req, DLM_LOCKREQ_OFF,
- sizeof(*dlm_req),
- lustre_swab_ldlm_request);
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_CALLBACK);
+ dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
if (dlm_req != NULL)
CDEBUG(D_RPCTRACE, "--> lock cookie: "LPX64"\n",
dlm_req->lock_handle[0].cookie);
RETURN(0);
break;
case OBD_LOG_CANCEL: /* remove this eventually - for 1.4.0 compat */
+ req_capsule_set(&req->rq_pill, &RQF_LOG_CANCEL);
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOG_CANCEL_NET))
RETURN(0);
rc = llog_origin_handle_cancel(req);
ldlm_callback_reply(req, rc);
RETURN(0);
case OBD_QC_CALLBACK:
+ req_capsule_set(&req->rq_pill, &RQF_QC_CALLBACK);
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_QC_CALLBACK_NET))
RETURN(0);
rc = target_handle_qc_callback(req);
case QUOTA_DQACQ:
case QUOTA_DQREL:
/* reply in handler */
+ req_capsule_set(&req->rq_pill, &RQF_MDS_QUOTA_DQACQ);
rc = target_handle_dqacq_callback(req);
RETURN(0);
case LLOG_ORIGIN_HANDLE_CREATE:
+ req_capsule_set(&req->rq_pill, &RQF_LLOG_ORIGIN_HANDLE_CREATE);
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOGD_NET))
RETURN(0);
rc = llog_origin_handle_create(req);
ldlm_callback_reply(req, rc);
RETURN(0);
case LLOG_ORIGIN_HANDLE_NEXT_BLOCK:
+ req_capsule_set(&req->rq_pill,
+ &RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK);
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOGD_NET))
RETURN(0);
rc = llog_origin_handle_next_block(req);
ldlm_callback_reply(req, rc);
RETURN(0);
case LLOG_ORIGIN_HANDLE_READ_HEADER:
+ req_capsule_set(&req->rq_pill,
+ &RQF_LLOG_ORIGIN_HANDLE_READ_HEADER);
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOGD_NET))
RETURN(0);
rc = llog_origin_handle_read_header(req);
ns = req->rq_export->exp_obd->obd_namespace;
LASSERT(ns != NULL);
- dlm_req = lustre_swab_reqbuf(req, DLM_LOCKREQ_OFF, sizeof(*dlm_req),
- lustre_swab_ldlm_request);
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_CALLBACK);
+
+ dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
if (dlm_req == NULL) {
- CERROR ("can't unpack dlm_req\n");
ldlm_callback_reply(req, -EPROTO);
- RETURN (0);
+ RETURN(0);
}
lock = ldlm_handle2lock_ns(ns, &dlm_req->lock_handle[0]);
switch (lustre_msg_get_opc(req->rq_reqmsg)) {
case LDLM_BL_CALLBACK:
CDEBUG(D_INODE, "blocking ast\n");
+ req_capsule_extend(&req->rq_pill, &RQF_LDLM_BL_CALLBACK);
if (!(lock->l_flags & LDLM_FL_CANCEL_ON_BLOCK))
ldlm_callback_reply(req, 0);
if (ldlm_bl_to_thread_lock(ns, &dlm_req->lock_desc, lock))
break;
case LDLM_CP_CALLBACK:
CDEBUG(D_INODE, "completion ast\n");
+ req_capsule_extend(&req->rq_pill, &RQF_LDLM_CP_CALLBACK);
ldlm_callback_reply(req, 0);
ldlm_handle_cp_callback(req, ns, dlm_req, lock);
break;
case LDLM_GL_CALLBACK:
CDEBUG(D_INODE, "glimpse ast\n");
+ req_capsule_extend(&req->rq_pill, &RQF_LDLM_GL_CALLBACK);
ldlm_handle_gl_callback(req, ns, dlm_req, lock);
break;
default:
* incoming request message body, but I am responsible for the
* message buffers. */
+ req_capsule_init(&req->rq_pill, req, RCL_SERVER);
+
if (req->rq_export == NULL) {
struct ldlm_request *dlm_req;
libcfs_id2str(req->rq_peer),
lustre_msg_get_handle(req->rq_reqmsg)->cookie);
- dlm_req = lustre_swab_reqbuf(req, DLM_LOCKREQ_OFF,
- sizeof(*dlm_req),
- lustre_swab_ldlm_request);
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_CALLBACK);
+ dlm_req = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
if (dlm_req != NULL)
ldlm_lock_dump_handle(D_ERROR,
&dlm_req->lock_handle[0]);
/* XXX FIXME move this back to mds/handler.c, bug 249 */
case LDLM_CANCEL:
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_CANCEL);
CDEBUG(D_INODE, "cancel\n");
if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL))
RETURN(0);
break;
RETURN(0);
case OBD_LOG_CANCEL:
+ req_capsule_set(&req->rq_pill, &RQF_LOG_CANCEL);
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOG_CANCEL_NET))
RETURN(0);
rc = llog_origin_handle_cancel(req);
default:
CERROR("invalid opcode %d\n",
lustre_msg_get_opc(req->rq_reqmsg));
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_CALLBACK);
ldlm_callback_reply(req, -EINVAL);
}
* Thus lock is marked LDLM_FL_CANCELING, and already
* canceled locally. */
ldlm_cli_cancel_list(&blwi->blwi_head,
- blwi->blwi_count, NULL, 0, 0);
+ blwi->blwi_count, NULL, 0);
} else {
ldlm_handle_bl_callback(blwi->blwi_ns, &blwi->blwi_ld,
blwi->blwi_lock);
rc == ELDLM_LOCK_ABORTED ? "ABORTED" : "FAILED");
if (rc == ELDLM_LOCK_ABORTED) {
/* Before we return, swab the reply */
- reply = lustre_swab_repbuf(req, DLM_LOCKREPLY_OFF,
- sizeof(*reply),
- lustre_swab_ldlm_reply);
- if (reply == NULL) {
- CERROR("Can't unpack ldlm_reply\n");
+ reply = req_capsule_server_get(&req->rq_pill,
+ &RMF_DLM_REP);
+ if (reply == NULL)
rc = -EPROTO;
- }
if (lvb_len) {
- void *tmplvb;
- tmplvb = lustre_swab_repbuf(req,
- DLM_REPLY_REC_OFF,
- lvb_len,
- lvb_swabber);
+ struct ost_lvb *tmplvb;
+
+ req_capsule_set_size(&req->rq_pill,
+ &RMF_DLM_LVB, RCL_SERVER,
+ lvb_len);
+ tmplvb = req_capsule_server_swab_get(&req->rq_pill,
+ &RMF_DLM_LVB,
+ lvb_swabber);
if (tmplvb == NULL)
GOTO(cleanup, rc = -EPROTO);
if (lvb != NULL)
GOTO(cleanup, rc);
}
- reply = lustre_swab_repbuf(req, DLM_LOCKREPLY_OFF, sizeof(*reply),
- lustre_swab_ldlm_reply);
- if (reply == NULL) {
- CERROR("Can't unpack ldlm_reply\n");
+ reply = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP);
+ if (reply == NULL)
GOTO(cleanup, rc = -EPROTO);
- }
/* lock enqueued on the server */
cleanup_phase = 0;
* clobber the LVB with an older one. */
if (lvb_len && (lock->l_req_mode != lock->l_granted_mode)) {
void *tmplvb;
- tmplvb = lustre_swab_repbuf(req, DLM_REPLY_REC_OFF, lvb_len,
- lvb_swabber);
+
+ req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER,
+ lvb_len);
+ tmplvb = req_capsule_server_swab_get(&req->rq_pill,
+ &RMF_DLM_LVB,
+ lvb_swabber);
if (tmplvb == NULL)
GOTO(cleanup, rc = -EPROTO);
memcpy(lock->l_lvb_data, tmplvb, lvb_len);
/* Cancel lru locks and pack them into the enqueue request. Pack there the given
* @count locks in @cancels. */
-struct ptlrpc_request *ldlm_prep_elc_req(struct obd_export *exp, int version,
- int opc, int bufcount, int *size,
- int bufoff, int canceloff,
- struct list_head *cancels, int count)
+int ldlm_prep_elc_req(struct obd_export *exp, struct ptlrpc_request *req,
+ int version, int opc, int canceloff,
+ struct list_head *cancels, int count)
{
- struct ldlm_namespace *ns = exp->exp_obd->obd_namespace;
- int flags, avail, to_free, pack = 0;
- struct ldlm_request *dlm = NULL;
- struct ptlrpc_request *req;
- CFS_LIST_HEAD(head);
+ struct ldlm_namespace *ns = exp->exp_obd->obd_namespace;
+ struct req_capsule *pill = &req->rq_pill;
+ struct ldlm_request *dlm = NULL;
+ int flags, avail, to_free, bufcount, pack = 0;
+ int rc;
ENTRY;
- if (cancels == NULL)
- cancels = &head;
+
+ LASSERT(cancels != NULL);
+
if (exp_connect_cancelset(exp)) {
/* Estimate the amount of available space in the request. */
- avail = ldlm_req_handles_avail(exp, size, bufcount,
- bufoff, canceloff);
+ bufcount = req_capsule_filled_sizes(pill, RCL_CLIENT);
+ avail = ldlm_req_handles_avail(exp, pill->rc_area[RCL_CLIENT],
+ bufcount, bufcount - 1, canceloff);
flags = ns_connect_lru_resize(ns) ?
LDLM_CANCEL_LRUR : LDLM_CANCEL_AGED;
to_free = !ns_connect_lru_resize(ns) &&
pack = count;
else
pack = avail;
- size[bufoff] = ldlm_request_bufsize(pack, opc);
+ req_capsule_set_size(&req->rq_pill, &RMF_DLM_REQ, RCL_CLIENT,
+ ldlm_request_bufsize(count, opc));
}
- req = ptlrpc_prep_req(class_exp2cliimp(exp), version,
- opc, bufcount, size, NULL);
- if (exp_connect_cancelset(exp) && req) {
+
+ rc = ptlrpc_request_pack(req, version, opc);
+ if (rc) {
+ ldlm_lock_list_put(cancels, l_bl_ast, count);
+ RETURN(rc);
+ }
+
+ if (exp_connect_cancelset(exp)) {
if (canceloff) {
- dlm = lustre_msg_buf(req->rq_reqmsg, bufoff,
- sizeof(*dlm));
+ dlm = req_capsule_client_get(pill, &RMF_DLM_REQ);
+ LASSERT(dlm);
/* Skip first lock handler in ldlm_request_pack(),
* this method will incrment @lock_count according
* to the lock handle amount actually written to
dlm->lock_count = canceloff;
}
/* Pack into the request @pack lock handles. */
- ldlm_cli_cancel_list(cancels, pack, req, bufoff, 0);
+ ldlm_cli_cancel_list(cancels, pack, req, 0);
/* Prepare and send separate cancel rpc for others. */
- ldlm_cli_cancel_list(cancels, count - pack, NULL, 0, 0);
+ ldlm_cli_cancel_list(cancels, count - pack, NULL, 0);
} else {
ldlm_lock_list_put(cancels, l_bl_ast, count);
}
- RETURN(req);
+ RETURN(0);
}
-struct ptlrpc_request *ldlm_prep_enqueue_req(struct obd_export *exp,
- int bufcount, int *size,
- struct list_head *cancels,
- int count)
+int ldlm_prep_enqueue_req(struct obd_export *exp,
+ struct ptlrpc_request *req,
+ struct list_head *cancels,
+ int count)
{
- return ldlm_prep_elc_req(exp, LUSTRE_DLM_VERSION, LDLM_ENQUEUE,
- bufcount, size, DLM_LOCKREQ_OFF,
+ return ldlm_prep_elc_req(exp, req, LUSTRE_DLM_VERSION, LDLM_ENQUEUE,
LDLM_ENQUEUE_CANCEL_OFF, cancels, count);
}
struct lustre_handle *lockh, int async)
{
struct ldlm_namespace *ns = exp->exp_obd->obd_namespace;
- struct ldlm_lock *lock;
- struct ldlm_request *body;
- struct ldlm_reply *reply;
- int size[3] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body),
- [DLM_LOCKREQ_OFF] = sizeof(*body),
- [DLM_REPLY_REC_OFF] = lvb_len };
- int is_replay = *flags & LDLM_FL_REPLAY;
- int req_passed_in = 1, rc, err;
+ struct ldlm_lock *lock;
+ struct ldlm_request *body;
+ int is_replay = *flags & LDLM_FL_REPLAY;
+ int req_passed_in = 1;
+ int rc, err;
struct ptlrpc_request *req;
ENTRY;
/* lock not sent to server yet */
if (reqp == NULL || *reqp == NULL) {
- req = ldlm_prep_enqueue_req(exp, 2, size, NULL, 0);
+ req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp),
+ &RQF_LDLM_ENQUEUE,
+ LUSTRE_DLM_VERSION,
+ LDLM_ENQUEUE);
if (req == NULL) {
failed_lock_cleanup(ns, lock, lockh, einfo->ei_mode);
LDLM_LOCK_PUT(lock);
if (reqp)
*reqp = req;
} else {
+ int len;
+
req = *reqp;
- LASSERTF(lustre_msg_buflen(req->rq_reqmsg, DLM_LOCKREQ_OFF) >=
- sizeof(*body), "buflen[%d] = %d, not "LPSZ"\n",
- DLM_LOCKREQ_OFF,
- lustre_msg_buflen(req->rq_reqmsg, DLM_LOCKREQ_OFF),
- sizeof(*body));
+ len = req_capsule_get_size(&req->rq_pill, &RMF_DLM_REQ,
+ RCL_CLIENT);
+ LASSERTF(len >= sizeof(*body), "buflen[%d] = %d, not %d\n",
+ DLM_LOCKREQ_OFF, len, sizeof(*body));
}
lock->l_conn_export = exp;
lock->l_blocking_ast = einfo->ei_cb_bl;
/* Dump lock data into the request buffer */
- body = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF, sizeof(*body));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
ldlm_lock2desc(lock, &body->lock_desc);
body->lock_flags = *flags;
body->lock_handle[0] = *lockh;
/* Continue as normal. */
if (!req_passed_in) {
- size[DLM_LOCKREPLY_OFF] = sizeof(*reply);
- ptlrpc_req_set_repsize(req, 2 + (lvb_len > 0), size);
+ if (lvb_len > 0) {
+ req_capsule_extend(&req->rq_pill,
+ &RQF_LDLM_ENQUEUE_LVB);
+ req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB,
+ RCL_SERVER, lvb_len);
+ }
+ ptlrpc_request_set_replen(req);
}
/*
accounting */
int ldlm_cli_convert(struct lustre_handle *lockh, int new_mode, __u32 *flags)
{
- struct ldlm_request *body;
- struct ldlm_reply *reply;
- struct ldlm_lock *lock;
- struct ldlm_resource *res;
+ struct ldlm_request *body;
+ struct ldlm_reply *reply;
+ struct ldlm_lock *lock;
+ struct ldlm_resource *res;
struct ptlrpc_request *req;
- int size[2] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body),
- [DLM_LOCKREQ_OFF] = sizeof(*body) };
- int rc;
+ int rc;
ENTRY;
lock = ldlm_handle2lock(lockh);
LDLM_DEBUG(lock, "client-side convert");
- req = ptlrpc_prep_req(class_exp2cliimp(lock->l_conn_export),
- LUSTRE_DLM_VERSION, LDLM_CONVERT, 2, size, NULL);
- if (!req)
- GOTO(out, rc = -ENOMEM);
+ req = ptlrpc_request_alloc_pack(class_exp2cliimp(lock->l_conn_export),
+ &RQF_LDLM_CONVERT, LUSTRE_DLM_VERSION,
+ LDLM_CONVERT);
+ if (req == NULL) {
+ LDLM_LOCK_PUT(lock);
+ RETURN(-ENOMEM);
+ }
- body = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF, sizeof(*body));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
body->lock_handle[0] = lock->l_remote_handle;
body->lock_desc.l_req_mode = new_mode;
body->lock_flags = *flags;
- size[DLM_LOCKREPLY_OFF] = sizeof(*reply);
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
if (rc != ELDLM_OK)
GOTO(out, rc);
- reply = lustre_swab_repbuf(req, DLM_LOCKREPLY_OFF, sizeof(*reply),
- lustre_swab_ldlm_reply);
- if (reply == NULL) {
- CERROR ("Can't unpack ldlm_reply\n");
- GOTO (out, rc = -EPROTO);
- }
+ reply = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP);
+ if (reply == NULL)
+ GOTO(out, rc = -EPROTO);
if (req->rq_status)
GOTO(out, rc = req->rq_status);
/* Pack @count locks in @head into ldlm_request buffer at the offset @off,
of the request @req. */
-static void ldlm_cancel_pack(struct ptlrpc_request *req, int off,
+static void ldlm_cancel_pack(struct ptlrpc_request *req,
struct list_head *head, int count)
{
struct ldlm_request *dlm;
int max, packed = 0;
ENTRY;
- dlm = lustre_msg_buf(req->rq_reqmsg, off, sizeof(*dlm));
+ dlm = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
LASSERT(dlm != NULL);
/* Check the room in the request buffer. */
- max = lustre_msg_buflen(req->rq_reqmsg, off) -
+ max = req_capsule_get_size(&req->rq_pill, &RMF_DLM_REQ, RCL_CLIENT) -
sizeof(struct ldlm_request);
max /= sizeof(struct lustre_handle);
max += LDLM_LOCKREQ_HANDLES;
int count, int flags)
{
struct ptlrpc_request *req = NULL;
- struct ldlm_request *body;
- int size[2] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body),
- [DLM_LOCKREQ_OFF] = sizeof(*body) };
struct obd_import *imp;
int free, sent = 0;
int rc = 0;
if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL_RACE))
RETURN(count);
- free = ldlm_req_handles_avail(exp, size, 2, DLM_LOCKREQ_OFF, 0);
- if (count > free)
- count = free;
-
- size[DLM_LOCKREQ_OFF] = ldlm_request_bufsize(count, LDLM_CANCEL);
while (1) {
+ int bufcount;
+ struct req_capsule *pill;
imp = class_exp2cliimp(exp);
if (imp == NULL || imp->imp_invalid) {
CDEBUG(D_DLMTRACE,
RETURN(count);
}
- req = ptlrpc_prep_req(imp, LUSTRE_DLM_VERSION, LDLM_CANCEL, 2,
- size, NULL);
- if (!req)
+ req = ptlrpc_request_alloc(imp, &RQF_LDLM_CANCEL);
+ if (req == NULL)
GOTO(out, rc = -ENOMEM);
+ pill = &req->rq_pill;
+ bufcount = req_capsule_filled_sizes(pill, RCL_CLIENT);
+
+ free = ldlm_req_handles_avail(exp, pill->rc_area[RCL_CLIENT],
+ bufcount, bufcount, 0);
+ if (count > free)
+ count = free;
+
+ req_capsule_set_size(&req->rq_pill, &RMF_DLM_REQ, RCL_CLIENT,
+ ldlm_request_bufsize(count, LDLM_CANCEL));
+
+ rc = ptlrpc_request_pack(req, LUSTRE_DLM_VERSION, LDLM_CANCEL);
+ if (rc) {
+ ptlrpc_request_free(req);
+ GOTO(out, rc);
+ }
req->rq_no_resend = 1;
req->rq_no_delay = 1;
req->rq_request_portal = LDLM_CANCEL_REQUEST_PORTAL;
req->rq_reply_portal = LDLM_CANCEL_REPLY_PORTAL;
- body = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF,
- sizeof(*body));
- ldlm_cancel_pack(req, DLM_LOCKREQ_OFF, cancels, count);
+ ldlm_cancel_pack(req, cancels, count);
- ptlrpc_req_set_repsize(req, 1, NULL);
+ ptlrpc_request_set_replen(req);
if (flags & LDLM_FL_ASYNC) {
ptlrpcd_add_req(req);
sent = count;
count += ldlm_cancel_lru_local(ns, &cancels, 0, avail - 1,
LDLM_FL_BL_AST, flags);
}
- ldlm_cli_cancel_list(&cancels, count, NULL, 0, 0);
+ ldlm_cli_cancel_list(&cancels, count, NULL, 0);
RETURN(0);
}
}
if (bl_ast > 0) {
count -= bl_ast;
- ldlm_cli_cancel_list(&head, bl_ast, NULL, 0, 0);
+ ldlm_cli_cancel_list(&head, bl_ast, NULL, 0);
}
RETURN(count);
/* If an error occured in ASYNC mode, or
* this is SYNC mode, cancel the list. */
- ldlm_cli_cancel_list(&cancels, count, NULL, 0, 0);
+ ldlm_cli_cancel_list(&cancels, count, NULL, 0);
RETURN(count);
}
* buffer at the offset @off.
* Destroy @cancels at the end. */
int ldlm_cli_cancel_list(struct list_head *cancels, int count,
- struct ptlrpc_request *req, int off, int flags)
+ struct ptlrpc_request *req, int flags)
{
struct ldlm_lock *lock;
int res = 0;
if (exp_connect_cancelset(lock->l_conn_export)) {
res = count;
if (req)
- ldlm_cancel_pack(req, off, cancels, count);
+ ldlm_cancel_pack(req, cancels, count);
else
res = ldlm_cli_cancel_req(lock->l_conn_export,
cancels, count,
count = ldlm_cancel_resource_local(res, &cancels, policy, mode,
0, flags, opaque);
- rc = ldlm_cli_cancel_list(&cancels, count, NULL, 0, flags);
+ rc = ldlm_cli_cancel_list(&cancels, count, NULL, flags);
if (rc != ELDLM_OK)
CERROR("ldlm_cli_cancel_unused_resource: %d\n", rc);
static int replay_lock_interpret(struct ptlrpc_request *req,
struct ldlm_async_args *aa, int rc)
{
- struct ldlm_lock *lock;
+ struct ldlm_lock *lock;
struct ldlm_reply *reply;
ENTRY;
GOTO(out, rc);
- reply = lustre_swab_repbuf(req, DLM_LOCKREPLY_OFF, sizeof(*reply),
- lustre_swab_ldlm_reply);
- if (reply == NULL) {
- CERROR("Can't unpack ldlm_reply\n");
- GOTO (out, rc = -EPROTO);
- }
+ reply = req_capsule_server_get(&req->rq_pill, &RMF_DLM_REP);
+ if (reply == NULL)
+ GOTO(out, rc = -EPROTO);
lock = ldlm_handle2lock(&aa->lock_handle);
if (!lock) {
static int replay_one_lock(struct obd_import *imp, struct ldlm_lock *lock)
{
struct ptlrpc_request *req;
- struct ldlm_request *body;
- struct ldlm_reply *reply;
struct ldlm_async_args *aa;
- int buffers = 2;
- int size[3] = { sizeof(struct ptlrpc_body) };
+ struct ldlm_request *body;
int flags;
ENTRY;
else
flags = LDLM_FL_REPLAY;
- size[DLM_LOCKREQ_OFF] = sizeof(*body);
- req = ptlrpc_prep_req(imp, LUSTRE_DLM_VERSION, LDLM_ENQUEUE, 2, size,
- NULL);
- if (!req)
+ req = ptlrpc_request_alloc_pack(imp, &RQF_LDLM_ENQUEUE,
+ LUSTRE_DLM_VERSION, LDLM_ENQUEUE);
+ if (req == NULL)
RETURN(-ENOMEM);
/* We're part of recovery, so don't wait for it. */
req->rq_send_state = LUSTRE_IMP_REPLAY_LOCKS;
- body = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF, sizeof(*body));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_DLM_REQ);
ldlm_lock2desc(lock, &body->lock_desc);
body->lock_flags = flags;
ldlm_lock2handle(lock, &body->lock_handle[0]);
- size[DLM_LOCKREPLY_OFF] = sizeof(*reply);
if (lock->l_lvb_len != 0) {
- buffers = 3;
- size[DLM_REPLY_REC_OFF] = lock->l_lvb_len;
+ req_capsule_extend(&req->rq_pill, &RQF_LDLM_ENQUEUE_LVB);
+ req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER,
+ lock->l_lvb_len);
}
- ptlrpc_req_set_repsize(req, buffers, size);
+ ptlrpc_request_set_replen(req);
/* notify the server we've replayed all requests.
* also, we mark the request to be put on a dedicated
* queue to be processed after all request replayes.
rc = md_readpage(sbi->ll_md_exp, &lli->lli_fid, NULL,
offset, page, &request);
if (!rc) {
- body = lustre_msg_buf(request->rq_repmsg, REPLY_REC_OFF,
- sizeof(*body));
+ body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY);
LASSERT(body != NULL); /* checked by md_readpage() */
- /* swabbed by md_readpage() */
- LASSERT(lustre_rep_swabbed(request, REPLY_REC_OFF));
if (body->valid & OBD_MD_FLSIZE)
st->st_size = body->size;
struct mdt_body *body;
ENTRY;
- body = lustre_msg_buf(req->rq_repmsg, DLM_REPLY_REC_OFF, sizeof(*body));
- LASSERT(body != NULL); /* reply already checked out */
- /* and swabbed down */
- LASSERT(lustre_rep_swabbed(req, DLM_REPLY_REC_OFF));
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
+ LASSERT(body != NULL);
/* already opened? */
if (lli->lli_open_count++)
RETURN(rc);
}
-int llu_objects_destroy(struct ptlrpc_request *request, struct inode *dir)
+int llu_objects_destroy(struct ptlrpc_request *req, struct inode *dir)
{
struct mdt_body *body;
struct lov_mds_md *eadata;
int rc;
ENTRY;
- /* req is swabbed so this is safe */
- body = lustre_msg_buf(request->rq_repmsg, REPLY_REC_OFF, sizeof(*body));
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
if (!(body->valid & OBD_MD_FLEASIZE))
RETURN(0);
* to this file. Use this EA to unlink the objects on the OST.
* It's opaque so we don't swab here; we leave it to obd_unpackmd() to
* check it is complete and sensible. */
- eadata = lustre_swab_repbuf(request, REPLY_REC_OFF+1, body->eadatasize,
- NULL);
+ eadata = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD,
+ body->eadatasize);
+
LASSERT(eadata != NULL);
- if (eadata == NULL) {
- CERROR("Can't unpack MDS EA data\n");
- GOTO(out, rc = -EPROTO);
- }
rc = obd_unpackmd(llu_i2obdexp(dir), &lsm, eadata,body->eadatasize);
if (rc < 0) {
if (body->valid & OBD_MD_FLCOOKIE) {
oa->o_valid |= OBD_MD_FLCOOKIE;
oti.oti_logcookies =
- lustre_msg_buf(request->rq_repmsg, REPLY_REC_OFF + 2,
- sizeof(struct llog_cookie) *
- lsm->lsm_stripe_count);
+ req_capsule_server_sized_get(&req->rq_pill,
+ &RMF_LOGCOOKIES,
+ sizeof(struct llog_cookie) *
+ lsm->lsm_stripe_count);
if (oti.oti_logcookies == NULL) {
oa->o_valid &= ~OBD_MD_FLCOOKIE;
body->valid &= ~OBD_MD_FLCOOKIE;
if (ocd == NULL)
GOTO(out_cleanup, rc = -ENOMEM);
- ocd->ocd_connect_flags = OBD_CONNECT_VERSION;
+ ocd->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_FID;
#ifdef LIBLUSTRE_POSIX_ACL
ocd->ocd_connect_flags |= OBD_CONNECT_ACL;
#endif
}
static int pnode_revalidate_finish(struct ptlrpc_request *req,
- int offset,
struct lookup_intent *it,
struct pnode *pnode)
{
RETURN(-ENOENT);
rc = md_get_lustre_md(llu_i2sbi(inode)->ll_md_exp, req,
- offset, llu_i2sbi(inode)->ll_dt_exp,
+ llu_i2sbi(inode)->ll_dt_exp,
llu_i2sbi(inode)->ll_md_exp, &md);
if (rc)
RETURN(rc);
if (rc < 0)
GOTO(out, rc = 0);
- rc = pnode_revalidate_finish(req, DLM_REPLY_REC_OFF, it, pnode);
+ rc = pnode_revalidate_finish(req, it, pnode);
if (rc != 0) {
ll_intent_release(it);
GOTO(out, rc = 0);
if (it_disposition(it, DISP_OPEN_CREATE))
ptlrpc_req_finished(request);
- rc = md_get_lustre_md(sbi->ll_md_exp, request, offset,
+ rc = md_get_lustre_md(sbi->ll_md_exp, request,
sbi->ll_dt_exp, sbi->ll_md_exp, &md);
if (rc)
RETURN(rc);
struct inode *inode = llu_inode_from_lock(lock);
struct llu_inode_info *lli;
struct ost_lvb *lvb;
- int size[2] = { sizeof(struct ptlrpc_body), sizeof(*lvb) };
int rc, stripe = 0;
ENTRY;
if (lli->lli_smd->lsm_stripe_count > 1)
stripe = llu_lock_to_stripe_offset(inode, lock);
- rc = lustre_pack_reply(req, 2, size, NULL);
- if (rc)
+ req_capsule_extend(&req->rq_pill, &RQF_LDLM_GL_CALLBACK);
+ req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER,
+ sizeof(*lvb));
+ rc = req_capsule_server_pack(&req->rq_pill);
+ if (rc) {
+ CERROR("failed pack reply: %d\n", rc);
GOTO(iput, rc);
+ }
- lvb = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*lvb));
+ lvb = req_capsule_server_get(&req->rq_pill, &RMF_DLM_LVB);
lvb->lvb_size = lli->lli_smd->lsm_oinfo[stripe]->loi_kms;
LDLM_DEBUG(lock, "i_size: %llu -> stripe number %u -> kms "LPU64,
(long long)llu_i2stat(inode)->st_ino);
RETURN(-abs(rc));
}
- rc = md_get_lustre_md(sbi->ll_md_exp, req, REPLY_REC_OFF,
+ rc = md_get_lustre_md(sbi->ll_md_exp, req,
sbi->ll_dt_exp, sbi->ll_md_exp, &md);
/* XXX Too paranoid? */
RETURN(rc);
}
- rc = md_get_lustre_md(sbi->ll_md_exp, request, REPLY_REC_OFF,
+ rc = md_get_lustre_md(sbi->ll_md_exp, request,
sbi->ll_dt_exp, sbi->ll_md_exp, &md);
if (rc) {
ptlrpc_req_finished(request);
RETURN(rc);
}
- body = lustre_msg_buf((*request)->rq_repmsg, REPLY_REC_OFF,
- sizeof(*body));
+ body = req_capsule_server_get(&(*request)->rq_pill, &RMF_MDT_BODY);
LASSERT(body != NULL);
- LASSERT(lustre_rep_swabbed(*request, REPLY_REC_OFF));
if ((body->valid & OBD_MD_LINKNAME) == 0) {
CERROR ("OBD_MD_LINKNAME not set on reply\n");
GOTO(failed, rc = -EPROTO);
}
- *symname = lustre_msg_buf((*request)->rq_repmsg, REPLY_REC_OFF + 1,
- symlen);
+ *symname = req_capsule_server_get(&(*request)->rq_pill, &RMF_MDT_MD);
if (*symname == NULL ||
strnlen(*symname, symlen) != symlen - 1) {
/* not full/NULL terminated */
}
rc = md_get_lustre_md(sbi->ll_md_exp, req,
- DLM_REPLY_REC_OFF, sbi->ll_dt_exp, sbi->ll_md_exp, &md);
+ sbi->ll_dt_exp, sbi->ll_md_exp, &md);
if (rc)
GOTO(out, rc);
obd_set_info_async(obd->obd_self_export, strlen("async"), "async",
sizeof(async), &async, NULL);
- ocd.ocd_connect_flags = OBD_CONNECT_IBITS | OBD_CONNECT_VERSION;
+ ocd.ocd_connect_flags = OBD_CONNECT_IBITS | OBD_CONNECT_VERSION |
+ OBD_CONNECT_FID;
#ifdef LIBLUSTRE_POSIX_ACL
ocd.ocd_connect_flags |= OBD_CONNECT_ACL;
#endif
GOTO(out_dt, err);
}
- err = md_get_lustre_md(sbi->ll_md_exp, request, REPLY_REC_OFF,
+ err = md_get_lustre_md(sbi->ll_md_exp, request,
sbi->ll_dt_exp, sbi->ll_md_exp, &md);
if (err) {
CERROR("failed to understand root inode md: rc = %d\n",err);
}
int ll_revalidate_it_finish(struct ptlrpc_request *request,
- int offset, struct lookup_intent *it,
+ struct lookup_intent *it,
struct dentry *de)
{
int rc = 0;
if (it_disposition(it, DISP_LOOKUP_NEG))
RETURN(-ENOENT);
- rc = ll_prep_inode(&de->d_inode,
- request, offset, NULL);
+ rc = ll_prep_inode(&de->d_inode, request, NULL);
RETURN(rc);
}
}
revalidate_finish:
- rc = ll_revalidate_it_finish(req, DLM_REPLY_REC_OFF, it, de);
+ rc = ll_revalidate_it_finish(req, it, de);
if (rc != 0) {
if (rc != -ESTALE && rc != -ENOENT)
ll_intent_release(it);
rc = md_intent_lock(exp, op_data, NULL, 0, it, 0, &req,
ll_md_blocking_ast, 0);
if (rc >= 0) {
- struct mdt_body *mdt_body = lustre_msg_buf(req->rq_repmsg,
- DLM_REPLY_REC_OFF,
- sizeof(*mdt_body));
+ struct mdt_body *mdt_body;
struct lu_fid fid = {.f_seq = 0, .f_oid = 0, .f_ver = 0};
-
+ mdt_body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
+
if (de->d_inode)
fid = *ll_inode2fid(de->d_inode);
oc, hash, page, &request);
capa_put(oc);
if (!rc) {
- body = lustre_msg_buf(request->rq_repmsg, REPLY_REC_OFF,
- sizeof(*body));
+ body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY);
/* Checked by mdc_readpage() */
LASSERT(body != NULL);
- /* Swabbed by mdc_readpage() */
- LASSERT(lustre_rep_swabbed(request, REPLY_REC_OFF));
-
if (body->valid & OBD_MD_FLSIZE) {
ll_inode_size_lock(inode, 0);
i_size_write(inode, body->size);
GOTO(out, rc);
}
- body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*body));
- LASSERT(body != NULL); /* checked by md_getattr_name */
- /* swabbed by mdc_getattr_name */
- LASSERT(lustre_rep_swabbed(req, REPLY_REC_OFF));
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
+ LASSERT(body != NULL);
lmmsize = body->eadatasize;
GOTO(out, rc = -ENODATA);
}
- lmm = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, lmmsize);
+ lmm = req_capsule_server_sized_get(&req->rq_pill,
+ &RMF_MDT_MD, lmmsize);
LASSERT(lmm != NULL);
- LASSERT(lustre_rep_swabbed(req, REPLY_REC_OFF + 1));
/*
* This is coming from the MDS, so is probably in
}
if (request) {
- body = lustre_msg_buf(request->rq_repmsg,
- REPLY_REC_OFF, sizeof(*body));
- LASSERT(body != NULL); /* checked by md_getattr_name */
- /* swabbed by md_getattr_name */
- LASSERT(lustre_rep_swabbed(request, REPLY_REC_OFF));
+ body = req_capsule_server_get(&request->rq_pill,
+ &RMF_MDT_BODY);
+ LASSERT(body != NULL);
} else {
GOTO(out_req, rc);
}
}
case OBD_IOC_LLOG_CATINFO: {
struct ptlrpc_request *req = NULL;
- char *buf = NULL;
- int rc, len = 0;
- char *bufs[3] = { NULL }, *str;
- int lens[3] = { sizeof(struct ptlrpc_body) };
- int size[2] = { sizeof(struct ptlrpc_body) };
+ char *buf = NULL;
+ char *str;
+ int len = 0;
+ int rc;
rc = obd_ioctl_getdata(&buf, &len, (void *)arg);
if (rc)
RETURN(-EINVAL);
}
- lens[REQ_REC_OFF] = data->ioc_inllen1;
- bufs[REQ_REC_OFF] = data->ioc_inlbuf1;
- if (data->ioc_inllen2) {
- lens[REQ_REC_OFF + 1] = data->ioc_inllen2;
- bufs[REQ_REC_OFF + 1] = data->ioc_inlbuf2;
- } else {
- lens[REQ_REC_OFF + 1] = 0;
- bufs[REQ_REC_OFF + 1] = NULL;
+ req = ptlrpc_request_alloc(sbi2mdc(sbi)->cl_import,
+ &RQF_LLOG_CATINFO);
+ if (req == NULL)
+ GOTO(out_catinfo, rc = -ENOMEM);
+
+ req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT,
+ data->ioc_inllen1);
+ req_capsule_set_size(&req->rq_pill, &RMF_STRING, RCL_CLIENT,
+ data->ioc_inllen2);
+
+ rc = ptlrpc_request_pack(req, LUSTRE_LOG_VERSION, LLOG_CATINFO);
+ if (rc) {
+ ptlrpc_request_free(req);
+ GOTO(out_catinfo, rc);
}
- req = ptlrpc_prep_req(sbi2mdc(sbi)->cl_import,
- LUSTRE_LOG_VERSION, LLOG_CATINFO, 3, lens,
- bufs);
- if (!req)
- GOTO(out_catinfo, rc = -ENOMEM);
+ str = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
+ memcpy(str, data->ioc_inlbuf1, data->ioc_inllen1);
+ if (data->ioc_inllen2) {
+ str = req_capsule_client_get(&req->rq_pill,
+ &RMF_STRING);
+ memcpy(str, data->ioc_inlbuf2, data->ioc_inllen2);
+ }
- size[REPLY_REC_OFF] = data->ioc_plen1;
- ptlrpc_req_set_repsize(req, 2, size);
+ req_capsule_set_size(&req->rq_pill, &RMF_STRING, RCL_SERVER,
+ data->ioc_plen1);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
if (!rc) {
- str = lustre_msg_string(req->rq_repmsg, REPLY_REC_OFF,
- data->ioc_plen1);
+ str = req_capsule_server_get(&req->rq_pill,
+ &RMF_STRING);
rc = copy_to_user(data->ioc_pbuf1, str, data->ioc_plen1);
}
ptlrpc_req_finished(req);
&itp->d.lustre.it_lock_handle,
file->f_dentry->d_inode);
- rc = ll_prep_inode(&file->f_dentry->d_inode, req, DLM_REPLY_REC_OFF,
- NULL);
+ rc = ll_prep_inode(&file->f_dentry->d_inode, req, NULL);
out:
ptlrpc_req_finished(itp->d.lustre.it_data);
LASSERT(och);
- body = lustre_msg_buf(req->rq_repmsg, DLM_REPLY_REC_OFF, sizeof(*body));
- /* reply already checked out */
- LASSERT(body != NULL);
- /* and swabbed in md_enqueue */
- LASSERT(lustre_rep_swabbed(req, DLM_REPLY_REC_OFF));
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
+ LASSERT(body != NULL); /* reply already checked out */
memcpy(&och->och_fh, &body->handle, sizeof(body->handle));
och->och_magic = OBD_CLIENT_HANDLE_MAGIC;
if (rc)
RETURN(rc);
- body = lustre_msg_buf(req->rq_repmsg,
- DLM_REPLY_REC_OFF, sizeof(*body));
-
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
if ((it->it_flags & FMODE_WRITE) &&
(body->valid & OBD_MD_FLSIZE))
- {
CDEBUG(D_INODE, "Epoch "LPU64" opened on "DFID"\n",
lli->lli_ioepoch, PFID(&lli->lli_fid));
- }
}
LUSTRE_FPRIVATE(file) = fd;
struct lov_stripe_md *lsm;
struct ost_lvb *lvb;
int rc, stripe;
- int size[2] = { sizeof(struct ptlrpc_body), sizeof(*lvb) };
ENTRY;
if (inode == NULL)
if (stripe < 0)
GOTO(iput, rc = -ELDLM_NO_LOCK_DATA);
- rc = lustre_pack_reply(req, 2, size, NULL);
- if (rc)
+ req_capsule_extend(&req->rq_pill, &RQF_LDLM_GL_CALLBACK);
+ req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER,
+ sizeof(*lvb));
+ rc = req_capsule_server_pack(&req->rq_pill);
+ if (rc) {
+ CERROR("lustre_pack_reply: %d\n", rc);
GOTO(iput, rc);
+ }
- lvb = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*lvb));
+ lvb = req_capsule_server_get(&req->rq_pill, &RMF_DLM_LVB);
lvb->lvb_size = lli->lli_smd->lsm_oinfo[stripe]->loi_kms;
lvb->lvb_mtime = LTIME_S(inode->i_mtime);
lvb->lvb_atime = LTIME_S(inode->i_atime);
GOTO(out, rc);
}
- body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*body));
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
LASSERT(body != NULL); /* checked by mdc_getattr_name */
- /* swabbed by mdc_getattr_name */
- LASSERT(lustre_rep_swabbed(req, REPLY_REC_OFF));
lmmsize = body->eadatasize;
GOTO(out, rc = -ENODATA);
}
- lmm = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, lmmsize);
+ lmm = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD, lmmsize);
LASSERT(lmm != NULL);
- LASSERT(lustre_rep_swabbed(req, REPLY_REC_OFF + 1));
/*
* This is coming from the MDS, so is probably in
GOTO (out, rc);
}
- rc = ll_revalidate_it_finish(req, DLM_REPLY_REC_OFF, &oit, dentry);
+ rc = ll_revalidate_it_finish(req, &oit, dentry);
if (rc != 0) {
ll_intent_release(&oit);
GOTO(out, rc);
RETURN(rc);
}
- rc = ll_prep_inode(&inode, req, REPLY_REC_OFF,
- NULL);
+ rc = ll_prep_inode(&inode, req, NULL);
if (rc)
GOTO(out, rc);
}
extern struct inode_operations ll_dir_inode_operations;
/* llite/namei.c */
-int ll_objects_destroy(struct ptlrpc_request *request, struct inode *dir);
+int ll_objects_destroy(struct ptlrpc_request *request,
+ struct inode *dir);
struct inode *ll_iget(struct super_block *sb, ino_t hash,
struct lustre_md *lic);
struct dentry *ll_find_alias(struct inode *, struct dentry *);
void ll_frob_intent(struct lookup_intent **itp, struct lookup_intent *deft);
void ll_lookup_finish_locks(struct lookup_intent *it, struct dentry *dentry);
int ll_dcompare(struct dentry *parent, struct qstr *d_name, struct qstr *name);
-int ll_revalidate_it_finish(struct ptlrpc_request *request, int offset,
+int ll_revalidate_it_finish(struct ptlrpc_request *request,
struct lookup_intent *it, struct dentry *de);
/* llite/llite_lib.c */
#endif
int ll_remount_fs(struct super_block *sb, int *flags, char *data);
int ll_prep_inode(struct inode **inode, struct ptlrpc_request *req,
- int offset, struct super_block *);
+ struct super_block *);
void lustre_dump_dentry(struct dentry *, int recur);
void lustre_dump_inode(struct inode *);
struct ll_async_page *llite_pglist_next_llap(struct ll_sb_info *sbi,
}
/* indicate the features supported by this client */
- data->ocd_connect_flags = OBD_CONNECT_IBITS | OBD_CONNECT_NODEVOH |
- OBD_CONNECT_JOIN |
- OBD_CONNECT_ATTRFID | OBD_CONNECT_VERSION |
- OBD_CONNECT_MDS_CAPA | OBD_CONNECT_OSS_CAPA |
- OBD_CONNECT_CANCELSET;
+ data->ocd_connect_flags = OBD_CONNECT_IBITS | OBD_CONNECT_NODEVOH |
+ OBD_CONNECT_JOIN | OBD_CONNECT_ATTRFID |
+ OBD_CONNECT_VERSION | OBD_CONNECT_MDS_CAPA |
+ OBD_CONNECT_OSS_CAPA | OBD_CONNECT_CANCELSET|
+ OBD_CONNECT_FID;
+
#ifdef HAVE_LRU_RESIZE_SUPPORT
if (sbi->ll_flags & LL_SBI_LRU_RESIZE)
data->ocd_connect_flags |= OBD_CONNECT_LRU_RESIZE;
GOTO(out_md_fid, err = -ENODEV);
}
- data->ocd_connect_flags = OBD_CONNECT_GRANT | OBD_CONNECT_VERSION |
+ data->ocd_connect_flags = OBD_CONNECT_GRANT | OBD_CONNECT_VERSION |
OBD_CONNECT_REQPORTAL | OBD_CONNECT_BRW_SIZE |
- OBD_CONNECT_CANCELSET;
+ OBD_CONNECT_CANCELSET | OBD_CONNECT_FID;
if (sbi->ll_flags & LL_SBI_OSS_CAPA)
data->ocd_connect_flags |= OBD_CONNECT_OSS_CAPA;
GOTO(out_dt_fid, err);
}
memset(&lmd, 0, sizeof(lmd));
- err = md_get_lustre_md(sbi->ll_md_exp, request,
- REPLY_REC_OFF, sbi->ll_dt_exp, sbi->ll_md_exp,
- &lmd);
+ err = md_get_lustre_md(sbi->ll_md_exp, request, sbi->ll_dt_exp,
+ sbi->ll_md_exp, &lmd);
if (err) {
CERROR("failed to understand root inode md: rc = %d\n", err);
ptlrpc_req_finished (request);
RETURN(rc);
}
- rc = md_get_lustre_md(sbi->ll_md_exp, request, REPLY_REC_OFF,
- sbi->ll_dt_exp, sbi->ll_md_exp, &md);
+ rc = md_get_lustre_md(sbi->ll_md_exp, request, sbi->ll_dt_exp,
+ sbi->ll_md_exp, &md);
if (rc) {
ptlrpc_req_finished(request);
RETURN(rc);
RETURN(-abs(rc));
}
- body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF,
- sizeof(*body));
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
+
flags = body->flags;
- ptlrpc_req_finished (req);
+ ptlrpc_req_finished(req);
RETURN(put_user(flags, (int *)arg));
}
return 0;
}
-int ll_prep_inode(struct inode **inode, struct ptlrpc_request *req,
- int offset, struct super_block *sb)
+int ll_prep_inode(struct inode **inode,
+ struct ptlrpc_request *req,
+ struct super_block *sb)
{
struct ll_sb_info *sbi = NULL;
struct lustre_md md;
prune_deathrow(sbi, 1);
memset(&md, 0, sizeof(struct lustre_md));
- rc = md_get_lustre_md(sbi->ll_md_exp, req, offset,
- sbi->ll_dt_exp, sbi->ll_md_exp, &md);
+ rc = md_get_lustre_md(sbi->ll_md_exp, req, sbi->ll_dt_exp,
+ sbi->ll_md_exp, &md);
if (rc)
RETURN(rc);
RETURN(ERR_PTR(rc));
}
- rc = ll_prep_inode(&inode, req, REPLY_REC_OFF, sb);
+ rc = ll_prep_inode(&inode, req, sb);
ptlrpc_req_finished(req);
if (rc)
RETURN(ERR_PTR(rc));
CERROR("failure %d inode %lu get parent\n", rc, dir->i_ino);
RETURN(ERR_PTR(rc));
}
- body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*body));
-
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
LASSERT(body->valid & OBD_MD_FLID);
CDEBUG(D_INFO, "parent for "DFID" is "DFID"\n",
return de;
}
-static int lookup_it_finish(struct ptlrpc_request *request, int offset,
- struct lookup_intent *it, void *data)
+static int lookup_it_finish(struct ptlrpc_request *request,
+ struct lookup_intent *it,
+ void *data)
{
struct it_cb_data *icbd = data;
struct dentry **de = icbd->icbd_childp;
if (!it_disposition(it, DISP_LOOKUP_NEG)) {
ENTRY;
- rc = ll_prep_inode(&inode, request, offset,
- (*de)->d_sb);
+ rc = ll_prep_inode(&inode, request, (*de)->d_sb);
if (rc)
RETURN(rc);
if (rc < 0)
GOTO(out, retval = ERR_PTR(rc));
- rc = lookup_it_finish(req, DLM_REPLY_REC_OFF, it, &icbd);
+ rc = lookup_it_finish(req, it, &icbd);
if (rc != 0) {
ll_intent_release(it);
GOTO(out, retval = ERR_PTR(rc));
LASSERT(it_disposition(it, DISP_ENQ_CREATE_REF));
request = it->d.lustre.it_data;
it_clear_disposition(it, DISP_ENQ_CREATE_REF);
- rc = ll_prep_inode(&inode, request, DLM_REPLY_REC_OFF, dir->i_sb);
+ rc = ll_prep_inode(&inode, request, dir->i_sb);
if (rc)
GOTO(out, inode = ERR_PTR(rc));
RETURN(0);
}
-static void ll_update_times(struct ptlrpc_request *request, int offset,
+static void ll_update_times(struct ptlrpc_request *request,
struct inode *inode)
{
- struct mdt_body *body = lustre_msg_buf(request->rq_repmsg, offset,
- sizeof(*body));
- LASSERT(body);
+ struct mdt_body *body = req_capsule_server_get(&request->rq_pill,
+ &RMF_MDT_BODY);
+ LASSERT(body);
/* mtime is always updated with ctime, but can be set in past.
As write and utime(2) may happen within 1 second, and utime's
mtime has a priority over write's one, so take mtime from mds
if (err)
GOTO(err_exit, err);
- ll_update_times(request, REPLY_REC_OFF, dir);
+ ll_update_times(request, dir);
if (dchild) {
- err = ll_prep_inode(&inode, request, REPLY_REC_OFF,
- dchild->d_sb);
+ err = ll_prep_inode(&inode, request, dchild->d_sb);
if (err)
GOTO(err_exit, err);
if (dchild)
d_drop(dchild);
- ll_update_times(request, REPLY_REC_OFF, dir);
+ ll_update_times(request, dir);
EXIT;
out:
ptlrpc_req_finished(request);
rc = md_unlink(ll_i2sbi(dir)->ll_md_exp, op_data, &request);
ll_finish_md_op_data(op_data);
if (rc == 0)
- ll_update_times(request, REPLY_REC_OFF, dir);
+ ll_update_times(request, dir);
ptlrpc_req_finished(request);
RETURN(rc);
}
ENTRY;
/* req is swabbed so this is safe */
- body = lustre_msg_buf(request->rq_repmsg, REPLY_REC_OFF, sizeof(*body));
-
+ body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY);
if (!(body->valid & OBD_MD_FLEASIZE))
RETURN(0);
* to this file. Use this EA to unlink the objects on the OST.
* It's opaque so we don't swab here; we leave it to obd_unpackmd() to
* check it is complete and sensible. */
- eadata = lustre_swab_repbuf(request, REPLY_REC_OFF + 1,
- body->eadatasize, NULL);
+ eadata = req_capsule_server_sized_get(&request->rq_pill, &RMF_MDT_MD,
+ body->eadatasize);
LASSERT(eadata != NULL);
- if (eadata == NULL) {
- CERROR("Can't unpack MDS EA data\n");
- GOTO(out, rc = -EPROTO);
- }
rc = obd_unpackmd(ll_i2dtexp(dir), &lsm, eadata, body->eadatasize);
if (rc < 0) {
if (body->valid & OBD_MD_FLCOOKIE) {
oa->o_valid |= OBD_MD_FLCOOKIE;
- oti.oti_logcookies =
- lustre_msg_buf(request->rq_repmsg, REPLY_REC_OFF + 2,
- sizeof(struct llog_cookie) *
- lsm->lsm_stripe_count);
+ oti.oti_logcookies =
+ req_capsule_server_sized_get(&request->rq_pill,
+ &RMF_LOGCOOKIES,
+ sizeof(struct llog_cookie) *
+ lsm->lsm_stripe_count);
if (oti.oti_logcookies == NULL) {
oa->o_valid &= ~OBD_MD_FLCOOKIE;
body->valid &= ~OBD_MD_FLCOOKIE;
if (rc)
GOTO(out, rc);
- ll_update_times(request, REPLY_REC_OFF, dir);
+ ll_update_times(request, dir);
rc = ll_objects_destroy(request, dir);
out:
tgt_name->name, tgt_name->len, &request);
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);
+ ll_update_times(request, src);
+ ll_update_times(request, tgt);
err = ll_objects_destroy(request, src);
}
}
/* NB: setxid permission is not checked here, instead it's done on
- * MDT when client get remote permission. (lookup/mdc_get_remote_perm). */
+ * MDT when client get remote permission. */
static int do_check_remote_perm(struct ll_inode_info *lli, int mask)
{
struct hlist_head *head;
RETURN(rc);
}
- perm = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, sizeof(*perm));
+ perm = req_capsule_server_get(&req->rq_pill, &RMF_ACL);
LASSERT(perm);
- LASSERT(lustre_rep_swabbed(req, REPLY_REC_OFF + 1));
rc = ll_update_remote_perm(inode, perm);
up(&lli->lli_rmtperm_sem);
GOTO (failed, rc);
}
- body = lustre_msg_buf((*request)->rq_repmsg, REPLY_REC_OFF,
- sizeof(*body));
+ body = req_capsule_server_get(&(*request)->rq_pill, &RMF_MDT_BODY);
LASSERT(body != NULL);
- LASSERT(lustre_rep_swabbed(*request, REPLY_REC_OFF));
-
if ((body->valid & OBD_MD_LINKNAME) == 0) {
CERROR("OBD_MD_LINKNAME not set on reply\n");
GOTO(failed, rc = -EPROTO);
GOTO(failed, rc = -EPROTO);
}
- *symname = lustre_msg_buf((*request)->rq_repmsg, REPLY_REC_OFF + 1,
- symlen);
+ *symname = req_capsule_server_get(&(*request)->rq_pill, &RMF_MDT_MD);
if (*symname == NULL ||
- strnlen (*symname, symlen) != symlen - 1) {
+ strnlen(*symname, symlen) != symlen - 1) {
/* not full/NULL terminated */
CERROR("inode %lu: symlink not NULL terminated string"
"of length %d\n", inode->i_ino, symlen - 1);
RETURN(rc);
}
- body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*body));
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
LASSERT(body);
- LASSERT(lustre_rep_swabbed(req, REPLY_REC_OFF));
/* only detect the xattr size */
if (size == 0)
GOTO(out, rc = -ERANGE);
}
- if (lustre_msg_bufcount(req->rq_repmsg) < 3) {
- CERROR("reply bufcount %u\n",
- lustre_msg_bufcount(req->rq_repmsg));
- GOTO(out, rc = -EFAULT);
- }
-
/* do not need swab xattr data */
- lustre_set_rep_swabbed(req, REPLY_REC_OFF + 1);
- xdata = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1,
- body->eadatasize);
- if (!xdata) {
- CERROR("can't extract: %u : %u\n", body->eadatasize,
- lustre_msg_buflen(req->rq_repmsg, REPLY_REC_OFF + 1));
+ xdata = req_capsule_server_sized_get(&req->rq_pill, &RMF_EADATA,
+ body->eadatasize);
+ if (!xdata)
GOTO(out, rc = -EFAULT);
- }
#ifdef CONFIG_FS_POSIX_ACL
if (body->eadatasize >= 0 && rce && rce->rce_ops == RMT_LSETFACL) {
int pmode, rc = 0;
ENTRY;
- body = lustre_msg_buf((*reqp)->rq_repmsg,
- DLM_REPLY_REC_OFF, sizeof(*body));
+ body = req_capsule_server_get(&(*reqp)->rq_pill, &RMF_DLM_REP);
LASSERT(body != NULL);
- LASSERT(lustre_rep_swabbed(*reqp, DLM_REPLY_REC_OFF));
if (!(body->valid & OBD_MD_MDS))
RETURN(0);
/* caller may use attrs MDS returns on IT_OPEN lock request so, we have
* to update them for split dir */
- body = lustre_msg_buf((*reqp)->rq_repmsg,
- DLM_REPLY_REC_OFF, sizeof(*body));
+ body = req_capsule_server_get(&(*reqp)->rq_pill, &RMF_DLM_REP);
LASSERT(body != NULL);
- LASSERT(lustre_rep_swabbed(*reqp, DLM_REPLY_REC_OFF));
/* could not find object, FID is not present in response. */
if (!(body->valid & OBD_MD_FLID))
GOTO(out_free_sop_data, rc = 0);
obj = lmv_obj_grab(obd, &body->fid1);
- if (!obj && (mea = lmv_get_mea(*reqp, DLM_REPLY_REC_OFF))) {
+ if (!obj && (mea = lmv_get_mea(*reqp))) {
/* FIXME: capability for remote! */
/* wow! this is split dir, we'd like to handle it */
obj = lmv_obj_create(exp, &body->fid1, mea);
LASSERT(*reqp);
LASSERT((*reqp)->rq_repmsg);
- body = lustre_msg_buf((*reqp)->rq_repmsg,
- DLM_REPLY_REC_OFF, sizeof(*body));
+ body = req_capsule_server_get(&(*reqp)->rq_pill, &RMF_MDT_BODY);
LASSERT(body != NULL);
- LASSERT(lustre_rep_swabbed(*reqp, DLM_REPLY_REC_OFF));
/* could not find object, FID is not present in response. */
if (!(body->valid & OBD_MD_FLID))
obj2 = lmv_obj_grab(obd, &body->fid1);
- if (!obj2 && (mea = lmv_get_mea(*reqp, DLM_REPLY_REC_OFF))) {
+ if (!obj2 && (mea = lmv_get_mea(*reqp))) {
/* FIXME remote capability! */
/* wow! this is split dir, we'd like to handle it. */
if (op_data == NULL)
RETURN(-ENOMEM);
- body = lustre_msg_buf((*reqp)->rq_repmsg,
- DLM_REPLY_REC_OFF, sizeof(*body));
+ body = req_capsule_server_get(&(*reqp)->rq_pill, &RMF_MDT_BODY);
LASSERT(body != NULL);
- LASSERT(lustre_rep_swabbed(*reqp, DLM_REPLY_REC_OFF));
LASSERT((body->valid & OBD_MD_FLID) != 0);
obj = lmv_obj_grab(obd, &body->fid1);
lock->l_ast_data = lmv_obj_get(obj);
- body2 = lustre_msg_buf(req->rq_repmsg,
- DLM_REPLY_REC_OFF, sizeof(*body2));
+ body2 = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
LASSERT(body2 != NULL);
- LASSERT(lustre_rep_swabbed(req, DLM_REPLY_REC_OFF));
obj->lo_inodes[i].li_size = body2->size;
rc = lmv_intent_remote(exp, lmm, lmmsize, it, flags, reqp,
cb_blocking, extra_lock_flags);
- if (rc == 0 && (mea = lmv_get_mea(*reqp, DLM_REPLY_REC_OFF))) {
+ if (rc == 0 && (mea = lmv_get_mea(*reqp))) {
/* Wow! This is split dir, we'd like to handle it. */
- body = lustre_msg_buf((*reqp)->rq_repmsg,
- DLM_REPLY_REC_OFF, sizeof(*body));
+ body = req_capsule_server_get(&(*reqp)->rq_pill, &RMF_MDT_BODY);
LASSERT(body != NULL);
- LASSERT(lustre_rep_swabbed(*reqp, DLM_REPLY_REC_OFF));
LASSERT((body->valid & OBD_MD_FLID) != 0);
obj = lmv_obj_grab(obd, &body->fid1);
* It even got the reply refresh attrs
* from that reply.
*/
- body = lustre_msg_buf(mreq->rq_repmsg,
- DLM_REPLY_REC_OFF,
- sizeof(*body));
+ body = req_capsule_server_get(
+ &mreq->rq_pill,
+ &RMF_MDT_BODY);
LASSERT(body != NULL);
- LASSERT(lustre_rep_swabbed(
- mreq, DLM_REPLY_REC_OFF));
goto update;
}
/* take already cached attrs into account */
*reqp = req;
}
- body = lustre_msg_buf(req->rq_repmsg,
- DLM_REPLY_REC_OFF, sizeof(*body));
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
LASSERT(body != NULL);
- LASSERT(lustre_rep_swabbed(req, DLM_REPLY_REC_OFF));
update:
obj->lo_inodes[i].li_size = body->size;
CDEBUG(D_OTHER, "return refreshed attrs: size = %lu\n",
(unsigned long)size);
- body = lustre_msg_buf((*reqp)->rq_repmsg,
- DLM_REPLY_REC_OFF, sizeof(*body));
+ body = req_capsule_server_get(&(*reqp)->rq_pill, &RMF_MDT_BODY);
LASSERT(body != NULL);
- LASSERT(lustre_rep_swabbed(*reqp, DLM_REPLY_REC_OFF));
body->size = size;
struct md_op_data *op, struct lu_fid *fid);
static inline struct lmv_stripe_md *
-lmv_get_mea(struct ptlrpc_request *req, int offset)
+lmv_get_mea(struct ptlrpc_request *req)
{
struct mdt_body *body;
struct lmv_stripe_md *mea;
LASSERT(req);
- body = lustre_msg_buf(req->rq_repmsg, offset, sizeof(*body));
- LASSERT(lustre_rep_swabbed(req, offset));
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
if (!body || !S_ISDIR(body->mode) || !body->eadatasize)
return NULL;
- mea = lustre_msg_buf(req->rq_repmsg, offset + 1,
- body->eadatasize);
+ mea = req_capsule_server_sized_get(&req->rq_pill, &RMF_MDT_MD,
+ body->eadatasize);
LASSERT(mea != NULL);
if (mea->mea_count == 0)
RETURN(rc);
}
- body = lustre_msg_buf((*request)->rq_repmsg, REPLY_REC_OFF,
- sizeof(*body));
+ body = req_capsule_server_get(&(*request)->rq_pill,
+ &RMF_MDT_BODY);
LASSERT(body != NULL);
- LASSERT(lustre_rep_swabbed(*request, REPLY_REC_OFF));
lmv_obj_lock(obj);
GOTO(cleanup, rc);
}
- rc = md_get_lustre_md(tgt_exp, req, 1, NULL, exp, &md);
+ rc = md_get_lustre_md(tgt_exp, req, NULL, exp, &md);
if (rc) {
CERROR("mdc_get_lustre_md() failed, error %d\n", rc);
GOTO(cleanup, rc);
int rc = 0, pmode;
ENTRY;
- body = lustre_msg_buf(req->rq_repmsg,
- DLM_REPLY_REC_OFF, sizeof(*body));
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
LASSERT(body != NULL);
- LASSERT(lustre_rep_swabbed(req, DLM_REPLY_REC_OFF));
if (!(body->valid & OBD_MD_MDS))
RETURN(0);
rc = md_getattr_name(tgt_exp, &rid, oc, filename, namelen, valid,
ea_size, suppgid, request);
if (rc == 0) {
- body = lustre_msg_buf((*request)->rq_repmsg,
- REQ_REC_OFF, sizeof(*body));
+ body = req_capsule_server_get(&(*request)->rq_pill,
+ &RMF_MDT_BODY);
LASSERT(body != NULL);
- LASSERT(lustre_rep_swabbed(*request, REQ_REC_OFF));
if (body->valid & OBD_MD_MDS) {
struct ptlrpc_request *req = NULL;
}
int lmv_get_lustre_md(struct obd_export *exp, struct ptlrpc_request *req,
- int offset, struct obd_export *dt_exp,
- struct obd_export *md_exp, struct lustre_md *md)
+ struct obd_export *dt_exp, struct obd_export *md_exp,
+ struct lustre_md *md)
{
struct obd_device *obd = exp->exp_obd;
struct lmv_obd *lmv = &obd->u.lmv;
int rc;
ENTRY;
- rc = md_get_lustre_md(lmv->tgts[0].ltd_exp, req, offset, dt_exp, md_exp,
- md);
+ rc = md_get_lustre_md(lmv->tgts[0].ltd_exp, req, dt_exp, md_exp, md);
RETURN(rc);
}
GOTO(cleanup, obj = ERR_PTR(rc));
}
- rc = md_get_lustre_md(exp, req, 0, NULL, exp, &md);
+ rc = md_get_lustre_md(exp, req, NULL, exp, &md);
if (rc) {
CERROR("mdc_get_lustre_md() failed, error %d\n", rc);
GOTO(cleanup, obj = ERR_PTR(rc));
memset(lvars, 0, sizeof(*lvars));
}
#endif
-void mdc_pack_req_body(struct ptlrpc_request *req, int offset,
- __u64 valid, const struct lu_fid *fid,
- struct obd_capa *oc, int ea_size,
- __u32 suppgid, int flags);
-void mdc_pack_capa(struct ptlrpc_request *req, int offset, struct obd_capa *oc);
-void mdc_pack_rep_body(struct ptlrpc_request *);
-void mdc_is_subdir_pack(struct ptlrpc_request *req, int offset,
- const struct lu_fid *pfid, const struct lu_fid *cfid,
- int flags);
-void mdc_readdir_pack(struct ptlrpc_request *req, int pos, __u64 offset,
- __u32 size, const struct lu_fid *fid,
- struct obd_capa *oc);
-void mdc_getattr_pack(struct ptlrpc_request *req, int offset, __u64 valid,
- int flags, struct md_op_data *data);
-void mdc_setattr_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data,
- void *ea, int ealen, void *ea2, int ea2len);
-void mdc_create_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data, const void *data, int datalen,
- __u32 mode, __u32 uid, __u32 gid, __u32 cap_effective,
- __u64 rdev);
-void mdc_open_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data, __u32 mode, __u64 rdev,
- __u32 flags, const void *data, int datalen);
-void mdc_join_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data, __u64 head_size);
-void mdc_unlink_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data);
-void mdc_link_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data);
-void mdc_rename_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data,
+
+void mdc_pack_body(struct ptlrpc_request *req, const struct lu_fid *fid,
+ struct obd_capa *oc, __u64 valid, int ea_size,
+ __u32 suppgid, int flags);
+void mdc_pack_capa(struct ptlrpc_request *req, const struct req_msg_field *field,
+ struct obd_capa *oc);
+int mdc_pack_req(struct ptlrpc_request *req, int version, int opc);
+void mdc_is_subdir_pack(struct ptlrpc_request *req, const struct lu_fid *pfid,
+ const struct lu_fid *cfid, int flags);
+void mdc_readdir_pack(struct ptlrpc_request *req, __u64 pgoff, __u32 size,
+ const struct lu_fid *fid, struct obd_capa *oc);
+void mdc_getattr_pack(struct ptlrpc_request *req, __u64 valid, int flags,
+ struct md_op_data *data);
+void mdc_setattr_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+ void *ea, int ealen, void *ea2, int ea2len);
+void mdc_create_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+ const void *data, int datalen, __u32 mode, __u32 uid,
+ __u32 gid, __u32 cap_effective, __u64 rdev);
+void mdc_open_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+ __u32 mode, __u64 rdev, __u32 flags, const void *data,
+ int datalen);
+void mdc_join_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+ __u64 head_size);
+void mdc_unlink_pack(struct ptlrpc_request *req, struct md_op_data *op_data);
+void mdc_link_pack(struct ptlrpc_request *req, struct md_op_data *op_data);
+void mdc_rename_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
const char *old, int oldlen, const char *new, int newlen);
-void mdc_close_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data);
-void mdc_exit_request(struct client_obd *cli);
+void mdc_close_pack(struct ptlrpc_request *req, struct md_op_data *op_data);
void mdc_enter_request(struct client_obd *cli);
+void mdc_exit_request(struct client_obd *cli);
static inline int client_is_remote(struct obd_export *exp)
{
struct obd_client_handle;
int mdc_get_lustre_md(struct obd_export *md_exp, struct ptlrpc_request *req,
- int offset, struct obd_export *dt_exp,
- struct obd_export *lmv_exp,
+ struct obd_export *dt_exp, struct obd_export *lmv_exp,
struct lustre_md *md);
int mdc_free_lustre_md(struct obd_export *exp, struct lustre_md *md);
int mdc_cancel_unused(struct obd_export *exp, const struct lu_fid *fid,
ldlm_policy_data_t *policy, ldlm_mode_t mode,
int flags, void *opaque);
+
+static inline void mdc_set_capa_size(struct ptlrpc_request *req,
+ const struct req_msg_field *field,
+ struct obd_capa *oc)
+{
+ if (oc == NULL)
+ req_capsule_set_size(&req->rq_pill, field, RCL_CLIENT, 0);
+ else
+ /* it is already calculated as sizeof struct obd_capa */
+ ;
+}
+
ldlm_mode_t mdc_lock_match(struct obd_export *exp, int flags,
const struct lu_fid *fid, ldlm_type_t type,
ldlm_policy_data_t *policy, ldlm_mode_t mode,
#endif
#endif
-static void mdc_pack_body(struct mdt_body *b, __u32 suppgid)
+static void __mdc_pack_body(struct mdt_body *b, __u32 suppgid)
{
LASSERT (b != NULL);
b->capability = current->cap_effective;
}
-void mdc_pack_capa(struct ptlrpc_request *req, int offset, struct obd_capa *oc)
+void mdc_pack_capa(struct ptlrpc_request *req, const struct req_msg_field *field,
+ struct obd_capa *oc)
{
+ struct req_capsule *pill = &req->rq_pill;
struct lustre_capa *c;
if (oc == NULL) {
- LASSERT(lustre_msg_buflen(req->rq_reqmsg, offset) == 0);
+ LASSERT(req_capsule_get_size(pill, field, RCL_CLIENT) == 0);
return;
}
- c = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*c));
+ c = req_capsule_client_get(pill, field);
LASSERT(c != NULL);
capa_cpy(c, oc);
DEBUG_CAPA(D_SEC, c, "pack");
}
-void mdc_is_subdir_pack(struct ptlrpc_request *req, int offset,
- const struct lu_fid *pfid,
+void mdc_is_subdir_pack(struct ptlrpc_request *req, const struct lu_fid *pfid,
const struct lu_fid *cfid, int flags)
{
- struct mdt_body *b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*b));
+ struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
+ &RMF_MDT_BODY);
- if (pfid)
+ if (pfid) {
b->fid1 = *pfid;
+ b->valid = OBD_MD_FLID;
+ }
if (cfid)
b->fid2 = *cfid;
- b->valid = OBD_MD_FLID;
b->flags = flags;
}
-void mdc_pack_req_body(struct ptlrpc_request *req, int offset,
- __u64 valid, const struct lu_fid *fid,
- struct obd_capa *oc, int ea_size, __u32 suppgid,
- int flags)
+void mdc_pack_body(struct ptlrpc_request *req,
+ const struct lu_fid *fid, struct obd_capa *oc,
+ __u64 valid, int ea_size, __u32 suppgid, int flags)
{
- struct mdt_body *b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*b));
-
+ struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
+ &RMF_MDT_BODY);
+ LASSERT(b != NULL);
b->valid = valid;
b->eadatasize = ea_size;
b->flags = flags;
- mdc_pack_body(b, suppgid);
+ __mdc_pack_body(b, suppgid);
if (fid) {
b->fid1 = *fid;
- mdc_pack_capa(req, offset + 1, oc);
+ b->valid |= OBD_MD_FLID;
+ mdc_pack_capa(req, &RMF_CAPA1, oc);
}
}
-void mdc_readdir_pack(struct ptlrpc_request *req, int offset, __u64 pgoff,
+void mdc_readdir_pack(struct ptlrpc_request *req, __u64 pgoff,
__u32 size, const struct lu_fid *fid, struct obd_capa *oc)
{
- struct mdt_body *b;
-
- b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*b));
+ struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
+ &RMF_MDT_BODY);
b->fid1 = *fid;
+ b->valid |= OBD_MD_FLID;
b->size = pgoff; /* !! */
b->nlink = size; /* !! */
- mdc_pack_body(b, -1);
- mdc_pack_capa(req, offset + 1, oc);
+ __mdc_pack_body(b, -1);
+ mdc_pack_capa(req, &RMF_CAPA1, oc);
}
/* packing of MDS records */
-void mdc_create_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data, const void *data, int datalen,
- __u32 mode, __u32 uid, __u32 gid, __u32 cap_effective,
- __u64 rdev)
+void mdc_create_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+ const void *data, int datalen, __u32 mode,
+ __u32 uid, __u32 gid, __u32 cap_effective, __u64 rdev)
{
struct mdt_rec_create *rec;
- char *tmp;
-
- rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*rec));
-
- rec->cr_opcode = REINT_CREATE;
- rec->cr_fsuid = uid;
- rec->cr_fsgid = gid;
- rec->cr_cap = cap_effective;
- rec->cr_fid1 = op_data->op_fid1;
- rec->cr_fid2 = op_data->op_fid2;
- rec->cr_mode = mode;
- rec->cr_rdev = rdev;
- rec->cr_time = op_data->op_mod_time;
+ char *tmp;
+
+ CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_create));
+ rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
+
+
+ rec->cr_opcode = REINT_CREATE;
+ rec->cr_fsuid = uid;
+ rec->cr_fsgid = gid;
+ rec->cr_cap = cap_effective;
+ rec->cr_fid1 = op_data->op_fid1;
+ rec->cr_fid2 = op_data->op_fid2;
+ rec->cr_mode = mode;
+ rec->cr_rdev = rdev;
+ rec->cr_time = op_data->op_mod_time;
rec->cr_suppgid1 = op_data->op_suppgids[0];
rec->cr_suppgid2 = op_data->op_suppgids[1];
- rec->cr_flags = op_data->op_flags & ~MF_SOM_LOCAL_FLAGS;
- rec->cr_bias = op_data->op_bias;
+ rec->cr_flags = op_data->op_flags & ~MF_SOM_LOCAL_FLAGS;
+ rec->cr_bias = op_data->op_bias;
- mdc_pack_capa(req, offset + 1, op_data->op_capa1);
+ mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
- tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2, op_data->op_namelen + 1);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
LOGL0(op_data->op_name, op_data->op_namelen, tmp);
if (data) {
- tmp = lustre_msg_buf(req->rq_reqmsg, offset + 3, datalen);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_EADATA);
memcpy(tmp, data, datalen);
}
}
}
/* packing of MDS records */
-void mdc_join_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data, __u64 head_size)
+void mdc_join_pack(struct ptlrpc_request *req,
+ struct md_op_data *op_data,
+ __u64 head_size)
{
struct mdt_rec_join *rec;
- rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*rec));
+ rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_JOINFILE);
LASSERT(rec != NULL);
rec->jr_fid = op_data->op_fid2;
rec->jr_headsize = head_size;
}
-void mdc_open_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data, __u32 mode, __u64 rdev,
- __u32 flags, const void *lmm, int lmmlen)
+void mdc_open_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+ __u32 mode, __u64 rdev, __u32 flags, const void *lmm,
+ int lmmlen)
{
struct mdt_rec_create *rec;
char *tmp;
- rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
+
+ CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_create));
+ rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
/* XXX do something about time, uid, gid */
- rec->cr_opcode = REINT_OPEN;
- rec->cr_fsuid = current->fsuid;
- rec->cr_fsgid = current->fsgid;
- rec->cr_cap = current->cap_effective;
+ rec->cr_opcode = REINT_OPEN;
+ rec->cr_fsuid = current->fsuid;
+ rec->cr_fsgid = current->fsgid;
+ rec->cr_cap = current->cap_effective;
if (op_data != NULL) {
rec->cr_fid1 = op_data->op_fid1;
rec->cr_fid2 = op_data->op_fid2;
}
- rec->cr_mode = mode;
- rec->cr_flags = mds_pack_open_flags(flags);
- rec->cr_time = op_data->op_mod_time;
- rec->cr_rdev = rdev;
+ rec->cr_mode = mode;
+ rec->cr_flags = mds_pack_open_flags(flags);
+ rec->cr_rdev = rdev;
+ rec->cr_time = op_data->op_mod_time;
rec->cr_suppgid1 = op_data->op_suppgids[0];
rec->cr_suppgid2 = op_data->op_suppgids[1];
- rec->cr_bias = op_data->op_bias;
+ rec->cr_bias = op_data->op_bias;
- mdc_pack_capa(req, offset + 1, op_data->op_capa1);
+ mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
/* the next buffer is child capa, which is used for replay,
* will be packed from the data in reply message. */
if (op_data->op_name) {
- tmp = lustre_msg_buf(req->rq_reqmsg, offset + 3,
- op_data->op_namelen + 1);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
LOGL0(op_data->op_name, op_data->op_namelen, tmp);
}
/*XXX a hack for liblustre to set EA (LL_IOC_LOV_SETSTRIPE) */
rec->cr_fid2 = op_data->op_fid2;
#endif
- tmp = lustre_msg_buf(req->rq_reqmsg, offset + 4, lmmlen);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_EADATA);
memcpy (tmp, lmm, lmmlen);
}
}
static void mdc_setattr_pack_rec(struct mdt_rec_setattr *rec,
struct md_op_data *op_data)
{
- rec->sa_opcode = REINT_SETATTR;
- rec->sa_fsuid = current->fsuid;
- rec->sa_fsgid = current->fsgid;
- rec->sa_cap = current->cap_effective;
+ rec->sa_opcode = REINT_SETATTR;
+ rec->sa_fsuid = current->fsuid;
+ rec->sa_fsgid = current->fsgid;
+ rec->sa_cap = current->cap_effective;
rec->sa_suppgid = -1;
- rec->sa_fid = op_data->op_fid1;
- rec->sa_valid = attr_pack(op_data->op_attr.ia_valid);
- rec->sa_mode = op_data->op_attr.ia_mode;
- rec->sa_uid = op_data->op_attr.ia_uid;
- rec->sa_gid = op_data->op_attr.ia_gid;
- rec->sa_size = op_data->op_attr.ia_size;
+ rec->sa_fid = op_data->op_fid1;
+ rec->sa_valid = attr_pack(op_data->op_attr.ia_valid);
+ rec->sa_mode = op_data->op_attr.ia_mode;
+ rec->sa_uid = op_data->op_attr.ia_uid;
+ rec->sa_gid = op_data->op_attr.ia_gid;
+ rec->sa_size = op_data->op_attr.ia_size;
rec->sa_blocks = op_data->op_attr_blocks;
- rec->sa_atime = LTIME_S(op_data->op_attr.ia_atime);
- rec->sa_mtime = LTIME_S(op_data->op_attr.ia_mtime);
- rec->sa_ctime = LTIME_S(op_data->op_attr.ia_ctime);
+ rec->sa_atime = LTIME_S(op_data->op_attr.ia_atime);
+ rec->sa_mtime = LTIME_S(op_data->op_attr.ia_mtime);
+ rec->sa_ctime = LTIME_S(op_data->op_attr.ia_ctime);
rec->sa_attr_flags = ((struct ll_iattr *)&op_data->op_attr)->ia_attr_flags;
if ((op_data->op_attr.ia_valid & ATTR_GID) &&
in_group_p(op_data->op_attr.ia_gid))
epoch->flags = op_data->op_flags & ~MF_SOM_LOCAL_FLAGS;
}
-void mdc_setattr_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data, void *ea,
- int ealen, void *ea2, int ea2len)
+void mdc_setattr_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
+ void *ea, int ealen, void *ea2, int ea2len)
{
struct mdt_rec_setattr *rec;
struct mdt_epoch *epoch;
- rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
+ CLASSERT(sizeof(struct mdt_rec_reint) ==sizeof(struct mdt_rec_setattr));
+ rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
mdc_setattr_pack_rec(rec, op_data);
- mdc_pack_capa(req, offset + 1, op_data->op_capa1);
+ mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
if (op_data->op_flags & (MF_SOM_CHANGE | MF_EPOCH_OPEN)) {
- epoch = lustre_msg_buf(req->rq_reqmsg, offset + 2,
- sizeof(*epoch));
+ epoch = req_capsule_client_get(&req->rq_pill, &RMF_MDT_EPOCH);
mdc_epoch_pack(epoch, op_data);
}
if (ealen == 0)
return;
- memcpy(lustre_msg_buf(req->rq_reqmsg, offset + 3, ealen), ea, ealen);
+ memcpy(req_capsule_client_get(&req->rq_pill, &RMF_EADATA), ea, ealen);
if (ea2len == 0)
return;
- memcpy(lustre_msg_buf(req->rq_reqmsg, offset + 4, ea2len), ea2, ea2len);
+ memcpy(req_capsule_client_get(&req->rq_pill, &RMF_LOGCOOKIES), ea2,
+ ea2len);
}
-void mdc_unlink_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data)
+void mdc_unlink_pack(struct ptlrpc_request *req, struct md_op_data *op_data)
{
struct mdt_rec_unlink *rec;
char *tmp;
-
- rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
+
+ CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_unlink));
+ rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
LASSERT (rec != NULL);
- rec->ul_opcode = REINT_UNLINK;
- rec->ul_fsuid = op_data->op_fsuid;//current->fsuid;
- rec->ul_fsgid = op_data->op_fsgid;//current->fsgid;
- rec->ul_cap = op_data->op_cap;//current->cap_effective;
- rec->ul_mode = op_data->op_mode;
- rec->ul_suppgid = op_data->op_suppgids[0];
- rec->ul_fid1 = op_data->op_fid1;
- rec->ul_fid2 = op_data->op_fid2;
- rec->ul_time = op_data->op_mod_time;
- rec->ul_bias = op_data->op_bias;
-
- mdc_pack_capa(req, offset + 1, op_data->op_capa1);
-
- tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2, op_data->op_namelen + 1);
+ rec->ul_opcode = REINT_UNLINK;
+ rec->ul_fsuid = op_data->op_fsuid;
+ rec->ul_fsgid = op_data->op_fsgid;
+ rec->ul_cap = op_data->op_cap;
+ rec->ul_mode = op_data->op_mode;
+ rec->ul_suppgid1= op_data->op_suppgids[0];
+ rec->ul_suppgid2= -1;
+ rec->ul_fid1 = op_data->op_fid1;
+ rec->ul_fid2 = op_data->op_fid2;
+ rec->ul_time = op_data->op_mod_time;
+ rec->ul_bias = op_data->op_bias;
+
+ mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
+
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
LASSERT(tmp != NULL);
LOGL0(op_data->op_name, op_data->op_namelen, tmp);
}
-void mdc_link_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data)
+void mdc_link_pack(struct ptlrpc_request *req, struct md_op_data *op_data)
{
struct mdt_rec_link *rec;
char *tmp;
- rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
+ CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_link));
+ rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
+ LASSERT (rec != NULL);
- rec->lk_opcode = REINT_LINK;
- rec->lk_fsuid = op_data->op_fsuid;//current->fsuid;
- rec->lk_fsgid = op_data->op_fsgid;//current->fsgid;
- rec->lk_cap = op_data->op_cap;//current->cap_effective;
+ rec->lk_opcode = REINT_LINK;
+ rec->lk_fsuid = op_data->op_fsuid;//current->fsuid;
+ rec->lk_fsgid = op_data->op_fsgid;//current->fsgid;
+ rec->lk_cap = op_data->op_cap;//current->cap_effective;
rec->lk_suppgid1 = op_data->op_suppgids[0];
rec->lk_suppgid2 = op_data->op_suppgids[1];
- rec->lk_fid1 = op_data->op_fid1;
- rec->lk_fid2 = op_data->op_fid2;
- rec->lk_time = op_data->op_mod_time;
- rec->lk_bias = op_data->op_bias;
+ rec->lk_fid1 = op_data->op_fid1;
+ rec->lk_fid2 = op_data->op_fid2;
+ rec->lk_time = op_data->op_mod_time;
+ rec->lk_bias = op_data->op_bias;
- mdc_pack_capa(req, offset + 1, op_data->op_capa1);
- mdc_pack_capa(req, offset + 2, op_data->op_capa2);
+ mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
+ mdc_pack_capa(req, &RMF_CAPA2, op_data->op_capa2);
- tmp = lustre_msg_buf(req->rq_reqmsg, offset + 3, op_data->op_namelen + 1);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
LOGL0(op_data->op_name, op_data->op_namelen, tmp);
}
-void mdc_rename_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data,
+void mdc_rename_pack(struct ptlrpc_request *req, struct md_op_data *op_data,
const char *old, int oldlen, const char *new, int newlen)
{
struct mdt_rec_rename *rec;
char *tmp;
- rec = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*rec));
+ CLASSERT(sizeof(struct mdt_rec_reint) == sizeof(struct mdt_rec_rename));
+ rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
/* XXX do something about time, uid, gid */
- rec->rn_opcode = REINT_RENAME;
- rec->rn_fsuid = op_data->op_fsuid;//current->fsuid;
- rec->rn_fsgid = op_data->op_fsgid;//current->fsgid;
- rec->rn_cap = op_data->op_cap;//current->cap_effective;
+ rec->rn_opcode = REINT_RENAME;
+ rec->rn_fsuid = op_data->op_fsuid;
+ rec->rn_fsgid = op_data->op_fsgid;
+ rec->rn_cap = op_data->op_cap;
rec->rn_suppgid1 = op_data->op_suppgids[0];
rec->rn_suppgid2 = op_data->op_suppgids[1];
- rec->rn_fid1 = op_data->op_fid1;
- rec->rn_fid2 = op_data->op_fid2;
- rec->rn_time = op_data->op_mod_time;
- rec->rn_mode = op_data->op_mode;
- rec->rn_bias = op_data->op_bias;
+ rec->rn_fid1 = op_data->op_fid1;
+ rec->rn_fid2 = op_data->op_fid2;
+ rec->rn_time = op_data->op_mod_time;
+ rec->rn_mode = op_data->op_mode;
+ rec->rn_bias = op_data->op_bias;
- mdc_pack_capa(req, offset + 1, op_data->op_capa1);
- mdc_pack_capa(req, offset + 2, op_data->op_capa2);
+ mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
+ mdc_pack_capa(req, &RMF_CAPA2, op_data->op_capa2);
- tmp = lustre_msg_buf(req->rq_reqmsg, offset + 3, oldlen + 1);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
LOGL0(old, oldlen, tmp);
if (new) {
- tmp = lustre_msg_buf(req->rq_reqmsg, offset + 4, newlen + 1);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_SYMTGT);
LOGL0(new, newlen, tmp);
}
}
-void mdc_getattr_pack(struct ptlrpc_request *req, int offset, __u64 valid,
- int flags, struct md_op_data *op_data)
+void mdc_getattr_pack(struct ptlrpc_request *req, __u64 valid, int flags,
+ struct md_op_data *op_data)
{
- struct mdt_body *b;
- b = lustre_msg_buf(req->rq_reqmsg, offset, sizeof (*b));
+ struct mdt_body *b = req_capsule_client_get(&req->rq_pill,
+ &RMF_MDT_BODY);
b->fsuid = current->fsuid;
b->fsgid = current->fsgid;
b->fid1 = op_data->op_fid1;
b->fid2 = op_data->op_fid2;
+ b->valid |= OBD_MD_FLID;
- mdc_pack_capa(req, offset + 1, op_data->op_capa1);
+ mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
if (op_data->op_name) {
- char *tmp;
- tmp = lustre_msg_buf(req->rq_reqmsg, offset + 2,
- op_data->op_namelen + 1);
+ char *tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
LOGL0(op_data->op_name, op_data->op_namelen, tmp);
}
}
-void mdc_close_pack(struct ptlrpc_request *req, int offset,
- struct md_op_data *op_data)
+void mdc_close_pack(struct ptlrpc_request *req, struct md_op_data *op_data)
{
struct mdt_epoch *epoch;
struct mdt_rec_setattr *rec;
- epoch = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*epoch));
- rec = lustre_msg_buf(req->rq_reqmsg, offset + 1, sizeof(*rec));
+ epoch = req_capsule_client_get(&req->rq_pill, &RMF_MDT_EPOCH);
+ rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
mdc_setattr_pack_rec(rec, op_data);
- mdc_pack_capa(req, offset + 2, op_data->op_capa1);
+ mdc_pack_capa(req, &RMF_CAPA1, op_data->op_capa1);
mdc_epoch_pack(epoch, op_data);
}
* but this is incredibly unlikely, and questionable whether the client
* could do MDS recovery under OOM anyways... */
static void mdc_realloc_openmsg(struct ptlrpc_request *req,
- struct mdt_body *body, int size[9])
+ struct mdt_body *body)
{
int rc;
- ENTRY;
+ /* FIXME: remove this explicit offset. */
rc = sptlrpc_cli_enlarge_reqbuf(req, DLM_INTENT_REC_OFF + 4,
body->eadatasize);
if (rc) {
body->valid &= ~OBD_MD_FLEASIZE;
body->eadatasize = 0;
}
- EXIT;
}
-/* We always reserve enough space in the reply packet for a stripe MD, because
- * we don't know in advance the file type. */
-int mdc_enqueue(struct obd_export *exp, struct ldlm_enqueue_info *einfo,
- struct lookup_intent *it, struct md_op_data *op_data,
- struct lustre_handle *lockh, void *lmm, int lmmsize,
- int extra_lock_flags)
+static struct ptlrpc_request *mdc_intent_open_pack(struct obd_export *exp,
+ struct lookup_intent *it,
+ struct md_op_data *op_data,
+ void *lmm, int lmmsize,
+ void *cb_data)
{
struct ptlrpc_request *req;
- struct obd_device *obddev = class_exp2obd(exp);
- struct ldlm_res_id res_id =
- { .name = {fid_seq(&op_data->op_fid1),
- fid_oid(&op_data->op_fid1),
- fid_ver(&op_data->op_fid1)} };
- ldlm_policy_data_t policy = { .l_inodebits = { MDS_INODELOCK_LOOKUP } };
- struct ldlm_request *lockreq;
- struct ldlm_intent *lit;
- struct ldlm_reply *lockrep;
- int size[9] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body),
- [DLM_LOCKREQ_OFF] = sizeof(*lockreq),
- [DLM_INTENT_IT_OFF] = sizeof(*lit),
- 0, 0, 0, 0, 0, 0 };
- int repsize[7] = { [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body),
- [DLM_LOCKREPLY_OFF] = sizeof(*lockrep),
- [DLM_REPLY_REC_OFF] = sizeof(struct mdt_body),
- [DLM_REPLY_REC_OFF+1] = obddev->u.cli.
- cl_max_mds_easize,
- 0, 0, 0 };
- int flags = extra_lock_flags | LDLM_FL_HAS_INTENT;
- int repbufcnt = 4, rc;
+ struct obd_device *obddev = class_exp2obd(exp);
+ struct ldlm_intent *lit;
+ int joinfile = !!((it->it_flags & O_JOIN_FILE) &&
+ op_data->op_data);
+ CFS_LIST_HEAD(cancels);
+ int count = 0;
+ int mode;
+ int rc;
ENTRY;
- LASSERTF(einfo->ei_type == LDLM_IBITS,"lock type %d\n", einfo->ei_type);
+ it->it_create_mode = (it->it_create_mode & ~S_IFMT) | S_IFREG;
- if (it->it_op & IT_OPEN) {
- int do_join = (!!(it->it_flags & O_JOIN_FILE) &&
- op_data->op_data);
- CFS_LIST_HEAD(cancels);
- int count = 0;
- int mode;
-
- it->it_create_mode = (it->it_create_mode & ~S_IFMT) | S_IFREG;
-
- size[DLM_INTENT_REC_OFF] = sizeof(struct mdt_rec_create);
- /* parent capability */
- size[DLM_INTENT_REC_OFF + 1] = op_data->op_capa1 ?
- sizeof(struct lustre_capa) : 0;
- /* child capability, used for replay only */
- size[DLM_INTENT_REC_OFF + 2] = sizeof(struct lustre_capa);
- size[DLM_INTENT_REC_OFF + 3] = op_data->op_namelen + 1;
- /* As an optimization, we allocate an RPC request buffer for
- * at least a default-sized LOV EA even if we aren't sending
- * one.
- */
- size[DLM_INTENT_REC_OFF + 4] = max(lmmsize,
- obddev->u.cli.cl_default_mds_easize);
-
- /* XXX: openlock is not cancelled for cross-refs. */
- /* If inode is known, cancel conflicting OPEN locks. */
- if (fid_is_sane(&op_data->op_fid2)) {
- if (it->it_flags & (FMODE_WRITE|MDS_OPEN_TRUNC))
- mode = LCK_CW;
+ /* XXX: openlock is not cancelled for cross-refs. */
+ /* If inode is known, cancel conflicting OPEN locks. */
+ if (fid_is_sane(&op_data->op_fid2)) {
+ if (it->it_flags & (FMODE_WRITE|MDS_OPEN_TRUNC))
+ mode = LCK_CW;
#ifdef FMODE_EXEC
- else if (it->it_flags & FMODE_EXEC)
- mode = LCK_PR;
+ else if (it->it_flags & FMODE_EXEC)
+ mode = LCK_PR;
#endif
- else
- mode = LCK_CR;
- count = mdc_resource_get_unused(exp, &op_data->op_fid2,
- &cancels, mode,
- MDS_INODELOCK_OPEN);
- }
-
- /* If CREATE or JOIN_FILE, cancel parent's UPDATE lock. */
- if (it->it_op & IT_CREAT || do_join)
- mode = LCK_EX;
else
mode = LCK_CR;
- count += mdc_resource_get_unused(exp, &op_data->op_fid1,
- &cancels, mode,
- MDS_INODELOCK_UPDATE);
+ count = mdc_resource_get_unused(exp, &op_data->op_fid2,
+ &cancels, mode,
+ MDS_INODELOCK_OPEN);
+ }
- if (do_join)
- size[DLM_INTENT_REC_OFF + 5] =
- sizeof(struct mdt_rec_join);
- else
- it->it_flags &= ~O_JOIN_FILE;
+ /* If CREATE or JOIN_FILE, cancel parent's UPDATE lock. */
+ if (it->it_op & IT_CREAT || joinfile)
+ mode = LCK_EX;
+ else
+ mode = LCK_CR;
+ count += mdc_resource_get_unused(exp, &op_data->op_fid1,
+ &cancels, mode,
+ MDS_INODELOCK_UPDATE);
+
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp),
+ &RQF_LDLM_INTENT_OPEN);
+ if (req == NULL) {
+ ldlm_lock_list_put(&cancels, l_bl_ast, count);
+ RETURN(ERR_PTR(-ENOMEM));
+ }
- req = ldlm_prep_enqueue_req(exp, 8 + do_join, size, &cancels,
- count);
- if (!req)
- RETURN(-ENOMEM);
+ /* parent capability */
+ mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1);
+ /* child capability, reserve the size according to parent capa, it will
+ * be filled after we get the reply */
+ mdc_set_capa_size(req, &RMF_CAPA2, op_data->op_capa1);
+
+ req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT,
+ op_data->op_namelen + 1);
+ req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_CLIENT,
+ max(lmmsize, obddev->u.cli.cl_default_mds_easize));
+ if (!joinfile) {
+ req_capsule_set_size(&req->rq_pill, &RMF_REC_JOINFILE,
+ RCL_CLIENT, 0);
+ }
- if (do_join) {
- /* join is like an unlink of the tail */
- policy.l_inodebits.bits = MDS_INODELOCK_UPDATE;
- mdc_join_pack(req, DLM_INTENT_REC_OFF + 5, op_data,
- (*(__u64 *)op_data->op_data));
- }
+ if (exp_connect_cancelset(exp) && count) {
+ req_capsule_set_size(&req->rq_pill, &RMF_DLM_REQ, RCL_CLIENT,
+ ldlm_request_bufsize(count, LDLM_ENQUEUE));
+ }
- spin_lock(&req->rq_lock);
- req->rq_replay = 1;
- spin_unlock(&req->rq_lock);
+ rc = ptlrpc_request_pack(req, LUSTRE_DLM_VERSION, LDLM_ENQUEUE);
+ if (rc) {
+ ptlrpc_request_free(req);
+ ldlm_lock_list_put(&cancels, l_bl_ast, count);
+ return NULL;
+ }
+ if (exp_connect_cancelset(exp) && req)
+ ldlm_cli_cancel_list(&cancels, count, req, 0);
- /* pack the intent */
- lit = lustre_msg_buf(req->rq_reqmsg, DLM_INTENT_IT_OFF,
- sizeof(*lit));
- lit->opc = (__u64)it->it_op;
-
- /* pack the intended request */
- mdc_open_pack(req, DLM_INTENT_REC_OFF, op_data,
- it->it_create_mode, 0, it->it_flags,
- lmm, lmmsize);
-
- /* for remote client, fetch remote perm for current user */
- repsize[repbufcnt++] = client_is_remote(exp) ?
- sizeof(struct mdt_remote_perm) :
- LUSTRE_POSIX_ACL_MAX_SIZE;
- repsize[repbufcnt++] = sizeof(struct lustre_capa);
- repsize[repbufcnt++] = sizeof(struct lustre_capa);
- } else if (it->it_op & IT_UNLINK) {
- size[DLM_INTENT_REC_OFF] = sizeof(struct mdt_rec_unlink);
- size[DLM_INTENT_REC_OFF + 1] = op_data->op_capa1 ?
- sizeof(struct lustre_capa) : 0;
- size[DLM_INTENT_REC_OFF + 2] = op_data->op_namelen + 1;
- policy.l_inodebits.bits = MDS_INODELOCK_UPDATE;
- req = ldlm_prep_enqueue_req(exp, 6, size, NULL, 0);
- if (!req)
- RETURN(-ENOMEM);
-
- /* pack the intent */
- lit = lustre_msg_buf(req->rq_reqmsg, DLM_INTENT_IT_OFF,
- sizeof(*lit));
- lit->opc = (__u64)it->it_op;
-
- /* pack the intended request */
- mdc_unlink_pack(req, DLM_INTENT_REC_OFF, op_data);
-
- repsize[repbufcnt++] = obddev->u.cli.cl_max_mds_cookiesize;
- } else if (it->it_op & (IT_GETATTR | IT_LOOKUP)) {
- obd_valid valid = OBD_MD_FLGETATTR | OBD_MD_FLEASIZE |
- OBD_MD_FLMODEASIZE | OBD_MD_FLDIREA |
- OBD_MD_FLMDSCAPA | OBD_MD_MEA;
- valid |= client_is_remote(exp) ? OBD_MD_FLRMTPERM :
- OBD_MD_FLACL;
- size[DLM_INTENT_REC_OFF] = sizeof(struct mdt_body);
- size[DLM_INTENT_REC_OFF + 1] = op_data->op_capa1 ?
- sizeof(struct lustre_capa) : 0;
- size[DLM_INTENT_REC_OFF + 2] = op_data->op_namelen + 1;
-
- if (it->it_op & IT_GETATTR)
- policy.l_inodebits.bits = MDS_INODELOCK_UPDATE;
+ if (joinfile) {
+ __u64 head_size = *(__u64 *)op_data->op_data;
+ mdc_join_pack(req, op_data, head_size);
+ }
+
+ spin_lock(&req->rq_lock);
+ req->rq_replay = 1;
+ spin_unlock(&req->rq_lock);
+
+ /* pack the intent */
+ lit = req_capsule_client_get(&req->rq_pill, &RMF_LDLM_INTENT);
+ lit->opc = (__u64)it->it_op;
+
+ /* pack the intended request */
+ mdc_open_pack(req, op_data, it->it_create_mode, 0, it->it_flags, lmm,
+ lmmsize);
+
+ /* for remote client, fetch remote perm for current user */
+ if (client_is_remote(exp))
+ req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER,
+ sizeof(struct mdt_remote_perm));
+ ptlrpc_request_set_replen(req);
+ return req;
+}
+
+static struct ptlrpc_request *mdc_intent_unlink_pack(struct obd_export *exp,
+ struct lookup_intent *it,
+ struct md_op_data *op_data)
+{
+ struct ptlrpc_request *req;
+ struct obd_device *obddev = class_exp2obd(exp);
+ struct ldlm_intent *lit;
+ int rc;
+ ENTRY;
+
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp),
+ &RQF_LDLM_INTENT_UNLINK);
+ if (req == NULL)
+ RETURN(ERR_PTR(-ENOMEM));
+
+ mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1);
+ req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT,
+ op_data->op_namelen + 1);
+
+ rc = ptlrpc_request_pack(req, LUSTRE_DLM_VERSION, LDLM_ENQUEUE);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(ERR_PTR(rc));
+ }
+
+ /* pack the intent */
+ lit = req_capsule_client_get(&req->rq_pill, &RMF_LDLM_INTENT);
+ lit->opc = (__u64)it->it_op;
+
+ /* pack the intended request */
+ mdc_unlink_pack(req, op_data);
+
+ req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER,
+ obddev->u.cli.cl_max_mds_easize);
+ req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER,
+ obddev->u.cli.cl_max_mds_cookiesize);
+ ptlrpc_request_set_replen(req);
+ RETURN(req);
+}
- req = ldlm_prep_enqueue_req(exp, 6, size, NULL, 0);
- if (!req)
- RETURN(-ENOMEM);
+static struct ptlrpc_request *mdc_intent_getattr_pack(struct obd_export *exp,
+ struct lookup_intent *it,
+ struct md_op_data *op_data)
+{
+ struct ptlrpc_request *req;
+ struct obd_device *obddev = class_exp2obd(exp);
+ obd_valid valid = OBD_MD_FLGETATTR | OBD_MD_FLEASIZE |
+ OBD_MD_FLMODEASIZE | OBD_MD_FLDIREA |
+ OBD_MD_FLMDSCAPA | OBD_MD_MEA |
+ (client_is_remote(exp) ?
+ OBD_MD_FLRMTPERM : OBD_MD_FLACL);
+ struct ldlm_intent *lit;
+ int rc;
+ ENTRY;
- /* pack the intent */
- lit = lustre_msg_buf(req->rq_reqmsg, DLM_INTENT_IT_OFF,
- sizeof(*lit));
- lit->opc = (__u64)it->it_op;
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp),
+ &RQF_LDLM_INTENT_GETATTR);
+ if (req == NULL)
+ RETURN(ERR_PTR(-ENOMEM));
- /* pack the intended request */
- mdc_getattr_pack(req, DLM_INTENT_REC_OFF, valid,
- it->it_flags, op_data);
+ mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1);
+ req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT,
+ op_data->op_namelen + 1);
+
+ rc = ptlrpc_request_pack(req, LUSTRE_DLM_VERSION, LDLM_ENQUEUE);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(ERR_PTR(rc));
+ }
- repsize[repbufcnt++] = client_is_remote(exp) ?
- sizeof(struct mdt_remote_perm) :
- LUSTRE_POSIX_ACL_MAX_SIZE;
- repsize[repbufcnt++] = sizeof(struct lustre_capa);
- } else if (it->it_op == IT_READDIR) {
+ /* pack the intent */
+ lit = req_capsule_client_get(&req->rq_pill, &RMF_LDLM_INTENT);
+ lit->opc = (__u64)it->it_op;
+
+ /* pack the intended request */
+ mdc_getattr_pack(req, valid, it->it_flags, op_data);
+
+ req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER,
+ obddev->u.cli.cl_max_mds_easize);
+ if (client_is_remote(exp))
+ req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER,
+ sizeof(struct mdt_remote_perm));
+ ptlrpc_request_set_replen(req);
+ RETURN(req);
+}
+
+static struct ptlrpc_request *ldlm_enqueue_pack(struct obd_export *exp)
+{
+ struct ptlrpc_request *req;
+ ENTRY;
+
+ req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp),
+ &RQF_LDLM_ENQUEUE, LUSTRE_DLM_VERSION,
+ LDLM_ENQUEUE);
+ if (req == NULL)
+ RETURN(ERR_PTR(-ENOMEM));
+
+ ptlrpc_request_set_replen(req);
+ RETURN(req);
+}
+
+/* We always reserve enough space in the reply packet for a stripe MD, because
+ * we don't know in advance the file type. */
+int mdc_enqueue(struct obd_export *exp, struct ldlm_enqueue_info *einfo,
+ struct lookup_intent *it, struct md_op_data *op_data,
+ struct lustre_handle *lockh, void *lmm, int lmmsize,
+ int extra_lock_flags)
+{
+ struct obd_device *obddev = class_exp2obd(exp);
+ struct ptlrpc_request *req;
+ struct req_capsule *pill;
+ struct ldlm_request *lockreq;
+ struct ldlm_reply *lockrep;
+ int flags = extra_lock_flags | LDLM_FL_HAS_INTENT;
+ int rc;
+ struct ldlm_res_id res_id =
+ { .name = {fid_seq(&op_data->op_fid1),
+ fid_oid(&op_data->op_fid1),
+ fid_ver(&op_data->op_fid1)} };
+ ldlm_policy_data_t policy = { .l_inodebits = { MDS_INODELOCK_LOOKUP } };
+ ENTRY;
+
+ LASSERTF(einfo->ei_type == LDLM_IBITS,"lock type %d\n", einfo->ei_type);
+
+ if (it->it_op & (IT_UNLINK | IT_GETATTR | IT_READDIR))
policy.l_inodebits.bits = MDS_INODELOCK_UPDATE;
- req = ldlm_prep_enqueue_req(exp, 2, size, NULL, 0);
- if (!req)
- RETURN(-ENOMEM);
- repbufcnt = 2;
- } else {
+ if (it->it_op & IT_OPEN) {
+ int joinfile = !!((it->it_flags & O_JOIN_FILE) &&
+ op_data->op_data);
+
+ req = mdc_intent_open_pack(exp, it, op_data, lmm, lmmsize,
+ einfo->ei_cbdata);
+ if (!joinfile) {
+ policy.l_inodebits.bits = MDS_INODELOCK_UPDATE;
+ einfo->ei_cbdata = NULL;
+ lmm = NULL;
+ } else
+ it->it_flags &= ~O_JOIN_FILE;
+ } else if (it->it_op & IT_UNLINK)
+ req = mdc_intent_unlink_pack(exp, it, op_data);
+ else if (it->it_op & (IT_GETATTR | IT_LOOKUP))
+ req = mdc_intent_getattr_pack(exp, it, op_data);
+ else if (it->it_op == IT_READDIR)
+ req = ldlm_enqueue_pack(exp);
+ else {
LBUG();
RETURN(-EINVAL);
}
- /* get ready for the reply */
- ptlrpc_req_set_repsize(req, repbufcnt, repsize);
+ if (IS_ERR(req))
+ RETURN(PTR_ERR(req));
+ pill = &req->rq_pill;
- /* It is important to obtain rpc_lock first (if applicable), so that
- * threads that are serialised with rpc_lock are not polluting our
- * rpcs in flight counter */
+ /* It is important to obtain rpc_lock first (if applicable), so that
+ * threads that are serialised with rpc_lock are not polluting our
+ * rpcs in flight counter */
mdc_get_rpc_lock(obddev->u.cli.cl_rpc_lock, it);
mdc_enter_request(&obddev->u.cli);
rc = ldlm_cli_enqueue(exp, &req, einfo, &res_id, &policy, &flags, NULL,
/* Similarly, if we're going to replay this request, we don't want to
* actually get a lock, just perform the intent. */
if (req->rq_transno || req->rq_replay) {
- lockreq = lustre_msg_buf(req->rq_reqmsg, DLM_LOCKREQ_OFF,
- sizeof(*lockreq));
+ lockreq = req_capsule_client_get(pill, &RMF_DLM_REQ);
lockreq->lock_flags |= LDLM_FL_INTENT_ONLY;
}
LDLM_LOCK_PUT(lock);
}
- lockrep = lustre_msg_buf(req->rq_repmsg, DLM_LOCKREPLY_OFF,
- sizeof(*lockrep));
+ lockrep = req_capsule_server_get(pill, &RMF_DLM_REP);
LASSERT(lockrep != NULL); /* checked by ldlm_cli_enqueue() */
- /* swabbed by ldlm_cli_enqueue() */
- LASSERT(lustre_rep_swabbed(req, DLM_LOCKREPLY_OFF));
it->d.lustre.it_disposition = (int)lockrep->lock_policy_res1;
it->d.lustre.it_status = (int)lockrep->lock_policy_res2;
it->it_op,it->d.lustre.it_disposition,it->d.lustre.it_status);
/* We know what to expect, so we do any byte flipping required here */
- LASSERT(repbufcnt == 7 || repbufcnt == 6 || repbufcnt == 2);
- if (repbufcnt >= 6) {
- int reply_off = DLM_REPLY_REC_OFF;
+ if (it->it_op & (IT_OPEN | IT_UNLINK | IT_LOOKUP | IT_GETATTR)) {
struct mdt_body *body;
- body = lustre_swab_repbuf(req, reply_off++, sizeof(*body),
- lustre_swab_mdt_body);
+ body = req_capsule_server_get(pill, &RMF_MDT_BODY);
if (body == NULL) {
CERROR ("Can't swab mdt_body\n");
RETURN (-EPROTO);
* The eadata is opaque; just check that it is there.
* Eventually, obd_unpackmd() will check the contents.
*/
- eadata = lustre_swab_repbuf(req, reply_off++,
- body->eadatasize, NULL);
- if (eadata == NULL) {
- CERROR("Missing/short eadata\n");
+ eadata = req_capsule_server_sized_get(pill, &RMF_MDT_MD,
+ body->eadatasize);
+ if (eadata == NULL)
RETURN(-EPROTO);
- }
+
if (body->valid & OBD_MD_FLMODEASIZE) {
if (obddev->u.cli.cl_max_mds_easize <
body->max_mdsize) {
* (for example error one).
*/
if ((it->it_op & IT_OPEN) && req->rq_replay) {
- if (lustre_msg_buflen(req->rq_reqmsg,
- DLM_INTENT_REC_OFF + 4) <
- body->eadatasize)
- mdc_realloc_openmsg(req, body, size);
-
- lmm = lustre_msg_buf(req->rq_reqmsg,
- DLM_INTENT_REC_OFF + 4,
- body->eadatasize);
+ if (req_capsule_get_size(pill, &RMF_EADATA,
+ RCL_CLIENT) <
+ body->eadatasize) {
+ mdc_realloc_openmsg(req, body);
+ req_capsule_set_size(pill, &RMF_EADATA,
+ RCL_CLIENT,
+ body->eadatasize);
+ }
+ lmm = req_capsule_client_get(pill, &RMF_EADATA);
if (lmm)
memcpy(lmm, eadata, body->eadatasize);
}
}
+
if (body->valid & OBD_MD_FLRMTPERM) {
struct mdt_remote_perm *perm;
LASSERT(client_is_remote(exp));
- perm = lustre_swab_repbuf(req, reply_off++,
- sizeof(*perm),
- lustre_swab_mdt_remote_perm);
- if (perm == NULL) {
- CERROR("missing remote permission!\n");
+ perm = req_capsule_server_get(pill, &RMF_ACL);
+ if (perm == NULL)
RETURN(-EPROTO);
- }
- } else if ((body->valid & OBD_MD_FLACL) && body->aclsize) {
- reply_off++;
+
+ lustre_swab_mdt_remote_perm(perm);
}
if (body->valid & OBD_MD_FLMDSCAPA) {
struct lustre_capa *capa, *p;
- capa = lustre_unpack_capa(req->rq_repmsg, reply_off++);
- if (capa == NULL) {
- CERROR("Missing/short MDS capability\n");
+ capa = req_capsule_server_get(pill, &RMF_CAPA1);
+ if (capa == NULL)
RETURN(-EPROTO);
- }
if (it->it_op & IT_OPEN) {
/* client fid capa will be checked in replay */
- p = lustre_msg_buf(req->rq_reqmsg,
- DLM_INTENT_REC_OFF + 2,
- sizeof(*p));
+ p = req_capsule_client_get(pill, &RMF_CAPA2);
LASSERT(p);
*p = *capa;
}
if (body->valid & OBD_MD_FLOSSCAPA) {
struct lustre_capa *capa;
- capa = lustre_unpack_capa(req->rq_repmsg, reply_off++);
- if (capa == NULL) {
- CERROR("Missing/short OSS capability\n");
+ capa = req_capsule_server_get(pill, &RMF_CAPA2);
+ if (capa == NULL)
RETURN(-EPROTO);
- }
}
}
if (rc)
RETURN(rc);
- mdt_body = lustre_msg_buf(request->rq_repmsg, DLM_REPLY_REC_OFF,
- sizeof(*mdt_body));
- /* mdc_enqueue checked */
- LASSERT(mdt_body != NULL);
- /* mdc_enqueue swabbed */
- LASSERT(lustre_rep_swabbed(request, 1));
+ mdt_body = req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY);
+ LASSERT(mdt_body != NULL); /* mdc_enqueue checked */
/* If we were revalidating a fid/name pair, mark the intent in
* case we fail and get called again from lookup */
- if (fid_is_sane(&op_data->op_fid2) && (it->it_flags & O_CHECK_STALE) &&
- (it->it_op != IT_GETATTR)) {
+ if (fid_is_sane(&op_data->op_fid2) &&
+ (it->it_flags & O_CHECK_STALE) &&
+ it->it_op != IT_GETATTR) {
it_set_disposition(it, DISP_ENQ_COMPLETE);
/* Also: did we find the same inode? */
/* mdc_setattr does its own semaphore handling */
static int mdc_reint(struct ptlrpc_request *request,
- struct mdc_rpc_lock *rpc_lock, int level)
+ struct mdc_rpc_lock *rpc_lock,
+ int level)
{
int rc;
mdc_put_rpc_lock(rpc_lock, NULL);
if (rc)
CDEBUG(D_INFO, "error in handling %d\n", rc);
- else if (!lustre_swab_repbuf(request, REPLY_REC_OFF,
- sizeof(struct mdt_body),
- lustre_swab_mdt_body)) {
- CERROR ("Can't unpack mdt_body\n");
+ else if (!req_capsule_server_get(&request->rq_pill, &RMF_MDT_BODY)) {
rc = -EPROTO;
}
return rc;
RETURN(count);
}
-struct ptlrpc_request *mdc_prep_elc_req(struct obd_export *exp,
- int bufcount, int *size, int off,
- struct list_head *cancels, int count)
+static int mdc_prep_elc_req(struct obd_export *exp, struct ptlrpc_request *req,
+ struct list_head *cancels, int count)
{
- return ldlm_prep_elc_req(exp, LUSTRE_MDS_VERSION, MDS_REINT,
- bufcount, size, off, 0, cancels, count);
+ return ldlm_prep_elc_req(exp, req, LUSTRE_MDS_VERSION, MDS_REINT,
+ 0, cancels, count);
}
/* If mdc_setattr is called with an 'iattr', then it is a normal RPC that
{
CFS_LIST_HEAD(cancels);
struct ptlrpc_request *req;
- struct mdt_rec_setattr *rec;
struct mdc_rpc_lock *rpc_lock;
struct obd_device *obd = exp->exp_obd;
- int size[7] = { sizeof(struct ptlrpc_body),
- sizeof(*rec), 0, 0, ealen, ea2len, 0 };
- int count = 0, bufcount = 4, rc;
+ int count = 0, rc;
__u64 bits;
ENTRY;
LASSERT(op_data != NULL);
- size[REQ_REC_OFF + 1] = op_data->op_capa1 ?
- sizeof(struct lustre_capa) : 0;
-
- if (op_data->op_flags & (MF_SOM_CHANGE | MF_EPOCH_OPEN))
- size[REQ_REC_OFF + 2] = sizeof(struct mdt_epoch);
-
- if (ealen > 0) {
- bufcount++;
- if (ea2len > 0)
- bufcount++;
- }
-
bits = MDS_INODELOCK_UPDATE;
if (op_data->op_attr.ia_valid & (ATTR_MODE|ATTR_UID|ATTR_GID))
bits |= MDS_INODELOCK_LOOKUP;
(fid_is_sane(&op_data->op_fid1)))
count = mdc_resource_get_unused(exp, &op_data->op_fid1,
&cancels, LCK_EX, bits);
- if (exp_connect_cancelset(exp) && count)
- bufcount = 7;
- req = mdc_prep_elc_req(exp, bufcount, size,
- REQ_REC_OFF + 5, &cancels, count);
-
- if (req == NULL)
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp),
+ &RQF_MDS_REINT_SETATTR);
+ if (req == NULL) {
+ ldlm_lock_list_put(&cancels, l_bl_ast, count);
RETURN(-ENOMEM);
+ }
+ mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1);
+ if ((op_data->op_flags & (MF_SOM_CHANGE | MF_EPOCH_OPEN)) == 0)
+ req_capsule_set_size(&req->rq_pill, &RMF_MDT_EPOCH, RCL_CLIENT,
+ 0);
+ req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_CLIENT, ealen);
+ req_capsule_set_size(&req->rq_pill, &RMF_LOGCOOKIES, RCL_CLIENT,
+ ea2len);
+
+ rc = mdc_prep_elc_req(exp, req, &cancels, count);
+ if (rc) {
+ ldlm_lock_list_put(&cancels, l_bl_ast, count);
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
if (op_data->op_attr.ia_valid & ATTR_FROM_OPEN) {
req->rq_request_portal = MDS_SETATTR_PORTAL; //XXX FIXME bug 249
CDEBUG(D_INODE, "setting mtime %lu, ctime %lu\n",
LTIME_S(op_data->op_attr.ia_mtime),
LTIME_S(op_data->op_attr.ia_ctime));
- mdc_setattr_pack(req, REQ_REC_OFF, op_data, ea, ealen, ea2, ea2len);
+ mdc_setattr_pack(req, op_data, ea, ealen, ea2, ea2len);
- size[REPLY_REC_OFF] = sizeof(struct mdt_body);
- size[REPLY_REC_OFF + 1] = sizeof(struct lustre_capa);
- ptlrpc_req_set_repsize(req, 3, size);
+ ptlrpc_request_set_replen(req);
if (mod && (op_data->op_flags & MF_EPOCH_OPEN) &&
req->rq_import->imp_replayable)
{
const void *data, int datalen, int mode, __u32 uid, __u32 gid,
__u32 cap_effective, __u64 rdev, struct ptlrpc_request **request)
{
- int size[6] = { sizeof(struct ptlrpc_body),
- sizeof(struct mdt_rec_create),
- 0, op_data->op_namelen + 1, 0, 0 };
- struct obd_device *obd = exp->exp_obd;
- int level, bufcount = 4, rc;
struct ptlrpc_request *req;
+ int level, rc;
int count = 0;
CFS_LIST_HEAD(cancels);
ENTRY;
}
}
- size[REQ_REC_OFF + 1] = op_data->op_capa1 ?
- sizeof(struct lustre_capa) : 0;
-
- if (data && datalen) {
- size[bufcount] = datalen;
- bufcount++;
- }
-
if ((op_data->op_flags & MF_MDC_CANCEL_FID1) &&
(fid_is_sane(&op_data->op_fid1)))
count = mdc_resource_get_unused(exp, &op_data->op_fid1,
&cancels, LCK_EX,
MDS_INODELOCK_UPDATE);
- if (exp_connect_cancelset(exp) && count)
- bufcount = 6;
- req = mdc_prep_elc_req(exp, bufcount, size,
- REQ_REC_OFF + 4, &cancels, count);
- if (req == NULL)
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp),
+ &RQF_MDS_REINT_CREATE_RMT_ACL);
+ if (req == NULL) {
+ ldlm_lock_list_put(&cancels, l_bl_ast, count);
RETURN(-ENOMEM);
+ }
+ mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1);
+ req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT,
+ op_data->op_namelen + 1);
+ req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_CLIENT,
+ data && datalen ? datalen : 0);
+
+ rc = mdc_prep_elc_req(exp, req, &cancels, count);
+ if (rc) {
+ ldlm_lock_list_put(&cancels, l_bl_ast, count);
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
/*
* 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,
+ mdc_create_pack(req, op_data, data, datalen, mode, uid,
gid, cap_effective, rdev);
- size[REPLY_REC_OFF] = sizeof(struct mdt_body);
- size[REPLY_REC_OFF + 1] = sizeof(struct lustre_capa);
- ptlrpc_req_set_repsize(req, 3, size);
+ ptlrpc_request_set_replen(req);
level = LUSTRE_IMP_FULL;
resend:
- rc = mdc_reint(req, obd->u.cli.cl_rpc_lock, level);
+ rc = mdc_reint(req, exp->exp_obd->u.cli.cl_rpc_lock, level);
/* Resend if we were told to. */
if (rc == -ERESTARTSYS) {
struct mdt_body *body;
struct lustre_capa *capa;
- body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF,
- sizeof(*body));
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
LASSERT(body);
if (body->valid & OBD_MD_FLMDSCAPA) {
- capa = lustre_unpack_capa(req->rq_repmsg,
- REPLY_REC_OFF + 1);
- if (capa == NULL) {
- CERROR("Missing/short MDS capability\n");
+ capa = req_capsule_server_get(&req->rq_pill,
+ &RMF_CAPA1);
+ if (capa == NULL)
rc = -EPROTO;
- }
}
}
CFS_LIST_HEAD(cancels);
struct obd_device *obd = class_exp2obd(exp);
struct ptlrpc_request *req = *request;
- int size[5] = { sizeof(struct ptlrpc_body),
- sizeof(struct mdt_rec_unlink),
- 0, op_data->op_namelen + 1, 0 };
- int count = 0, rc, bufcount = 4;
+ int count = 0, rc;
ENTRY;
LASSERT(req == NULL);
- size[REQ_REC_OFF + 1] = op_data->op_capa1 ?
- sizeof(struct lustre_capa) : 0;
-
if ((op_data->op_flags & MF_MDC_CANCEL_FID1) &&
(fid_is_sane(&op_data->op_fid1)))
count = mdc_resource_get_unused(exp, &op_data->op_fid1,
count += mdc_resource_get_unused(exp, &op_data->op_fid3,
&cancels, LCK_EX,
MDS_INODELOCK_FULL);
- if (exp_connect_cancelset(exp) && count)
- bufcount = 5;
-
- req = mdc_prep_elc_req(exp, bufcount, size,
- REQ_REC_OFF + 3, &cancels, count);
-
- if (req == NULL)
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp),
+ &RQF_MDS_REINT_UNLINK);
+ if (req == NULL) {
+ ldlm_lock_list_put(&cancels, l_bl_ast, count);
RETURN(-ENOMEM);
- *request = req;
+ }
+ mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1);
+ req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT,
+ op_data->op_namelen + 1);
+
+ rc = mdc_prep_elc_req(exp, req, &cancels, count);
+ if (rc) {
+ ldlm_lock_list_put(&cancels, l_bl_ast, count);
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
+
+ mdc_unlink_pack(req, op_data);
- size[REPLY_REC_OFF] = sizeof(struct mdt_body);
- size[REPLY_REC_OFF + 1] = obd->u.cli.cl_max_mds_easize;
- size[REPLY_REC_OFF + 2] = obd->u.cli.cl_max_mds_cookiesize;
- ptlrpc_req_set_repsize(req, 4, size);
+ req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER,
+ obd->u.cli.cl_max_mds_easize);
+ req_capsule_set_size(&req->rq_pill, &RMF_LOGCOOKIES, RCL_SERVER,
+ obd->u.cli.cl_max_mds_cookiesize);
+ ptlrpc_request_set_replen(req);
- mdc_unlink_pack(req, REQ_REC_OFF, op_data);
+ *request = req;
rc = mdc_reint(req, obd->u.cli.cl_rpc_lock, LUSTRE_IMP_FULL);
if (rc == -ERESTARTSYS)
CFS_LIST_HEAD(cancels);
struct obd_device *obd = exp->exp_obd;
struct ptlrpc_request *req;
- int size[6] = { sizeof(struct ptlrpc_body),
- sizeof(struct mdt_rec_link),
- 0, 0, op_data->op_namelen + 1, 0 };
- int count = 0, rc, bufcount = 5;
+ int count = 0, rc;
ENTRY;
- size[REQ_REC_OFF + 1] = op_data->op_capa1 ?
- sizeof(struct lustre_capa) : 0;
- size[REQ_REC_OFF + 2] = op_data->op_capa2 ?
- sizeof(struct lustre_capa) : 0;
-
if ((op_data->op_flags & MF_MDC_CANCEL_FID2) &&
(fid_is_sane(&op_data->op_fid2)))
count = mdc_resource_get_unused(exp, &op_data->op_fid2,
count += mdc_resource_get_unused(exp, &op_data->op_fid1,
&cancels, LCK_EX,
MDS_INODELOCK_UPDATE);
- if (exp_connect_cancelset(exp) && count)
- bufcount = 6;
- req = mdc_prep_elc_req(exp, bufcount, size,
- REQ_REC_OFF + 4, &cancels, count);
- if (req == NULL)
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_REINT_LINK);
+ if (req == NULL) {
+ ldlm_lock_list_put(&cancels, l_bl_ast, count);
RETURN(-ENOMEM);
+ }
+ mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1);
+ mdc_set_capa_size(req, &RMF_CAPA2, op_data->op_capa2);
+ req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT,
+ op_data->op_namelen + 1);
+
+ rc = mdc_prep_elc_req(exp, req, &cancels, count);
+ if (rc) {
+ ldlm_lock_list_put(&cancels, l_bl_ast, count);
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
- mdc_link_pack(req, REQ_REC_OFF, op_data);
-
- size[REPLY_REC_OFF] = sizeof(struct mdt_body);
- ptlrpc_req_set_repsize(req, 2, size);
+ mdc_link_pack(req, op_data);
+ ptlrpc_request_set_replen(req);
rc = mdc_reint(req, obd->u.cli.cl_rpc_lock, LUSTRE_IMP_FULL);
*request = req;
CFS_LIST_HEAD(cancels);
struct obd_device *obd = exp->exp_obd;
struct ptlrpc_request *req;
- int size[7] = { sizeof(struct ptlrpc_body),
- sizeof(struct mdt_rec_rename),
- 0, 0, oldlen + 1, newlen + 1, 0 };
- int count = 0, rc, bufcount = 6;
+ int count = 0, rc;
ENTRY;
- size[REQ_REC_OFF + 1] = op_data->op_capa1 ?
- sizeof(struct lustre_capa) : 0;
- size[REQ_REC_OFF + 2] = op_data->op_capa2 ?
- sizeof(struct lustre_capa) : 0;
-
if ((op_data->op_flags & MF_MDC_CANCEL_FID1) &&
(fid_is_sane(&op_data->op_fid1)))
count = mdc_resource_get_unused(exp, &op_data->op_fid1,
count += mdc_resource_get_unused(exp, &op_data->op_fid4,
&cancels, LCK_EX,
MDS_INODELOCK_FULL);
- if (exp_connect_cancelset(exp) && count)
- bufcount = 7;
- req = mdc_prep_elc_req(exp, bufcount, size,
- REQ_REC_OFF + 5, &cancels, count);
- if (req == NULL)
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp),
+ &RQF_MDS_REINT_RENAME);
+ if (req == NULL) {
+ ldlm_lock_list_put(&cancels, l_bl_ast, count);
RETURN(-ENOMEM);
+ }
+
+ mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1);
+ mdc_set_capa_size(req, &RMF_CAPA2, op_data->op_capa2);
+ req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, oldlen + 1);
+ req_capsule_set_size(&req->rq_pill, &RMF_SYMTGT, RCL_CLIENT, newlen+1);
+
+ rc = mdc_prep_elc_req(exp, req, &cancels, count);
+ if (rc) {
+ ldlm_lock_list_put(&cancels, l_bl_ast, count);
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
+
+ if (exp_connect_cancelset(exp) && req)
+ ldlm_cli_cancel_list(&cancels, count, req, 0);
- mdc_rename_pack(req, REQ_REC_OFF, op_data, old, oldlen, new, newlen);
+ mdc_rename_pack(req, op_data, old, oldlen, new, newlen);
- size[REPLY_REC_OFF] = sizeof(struct mdt_body);
- size[REPLY_REC_OFF + 1] = obd->u.cli.cl_max_mds_easize;
- size[REPLY_REC_OFF + 2] = obd->u.cli.cl_max_mds_cookiesize;
- ptlrpc_req_set_repsize(req, 4, size);
+ req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER,
+ obd->u.cli.cl_max_mds_easize);
+ req_capsule_set_size(&req->rq_pill, &RMF_LOGCOOKIES, RCL_SERVER,
+ obd->u.cli.cl_max_mds_cookiesize);
+ ptlrpc_request_set_replen(req);
rc = mdc_reint(req, obd->u.cli.cl_rpc_lock, LUSTRE_IMP_FULL);
*request = req;
static int mdc_cleanup(struct obd_device *obd);
static struct obd_capa *mdc_unpack_capa(struct ptlrpc_request *req,
- unsigned int offset)
+ const struct req_msg_field *field)
{
struct lustre_capa *capa;
struct obd_capa *oc;
/* swabbed already in mdc_enqueue */
- capa = lustre_msg_buf(req->rq_repmsg, offset, sizeof(*capa));
- if (capa == NULL) {
- CERROR("missing capa at offset %d failed!\n", offset);
- return ERR_PTR(-EFAULT);
- }
+ capa = req_capsule_server_get(&req->rq_pill, field);
+ if (capa == NULL)
+ return ERR_PTR(-EPROTO);
oc = alloc_capa(CAPA_SITE_CLIENT);
if (!oc) {
- CERROR("alloc capa failed!\n");
+ CDEBUG(D_INFO, "alloc capa failed!\n");
return ERR_PTR(-ENOMEM);
}
oc->c_capa = *capa;
struct obd_capa **pc, int level, int msg_flags)
{
struct ptlrpc_request *req;
- struct mdt_body *body;
- int rc, size[3] = { sizeof(struct ptlrpc_body),
- sizeof(*body),
- sizeof(struct lustre_capa) };
+ struct mdt_body *body;
+ int rc;
ENTRY;
- req = ptlrpc_prep_req(imp, LUSTRE_MDS_VERSION, MDS_GETSTATUS, 2, size,
- NULL);
- if (!req)
- GOTO(out, rc = -ENOMEM);
-
- req->rq_send_state = level;
- ptlrpc_req_set_repsize(req, 3, size);
+ req = ptlrpc_request_alloc_pack(imp, &RQF_MDS_GETSTATUS,
+ LUSTRE_MDS_VERSION, MDS_GETSTATUS);
+ if (req == NULL)
+ RETURN(-ENOMEM);
- mdc_pack_req_body(req, REQ_REC_OFF, 0, NULL, NULL, 0, -1, 0);
+ mdc_pack_body(req, NULL, NULL, 0, 0, -1, 0);
lustre_msg_add_flags(req->rq_reqmsg, msg_flags);
- rc = ptlrpc_queue_wait(req);
+ req->rq_send_state = level;
- if (!rc) {
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_mdt_body);
- if (body == NULL) {
- CERROR ("Can't extract mdt_body\n");
- GOTO (out, rc = -EPROTO);
- }
+ ptlrpc_request_set_replen(req);
- *rootfid = body->fid1;
+ rc = ptlrpc_queue_wait(req);
+ if (rc)
+ GOTO(out, rc);
- if (body->valid & OBD_MD_FLMDSCAPA) {
- struct obd_capa *oc;
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
+ if (body == NULL)
+ GOTO(out, rc = -EPROTO);
- oc = mdc_unpack_capa(req, REPLY_REC_OFF + 1);
- if (IS_ERR(oc))
- GOTO(out, rc = PTR_ERR(oc));
- *pc = oc;
- }
+ if (body->valid & OBD_MD_FLMDSCAPA) {
+ struct obd_capa *oc;
- CDEBUG(D_NET, "root fid="DFID", last_committed="LPU64
- ", last_xid="LPU64"\n",
- PFID(rootfid),
- lustre_msg_get_last_committed(req->rq_repmsg),
- lustre_msg_get_last_xid(req->rq_repmsg));
+ oc = mdc_unpack_capa(req, &RMF_CAPA1);
+ if (IS_ERR(oc))
+ GOTO(out, rc = PTR_ERR(oc));
+ *pc = oc;
}
+ *rootfid = body->fid1;
+ CDEBUG(D_NET,
+ "root fid="DFID", last_committed="LPU64", last_xid="LPU64"\n",
+ PFID(rootfid),
+ lustre_msg_get_last_committed(req->rq_repmsg),
+ lustre_msg_get_last_xid(req->rq_repmsg));
EXIT;
- out:
+out:
ptlrpc_req_finished(req);
return rc;
}
* 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, int mdscapa,
+static int mdc_getattr_common(struct obd_export *exp,
struct ptlrpc_request *req)
{
- struct mdt_body *body;
- void *eadata;
- int size[5] = { sizeof(struct ptlrpc_body),
- sizeof(*body),
- ea_size,
- acl_size,
- sizeof(struct lustre_capa) };
- int offset, rc;
+ struct req_capsule *pill = &req->rq_pill;
+ struct mdt_body *body;
+ void *eadata;
+ int rc;
ENTRY;
/* Request message already built. */
- if (ea_size)
- CDEBUG(D_INODE, "reserved %u bytes for MD/symlink in packet\n",
- ea_size);
- if (acl_size)
- CDEBUG(D_INODE, "reserved %u bytes for ACL\n", acl_size);
-
- ptlrpc_req_set_repsize(req, 5, size);
-
rc = ptlrpc_queue_wait(req);
if (rc != 0)
- RETURN (rc);
+ RETURN(rc);
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_mdt_body);
- if (body == NULL) {
- CERROR ("Can't unpack mdt_body\n");
- RETURN (-EPROTO);
- }
+ /* sanity check for the reply */
+ body = req_capsule_server_get(pill, &RMF_MDT_BODY);
+ if (body == NULL)
+ RETURN(-EPROTO);
CDEBUG(D_NET, "mode: %o\n", body->mode);
- offset = REPLY_REC_OFF + 1;
- lustre_set_rep_swabbed(req, offset);
if (body->eadatasize != 0) {
- /* reply indicates presence of eadata; check it's there... */
- eadata = lustre_msg_buf(req->rq_repmsg, offset++,
- body->eadatasize);
- if (eadata == NULL) {
- CERROR ("Missing/short eadata\n");
- RETURN (-EPROTO);
- }
+ eadata = req_capsule_server_sized_get(pill, &RMF_MDT_MD,
+ body->eadatasize);
+ if (eadata == NULL)
+ RETURN(-EPROTO);
}
if (body->valid & OBD_MD_FLMODEASIZE) {
cli->cl_max_mds_cookiesize = body->max_cookiesize;
}
- offset += !!body->aclsize;
+ if (body->valid & OBD_MD_FLRMTPERM) {
+ struct mdt_remote_perm *perm;
+ perm = req_capsule_server_get(pill, &RMF_ACL);
+ if (perm == NULL)
+ RETURN(-EPROTO);
+ }
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");
+ capa = req_capsule_server_get(pill, &RMF_CAPA1);
+ if (capa == NULL)
RETURN(-EPROTO);
- }
}
- RETURN (0);
+ RETURN(0);
}
int mdc_getattr(struct obd_export *exp, const struct lu_fid *fid,
struct ptlrpc_request **request)
{
struct ptlrpc_request *req;
- int size[3] = { sizeof(struct ptlrpc_body), sizeof(struct mdt_body) };
- int acl_size = 0, rc;
+ int rc;
ENTRY;
- size[REQ_REC_OFF + 1] = oc ? sizeof(struct lustre_capa) : 0;
+ *request = NULL;
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_GETATTR);
+ if (req == NULL)
+ RETURN(-ENOMEM);
- /*
- * XXX: Do we need to make another request here? We just did a getattr
- * to do the lookup in the first place.
- */
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
- MDS_GETATTR, 3, size, NULL);
- if (!req)
- GOTO(out, rc = -ENOMEM);
+ mdc_set_capa_size(req, &RMF_CAPA1, oc);
+
+ rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_GETATTR);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
- mdc_pack_req_body(req, REQ_REC_OFF, valid, fid, oc, ea_size, -1,
- MDS_BFLAG_EXT_FLAGS/*request "new" flags(bug 9486)*/);
+ /* MDS_BFLAG_EXT_FLAGS: request "new" flags(bug 9486) */
+ mdc_pack_body(req, fid, oc, valid, ea_size, -1, MDS_BFLAG_EXT_FLAGS);
+ req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER, ea_size);
if (valid & OBD_MD_FLRMTPERM)
- acl_size = sizeof(struct mdt_remote_perm);
-
- /* Currently only root inode will call us with FLACL */
- else if (valid & OBD_MD_FLACL)
- acl_size = LUSTRE_POSIX_ACL_MAX_SIZE;
+ req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER,
+ sizeof(struct mdt_remote_perm));
+ ptlrpc_request_set_replen(req);
- rc = mdc_getattr_common(exp, ea_size, acl_size,
- !!(valid & OBD_MD_FLMDSCAPA), req);
- if (rc != 0) {
- ptlrpc_req_finished (req);
- req = NULL;
- }
- out:
- *request = req;
- RETURN (rc);
+ rc = mdc_getattr_common(exp, req);
+ if (rc)
+ ptlrpc_req_finished(req);
+ else
+ *request = req;
+ RETURN(rc);
}
int mdc_getattr_name(struct obd_export *exp, const struct lu_fid *fid,
struct ptlrpc_request **request)
{
struct ptlrpc_request *req;
- struct mdt_body *body;
- int size[4] = { sizeof(struct ptlrpc_body), sizeof(*body), 0, namelen};
- int rc;
+ int rc;
ENTRY;
- size[REQ_REC_OFF + 1] = oc ? sizeof(struct lustre_capa) : 0;
+ *request = NULL;
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp),
+ &RQF_MDS_GETATTR_NAME);
+ if (req == NULL)
+ RETURN(-ENOMEM);
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
- MDS_GETATTR_NAME, 4, size, NULL);
- if (!req)
- GOTO(out, rc = -ENOMEM);
+ mdc_set_capa_size(req, &RMF_CAPA1, oc);
+ req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT, namelen);
+
+ rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_GETATTR_NAME);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
- mdc_pack_req_body(req, REQ_REC_OFF, valid, fid, oc, ea_size, suppgid,
- MDS_BFLAG_EXT_FLAGS/*request "new" flags(bug 9486)*/);
+ /* MDS_BFLAG_EXT_FLAGS: request "new" flags(bug 9486) */
+ mdc_pack_body(req, fid, oc, valid, ea_size, suppgid,
+ MDS_BFLAG_EXT_FLAGS);
if (filename) {
+ char *name = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
LASSERT(strnlen(filename, namelen) == namelen - 1);
- memcpy(lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF + 2, namelen),
- filename, namelen);
+ memcpy(name, filename, namelen);
}
- rc = mdc_getattr_common(exp, ea_size, 0, !!(valid & OBD_MD_FLMDSCAPA),
- req);
- if (rc != 0) {
- ptlrpc_req_finished (req);
- req = NULL;
- }
- out:
- *request = req;
+ req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER, ea_size);
+ ptlrpc_request_set_replen(req);
+
+ rc = mdc_getattr_common(exp, req);
+ if (rc)
+ ptlrpc_req_finished(req);
+ else
+ *request = req;
RETURN(rc);
}
-static int mdc_is_subdir(struct obd_export *exp, const struct lu_fid *pfid,
- const struct lu_fid *cfid, struct ptlrpc_request **request)
+static int mdc_is_subdir(struct obd_export *exp,
+ const struct lu_fid *pfid,
+ const struct lu_fid *cfid,
+ struct ptlrpc_request **request)
{
- int size[2] = { sizeof(struct ptlrpc_body),
- sizeof(struct mdt_body) };
- struct ptlrpc_request *req;
- struct mdt_body *body;
- int rc;
+ struct ptlrpc_request *req;
+ int rc;
+
ENTRY;
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
- MDS_IS_SUBDIR, 2, size, NULL);
- if (!req)
- GOTO(out, rc = -ENOMEM);
+ *request = NULL;
+ req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp),
+ &RQF_MDS_IS_SUBDIR, LUSTRE_MDS_VERSION,
+ MDS_IS_SUBDIR);
+ if (req == NULL)
+ RETURN(-ENOMEM);
- mdc_is_subdir_pack(req, REQ_REC_OFF, pfid, cfid, 0);
+ mdc_is_subdir_pack(req, pfid, cfid, 0);
+ ptlrpc_request_set_replen(req);
- ptlrpc_req_set_repsize(req, 2, size);
rc = ptlrpc_queue_wait(req);
- if (rc != 0 && rc != -EREMOTE)
- GOTO(out, rc);
-
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_mdt_body);
- if (body == NULL) {
- CERROR ("Can't unpack mdt_body\n");
- GOTO(out, rc = -EPROTO);
- }
- EXIT;
- out:
- *request = req;
- return rc;
+ if (rc && rc != -EREMOTE)
+ ptlrpc_req_finished(req);
+ else
+ *request = req;
+ RETURN(rc);
}
-static
-int mdc_xattr_common(struct obd_export *exp, const struct lu_fid *fid,
- struct obd_capa *oc,
- int opcode, obd_valid valid, const char *xattr_name,
- const char *input, int input_size, int output_size,
- int flags, __u32 suppgid, struct ptlrpc_request **request)
+static int mdc_xattr_common(struct obd_export *exp,const struct req_format *fmt,
+ const struct lu_fid *fid,
+ struct obd_capa *oc, int opcode, obd_valid valid,
+ const char *xattr_name, const char *input,
+ int input_size, int output_size, int flags,
+ __u32 suppgid, struct ptlrpc_request **request)
{
struct ptlrpc_request *req;
- int size[5] = { sizeof(struct ptlrpc_body), sizeof(struct mdt_body) };
- int bufcnt = 3, offset = REQ_REC_OFF + 2;
- int rc, xattr_namelen = 0;
- void *tmp;
+ int xattr_namelen = 0;
+ char *tmp;
+ int rc;
ENTRY;
- size[REQ_REC_OFF + 1] = oc ? sizeof(struct lustre_capa) : 0;
+ *request = NULL;
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), fmt);
+ if (req == NULL)
+ RETURN(-ENOMEM);
+
+ mdc_set_capa_size(req, &RMF_CAPA1, oc);
if (xattr_name) {
xattr_namelen = strlen(xattr_name) + 1;
- size[bufcnt++] = xattr_namelen;
+ req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT,
+ xattr_namelen);
}
if (input_size) {
LASSERT(input);
- size[bufcnt++] = input_size;
+ req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_CLIENT,
+ input_size);
}
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
- opcode, bufcnt, size, NULL);
- if (!req)
- GOTO(out, rc = -ENOMEM);
+ rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, opcode);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
- /* request data */
- mdc_pack_req_body(req, REQ_REC_OFF, valid, fid, oc, output_size,
- suppgid, flags);
+ if (opcode == MDS_REINT) {
+ struct mdt_rec_setxattr *rec;
+ CLASSERT(sizeof(struct mdt_rec_setxattr) ==
+ sizeof(struct mdt_rec_reint));
+ rec = req_capsule_client_get(&req->rq_pill, &RMF_REC_REINT);
+ rec->sx_opcode = REINT_SETXATTR;
+ /* TODO:
+ * cfs_curproc_fs{u,g}id() should replace
+ * current->fs{u,g}id for portability.
+ */
+ rec->sx_fsuid = current->fsuid;
+ rec->sx_fsgid = current->fsgid;
+ rec->sx_cap = current->cap_effective;
+ rec->sx_suppgid1 = suppgid;
+ rec->sx_suppgid1 = -1;
+ rec->sx_fid = *fid;
+ rec->sx_valid = valid;
+ rec->sx_size = output_size;
+ rec->sx_flags = flags;
+
+ mdc_pack_capa(req, &RMF_CAPA1, oc);
+ } else {
+ mdc_pack_body(req, fid, oc, valid, output_size, suppgid, flags);
+ }
if (xattr_name) {
- tmp = lustre_msg_buf(req->rq_reqmsg, offset++, xattr_namelen);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
memcpy(tmp, xattr_name, xattr_namelen);
}
if (input_size) {
- tmp = lustre_msg_buf(req->rq_reqmsg, offset++, input_size);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_EADATA);
memcpy(tmp, input, input_size);
}
- /* reply buffers */
- if (opcode == MDS_GETXATTR) {
- size[REPLY_REC_OFF] = sizeof(struct mdt_body);
- bufcnt = 2;
- } else {
- bufcnt = 1;
- }
-
- /* we do this even output_size is 0, because server is doing that */
- size[bufcnt++] = output_size;
- ptlrpc_req_set_repsize(req, bufcnt, size);
+ if (req_capsule_has_field(&req->rq_pill, &RMF_EADATA, RCL_SERVER))
+ req_capsule_set_size(&req->rq_pill, &RMF_EADATA,
+ RCL_SERVER, output_size);
+ ptlrpc_request_set_replen(req);
/* make rpc */
- if (opcode == MDS_SETXATTR)
+ if (opcode == MDS_REINT)
mdc_get_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL);
rc = ptlrpc_queue_wait(req);
- if (opcode == MDS_SETXATTR)
+ if (opcode == MDS_REINT)
mdc_put_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL);
- if (rc != 0)
- GOTO(err_out, rc);
-
- if (opcode == MDS_GETXATTR) {
- struct mdt_body * body = lustre_swab_repbuf(req, REPLY_REC_OFF,
- sizeof(*body), lustre_swab_mdt_body);
- if (body == NULL) {
- CERROR ("Can't unpack mdt_body\n");
- GOTO(err_out, rc = -EPROTO);
- }
- }
-out:
- *request = req;
- RETURN (rc);
-err_out:
- ptlrpc_req_finished(req);
- req = NULL;
- goto out;
+ if (rc)
+ ptlrpc_req_finished(req);
+ else
+ *request = req;
+ RETURN(rc);
}
int mdc_setxattr(struct obd_export *exp, const struct lu_fid *fid,
struct obd_capa *oc, obd_valid valid, const char *xattr_name,
- const char *input, int input_size, int output_size, int flags,
- __u32 suppgid, struct ptlrpc_request **request)
+ const char *input, int input_size, int output_size,
+ int flags, __u32 suppgid, struct ptlrpc_request **request)
{
- return mdc_xattr_common(exp, fid, oc, MDS_SETXATTR, valid, xattr_name,
- input, input_size, output_size, flags, suppgid,
- request);
+ return mdc_xattr_common(exp, &RQF_MDS_REINT_SETXATTR,
+ fid, oc, MDS_REINT, valid, xattr_name,
+ input, input_size, output_size, flags,
+ suppgid, request);
}
int mdc_getxattr(struct obd_export *exp, const struct lu_fid *fid,
struct obd_capa *oc, obd_valid valid, const char *xattr_name,
- const char *input, int input_size, int output_size, int flags,
- struct ptlrpc_request **request)
+ const char *input, int input_size, int output_size,
+ int flags, struct ptlrpc_request **request)
{
- return mdc_xattr_common(exp, fid, oc, MDS_GETXATTR, valid, xattr_name,
- input, input_size, output_size, flags, -1,
- request);
+ return mdc_xattr_common(exp, &RQF_MDS_GETXATTR,
+ fid, oc, MDS_GETXATTR, valid, xattr_name,
+ input, input_size, output_size, flags,
+ -1, request);
}
#ifdef CONFIG_FS_POSIX_ACL
-static
-int mdc_unpack_acl(struct obd_export *exp, struct ptlrpc_request *req,
- struct lustre_md *md, unsigned int offset)
+static int mdc_unpack_acl(struct ptlrpc_request *req, struct lustre_md *md)
{
- struct mdt_body *body = md->body;
- struct posix_acl *acl;
- void *buf;
- int rc;
+ struct req_capsule *pill = &req->rq_pill;
+ struct mdt_body *body = md->body;
+ struct posix_acl *acl;
+ void *buf;
+ int rc;
+ ENTRY;
if (!body->aclsize)
- return 0;
+ RETURN(0);
- buf = lustre_msg_buf(req->rq_repmsg, offset, body->aclsize);
- if (!buf) {
- CERROR("aclsize %u, bufcount %u, bufsize %u\n",
- body->aclsize, lustre_msg_bufcount(req->rq_repmsg),
- (lustre_msg_bufcount(req->rq_repmsg) <= offset) ?
- -1 : lustre_msg_buflen(req->rq_repmsg, offset));
- return -EPROTO;
- }
+ buf = req_capsule_server_sized_get(pill, &RMF_ACL, body->aclsize);
+
+ if (!buf)
+ RETURN(-EPROTO);
acl = posix_acl_from_xattr(buf, body->aclsize);
if (IS_ERR(acl)) {
rc = PTR_ERR(acl);
CERROR("convert xattr to acl: %d\n", rc);
- return rc;
+ RETURN(rc);
}
rc = posix_acl_valid(acl);
if (rc) {
CERROR("validate acl: %d\n", rc);
posix_acl_release(acl);
- return rc;
+ RETURN(rc);
}
md->posix_acl = acl;
- return 0;
+ RETURN(0);
}
#else
-#define mdc_unpack_acl(exp, req, md, offset) 0
+#define mdc_unpack_acl(req, md) 0
#endif
int mdc_get_lustre_md(struct obd_export *exp, struct ptlrpc_request *req,
- int offset, struct obd_export *dt_exp,
- struct obd_export *md_exp,
+ struct obd_export *dt_exp, struct obd_export *md_exp,
struct lustre_md *md)
{
+ struct req_capsule *pill = &req->rq_pill;
int rc;
ENTRY;
LASSERT(md);
memset(md, 0, sizeof(*md));
- md->body = lustre_msg_buf(req->rq_repmsg, offset, sizeof (*md->body));
- LASSERT (md->body != NULL);
- LASSERT(lustre_rep_swabbed(req, offset));
- offset++;
+ md->body = req_capsule_server_get(pill, &RMF_MDT_BODY);
+ LASSERT(md->body != NULL);
if (md->body->valid & OBD_MD_FLEASIZE) {
int lmmsize;
struct lov_mds_md *lmm;
if (!S_ISREG(md->body->mode)) {
- CERROR("OBD_MD_FLEASIZE set, should be a regular file, "
- "but is not\n");
+ CDEBUG(D_INFO, "OBD_MD_FLEASIZE set, should be a "
+ "regular file, but is not\n");
GOTO(out, rc = -EPROTO);
}
if (md->body->eadatasize == 0) {
- CERROR("OBD_MD_FLEASIZE set, but eadatasize 0\n");
+ CDEBUG(D_INFO, "OBD_MD_FLEASIZE set, "
+ "but eadatasize 0\n");
GOTO(out, rc = -EPROTO);
}
lmmsize = md->body->eadatasize;
- lmm = lustre_msg_buf(req->rq_repmsg, offset, lmmsize);
- if (!lmm) {
- CERROR ("incorrect message: lmm == 0\n");
+ lmm = req_capsule_server_sized_get(pill, &RMF_MDT_MD, lmmsize);
+ if (!lmm)
GOTO(out, rc = -EPROTO);
- }
- LASSERT(lustre_rep_swabbed(req, offset));
rc = obd_unpackmd(dt_exp, &md->lsm, lmm, lmmsize);
if (rc < 0)
GOTO(out, rc);
if (rc < sizeof(*md->lsm)) {
- CERROR ("lsm size too small: rc < sizeof (*md->lsm) "
- "(%d < "LPSZ")\n", rc, sizeof(*md->lsm));
+ CDEBUG(D_INFO, "lsm size too small: "
+ "rc < sizeof (*md->lsm) (%d < "LPSZ")\n",
+ rc, sizeof(*md->lsm));
GOTO(out, rc = -EPROTO);
}
- offset++;
} else if (md->body->valid & OBD_MD_FLDIREA) {
int lmvsize;
struct lov_mds_md *lmv;
if(!S_ISDIR(md->body->mode)) {
- CERROR("OBD_MD_FLDIREA set, should be a directory, but "
- "is not\n");
+ CDEBUG(D_INFO, "OBD_MD_FLDIREA set, should be a "
+ "directory, but is not\n");
GOTO(out, rc = -EPROTO);
}
if (md->body->eadatasize == 0) {
- CERROR("OBD_MD_FLDIREA is set, but eadatasize 0\n");
+ CDEBUG(D_INFO, "OBD_MD_FLDIREA is set, "
+ "but eadatasize 0\n");
RETURN(-EPROTO);
}
if (md->body->valid & OBD_MD_MEA) {
lmvsize = md->body->eadatasize;
- lmv = lustre_msg_buf(req->rq_repmsg, offset, lmvsize);
- if (!lmv) {
- CERROR ("incorrect message: lmv == 0\n");
+ lmv = req_capsule_server_sized_get(pill, &RMF_MDT_MD,
+ lmvsize);
+ if (!lmv)
GOTO(out, rc = -EPROTO);
- }
-
- LASSERT(lustre_rep_swabbed(req, offset));
rc = obd_unpackmd(md_exp, (void *)&md->mea, lmv,
lmvsize);
GOTO(out, rc);
if (rc < sizeof(*md->mea)) {
- CERROR ("size too small: rc < sizeof(*md->mea) "
- "(%d < %d)\n", rc, sizeof(*md->mea));
+ CDEBUG(D_INFO, "size too small: "
+ "rc < sizeof(*md->mea) (%d < %d)\n",
+ rc, sizeof(*md->mea));
GOTO(out, rc = -EPROTO);
}
}
- offset++;
}
rc = 0;
- /* remote permission */
if (md->body->valid & OBD_MD_FLRMTPERM) {
- md->remote_perm = lustre_msg_buf(req->rq_repmsg, offset++,
- sizeof(struct mdt_remote_perm));
- if (!md->remote_perm) {
- CERROR ("incorrect message: remote_perm == 0\n");
+ /* remote permission */
+ md->remote_perm = req_capsule_server_get(pill, &RMF_ACL);
+ if (!md->remote_perm)
GOTO(out, rc = -EPROTO);
- }
}
-
- /* 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. */
else if (md->body->valid & OBD_MD_FLACL) {
+ /* 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->aclsize) {
- rc = mdc_unpack_acl(dt_exp, req, md, offset++);
+ rc = mdc_unpack_acl(req, md);
if (rc)
GOTO(out, rc);
#ifdef CONFIG_FS_POSIX_ACL
#endif
}
}
-
if (md->body->valid & OBD_MD_FLMDSCAPA) {
- struct obd_capa *oc = mdc_unpack_capa(req, offset++);
+ struct obd_capa *oc = mdc_unpack_capa(req, &RMF_CAPA1);
if (IS_ERR(oc))
GOTO(out, rc = PTR_ERR(oc));
}
if (md->body->valid & OBD_MD_FLOSSCAPA) {
- struct obd_capa *oc = mdc_unpack_capa(req, offset++);
+ struct obd_capa *oc = mdc_unpack_capa(req, &RMF_CAPA2);
if (IS_ERR(oc))
GOTO(out, rc = PTR_ERR(oc));
return;
}
- body = lustre_swab_repbuf(req, DLM_REPLY_REC_OFF, sizeof(*body),
- lustre_swab_mdt_body);
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
LASSERT(body != NULL);
och = mod->mod_och;
old = *file_fh;
*file_fh = body->handle;
}
-
list_for_each_entry_safe(cur, tmp, &mod->mod_replay_list, rq_mod_list) {
int opc = lustre_msg_get_opc(cur->rq_reqmsg);
struct mdt_epoch *epoch = NULL;
if (opc == MDS_CLOSE || opc == MDS_DONE_WRITING) {
- epoch = lustre_msg_buf(cur->rq_reqmsg,
- REQ_REC_OFF, sizeof(*epoch));
+ epoch = req_capsule_client_get(&cur->rq_pill,
+ &RMF_MDT_EPOCH);
LASSERT(epoch);
DEBUG_REQ(D_HA, cur, "updating %s body with new fh",
opc == MDS_CLOSE ? "CLOSE" : "DONE_WRITING");
struct mdt_rec_setattr *rec;
/* Check this is REINT_SETATTR. */
- rec = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF,
- sizeof (*rec));
+ rec = req_capsule_client_get(&cur->rq_pill,
+ &RMF_REC_REINT);
LASSERT(rec && rec->sa_opcode == REINT_SETATTR);
- epoch = lustre_msg_buf(cur->rq_reqmsg,
- REQ_REC_OFF + 2, sizeof(*epoch));
+ epoch = req_capsule_client_get(&cur->rq_pill,
+ &RMF_MDT_EPOCH);
LASSERT(epoch);
DEBUG_REQ(D_HA, cur, "updating REINT_SETATTR body "
"with new fh");
struct obd_client_handle *och,
struct ptlrpc_request *open_req)
{
- struct md_open_data *mod;
- struct mdt_rec_create *rec = lustre_msg_buf(open_req->rq_reqmsg,
- DLM_INTENT_REC_OFF,
- sizeof(*rec));
- struct mdt_body *body = lustre_msg_buf(open_req->rq_repmsg,
- DLM_REPLY_REC_OFF,
- sizeof(*body));
- struct obd_import *imp = open_req->rq_import;
+ struct md_open_data *mod;
+ struct mdt_rec_create *rec;
+ struct mdt_body *body;
+ struct obd_import *imp = open_req->rq_import;
ENTRY;
+ rec = req_capsule_client_get(&open_req->rq_pill, &RMF_REC_REINT);
+ body = req_capsule_server_get(&open_req->rq_pill, &RMF_MDT_BODY);
LASSERT(rec != NULL);
-
/* Incoming message in my byte order (it's been swabbed). */
- LASSERT(lustre_rep_swabbed(open_req, DLM_REPLY_REC_OFF));
-
/* Outgoing messages always in my byte order. */
LASSERT(body != NULL);
/*Only the import is replayable, we set replay_open data */
if (och && imp->imp_replayable) {
- OBD_ALLOC(mod, sizeof(*mod));
+ OBD_ALLOC_PTR(mod);
if (mod == NULL) {
DEBUG_REQ(D_ERROR, open_req,
"Can't allocate md_open_data");
int mdc_close(struct obd_export *exp, struct md_op_data *op_data,
struct md_open_data *mod, struct ptlrpc_request **request)
{
- struct obd_device *obd = class_exp2obd(exp);
- int reqsize[4] = { sizeof(struct ptlrpc_body),
- sizeof(struct mdt_epoch),
- sizeof(struct mdt_rec_setattr)};
- int repsize[4] = { sizeof(struct ptlrpc_body),
- sizeof(struct mdt_body),
- obd->u.cli.cl_max_mds_easize,
- obd->u.cli.cl_max_mds_cookiesize };
+ struct obd_device *obd = class_exp2obd(exp);
struct ptlrpc_request *req;
- int rc;
+ int rc;
ENTRY;
- reqsize[REQ_REC_OFF + 2] = op_data->op_capa1 ?
- sizeof(struct lustre_capa) : 0;
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
- MDS_CLOSE, 4, reqsize, NULL);
+ *request = NULL;
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_CLOSE);
if (req == NULL)
- GOTO(out, rc = -ENOMEM);
+ RETURN(-ENOMEM);
+
+ mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1);
+
+ rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_CLOSE);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
/* To avoid a livelock (bug 7034), we need to send CLOSE RPCs to a
* portal whose threads are not taking any DLM locks and are therefore
else
CDEBUG(D_HA, "couldn't find open req; expecting close error\n");
- mdc_close_pack(req, REQ_REC_OFF, op_data);
- ptlrpc_req_set_repsize(req, 4, repsize);
+ mdc_close_pack(req, op_data);
+ ptlrpc_request_set_replen(req);
req->rq_commit_cb = mdc_commit_delayed;
req->rq_replay = 1;
LASSERT(req->rq_cb_data == NULL);
CDEBUG(D_RPCTRACE, "request failed to send: %p, %d\n", req,
req->rq_status);
if (rc == 0)
- rc = req->rq_status ? req->rq_status : -EIO;
+ rc = req->rq_status ?: -EIO;
} else if (rc == 0 || rc == -EAGAIN) {
+ struct mdt_body *body;
+
rc = lustre_msg_get_status(req->rq_repmsg);
if (lustre_msg_get_type(req->rq_repmsg) == PTL_RPC_MSG_ERR) {
DEBUG_REQ(D_ERROR, req, "type == PTL_RPC_MSG_ERR, err "
"but close succeeded with replayable imp"
"Please tell CFS.\n");
}
- if (!lustre_swab_repbuf(req, REPLY_REC_OFF,
- sizeof(struct mdt_body),
- lustre_swab_mdt_body)) {
- CERROR("Error unpacking mdt_body\n");
+
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
+ if (body == NULL)
rc = -EPROTO;
- }
}
EXIT;
- *request = req;
- out:
if (rc != 0 && rc != -EAGAIN && req && req->rq_commit_cb)
req->rq_commit_cb(req);
+ *request = req;
return rc;
}
int mdc_done_writing(struct obd_export *exp, struct md_op_data *op_data,
struct md_open_data *mod)
{
- struct obd_device *obd = class_exp2obd(exp);
+ struct obd_device *obd = class_exp2obd(exp);
struct ptlrpc_request *req;
- int size[4] = { sizeof(struct ptlrpc_body),
- sizeof(struct mdt_epoch),
- sizeof(struct mdt_rec_setattr)};
- int repsize[2] = { sizeof(struct ptlrpc_body),
- sizeof(struct mdt_body)};
- int rc;
+ int rc;
ENTRY;
- if (op_data->op_capa1)
- size[REQ_REC_OFF + 2] = sizeof(struct lustre_capa);
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
- MDS_DONE_WRITING, 4, size, NULL);
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp),
+ &RQF_MDS_DONE_WRITING);
if (req == NULL)
RETURN(-ENOMEM);
- mdc_close_pack(req, REQ_REC_OFF, op_data);
-
+ mdc_set_capa_size(req, &RMF_CAPA1, op_data->op_capa1);
+ rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_DONE_WRITING);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
+
+ /* XXX: add DONE_WRITING request to och -- when Size-on-MDS
+ * recovery will be ready. */
+ mdc_close_pack(req, op_data);
+ ptlrpc_request_set_replen(req);
req->rq_replay = 1;
req->rq_cb_data = mod;
req->rq_commit_cb = mdc_commit_delayed;
else
CDEBUG(D_HA, "couldn't find open req; expecting close error\n");
- ptlrpc_req_set_repsize(req, 2, repsize);
mdc_get_rpc_lock(obd->u.cli.cl_close_lock, NULL);
rc = ptlrpc_queue_wait(req);
mdc_put_rpc_lock(obd->u.cli.cl_close_lock, NULL);
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_bulk_desc *desc = NULL;
- struct ptlrpc_request *req = NULL;
+ struct ptlrpc_request *req;
+ struct ptlrpc_bulk_desc *desc;
+ int rc;
ENTRY;
- CDEBUG(D_INODE, "object: "DFID"\n", PFID(fid));
-
- req = ptlrpc_prep_req(imp, LUSTRE_MDS_VERSION, MDS_WRITEPAGE, 3,
- size, NULL);
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_WRITEPAGE);
if (req == NULL)
- GOTO(out, rc = -ENOMEM);
+ RETURN(-ENOMEM);
+
+ /* FIXME: capa doesn't support split yet */
+ mdc_set_capa_size(req, &RMF_CAPA1, NULL);
+
+ rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_WRITEPAGE);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
req->rq_request_portal = MDS_READPAGE_PORTAL;
/* 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);
+ mdc_readdir_pack(req, 0, offset, fid, NULL);
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
- EXIT;
+ GOTO(out, rc);
out:
- if (req != NULL)
- ptlrpc_req_finished(req);
+ ptlrpc_req_finished(req);
return rc;
}
EXPORT_SYMBOL(mdc_sendpage);
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_bulk_desc *desc = NULL;
- struct ptlrpc_request *req = NULL;
- struct mdt_body *body;
+ struct ptlrpc_request *req;
+ struct ptlrpc_bulk_desc *desc;
+ int rc;
ENTRY;
- CDEBUG(D_INODE, "object: "DFID"\n", PFID(fid));
-
- size[REQ_REC_OFF + 1] = oc ? sizeof(struct lustre_capa) : 0;
- req = ptlrpc_prep_req(imp, LUSTRE_MDS_VERSION, MDS_READPAGE, 3, size,
- NULL);
+ *request = NULL;
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_READPAGE);
if (req == NULL)
- GOTO(out, rc = -ENOMEM);
+ RETURN(-ENOMEM);
+
+ mdc_set_capa_size(req, &RMF_CAPA1, oc);
+
+ rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_READPAGE);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
/* XXX FIXME bug 249 */
req->rq_request_portal = MDS_READPAGE_PORTAL;
-
desc = ptlrpc_prep_bulk_imp(req, 1, BULK_PUT_SINK, MDS_BULK_PORTAL);
- if (desc == NULL)
- GOTO(out, rc = -ENOMEM);
+ if (desc == NULL) {
+ ptlrpc_request_free(req);
+ RETURN(-ENOMEM);
+ }
/* NB req now owns desc and will free it when it gets freed */
ptlrpc_prep_bulk_page(desc, page, 0, CFS_PAGE_SIZE);
- mdc_readdir_pack(req, REQ_REC_OFF, offset, CFS_PAGE_SIZE, fid, oc);
+ mdc_readdir_pack(req, offset, CFS_PAGE_SIZE, fid, oc);
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
+ if (rc) {
+ ptlrpc_req_finished(req);
+ RETURN(rc);
+ }
- if (rc == 0) {
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_mdt_body);
- if (body == NULL) {
- CERROR("Can't unpack mdt_body\n");
- GOTO(out, rc = -EPROTO);
- }
-
- if (req->rq_bulk->bd_nob_transferred != CFS_PAGE_SIZE) {
- CERROR ("Unexpected # bytes transferred: %d"
- " (%ld expected)\n",
- req->rq_bulk->bd_nob_transferred,
- CFS_PAGE_SIZE);
- GOTO(out, rc = -EPROTO);
- }
+ if (req->rq_bulk->bd_nob_transferred != CFS_PAGE_SIZE) {
+ CERROR("Unexpected # bytes transferred: %d (%ld expected)\n",
+ req->rq_bulk->bd_nob_transferred, CFS_PAGE_SIZE);
+ ptlrpc_req_finished(req);
+ RETURN(-EPROTO);
}
- EXIT;
- out:
*request = req;
- return rc;
+ RETURN(0);
}
static int mdc_iocontrol(unsigned int cmd, struct obd_export *exp, int len,
return rc;
}
-int mdc_set_info_async(struct obd_export *exp, obd_count keylen,
- void *key, obd_count vallen, void *val,
+static int do_set_info_async(struct obd_export *exp,
+ obd_count keylen, void *key,
+ obd_count vallen, void *val,
+ struct ptlrpc_request_set *set)
+{
+ struct obd_import *imp = class_exp2cliimp(exp);
+ struct ptlrpc_request *req;
+ char *tmp;
+ int rc;
+ ENTRY;
+
+ if (vallen != sizeof(int))
+ RETURN(-EINVAL);
+
+ spin_lock(&imp->imp_lock);
+ if (*((int *)val)) {
+ imp->imp_connect_flags_orig |= OBD_CONNECT_RDONLY;
+ imp->imp_connect_data.ocd_connect_flags |= OBD_CONNECT_RDONLY;
+ } else {
+ imp->imp_connect_flags_orig &= ~OBD_CONNECT_RDONLY;
+ imp->imp_connect_data.ocd_connect_flags &= ~OBD_CONNECT_RDONLY;
+ }
+ spin_unlock(&imp->imp_lock);
+
+ req = ptlrpc_request_alloc(imp, &RQF_MDS_SET_INFO);
+ if (req == NULL)
+ RETURN(-ENOMEM);
+
+ req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY,
+ RCL_CLIENT, keylen);
+ req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_VAL,
+ RCL_CLIENT, vallen);
+ rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_SET_INFO);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
+
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY);
+ memcpy(tmp, key, keylen);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_VAL);
+ memcpy(tmp, val, vallen);
+
+ ptlrpc_request_set_replen(req);
+
+ if (set) {
+ ptlrpc_set_add_req(set, req);
+ ptlrpc_check_set(set);
+ } else {
+ rc = ptlrpc_queue_wait(req);
+ ptlrpc_req_finished(req);
+ }
+
+ RETURN(rc);
+}
+
+int mdc_set_info_async(struct obd_export *exp,
+ obd_count keylen, void *key,
+ obd_count vallen, void *val,
struct ptlrpc_request_set *set)
{
struct obd_import *imp = class_exp2cliimp(exp);
- int rc = -EINVAL;
+ int rc = -EINVAL;
+ ENTRY;
if (KEY_IS(KEY_INIT_RECOV)) {
if (vallen != sizeof(int))
RETURN(0);
}
if (KEY_IS(KEY_READ_ONLY)) {
- struct ptlrpc_request *req;
- int size[3] = { sizeof(struct ptlrpc_body), keylen, vallen };
- char *bufs[3] = { NULL, key, val };
-
- if (vallen != sizeof(int))
- RETURN(-EINVAL);
-
- spin_lock(&imp->imp_lock);
- if (*((int *)val)) {
- imp->imp_connect_flags_orig |= OBD_CONNECT_RDONLY;
- imp->imp_connect_data.ocd_connect_flags |=
- OBD_CONNECT_RDONLY;
- } else {
- imp->imp_connect_flags_orig &= ~OBD_CONNECT_RDONLY;
- imp->imp_connect_data.ocd_connect_flags &=
- ~OBD_CONNECT_RDONLY;
- }
- spin_unlock(&imp->imp_lock);
-
- req = ptlrpc_prep_req(imp, LUSTRE_MDS_VERSION, MDS_SET_INFO,
- 3, size, bufs);
- if (req == NULL)
- RETURN(-ENOMEM);
-
- ptlrpc_req_set_repsize(req, 1, NULL);
- if (set) {
- rc = 0;
- ptlrpc_set_add_req(set, req);
- ptlrpc_check_set(set);
- } else {
- rc = ptlrpc_queue_wait(req);
- ptlrpc_req_finished(req);
- }
-
+ rc = do_set_info_async(exp, keylen, key, vallen, val, set);
RETURN(rc);
}
if (KEY_IS(KEY_FLUSH_CTX)) {
__u64 max_age)
{
struct ptlrpc_request *req;
- struct obd_statfs *msfs;
- int rc, size[2] = { sizeof(struct ptlrpc_body), sizeof(*msfs) };
+ struct obd_statfs *msfs;
+ int rc;
ENTRY;
- /* We could possibly pass max_age in the request (as an absolute
- * timestamp or a "seconds.usec ago") so the target can avoid doing
- * extra calls into the filesystem if that isn't necessary (e.g.
- * during mount that would help a bit). Having relative timestamps
- * is not so great if request processing is slow, while absolute
- * timestamps are not ideal because they need time synchronization. */
- req = ptlrpc_prep_req(obd->u.cli.cl_import, LUSTRE_MDS_VERSION,
- MDS_STATFS, 1, NULL, NULL);
- if (!req)
+ req = ptlrpc_request_alloc_pack(obd->u.cli.cl_import, &RQF_MDS_STATFS,
+ LUSTRE_MDS_VERSION, MDS_STATFS);
+ if (req == NULL)
RETURN(-ENOMEM);
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
-
if (rc) {
/* check connection error first */
if (obd->u.cli.cl_import->imp_connect_error)
rc = obd->u.cli.cl_import->imp_connect_error;
-
GOTO(out, rc);
}
- msfs = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*msfs),
- lustre_swab_obd_statfs);
- if (msfs == NULL) {
- CERROR("Can't unpack obd_statfs\n");
+ msfs = req_capsule_server_get(&req->rq_pill, &RMF_OBD_STATFS);
+ if (msfs == NULL)
GOTO(out, rc = -EPROTO);
- }
- memcpy(osfs, msfs, sizeof(*msfs));
+ *osfs = *msfs;
EXIT;
out:
ptlrpc_req_finished(req);
-
return rc;
}
static int mdc_pin(struct obd_export *exp, const struct lu_fid *fid,
- struct obd_capa *oc,
- struct obd_client_handle *handle, int flag)
+ struct obd_capa *oc, struct obd_client_handle *handle,
+ int flags)
{
struct ptlrpc_request *req;
- struct mdt_body *body;
- int rc, size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) };
+ struct mdt_body *body;
+ int rc;
ENTRY;
- size[REQ_REC_OFF + 1] = oc ? sizeof(struct lustre_capa) : 0;
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
- MDS_PIN, 3, size, NULL);
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_PIN);
if (req == NULL)
RETURN(-ENOMEM);
- body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof (*body));
- body->fid1 = *fid;
- body->flags = flag;
- mdc_pack_capa(req, REQ_REC_OFF + 1, oc);
+ mdc_set_capa_size(req, &RMF_CAPA1, oc);
+
+ rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_PIN);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
- ptlrpc_req_set_repsize(req, 2, size);
+ mdc_pack_body(req, fid, oc, 0, 0, -1, flags);
+
+ ptlrpc_request_set_replen(req);
mdc_get_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL);
rc = ptlrpc_queue_wait(req);
mdc_put_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL);
if (rc) {
- CERROR("pin failed: %d\n", rc);
- ptlrpc_req_finished(req);
- RETURN(rc);
+ CERROR("Pin failed: %d\n", rc);
+ GOTO(err_out, rc);
}
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_mdt_body);
- if (body == NULL) {
- ptlrpc_req_finished(req);
- RETURN(rc);
- }
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
+ if (body == NULL)
+ GOTO(err_out, rc = -EPROTO);
- memcpy(&handle->och_fh, &body->handle, sizeof(body->handle));
+ handle->och_fh = body->handle;
handle->och_magic = OBD_CLIENT_HANDLE_MAGIC;
- OBD_ALLOC(handle->och_mod, sizeof(*handle->och_mod));
+ OBD_ALLOC_PTR(handle->och_mod);
if (handle->och_mod == NULL) {
- DEBUG_REQ(D_ERROR, req, "can't allocate md_open_data");
- RETURN(-ENOMEM);
+ DEBUG_REQ(D_ERROR, req, "can't allocate mdc_open_data");
+ GOTO(err_out, rc = -ENOMEM);
}
-
/* will be dropped by unpin */
CFS_INIT_LIST_HEAD(&handle->och_mod->mod_replay_list);
list_add_tail(&req->rq_mod_list, &handle->och_mod->mod_replay_list);
+ RETURN(0);
+
+err_out:
+ ptlrpc_req_finished(req);
RETURN(rc);
}
-static int mdc_unpin(struct obd_export *exp,
- struct obd_client_handle *handle, int flag)
+static int mdc_unpin(struct obd_export *exp, struct obd_client_handle *handle,
+ int flag)
{
struct ptlrpc_request *req;
- struct mdt_body *body;
- int rc, size[2] = { sizeof(struct ptlrpc_body), sizeof(*body) };
+ struct mdt_body *body;
+ int rc;
ENTRY;
- if (handle->och_magic != OBD_CLIENT_HANDLE_MAGIC)
- RETURN(0);
-
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
- MDS_CLOSE, 2, size, NULL);
+ req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), &RQF_MDS_UNPIN,
+ LUSTRE_MDS_VERSION, MDS_UNPIN);
if (req == NULL)
RETURN(-ENOMEM);
- body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body));
- memcpy(&body->handle, &handle->och_fh, sizeof(body->handle));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_MDT_BODY);
+ body->handle = handle->och_fh;
body->flags = flag;
- ptlrpc_req_set_repsize(req, 1, NULL);
+ ptlrpc_request_set_replen(req);
+
mdc_get_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL);
rc = ptlrpc_queue_wait(req);
mdc_put_rpc_lock(exp->exp_obd->u.cli.cl_rpc_lock, NULL);
if (rc != 0)
- CERROR("unpin failed: %d\n", rc);
+ CERROR("Unpin failed: %d\n", rc);
ptlrpc_req_finished(req);
struct obd_capa *oc, struct ptlrpc_request **request)
{
struct ptlrpc_request *req;
- int size[3] = { sizeof(struct ptlrpc_body), sizeof(struct mdt_body) };
- int rc;
+ int rc;
ENTRY;
- size[REQ_REC_OFF + 1] = oc ? sizeof(struct lustre_capa) : 0;
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
- MDS_SYNC, 3, size, NULL);
- if (!req)
- RETURN(rc = -ENOMEM);
+ *request = NULL;
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_SYNC);
+ if (req == NULL)
+ RETURN(-ENOMEM);
+
+ mdc_set_capa_size(req, &RMF_CAPA1, oc);
+
+ rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_SYNC);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
- mdc_pack_req_body(req, REQ_REC_OFF, 0, fid, oc, 0, -1, 0);
+ mdc_pack_body(req, fid, oc, 0, 0, -1, 0);
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
- if (rc || request == NULL)
+ if (rc)
ptlrpc_req_finished(req);
else
*request = req;
-
RETURN(rc);
}
static int mdc_llog_init(struct obd_device *obd, struct obd_llogs *llogs,
- struct obd_device *tgt,
- int count, struct llog_catid *logid,
- struct obd_uuid *uuid)
+ struct obd_device *tgt, int count,
+ struct llog_catid *logid, struct obd_uuid *uuid)
{
struct llog_ctxt *ctxt;
int rc;
return(rc);
}
+
/* get remote permission for current user on fid */
int mdc_get_remote_perm(struct obd_export *exp, const struct lu_fid *fid,
struct obd_capa *oc, __u32 suppgid,
struct ptlrpc_request **request)
{
- struct ptlrpc_request *req;
- struct mdt_body *body;
- struct mdt_remote_perm *perm;
- int size[5] = { sizeof(struct ptlrpc_body), sizeof(*body) };
- int rc;
+ struct ptlrpc_request *req;
+ int rc;
ENTRY;
- size[REQ_REC_OFF + 1] = oc ? sizeof(struct lustre_capa) : 0;
-
*request = NULL;
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
- MDS_GETATTR, 3, size, NULL);
- if (!req)
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_MDS_GETATTR);
+ if (req == NULL)
RETURN(-ENOMEM);
- mdc_pack_req_body(req, REQ_REC_OFF, OBD_MD_FLRMTPERM, fid, oc, 0,
- suppgid, 0);
+ mdc_set_capa_size(req, &RMF_CAPA1, oc);
- size[REPLY_REC_OFF + 1] = sizeof(*perm);
- ptlrpc_req_set_repsize(req, 5, size);
- rc = ptlrpc_queue_wait(req);
+ rc = ptlrpc_request_pack(req, LUSTRE_MDS_VERSION, MDS_GETATTR);
if (rc) {
- ptlrpc_req_finished(req);
+ ptlrpc_request_free(req);
RETURN(rc);
}
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_mdt_body);
- LASSERT(body);
- LASSERT(body->valid & OBD_MD_FLRMTPERM);
+ mdc_pack_body(req, fid, oc, OBD_MD_FLRMTPERM, 0, suppgid, 0);
- perm = lustre_swab_repbuf(req, REPLY_REC_OFF + 1, sizeof(*perm),
- lustre_swab_mdt_remote_perm);
- LASSERT(perm);
+ ptlrpc_request_set_replen(req);
- *request = req;
- RETURN(0);
+ rc = ptlrpc_queue_wait(req);
+ if (rc)
+ ptlrpc_req_finished(req);
+ else
+ *request = req;
+ RETURN(rc);
}
static int mdc_interpret_renew_capa(struct ptlrpc_request *req, void *unused,
if (status)
GOTO(out, capa = ERR_PTR(status));
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_mdt_body);
+ body = req_capsule_server_get(&req->rq_pill, &RMF_MDT_BODY);
if (body == NULL)
GOTO(out, capa = ERR_PTR(-EFAULT));
if ((body->valid & OBD_MD_FLOSSCAPA) == 0)
GOTO(out, capa = ERR_PTR(-ENOENT));
- capa = lustre_unpack_capa(req->rq_repmsg, REPLY_REC_OFF + 1);
+ capa = req_capsule_server_get(&req->rq_pill, &RMF_CAPA2);
if (!capa)
GOTO(out, capa = ERR_PTR(-EFAULT));
EXIT;
renew_capa_cb_t cb)
{
struct ptlrpc_request *req;
- int size[5] = { sizeof(struct ptlrpc_body),
- sizeof(struct mdt_body),
- sizeof(struct lustre_capa) };
ENTRY;
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MDS_VERSION,
- MDS_GETATTR, 3, size, NULL);
- if (!req)
+ req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), &RQF_MDS_GETATTR,
+ LUSTRE_MDS_VERSION, MDS_GETATTR);
+ if (req == NULL)
RETURN(-ENOMEM);
- mdc_pack_req_body(req, REQ_REC_OFF, OBD_MD_FLOSSCAPA,
- &oc->c_capa.lc_fid, oc, 0, -1, 0);
+ /* NB, OBD_MD_FLOSSCAPA is set here, but it doesn't necessarily mean the
+ * capa to renew is oss capa.
+ */
+ mdc_pack_body(req, &oc->c_capa.lc_fid, oc, OBD_MD_FLOSSCAPA, 0, -1, 0);
+ ptlrpc_request_set_replen(req);
- ptlrpc_req_set_repsize(req, 5, size);
req->rq_async_args.pointer_arg[0] = oc;
req->rq_async_args.pointer_arg[1] = cb;
req->rq_interpret_reply = mdc_interpret_renew_capa;
ptlrpcd_add_req(req);
-
RETURN(0);
}
static int mdc_connect(const struct lu_env *env,
struct lustre_handle *dlm_handle,
struct obd_device *obd, struct obd_uuid *cluuid,
- struct obd_connect_data *data) {
+ struct obd_connect_data *data)
+{
struct obd_import *imp = obd->u.cli.cl_import;
/* mds-mds import features */
*/
iops = &next->do_index_ops->dio_it;
it = iops->init(env, next, 0, mdd_object_capa(env, obj));
- if (it == NULL)
- return -ENOMEM;
+ if (IS_ERR(it))
+ return PTR_ERR(it);
rc = iops->load(env, it, rdpg->rp_hash);
OBD_ALLOC(data, sizeof(*data));
if (data == NULL)
RETURN(-ENOMEM);
- data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_INDEX |
+ data->ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_INDEX |
OBD_CONNECT_REQPORTAL | OBD_CONNECT_QUOTA64 |
- OBD_CONNECT_OSS_CAPA;
+ OBD_CONNECT_OSS_CAPA | OBD_CONNECT_FID;
#ifdef HAVE_LRU_RESIZE_SUPPORT
data->ocd_connect_flags |= OBD_CONNECT_LRU_RESIZE;
#endif
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_GETSTATUS_PACK))
RETURN(err_serious(-ENOMEM));
- repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
rc = next->md_ops->mdo_root_get(info->mti_env, next, &repbody->fid1);
if (rc != 0)
RETURN(rc);
if (IS_ERR(root))
RETURN(PTR_ERR(root));
- capa = req_capsule_server_get(&info->mti_pill, &RMF_CAPA1);
+ capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA1);
LASSERT(capa);
capa->lc_opc = CAPA_OPC_MDS_DEFAULT;
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_STATFS_PACK)) {
rc = err_serious(-ENOMEM);
} else {
- osfs = req_capsule_server_get(&info->mti_pill,&RMF_OBD_STATFS);
+ osfs = req_capsule_server_get(info->mti_pill, &RMF_OBD_STATFS);
rc = next->md_ops->mdo_statfs(info->mti_env, next,
&info->mti_u.ksfs);
statfs_pack(osfs, &info->mti_u.ksfs);
struct mdt_body *b;
struct lu_attr *attr = &info->mti_attr.ma_attr;
- b = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ b = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
/* Check if Size-on-MDS is enabled. */
if ((mdt_conn_flags(info) & OBD_CONNECT_SOM) &&
if (fid) {
b->fid1 = *fid;
b->valid |= OBD_MD_FLID;
- CDEBUG(D_INODE, ""DFID": nlink=%d, mode=%o, size="LPU64"\n",
+
+ /* FIXME: these should be fixed when new igif ready.*/
+ b->ino = fid_oid(fid); /* 1.6 compatibility */
+ b->generation = fid_ver(fid); /* 1.6 compatibility */
+ b->valid |= OBD_MD_FLGENER; /* 1.6 compatibility */
+
+ CDEBUG(D_INODE, DFID": nlink=%d, mode=%o, size="LPU64"\n",
PFID(fid), b->nlink, b->mode, b->size);
}
struct mdt_export_data *med = &req->rq_export->exp_mdt_data;
struct md_attr *ma = &info->mti_attr;
struct lu_attr *la = &ma->ma_attr;
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
const struct lu_env *env = info->mti_env;
struct mdt_body *repbody;
struct lu_buf *buffer = &info->mti_buf;
info->mti_mdt->mdt_opts.mo_mds_capa) {
struct lustre_capa *capa;
- capa = req_capsule_server_get(&info->mti_pill, &RMF_CAPA1);
+ capa = req_capsule_server_get(pill, &RMF_CAPA1);
LASSERT(capa);
capa->lc_opc = CAPA_OPC_MDS_DEFAULT;
rc = mo_capa_get(env, next, capa, 0);
if (!obj || !mdt->mdt_opts.mo_mds_capa)
RETURN(0);
- body = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ body = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(body != NULL);
- c = req_capsule_client_get(&info->mti_pill, &RMF_CAPA1);
+ c = req_capsule_client_get(info->mti_pill, &RMF_CAPA1);
LASSERT(c);
- capa = req_capsule_server_get(&info->mti_pill, &RMF_CAPA1);
+ capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA2);
LASSERT(capa);
*capa = *c;
rc = mo_capa_get(info->mti_env, mdt_object_child(obj), capa, 1);
if (rc == 0)
body->valid |= OBD_MD_FLOSSCAPA;
-
RETURN(rc);
}
static int mdt_getattr(struct mdt_thread_info *info)
{
struct mdt_object *obj = info->mti_object;
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
struct mdt_body *reqbody;
struct mdt_body *repbody;
mode_t mode;
LASSERT(reqbody);
if (reqbody->valid & OBD_MD_FLOSSCAPA) {
- rc = req_capsule_pack(pill);
+ rc = req_capsule_server_pack(pill);
if (unlikely(rc))
- rc = err_serious(rc);
- else {
- rc = mdt_renew_capa(info);
- mdt_shrink_reply(info);
- }
- GOTO(out, rc);
+ RETURN(err_serious(rc));
+ rc = mdt_renew_capa(info);
+ GOTO(out_shrink, rc);
}
LASSERT(obj != NULL);
req_capsule_set_size(pill, &RMF_MDT_MD, RCL_SERVER, md_size);
- rc = req_capsule_pack(pill);
+ rc = req_capsule_server_pack(pill);
if (unlikely(rc != 0))
- GOTO(out, rc = err_serious(rc));
+ RETURN(err_serious(rc));
repbody = req_capsule_server_get(pill, &RMF_MDT_BODY);
LASSERT(repbody != NULL);
EXIT;
out_shrink:
mdt_shrink_reply(info);
-out:
return rc;
}
static int mdt_is_subdir(struct mdt_thread_info *info)
{
struct mdt_object *o = info->mti_object;
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
const struct mdt_body *body = info->mti_body;
struct mdt_body *repbody;
int rc;
} else
mdt_set_disposition(info, ldlm_rep, DISP_LOOKUP_POS);
- repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
#endif
if (rc == 0) {
- repbody = req_capsule_server_get(&info->mti_pill,
- &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
repbody->fid1 = *child_fid;
repbody->valid = OBD_MD_FLID;
}
lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT));
LASSERT(parent != NULL);
- name = req_capsule_client_get(&info->mti_pill, &RMF_NAME);
+ name = req_capsule_client_get(info->mti_pill, &RMF_NAME);
if (name == NULL)
RETURN(err_serious(-EFAULT));
- namelen = req_capsule_get_size(&info->mti_pill, &RMF_NAME,
+ namelen = req_capsule_get_size(info->mti_pill, &RMF_NAME,
RCL_CLIENT) - 1;
LASSERT(namelen >= 0);
* otherwise do not allow empty name, that is the name must contain
* at least one character and the terminating '\0'*/
if (namelen == 0) {
- reqbody =req_capsule_client_get(&info->mti_pill, &RMF_MDT_BODY);
+ reqbody =req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(fid_is_sane(&reqbody->fid2));
name = NULL;
if (unlikely(rc != 0))
mdt_object_unlock(info, child, lhc, 1);
}
- GOTO(out, rc);
+ RETURN(rc);
}
/* step 1: lock parent */
* Pack Size-on-MDS inode attributes to the body if
* update lock is given.
*/
- repbody = req_capsule_server_get(&info->mti_pill,
+ repbody = req_capsule_server_get(info->mti_pill,
&RMF_MDT_BODY);
ma = &info->mti_attr.ma_attr;
if (lock->l_policy_data.l_inodebits.bits &
mdt_object_put(info->mti_env, child);
out_parent:
mdt_object_unlock(info, parent, lhp, 1);
-out:
return rc;
}
int rc;
ENTRY;
- reqbody = req_capsule_client_get(&info->mti_pill, &RMF_MDT_BODY);
+ reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(reqbody != NULL);
- repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(repbody != NULL);
info->mti_spec.sp_ck_split = !!(reqbody->valid & OBD_MD_FLCKSPLIT);
rc = mdt_init_ucred(info, reqbody);
if (unlikely(rc))
- GOTO(out, rc);
+ GOTO(out_shrink, rc);
rc = mdt_getattr_name_lock(info, lhc, MDS_INODELOCK_UPDATE, NULL);
if (lustre_handle_is_used(&lhc->mlh_reg_lh)) {
}
mdt_exit_ucred(info);
EXIT;
-out:
+out_shrink:
mdt_shrink_reply(info);
return rc;
}
int keylen, rc = 0;
ENTRY;
- rc = lustre_pack_reply(req, 1, NULL, NULL);
+ rc = req_capsule_server_pack(info->mti_pill);
if (rc)
RETURN(rc);
- key = req_capsule_client_get(&info->mti_pill, &RMF_SETINFO_KEY);
+ key = req_capsule_client_get(info->mti_pill, &RMF_SETINFO_KEY);
if (key == NULL) {
DEBUG_REQ(D_HA, req, "no set_info key");
RETURN(-EFAULT);
}
- keylen = req_capsule_get_size(&info->mti_pill, &RMF_SETINFO_KEY,
+ keylen = req_capsule_get_size(info->mti_pill, &RMF_SETINFO_KEY,
RCL_CLIENT);
- val = req_capsule_client_get(&info->mti_pill, &RMF_SETINFO_VAL);
+ val = req_capsule_client_get(info->mti_pill, &RMF_SETINFO_VAL);
if (val == NULL) {
DEBUG_REQ(D_HA, req, "no set_info val");
RETURN(-EFAULT);
desc = ptlrpc_prep_bulk_exp(req, rdpg->rp_npages, BULK_PUT_SOURCE,
MDS_BULK_PORTAL);
if (desc == NULL)
- GOTO(out, rc = -ENOMEM);
+ RETURN(-ENOMEM);
for (i = 0, tmpcount = rdpg->rp_count;
i < rdpg->rp_npages; i++, tmpcount -= tmpsize) {
ptlrpc_abort_bulk(desc);
free_desc:
ptlrpc_free_bulk(desc);
-out:
return rc;
}
ENTRY;
- reqbody = req_capsule_client_get(&info->mti_pill, &RMF_MDT_BODY);
+ reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
if (reqbody == NULL)
RETURN(err_serious(-EFAULT));
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_READPAGE_PACK))
RETURN(err_serious(-ENOMEM));
- reqbody = req_capsule_client_get(&info->mti_pill, &RMF_MDT_BODY);
- repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
if (reqbody == NULL || repbody == NULL)
RETURN(err_serious(-EFAULT));
struct mdt_lock_handle *lhc,
__u32 op)
{
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
struct mdt_device *mdt = info->mti_mdt;
struct mdt_body *repbody;
- int need_shrink = 0;
- int rc;
+ int rc = 0;
ENTRY;
/* pack reply */
- if (req_capsule_has_field(pill, &RMF_MDT_MD, RCL_SERVER)) {
+ if (req_capsule_has_field(pill, &RMF_MDT_MD, RCL_SERVER))
req_capsule_set_size(pill, &RMF_MDT_MD, RCL_SERVER,
mdt->mdt_max_mdsize);
- need_shrink = 1;
- }
- if (req_capsule_has_field(pill, &RMF_LOGCOOKIES, RCL_SERVER)) {
+ if (req_capsule_has_field(pill, &RMF_LOGCOOKIES, RCL_SERVER))
req_capsule_set_size(pill, &RMF_LOGCOOKIES, RCL_SERVER,
mdt->mdt_max_cookiesize);
- need_shrink = 1;
- }
- rc = req_capsule_pack(pill);
+
+ rc = req_capsule_server_pack(pill);
if (rc != 0) {
CERROR("Can't pack response, rc %d\n", rc);
RETURN(err_serious(rc));
if (rc != 0)
GOTO(out_ucred, rc = err_serious(rc));
- need_shrink = 0;
if (mdt_check_resent(info, mdt_reconstruct, lhc)) {
rc = lustre_msg_get_status(mdt_info_req(info)->rq_repmsg);
GOTO(out_ucred, rc);
}
-
rc = mdt_reint_rec(info, lhc);
EXIT;
out_ucred:
mdt_exit_ucred(info);
out_shrink:
- if (need_shrink)
- mdt_shrink_reply(info);
+ mdt_shrink_reply(info);
return rc;
}
static long mdt_reint_opcode(struct mdt_thread_info *info,
const struct req_format **fmt)
{
- __u32 *ptr;
+ struct mdt_rec_reint *rec;
long opc;
opc = err_serious(-EFAULT);
- ptr = req_capsule_client_get(&info->mti_pill, &RMF_REINT_OPC);
- if (ptr != NULL) {
- opc = *ptr;
+ rec = req_capsule_client_get(info->mti_pill, &RMF_REC_REINT);
+ if (rec != NULL) {
+ opc = rec->rr_opcode;
DEBUG_REQ(D_INODE, mdt_info_req(info), "reint opt = %ld", opc);
if (opc < REINT_MAX && fmt[opc] != NULL)
- req_capsule_extend(&info->mti_pill, fmt[opc]);
+ req_capsule_extend(info->mti_pill, fmt[opc]);
else {
CERROR("Unsupported opc: %ld\n", opc);
opc = err_serious(opc);
int rc;
static const struct req_format *reint_fmts[REINT_MAX] = {
- [REINT_SETATTR] = &RQF_MDS_REINT_SETATTR,
- [REINT_CREATE] = &RQF_MDS_REINT_CREATE,
- [REINT_LINK] = &RQF_MDS_REINT_LINK,
- [REINT_UNLINK] = &RQF_MDS_REINT_UNLINK,
- [REINT_RENAME] = &RQF_MDS_REINT_RENAME,
- [REINT_OPEN] = &RQF_MDS_REINT_OPEN
+ [REINT_SETATTR] = &RQF_MDS_REINT_SETATTR,
+ [REINT_CREATE] = &RQF_MDS_REINT_CREATE,
+ [REINT_LINK] = &RQF_MDS_REINT_LINK,
+ [REINT_UNLINK] = &RQF_MDS_REINT_UNLINK,
+ [REINT_RENAME] = &RQF_MDS_REINT_RENAME,
+ [REINT_OPEN] = &RQF_MDS_REINT_OPEN,
+ [REINT_SETXATTR] = &RQF_MDS_REINT_SETXATTR
};
ENTRY;
static int mdt_sync(struct mdt_thread_info *info)
{
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
struct mdt_body *body;
int rc;
ENTRY;
if (fid_seq(&body->fid1) == 0) {
/* sync the whole device */
- rc = req_capsule_pack(pill);
+ rc = req_capsule_server_pack(pill);
if (rc == 0)
rc = mdt_device_sync(info);
else
{
int rc;
ENTRY;
+
+ req_capsule_set(info->mti_pill, &RQF_OBD_PING);
+
rc = target_handle_ping(mdt_info_req(info));
if (rc < 0)
rc = err_serious(rc);
struct mdt_object *m;
ENTRY;
+ CDEBUG(D_INFO, "Find object for "DFID"\n", PFID(f));
o = lu_object_find(env, d->mdt_md_dev.md_lu_dev.ld_site, f);
if (unlikely(IS_ERR(o)))
m = (struct mdt_object *)o;
const struct lu_env *env;
struct req_capsule *pill;
int rc;
+ ENTRY;
env = info->mti_env;
- pill = &info->mti_pill;
+ pill = info->mti_pill;
body = info->mti_body = req_capsule_client_get(pill, &RMF_MDT_BODY);
if (body == NULL)
- return -EFAULT;
+ RETURN(-EFAULT);
+
+ if (!(body->valid & OBD_MD_FLID))
+ RETURN(0);
if (!fid_is_sane(&body->fid1)) {
CERROR("Invalid fid: "DFID"\n", PFID(&body->fid1));
- return -EINVAL;
+ RETURN(-EINVAL);
}
/*
} else
rc = PTR_ERR(obj);
- return rc;
+ RETURN(rc);
}
static int mdt_unpack_req_pack_rep(struct mdt_thread_info *info, __u32 flags)
{
- struct req_capsule *pill;
+ struct req_capsule *pill = info->mti_pill;
int rc;
-
ENTRY;
- pill = &info->mti_pill;
if (req_capsule_has_field(pill, &RMF_MDT_BODY, RCL_CLIENT))
rc = mdt_body_unpack(info, flags);
req_capsule_set_size(pill, &RMF_LOGCOOKIES, RCL_SERVER,
mdt->mdt_max_cookiesize);
- rc = req_capsule_pack(pill);
+ rc = req_capsule_server_pack(pill);
}
RETURN(rc);
}
LASSERT(ergo(flags & (HABEO_CORPUS|HABEO_REFERO), h->mh_fmt != NULL));
if (h->mh_fmt != NULL) {
- req_capsule_set(&info->mti_pill, h->mh_fmt);
+ req_capsule_set(info->mti_pill, h->mh_fmt);
rc = mdt_unpack_req_pack_rep(info, flags);
}
LASSERT(h->mh_fmt != NULL);
- dlm_req = req_capsule_client_get(&info->mti_pill, &RMF_DLM_REQ);
+ dlm_req = req_capsule_client_get(info->mti_pill, &RMF_DLM_REQ);
if (dlm_req != NULL) {
if (info->mti_mdt->mdt_opts.mo_compat_resname)
rc = mdt_lock_resname_compat(info->mti_mdt,
dlm_req);
info->mti_dlm_req = dlm_req;
} else {
- CERROR("Can't unpack dlm request\n");
rc = -EFAULT;
}
}
info->mti_mdt->mdt_opts.mo_compat_resname) {
struct ldlm_reply *dlmrep;
- dlmrep = req_capsule_server_get(&info->mti_pill, &RMF_DLM_REP);
+ dlmrep = req_capsule_server_get(info->mti_pill, &RMF_DLM_REP);
if (dlmrep != NULL)
rc = mdt_lock_reply_compat(info->mti_mdt, dlmrep);
}
int i;
struct md_capainfo *ci;
- info->mti_rep_buf_nr = ARRAY_SIZE(info->mti_rep_buf_size);
- for (i = 0; i < ARRAY_SIZE(info->mti_rep_buf_size); i++)
- info->mti_rep_buf_size[i] = -1;
- req_capsule_init(&info->mti_pill, req, RCL_SERVER,
- info->mti_rep_buf_size);
+ req_capsule_init(&req->rq_pill, req, RCL_SERVER);
+ info->mti_pill = &req->rq_pill;
/* lock handle */
for (i = 0; i < ARRAY_SIZE(info->mti_lh); i++)
{
int i;
- req_capsule_fini(&info->mti_pill);
+ req_capsule_fini(info->mti_pill);
if (info->mti_object != NULL) {
mdt_object_put(info->mti_env, info->mti_object);
info->mti_object = NULL;
if (!(lustre_msg_get_flags(req->rq_reqmsg) & MSG_RESENT))
return;
- dlmreq = req_capsule_client_get(&info->mti_pill, &RMF_DLM_REQ);
+ dlmreq = req_capsule_client_get(info->mti_pill, &RMF_DLM_REQ);
remote_hdl = dlmreq->lock_handle[0];
spin_lock(&exp->exp_ldlm_data.led_lock);
int rc;
ENTRY;
- reqbody = req_capsule_client_get(&info->mti_pill, &RMF_MDT_BODY);
+ reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(reqbody);
- repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(repbody);
info->mti_spec.sp_ck_split = !!(reqbody->valid & OBD_MD_FLCKSPLIT);
break;
default:
CERROR("Unhandled till now");
- GOTO(out, rc = -EINVAL);
+ GOTO(out_shrink, rc = -EINVAL);
}
rc = mdt_init_ucred(info, reqbody);
if (rc)
- GOTO(out, rc);
+ GOTO(out_shrink, rc);
- req = info->mti_pill.rc_req;
- ldlm_rep = req_capsule_server_get(&info->mti_pill, &RMF_DLM_REP);
+ req = info->mti_pill->rc_req;
+ ldlm_rep = req_capsule_server_get(info->mti_pill, &RMF_DLM_REP);
mdt_set_disposition(info, ldlm_rep, DISP_IT_EXECD);
/* Get lock from request for possible resent case. */
EXIT;
out_ucred:
mdt_exit_ucred(info);
-out:
+out_shrink:
mdt_shrink_reply(info);
return rc;
}
opc = mdt_reint_opcode(info, intent_fmts);
if (opc < 0)
- GOTO(out, rc = opc);
+ RETURN(opc);
if (mdt_it_flavor[opcode].it_reint != opc) {
CERROR("Reint code %ld doesn't match intent: %d\n",
opc, opcode);
- GOTO(out, rc = err_serious(-EPROTO));
+ RETURN(err_serious(-EPROTO));
}
/* Get lock from request for possible resent case. */
/* Check whether the reply has been packed successfully. */
if (mdt_info_req(info)->rq_repmsg != NULL)
- rep = req_capsule_server_get(&info->mti_pill, &RMF_DLM_REP);
+ rep = req_capsule_server_get(info->mti_pill, &RMF_DLM_REP);
if (rep == NULL)
- GOTO(out, rc = err_serious(-EFAULT));
+ RETURN(err_serious(-EFAULT));
/* MDC expects this in any case */
if (rc != 0)
LASSERT(lustre_handle_is_used(&lhc->mlh_reg_lh));
rep->lock_policy_res2 = 0;
rc = mdt_intent_lock_replace(info, lockp, NULL, lhc, flags);
- GOTO(out, rc);
+ RETURN(rc);
}
rep->lock_policy_res2 = clear_serious(rc);
lhc->mlh_reg_lh.cookie = 0ull;
rc = ELDLM_LOCK_ABORTED;
- EXIT;
-out:
- return rc;
+ RETURN(rc);
}
static int mdt_intent_code(long itcode)
if (opc < 0)
RETURN(-EINVAL);
- pill = &info->mti_pill;
+ pill = info->mti_pill;
flv = &mdt_it_flavor[opc];
if (flv->it_fmt != NULL)
struct ptlrpc_request *req = mdt_info_req(info);
if (flv->it_flags & MUTABOR &&
req->rq_export->exp_connect_flags & OBD_CONNECT_RDONLY)
- rc = -EROFS;
+ RETURN(-EROFS);
}
if (rc == 0 && flv->it_act != NULL) {
/* execute policy */
rc = flv->it_act(opc, info, lockp, flags);
- } else
+ } else {
rc = -EOPNOTSUPP;
+ }
RETURN(rc);
}
info = lu_context_key_get(&req->rq_svc_thread->t_env->le_ctx,
&mdt_thread_key);
LASSERT(info != NULL);
- pill = &info->mti_pill;
+ pill = info->mti_pill;
LASSERT(pill->rc_req == req);
if (req->rq_reqmsg->lm_bufcount > DLM_INTENT_IT_OFF) {
} else {
/* No intent was provided */
LASSERT(pill->rc_fmt == &RQF_LDLM_ENQUEUE);
- rc = req_capsule_pack(pill);
+ rc = req_capsule_server_pack(pill);
if (rc)
rc = err_serious(rc);
}
return -EBADE;
}
+ if ((exp->exp_connect_flags & OBD_CONNECT_FID) == 0) {
+ CWARN("%s: MDS requires FID support, but client not\n",
+ mdt->mdt_md_dev.md_lu_dev.ld_obd->obd_name);
+ return -EBADE;
+ }
+
return 0;
}
RETURN(-EINVAL);
info = lu_context_key_get(&env->le_ctx, &mdt_thread_key);
- req = info->mti_pill.rc_req;
+ req = info->mti_pill->rc_req;
mdt = mdt_dev(obd->obd_lu_dev);
rc = class_connect(conn, obd, cluuid);
RETURN(-EINVAL);
info = lu_context_key_get(&env->le_ctx, &mdt_thread_key);
- req = info->mti_pill.rc_req;
+ req = info->mti_pill->rc_req;
mdt = mdt_dev(obd->obd_lu_dev);
CDEBUG(D_SEC, "from %s\n", sptlrpc_part2name(req->rq_sp_from));
DEF_MDT_HNDL_F(0 |HABEO_REFERO, GETSTATUS, mdt_getstatus),
DEF_MDT_HNDL_F(HABEO_CORPUS, GETATTR, mdt_getattr),
DEF_MDT_HNDL_F(HABEO_CORPUS|HABEO_REFERO, GETATTR_NAME, mdt_getattr_name),
-DEF_MDT_HNDL_F(HABEO_CORPUS|MUTABOR, SETXATTR, mdt_setxattr),
DEF_MDT_HNDL_F(HABEO_CORPUS, GETXATTR, mdt_getxattr),
DEF_MDT_HNDL_F(0 |HABEO_REFERO, STATFS, mdt_statfs),
DEF_MDT_HNDL_F(0 |MUTABOR, REINT, mdt_reint),
DEF_MDT_HNDL_F(0 |HABEO_REFERO, PIN, mdt_pin),
DEF_MDT_HNDL_0(0, SYNC, mdt_sync),
DEF_MDT_HNDL_F(HABEO_CORPUS|HABEO_REFERO, IS_SUBDIR, mdt_is_subdir),
-DEF_MDT_HNDL_0(0, QUOTACHECK, mdt_quotacheck_handle),
-DEF_MDT_HNDL_0(0, QUOTACTL, mdt_quotactl_handle)
+DEF_MDT_HNDL_F(0, QUOTACHECK, mdt_quotacheck_handle),
+DEF_MDT_HNDL_F(0, QUOTACTL, mdt_quotactl_handle)
};
#define DEF_OBD_HNDL(flags, name, fn) \
int rc = 0, remote;
ENTRY;
- data = req_capsule_client_get(&info->mti_pill, &RMF_CONNECT_DATA);
- reply = req_capsule_server_get(&info->mti_pill, &RMF_CONNECT_DATA);
+ data = req_capsule_client_get(info->mti_pill, &RMF_CONNECT_DATA);
+ reply = req_capsule_server_get(info->mti_pill, &RMF_CONNECT_DATA);
if (data == NULL || reply == NULL)
RETURN(-EFAULT);
struct mdt_thread_info {
/*
* XXX: Part One:
- * The following members will be filled expilictly
+ * The following members will be filled explicitly
* with specific data in mdt_thread_info_init().
*/
-
- /*
- * for req-layout interface. This field should be first to be compatible
- * with "struct com_thread_info" in seq and fld.
+ /* TODO: move this into mdt_session_key(with LCT_SESSION), because
+ * request handling may migrate from one server thread to another.
*/
- struct req_capsule mti_pill;
+ struct req_capsule *mti_pill;
+
/* although we have export in req, there are cases when it is not
* available, e.g. closing files upon export destroy */
struct obd_export *mti_exp;
/*
- * number of buffers in reply message.
- */
- int mti_rep_buf_nr;
- /*
- * sizes of reply buffers.
- */
- int mti_rep_buf_size[REQ_MAX_FIELD_NR];
- /*
* A couple of lock handles.
*/
struct mdt_lock_handle mti_lh[MDT_LH_NR];
static inline struct md_object *mdt_object_child(struct mdt_object *o)
{
+ LASSERT(o);
return lu2md(lu_object_next(&o->mot_obj.mo_lu));
}
static inline struct ptlrpc_request *mdt_info_req(struct mdt_thread_info *info)
{
- return info->mti_pill.rc_req;
+ return info->mti_pill ? info->mti_pill->rc_req : NULL;
}
static inline __u64 mdt_conn_flags(struct mdt_thread_info *info)
const struct lu_attr *attr, const struct lu_fid *fid);
int mdt_getxattr(struct mdt_thread_info *info);
-int mdt_setxattr(struct mdt_thread_info *info);
+int mdt_reint_setxattr(struct mdt_thread_info *info,
+ struct mdt_lock_handle *lh);
void mdt_lock_handle_init(struct mdt_lock_handle *lh);
void mdt_lock_handle_fini(struct mdt_lock_handle *lh);
void mdt_shrink_reply(struct mdt_thread_info *info)
{
- struct req_capsule *pill = &info->mti_pill;
- struct mdt_body *body;
- int acl_size, md_size, adjust = 0;
+ struct req_capsule *pill = info->mti_pill;
+ struct mdt_body *body;
+ int md_size;
+ int acl_size;
ENTRY;
body = req_capsule_server_get(pill, &RMF_MDT_BODY);
acl_size = body->aclsize;
CDEBUG(D_INFO, "Shrink to md_size = %d cookie/acl_size = %d"
- " MDSCAPA = %d, OSSCAPA = %d\n",
+ " MDSCAPA = "LPX64", OSSCAPA = "LPX64"\n",
md_size, acl_size,
- (int)(body->valid & OBD_MD_FLMDSCAPA),
- (int)(body->valid & OBD_MD_FLOSSCAPA));
+ body->valid & OBD_MD_FLMDSCAPA,
+ body->valid & OBD_MD_FLOSSCAPA);
/*
&RMF_MDT_BODY,
&RMF_MDT_MD,
(optional) &RMF_CAPA2,
(optional) something else
*/
- adjust += req_capsule_shrink(pill, &RMF_MDT_MD,
- md_size, adjust, 1);
+ if (req_capsule_has_field(pill, &RMF_MDT_MD, RCL_SERVER))
+ req_capsule_shrink(pill, &RMF_MDT_MD, md_size,
+ RCL_SERVER);
if (req_capsule_has_field(pill, &RMF_ACL, RCL_SERVER))
- adjust += req_capsule_shrink(pill, &RMF_ACL,
- acl_size, adjust, 1);
+ req_capsule_shrink(pill, &RMF_ACL, acl_size, RCL_SERVER);
else if (req_capsule_has_field(pill, &RMF_LOGCOOKIES, RCL_SERVER))
- adjust += req_capsule_shrink(pill, &RMF_LOGCOOKIES,
- acl_size, adjust, 1);
-
- /* RMF_CAPA1 on server-side maybe for OBD_MD_FLMDSCAPA or
- * OBD_MD_FLOSSCAPA. If RMF_CAPA2 exist also, RMF_CAPA1 is
- * for OBD_MD_FLMDSCAPA only. */
- if (req_capsule_has_field(pill, &RMF_CAPA1, RCL_SERVER)) {
- if ((req_capsule_has_field(pill, &RMF_CAPA2, RCL_SERVER) &&
- !(body->valid & OBD_MD_FLMDSCAPA)) ||
- (!req_capsule_has_field(pill, &RMF_CAPA2, RCL_SERVER) &&
- !(body->valid & OBD_MD_FLMDSCAPA) &&
- !(body->valid & OBD_MD_FLOSSCAPA)))
- adjust += req_capsule_shrink(pill, &RMF_CAPA1,
- 0, adjust, 1);
- }
+ req_capsule_shrink(pill, &RMF_LOGCOOKIES,
+ acl_size, RCL_SERVER);
+
+ if (req_capsule_has_field(pill, &RMF_CAPA1, RCL_SERVER) &&
+ !(body->valid & OBD_MD_FLMDSCAPA))
+ req_capsule_shrink(pill, &RMF_CAPA1, 0, RCL_SERVER);
- /* RMF_CAPA2 on server-side is for OBD_MD_FLOSSCAPA only. */
- if ((req_capsule_has_field(pill, &RMF_CAPA2, RCL_SERVER) &&
- !(body->valid & OBD_MD_FLOSSCAPA)))
- adjust += req_capsule_shrink(pill, &RMF_CAPA2, 0, adjust, 0);
+ if (req_capsule_has_field(pill, &RMF_CAPA2, RCL_SERVER) &&
+ !(body->valid & OBD_MD_FLOSSCAPA))
+ req_capsule_shrink(pill, &RMF_CAPA2, 0, RCL_SERVER);
/*
* Some more field should be shrinked if needed.
const struct lu_attr *la = &ma->ma_attr;
ENTRY;
- repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(repbody != NULL);
if (ma->ma_valid & MA_INODE)
struct md_ucred *uc = mdt_ucred(info);
struct md_attr *ma = &info->mti_attr;
struct lu_attr *la = &ma->ma_attr;
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
struct mdt_reint_record *rr = &info->mti_rr;
struct mdt_rec_setattr *rec;
ENTRY;
- rec = req_capsule_client_get(pill, &RMF_REC_SETATTR);
+ CLASSERT(sizeof(struct mdt_rec_setattr)== sizeof(struct mdt_rec_reint));
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
static int mdt_epoch_unpack(struct mdt_thread_info *info)
{
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
ENTRY;
if (req_capsule_get_size(pill, &RMF_MDT_EPOCH, RCL_CLIENT))
}
static inline int mdt_dlmreq_unpack(struct mdt_thread_info *info) {
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
if (req_capsule_get_size(pill, &RMF_DLM_REQ, RCL_CLIENT)) {
info->mti_dlm_req = req_capsule_client_get(pill, &RMF_DLM_REQ);
static int mdt_setattr_unpack(struct mdt_thread_info *info)
{
struct md_attr *ma = &info->mti_attr;
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
int rc;
ENTRY;
struct mdt_rec_create *rec;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct mdt_reint_record *rr = &info->mti_rr;
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
struct md_op_spec *sp = &info->mti_spec;
int rc;
ENTRY;
- rec = req_capsule_client_get(pill, &RMF_REC_CREATE);
+ CLASSERT(sizeof(struct mdt_rec_create) == sizeof(struct mdt_rec_reint));
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
rr->rr_namelen = req_capsule_get_size(pill, &RMF_NAME, RCL_CLIENT) - 1;
- LASSERT(rr->rr_namelen > 0);
+ LASSERT(rr->rr_name && rr->rr_namelen > 0);
#ifdef CONFIG_FS_POSIX_ACL
if (sp->sp_cr_flags & MDS_CREATE_RMT_ACL) {
RCL_CLIENT));
sp->u.sp_ea.eadata = req_capsule_client_get(pill, &RMF_EADATA);
sp->u.sp_ea.eadatalen = req_capsule_get_size(pill, &RMF_EADATA,
- RCL_CLIENT);
+ RCL_CLIENT);
sp->u.sp_ea.fid = rr->rr_fid1;
RETURN(0);
}
struct mdt_rec_link *rec;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct mdt_reint_record *rr = &info->mti_rr;
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
int rc;
ENTRY;
- rec = req_capsule_client_get(pill, &RMF_REC_LINK);
+ CLASSERT(sizeof(struct mdt_rec_link) == sizeof(struct mdt_rec_reint));
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
struct md_attr *ma = &info->mti_attr;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct mdt_reint_record *rr = &info->mti_rr;
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
int rc;
ENTRY;
- rec = req_capsule_client_get(pill, &RMF_REC_UNLINK);
+ CLASSERT(sizeof(struct mdt_rec_unlink) == sizeof(struct mdt_rec_reint));
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
uc->mu_fsuid = rec->ul_fsuid;
uc->mu_fsgid = rec->ul_fsgid;
uc->mu_cap = rec->ul_cap;
- uc->mu_suppgids[0] = rec->ul_suppgid;
+ uc->mu_suppgids[0] = rec->ul_suppgid1;
uc->mu_suppgids[1] = -1;
attr->la_uid = rec->ul_fsuid;
struct md_attr *ma = &info->mti_attr;
struct lu_attr *attr = &info->mti_attr.ma_attr;
struct mdt_reint_record *rr = &info->mti_rr;
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
int rc;
ENTRY;
- rec = req_capsule_client_get(pill, &RMF_REC_RENAME);
+ CLASSERT(sizeof(struct mdt_rec_rename) == sizeof(struct mdt_rec_reint));
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
struct md_ucred *uc = mdt_ucred(info);
struct mdt_rec_create *rec;
struct lu_attr *attr = &info->mti_attr.ma_attr;
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
struct mdt_reint_record *rr = &info->mti_rr;
struct ptlrpc_request *req = mdt_info_req(info);
struct md_op_spec *sp = &info->mti_spec;
ENTRY;
- rec = req_capsule_client_get(pill, &RMF_REC_CREATE);
+ CLASSERT(sizeof(struct mdt_rec_create) == sizeof(struct mdt_rec_reint));
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
if (rec == NULL)
RETURN(-EFAULT);
RETURN(0);
}
+static int mdt_setxattr_unpack(struct mdt_thread_info *info)
+{
+ struct mdt_reint_record *rr = &info->mti_rr;
+ struct md_ucred *uc = mdt_ucred(info);
+ struct lu_attr *attr = &info->mti_attr.ma_attr;
+ struct req_capsule *pill = info->mti_pill;
+ struct mdt_rec_setxattr *rec;
+ ENTRY;
+
+
+ CLASSERT(sizeof(struct mdt_rec_setxattr) ==
+ sizeof(struct mdt_rec_reint));
+
+ rec = req_capsule_client_get(pill, &RMF_REC_REINT);
+ if (rec == NULL)
+ RETURN(-EFAULT);
+
+ uc->mu_fsuid = rec->sx_fsuid;
+ uc->mu_fsgid = rec->sx_fsgid;
+ uc->mu_cap = rec->sx_cap;
+ uc->mu_suppgids[0] = uc->mu_suppgids[1] = -1;
+
+ rr->rr_opcode = rec->sx_opcode;
+ rr->rr_fid1 = &rec->sx_fid;
+ attr->la_valid = rec->sx_valid;
+ attr->la_size = rec->sx_size;
+ attr->la_flags = rec->sx_flags;
+
+ if (req_capsule_get_size(pill, &RMF_CAPA1, RCL_CLIENT))
+ mdt_set_capainfo(info, 0, rr->rr_fid1,
+ req_capsule_client_get(pill, &RMF_CAPA1));
+ else
+ mdt_set_capainfo(info, 0, rr->rr_fid1, BYPASS_CAPA);
+
+ rr->rr_name = req_capsule_client_get(pill, &RMF_NAME);
+ if (rr->rr_name == NULL)
+ RETURN(-EFAULT);
+ rr->rr_namelen = req_capsule_get_size(pill, &RMF_NAME, RCL_CLIENT) - 1;
+ LASSERT(rr->rr_namelen > 0);
+
+ rr->rr_eadatalen = req_capsule_get_size(pill, &RMF_EADATA, RCL_CLIENT);
+ if (rr->rr_eadatalen > 0) {
+ rr->rr_eadata = req_capsule_client_get(pill, &RMF_EADATA);
+ if (rr->rr_eadata == NULL)
+ RETURN(-EFAULT);
+ }
+
+ RETURN(0);
+}
+
+
typedef int (*reint_unpacker)(struct mdt_thread_info *info);
static reint_unpacker mdt_reint_unpackers[REINT_MAX] = {
[REINT_LINK] = mdt_link_unpack,
[REINT_UNLINK] = mdt_unlink_unpack,
[REINT_RENAME] = mdt_rename_unpack,
- [REINT_OPEN] = mdt_open_unpack
+ [REINT_OPEN] = mdt_open_unpack,
+ [REINT_SETXATTR] = mdt_setxattr_unpack
};
int mdt_reint_unpack(struct mdt_thread_info *info, __u32 op)
int rc = 0, isdir, isreg;
ENTRY;
- repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
isreg = S_ISREG(la->la_mode);
isdir = S_ISDIR(la->la_mode);
* above attr get, these size might be zero, so reset it, to
* retrieve the MD after create obj.
*/
- ma->ma_lmm_size = req_capsule_get_size(&info->mti_pill,
+ ma->ma_lmm_size = req_capsule_get_size(info->mti_pill,
&RMF_MDT_MD,
RCL_SERVER);
/* in replay case, p == NULL */
LASSERT(ma->ma_valid & MA_INODE);
- repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
isreg = S_ISREG(la->la_mode);
isdir = S_ISDIR(la->la_mode);
mdt_pack_attr2body(info, repbody, la, mdt_object_fid(o));
if (med->med_rmtclient) {
- void *buf = req_capsule_server_get(&info->mti_pill, &RMF_ACL);
+ void *buf = req_capsule_server_get(info->mti_pill, &RMF_ACL);
rc = mdt_pack_remote_perm(info, o, buf);
if (rc) {
struct md_object *next = mdt_object_child(o);
struct lu_buf *buf = &info->mti_buf;
- buf->lb_buf = req_capsule_server_get(&info->mti_pill, &RMF_ACL);
- buf->lb_len = req_capsule_get_size(&info->mti_pill, &RMF_ACL,
+ buf->lb_buf = req_capsule_server_get(info->mti_pill, &RMF_ACL);
+ buf->lb_len = req_capsule_get_size(info->mti_pill, &RMF_ACL,
RCL_SERVER);
if (buf->lb_len > 0) {
rc = mo_xattr_get(env, next, buf,
if (mdt->mdt_opts.mo_mds_capa) {
struct lustre_capa *capa;
- capa = req_capsule_server_get(&info->mti_pill, &RMF_CAPA1);
+ capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA1);
LASSERT(capa);
capa->lc_opc = CAPA_OPC_MDS_DEFAULT;
capa->lc_uid = 0;
S_ISREG(lu_object_attr(&o->mot_obj.mo_lu))) {
struct lustre_capa *capa;
- capa = req_capsule_server_get(&info->mti_pill, &RMF_CAPA2);
+ capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA2);
LASSERT(capa);
capa->lc_opc = CAPA_OPC_OSS_DEFAULT | capa_open_opc(flags);
capa->lc_uid = 0;
{
const struct lu_env *env = info->mti_env;
struct mdt_device *mdt = info->mti_mdt;
- struct req_capsule *pill = &info->mti_pill;
+ struct req_capsule *pill = info->mti_pill;
struct ptlrpc_request *req = mdt_info_req(info);
struct mdt_export_data *med = &req->rq_export->exp_mdt_data;
struct mdt_client_data *mcd = med->med_mcd;
ldlm_rep->lock_policy_res1, req->rq_status);
if (mdt_get_disposition(ldlm_rep, DISP_OPEN_CREATE) &&
- req->rq_status != 0) {
+ req->rq_status != 0)
/* We did not create successfully, return error to client. */
- mdt_shrink_reply(info);
GOTO(out, rc = req->rq_status);
- }
if (mdt_get_disposition(ldlm_rep, DISP_OPEN_CREATE)) {
/*
}
mdt_object_put(env, parent);
mdt_object_put(env, child);
- mdt_shrink_reply(info);
GOTO(out, rc);
} else {
regular_open:
} else {
/* the child object was created on remote server */
struct mdt_body *repbody;
- repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
repbody->fid1 = *rr->rr_fid2;
repbody->valid |= (OBD_MD_FLID | OBD_MD_MDS);
rc = 0;
OBD_FAIL_TIMEOUT_ORSET(OBD_FAIL_MDS_PAUSE_OPEN, OBD_FAIL_ONCE,
(obd_timeout + 1) / 4);
- repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
- ma->ma_lmm = req_capsule_server_get(&info->mti_pill, &RMF_MDT_MD);
- ma->ma_lmm_size = req_capsule_get_size(&info->mti_pill, &RMF_MDT_MD,
+ ma->ma_lmm = req_capsule_server_get(info->mti_pill, &RMF_MDT_MD);
+ ma->ma_lmm_size = req_capsule_get_size(info->mti_pill, &RMF_MDT_MD,
RCL_SERVER);
ma->ma_need = MA_INODE | MA_LOV;
ma->ma_valid = 0;
- LASSERT(info->mti_pill.rc_fmt == &RQF_LDLM_INTENT_OPEN);
- ldlm_rep = req_capsule_server_get(&info->mti_pill, &RMF_DLM_REP);
+ LASSERT(info->mti_pill->rc_fmt == &RQF_LDLM_INTENT_OPEN);
+ ldlm_rep = req_capsule_server_get(info->mti_pill, &RMF_DLM_REP);
/* TODO: JOIN file */
if (create_flags & MDS_OPEN_JOIN_FILE) {
out_parent:
mdt_object_unlock_put(info, parent, lh, result);
out:
- mdt_shrink_reply(info);
if (result)
lustre_msg_set_transno(req->rq_repmsg, 0);
return result;
LASSERT(info->mti_epoch);
- req_capsule_set_size(&info->mti_pill, &RMF_MDT_MD, RCL_SERVER,
+ req_capsule_set_size(info->mti_pill, &RMF_MDT_MD, RCL_SERVER,
info->mti_mdt->mdt_max_mdsize);
- req_capsule_set_size(&info->mti_pill, &RMF_LOGCOOKIES, RCL_SERVER,
+ req_capsule_set_size(info->mti_pill, &RMF_LOGCOOKIES, RCL_SERVER,
info->mti_mdt->mdt_max_cookiesize);
- rc = req_capsule_pack(&info->mti_pill);
+ rc = req_capsule_server_pack(info->mti_pill);
if (mdt_check_resent(info, mdt_reconstruct_generic, NULL))
RETURN(lustre_msg_get_status(req->rq_repmsg));
/* Continue to close handle even if we can not pack reply */
if (rc == 0) {
- repbody = req_capsule_server_get(&info->mti_pill,
+ repbody = req_capsule_server_get(info->mti_pill,
&RMF_MDT_BODY);
- ma->ma_lmm = req_capsule_server_get(&info->mti_pill,
+ ma->ma_lmm = req_capsule_server_get(info->mti_pill,
&RMF_MDT_MD);
- ma->ma_lmm_size = req_capsule_get_size(&info->mti_pill,
+ ma->ma_lmm_size = req_capsule_get_size(info->mti_pill,
&RMF_MDT_MD,
RCL_SERVER);
- ma->ma_cookie = req_capsule_server_get(&info->mti_pill,
+ ma->ma_cookie = req_capsule_server_get(info->mti_pill,
&RMF_LOGCOOKIES);
- ma->ma_cookie_size = req_capsule_get_size(&info->mti_pill,
+ ma->ma_cookie_size = req_capsule_get_size(info->mti_pill,
&RMF_LOGCOOKIES,
RCL_SERVER);
ma->ma_need = MA_INODE | MA_LOV | MA_COOKIE;
int rc;
ENTRY;
- rc = req_capsule_pack(&info->mti_pill);
+ rc = req_capsule_server_pack(info->mti_pill);
if (rc)
RETURN(err_serious(rc));
- repbody = req_capsule_server_get(&info->mti_pill,
+ repbody = req_capsule_server_get(info->mti_pill,
&RMF_MDT_BODY);
repbody->eadatasize = 0;
repbody->aclsize = 0;
child = mdt_object_find(mti->mti_env, mdt, mti->mti_rr.rr_fid2);
LASSERT(!IS_ERR(child));
- body = req_capsule_server_get(&mti->mti_pill, &RMF_MDT_BODY);
+ body = req_capsule_server_get(mti->mti_pill, &RMF_MDT_BODY);
rc = mo_attr_get(mti->mti_env, mdt_object_child(child), &mti->mti_attr);
if (rc == -EREMOTE) {
/* object was created on remote server */
if (req->rq_status)
return;
- body = req_capsule_server_get(&mti->mti_pill, &RMF_MDT_BODY);
+ body = req_capsule_server_get(mti->mti_pill, &RMF_MDT_BODY);
obj = mdt_object_find(mti->mti_env, mdt, mti->mti_rr.rr_fid1);
LASSERT(!IS_ERR(obj));
mo_attr_get(mti->mti_env, mdt_object_child(obj), &mti->mti_attr);
struct mdt_file_data *mfd;
struct mdt_body *repbody;
- repbody = req_capsule_server_get(&mti->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(mti->mti_pill, &RMF_MDT_BODY);
repbody->ioepoch = obj->mot_ioepoch;
spin_lock(&med->med_open_lock);
list_for_each_entry(mfd, &med->med_open_head, mfd_list) {
mdt_object_put(mti->mti_env, obj);
}
-static void mdt_reconstruct_with_shrink(struct mdt_thread_info *mti,
- struct mdt_lock_handle *lhc)
+static void mdt_reconstruct_setxattr(struct mdt_thread_info *mti,
+ struct mdt_lock_handle *lhc)
{
- mdt_reconstruct_generic(mti, lhc);
- mdt_shrink_reply(mti);
+ /* reply nothing */
+ req_capsule_shrink(mti->mti_pill, &RMF_EADATA, 0, RCL_SERVER);
}
typedef void (*mdt_reconstructor)(struct mdt_thread_info *mti,
[REINT_SETATTR] = mdt_reconstruct_setattr,
[REINT_CREATE] = mdt_reconstruct_create,
[REINT_LINK] = mdt_reconstruct_generic,
- [REINT_UNLINK] = mdt_reconstruct_with_shrink,
- [REINT_RENAME] = mdt_reconstruct_with_shrink,
- [REINT_OPEN] = mdt_reconstruct_open
+ [REINT_UNLINK] = mdt_reconstruct_generic,
+ [REINT_RENAME] = mdt_reconstruct_generic,
+ [REINT_OPEN] = mdt_reconstruct_open,
+ [REINT_SETXATTR] = mdt_reconstruct_setxattr
};
void mdt_reconstruct(struct mdt_thread_info *mti,
static inline void mdt_reint_init_ma(struct mdt_thread_info *info,
struct md_attr *ma)
{
- ma->ma_lmm = req_capsule_server_get(&info->mti_pill, &RMF_MDT_MD);
- ma->ma_lmm_size = req_capsule_get_size(&info->mti_pill,
+ ma->ma_lmm = req_capsule_server_get(info->mti_pill, &RMF_MDT_MD);
+ ma->ma_lmm_size = req_capsule_get_size(info->mti_pill,
&RMF_MDT_MD, RCL_SERVER);
- ma->ma_cookie = req_capsule_server_get(&info->mti_pill,
+ ma->ma_cookie = req_capsule_server_get(info->mti_pill,
&RMF_LOGCOOKIES);
- ma->ma_cookie_size = req_capsule_get_size(&info->mti_pill,
+ ma->ma_cookie_size = req_capsule_get_size(info->mti_pill,
&RMF_LOGCOOKIES,
RCL_SERVER);
if (rc == 0 && info->mti_mdt->mdt_opts.mo_mds_capa) {
struct lustre_capa *capa;
- capa = req_capsule_server_get(&info->mti_pill, &RMF_CAPA1);
+ capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA1);
LASSERT(capa);
capa->lc_opc = CAPA_OPC_MDS_DEFAULT;
rc = mo_capa_get(info->mti_env, mdt_object_child(object), capa,
if (rc == 0)
repbody->valid |= OBD_MD_FLMDSCAPA;
}
- if (!(repbody->valid & OBD_MD_FLMDSCAPA))
- lustre_shrink_reply(mdt_info_req(info), REPLY_REC_OFF+1, 0, 1);
RETURN(rc);
}
DEBUG_REQ(D_INODE, mdt_info_req(info), "Create (%s->"DFID") in "DFID,
rr->rr_name, PFID(rr->rr_fid2), PFID(rr->rr_fid1));
- repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
lh = &info->mti_lh[MDT_LH_PARENT];
mdt_lock_pdo_init(lh, LCK_PW, rr->rr_name, rr->rr_namelen);
ma->ma_need = MA_INODE;
ma->ma_valid = 0;
/* capa for cross-ref will be stored here */
- ma->ma_capa = req_capsule_server_get(&info->mti_pill,
+ ma->ma_capa = req_capsule_server_get(info->mti_pill,
&RMF_CAPA1);
LASSERT(ma->ma_capa);
DEBUG_REQ(D_INODE, mdt_info_req(info), "Partial create "DFID"",
PFID(info->mti_rr.rr_fid2));
- repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
o = mdt_object_find(info->mti_env, mdt, info->mti_rr.rr_fid2);
if (!IS_ERR(o)) {
if (info->mti_dlm_req)
ldlm_request_cancel(req, info->mti_dlm_req, 0);
- repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
mo = mdt_object_find(info->mti_env, info->mti_mdt, rr->rr_fid1);
if (IS_ERR(mo))
GOTO(out, rc = PTR_ERR(mo));
(ma->ma_attr.la_valid & LA_SIZE)) {
struct lustre_capa *capa;
- capa = req_capsule_server_get(&info->mti_pill, &RMF_CAPA1);
+ capa = req_capsule_server_get(info->mti_pill, &RMF_CAPA2);
LASSERT(capa);
capa->lc_opc = CAPA_OPC_OSS_DEFAULT | CAPA_OPC_OSS_TRUNC;
rc = mo_capa_get(info->mti_env, mdt_object_child(mo), capa, 0);
out_put:
mdt_object_put(info->mti_env, mo);
out:
+ mdt_shrink_reply(info);
return rc;
}
ENTRY;
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_CREATE))
- GOTO(out, rc = err_serious(-ESTALE));
+ RETURN(err_serious(-ESTALE));
if (info->mti_dlm_req)
ldlm_request_cancel(mdt_info_req(info), info->mti_dlm_req, 0);
default:
rc = err_serious(-EOPNOTSUPP);
}
- EXIT;
-out:
- return rc;
+ RETURN(rc);
}
static int mdt_reint_unlink(struct mdt_thread_info *info,
ldlm_request_cancel(req, info->mti_dlm_req, 0);
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_UNLINK))
- GOTO(out, rc = err_serious(-ENOENT));
+ RETURN(err_serious(-ENOENT));
/* step 1: lock the parent */
parent_lh = &info->mti_lh[MDT_LH_PARENT];
out_unlock_parent:
mdt_object_unlock_put(info, mp, parent_lh, rc);
out:
- mdt_shrink_reply(info);
return rc;
}
PFID(rr->rr_fid1), PFID(rr->rr_fid2), rr->rr_name);
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_REINT_LINK))
- GOTO(out, rc = err_serious(-ENOENT));
+ RETURN(err_serious(-ENOENT));
if (info->mti_dlm_req)
ldlm_request_cancel(req, info->mti_dlm_req, 0);
ms = mdt_object_find_lock(info, rr->rr_fid1, lhs,
MDS_INODELOCK_UPDATE);
if (IS_ERR(ms))
- GOTO(out, rc = PTR_ERR(ms));
+ RETURN(PTR_ERR(ms));
mdt_set_capainfo(info, 0, rr->rr_fid1, BYPASS_CAPA);
rc = mo_ref_add(info->mti_env, mdt_object_child(ms), ma);
mdt_object_unlock_put(info, ms, lhs, rc);
- GOTO(out, rc);
+ RETURN(rc);
}
/* Invalid case so return error immediately instead of
* processing it */
if (lu_fid_eq(rr->rr_fid1, rr->rr_fid2))
- GOTO(out, rc = -EPERM);
+ RETURN(-EPERM);
/* step 1: find & lock the target parent dir */
lhp = &info->mti_lh[MDT_LH_PARENT];
mp = mdt_object_find_lock(info, rr->rr_fid2, lhp,
MDS_INODELOCK_UPDATE);
if (IS_ERR(mp))
- GOTO(out, rc = PTR_ERR(mp));
+ RETURN(PTR_ERR(mp));
/* step 2: find & lock the source */
lhs = &info->mti_lh[MDT_LH_CHILD];
mdt_object_unlock_put(info, ms, lhs, rc);
out_unlock_parent:
mdt_object_unlock_put(info, mp, lhp, rc);
-out:
return rc;
}
mtgtdir = mdt_object_find_lock(info, rr->rr_fid1, lh_tgtdir,
MDS_INODELOCK_UPDATE);
if (IS_ERR(mtgtdir))
- GOTO(out, rc = PTR_ERR(mtgtdir));
+ RETURN(PTR_ERR(mtgtdir));
/* step 2: find & lock the target object if exists. */
mdt_set_capainfo(info, 0, rr->rr_fid1, BYPASS_CAPA);
mdt_object_unlock_put(info, mtgt, lh_tgt, rc);
out_unlock_tgtdir:
mdt_object_unlock_put(info, mtgtdir, lh_tgtdir, rc);
-out:
- mdt_shrink_reply(info);
return rc;
}
rc = mdt_rename_lock(info, &rename_lh);
if (rc) {
CERROR("Can't lock FS for rename, rc %d\n", rc);
- GOTO(out, rc);
+ RETURN(rc);
}
lh_newp = &info->mti_lh[MDT_LH_NEW];
mdt_object_unlock_put(info, msrcdir, lh_srcdirp, rc);
out_rename_lock:
mdt_rename_unlock(&rename_lh);
-out:
- mdt_shrink_reply(info);
return rc;
}
static mdt_reinter reinters[REINT_MAX] = {
[REINT_SETATTR] = mdt_reint_setattr,
- [REINT_CREATE] = mdt_reint_create,
- [REINT_LINK] = mdt_reint_link,
- [REINT_UNLINK] = mdt_reint_unlink,
- [REINT_RENAME] = mdt_reint_rename,
- [REINT_OPEN] = mdt_reint_open
+ [REINT_CREATE] = mdt_reint_create,
+ [REINT_LINK] = mdt_reint_link,
+ [REINT_UNLINK] = mdt_reint_unlink,
+ [REINT_RENAME] = mdt_reint_rename,
+ [REINT_OPEN] = mdt_reint_open,
+ [REINT_SETXATTR] = mdt_reint_setxattr
};
int mdt_reint_rec(struct mdt_thread_info *info,
/* return EADATA length to the caller. negative value means error */
static int mdt_getxattr_pack_reply(struct mdt_thread_info * info)
{
- struct req_capsule *pill = &info->mti_pill ;
+ struct req_capsule *pill = info->mti_pill ;
struct ptlrpc_request *req = mdt_info_req(info);
char *xattr_name;
__u64 valid = info->mti_body->valid;
mdt_object_child(info->mti_object),
&LU_BUF_NULL);
} else {
- CERROR("Valid bits: "LPX64"\n", info->mti_body->valid);
+ CDEBUG(D_INFO, "Valid bits: "LPX64"\n", info->mti_body->valid);
RETURN(-EINVAL);
}
if (size == -ENODATA)
size = 0;
else if (size != -EOPNOTSUPP) {
- CERROR("Error geting EA size: %d\n", size);
+ CDEBUG(D_INFO, "Error geting EA size: %d\n", size);
RETURN(size);
}
}
req_capsule_set_size(pill, &RMF_EADATA, RCL_SERVER,
min_t(int, size, info->mti_body->eadatasize));
- rc = req_capsule_pack(pill);
+ rc = req_capsule_server_pack(pill);
if (rc) {
LASSERT(rc < 0);
RETURN(rc);
CDEBUG(D_INODE, "getxattr "DFID"\n", PFID(&info->mti_body->fid1));
- reqbody = req_capsule_client_get(&info->mti_pill, &RMF_MDT_BODY);
+ reqbody = req_capsule_client_get(info->mti_pill, &RMF_MDT_BODY);
if (reqbody == NULL)
RETURN(err_serious(-EFAULT));
if (easize < 0)
GOTO(out, rc = err_serious(easize));
- repbody = req_capsule_server_get(&info->mti_pill, &RMF_MDT_BODY);
+ repbody = req_capsule_server_get(info->mti_pill, &RMF_MDT_BODY);
LASSERT(repbody != NULL);
/* No need further getxattr. */
GOTO(out, rc = easize);
buf = &info->mti_buf;
- buf->lb_buf = req_capsule_server_get(&info->mti_pill, &RMF_EADATA);
+ buf->lb_buf = req_capsule_server_get(info->mti_pill, &RMF_EADATA);
buf->lb_len = easize;
if (info->mti_body->valid & OBD_MD_FLXATTR) {
int flags = CFS_IC_NOTHING;
- char *xattr_name = req_capsule_client_get(&info->mti_pill,
+ char *xattr_name = req_capsule_client_get(info->mti_pill,
&RMF_NAME);
CDEBUG(D_INODE, "getxattr %s\n", xattr_name);
rc = mo_xattr_list(info->mti_env, next, buf);
if (rc < 0)
- CERROR("listxattr failed: %d\n", rc);
+ CDEBUG(D_INFO, "listxattr failed: %d\n", rc);
} else
LBUG();
return rc;
}
-static int mdt_rmtlsetfacl(struct mdt_thread_info *info, char *xattr_name,
+static int mdt_rmtlsetfacl(struct mdt_thread_info *info, const char *xattr_name,
ext_acl_xattr_header *header,
posix_acl_xattr_header **out)
{
if (rc < 0) {
CERROR("getxattr failed: %d\n", rc);
GOTO(_out, rc);
- }
+ }
} else
buf->lb_buf = NULL;
_out:
if (rc <= 0 && buf->lb_buf != NULL)
OBD_FREE(buf->lb_buf, buf->lb_len);
-
return rc;
}
-int mdt_setxattr(struct mdt_thread_info *info)
+int mdt_reint_setxattr(struct mdt_thread_info *info,
+ struct mdt_lock_handle *unused)
{
struct ptlrpc_request *req = mdt_info_req(info);
struct mdt_export_data *med = mdt_req2med(req);
struct md_ucred *uc = mdt_ucred(info);
- struct mdt_body *reqbody;
const char user_string[] = "user.";
const char trust_string[] = "trusted.";
struct mdt_lock_handle *lh;
- struct req_capsule *pill = &info->mti_pill;
- struct mdt_object *obj = info->mti_object;
- struct mdt_body *body = (struct mdt_body *)info->mti_body;
+ struct req_capsule *pill = info->mti_pill;
const struct lu_env *env = info->mti_env;
- struct md_object *child = mdt_object_child(obj);
struct lu_buf *buf = &info->mti_buf;
- __u64 valid = body->valid;
- char *xattr_name;
+ struct mdt_reint_record *rr = &info->mti_rr;
+ struct lu_attr *attr = &info->mti_attr.ma_attr;
+ struct mdt_object *obj;
+ struct md_object *child;
+ __u64 valid = attr->la_valid;
+ const char *xattr_name;
int xattr_len = 0;
__u64 lockpart;
int rc;
posix_acl_xattr_header *new_xattr = NULL;
ENTRY;
- CDEBUG(D_INODE, "setxattr "DFID"\n", PFID(&body->fid1));
+ CDEBUG(D_INODE, "setxattr for "DFID"\n", PFID(rr->rr_fid1));
if (OBD_FAIL_CHECK(OBD_FAIL_MDS_SETXATTR))
RETURN(err_serious(-ENOMEM));
- reqbody = req_capsule_client_get(pill, &RMF_MDT_BODY);
- if (reqbody == NULL)
- RETURN(err_serious(-EFAULT));
+ xattr_name = rr->rr_name;
- rc = mdt_init_ucred(info, reqbody);
- if (rc)
- RETURN(err_serious(rc));
+ CDEBUG(D_INODE, "%s xattr %s\n",
+ valid & OBD_MD_FLXATTR ? "set" : "remove", xattr_name);
+
+ rc = mdt_init_ucred_reint(info);
+ if (rc != 0)
+ RETURN(rc);
if (valid & OBD_MD_FLRMTRSETFACL) {
__u32 perm = mdt_identity_get_perm(uc->mu_identity,
GOTO(out, rc = err_serious(-EPERM));
}
- rc = req_capsule_pack(pill);
- if (rc < 0)
- GOTO(out, rc = err_serious(rc));
-
/* various sanity check for xattr name */
xattr_name = req_capsule_client_get(pill, &RMF_NAME);
if (!xattr_name)
GOTO(out, rc = err_serious(-EFAULT));
- CDEBUG(D_INODE, "%s xattr %s\n",
- body->valid & OBD_MD_FLXATTR ? "set" : "remove", xattr_name);
-
if (strncmp(xattr_name, trust_string, sizeof(trust_string) - 1) == 0) {
if (strcmp(xattr_name + 8, XATTR_NAME_LOV) == 0)
GOTO(out, rc = -EACCES);
lh = &info->mti_lh[MDT_LH_PARENT];
mdt_lock_reg_init(lh, LCK_PW);
- rc = mdt_object_lock(info, obj, lh, lockpart, MDT_LOCAL_LOCK);
- if (rc != 0)
- GOTO(out, rc);
+ obj = mdt_object_find_lock(info, rr->rr_fid1, lh, lockpart);
+ if (IS_ERR(obj))
+ GOTO(out, rc = PTR_ERR(obj));
+ child = mdt_object_child(obj);
if ((valid & OBD_MD_FLXATTR) == OBD_MD_FLXATTR) {
char * xattr;
+
if (!req_capsule_field_present(pill, &RMF_EADATA, RCL_CLIENT)) {
- CERROR("no xattr data supplied\n");
+ CDEBUG(D_INFO, "no xattr data supplied\n");
GOTO(out_unlock, rc = -EFAULT);
}
xattr_len = req_capsule_get_size(pill, &RMF_EADATA, RCL_CLIENT);
if (xattr_len) {
int flags = 0;
+
xattr = req_capsule_client_get(pill, &RMF_EADATA);
if (valid & OBD_MD_FLRMTLSETFACL) {
xattr = (char *)new_xattr;
}
- if (body->flags & XATTR_REPLACE)
+ if (attr->la_flags & XATTR_REPLACE)
flags |= LU_XATTR_REPLACE;
- if (body->flags & XATTR_CREATE)
+ if (attr->la_flags & XATTR_CREATE)
flags |= LU_XATTR_CREATE;
mdt_fail_write(env, info->mti_mdt->mdt_bottom,
} else if ((valid & OBD_MD_FLXATTRRM) == OBD_MD_FLXATTRRM) {
rc = mo_xattr_del(env, child, xattr_name);
} else {
- CERROR("valid bits: "LPX64"\n", body->valid);
+ CDEBUG(D_INFO, "valid bits: "LPX64"\n", valid);
rc = -EINVAL;
}
EXIT;
out_unlock:
+ mdt_object_unlock_put(info, obj, lh, rc);
if (unlikely(new_xattr != NULL))
lustre_posix_acl_xattr_free(new_xattr, xattr_len);
- mdt_object_unlock(info, obj, lh, rc);
out:
mdt_exit_ucred(info);
return rc;
static int mgc_target_register(struct obd_export *exp,
struct mgs_target_info *mti)
{
- struct ptlrpc_request *req;
+ struct ptlrpc_request *req;
struct mgs_target_info *req_mti, *rep_mti;
- int size[] = { sizeof(struct ptlrpc_body), sizeof(*req_mti) };
- int rep_size[] = { sizeof(struct ptlrpc_body), sizeof(*mti) };
- int rc;
+ int rc;
ENTRY;
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_MGS_VERSION,
- MGS_TARGET_REG, 2, size, NULL);
- if (!req)
+ req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp),
+ &RQF_MGS_TARGET_REG, LUSTRE_MGS_VERSION,
+ MGS_TARGET_REG);
+ if (req == NULL)
RETURN(-ENOMEM);
- req_mti = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*req_mti));
- if (!req_mti)
- RETURN(-ENOMEM);
+ req_mti = req_capsule_client_get(&req->rq_pill, &RMF_MGS_TARGET_INFO);
memcpy(req_mti, mti, sizeof(*req_mti));
- ptlrpc_req_set_repsize(req, 2, rep_size);
+ ptlrpc_request_set_replen(req);
CDEBUG(D_MGC, "register %s\n", mti->mti_svname);
rc = ptlrpc_queue_wait(req);
if (!rc) {
- rep_mti = lustre_swab_repbuf(req, REPLY_REC_OFF,
- sizeof(*rep_mti),
- lustre_swab_mgs_target_info);
+ rep_mti = req_capsule_server_get(&req->rq_pill,
+ &RMF_MGS_TARGET_INFO);
memcpy(mti, rep_mti, sizeof(*rep_mti));
CDEBUG(D_MGC, "register %s got index = %d\n",
mti->mti_svname, mti->mti_stripe_index);
data->ocd_version = LUSTRE_VERSION_CODE;
}
+ if ((exp->exp_connect_flags & OBD_CONNECT_FID) == 0) {
+ CWARN("MGS requires FID support, but client not\n");
+ rc = -EBADE;
+ }
+
if (rc) {
class_disconnect(exp);
} else {
struct obd_device *obd = req->rq_export->exp_obd;
struct lustre_handle lockh;
struct mgs_target_info *mti, *rep_mti;
- int rep_size[] = { sizeof(struct ptlrpc_body), sizeof(*mti) };
int rc = 0, lockrc;
ENTRY;
- mti = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*mti),
- lustre_swab_mgs_target_info);
-
+ mti = req_capsule_client_get(&req->rq_pill, &RMF_MGS_TARGET_INFO);
if (!(mti->mti_flags & (LDD_F_WRITECONF | LDD_F_UPGRADE14 |
LDD_F_UPDATE))) {
/* We're just here as a startup ping. */
out_nolock:
CDEBUG(D_MGS, "replying with %s, index=%d, rc=%d\n", mti->mti_svname,
mti->mti_stripe_index, rc);
- lustre_pack_reply(req, 2, rep_size, NULL);
+ rc = req_capsule_server_pack(&req->rq_pill);
+ if (rc)
+ RETURN(rc);
+
/* send back the whole mti in the reply */
- rep_mti = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF,
- sizeof(*rep_mti));
- memcpy(rep_mti, mti, sizeof(*rep_mti));
+ rep_mti = req_capsule_server_get(&req->rq_pill, &RMF_MGS_TARGET_INFO);
+ *rep_mti = *mti;
/* Flush logs to disk */
fsfilt_sync(obd, obd->u.mgs.mgs_sb);
struct obd_device *obd = req->rq_export->exp_obd;
struct mgs_send_param *msp, *rep_msp;
struct lustre_handle lockh;
- int rep_size[] = { sizeof(struct ptlrpc_body), sizeof(*msp) };
int lockrc, rc;
struct lustre_cfg_bufs bufs;
struct lustre_cfg *lcfg;
char fsname[MTI_NAME_MAXLEN];
ENTRY;
- msp = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*msp), NULL);
+ msp = req_capsule_client_get(&req->rq_pill, &RMF_MGS_SEND_PARAM);
+ LASSERT(msp);
/* Construct lustre_cfg structure to pass to function mgs_setparam */
lustre_cfg_bufs_reset(&bufs, NULL);
}
lustre_cfg_free(lcfg);
- lustre_pack_reply(req, 2, rep_size, NULL);
- rep_msp = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF,
- sizeof(*rep_msp));
- memcpy(rep_msp, msp, sizeof(*rep_msp));
-
+ rc = req_capsule_server_pack(&req->rq_pill);
+ if (rc == 0) {
+ rep_msp = req_capsule_server_get(&req->rq_pill, &RMF_MGS_SEND_PARAM);
+ rep_msp = msp;
+ }
RETURN(rc);
}
+/* TODO: handle requests in a similar way as MDT: see mdt_handle_common() */
int mgs_handle(struct ptlrpc_request *req)
{
int fail = OBD_FAIL_MGS_ALL_REPLY_NET;
int opc, rc = 0;
ENTRY;
+ req_capsule_init(&req->rq_pill, req, RCL_SERVER);
OBD_FAIL_TIMEOUT(OBD_FAIL_MGS_SLOW_REQUEST_NET, 2);
LASSERT(current->journal_info == NULL);
switch (opc) {
case MGS_CONNECT:
DEBUG_REQ(D_MGS, req, "connect");
+ /* MGS and MDS have same request format for connect */
+ req_capsule_set(&req->rq_pill, &RQF_MDS_CONNECT);
rc = target_handle_connect(req);
if (!rc && (lustre_msg_get_conn_cnt(req->rq_reqmsg) > 1))
/* Make clients trying to reconnect after a MGS restart
break;
case MGS_DISCONNECT:
DEBUG_REQ(D_MGS, req, "disconnect");
+ /* MGS and MDS have same request format for disconnect */
+ req_capsule_set(&req->rq_pill, &RQF_MDS_DISCONNECT);
rc = target_handle_disconnect(req);
req->rq_status = rc; /* superfluous? */
break;
case MGS_TARGET_REG:
DEBUG_REQ(D_MGS, req, "target add");
+ req_capsule_set(&req->rq_pill, &RQF_MGS_TARGET_REG);
rc = mgs_handle_target_reg(req);
break;
case MGS_TARGET_DEL:
//rc = mgs_handle_target_del(req);
break;
case MGS_SET_INFO:
+ DEBUG_REQ(D_MGS, req, "set_info");
+ req_capsule_set(&req->rq_pill, &RQF_MGS_SET_INFO);
rc = mgs_set_info_rpc(req);
break;
case LDLM_ENQUEUE:
DEBUG_REQ(D_MGS, req, "enqueue");
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_ENQUEUE);
rc = ldlm_handle_enqueue(req, ldlm_server_completion_ast,
ldlm_server_blocking_ast, NULL);
break;
case OBD_PING:
DEBUG_REQ(D_INFO, req, "ping");
+ req_capsule_set(&req->rq_pill, &RQF_OBD_PING);
rc = target_handle_ping(req);
break;
case OBD_LOG_CANCEL:
case LLOG_ORIGIN_HANDLE_CREATE:
DEBUG_REQ(D_MGS, req, "llog_init");
+ req_capsule_set(&req->rq_pill, &RQF_LLOG_ORIGIN_HANDLE_CREATE);
rc = llog_origin_handle_create(req);
break;
case LLOG_ORIGIN_HANDLE_NEXT_BLOCK:
DEBUG_REQ(D_MGS, req, "llog next block");
+ req_capsule_set(&req->rq_pill,
+ &RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK);
rc = llog_origin_handle_next_block(req);
break;
case LLOG_ORIGIN_HANDLE_READ_HEADER:
DEBUG_REQ(D_MGS, req, "llog read header");
+ req_capsule_set(&req->rq_pill,
+ &RQF_LLOG_ORIGIN_HANDLE_READ_HEADER);
rc = llog_origin_handle_read_header(req);
break;
case LLOG_ORIGIN_HANDLE_CLOSE:
break;
case LLOG_CATINFO:
DEBUG_REQ(D_MGS, req, "llog catinfo");
+ req_capsule_set(&req->rq_pill, &RQF_LLOG_CATINFO);
rc = llog_catinfo(req);
break;
default:
/* nonfatal */
CERROR("can't set %s %d\n", KEY_INIT_RECOV_BACKUP, rc);
/* We connect to the MGS at setup, and don't disconnect until cleanup */
+
+ ocd.ocd_connect_flags = OBD_CONNECT_VERSION | OBD_CONNECT_FID;
+ ocd.ocd_version = LUSTRE_VERSION_CODE;
+
rc = obd_connect(NULL, &mgc_conn, obd, &(obd->obd_uuid), &ocd);
if (rc) {
CERROR("connect failed %d\n", rc);
exp->exp_connect_flags = data->ocd_connect_flags;
data->ocd_version = LUSTRE_VERSION_CODE;
+ if ((exp->exp_connect_flags & OBD_CONNECT_FID) == 0) {
+ CWARN("%s: OST requires FID support (flag="LPX64
+ "), but client not\n",
+ exp->exp_obd->obd_name,
+ exp->exp_connect_flags);
+ RETURN(-EBADF);
+ }
+
if (exp->exp_connect_flags & OBD_CONNECT_GRANT) {
struct filter_export_data *fed = &exp->exp_filter_data;
obd_size left, want;
inode_init_lvb(dentry->d_inode, lvb);
- CDEBUG(D_DLMTRACE, "res: "LPU64" initial lvb size: "LPU64", "
- "mtime: "LPU64", blocks: "LPU64"\n",
+ CDEBUG(D_DLMTRACE, "res: "LPX64" initial lvb size: "LPX64", "
+ "mtime: "LPX64", blocks: "LPX64"\n",
res->lr_name.name[0], lvb->lvb_size,
lvb->lvb_mtime, lvb->lvb_blocks);
RETURN(lsm_size);
}
-static inline void osc_pack_capa(struct ptlrpc_request *req, int offset,
+static inline void osc_pack_capa(struct ptlrpc_request *req,
struct ost_body *body, void *capa)
{
struct obd_capa *oc = (struct obd_capa *)capa;
if (!capa)
return;
- c = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*c));
+ c = req_capsule_client_get(&req->rq_pill, &RMF_CAPA1);
LASSERT(c);
capa_cpy(c, oc);
body->oa.o_valid |= OBD_MD_FLOSSCAPA;
DEBUG_CAPA(D_SEC, c, "pack");
}
-static inline void osc_pack_req_body(struct ptlrpc_request *req, int offset,
+static inline void osc_pack_req_body(struct ptlrpc_request *req,
struct obd_info *oinfo)
{
struct ost_body *body;
- body = lustre_msg_buf(req->rq_reqmsg, offset, sizeof(*body));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY);
+ LASSERT(body);
+
body->oa = *oinfo->oi_oa;
- osc_pack_capa(req, offset + 1, body, oinfo->oi_capa);
+ osc_pack_capa(req, body, oinfo->oi_capa);
+}
+
+static inline void osc_set_capa_size(struct ptlrpc_request *req,
+ const struct req_msg_field *field,
+ struct obd_capa *oc)
+{
+ if (oc == NULL)
+ req_capsule_set_size(&req->rq_pill, field, RCL_CLIENT, 0);
+ else
+ /* it is already calculated as sizeof struct obd_capa */
+ ;
}
static int osc_getattr_interpret(struct ptlrpc_request *req,
aa->aa_oi->oi_oa->o_blksize = PTLRPC_MAX_BRW_SIZE;
aa->aa_oi->oi_oa->o_valid |= OBD_MD_FLBLKSZ;
} else {
- CERROR("can't unpack ost_body\n");
+ CDEBUG(D_INFO, "can't unpack ost_body\n");
rc = -EPROTO;
aa->aa_oi->oi_oa->o_valid = 0;
}
struct ptlrpc_request_set *set)
{
struct ptlrpc_request *req;
- struct ost_body *body;
- int size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) };
struct osc_async_args *aa;
+ int rc;
ENTRY;
- size[REQ_REC_OFF + 1] = oinfo->oi_capa ? sizeof(struct lustre_capa) : 0;
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION,
- OST_GETATTR, 3, size,NULL);
- if (!req)
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_GETATTR);
+ if (req == NULL)
RETURN(-ENOMEM);
- osc_pack_req_body(req, REQ_REC_OFF, oinfo);
+ osc_set_capa_size(req, &RMF_CAPA1, oinfo->oi_capa);
+ rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_GETATTR);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
- ptlrpc_req_set_repsize(req, 2, size);
+ osc_pack_req_body(req, oinfo);
+
+ ptlrpc_request_set_replen(req);
req->rq_interpret_reply = osc_getattr_interpret;
CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
aa->aa_oi = oinfo;
ptlrpc_set_add_req(set, req);
- RETURN (0);
+ RETURN(0);
}
static int osc_getattr(struct obd_export *exp, struct obd_info *oinfo)
{
struct ptlrpc_request *req;
- struct ost_body *body;
- int rc, size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) };
+ struct ost_body *body;
+ int rc;
ENTRY;
- size[REQ_REC_OFF + 1] = oinfo->oi_capa ? sizeof(struct lustre_capa) : 0;
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION,
- OST_GETATTR, 3, size, NULL);
- if (!req)
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_GETATTR);
+ if (req == NULL)
RETURN(-ENOMEM);
- osc_pack_req_body(req, REQ_REC_OFF, oinfo);
+ osc_set_capa_size(req, &RMF_CAPA1, oinfo->oi_capa);
+ rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_GETATTR);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
- ptlrpc_req_set_repsize(req, 2, size);
+ osc_pack_req_body(req, oinfo);
+ ptlrpc_request_set_replen(req);
+
rc = ptlrpc_queue_wait(req);
- if (rc) {
- CERROR("%s failed: rc = %d\n", __FUNCTION__, rc);
+ if (rc)
GOTO(out, rc);
- }
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_ost_body);
- if (body == NULL) {
- CERROR ("can't unpack ost_body\n");
- GOTO (out, rc = -EPROTO);
- }
+ body = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY);
+ if (body == NULL)
+ GOTO(out, rc = -EPROTO);
CDEBUG(D_INODE, "mode: %o\n", body->oa.o_mode);
*oinfo->oi_oa = body->oa;
struct obd_trans_info *oti)
{
struct ptlrpc_request *req;
- struct ost_body *body;
- int rc, size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) };
+ struct ost_body *body;
+ int rc;
ENTRY;
LASSERT(!(oinfo->oi_oa->o_valid & OBD_MD_FLGROUP) ||
oinfo->oi_oa->o_gr > 0);
- size[REQ_REC_OFF + 1] = oinfo->oi_capa ? sizeof(struct lustre_capa) : 0;
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION,
- OST_SETATTR, 3, size, NULL);
- if (!req)
+
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_SETATTR);
+ if (req == NULL)
RETURN(-ENOMEM);
- osc_pack_req_body(req, REQ_REC_OFF, oinfo);
+ osc_set_capa_size(req, &RMF_CAPA1, oinfo->oi_capa);
+ rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_SETATTR);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
+
+ osc_pack_req_body(req, oinfo);
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
+
rc = ptlrpc_queue_wait(req);
if (rc)
GOTO(out, rc);
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_ost_body);
+ body = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY);
if (body == NULL)
GOTO(out, rc = -EPROTO);
if (rc != 0)
GOTO(out, rc);
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_ost_body);
- if (body == NULL) {
- CERROR("can't unpack ost_body\n");
+ body = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY);
+ if (body == NULL)
GOTO(out, rc = -EPROTO);
- }
*aa->aa_oi->oi_oa = body->oa;
out:
struct ptlrpc_request_set *rqset)
{
struct ptlrpc_request *req;
- int size[3] = { sizeof(struct ptlrpc_body), sizeof(struct ost_body) };
struct osc_async_args *aa;
+ int rc;
ENTRY;
- size[REQ_REC_OFF + 1] = oinfo->oi_capa ? sizeof(struct lustre_capa) : 0;
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION,
- OST_SETATTR, 3, size, NULL);
- if (!req)
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_SETATTR);
+ if (req == NULL)
RETURN(-ENOMEM);
- osc_pack_req_body(req, REQ_REC_OFF, oinfo);
+ osc_set_capa_size(req, &RMF_CAPA1, oinfo->oi_capa);
+ rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_SETATTR);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
+
+ osc_pack_req_body(req, oinfo);
+
+ ptlrpc_request_set_replen(req);
+
if (oinfo->oi_oa->o_valid & OBD_MD_FLCOOKIE) {
LASSERT(oti);
*obdo_logcookie(oinfo->oi_oa) = *oti->oti_logcookies;
}
- ptlrpc_req_set_repsize(req, 2, size);
/* do mds to ost setattr asynchronouly */
if (!rqset) {
/* Do not wait for response. */
struct lov_stripe_md **ea, struct obd_trans_info *oti)
{
struct ptlrpc_request *req;
- struct ost_body *body;
- struct lov_stripe_md *lsm;
- int rc, size[2] = { sizeof(struct ptlrpc_body), sizeof(*body) };
+ struct ost_body *body;
+ struct lov_stripe_md *lsm;
+ int rc;
ENTRY;
LASSERT(oa);
RETURN(rc);
}
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION,
- OST_CREATE, 2, size, NULL);
- if (!req)
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_CREATE);
+ if (req == NULL)
GOTO(out, rc = -ENOMEM);
- body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body));
+ rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_CREATE);
+ if (rc) {
+ ptlrpc_request_free(req);
+ GOTO(out, rc);
+ }
+
+ body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY);
+ LASSERT(body);
body->oa = *oa;
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
+
if (oa->o_valid & OBD_MD_FLINLINE) {
LASSERT((oa->o_valid & OBD_MD_FLFLAGS) &&
oa->o_flags == OBD_FL_DELORPHAN);
if (rc)
GOTO(out_req, rc);
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_ost_body);
- if (body == NULL) {
- CERROR ("can't unpack ost_body\n");
- GOTO (out_req, rc = -EPROTO);
- }
+ body = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY);
+ if (body == NULL)
+ GOTO(out_req, rc = -EPROTO);
*oa = body->oa;
if (rc != 0)
GOTO(out, rc);
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof (*body),
- lustre_swab_ost_body);
- if (body == NULL) {
- CERROR ("can't unpack ost_body\n");
+ body = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY);
+ if (body == NULL)
GOTO(out, rc = -EPROTO);
- }
*aa->aa_oi->oi_oa = body->oa;
out:
{
struct ptlrpc_request *req;
struct osc_async_args *aa;
- struct ost_body *body;
- int size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) };
+ struct ost_body *body;
+ int rc;
ENTRY;
if (!oinfo->oi_oa) {
- CERROR("oa NULL\n");
+ CDEBUG(D_INFO, "oa NULL\n");
RETURN(-EINVAL);
}
- size[REQ_REC_OFF + 1] = oinfo->oi_capa? sizeof(struct lustre_capa) : 0;
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION,
- OST_PUNCH, 3, size, NULL);
- if (!req)
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_PUNCH);
+ if (req == NULL)
RETURN(-ENOMEM);
+ osc_set_capa_size(req, &RMF_CAPA1, oinfo->oi_capa);
+ rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_PUNCH);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
req->rq_request_portal = OST_IO_PORTAL; /* bug 7198 */
+ osc_pack_req_body(req, oinfo);
- osc_pack_req_body(req, REQ_REC_OFF, oinfo);
/* overload the size and blocks fields in the oa with start/end */
- body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY);
+ LASSERT(body);
body->oa.o_size = oinfo->oi_policy.l_extent.start;
body->oa.o_blocks = oinfo->oi_policy.l_extent.end;
body->oa.o_valid |= (OBD_MD_FLSIZE | OBD_MD_FLBLOCKS);
+ ptlrpc_request_set_replen(req);
- ptlrpc_req_set_repsize(req, 2, size);
req->rq_interpret_reply = osc_punch_interpret;
CLASSERT (sizeof(*aa) <= sizeof(req->rq_async_args));
void *capa)
{
struct ptlrpc_request *req;
- struct ost_body *body;
- int rc, size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) };
+ struct ost_body *body;
+ int rc;
ENTRY;
if (!oa) {
- CERROR("oa NULL\n");
+ CDEBUG(D_INFO, "oa NULL\n");
RETURN(-EINVAL);
}
- size[REQ_REC_OFF + 1] = capa ? sizeof(struct lustre_capa) : 0;
-
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION,
- OST_SYNC, 3, size, NULL);
- if (!req)
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_SYNC);
+ if (req == NULL)
RETURN(-ENOMEM);
+ osc_set_capa_size(req, &RMF_CAPA1, capa);
+ rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_SYNC);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
+
/* overload the size and blocks fields in the oa with start/end */
- body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY);
+ LASSERT(body);
body->oa = *oa;
body->oa.o_size = start;
body->oa.o_blocks = end;
body->oa.o_valid |= (OBD_MD_FLSIZE | OBD_MD_FLBLOCKS);
+ osc_pack_capa(req, body, capa);
- osc_pack_capa(req, REQ_REC_OFF + 1, body, capa);
-
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
if (rc)
GOTO(out, rc);
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_ost_body);
- if (body == NULL) {
- CERROR ("can't unpack ost_body\n");
- GOTO (out, rc = -EPROTO);
- }
+ body = req_capsule_server_get(&req->rq_pill, &RMF_OST_BODY);
+ if (body == NULL)
+ GOTO(out, rc = -EPROTO);
*oa = body->oa;
struct lov_stripe_md *ea, struct obd_trans_info *oti,
struct obd_export *md_export)
{
- CFS_LIST_HEAD(cancels);
+ struct client_obd *cli = &exp->exp_obd->u.cli;
struct ptlrpc_request *req;
- struct ost_body *body;
- int size[3] = { sizeof(struct ptlrpc_body), sizeof(*body), 0 };
- int count, bufcount = 2;
- struct client_obd *cli = &exp->exp_obd->u.cli;
+ struct ost_body *body;
+ CFS_LIST_HEAD(cancels);
+ int rc, count;
ENTRY;
if (!oa) {
- CERROR("oa NULL\n");
+ CDEBUG(D_INFO, "oa NULL\n");
RETURN(-EINVAL);
}
count = osc_resource_get_unused(exp, oa, &cancels, LCK_PW,
LDLM_FL_DISCARD_DATA);
- if (exp_connect_cancelset(exp) && count)
- bufcount = 3;
- req = ldlm_prep_elc_req(exp, LUSTRE_OST_VERSION, OST_DESTROY, bufcount,
- size, REQ_REC_OFF + 1, 0, &cancels, count);
- if (!req)
+
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp), &RQF_OST_DESTROY);
+ if (req == NULL) {
+ ldlm_lock_list_put(&cancels, l_bl_ast, count);
RETURN(-ENOMEM);
+ }
+
+ rc = ldlm_prep_elc_req(exp, req, LUSTRE_OST_VERSION, OST_DESTROY,
+ 0, &cancels, count);
+ if (rc) {
+ ldlm_lock_list_put(&cancels, l_bl_ast, count);
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
req->rq_request_portal = OST_IO_PORTAL; /* bug 7198 */
req->rq_interpret_reply = osc_destroy_interpret;
- body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body));
if (oti != NULL && oa->o_valid & OBD_MD_FLCOOKIE)
memcpy(obdo_logcookie(oa), oti->oti_logcookies,
sizeof(*oti->oti_logcookies));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_OST_BODY);
+ LASSERT(body);
body->oa = *oa;
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
if (!osc_can_send_destroy(cli)) {
struct l_wait_info lwi = { 0 };
remote_rcs = lustre_swab_repbuf(req, REQ_REC_OFF + 1,
sizeof(*remote_rcs) * niocount, NULL);
if (remote_rcs == NULL) {
- CERROR("Missing/short RC vector on BRW_WRITE reply\n");
+ CDEBUG(D_INFO, "Missing/short RC vector on BRW_WRITE reply\n");
return(-EPROTO);
}
if (lustre_msg_swabbed(req->rq_repmsg))
return(remote_rcs[i]);
if (remote_rcs[i] != 0) {
- CERROR("rc[%d] invalid (%d) req %p\n",
+ CDEBUG(D_INFO, "rc[%d] invalid (%d) req %p\n",
i, remote_rcs[i], req);
return(-EPROTO);
}
struct ost_body *body;
struct obd_ioobj *ioobj;
struct niobuf_remote *niobuf;
- int size[5] = { sizeof(struct ptlrpc_body), sizeof(*body) };
int niocount, i, requested_nob, opc, rc;
- struct ptlrpc_request_pool *pool;
- struct lustre_capa *capa;
struct osc_brw_async_args *aa;
+ struct req_capsule *pill;
ENTRY;
if (OBD_FAIL_CHECK(OBD_FAIL_OSC_BRW_PREP_REQ))
if ((cmd & OBD_BRW_WRITE) != 0) {
opc = OST_WRITE;
- pool = cli->cl_import->imp_rq_pool;
+ req = ptlrpc_request_alloc_pool(cli->cl_import,
+ cli->cl_import->imp_rq_pool,
+ &RQF_OST_BRW);
} else {
opc = OST_READ;
- pool = NULL;
+ req = ptlrpc_request_alloc(cli->cl_import, &RQF_OST_BRW);
}
+ if (req == NULL)
+ RETURN(-ENOMEM);
+
for (niocount = i = 1; i < page_count; i++) {
if (!can_merge_pages(pga[i - 1], pga[i]))
niocount++;
}
- size[REQ_REC_OFF + 1] = sizeof(*ioobj);
- size[REQ_REC_OFF + 2] = niocount * sizeof(*niobuf);
- if (ocapa)
- size[REQ_REC_OFF + 3] = sizeof(*capa);
-
- req = ptlrpc_prep_req_pool(cli->cl_import, LUSTRE_OST_VERSION, opc, 5,
- size, NULL, pool, NULL);
- if (req == NULL)
- RETURN (-ENOMEM);
+ pill = &req->rq_pill;
+ req_capsule_set_size(pill, &RMF_NIOBUF_REMOTE, RCL_CLIENT,
+ niocount * sizeof(*niobuf));
+ osc_set_capa_size(req, &RMF_CAPA1, ocapa);
+ rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, opc);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
req->rq_request_portal = OST_IO_PORTAL; /* bug 7198 */
if (opc == OST_WRITE)
- desc = ptlrpc_prep_bulk_imp (req, page_count,
- BULK_GET_SOURCE, OST_BULK_PORTAL);
+ desc = ptlrpc_prep_bulk_imp(req, page_count,
+ BULK_GET_SOURCE, OST_BULK_PORTAL);
else
- desc = ptlrpc_prep_bulk_imp (req, page_count,
- BULK_PUT_SINK, OST_BULK_PORTAL);
+ desc = ptlrpc_prep_bulk_imp(req, page_count,
+ BULK_PUT_SINK, OST_BULK_PORTAL);
+
if (desc == NULL)
GOTO(out, rc = -ENOMEM);
/* NB request now owns desc and will free it when it gets freed */
- body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body));
- ioobj = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF + 1, sizeof(*ioobj));
- niobuf = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF + 2,
- niocount * sizeof(*niobuf));
+ body = req_capsule_client_get(pill, &RMF_OST_BODY);
+ ioobj = req_capsule_client_get(pill, &RMF_OBD_IOOBJ);
+ niobuf = req_capsule_client_get(pill, &RMF_NIOBUF_REMOTE);
+ LASSERT(body && ioobj && niobuf);
body->oa = *oa;
obdo_to_ioobj(oa, ioobj);
ioobj->ioo_bufcnt = niocount;
- if (ocapa) {
- capa = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF + 3,
- sizeof(*capa));
- capa_cpy(capa, ocapa);
- body->oa.o_valid |= OBD_MD_FLOSSCAPA;
- }
-
+ osc_pack_capa(req, body, ocapa);
LASSERT (page_count > 0);
for (requested_nob = i = 0; i < page_count; i++, niobuf++) {
struct brw_page *pg = pga[i];
}
oa->o_cksum = body->oa.o_cksum;
/* 1 RC per niobuf */
- size[REPLY_REC_OFF + 1] = sizeof(__u32) * niocount;
- ptlrpc_req_set_repsize(req, 3, size);
+ req_capsule_set_size(pill, &RMF_NIOBUF_REMOTE, RCL_SERVER,
+ sizeof(__u32) * niocount);
} else {
if (unlikely(cli->cl_checksum) &&
req->rq_flvr.sf_bulk_csum == BULK_CSUM_ALG_NULL)
body->oa.o_valid |= OBD_MD_FLCKSUM;
+ req_capsule_set_size(pill, &RMF_NIOBUF_REMOTE, RCL_SERVER, 0);
/* 1 RC for the whole I/O */
- ptlrpc_req_set_repsize(req, 2, size);
}
+ ptlrpc_request_set_replen(req);
CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
aa = (struct osc_brw_async_args *)&req->rq_async_args;
INIT_LIST_HEAD(&aa->aa_oaps);
*reqp = req;
- RETURN (0);
+ RETURN(0);
out:
- ptlrpc_req_finished (req);
- RETURN (rc);
+ ptlrpc_req_finished(req);
+ RETURN(rc);
}
static int check_write_checksum(struct obdo *oa, const lnet_process_id_t *peer,
body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
lustre_swab_ost_body);
if (body == NULL) {
- CERROR ("Can't unpack body\n");
+ CDEBUG(D_INFO, "Can't unpack body\n");
RETURN(-EPROTO);
}
if (lustre_msg_get_opc(req->rq_reqmsg) == OST_WRITE) {
if (rc > 0) {
- CERROR ("Unexpected +ve rc %d\n", rc);
+ CERROR("Unexpected +ve rc %d\n", rc);
RETURN(-EPROTO);
}
LASSERT(req->rq_bulk->bd_nob == aa->aa_requested_nob);
/* The request was created before ldlm_cli_enqueue call. */
if (rc == ELDLM_LOCK_ABORTED) {
struct ldlm_reply *rep;
+ rep = req_capsule_server_get(&req->rq_pill,
+ &RMF_DLM_REP);
- /* swabbed by ldlm_cli_enqueue() */
- LASSERT(lustre_rep_swabbed(req, DLM_LOCKREPLY_OFF));
- rep = lustre_msg_buf(req->rq_repmsg, DLM_LOCKREPLY_OFF,
- sizeof(*rep));
LASSERT(rep != NULL);
if (rep->lock_policy_res1)
rc = rep->lock_policy_res1;
{
struct ldlm_res_id res_id = { .name = {0} };
struct obd_device *obd = exp->exp_obd;
- struct ldlm_reply *rep;
struct ptlrpc_request *req = NULL;
int intent = oinfo->oi_flags & LDLM_FL_HAS_INTENT;
ldlm_mode_t mode;
no_match:
if (intent) {
- int size[3] = {
- [MSG_PTLRPC_BODY_OFF] = sizeof(struct ptlrpc_body),
- [DLM_LOCKREQ_OFF] = sizeof(struct ldlm_request),
- [DLM_LOCKREQ_OFF + 1] = 0 };
-
- req = ldlm_prep_enqueue_req(exp, 2, size, NULL, 0);
+ CFS_LIST_HEAD(cancels);
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp),
+ &RQF_LDLM_ENQUEUE_LVB);
if (req == NULL)
RETURN(-ENOMEM);
- size[DLM_LOCKREPLY_OFF] = sizeof(*rep);
- size[DLM_REPLY_REC_OFF] =
- sizeof(oinfo->oi_md->lsm_oinfo[0]->loi_lvb);
- ptlrpc_req_set_repsize(req, 3, size);
+ rc = ldlm_prep_enqueue_req(exp, req, &cancels, 0);
+ if (rc)
+ RETURN(rc);
+
+ req_capsule_set_size(&req->rq_pill, &RMF_DLM_LVB, RCL_SERVER,
+ sizeof(oinfo->oi_md->lsm_oinfo[0]->loi_lvb));
+ ptlrpc_request_set_replen(req);
}
/* users of osc_enqueue() can pass this flag for ldlm_lock_match() */
if (rc != 0)
GOTO(out, rc);
- msfs = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*msfs),
- lustre_swab_obd_statfs);
+ msfs = req_capsule_server_get(&req->rq_pill, &RMF_OBD_STATFS);
if (msfs == NULL) {
- CERROR("Can't unpack obd_statfs\n");
GOTO(out, rc = -EPROTO);
}
- memcpy(aa->aa_oi->oi_osfs, msfs, sizeof(*msfs));
+ *aa->aa_oi->oi_osfs = *msfs;
out:
rc = aa->aa_oi->oi_cb_up(aa->aa_oi, rc);
RETURN(rc);
{
struct ptlrpc_request *req;
struct osc_async_args *aa;
- int size[2] = { sizeof(struct ptlrpc_body), sizeof(*oinfo->oi_osfs) };
+ int rc;
ENTRY;
/* We could possibly pass max_age in the request (as an absolute
* during mount that would help a bit). Having relative timestamps
* is not so great if request processing is slow, while absolute
* timestamps are not ideal because they need time synchronization. */
- req = ptlrpc_prep_req(obd->u.cli.cl_import, LUSTRE_OST_VERSION,
- OST_STATFS, 1, NULL, NULL);
- if (!req)
+ req = ptlrpc_request_alloc(obd->u.cli.cl_import, &RQF_OST_STATFS);
+ if (req == NULL)
RETURN(-ENOMEM);
- ptlrpc_req_set_repsize(req, 2, size);
+ rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_STATFS);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
+ ptlrpc_request_set_replen(req);
req->rq_request_portal = OST_CREATE_PORTAL; //XXX FIXME bug 249
req->rq_interpret_reply = osc_statfs_interpret;
static int osc_statfs(struct obd_device *obd, struct obd_statfs *osfs,
__u64 max_age)
{
- struct obd_statfs *msfs;
+ struct obd_statfs *msfs;
struct ptlrpc_request *req;
- int rc, size[2] = { sizeof(struct ptlrpc_body), sizeof(*osfs) };
+ int rc;
ENTRY;
/* We could possibly pass max_age in the request (as an absolute
* during mount that would help a bit). Having relative timestamps
* is not so great if request processing is slow, while absolute
* timestamps are not ideal because they need time synchronization. */
- req = ptlrpc_prep_req(obd->u.cli.cl_import, LUSTRE_OST_VERSION,
- OST_STATFS, 1, NULL, NULL);
- if (!req)
+ req = ptlrpc_request_alloc(obd->u.cli.cl_import, &RQF_OST_STATFS);
+ if (req == NULL)
RETURN(-ENOMEM);
- ptlrpc_req_set_repsize(req, 2, size);
+ rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_STATFS);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
+ ptlrpc_request_set_replen(req);
req->rq_request_portal = OST_CREATE_PORTAL; //XXX FIXME bug 249
rc = ptlrpc_queue_wait(req);
if (rc)
GOTO(out, rc);
- msfs = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*msfs),
- lustre_swab_obd_statfs);
+ msfs = req_capsule_server_get(&req->rq_pill, &RMF_OBD_STATFS);
if (msfs == NULL) {
- CERROR("Can't unpack obd_statfs\n");
GOTO(out, rc = -EPROTO);
}
- memcpy(osfs, msfs, sizeof(*osfs));
+ *osfs = *msfs;
EXIT;
out:
RETURN(0);
} else if (KEY_IS("last_id")) {
struct ptlrpc_request *req;
- obd_id *reply;
- char *bufs[2] = { NULL, key };
- int rc, size[2] = { sizeof(struct ptlrpc_body), keylen };
+ obd_id *reply;
+ char *tmp;
+ int rc;
- req = ptlrpc_prep_req(class_exp2cliimp(exp), LUSTRE_OST_VERSION,
- OST_GET_INFO, 2, size, bufs);
+ req = ptlrpc_request_alloc(class_exp2cliimp(exp),
+ &RQF_OST_GET_INFO);
if (req == NULL)
RETURN(-ENOMEM);
- size[REPLY_REC_OFF] = *vallen;
- ptlrpc_req_set_repsize(req, 2, size);
+ req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY,
+ RCL_CLIENT, keylen);
+ rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_GET_INFO);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
+
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY);
+ LASSERT(tmp);
+ memcpy(tmp, key, keylen);
+
+ req_capsule_set_size(&req->rq_pill, &RMF_OBD_ID,
+ RCL_SERVER, *vallen);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
if (rc)
GOTO(out, rc);
- reply = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*reply),
- lustre_swab_ost_last_id);
- if (reply == NULL) {
- CERROR("Can't unpack OST last ID\n");
+ reply = req_capsule_server_get(&req->rq_pill, &RMF_OBD_ID);
+ if (reply == NULL)
GOTO(out, rc = -EPROTO);
- }
+
*((obd_id *)val) = *reply;
out:
ptlrpc_req_finished(req);
struct ptlrpc_request_set *set)
{
struct ptlrpc_request *req;
- struct obd_device *obd = exp->exp_obd;
- struct obd_import *imp = class_exp2cliimp(exp);
- int size[3] = { sizeof(struct ptlrpc_body), keylen, vallen };
- char *bufs[3] = { NULL, key, val };
+ struct obd_device *obd = exp->exp_obd;
+ struct obd_import *imp = class_exp2cliimp(exp);
+ char *tmp;
+ int rc;
ENTRY;
OBD_FAIL_TIMEOUT(OBD_FAIL_OSC_SHUTDOWN, 10);
Even if something bad goes through, we'd get a -EINVAL from OST
anyway. */
- req = ptlrpc_prep_req(imp, LUSTRE_OST_VERSION, OST_SET_INFO, 3, size,
- bufs);
+
+ req = ptlrpc_request_alloc(imp, &RQF_OST_SET_INFO);
if (req == NULL)
RETURN(-ENOMEM);
+ req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_KEY,
+ RCL_CLIENT, keylen);
+ req_capsule_set_size(&req->rq_pill, &RMF_SETINFO_VAL,
+ RCL_CLIENT, vallen);
+ rc = ptlrpc_request_pack(req, LUSTRE_OST_VERSION, OST_SET_INFO);
+ if (rc) {
+ ptlrpc_request_free(req);
+ RETURN(rc);
+ }
+
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_KEY);
+ memcpy(tmp, key, keylen);
+ tmp = req_capsule_client_get(&req->rq_pill, &RMF_SETINFO_VAL);
+ memcpy(tmp, val, vallen);
+
if (KEY_IS(KEY_MDS_CONN)) {
struct osc_creator *oscc = &obd->u.cli.cl_oscc;
req->rq_interpret_reply = osc_setinfo_mds_conn_interpret;
}
- ptlrpc_req_set_repsize(req, 1, NULL);
+ ptlrpc_request_set_replen(req);
ptlrpc_set_add_req(set, req);
ptlrpc_check_set(set);
int rc;
ENTRY;
- oqctl = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*oqctl),
- lustre_swab_obd_quotactl);
+ oqctl = req_capsule_client_get(&req->rq_pill, &RMF_OBD_QUOTACTL);
if (oqctl == NULL)
RETURN(-EPROTO);
- rc = lustre_pack_reply(req, 1, NULL, NULL);
- if (rc)
- RETURN(rc);
+ rc = req_capsule_server_pack(&req->rq_pill);
+ if (rc) {
+ CERROR("ost: out of memory while packing quotacheck reply\n");
+ RETURN(-ENOMEM);
+ }
req->rq_status = obd_quotacheck(req->rq_export, oqctl);
RETURN(0);
return rc;
}
+/* TODO: handle requests in a similar way as MDT: see mdt_handle_common() */
int ost_handle(struct ptlrpc_request *req)
{
struct obd_trans_info trans_info = { 0, };
GOTO(out, rc = 0);
}
+ req_capsule_init(&req->rq_pill, req, RCL_SERVER);
+
/* XXX identical to MDS */
if (lustre_msg_get_opc(req->rq_reqmsg) != OST_CONNECT) {
int recovering;
switch (lustre_msg_get_opc(req->rq_reqmsg)) {
case OST_CONNECT: {
CDEBUG(D_INODE, "connect\n");
+ req_capsule_set(&req->rq_pill, &RQF_OST_CONNECT);
if (OBD_FAIL_CHECK(OBD_FAIL_OST_CONNECT_NET))
RETURN(0);
rc = target_handle_connect(req);
}
case OST_DISCONNECT:
CDEBUG(D_INODE, "disconnect\n");
+ req_capsule_set(&req->rq_pill, &RQF_OST_DISCONNECT);
if (OBD_FAIL_CHECK(OBD_FAIL_OST_DISCONNECT_NET))
RETURN(0);
rc = target_handle_disconnect(req);
break;
case OST_QUOTACHECK:
CDEBUG(D_INODE, "quotacheck\n");
+ req_capsule_set(&req->rq_pill, &RQF_OST_QUOTACHECK);
if (OBD_FAIL_CHECK(OBD_FAIL_OST_QUOTACHECK_NET))
RETURN(0);
rc = ost_handle_quotacheck(req);
break;
case OST_QUOTACTL:
CDEBUG(D_INODE, "quotactl\n");
+ req_capsule_set(&req->rq_pill, &RQF_OST_QUOTACTL);
if (OBD_FAIL_CHECK(OBD_FAIL_OST_QUOTACTL_NET))
RETURN(0);
rc = ost_handle_quotactl(req);
break;
case OBD_PING:
DEBUG_REQ(D_INODE, req, "ping");
+ req_capsule_set(&req->rq_pill, &RQF_OBD_PING);
rc = target_handle_ping(req);
break;
/* FIXME - just reply status */
case LLOG_ORIGIN_CONNECT:
DEBUG_REQ(D_INODE, req, "log connect");
+ req_capsule_set(&req->rq_pill, &RQF_LLOG_ORIGIN_CONNECT);
rc = ost_llog_handle_connect(req->rq_export, req);
req->rq_status = rc;
- rc = lustre_pack_reply(req, 1, NULL, NULL);
+ rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
RETURN(rc);
RETURN(ptlrpc_reply(req));
case OBD_LOG_CANCEL:
CDEBUG(D_INODE, "log cancel\n");
+ req_capsule_set(&req->rq_pill, &RQF_LOG_CANCEL);
if (OBD_FAIL_CHECK(OBD_FAIL_OBD_LOG_CANCEL_NET))
RETURN(0);
rc = llog_origin_handle_cancel(req);
req->rq_status = rc;
- rc = lustre_pack_reply(req, 1, NULL, NULL);
+ rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
RETURN(rc);
RETURN(ptlrpc_reply(req));
case LDLM_ENQUEUE:
CDEBUG(D_INODE, "enqueue\n");
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_ENQUEUE);
if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_ENQUEUE))
RETURN(0);
rc = ldlm_handle_enqueue(req, ldlm_server_completion_ast,
break;
case LDLM_CONVERT:
CDEBUG(D_INODE, "convert\n");
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_CONVERT);
if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CONVERT))
RETURN(0);
rc = ldlm_handle_convert(req);
break;
case LDLM_CANCEL:
CDEBUG(D_INODE, "cancel\n");
+ req_capsule_set(&req->rq_pill, &RQF_LDLM_CANCEL);
if (OBD_FAIL_CHECK(OBD_FAIL_LDLM_CANCEL))
RETURN(0);
rc = ldlm_handle_cancel(req);
#include <lustre_lib.h>
#include <lustre_ha.h>
#include <lustre_import.h>
+#include <lustre_req_layout.h>
#include "ptlrpc_internal.h"
return desc;
}
-struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_exp (struct ptlrpc_request *req,
- int npages, int type, int portal)
+struct ptlrpc_bulk_desc *ptlrpc_prep_bulk_exp(struct ptlrpc_request *req,
+ int npages, int type, int portal)
{
struct obd_export *exp = req->rq_export;
struct ptlrpc_bulk_desc *desc;
spin_unlock(&pool->prp_lock);
}
-struct ptlrpc_request *
-ptlrpc_prep_req_pool(struct obd_import *imp, __u32 version, int opcode,
- int count, int *lengths, char **bufs,
- struct ptlrpc_request_pool *pool,
- struct ptlrpc_cli_ctx *ctx)
+static int __ptlrpc_request_bufs_pack(struct ptlrpc_request *request,
+ __u32 version, int opcode,
+ int count, int *lengths, char **bufs,
+ struct ptlrpc_cli_ctx *ctx)
{
- struct ptlrpc_request *request = NULL;
- int rc;
+ struct obd_import *imp = request->rq_import;
+ int rc;
ENTRY;
- /* The obd disconnected */
- if (imp == NULL)
- return NULL;
-
- LASSERT(imp != LP_POISON);
- LASSERT((unsigned long)imp->imp_client > 0x1000);
- LASSERT(imp->imp_client != LP_POISON);
-
- if (pool)
- request = ptlrpc_prep_req_from_pool(pool);
-
- if (!request)
- OBD_ALLOC(request, sizeof(*request));
-
- if (!request) {
- CERROR("request allocation out of memory\n");
- RETURN(NULL);
- }
-
- request->rq_import = class_import_get(imp);
-
if (unlikely(ctx))
request->rq_cli_ctx = sptlrpc_cli_ctx_get(ctx);
else {
sptlrpc_req_set_flavor(request, opcode);
- rc = lustre_pack_request(request, imp->imp_msg_magic, count, lengths,
- bufs);
+ rc = lustre_pack_request(request, imp->imp_msg_magic, count,
+ lengths, bufs);
if (rc) {
LASSERT(!request->rq_pool);
GOTO(out_ctx, rc);
lustre_msg_set_opc(request->rq_reqmsg, opcode);
lustre_msg_set_flags(request->rq_reqmsg, 0);
- RETURN(request);
+ RETURN(0);
out_ctx:
sptlrpc_cli_ctx_put(request->rq_cli_ctx, 1);
out_free:
class_import_put(imp);
+ return rc;
+}
+
+int ptlrpc_request_bufs_pack(struct ptlrpc_request *request,
+ __u32 version, int opcode, char **bufs,
+ struct ptlrpc_cli_ctx *ctx)
+{
+ int count;
+
+ count = req_capsule_filled_sizes(&request->rq_pill, RCL_CLIENT);
+ return __ptlrpc_request_bufs_pack(request, version, opcode, count,
+ request->rq_pill.rc_area[RCL_CLIENT],
+ bufs, ctx);
+}
+
+int ptlrpc_request_pack(struct ptlrpc_request *request,
+ __u32 version, int opcode)
+{
+ return ptlrpc_request_bufs_pack(request, version, opcode, NULL, NULL);
+}
+
+static inline
+struct ptlrpc_request *__ptlrpc_request_alloc(struct obd_import *imp,
+ struct ptlrpc_request_pool *pool)
+{
+ struct ptlrpc_request *request = NULL;
+
+ if (pool)
+ request = ptlrpc_prep_req_from_pool(pool);
+
+ if (!request)
+ OBD_ALLOC_PTR(request);
+
+ if (request) {
+ LASSERT((unsigned long)imp > 0x1000);
+ LASSERT(imp != LP_POISON);
+ LASSERT((unsigned long)imp->imp_client > 0x1000);
+ LASSERT(imp->imp_client != LP_POISON);
+
+ request->rq_import = class_import_get(imp);
+ } else {
+ CERROR("request allocation out of memory\n");
+ }
+
+ return request;
+}
+
+static struct ptlrpc_request *
+ptlrpc_request_alloc_internal(struct obd_import *imp,
+ struct ptlrpc_request_pool * pool,
+ const struct req_format *format)
+{
+ struct ptlrpc_request *request;
+
+ request = __ptlrpc_request_alloc(imp, pool);
+ if (request == NULL)
+ return NULL;
+
+ req_capsule_init(&request->rq_pill, request, RCL_CLIENT);
+ req_capsule_set(&request->rq_pill, format);
+ return request;
+}
+
+struct ptlrpc_request *ptlrpc_request_alloc(struct obd_import *imp,
+ const struct req_format *format)
+{
+ return ptlrpc_request_alloc_internal(imp, NULL, format);
+}
+
+struct ptlrpc_request *ptlrpc_request_alloc_pool(struct obd_import *imp,
+ struct ptlrpc_request_pool * pool,
+ const struct req_format *format)
+{
+ return ptlrpc_request_alloc_internal(imp, pool, format);
+}
+
+void ptlrpc_request_free(struct ptlrpc_request *request)
+{
if (request->rq_pool)
__ptlrpc_free_req_to_pool(request);
else
- OBD_FREE(request, sizeof(*request));
- return NULL;
+ OBD_FREE_PTR(request);
+}
+
+struct ptlrpc_request *ptlrpc_request_alloc_pack(struct obd_import *imp,
+ const struct req_format *format,
+ __u32 version, int opcode)
+{
+ struct ptlrpc_request *req = ptlrpc_request_alloc(imp, format);
+ int rc;
+
+ if (req) {
+ rc = ptlrpc_request_pack(req, version, opcode);
+ if (rc) {
+ ptlrpc_request_free(req);
+ req = NULL;
+ }
+ }
+ return req;
+}
+
+struct ptlrpc_request *
+ptlrpc_prep_req_pool(struct obd_import *imp,
+ __u32 version, int opcode,
+ int count, int *lengths, char **bufs,
+ struct ptlrpc_request_pool *pool)
+{
+ struct ptlrpc_request *request;
+ int rc;
+
+ request = __ptlrpc_request_alloc(imp, pool);
+ if (!request)
+ return NULL;
+
+ rc = __ptlrpc_request_bufs_pack(request, version, opcode, count,
+ lengths, bufs, NULL);
+ if (rc) {
+ ptlrpc_request_free(request);
+ request = NULL;
+ }
+ return request;
}
struct ptlrpc_request *
int *lengths, char **bufs)
{
return ptlrpc_prep_req_pool(imp, version, opcode, count, lengths, bufs,
- NULL, NULL);
+ NULL);
}
struct ptlrpc_request_set *ptlrpc_prep_set(void)
LASSERTF(list_empty(&request->rq_set_chain), "req %p\n", request);
LASSERT(request->rq_cli_ctx);
+ req_capsule_fini(&request->rq_pill);
+
/* We must take it off the imp_replay_list first. Otherwise, we'll set
* request->rq_reqmsg to NULL while osc_close is dereferencing it. */
if (request->rq_import != NULL) {
struct obd_device *obd;
char obdname[64];
long lsize;
- int lmsg_size = sizeof(struct ptlrpc_body);
int rc;
if (count != sizeof(param)) {
/* force this import to use v2 msg */
imp->imp_msg_magic = LUSTRE_MSG_MAGIC_V2;
- req = ptlrpc_prep_req(imp, LUSTRE_OBD_VERSION, SEC_CTX_INIT,
- 1, &lmsg_size, NULL);
- if (!req) {
+ req = ptlrpc_request_alloc_pack(imp, &RQF_SEC_CTX, LUSTRE_OBD_VERSION,
+ SEC_CTX_INIT);
+ if (req == NULL) {
param.status = -ENOMEM;
goto out_copy;
}
goto out_copy;
}
- req->rq_replen = lustre_msg_size_v2(1, &lmsg_size);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
if (rc) {
struct obd_import *imp = ctx->cc_sec->ps_import;
struct ptlrpc_request *req;
struct ptlrpc_user_desc *pud;
- int buflens = sizeof(struct ptlrpc_body);
int rc;
ENTRY;
gctx->gc_proc = PTLRPC_GSS_PROC_DESTROY;
- req = ptlrpc_prep_req_pool(imp, LUSTRE_OBD_VERSION, SEC_CTX_FINI,
- 1, &buflens, NULL, NULL, ctx);
- if (!req) {
+ req = ptlrpc_request_alloc(imp, &RQF_SEC_CTX);
+ if (req == NULL) {
CWARN("ctx %p(%u): fail to prepare rpc, destroy locally\n",
ctx, ctx->cc_vcred.vc_uid);
GOTO(out, rc = -ENOMEM);
}
+ rc = ptlrpc_request_bufs_pack(req, LUSTRE_OBD_VERSION, SEC_CTX_FINI,
+ NULL, ctx);
+ if (rc) {
+ ptlrpc_request_free(req);
+ GOTO(out_ref, rc);
+ }
+
/* fix the user desc */
if (req->rq_pack_udesc) {
/* we rely the fact that this request is in AUTH mode,
struct obd_device *obd = imp->imp_obd;
int initial_connect = 0;
int set_transno = 0;
- int rc;
__u64 committed_before_reconnect = 0;
struct ptlrpc_request *request;
- int size[] = { sizeof(struct ptlrpc_body),
- sizeof(imp->imp_obd->u.cli.cl_target_uuid),
- sizeof(obd->obd_uuid),
- sizeof(imp->imp_dlm_handle),
- sizeof(imp->imp_connect_data) };
- char *tmp[] = { NULL,
- obd2cli_tgt(imp->imp_obd),
- obd->obd_uuid.uuid,
- (char *)&imp->imp_dlm_handle,
- (char *)&imp->imp_connect_data };
+ char *bufs[] = { NULL,
+ obd2cli_tgt(imp->imp_obd),
+ obd->obd_uuid.uuid,
+ (char *)&imp->imp_dlm_handle,
+ (char *)&imp->imp_connect_data };
struct ptlrpc_connect_async_args *aa;
+ int rc;
ENTRY;
spin_lock(&imp->imp_lock);
if (rc)
GOTO(out, rc);
- request = ptlrpc_prep_req(imp, LUSTRE_OBD_VERSION, imp->imp_connect_op,
- 5, size, tmp);
- if (!request)
+ request = ptlrpc_request_alloc(imp, &RQF_MDS_CONNECT);
+ if (request == NULL)
GOTO(out, rc = -ENOMEM);
+ rc = ptlrpc_request_bufs_pack(request, LUSTRE_OBD_VERSION,
+ imp->imp_connect_op, bufs, NULL);
+ if (rc) {
+ ptlrpc_request_free(request);
+ GOTO(out, rc);
+ }
+
#ifndef __KERNEL__
lustre_msg_add_op_flags(request->rq_reqmsg, MSG_CONNECT_LIBCLIENT);
#endif
request->rq_send_state = LUSTRE_IMP_CONNECTING;
/* Allow a slightly larger reply for future growth compatibility */
- size[REPLY_REC_OFF] = sizeof(struct obd_connect_data) +
- 16 * sizeof(__u64);
- ptlrpc_req_set_repsize(request, 2, size);
+ req_capsule_set_size(&request->rq_pill, &RMF_CONNECT_DATA, RCL_SERVER,
+ sizeof(struct obd_connect_data)+16*sizeof(__u64));
+ ptlrpc_request_set_replen(request);
request->rq_interpret_reply = ptlrpc_connect_interpret;
CLASSERT(sizeof (*aa) <= sizeof (request->rq_async_args));
} else {
struct obd_connect_data *ocd;
struct obd_export *exp;
-
- ocd = lustre_swab_repbuf(request, REPLY_REC_OFF, sizeof(*ocd),
- lustre_swab_connect);
+ int ret;
+ ret = req_capsule_get_size(&request->rq_pill, &RMF_CONNECT_DATA,
+ RCL_SERVER);
+ /* server replied obd_connect_data is always bigger */
+ ocd = req_capsule_server_sized_get(&request->rq_pill,
+ &RMF_CONNECT_DATA, ret);
spin_lock(&imp->imp_lock);
list_del(&imp->imp_conn_current->oic_item);
if (request->rq_repmsg == NULL)
RETURN(-EPROTO);
- ocd = lustre_swab_repbuf(request, REPLY_REC_OFF,
- sizeof *ocd,
- lustre_swab_connect);
+ ocd = req_capsule_server_get(&request->rq_pill,
+ &RMF_CONNECT_DATA);
if (ocd &&
(ocd->ocd_connect_flags & OBD_CONNECT_VERSION) &&
(ocd->ocd_version != LUSTRE_VERSION_CODE)) {
LASSERT(atomic_read(&imp->imp_replay_inflight) == 0);
atomic_inc(&imp->imp_replay_inflight);
- req = ptlrpc_prep_req(imp, LUSTRE_OBD_VERSION, OBD_PING, 1, NULL, NULL);
- if (!req) {
+ req = ptlrpc_request_alloc_pack(imp, &RQF_OBD_PING, LUSTRE_OBD_VERSION,
+ OBD_PING);
+ if (req == NULL) {
atomic_dec(&imp->imp_replay_inflight);
RETURN(-ENOMEM);
}
- ptlrpc_req_set_repsize(req, 1, NULL);
+ ptlrpc_request_set_replen(req);
req->rq_send_state = LUSTRE_IMP_REPLAY_WAIT;
lustre_msg_add_flags(req->rq_reqmsg,
MSG_LOCK_REPLAY_DONE | MSG_REQ_REPLAY_DONE);
spin_unlock(&imp->imp_lock);
- req = ptlrpc_prep_req(imp, LUSTRE_OBD_VERSION, rq_opc, 1, NULL, NULL);
+ req = ptlrpc_request_alloc_pack(imp, &RQF_MDS_DISCONNECT,
+ LUSTRE_OBD_VERSION, rq_opc);
if (req) {
/* We are disconnecting, do not retry a failed DISCONNECT rpc if
* it fails. We can get through the above with a down server
#endif
IMPORT_SET_STATE(imp, LUSTRE_IMP_CONNECTING);
req->rq_send_state = LUSTRE_IMP_CONNECTING;
- ptlrpc_req_set_repsize(req, 1, NULL);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
ptlrpc_req_finished(req);
}
&RMF_PTLRPC_BODY
};
+static const struct req_msg_field *mgs_target_info_only[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_MGS_TARGET_INFO
+};
+
+static const struct req_msg_field *mgs_set_info[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_MGS_SEND_PARAM
+};
+
+static const struct req_msg_field *log_cancel_client[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_LOGCOOKIES
+};
+
static const struct req_msg_field *mdt_body_only[] = {
&RMF_PTLRPC_BODY,
&RMF_MDT_BODY
&RMF_CAPA1
};
+static const struct req_msg_field *quotactl_only[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_OBD_QUOTACTL
+};
+
+static const struct req_msg_field *qunit_data_only[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_QUNIT_DATA
+};
+
static const struct req_msg_field *mdt_close_client[] = {
&RMF_PTLRPC_BODY,
&RMF_MDT_EPOCH,
- &RMF_REC_SETATTR,
+ &RMF_REC_REINT,
&RMF_CAPA1
};
-static const struct req_msg_field *mds_statfs_server[] = {
+static const struct req_msg_field *obd_statfs_server[] = {
&RMF_PTLRPC_BODY,
&RMF_OBD_STATFS
};
static const struct req_msg_field *mds_reint_client[] = {
&RMF_PTLRPC_BODY,
- &RMF_REINT_OPC
+ &RMF_REC_REINT
};
static const struct req_msg_field *mds_reint_create_client[] = {
&RMF_PTLRPC_BODY,
- &RMF_REC_CREATE,
+ &RMF_REC_REINT,
&RMF_CAPA1,
- &RMF_NAME,
+ &RMF_NAME
};
-static const struct req_msg_field *mds_reint_create_rmt_acl_client[] = {
+static const struct req_msg_field *mds_reint_create_slave_client[] = {
&RMF_PTLRPC_BODY,
- &RMF_REC_CREATE,
+ &RMF_REC_REINT,
&RMF_CAPA1,
&RMF_NAME,
&RMF_EADATA,
&RMF_DLM_REQ
};
-static const struct req_msg_field *mds_reint_create_sym_client[] = {
+static const struct req_msg_field *mds_reint_create_rmt_acl_client[] = {
&RMF_PTLRPC_BODY,
- &RMF_REC_CREATE,
+ &RMF_REC_REINT,
&RMF_CAPA1,
&RMF_NAME,
- &RMF_SYMTGT,
+ &RMF_EADATA,
&RMF_DLM_REQ
};
-static const struct req_msg_field *mds_reint_create_slave_client[] = {
+static const struct req_msg_field *mds_reint_create_sym_client[] = {
&RMF_PTLRPC_BODY,
- &RMF_REC_CREATE,
+ &RMF_REC_REINT,
&RMF_CAPA1,
&RMF_NAME,
- &RMF_EADATA
+ &RMF_SYMTGT,
+ &RMF_DLM_REQ
};
static const struct req_msg_field *mds_reint_open_client[] = {
&RMF_PTLRPC_BODY,
- &RMF_REC_CREATE,
+ &RMF_REC_REINT,
&RMF_CAPA1,
&RMF_CAPA2,
&RMF_NAME,
static const struct req_msg_field *mds_reint_unlink_client[] = {
&RMF_PTLRPC_BODY,
- &RMF_REC_UNLINK,
+ &RMF_REC_REINT,
&RMF_CAPA1,
&RMF_NAME,
&RMF_DLM_REQ
static const struct req_msg_field *mds_reint_link_client[] = {
&RMF_PTLRPC_BODY,
- &RMF_REC_LINK,
+ &RMF_REC_REINT,
&RMF_CAPA1,
&RMF_CAPA2,
&RMF_NAME,
static const struct req_msg_field *mds_reint_rename_client[] = {
&RMF_PTLRPC_BODY,
- &RMF_REC_RENAME,
+ &RMF_REC_REINT,
&RMF_CAPA1,
&RMF_CAPA2,
&RMF_NAME,
static const struct req_msg_field *mds_reint_setattr_client[] = {
&RMF_PTLRPC_BODY,
- &RMF_REC_SETATTR,
+ &RMF_REC_REINT,
&RMF_CAPA1,
&RMF_MDT_EPOCH,
&RMF_EADATA,
&RMF_DLM_REQ
};
-static const struct req_msg_field *mds_connect_client[] = {
+static const struct req_msg_field *mds_reint_setxattr_client[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_REC_REINT,
+ &RMF_CAPA1,
+ &RMF_NAME,
+ &RMF_EADATA
+};
+
+static const struct req_msg_field *obd_connect_client[] = {
&RMF_PTLRPC_BODY,
&RMF_TGTUUID,
&RMF_CLUUID,
&RMF_CONNECT_DATA
};
-static const struct req_msg_field *mds_connect_server[] = {
+static const struct req_msg_field *obd_connect_server[] = {
&RMF_PTLRPC_BODY,
&RMF_CONNECT_DATA
};
&RMF_DLM_REP
};
+static const struct req_msg_field *ldlm_enqueue_lvb_server[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_DLM_REP,
+ &RMF_DLM_LVB
+};
+
+static const struct req_msg_field *ldlm_cp_callback_client[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_DLM_REQ,
+ &RMF_DLM_LVB
+};
+
+static const struct req_msg_field *ldlm_gl_callback_server[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_DLM_LVB
+};
+
static const struct req_msg_field *ldlm_intent_client[] = {
&RMF_PTLRPC_BODY,
&RMF_DLM_REQ,
&RMF_LDLM_INTENT,
- &RMF_REINT_OPC
+ &RMF_REC_REINT
};
static const struct req_msg_field *ldlm_intent_server[] = {
&RMF_DLM_REP,
&RMF_MDT_BODY,
&RMF_MDT_MD,
- &RMF_ACL,
- &RMF_CAPA1
+ &RMF_ACL
};
static const struct req_msg_field *ldlm_intent_open_server[] = {
&RMF_NAME
};
+static const struct req_msg_field *ldlm_intent_getattr_server[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_DLM_REP,
+ &RMF_MDT_BODY,
+ &RMF_MDT_MD,
+ &RMF_ACL,
+ &RMF_CAPA1
+};
+
static const struct req_msg_field *ldlm_intent_create_client[] = {
&RMF_PTLRPC_BODY,
&RMF_DLM_REQ,
&RMF_LDLM_INTENT,
- &RMF_REC_CREATE, /* coincides with mds_reint_create_client[] */
+ &RMF_REC_REINT, /* coincides with mds_reint_create_client[] */
&RMF_CAPA1,
&RMF_NAME,
&RMF_EADATA
&RMF_PTLRPC_BODY,
&RMF_DLM_REQ,
&RMF_LDLM_INTENT,
- &RMF_REC_CREATE, /* coincides with mds_reint_open_client[] */
+ &RMF_REC_REINT, /* coincides with mds_reint_open_client[] */
&RMF_CAPA1,
&RMF_CAPA2,
&RMF_NAME,
- &RMF_EADATA
+ &RMF_EADATA,
+ &RMF_REC_JOINFILE
};
static const struct req_msg_field *ldlm_intent_unlink_client[] = {
&RMF_PTLRPC_BODY,
&RMF_DLM_REQ,
&RMF_LDLM_INTENT,
- &RMF_REC_UNLINK, /* coincides with mds_reint_unlink_client[] */
+ &RMF_REC_REINT, /* coincides with mds_reint_unlink_client[] */
&RMF_CAPA1,
&RMF_NAME
};
&RMF_EADATA
};
-static const struct req_msg_field *mds_setxattr_client[] = {
+static const struct req_msg_field *mds_getattr_server[] = {
&RMF_PTLRPC_BODY,
&RMF_MDT_BODY,
+ &RMF_MDT_MD,
+ &RMF_ACL,
&RMF_CAPA1,
+ &RMF_CAPA2
+};
+
+static const struct req_msg_field *mds_setattr_server[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_MDT_BODY,
+ &RMF_MDT_MD,
+ &RMF_ACL,
+ &RMF_CAPA1,
+ &RMF_CAPA2
+};
+
+static const struct req_msg_field *llog_catinfo_client[] = {
+ &RMF_PTLRPC_BODY,
&RMF_NAME,
+ &RMF_STRING
+};
+
+static const struct req_msg_field *llog_catinfo_server[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_STRING
+};
+
+static const struct req_msg_field *llog_origin_handle_create_client[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_LLOGD_BODY,
+ &RMF_NAME
+};
+
+static const struct req_msg_field *llogd_body_only[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_LLOGD_BODY
+};
+
+static const struct req_msg_field *llog_log_hdr_only[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_LLOG_LOG_HDR
+};
+
+static const struct req_msg_field *llogd_conn_body_only[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_LLOGD_CONN_BODY
+};
+
+static const struct req_msg_field *llog_origin_handle_next_block_server[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_LLOGD_BODY,
&RMF_EADATA
};
-static const struct req_msg_field *mds_setxattr_server[] = {
- &RMF_PTLRPC_BODY
+static const struct req_msg_field *ost_body_only[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_OST_BODY
};
-static const struct req_msg_field *mds_getattr_server[] = {
+static const struct req_msg_field *ost_body_capa[] = {
&RMF_PTLRPC_BODY,
- &RMF_MDT_BODY,
- &RMF_MDT_MD,
- &RMF_ACL,
+ &RMF_OST_BODY,
+ &RMF_CAPA1
+};
+
+static const struct req_msg_field *ost_destroy_client[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_OST_BODY,
+ &RMF_DLM_REQ
+};
+
+
+static const struct req_msg_field *ost_brw_client[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_OST_BODY,
+ &RMF_OBD_IOOBJ,
+ &RMF_NIOBUF_REMOTE,
&RMF_CAPA1
};
+static const struct req_msg_field *ost_brw_server[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_OST_BODY,
+ &RMF_NIOBUF_REMOTE
+};
+
+static const struct req_msg_field *ost_set_info_client[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_SETINFO_KEY,
+ &RMF_SETINFO_VAL
+};
+
+static const struct req_msg_field *ost_get_info_client[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_SETINFO_KEY
+};
+
+static const struct req_msg_field *ost_get_info_server[] = {
+ &RMF_PTLRPC_BODY,
+ &RMF_OBD_ID
+};
static const struct req_format *req_formats[] = {
+ &RQF_OBD_PING,
+ &RQF_SEC_CTX,
+ &RQF_SEQ_QUERY,
+ &RQF_FLD_QUERY,
+ &RQF_MGS_TARGET_REG,
+ &RQF_MGS_SET_INFO,
&RQF_MDS_CONNECT,
&RQF_MDS_DISCONNECT,
&RQF_MDS_SET_INFO,
&RQF_MDS_STATFS,
&RQF_MDS_GETATTR,
&RQF_MDS_GETATTR_NAME,
+ &RQF_MDS_GETXATTR,
+ &RQF_MDS_SYNC,
+ &RQF_MDS_CLOSE,
+ &RQF_MDS_PIN,
+ &RQF_MDS_UNPIN,
+ &RQF_MDS_READPAGE,
+ &RQF_MDS_WRITEPAGE,
+ &RQF_MDS_IS_SUBDIR,
+ &RQF_MDS_DONE_WRITING,
&RQF_MDS_REINT,
&RQF_MDS_REINT_CREATE,
&RQF_MDS_REINT_CREATE_RMT_ACL,
- &RQF_MDS_REINT_CREATE_SYM,
&RQF_MDS_REINT_CREATE_SLAVE,
+ &RQF_MDS_REINT_CREATE_SYM,
&RQF_MDS_REINT_OPEN,
&RQF_MDS_REINT_UNLINK,
&RQF_MDS_REINT_LINK,
&RQF_MDS_REINT_RENAME,
&RQF_MDS_REINT_SETATTR,
+ &RQF_MDS_REINT_SETXATTR,
+ &RQF_MDS_QUOTACHECK,
+ &RQF_MDS_QUOTACTL,
+ &RQF_MDS_QUOTA_DQACQ,
+ &RQF_OST_CONNECT,
+ &RQF_OST_DISCONNECT,
+ &RQF_OST_QUOTACHECK,
+ &RQF_OST_QUOTACTL,
+ &RQF_OST_GETATTR,
+ &RQF_OST_SETATTR,
+ &RQF_OST_CREATE,
+ &RQF_OST_PUNCH,
+ &RQF_OST_SYNC,
+ &RQF_OST_DESTROY,
+ &RQF_OST_BRW,
+ &RQF_OST_STATFS,
+ &RQF_OST_SET_INFO,
+ &RQF_OST_GET_INFO,
&RQF_LDLM_ENQUEUE,
+ &RQF_LDLM_ENQUEUE_LVB,
+ &RQF_LDLM_CONVERT,
+ &RQF_LDLM_CANCEL,
+ &RQF_LDLM_CALLBACK,
+ &RQF_LDLM_CP_CALLBACK,
+ &RQF_LDLM_BL_CALLBACK,
+ &RQF_LDLM_GL_CALLBACK,
&RQF_LDLM_INTENT,
&RQF_LDLM_INTENT_GETATTR,
&RQF_LDLM_INTENT_OPEN,
&RQF_LDLM_INTENT_CREATE,
&RQF_LDLM_INTENT_UNLINK,
- &RQF_SEQ_QUERY,
- &RQF_FLD_QUERY,
- &RQF_MDS_GETXATTR,
- &RQF_MDS_SETXATTR,
- &RQF_MDS_SYNC,
- &RQF_MDS_CLOSE,
- &RQF_MDS_PIN,
- &RQF_MDS_READPAGE,
- &RQF_MDS_WRITEPAGE,
- &RQF_MDS_IS_SUBDIR,
- &RQF_MDS_DONE_WRITING
+ &RQF_LOG_CANCEL,
+ &RQF_LLOG_CATINFO,
+ &RQF_LLOG_ORIGIN_HANDLE_CREATE,
+ &RQF_LLOG_ORIGIN_HANDLE_DESTROY,
+ &RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK,
+ &RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK,
+ &RQF_LLOG_ORIGIN_HANDLE_READ_HEADER,
+ &RQF_LLOG_ORIGIN_CONNECT
};
struct req_msg_field {
.rmf_swabber = (void (*)(void*))(swabber) \
}
+const struct req_msg_field RMF_MGS_TARGET_INFO =
+ DEFINE_MSGF("mgs_target_info", 0,
+ sizeof(struct mgs_target_info),
+ lustre_swab_mgs_target_info);
+EXPORT_SYMBOL(RMF_MGS_TARGET_INFO);
+
+const struct req_msg_field RMF_MGS_SEND_PARAM =
+ DEFINE_MSGF("mgs_send_param", 0,
+ sizeof(struct mgs_send_param),
+ NULL);
+EXPORT_SYMBOL(RMF_MGS_SEND_PARAM);
+
const struct req_msg_field RMF_SETINFO_VAL =
DEFINE_MSGF("setinfo_val", 0,
sizeof(__u32), lustre_swab_generic_32s);
sizeof(struct mdt_body), lustre_swab_mdt_body);
EXPORT_SYMBOL(RMF_MDT_BODY);
+const struct req_msg_field RMF_OBD_QUOTACTL =
+ DEFINE_MSGF("obd_quotactl", 0,
+ sizeof(struct obd_quotactl), lustre_swab_obd_quotactl);
+EXPORT_SYMBOL(RMF_OBD_QUOTACTL);
+
+const struct req_msg_field RMF_QUNIT_DATA =
+ DEFINE_MSGF("qunit_data", 0,
+ sizeof(struct qunit_data), NULL);
+EXPORT_SYMBOL(RMF_QUNIT_DATA);
+
const struct req_msg_field RMF_MDT_EPOCH =
DEFINE_MSGF("mdt_epoch", 0,
sizeof(struct mdt_epoch), lustre_swab_mdt_epoch);
DEFINE_MSGF("cluuid", RMF_F_STRING, sizeof(struct obd_uuid) - 1, NULL);
EXPORT_SYMBOL(RMF_CLUUID);
+const struct req_msg_field RMF_STRING =
+ DEFINE_MSGF("string", RMF_F_STRING, -1, NULL);
+EXPORT_SYMBOL(RMF_STRING);
+
+const struct req_msg_field RMF_LLOGD_BODY =
+ DEFINE_MSGF("llogd_body", 0,
+ sizeof(struct llogd_body), lustre_swab_llogd_body);
+EXPORT_SYMBOL(RMF_LLOGD_BODY);
+
+const struct req_msg_field RMF_LLOG_LOG_HDR =
+ DEFINE_MSGF("llog_log_hdr", 0,
+ sizeof(struct llog_log_hdr), lustre_swab_llog_hdr);
+EXPORT_SYMBOL(RMF_LLOG_LOG_HDR);
+
+const struct req_msg_field RMF_LLOGD_CONN_BODY =
+ DEFINE_MSGF("llogd_conn_body", 0,
+ sizeof(struct llogd_conn_body),
+ lustre_swab_llogd_conn_body);
+EXPORT_SYMBOL(RMF_LLOGD_CONN_BODY);
+
/*
* connection handle received in MDS_CONNECT request.
*
sizeof(struct ldlm_intent), lustre_swab_ldlm_intent);
EXPORT_SYMBOL(RMF_LDLM_INTENT);
+const struct req_msg_field RMF_DLM_LVB =
+ DEFINE_MSGF("dlm_lvb", 0, sizeof(struct ost_lvb), NULL);
+EXPORT_SYMBOL(RMF_DLM_LVB);
+
const struct req_msg_field RMF_MDT_MD =
- DEFINE_MSGF("mdt_md", 0, MIN_MD_SIZE, lustre_swab_lov_mds_md);
+ DEFINE_MSGF("mdt_md", 0, MIN_MD_SIZE, NULL);
EXPORT_SYMBOL(RMF_MDT_MD);
-const struct req_msg_field RMF_REC_UNLINK =
- DEFINE_MSGF("rec_unlink", 0, sizeof(struct mdt_rec_unlink),
- lustre_swab_mdt_rec_unlink);
-EXPORT_SYMBOL(RMF_REC_UNLINK);
-
-const struct req_msg_field RMF_REC_LINK =
- DEFINE_MSGF("rec_link", 0, sizeof(struct mdt_rec_link),
- lustre_swab_mdt_rec_link);
-EXPORT_SYMBOL(RMF_REC_LINK);
-
-const struct req_msg_field RMF_REC_RENAME =
- DEFINE_MSGF("rec_rename", 0, sizeof(struct mdt_rec_rename),
- lustre_swab_mdt_rec_rename);
-EXPORT_SYMBOL(RMF_REC_RENAME);
+const struct req_msg_field RMF_REC_REINT =
+ DEFINE_MSGF("rec_reint", 0, sizeof(struct mdt_rec_reint),
+ lustre_swab_mdt_rec_reint);
+EXPORT_SYMBOL(RMF_REC_REINT);
-const struct req_msg_field RMF_REC_CREATE =
- DEFINE_MSGF("rec_create", 0,
- sizeof(struct mdt_rec_create), lustre_swab_mdt_rec_create);
-EXPORT_SYMBOL(RMF_REC_CREATE);
-
-const struct req_msg_field RMF_REC_SETATTR =
- DEFINE_MSGF("rec_setattr", 0, sizeof(struct mdt_rec_setattr),
- lustre_swab_mdt_rec_setattr);
-EXPORT_SYMBOL(RMF_REC_SETATTR);
+const struct req_msg_field RMF_REC_JOINFILE =
+ DEFINE_MSGF("rec_joinfile", 0, sizeof(struct mdt_rec_join),
+ lustre_swab_mdt_rec_join);
+EXPORT_SYMBOL(RMF_REC_JOINFILE);
/* FIXME: this length should be defined as a macro */
const struct req_msg_field RMF_EADATA = DEFINE_MSGF("eadata", 0, -1, NULL);
DEFINE_MSGF("logcookies", 0, sizeof(struct llog_cookie), NULL);
EXPORT_SYMBOL(RMF_LOGCOOKIES);
-const struct req_msg_field RMF_REINT_OPC =
- DEFINE_MSGF("reint_opc", 0, sizeof(__u32), lustre_swab_generic_32s);
-EXPORT_SYMBOL(RMF_REINT_OPC);
-
const struct req_msg_field RMF_CAPA1 =
DEFINE_MSGF("capa", 0, sizeof(struct lustre_capa),
lustre_swab_lustre_capa);
lustre_swab_lustre_capa);
EXPORT_SYMBOL(RMF_CAPA2);
+/*
+ * OST request field.
+ */
+const struct req_msg_field RMF_OST_BODY =
+ DEFINE_MSGF("ost_body", 0,
+ sizeof(struct ost_body), lustre_swab_ost_body);
+EXPORT_SYMBOL(RMF_OST_BODY);
+
+const struct req_msg_field RMF_OBD_IOOBJ =
+ DEFINE_MSGF("obd_ioobj", 0,
+ sizeof(struct obd_ioobj), lustre_swab_obd_ioobj);
+EXPORT_SYMBOL(RMF_OBD_IOOBJ);
+
+const struct req_msg_field RMF_NIOBUF_REMOTE =
+ DEFINE_MSGF("niobuf_remote", 0, -1, lustre_swab_niobuf_remote);
+EXPORT_SYMBOL(RMF_NIOBUF_REMOTE);
+
+const struct req_msg_field RMF_OBD_ID =
+ DEFINE_MSGF("obd_id", 0,
+ sizeof(obd_id), lustre_swab_ost_last_id);
+EXPORT_SYMBOL(RMF_OBD_ID);
+
+
/*
* Request formats.
*/
} \
}
-#define DEFINE_REQ_FMT0(name, client, server) \
+#define DEFINE_REQ_FMT0(name, client, server) \
DEFINE_REQ_FMT(name, client, ARRAY_SIZE(client), server, ARRAY_SIZE(server))
+const struct req_format RQF_OBD_PING =
+ DEFINE_REQ_FMT0("OBD_PING", empty, empty);
+EXPORT_SYMBOL(RQF_OBD_PING);
+
+const struct req_format RQF_SEC_CTX =
+ DEFINE_REQ_FMT0("SEC_CTX", empty, empty);
+EXPORT_SYMBOL(RQF_SEC_CTX);
+
+const struct req_format RQF_MGS_TARGET_REG =
+ DEFINE_REQ_FMT0("MGS_TARGET_REG", mgs_target_info_only,
+ mgs_target_info_only);
+EXPORT_SYMBOL(RQF_MGS_TARGET_REG);
+
+const struct req_format RQF_MGS_SET_INFO =
+ DEFINE_REQ_FMT0("MGS_SET_INTO", mgs_set_info,
+ mgs_set_info);
+EXPORT_SYMBOL(RQF_MGS_SET_INFO);
+
+const struct req_format RQF_LOG_CANCEL =
+ DEFINE_REQ_FMT0("OBD_LOG_CANCEL", log_cancel_client, empty);
+EXPORT_SYMBOL(RQF_LOG_CANCEL);
+
+const struct req_format RQF_MDS_QUOTACHECK =
+ DEFINE_REQ_FMT0("MDS_QUOTACHECK", quotactl_only, empty);
+EXPORT_SYMBOL(RQF_MDS_QUOTACHECK);
+
+const struct req_format RQF_OST_QUOTACHECK =
+ DEFINE_REQ_FMT0("OST_QUOTACHECK", quotactl_only, empty);
+EXPORT_SYMBOL(RQF_OST_QUOTACHECK);
+
+const struct req_format RQF_MDS_QUOTACTL =
+ DEFINE_REQ_FMT0("MDS_QUOTACTL", quotactl_only, quotactl_only);
+EXPORT_SYMBOL(RQF_MDS_QUOTACTL);
+
+const struct req_format RQF_OST_QUOTACTL =
+ DEFINE_REQ_FMT0("OST_QUOTACTL", quotactl_only, quotactl_only);
+EXPORT_SYMBOL(RQF_OST_QUOTACTL);
+
+const struct req_format RQF_QC_CALLBACK =
+ DEFINE_REQ_FMT0("QC_CALLBACK", quotactl_only, empty);
+EXPORT_SYMBOL(RQF_QC_CALLBACK);
+
+const struct req_format RQF_MDS_QUOTA_DQACQ =
+ DEFINE_REQ_FMT0("MDS_QUOTA_DQACQ", qunit_data_only, qunit_data_only);
+EXPORT_SYMBOL(RQF_MDS_QUOTA_DQACQ);
+
const struct req_format RQF_SEQ_QUERY =
DEFINE_REQ_FMT0("SEQ_QUERY", seq_query_client, seq_query_server);
EXPORT_SYMBOL(RQF_SEQ_QUERY);
EXPORT_SYMBOL(RQF_FLD_QUERY);
const struct req_format RQF_MDS_GETSTATUS =
- DEFINE_REQ_FMT0("MDS_GETSTATUS", empty, mdt_body_capa);
+ DEFINE_REQ_FMT0("MDS_GETSTATUS", mdt_body_only, mdt_body_capa);
EXPORT_SYMBOL(RQF_MDS_GETSTATUS);
const struct req_format RQF_MDS_STATFS =
- DEFINE_REQ_FMT0("MDS_STATFS", empty, mds_statfs_server);
+ DEFINE_REQ_FMT0("MDS_STATFS", empty, obd_statfs_server);
EXPORT_SYMBOL(RQF_MDS_STATFS);
const struct req_format RQF_MDS_SYNC =
mds_getxattr_client, mds_getxattr_server);
EXPORT_SYMBOL(RQF_MDS_GETXATTR);
-const struct req_format RQF_MDS_SETXATTR =
- DEFINE_REQ_FMT0("MDS_SETXATTR",
- mds_setxattr_client, mds_setxattr_server);
-EXPORT_SYMBOL(RQF_MDS_SETXATTR);
-
const struct req_format RQF_MDS_GETATTR_NAME =
DEFINE_REQ_FMT0("MDS_GETATTR_NAME",
mds_getattr_name_client, mds_getattr_server);
EXPORT_SYMBOL(RQF_MDS_REINT_CREATE_RMT_ACL);
const struct req_format RQF_MDS_REINT_CREATE_SLAVE =
- DEFINE_REQ_FMT0("MDS_REINT_CREATE_SLAVE",
+ DEFINE_REQ_FMT0("MDS_REINT_CREATE_EA",
mds_reint_create_slave_client, mdt_body_capa);
EXPORT_SYMBOL(RQF_MDS_REINT_CREATE_SLAVE);
const struct req_format RQF_MDS_REINT_SETATTR =
DEFINE_REQ_FMT0("MDS_REINT_SETATTR",
- mds_reint_setattr_client, mdt_body_capa);
+ mds_reint_setattr_client, mds_setattr_server);
EXPORT_SYMBOL(RQF_MDS_REINT_SETATTR);
+const struct req_format RQF_MDS_REINT_SETXATTR =
+ DEFINE_REQ_FMT0("MDS_REINT_SETXATTR",
+ mds_reint_setxattr_client, mdt_body_only);
+EXPORT_SYMBOL(RQF_MDS_REINT_SETXATTR);
+
const struct req_format RQF_MDS_CONNECT =
DEFINE_REQ_FMT0("MDS_CONNECT",
- mds_connect_client, mds_connect_server);
+ obd_connect_client, obd_connect_server);
EXPORT_SYMBOL(RQF_MDS_CONNECT);
const struct req_format RQF_MDS_DISCONNECT =
DEFINE_REQ_FMT0("MDS_DISCONNECT", empty, empty);
EXPORT_SYMBOL(RQF_MDS_DISCONNECT);
-
+
const struct req_format RQF_MDS_SET_INFO =
DEFINE_REQ_FMT0("MDS_SET_INFO", mds_set_info_client, empty);
EXPORT_SYMBOL(RQF_MDS_SET_INFO);
const struct req_format RQF_LDLM_ENQUEUE =
DEFINE_REQ_FMT0("LDLM_ENQUEUE",
- ldlm_enqueue_client, ldlm_enqueue_server);
+ ldlm_enqueue_client, ldlm_enqueue_lvb_server);
EXPORT_SYMBOL(RQF_LDLM_ENQUEUE);
+const struct req_format RQF_LDLM_ENQUEUE_LVB =
+ DEFINE_REQ_FMT0("LDLM_ENQUEUE_LVB",
+ ldlm_enqueue_client, ldlm_enqueue_lvb_server);
+EXPORT_SYMBOL(RQF_LDLM_ENQUEUE_LVB);
+
+const struct req_format RQF_LDLM_CONVERT =
+ DEFINE_REQ_FMT0("LDLM_CONVERT",
+ ldlm_enqueue_client, ldlm_enqueue_server);
+EXPORT_SYMBOL(RQF_LDLM_CONVERT);
+
+const struct req_format RQF_LDLM_CANCEL =
+ DEFINE_REQ_FMT0("LDLM_CANCEL", ldlm_enqueue_client, empty);
+EXPORT_SYMBOL(RQF_LDLM_CANCEL);
+
+const struct req_format RQF_LDLM_CALLBACK =
+ DEFINE_REQ_FMT0("LDLM_CALLBACK", ldlm_enqueue_client, empty);
+EXPORT_SYMBOL(RQF_LDLM_CALLBACK);
+
+const struct req_format RQF_LDLM_CP_CALLBACK =
+ DEFINE_REQ_FMT0("LDLM_CP_CALLBACK", ldlm_cp_callback_client, empty);
+EXPORT_SYMBOL(RQF_LDLM_CP_CALLBACK);
+
+const struct req_format RQF_LDLM_BL_CALLBACK =
+ DEFINE_REQ_FMT0("LDLM_BL_CALLBACK", ldlm_enqueue_client, empty);
+EXPORT_SYMBOL(RQF_LDLM_BL_CALLBACK);
+
+const struct req_format RQF_LDLM_GL_CALLBACK =
+ DEFINE_REQ_FMT0("LDLM_GL_CALLBACK", ldlm_enqueue_client,
+ ldlm_gl_callback_server);
+EXPORT_SYMBOL(RQF_LDLM_GL_CALLBACK);
+
const struct req_format RQF_LDLM_INTENT =
DEFINE_REQ_FMT0("LDLM_INTENT",
ldlm_intent_client, ldlm_intent_server);
const struct req_format RQF_LDLM_INTENT_GETATTR =
DEFINE_REQ_FMT0("LDLM_INTENT_GETATTR",
- ldlm_intent_getattr_client, ldlm_intent_server);
+ ldlm_intent_getattr_client, ldlm_intent_getattr_server);
EXPORT_SYMBOL(RQF_LDLM_INTENT_GETATTR);
const struct req_format RQF_LDLM_INTENT_OPEN =
const struct req_format RQF_LDLM_INTENT_CREATE =
DEFINE_REQ_FMT0("LDLM_INTENT_CREATE",
- ldlm_intent_create_client, ldlm_intent_server);
+ ldlm_intent_create_client, ldlm_intent_getattr_server);
EXPORT_SYMBOL(RQF_LDLM_INTENT_CREATE);
const struct req_format RQF_LDLM_INTENT_UNLINK =
mdt_body_capa, mdt_body_only);
EXPORT_SYMBOL(RQF_MDS_PIN);
+const struct req_format RQF_MDS_UNPIN =
+ DEFINE_REQ_FMT0("MDS_UNPIN", mdt_body_only, empty);
+EXPORT_SYMBOL(RQF_MDS_UNPIN);
+
const struct req_format RQF_MDS_DONE_WRITING =
DEFINE_REQ_FMT0("MDS_DONE_WRITING",
mdt_close_client, mdt_body_only);
mdt_body_only, mdt_body_only);
EXPORT_SYMBOL(RQF_MDS_IS_SUBDIR);
+const struct req_format RQF_LLOG_CATINFO =
+ DEFINE_REQ_FMT0("LLOG_CATINFO",
+ llog_catinfo_client, llog_catinfo_server);
+EXPORT_SYMBOL(RQF_LLOG_CATINFO);
+
+const struct req_format RQF_LLOG_ORIGIN_HANDLE_CREATE =
+ DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_CREATE",
+ llog_origin_handle_create_client, llogd_body_only);
+EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_CREATE);
+
+const struct req_format RQF_LLOG_ORIGIN_HANDLE_DESTROY =
+ DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_DESTROY",
+ llogd_body_only, llogd_body_only);
+EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_DESTROY);
+
+const struct req_format RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK =
+ DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_NEXT_BLOCK",
+ llogd_body_only, llog_origin_handle_next_block_server);
+EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK);
+
+const struct req_format RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK =
+ DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_PREV_BLOCK",
+ llogd_body_only, llog_origin_handle_next_block_server);
+EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK);
+
+const struct req_format RQF_LLOG_ORIGIN_HANDLE_READ_HEADER =
+ DEFINE_REQ_FMT0("LLOG_ORIGIN_HANDLE_READ_HEADER",
+ llogd_body_only, llog_log_hdr_only);
+EXPORT_SYMBOL(RQF_LLOG_ORIGIN_HANDLE_READ_HEADER);
+
+const struct req_format RQF_LLOG_ORIGIN_CONNECT =
+ DEFINE_REQ_FMT0("LLOG_ORIGIN_CONNECT", llogd_conn_body_only, empty);
+EXPORT_SYMBOL(RQF_LLOG_ORIGIN_CONNECT);
+
+const struct req_format RQF_OST_CONNECT =
+ DEFINE_REQ_FMT0("OST_CONNECT",
+ obd_connect_client, obd_connect_server);
+EXPORT_SYMBOL(RQF_OST_CONNECT);
+
+const struct req_format RQF_OST_DISCONNECT =
+ DEFINE_REQ_FMT0("OST_DISCONNECT", empty, empty);
+EXPORT_SYMBOL(RQF_OST_DISCONNECT);
+
+const struct req_format RQF_OST_GETATTR =
+ DEFINE_REQ_FMT0("OST_GETATTR", ost_body_capa, ost_body_only);
+EXPORT_SYMBOL(RQF_OST_GETATTR);
+
+const struct req_format RQF_OST_SETATTR =
+ DEFINE_REQ_FMT0("OST_SETATTR", ost_body_capa, ost_body_only);
+EXPORT_SYMBOL(RQF_OST_SETATTR);
+
+const struct req_format RQF_OST_CREATE =
+ DEFINE_REQ_FMT0("OST_CREATE", ost_body_only, ost_body_only);
+EXPORT_SYMBOL(RQF_OST_CREATE);
+
+const struct req_format RQF_OST_PUNCH =
+ DEFINE_REQ_FMT0("OST_PUNCH", ost_body_capa, ost_body_only);
+EXPORT_SYMBOL(RQF_OST_PUNCH);
+
+const struct req_format RQF_OST_SYNC =
+ DEFINE_REQ_FMT0("OST_SYNC", ost_body_capa, ost_body_only);
+EXPORT_SYMBOL(RQF_OST_SYNC);
+
+const struct req_format RQF_OST_DESTROY =
+ DEFINE_REQ_FMT0("OST_DESTROY", ost_destroy_client, ost_body_only);
+EXPORT_SYMBOL(RQF_OST_DESTROY);
+
+const struct req_format RQF_OST_BRW =
+ DEFINE_REQ_FMT0("OST_BRW", ost_brw_client, ost_brw_server);
+EXPORT_SYMBOL(RQF_OST_BRW);
+
+const struct req_format RQF_OST_STATFS =
+ DEFINE_REQ_FMT0("OST_STATFS", empty, obd_statfs_server);
+EXPORT_SYMBOL(RQF_OST_STATFS);
+
+const struct req_format RQF_OST_SET_INFO =
+ DEFINE_REQ_FMT0("OST_SET_INFO", ost_set_info_client, empty);
+EXPORT_SYMBOL(RQF_OST_SET_INFO);
+
+const struct req_format RQF_OST_GET_INFO =
+ DEFINE_REQ_FMT0("OST_GET_INFO", ost_get_info_client,
+ ost_get_info_server);
+EXPORT_SYMBOL(RQF_OST_GET_INFO);
+
+
#if !defined(__REQ_LAYOUT_USER__)
int req_layout_init(void)
}
EXPORT_SYMBOL(req_layout_fini);
+void req_capsule_init_area(struct req_capsule *pill)
+{
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(pill->rc_area[RCL_CLIENT]); i++) {
+ pill->rc_area[RCL_CLIENT][i] = -1;
+ pill->rc_area[RCL_SERVER][i] = -1;
+ }
+}
+EXPORT_SYMBOL(req_capsule_init_area);
+
/*
* Initialize capsule.
*
* variable-sized fields.
*/
void req_capsule_init(struct req_capsule *pill,
- struct ptlrpc_request *req, enum req_location location,
- int *area)
+ struct ptlrpc_request *req,
+ enum req_location location)
{
LASSERT(location == RCL_SERVER || location == RCL_CLIENT);
memset(pill, 0, sizeof *pill);
pill->rc_req = req;
pill->rc_loc = location;
- pill->rc_area = area;
+ req_capsule_init_area(pill);
}
EXPORT_SYMBOL(req_capsule_init);
}
EXPORT_SYMBOL(req_capsule_set);
-int req_capsule_pack(struct req_capsule *pill)
+int req_capsule_filled_sizes(struct req_capsule *pill,
+ enum req_location loc)
{
- int i;
- int nr;
- int result;
- int total;
+ const struct req_format *fmt = pill->rc_fmt;
+ int i;
+
+ LASSERT(fmt != NULL);
+
+ for (i = 0; i < fmt->rf_fields[loc].nr; ++i) {
+ if (pill->rc_area[loc][i] == -1) {
+ pill->rc_area[loc][i] =
+ fmt->rf_fields[loc].d[i]->rmf_size;
+ if (pill->rc_area[loc][i] == -1) {
+ /* skip the following fields */
+ LASSERT(loc != RCL_SERVER);
+ break;
+ }
+ }
+ }
+ return i;
+}
+EXPORT_SYMBOL(req_capsule_filled_sizes);
+int req_capsule_server_pack(struct req_capsule *pill)
+{
const struct req_format *fmt;
+ int count;
+ int rc;
LASSERT(pill->rc_loc == RCL_SERVER);
fmt = pill->rc_fmt;
LASSERT(fmt != NULL);
- nr = fmt->rf_fields[RCL_SERVER].nr;
- for (total = 0, i = 0; i < nr; ++i) {
- int *size;
-
- size = &pill->rc_area[i];
- if (*size == -1) {
- *size = fmt->rf_fields[RCL_SERVER].d[i]->rmf_size;
- LASSERT(*size != -1);
- }
- total += *size;
- }
- result = lustre_pack_reply(pill->rc_req, nr, pill->rc_area, NULL);
- if (result != 0) {
+ count = req_capsule_filled_sizes(pill, RCL_SERVER);
+ rc = lustre_pack_reply(pill->rc_req, count,
+ pill->rc_area[RCL_SERVER], NULL);
+ if (rc != 0) {
DEBUG_REQ(D_ERROR, pill->rc_req,
- "Cannot pack %d fields (%d bytes) in format `%s': ",
- nr, total, fmt->rf_name);
+ "Cannot pack %d fields in format `%s': ",
+ count, fmt->rf_name);
}
- return result;
+ return rc;
}
-EXPORT_SYMBOL(req_capsule_pack);
+EXPORT_SYMBOL(req_capsule_server_pack);
static int __req_capsule_offset(const struct req_capsule *pill,
const struct req_msg_field *field,
int offset;
offset = field->rmf_offset[pill->rc_fmt->rf_idx][loc];
- LASSERT(offset > 0);
+ LASSERTF(offset > 0, "%s:%s, off=%d, loc=%d\n",
+ pill->rc_fmt->rf_name,
+ field->rmf_name, offset, loc);
offset --;
LASSERT(0 <= offset && offset < (sizeof(pill->rc_swabbed) << 3));
return offset;
static void *__req_capsule_get(struct req_capsule *pill,
const struct req_msg_field *field,
- enum req_location loc)
+ enum req_location loc,
+ void (*swabber)( void *))
{
const struct req_format *fmt;
struct lustre_msg *msg;
offset = __req_capsule_offset(pill, field, loc);
msg = __req_msg(pill, loc);
+ LASSERT(msg != NULL);
getter = (field->rmf_flags & RMF_F_STRING) ?
(typeof(getter))lustre_msg_string : lustre_msg_buf;
- len = max(field->rmf_size, 0);
+ if (pill->rc_area[loc][offset] != -1)
+ len = pill->rc_area[loc][offset];
+ else
+ len = max(field->rmf_size, 0);
value = getter(msg, offset, len);
+ swabber = swabber ?: field->rmf_swabber;
if (!(pill->rc_swabbed & (1 << offset)) && loc != pill->rc_loc &&
- field->rmf_swabber != NULL && value != NULL &&
+ swabber != NULL && value != NULL &&
lustre_msg_swabbed(msg)) {
- field->rmf_swabber(value);
+ swabber(value);
pill->rc_swabbed |= (1 << offset);
}
- if (value == NULL)
+ if (value == NULL) {
DEBUG_REQ(D_ERROR, pill->rc_req,
"Wrong buffer for field `%s' (%d of %d) "
"in format `%s': %d vs. %d (%s)\n",
field->rmf_name, offset, lustre_msg_bufcount(msg), fmt->rf_name,
- lustre_msg_buflen(msg, offset), field->rmf_size,
+ lustre_msg_buflen(msg, offset), len,
rcl_names[loc]);
+ }
return value;
}
void *req_capsule_client_get(struct req_capsule *pill,
const struct req_msg_field *field)
{
- return __req_capsule_get(pill, field, RCL_CLIENT);
+ return __req_capsule_get(pill, field, RCL_CLIENT, NULL);
}
EXPORT_SYMBOL(req_capsule_client_get);
+void *req_capsule_client_swab_get(struct req_capsule *pill,
+ const struct req_msg_field *field,
+ void (*swabber)(void* ))
+{
+ return __req_capsule_get(pill, field, RCL_CLIENT, swabber);
+}
+EXPORT_SYMBOL(req_capsule_client_swab_get);
+
+void *req_capsule_client_sized_get(struct req_capsule *pill,
+ const struct req_msg_field *field,
+ int len)
+{
+ req_capsule_set_size(pill, field, RCL_CLIENT, len);
+ return __req_capsule_get(pill, field, RCL_CLIENT, NULL);
+}
+EXPORT_SYMBOL(req_capsule_client_sized_get);
+
void *req_capsule_server_get(struct req_capsule *pill,
const struct req_msg_field *field)
{
- return __req_capsule_get(pill, field, RCL_SERVER);
+ return __req_capsule_get(pill, field, RCL_SERVER, NULL);
}
EXPORT_SYMBOL(req_capsule_server_get);
+void *req_capsule_server_swab_get(struct req_capsule *pill,
+ const struct req_msg_field *field,
+ void *swabber)
+{
+ return __req_capsule_get(pill, field, RCL_SERVER, swabber);
+}
+EXPORT_SYMBOL(req_capsule_server_swab_get);
+
+
+void *req_capsule_server_sized_get(struct req_capsule *pill,
+ const struct req_msg_field *field,
+ int len)
+{
+ req_capsule_set_size(pill, field, RCL_SERVER, len);
+ return __req_capsule_get(pill, field, RCL_SERVER, NULL);
+}
+EXPORT_SYMBOL(req_capsule_server_sized_get);
+
const void *req_capsule_other_get(struct req_capsule *pill,
const struct req_msg_field *field)
{
- return __req_capsule_get(pill, field, pill->rc_loc ^ 1);
+ return __req_capsule_get(pill, field, pill->rc_loc ^ 1, NULL);
}
EXPORT_SYMBOL(req_capsule_other_get);
-void req_capsule_set_size(const struct req_capsule *pill,
+void req_capsule_set_size(struct req_capsule *pill,
const struct req_msg_field *field,
enum req_location loc, int size)
{
- pill->rc_area[__req_capsule_offset(pill, field, loc)] = size;
+ LASSERT(loc == RCL_SERVER || loc == RCL_CLIENT);
+
+ pill->rc_area[loc][__req_capsule_offset(pill, field, loc)] = size;
}
EXPORT_SYMBOL(req_capsule_set_size);
+/* NB: this function doesn't correspond with req_capsule_set_size(), which
+ * actually sets the size in pill.rc_area[loc][offset], but this function
+ * returns the message buflen[offset], maybe we should use another name.
+ */
int req_capsule_get_size(const struct req_capsule *pill,
const struct req_msg_field *field,
enum req_location loc)
}
EXPORT_SYMBOL(req_capsule_field_present);
-
-/*
- * Shrink the specified reply message buffer @field to a specified @newlen.
- * If @move_data is non-zero, then move following buffer backward
- * if @newlen is zero;
- * The internal offset should be adjusted by @adjust because buffer maybe has
- * been moved by previous call. (@adjust >= 0) is a must.
- * Return value: 1 if buffer has been moved, otherwise 0 is returned.
- */
-int req_capsule_shrink(const struct req_capsule *pill,
- const struct req_msg_field *field,
- const unsigned int newlen,
- const int adjust,
- const int move_data)
+void req_capsule_shrink(struct req_capsule *pill,
+ const struct req_msg_field *field,
+ unsigned int newlen,
+ enum req_location loc)
{
- int offset;
+ const struct req_format *fmt;
+ struct lustre_msg *msg;
+ int len;
+ int offset;
- LASSERT(adjust >= 0);
- LASSERT(req_capsule_has_field(pill, field, RCL_SERVER));
+ fmt = pill->rc_fmt;
+ LASSERT(fmt != NULL);
+ LASSERT(__req_format_is_sane(fmt));
+ LASSERT(req_capsule_has_field(pill, field, loc));
+ LASSERT(req_capsule_field_present(pill, field, loc));
- offset = __req_capsule_offset(pill, field, RCL_SERVER);
- offset -= adjust;
- LASSERT(offset >= 1);
+ offset = __req_capsule_offset(pill, field, loc);
- lustre_shrink_reply(pill->rc_req, offset, newlen, move_data);
- return (newlen == 0) ? 1 : 0;
+ msg = __req_msg(pill, loc);
+ len = lustre_msg_buflen(msg, offset);
+ LASSERTF(newlen <= len, "%s:%s, oldlen=%d, newlen=%d\n",
+ fmt->rf_name, field->rmf_name, len, newlen);
+
+ if (loc == RCL_CLIENT)
+ pill->rc_req->rq_reqlen = lustre_shrink_msg(msg, offset, newlen,
+ 1);
+ else
+ pill->rc_req->rq_replen = lustre_shrink_msg(msg, offset, newlen,
+ 1);
}
EXPORT_SYMBOL(req_capsule_shrink);
static int llog_client_create(struct llog_ctxt *ctxt, struct llog_handle **res,
struct llog_logid *logid, char *name)
{
- struct obd_import *imp;
- struct llogd_body req_body;
- struct llogd_body *body;
- struct llog_handle *handle;
+ struct obd_import *imp;
+ struct llogd_body *body;
+ struct llog_handle *handle;
struct ptlrpc_request *req = NULL;
- int size[3] = { sizeof(struct ptlrpc_body), sizeof(req_body) };
- char *bufs[3] = { NULL, (char*)&req_body };
- int bufcount = 2;
- int rc;
+ int rc;
ENTRY;
if (ctxt->loc_imp == NULL) {
RETURN(-ENOMEM);
*res = handle;
- memset(&req_body, 0, sizeof(req_body));
+ req = ptlrpc_request_alloc(imp, &RQF_LLOG_ORIGIN_HANDLE_CREATE);
+ if (req == NULL)
+ GOTO(err_free, rc = -ENOMEM);
+
+ if (name)
+ req_capsule_set_size(&req->rq_pill, &RMF_NAME, RCL_CLIENT,
+ strlen(name) + 1);
+
+ rc = ptlrpc_request_pack(req, LUSTRE_LOG_VERSION,
+ LLOG_ORIGIN_HANDLE_CREATE);
+ if (rc) {
+ ptlrpc_request_free(req);
+ GOTO(err_free, rc);
+ }
+ ptlrpc_request_set_replen(req);
+
+ body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
if (logid)
- req_body.lgd_logid = *logid;
- req_body.lgd_ctxt_idx = ctxt->loc_idx - 1;
+ body->lgd_logid = *logid;
+ body->lgd_ctxt_idx = ctxt->loc_idx - 1;
if (name) {
- size[bufcount] = strlen(name) + 1;
- bufs[bufcount] = name;
- bufcount++;
+ char *tmp;
+ tmp = req_capsule_client_sized_get(&req->rq_pill, &RMF_NAME,
+ strlen(name) + 1);
+ LASSERT(tmp);
+ strcpy(tmp, name);
}
- req = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION,
- LLOG_ORIGIN_HANDLE_CREATE, bufcount, size, bufs);
- if (!req)
- GOTO(err_free, rc = -ENOMEM);
-
- ptlrpc_req_set_repsize(req, 2, size);
rc = ptlrpc_queue_wait(req);
if (rc)
GOTO(err_free, rc);
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_llogd_body);
- if (body == NULL) {
- CERROR ("Can't unpack llogd_body\n");
+ body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
+ if (body == NULL)
GOTO(err_free, rc =-EFAULT);
- }
handle->lgh_id = body->lgd_logid;
handle->lgh_ctxt = ctxt;
-
+ EXIT;
out:
- if (req)
- ptlrpc_req_finished(req);
- RETURN(rc);
-
+ ptlrpc_req_finished(req);
+ return rc;
err_free:
llog_free_handle(handle);
goto out;
static int llog_client_destroy(struct llog_handle *loghandle)
{
- struct obd_import *imp = loghandle->lgh_ctxt->loc_imp;
struct ptlrpc_request *req = NULL;
- struct llogd_body *body;
- int size[] = { sizeof(struct ptlrpc_body), sizeof(*body) };
- int rc;
+ struct llogd_body *body;
+ int rc;
ENTRY;
- req = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION,
- LLOG_ORIGIN_HANDLE_DESTROY, 2, size, NULL);
- if (!req)
+ req = ptlrpc_request_alloc_pack(loghandle->lgh_ctxt->loc_imp,
+ &RQF_LLOG_ORIGIN_HANDLE_DESTROY,
+ LUSTRE_LOG_VERSION,
+ LLOG_ORIGIN_HANDLE_DESTROY);
+ if (req == NULL)
RETURN(-ENOMEM);
- body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
body->lgd_logid = loghandle->lgh_id;
body->lgd_llh_flags = loghandle->lgh_hdr->llh_flags;
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
ptlrpc_req_finished(req);
int *cur_idx, int next_idx,
__u64 *cur_offset, void *buf, int len)
{
- struct obd_import *imp = loghandle->lgh_ctxt->loc_imp;
struct ptlrpc_request *req = NULL;
- struct llogd_body *body;
- void * ptr;
- int size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) };
- int rc;
+ struct llogd_body *body;
+ void *ptr;
+ int rc;
ENTRY;
- req = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION,
- LLOG_ORIGIN_HANDLE_NEXT_BLOCK, 2, size, NULL);
- if (!req)
- GOTO(out, rc = -ENOMEM);
+ req = ptlrpc_request_alloc_pack(loghandle->lgh_ctxt->loc_imp,
+ &RQF_LLOG_ORIGIN_HANDLE_NEXT_BLOCK,
+ LUSTRE_LOG_VERSION,
+ LLOG_ORIGIN_HANDLE_NEXT_BLOCK);
+ if (req == NULL)
+ RETURN(-ENOMEM);
- body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
body->lgd_logid = loghandle->lgh_id;
body->lgd_ctxt_idx = loghandle->lgh_ctxt->loc_idx - 1;
body->lgd_llh_flags = loghandle->lgh_hdr->llh_flags;
body->lgd_len = len;
body->lgd_cur_offset = *cur_offset;
- size[REPLY_REC_OFF + 1] = len;
- ptlrpc_req_set_repsize(req, 3, size);
+ req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER, len);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
if (rc)
GOTO(out, rc);
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_llogd_body);
- if (body == NULL) {
- CERROR ("Can't unpack llogd_body\n");
+ body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
+ if (body == NULL)
GOTO(out, rc =-EFAULT);
- }
/* The log records are swabbed as they are processed */
- ptr = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, len);
- if (ptr == NULL) {
- CERROR ("Can't unpack bitmap\n");
+ ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA);
+ if (ptr == NULL)
GOTO(out, rc =-EFAULT);
- }
*cur_idx = body->lgd_saved_index;
*cur_offset = body->lgd_cur_offset;
memcpy(buf, ptr, len);
-
+ EXIT;
out:
- if (req)
- ptlrpc_req_finished(req);
- RETURN(rc);
+ ptlrpc_req_finished(req);
+ return rc;
}
static int llog_client_prev_block(struct llog_handle *loghandle,
int prev_idx, void *buf, int len)
{
- struct obd_import *imp = loghandle->lgh_ctxt->loc_imp;
struct ptlrpc_request *req = NULL;
- struct llogd_body *body;
- void * ptr;
- int size[3] = { sizeof(struct ptlrpc_body), sizeof(*body) };
- int rc;
+ struct llogd_body *body;
+ void *ptr;
+ int rc;
ENTRY;
- req = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION,
- LLOG_ORIGIN_HANDLE_PREV_BLOCK, 2, size, NULL);
- if (!req)
- GOTO(out, rc = -ENOMEM);
+ req = ptlrpc_request_alloc_pack(loghandle->lgh_ctxt->loc_imp,
+ &RQF_LLOG_ORIGIN_HANDLE_PREV_BLOCK,
+ LUSTRE_LOG_VERSION,
+ LLOG_ORIGIN_HANDLE_PREV_BLOCK);
+ if (req == NULL)
+ RETURN(-ENOMEM);
- body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
body->lgd_logid = loghandle->lgh_id;
body->lgd_ctxt_idx = loghandle->lgh_ctxt->loc_idx - 1;
body->lgd_llh_flags = loghandle->lgh_hdr->llh_flags;
body->lgd_index = prev_idx;
body->lgd_len = len;
- size[REPLY_REC_OFF + 1] = len;
- ptlrpc_req_set_repsize(req, 3, size);
+ req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER, len);
+ ptlrpc_request_set_replen(req);
+
rc = ptlrpc_queue_wait(req);
if (rc)
GOTO(out, rc);
- body = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*body),
- lustre_swab_llogd_body);
- if (body == NULL) {
- CERROR ("Can't unpack llogd_body\n");
+ body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
+ if (body == NULL)
GOTO(out, rc =-EFAULT);
- }
- ptr = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, len);
- if (ptr == NULL) {
- CERROR ("Can't unpack bitmap\n");
+ ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA);
+ if (ptr == NULL)
GOTO(out, rc =-EFAULT);
- }
memcpy(buf, ptr, len);
-
+ EXIT;
out:
- if (req)
- ptlrpc_req_finished(req);
- RETURN(rc);
+ ptlrpc_req_finished(req);
+ return rc;
}
static int llog_client_read_header(struct llog_handle *handle)
{
- struct obd_import *imp = handle->lgh_ctxt->loc_imp;
struct ptlrpc_request *req = NULL;
- struct llogd_body *body;
- struct llog_log_hdr *hdr;
- struct llog_rec_hdr *llh_hdr;
- int size[2] = { sizeof(struct ptlrpc_body), sizeof(*body) };
- int repsize[2] = { sizeof(struct ptlrpc_body), sizeof(*hdr) };
- int rc;
+ struct llogd_body *body;
+ struct llog_log_hdr *hdr;
+ struct llog_rec_hdr *llh_hdr;
+ int rc;
ENTRY;
- req = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION,
- LLOG_ORIGIN_HANDLE_READ_HEADER, 2, size, NULL);
- if (!req)
- GOTO(out, rc = -ENOMEM);
+ req = ptlrpc_request_alloc_pack(handle->lgh_ctxt->loc_imp,
+ &RQF_LLOG_ORIGIN_HANDLE_READ_HEADER,
+ LUSTRE_LOG_VERSION,
+ LLOG_ORIGIN_HANDLE_READ_HEADER);
+ if (req == NULL)
+ RETURN(-ENOMEM);
- body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
body->lgd_logid = handle->lgh_id;
body->lgd_ctxt_idx = handle->lgh_ctxt->loc_idx - 1;
body->lgd_llh_flags = handle->lgh_hdr->llh_flags;
- ptlrpc_req_set_repsize(req, 2, repsize);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
if (rc)
GOTO(out, rc);
- hdr = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*hdr),
- lustre_swab_llog_hdr);
- if (hdr == NULL) {
- CERROR ("Can't unpack llog_hdr\n");
+ hdr = req_capsule_server_get(&req->rq_pill, &RMF_LLOG_LOG_HDR);
+ if (hdr == NULL)
GOTO(out, rc =-EFAULT);
- }
memcpy(handle->lgh_hdr, hdr, sizeof (*hdr));
handle->lgh_last_idx = handle->lgh_hdr->llh_tail.lrt_index;
CERROR("you may need to re-run lconf --write_conf.\n");
rc = -EIO;
}
-
+ EXIT;
out:
- if (req)
- ptlrpc_req_finished(req);
- RETURN(rc);
+ ptlrpc_req_finished(req);
+ return rc;
}
static int llog_client_close(struct llog_handle *handle)
struct llog_logid *logid, struct llog_gen *gen,
struct obd_uuid *uuid)
{
- struct llog_gen_rec *lgr;
- struct obd_import *imp;
- struct ptlrpc_request *request;
+ struct llog_gen_rec *lgr;
+ struct ptlrpc_request *req;
struct llogd_conn_body *req_body;
- int size[2] = { sizeof(struct ptlrpc_body),
- sizeof(struct llogd_conn_body) };
- int rc;
+ int rc;
ENTRY;
if (list_empty(&ctxt->loc_handle->u.chd.chd_head)) {
LLOG_GEN_INC(ctxt->loc_gen);
/* first add llog_gen_rec */
- OBD_ALLOC(lgr, sizeof(*lgr));
+ OBD_ALLOC_PTR(lgr);
if (!lgr)
RETURN(-ENOMEM);
lgr->lgr_hdr.lrh_len = lgr->lgr_tail.lrt_len = sizeof(*lgr);
lgr->lgr_hdr.lrh_type = LLOG_GEN_REC;
lgr->lgr_gen = ctxt->loc_gen;
rc = llog_add(ctxt, &lgr->lgr_hdr, NULL, NULL, 1);
- OBD_FREE(lgr, sizeof(*lgr));
+ OBD_FREE_PTR(lgr);
if (rc != 1)
RETURN(rc);
LASSERT(ctxt->loc_imp);
- imp = ctxt->loc_imp;
-
- request = ptlrpc_prep_req(imp, LUSTRE_LOG_VERSION,
- LLOG_ORIGIN_CONNECT, 2, size, NULL);
- if (!request)
+ req = ptlrpc_request_alloc_pack(ctxt->loc_imp, &RQF_LLOG_ORIGIN_CONNECT,
+ LUSTRE_LOG_VERSION,
+ LLOG_ORIGIN_CONNECT);
+ if (req == NULL)
RETURN(-ENOMEM);
- req_body = lustre_msg_buf(request->rq_reqmsg, REQ_REC_OFF,
- sizeof(*req_body));
-
+ req_body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_CONN_BODY);
req_body->lgdc_gen = ctxt->loc_gen;
req_body->lgdc_logid = ctxt->loc_handle->lgh_id;
req_body->lgdc_ctxt_idx = ctxt->loc_idx + 1;
- ptlrpc_req_set_repsize(request, 1, NULL);
+ ptlrpc_request_set_replen(req);
- rc = ptlrpc_queue_wait(request);
- ptlrpc_req_finished(request);
+ rc = ptlrpc_queue_wait(req);
+ ptlrpc_req_finished(req);
RETURN(rc);
}
int rc;
ENTRY;
- req_body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF,
- sizeof(*req_body));
+ req_body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_CONN_BODY);
ctxt = llog_get_context(obd, req_body->lgdc_ctxt_idx);
rc = llog_connect(ctxt, 1, &req_body->lgdc_logid,
int llog_origin_handle_create(struct ptlrpc_request *req)
{
- struct obd_export *exp = req->rq_export;
- struct obd_device *obd = exp->exp_obd;
- struct obd_device *disk_obd;
- struct llog_handle *loghandle;
- struct llogd_body *body;
- struct lvfs_run_ctxt saved;
- struct llog_logid *logid = NULL;
- struct llog_ctxt *ctxt;
- char * name = NULL;
- int size[2] = { sizeof(struct ptlrpc_body), sizeof(*body) };
- int rc, rc2;
+ struct obd_export *exp = req->rq_export;
+ struct obd_device *obd = exp->exp_obd;
+ struct obd_device *disk_obd;
+ struct llog_handle *loghandle;
+ struct llogd_body *body;
+ struct lvfs_run_ctxt saved;
+ struct llog_logid *logid = NULL;
+ struct llog_ctxt *ctxt;
+ char *name = NULL;
+ int rc, rc2;
ENTRY;
- body = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*body),
- lustre_swab_llogd_body);
- if (body == NULL) {
- CERROR ("Can't unpack llogd_body\n");
+ body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
+ if (body == NULL)
GOTO(out, rc =-EFAULT);
- }
if (body->lgd_logid.lgl_oid > 0)
logid = &body->lgd_logid;
- if (lustre_msg_bufcount(req->rq_reqmsg) > 2) {
- name = lustre_msg_string(req->rq_reqmsg, REQ_REC_OFF + 1, 0);
- if (name == NULL) {
- CERROR("Can't unpack name\n");
+ if (req_capsule_field_present(&req->rq_pill, &RMF_NAME, RCL_CLIENT)) {
+ name = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
+ if (name == NULL)
GOTO(out, rc = -EFAULT);
- }
CDEBUG(D_INFO, "opening log %s\n", name);
}
if (rc)
GOTO(out_pop, rc);
- rc = lustre_pack_reply(req, 2, size, NULL);
+ rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out_close, rc = -ENOMEM);
- body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*body));
+ body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
body->lgd_logid = loghandle->lgh_id;
out_close:
int llog_origin_handle_destroy(struct ptlrpc_request *req)
{
- struct obd_export *exp = req->rq_export;
- struct obd_device *obd = exp->exp_obd;
- struct obd_device *disk_obd;
- struct llog_handle *loghandle;
- struct llogd_body *body;
- struct lvfs_run_ctxt saved;
- struct llog_logid *logid = NULL;
- struct llog_ctxt *ctxt;
- int size[] = { sizeof(struct ptlrpc_body), sizeof(*body) };
- int rc;
- __u32 flags;
+ struct obd_export *exp = req->rq_export;
+ struct obd_device *obd = exp->exp_obd;
+ struct obd_device *disk_obd;
+ struct llog_handle *loghandle;
+ struct llogd_body *body;
+ struct lvfs_run_ctxt saved;
+ struct llog_logid *logid = NULL;
+ struct llog_ctxt *ctxt;
+ __u32 flags;
+ int rc;
ENTRY;
- body = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*body),
- lustre_swab_llogd_body);
- if (body == NULL) {
- CERROR ("Can't unpack llogd_body\n");
+ body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
+ if (body == NULL)
GOTO(out, rc =-EFAULT);
- }
if (body->lgd_logid.lgl_oid > 0)
logid = &body->lgd_logid;
if (rc)
GOTO(out_pop, rc);
- rc = lustre_pack_reply(req, 2, size, NULL);
+ rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out_close, rc = -ENOMEM);
- body = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof (*body));
+ body = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
body->lgd_logid = loghandle->lgh_id;
flags = body->lgd_llh_flags;
rc = llog_init_handle(loghandle, LLOG_F_IS_PLAIN, NULL);
int llog_origin_handle_next_block(struct ptlrpc_request *req)
{
- struct obd_export *exp = req->rq_export;
- struct obd_device *obd = exp->exp_obd;
- struct obd_device *disk_obd;
+ struct obd_export *exp = req->rq_export;
+ struct obd_device *obd = exp->exp_obd;
+ struct obd_device *disk_obd;
struct llog_handle *loghandle;
- struct llogd_body *body;
+ struct llogd_body *body;
+ struct llogd_body *repbody;
struct lvfs_run_ctxt saved;
- struct llog_ctxt *ctxt;
- __u32 flags;
- __u8 *buf;
- void * ptr;
- int size[3] = { sizeof(struct ptlrpc_body),
- sizeof(*body),
- LLOG_CHUNK_SIZE };
- int rc, rc2;
+ struct llog_ctxt *ctxt;
+ __u32 flags;
+ __u8 *buf;
+ void *ptr;
+ int rc, rc2;
ENTRY;
- body = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*body),
- lustre_swab_llogd_body);
- if (body == NULL) {
- CERROR ("Can't unpack llogd_body\n");
+ body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
+ if (body == NULL)
GOTO(out, rc =-EFAULT);
- }
OBD_ALLOC(buf, LLOG_CHUNK_SIZE);
if (!buf)
if (rc)
GOTO(out_close, rc);
-
- rc = lustre_pack_reply(req, 3, size, NULL);
+ req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER,
+ LLOG_CHUNK_SIZE);
+ rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out_close, rc = -ENOMEM);
- ptr = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof (body));
- memcpy(ptr, body, sizeof(*body));
+ repbody = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
+ *repbody = *body;
- ptr = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF + 1, LLOG_CHUNK_SIZE);
+ ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA);
memcpy(ptr, buf, LLOG_CHUNK_SIZE);
out_close:
int llog_origin_handle_prev_block(struct ptlrpc_request *req)
{
- struct obd_export *exp = req->rq_export;
- struct obd_device *obd = exp->exp_obd;
- struct llog_handle *loghandle;
- struct llogd_body *body;
- struct obd_device *disk_obd;
- struct lvfs_run_ctxt saved;
- struct llog_ctxt *ctxt;
- __u32 flags;
- __u8 *buf;
- void * ptr;
- int size[] = { sizeof(struct ptlrpc_body),
- sizeof(*body),
- LLOG_CHUNK_SIZE };
- int rc, rc2;
+ struct obd_export *exp = req->rq_export;
+ struct obd_device *obd = exp->exp_obd;
+ struct llog_handle *loghandle;
+ struct llogd_body *body;
+ struct llogd_body *repbody;
+ struct obd_device *disk_obd;
+ struct lvfs_run_ctxt saved;
+ struct llog_ctxt *ctxt;
+ __u32 flags;
+ __u8 *buf;
+ void *ptr;
+ int rc, rc2;
ENTRY;
- body = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*body),
- lustre_swab_llogd_body);
- if (body == NULL) {
- CERROR ("Can't unpack llogd_body\n");
+ body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
+ if (body == NULL)
GOTO(out, rc =-EFAULT);
- }
OBD_ALLOC(buf, LLOG_CHUNK_SIZE);
if (!buf)
if (rc)
GOTO(out_close, rc);
-
- rc = lustre_pack_reply(req, 3, size, NULL);
+ req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_SERVER,
+ LLOG_CHUNK_SIZE);
+ rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out_close, rc = -ENOMEM);
- ptr = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(body));
- memcpy(ptr, body, sizeof(*body));
+ repbody = req_capsule_server_get(&req->rq_pill, &RMF_LLOGD_BODY);
+ *repbody = *body;
- ptr = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF+1, LLOG_CHUNK_SIZE);
+ ptr = req_capsule_server_get(&req->rq_pill, &RMF_EADATA);
memcpy(ptr, buf, LLOG_CHUNK_SIZE);
out_close:
int llog_origin_handle_read_header(struct ptlrpc_request *req)
{
- struct obd_export *exp = req->rq_export;
- struct obd_device *obd = exp->exp_obd;
- struct obd_device *disk_obd;
- struct llog_handle *loghandle;
- struct llogd_body *body;
- struct llog_log_hdr *hdr;
- struct lvfs_run_ctxt saved;
- struct llog_ctxt *ctxt;
- __u32 flags;
- int size[2] = { sizeof(struct ptlrpc_body), sizeof(*hdr) };
- int rc, rc2;
+ struct obd_export *exp = req->rq_export;
+ struct obd_device *obd = exp->exp_obd;
+ struct obd_device *disk_obd;
+ struct llog_handle *loghandle;
+ struct llogd_body *body;
+ struct llog_log_hdr *hdr;
+ struct lvfs_run_ctxt saved;
+ struct llog_ctxt *ctxt;
+ __u32 flags;
+ int rc, rc2;
ENTRY;
- body = lustre_swab_reqbuf(req, REQ_REC_OFF, sizeof(*body),
- lustre_swab_llogd_body);
- if (body == NULL) {
- CERROR ("Can't unpack llogd_body\n");
+ body = req_capsule_client_get(&req->rq_pill, &RMF_LLOGD_BODY);
+ if (body == NULL)
GOTO(out, rc =-EFAULT);
- }
ctxt = llog_get_context(obd, body->lgd_ctxt_idx);
if (ctxt == NULL)
if (rc)
GOTO(out_close, rc);
- rc = lustre_pack_reply(req, 2, size, NULL);
+ rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out_close, rc = -ENOMEM);
- hdr = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, sizeof(*hdr));
- memcpy(hdr, loghandle->lgh_hdr, sizeof(*hdr));
+ hdr = req_capsule_server_get(&req->rq_pill, &RMF_LLOG_LOG_HDR);
+ *hdr = *loghandle->lgh_hdr;
out_close:
rc2 = llog_close(loghandle);
void *handle;
ENTRY;
- logcookies = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF,
- sizeof(*logcookies));
- num_cookies = lustre_msg_buflen(req->rq_reqmsg, REQ_REC_OFF) /
- sizeof(*logcookies);
+ logcookies = req_capsule_client_get(&req->rq_pill, &RMF_LOGCOOKIES);
+ num_cookies = req_capsule_get_size(&req->rq_pill, &RMF_LOGCOOKIES,
+ RCL_CLIENT) / sizeof(*logcookies);
if (logcookies == NULL || num_cookies == 0) {
DEBUG_REQ(D_HA, req, "no cookies sent");
RETURN(-EFAULT);
static int llog_catinfo_config(struct obd_device *obd, char *buf, int buf_len,
char *client)
{
- struct mds_obd *mds = &obd->u.mds;
- struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
- struct lvfs_run_ctxt saved;
- struct llog_handle *handle = NULL;
- char name[4][64];
- int rc, i, l, remains = buf_len;
- char *out = buf;
+ struct mds_obd *mds = &obd->u.mds;
+ struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
+ struct lvfs_run_ctxt saved;
+ struct llog_handle *handle = NULL;
+ char name[4][64];
+ int rc, i, l, remains = buf_len;
+ char *out = buf;
if (ctxt == NULL || mds == NULL)
RETURN(-EOPNOTSUPP);
struct llog_catid *idarray;
struct llog_logid *id;
char name[32] = CATLIST;
- int rc;
struct cb_data data;
struct llog_ctxt *ctxt = llog_get_context(obd, LLOG_CONFIG_ORIG_CTXT);
+ int rc;
if (ctxt == NULL || mds == NULL)
RETURN(-EOPNOTSUPP);
{
struct obd_export *exp = req->rq_export;
struct obd_device *obd = exp->exp_obd;
- char *keyword;
- char *buf, *reply;
- int rc, buf_len = LLOG_CHUNK_SIZE;
- int size[2] = { sizeof(struct ptlrpc_body), buf_len };
+ char *keyword;
+ char *buf, *reply;
+ int rc;
- OBD_ALLOC(buf, buf_len);
+ OBD_ALLOC(buf, LLOG_CHUNK_SIZE);
if (buf == NULL)
return -ENOMEM;
- memset(buf, 0, buf_len);
+ memset(buf, 0, LLOG_CHUNK_SIZE);
- keyword = lustre_msg_string(req->rq_reqmsg, REQ_REC_OFF, 0);
+ keyword = req_capsule_client_get(&req->rq_pill, &RMF_NAME);
+ LASSERT(keyword);
if (strcmp(keyword, "config") == 0) {
- char *client = lustre_msg_string(req->rq_reqmsg,
- REQ_REC_OFF + 1, 0);
- rc = llog_catinfo_config(obd, buf, buf_len, client);
+ char *client = req_capsule_client_get(&req->rq_pill,
+ &RMF_STRING);
+
+ LASSERT(client);
+ rc = llog_catinfo_config(obd, buf, LLOG_CHUNK_SIZE, client);
} else if (strcmp(keyword, "deletions") == 0) {
- rc = llog_catinfo_deletions(obd, buf, buf_len);
+ rc = llog_catinfo_deletions(obd, buf, LLOG_CHUNK_SIZE);
} else {
rc = -EOPNOTSUPP;
}
- rc = lustre_pack_reply(req, 2, size, NULL);
+ req_capsule_set_size(&req->rq_pill, &RMF_STRING, RCL_SERVER,
+ LLOG_CHUNK_SIZE);
+ rc = req_capsule_server_pack(&req->rq_pill);
if (rc)
GOTO(out_free, rc = -ENOMEM);
- reply = lustre_msg_buf(req->rq_repmsg, REPLY_REC_OFF, buf_len);
+ reply = req_capsule_server_get(&req->rq_pill, &RMF_STRING);
if (strlen(buf) == 0)
sprintf(buf, "%s", "No log informations\n");
- memcpy(reply, buf, buf_len);
+ memcpy(reply, buf, LLOG_CHUNK_SIZE);
out_free:
- OBD_FREE(buf, buf_len);
+ OBD_FREE(buf, LLOG_CHUNK_SIZE);
return rc;
}
int lprocfs_wr_ping(struct file *file, const char *buffer,
unsigned long count, void *data)
{
- struct obd_device *obd = data;
+ struct obd_device *obd = data;
struct ptlrpc_request *req;
- int rc;
+ int rc;
ENTRY;
LPROCFS_CLIMP_CHECK(obd);
- req = ptlrpc_prep_req(obd->u.cli.cl_import, LUSTRE_OBD_VERSION,
- OBD_PING, 1, NULL, NULL);
+ req = ptlrpc_request_alloc_pack(obd->u.cli.cl_import, &RQF_OBD_PING,
+ LUSTRE_OBD_VERSION, OBD_PING);
+
LPROCFS_CLIMP_EXIT(obd);
if (req == NULL)
RETURN(-ENOMEM);
- ptlrpc_req_set_repsize(req, 1, NULL);
+ ptlrpc_request_set_replen(req);
req->rq_send_state = LUSTRE_IMP_FULL;
req->rq_no_resend = 1;
if (newpos != tail)
memcpy(newpos, tail, tail_len);
}
-
- if (newlen == 0 && msg->lm_bufcount > segment + 1) {
- memmove(&msg->lm_buflens[segment], &msg->lm_buflens[segment + 1],
- (msg->lm_bufcount - segment - 1) * sizeof(__u32));
- msg->lm_buflens[msg->lm_bufcount - 1] = 0;
- }
-
out:
return lustre_msg_size_v2(msg->lm_bufcount, (int *)msg->lm_buflens);
}
}
}
+void ptlrpc_request_set_replen(struct ptlrpc_request *req)
+{
+ int count = req_capsule_filled_sizes(&req->rq_pill, RCL_SERVER);
+
+ req->rq_replen = lustre_msg_size(req->rq_reqmsg->lm_magic, count,
+ req->rq_pill.rc_area[RCL_SERVER]);
+ if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
+ req->rq_reqmsg->lm_repsize = req->rq_replen;
+}
+
+void ptlrpc_req_set_repsize(struct ptlrpc_request *req, int count, int *lens)
+{
+ req->rq_replen = lustre_msg_size(req->rq_reqmsg->lm_magic, count, lens);
+ if (req->rq_reqmsg->lm_magic == LUSTRE_MSG_MAGIC_V2)
+ req->rq_reqmsg->lm_repsize = req->rq_replen;
+}
+
/* byte flipping routines for all wire types declared in
* lustre_idl.h implemented here.
*/
__swab64s (&b->ctime);
__swab64s (&b->blocks);
__swab64s (&b->ioepoch);
+ __swab64s (&b->ino);
__swab32s (&b->fsuid);
__swab32s (&b->fsgid);
__swab32s (&b->capability);
__swab32s (&b->flags);
__swab32s (&b->rdev);
__swab32s (&b->nlink);
+ __swab32s (&b->generation);
__swab32s (&b->suppgid);
__swab32s (&b->eadatasize);
__swab32s (&b->aclsize);
__swab32s (&b->max_mdsize);
__swab32s (&b->max_cookiesize);
+ __swab32s (&b->padding_4);
}
void lustre_swab_mdt_epoch (struct mdt_epoch *b)
CLASSERT(offsetof(typeof(*sa), sa_padding) != 0);
}
-void lustre_swab_mdt_rec_setattr (struct mdt_rec_setattr *sa)
-{
- __swab32s (&sa->sa_opcode);
- __swab32s (&sa->sa_fsuid);
- __swab32s (&sa->sa_fsgid);
- __swab32s (&sa->sa_cap);
- __swab32s (&sa->sa_suppgid);
- __swab32s (&sa->sa_mode);
- lustre_swab_lu_fid (&sa->sa_fid);
- __swab64s (&sa->sa_valid);
- __swab64s (&sa->sa_size);
- __swab64s (&sa->sa_blocks);
- __swab64s (&sa->sa_mtime);
- __swab64s (&sa->sa_atime);
- __swab64s (&sa->sa_ctime);
- __swab32s (&sa->sa_uid);
- __swab32s (&sa->sa_gid);
- __swab32s (&sa->sa_attr_flags);
- CLASSERT(offsetof(typeof(*sa), sa_padding) != 0);
-}
-
void lustre_swab_mds_rec_join (struct mds_rec_join *jr)
{
__swab64s(&jr->jr_headsize);
CLASSERT(offsetof(typeof(*cr), cr_padding_5) != 0);
}
-void lustre_swab_mdt_rec_create (struct mdt_rec_create *cr)
-{
- __swab32s (&cr->cr_opcode);
- __swab32s (&cr->cr_fsuid);
- __swab32s (&cr->cr_fsgid);
- __swab32s (&cr->cr_cap);
- __swab32s (&cr->cr_flags); /* for use with open */
- __swab32s (&cr->cr_mode);
- /* handle is opaque */
- lustre_swab_lu_fid (&cr->cr_fid1);
- lustre_swab_lu_fid (&cr->cr_fid2);
- __swab64s (&cr->cr_time);
- __swab64s (&cr->cr_rdev);
- __swab64s (&cr->cr_ioepoch);
- __swab32s (&cr->cr_suppgid1);
- __swab32s (&cr->cr_suppgid2);
- __swab32s (&cr->cr_bias);
- CLASSERT(offsetof(typeof(*cr), cr_padding_1) != 0);
-}
-
void lustre_swab_mds_rec_link (struct mds_rec_link *lk)
{
__swab32s (&lk->lk_opcode);
CLASSERT(offsetof(typeof(*lk), lk_padding_4) != 0);
}
-void lustre_swab_mdt_rec_link (struct mdt_rec_link *lk)
-{
- __swab32s (&lk->lk_opcode);
- __swab32s (&lk->lk_fsuid);
- __swab32s (&lk->lk_fsgid);
- __swab32s (&lk->lk_cap);
- __swab32s (&lk->lk_suppgid1);
- __swab32s (&lk->lk_suppgid2);
- lustre_swab_lu_fid (&lk->lk_fid1);
- lustre_swab_lu_fid (&lk->lk_fid2);
- __swab64s (&lk->lk_time);
- __swab32s (&lk->lk_bias);
- CLASSERT(offsetof(typeof(*lk), lk_padding_2) != 0);
- CLASSERT(offsetof(typeof(*lk), lk_padding_3) != 0);
- CLASSERT(offsetof(typeof(*lk), lk_padding_4) != 0);
-}
-
void lustre_swab_mds_rec_unlink (struct mds_rec_unlink *ul)
{
__swab32s (&ul->ul_opcode);
CLASSERT(offsetof(typeof(*ul), ul_padding_4) != 0);
}
-void lustre_swab_mdt_rec_unlink (struct mdt_rec_unlink *ul)
-{
- __swab32s (&ul->ul_opcode);
- __swab32s (&ul->ul_fsuid);
- __swab32s (&ul->ul_fsgid);
- __swab32s (&ul->ul_cap);
- __swab32s (&ul->ul_suppgid);
- __swab32s (&ul->ul_mode);
- lustre_swab_lu_fid (&ul->ul_fid1);
- lustre_swab_lu_fid (&ul->ul_fid2);
- __swab64s (&ul->ul_time);
- __swab32s (&ul->ul_bias);
- CLASSERT(offsetof(typeof(*ul), ul_padding_2) != 0);
- CLASSERT(offsetof(typeof(*ul), ul_padding_3) != 0);
- CLASSERT(offsetof(typeof(*ul), ul_padding_4) != 0);
-}
-
void lustre_swab_mds_rec_rename (struct mds_rec_rename *rn)
{
__swab32s (&rn->rn_opcode);
CLASSERT(offsetof(typeof(*rn), rn_padding_4) != 0);
}
-void lustre_swab_mdt_rec_rename (struct mdt_rec_rename *rn)
+void lustre_swab_mdt_rec_reint (struct mdt_rec_reint *rr)
{
- __swab32s (&rn->rn_opcode);
- __swab32s (&rn->rn_fsuid);
- __swab32s (&rn->rn_fsgid);
- __swab32s (&rn->rn_cap);
- __swab32s (&rn->rn_suppgid1);
- __swab32s (&rn->rn_suppgid2);
- lustre_swab_lu_fid (&rn->rn_fid1);
- lustre_swab_lu_fid (&rn->rn_fid2);
- __swab64s (&rn->rn_time);
- __swab32s (&rn->rn_mode);
- __swab32s (&rn->rn_bias);
- CLASSERT(offsetof(typeof(*rn), rn_padding_3) != 0);
- CLASSERT(offsetof(typeof(*rn), rn_padding_4) != 0);
-}
+ __swab32s (&rr->rr_opcode);
+ __swab32s (&rr->rr_fsuid);
+ __swab32s (&rr->rr_fsgid);
+ __swab32s (&rr->rr_cap);
+ __swab32s (&rr->rr_suppgid1);
+ __swab32s (&rr->rr_suppgid2);
+ /* handle is opaque */
+ lustre_swab_lu_fid (&rr->rr_fid1);
+ lustre_swab_lu_fid (&rr->rr_fid2);
+ __swab64s (&rr->rr_mtime);
+ __swab64s (&rr->rr_atime);
+ __swab64s (&rr->rr_ctime);
+ __swab64s (&rr->rr_size);
+ __swab64s (&rr->rr_blocks);
+ __swab32s (&rr->rr_bias);
+ __swab32s (&rr->rr_mode);
+ __swab32s (&rr->rr_padding_1);
+ __swab32s (&rr->rr_padding_2);
+ __swab32s (&rr->rr_padding_3);
+ __swab32s (&rr->rr_padding_4);
+
+ CLASSERT(offsetof(typeof(*rr), rr_padding_1) != 0);
+ CLASSERT(offsetof(typeof(*rr), rr_padding_2) != 0);
+ CLASSERT(offsetof(typeof(*rr), rr_padding_3) != 0);
+ CLASSERT(offsetof(typeof(*rr), rr_padding_4) != 0);
+};
void lustre_swab_lov_desc (struct lov_desc *ld)
{
int ptlrpc_ping(struct obd_import *imp)
{
struct ptlrpc_request *req;
- int rc = 0;
ENTRY;
- req = ptlrpc_prep_req(imp, LUSTRE_OBD_VERSION, OBD_PING, 1, NULL, NULL);
- if (req) {
- DEBUG_REQ(D_INFO, req, "pinging %s->%s",
- imp->imp_obd->obd_uuid.uuid,
- obd2cli_tgt(imp->imp_obd));
- req->rq_no_resend = req->rq_no_delay = 1;
- ptlrpc_req_set_repsize(req, 1, NULL);
- req->rq_timeout = PING_INTERVAL;
- ptlrpcd_add_req(req);
- } else {
+ req = ptlrpc_request_alloc_pack(imp, &RQF_OBD_PING, LUSTRE_OBD_VERSION,
+ OBD_PING);
+ if (req == NULL) {
CERROR("OOM trying to ping %s->%s\n",
imp->imp_obd->obd_uuid.uuid,
obd2cli_tgt(imp->imp_obd));
- rc = -ENOMEM;
+ RETURN(-ENOMEM);
}
- RETURN(rc);
+ DEBUG_REQ(D_INFO, req, "pinging %s->%s",
+ imp->imp_obd->obd_uuid.uuid, obd2cli_tgt(imp->imp_obd));
+ req->rq_no_resend = req->rq_no_delay = 1;
+ ptlrpc_request_set_replen(req);
+ req->rq_timeout = PING_INTERVAL;
+ ptlrpcd_add_req(req);
+
+ RETURN(0);
}
void ptlrpc_update_next_ping(struct obd_import *imp)
continue;
}
- req = ptlrpc_prep_req(imp, LUSTRE_OBD_VERSION, OBD_PING,
- 1, NULL, NULL);
- if (!req) {
- CERROR("out of memory\n");
+ req = ptlrpc_request_alloc_pack(imp, &RQF_OBD_PING,
+ LUSTRE_OBD_VERSION,
+ OBD_PING);
+ if (req == NULL) {
+ CERROR("OOM trying to ping %s->%s\n",
+ imp->imp_obd->obd_uuid.uuid,
+ obd2cli_tgt(imp->imp_obd));
break;
}
+
req->rq_no_resend = 1;
- ptlrpc_req_set_repsize(req, 1, NULL);
+ ptlrpc_request_set_replen(req);
req->rq_send_state = LUSTRE_IMP_FULL;
req->rq_phase = RQ_PHASE_RPC;
req->rq_import_generation = generation;
EXPORT_SYMBOL(ptlrpc_init_rq_pool);
EXPORT_SYMBOL(ptlrpc_free_rq_pool);
EXPORT_SYMBOL(ptlrpc_prep_req_pool);
+EXPORT_SYMBOL(ptlrpc_request_alloc);
+EXPORT_SYMBOL(ptlrpc_request_alloc_pool);
+EXPORT_SYMBOL(ptlrpc_request_free);
+EXPORT_SYMBOL(ptlrpc_request_pack);
+EXPORT_SYMBOL(ptlrpc_request_alloc_pack);
EXPORT_SYMBOL(ptlrpc_prep_req);
EXPORT_SYMBOL(ptlrpc_free_req);
EXPORT_SYMBOL(ptlrpc_unregister_reply);
EXPORT_SYMBOL(ptlrpc_abort_inflight);
EXPORT_SYMBOL(ptlrpc_retain_replayable_request);
EXPORT_SYMBOL(ptlrpc_next_xid);
+EXPORT_SYMBOL(ptlrpc_req_set_repsize);
+EXPORT_SYMBOL(ptlrpc_request_set_replen);
EXPORT_SYMBOL(ptlrpc_prep_set);
EXPORT_SYMBOL(ptlrpc_set_add_cb);
EXPORT_SYMBOL(lustre_swab_mds_remote_perm);
EXPORT_SYMBOL(lustre_swab_mdt_remote_perm);
EXPORT_SYMBOL(lustre_swab_mds_rec_setattr);
-EXPORT_SYMBOL(lustre_swab_mdt_rec_setattr);
EXPORT_SYMBOL(lustre_swab_mds_rec_create);
-EXPORT_SYMBOL(lustre_swab_mdt_rec_create);
EXPORT_SYMBOL(lustre_swab_mds_rec_join);
EXPORT_SYMBOL(lustre_swab_mdt_rec_join);
EXPORT_SYMBOL(lustre_swab_mds_rec_link);
-EXPORT_SYMBOL(lustre_swab_mdt_rec_link);
EXPORT_SYMBOL(lustre_swab_mds_rec_unlink);
-EXPORT_SYMBOL(lustre_swab_mdt_rec_unlink);
EXPORT_SYMBOL(lustre_swab_mds_rec_rename);
-EXPORT_SYMBOL(lustre_swab_mdt_rec_rename);
+EXPORT_SYMBOL(lustre_swab_mdt_rec_reint);
EXPORT_SYMBOL(lustre_swab_lov_desc);
EXPORT_SYMBOL(lustre_swab_lov_user_md);
EXPORT_SYMBOL(lustre_swab_lov_mds_md);
}
EXPORT_SYMBOL(llog_obd_repl_sync);
+static inline void stop_log_commit(struct llog_commit_master *lcm,
+ struct llog_commit_daemon *lcd,
+ int rc)
+{
+ CERROR("error preparing commit: rc %d\n", rc);
+
+ spin_lock(&lcm->lcm_llcd_lock);
+ list_splice(&lcd->lcd_llcd_list, &lcm->lcm_llcd_resend);
+ CFS_INIT_LIST_HEAD(&lcd->lcd_llcd_list);
+ spin_unlock(&lcm->lcm_llcd_lock);
+}
+
static int log_commit_thread(void *arg)
{
struct llog_commit_master *lcm = arg;
/* We are the only one manipulating our local list - no lock */
list_for_each_entry_safe(llcd,n, &lcd->lcd_llcd_list,llcd_list){
- int size[2] = { sizeof(struct ptlrpc_body),
- llcd->llcd_cookiebytes };
char *bufs[2] = { NULL, (char *)llcd->llcd_cookies };
list_del(&llcd->llcd_list);
OBD_FAIL_TIMEOUT(OBD_FAIL_PTLRPC_DELAY_RECOV, 10);
- request = ptlrpc_prep_req(import, LUSTRE_LOG_VERSION,
- OBD_LOG_CANCEL, 2, size,bufs);
+ request = ptlrpc_request_alloc(import, &RQF_LOG_CANCEL);
if (request == NULL) {
rc = -ENOMEM;
- CERROR("error preparing commit: rc %d\n", rc);
+ stop_log_commit(lcm, lcd, rc);
+ break;
+ }
+
+ req_capsule_set_size(&request->rq_pill, &RMF_LOGCOOKIES,
+ RCL_CLIENT,llcd->llcd_cookiebytes);
- spin_lock(&lcm->lcm_llcd_lock);
- list_splice(&lcd->lcd_llcd_list,
- &lcm->lcm_llcd_resend);
- CFS_INIT_LIST_HEAD(&lcd->lcd_llcd_list);
- spin_unlock(&lcm->lcm_llcd_lock);
+ rc = ptlrpc_request_bufs_pack(request,
+ LUSTRE_LOG_VERSION,
+ OBD_LOG_CANCEL, bufs,
+ NULL);
+ if (rc) {
+ ptlrpc_request_free(request);
+ stop_log_commit(lcm, lcd, rc);
break;
}
request->rq_request_portal = LDLM_CANCEL_REQUEST_PORTAL;
request->rq_reply_portal = LDLM_CANCEL_REPLY_PORTAL;
- ptlrpc_req_set_repsize(request, 1, NULL);
+ ptlrpc_request_set_replen(request);
mutex_down(&llcd->llcd_ctxt->loc_sem);
if (llcd->llcd_ctxt->loc_imp == NULL) {
mutex_up(&llcd->llcd_ctxt->loc_sem);
(long long)REINT_RENAME);
LASSERTF(REINT_OPEN == 6, " found %lld\n",
(long long)REINT_OPEN);
- LASSERTF(REINT_MAX == 7, " found %lld\n",
+ LASSERTF(REINT_MAX == 8, " found %lld\n",
(long long)REINT_MAX);
LASSERTF(MGS_CONNECT == 250, " found %lld\n",
(long long)MGS_CONNECT);
struct obd_quotactl *oqctl)
{
struct ptlrpc_request *req;
- struct obd_quotactl *body;
- int rc, size[2] = { sizeof(struct ptlrpc_body), sizeof(*oqctl) };
+ struct obd_quotactl *body;
+ int rc;
ENTRY;
- req = ptlrpc_prep_req(exp->exp_imp_reverse, LUSTRE_OBD_VERSION,
- OBD_QC_CALLBACK, 2, size, NULL);
- if (!req)
+ req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp), &RQF_QC_CALLBACK,
+ LUSTRE_OBD_VERSION, OBD_QC_CALLBACK);
+ if (req == NULL)
RETURN(-ENOMEM);
- body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_OBD_QUOTACTL);
*body = *oqctl;
- ptlrpc_req_set_repsize(req, 1, NULL);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
ptlrpc_req_finished(req);
int client_quota_check(struct obd_export *exp, struct obd_quotactl *oqctl)
{
- struct client_obd *cli = &exp->exp_obd->u.cli;
+ struct client_obd *cli = &exp->exp_obd->u.cli;
struct ptlrpc_request *req;
- struct obd_quotactl *body;
- int size[2] = { sizeof(struct ptlrpc_body), sizeof(*body) };
- int ver, opc, rc;
+ struct obd_quotactl *body;
+ int ver, opc, rc;
ENTRY;
if (!strcmp(exp->exp_obd->obd_type->typ_name, LUSTRE_MDC_NAME)) {
RETURN(-EINVAL);
}
- req = ptlrpc_prep_req(class_exp2cliimp(exp), ver, opc, 2, size, NULL);
- if (!req)
- GOTO(out, rc = -ENOMEM);
+ req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp),
+ &RQF_MDS_QUOTACHECK, ver, opc);
+ if (req == NULL)
+ RETURN(-ENOMEM);
- body = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*body));
+ body = req_capsule_client_get(&req->rq_pill, &RMF_OBD_QUOTACTL);
*body = *oqctl;
- ptlrpc_req_set_repsize(req, 1, NULL);
+ ptlrpc_request_set_replen(req);
/* the next poll will find -ENODATA, that means quotacheck is
* going on */
rc = ptlrpc_queue_wait(req);
if (rc)
cli->cl_qchk_stat = rc;
-out:
ptlrpc_req_finished(req);
RETURN(rc);
}
LASSERT(req);
LASSERT(req->rq_import);
- if ((req->rq_import->imp_connect_data.ocd_connect_flags & OBD_CONNECT_QUOTA64) &&
+
+ if ((req->rq_import->imp_connect_data.ocd_connect_flags &
+ OBD_CONNECT_QUOTA64) &&
!OBD_FAIL_CHECK(OBD_FAIL_QUOTA_QD_COUNT_32BIT)) {
CDEBUG(D_QUOTA, "qd_count is 64bit!\n");
- qdata = lustre_swab_reqbuf(req, REPLY_REC_OFF, sizeof(*qdata), lustre_swab_qdata);
+
+ qdata = req_capsule_server_swab_get(&req->rq_pill,
+ &RMF_QUNIT_DATA,
+ (void*)lustre_swab_qdata);
} else {
CDEBUG(D_QUOTA, "qd_count is 32bit!\n");
- qdata_old = lustre_swab_reqbuf(req, REPLY_REC_OFF, sizeof(struct qunit_data_old),
- lustre_swab_qdata_old);
+
+ qdata = req_capsule_server_swab_get(&req->rq_pill,
+ &RMF_QUNIT_DATA,
+ (void*)lustre_swab_qdata_old);
qdata = lustre_quota_old_to_new(qdata_old);
}
if (qdata == NULL) {
}
LASSERT(qdata->qd_id == qunit->lq_data.qd_id &&
- (qdata->qd_flags & QUOTA_IS_GRP) == (qunit->lq_data.qd_flags & QUOTA_IS_GRP) &&
+ (qdata->qd_flags & QUOTA_IS_GRP) ==
+ (qunit->lq_data.qd_flags & QUOTA_IS_GRP) &&
(qdata->qd_count == qunit->lq_data.qd_count ||
qdata->qd_count == 0));
struct ptlrpc_request *req;
struct qunit_data *reqdata;
struct dqacq_async_args *aa;
- int size[2] = { sizeof(struct ptlrpc_body), sizeof(*reqdata) };
unsigned long factor;
int rc = 0;
ENTRY;
LASSERT(qunit);
/* master is going to dqacq/dqrel from itself */
- if (is_master(obd, qctxt, qdata->qd_id, qdata->qd_flags & QUOTA_IS_GRP)) {
+ if (is_master(obd, qctxt, qdata->qd_id, qdata->qd_flags & QUOTA_IS_GRP))
+ {
int rc2;
QDATA_DEBUG(qdata, "local %s.\n",
opc == QUOTA_DQACQ ? "DQACQ" : "DQREL");
/* build dqacq/dqrel request */
LASSERT(qctxt->lqc_import);
- req = ptlrpc_prep_req(qctxt->lqc_import, LUSTRE_MDS_VERSION, opc, 2,
- size, NULL);
- if (!req) {
+
+ req = ptlrpc_request_alloc_pack(qctxt->lqc_import, &RQF_MDS_QUOTA_DQACQ,
+ LUSTRE_MDS_VERSION, opc);
+ if (req == NULL) {
dqacq_completion(obd, qctxt, qdata, -ENOMEM, opc);
RETURN(-ENOMEM);
}
{
struct qunit_data_old *reqdata_old, *tmp;
- reqdata_old = lustre_msg_buf(req->rq_reqmsg, REPLY_REC_OFF,
- sizeof(*reqdata_old));
+ reqdata_old = req_capsule_client_get(&req->rq_pill,
+ &RMF_QUNIT_DATA);
+
tmp = lustre_quota_new_to_old(qdata);
*reqdata_old = *tmp;
- size[1] = sizeof(*reqdata_old);
+ req_capsule_set_size(&req->rq_pill, &RMF_QUNIT_DATA, RCL_SERVER,
+ sizeof(*reqdata_old));
CDEBUG(D_QUOTA, "qd_count is 32bit!\n");
} else {
- reqdata = lustre_msg_buf(req->rq_reqmsg, REPLY_REC_OFF,
- sizeof(*reqdata));
+ reqdata = req_capsule_client_get(&req->rq_pill,
+ &RMF_QUNIT_DATA);
+
*reqdata = *qdata;
- size[1] = sizeof(*reqdata);
+ req_capsule_set_size(&req->rq_pill, &RMF_QUNIT_DATA, RCL_SERVER,
+ sizeof(*reqdata));
CDEBUG(D_QUOTA, "qd_count is 64bit!\n");
}
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
CLASSERT(sizeof(*aa) <= sizeof(req->rq_async_args));
aa = (struct dqacq_async_args *)&req->rq_async_args;
int client_quota_ctl(struct obd_export *exp, struct obd_quotactl *oqctl)
{
struct ptlrpc_request *req;
- struct obd_quotactl *oqc;
- int size[2] = { sizeof(struct ptlrpc_body), sizeof(*oqctl) };
- int ver, opc, rc;
+ struct obd_quotactl *oqc;
+ int ver, opc, rc;
ENTRY;
if (!strcmp(exp->exp_obd->obd_type->typ_name, LUSTRE_MDC_NAME)) {
RETURN(-EINVAL);
}
- req = ptlrpc_prep_req(class_exp2cliimp(exp), ver, opc, 2, size, NULL);
- if (!req)
- GOTO(out, rc = -ENOMEM);
+ req = ptlrpc_request_alloc_pack(class_exp2cliimp(exp),
+ &RQF_MDS_QUOTACTL, ver, opc);
+ if (req == NULL)
+ RETURN(-ENOMEM);
- oqc = lustre_msg_buf(req->rq_reqmsg, REQ_REC_OFF, sizeof(*oqctl));
+ oqc = req_capsule_client_get(&req->rq_pill, &RMF_OBD_QUOTACTL);
*oqc = *oqctl;
- ptlrpc_req_set_repsize(req, 2, size);
+ ptlrpc_request_set_replen(req);
rc = ptlrpc_queue_wait(req);
if (!rc) {
- oqc = lustre_swab_repbuf(req, REPLY_REC_OFF, sizeof(*oqc),
- lustre_swab_obd_quotactl);
- if (oqc == NULL) {
- CERROR ("Can't unpack obd_quotactl\n");
+ oqc = req_capsule_server_get(&req->rq_pill, &RMF_OBD_QUOTACTL);
+ if (oqc == NULL)
GOTO(out, rc = -EPROTO);
- }
*oqctl = *oqc;
}
#define lustre_swab_ldlm_reply NULL
#define lustre_swab_ldlm_intent NULL
#define lustre_swab_lov_mds_md NULL
-#define lustre_swab_mdt_rec_unlink NULL
-#define lustre_swab_mdt_rec_link NULL
-#define lustre_swab_mdt_rec_rename NULL
-#define lustre_swab_mdt_rec_create NULL
-#define lustre_swab_mdt_rec_setattr NULL
+#define lustre_swab_mdt_rec_reint NULL
#define lustre_swab_lustre_capa NULL
#define lustre_swab_lustre_capa_key NULL
+#define lustre_swab_mdt_rec_join NULL
+#define lustre_swab_llogd_conn_body NULL
+#define lustre_swab_llog_hdr NULL
+#define lustre_swab_llogd_body NULL
+#define lustre_swab_obd_quotactl NULL
+#define lustre_swab_mgs_target_info NULL
+#define lustre_swab_niobuf_remote NULL
+#define lustre_swab_obd_ioobj NULL
+#define lustre_swab_ost_body NULL
+#define lustre_swab_ost_last_id NULL
/*
* Yes, include .c file.
(long long)REINT_RENAME);
LASSERTF(REINT_OPEN == 6, " found %lld\n",
(long long)REINT_OPEN);
- LASSERTF(REINT_MAX == 7, " found %lld\n",
+ LASSERTF(REINT_SETXATTR == 7, " found %lld\n",
+ (long long)REINT_SETXATTR);
+ LASSERTF(REINT_MAX == 8, " found %lld\n",
(long long)REINT_MAX);
LASSERTF(MGS_CONNECT == 250, " found %lld\n",
(long long)MGS_CONNECT);
git://git.whamcloud.com / fs / lustre-release.git / commitdiff