spin_lock(&req->rq_lock);
req->rq_replay = 0;
spin_unlock(&req->rq_lock);
- }
- if (rc && req->rq_transno != 0) {
- DEBUG_REQ(D_ERROR, req, "transno returned on error rc %d", rc);
- LBUG();
- }
+ }
+ if (rc && req->rq_transno != 0) {
+ DEBUG_REQ(D_ERROR, req, "transno returned on error: rc = %d",
+ rc);
+ LBUG();
+ }
}
/* Save a large LOV EA into the request buffer so that it is available
const void *lmm = op_data->op_data;
__u32 lmmsize = op_data->op_data_size;
__u32 mdt_md_capsule_size;
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
int count = 0;
enum ldlm_mode mode;
int rc;
struct ptlrpc_request *req;
struct ldlm_intent *lit;
int rc, count = 0;
- struct list_head cancels = LIST_HEAD_INIT(cancels);
+ LIST_HEAD(cancels);
u32 ea_vals_buf_size = GA_DEFAULT_EA_VAL_LEN * GA_DEFAULT_EA_NUM;
ENTRY;
mdc_intent_getattr_pack(struct obd_export *exp, struct lookup_intent *it,
struct md_op_data *op_data, __u32 acl_bufsize)
{
- struct ptlrpc_request *req;
- struct obd_device *obddev = class_exp2obd(exp);
- u64 valid = OBD_MD_FLGETATTR | OBD_MD_FLEASIZE |
- OBD_MD_FLMODEASIZE | OBD_MD_FLDIREA |
- OBD_MD_MEA | OBD_MD_FLACL;
- struct ldlm_intent *lit;
- int rc;
- __u32 easize;
- bool have_secctx = false;
+ struct ptlrpc_request *req;
+ struct obd_device *obddev = class_exp2obd(exp);
+ u64 valid = OBD_MD_FLGETATTR | OBD_MD_FLEASIZE | OBD_MD_FLMODEASIZE |
+ OBD_MD_FLDIREA | OBD_MD_MEA | OBD_MD_FLACL |
+ OBD_MD_DEFAULT_MEA;
+ struct ldlm_intent *lit;
+ __u32 easize;
+ bool have_secctx = false;
+ int rc;
+
ENTRY;
req = ptlrpc_request_alloc(class_exp2cliimp(exp),
req_capsule_set_size(&req->rq_pill, &RMF_MDT_MD, RCL_SERVER, easize);
req_capsule_set_size(&req->rq_pill, &RMF_ACL, RCL_SERVER, acl_bufsize);
+ req_capsule_set_size(&req->rq_pill, &RMF_DEFAULT_MDT_MD, RCL_SERVER,
+ sizeof(struct lmv_user_md));
if (have_secctx) {
char *secctx_name;
struct md_op_data *op_data)
{
struct obd_device *obd = class_exp2obd(exp);
+ LIST_HEAD(cancels);
struct ptlrpc_request *req;
struct ldlm_intent *lit;
struct layout_intent *layout;
- int rc;
+ int count = 0, rc;
ENTRY;
req = ptlrpc_request_alloc(class_exp2cliimp(exp),
if (req == NULL)
RETURN(ERR_PTR(-ENOMEM));
+ if (fid_is_sane(&op_data->op_fid2) && (it->it_op & IT_LAYOUT) &&
+ (it->it_flags & FMODE_WRITE)) {
+ count = mdc_resource_get_unused(exp, &op_data->op_fid2,
+ &cancels, LCK_EX,
+ MDS_INODELOCK_LAYOUT);
+ }
+
req_capsule_set_size(&req->rq_pill, &RMF_EADATA, RCL_CLIENT, 0);
- rc = ldlm_prep_enqueue_req(exp, req, NULL, 0);
+ rc = ldlm_prep_enqueue_req(exp, req, &cancels, count);
if (rc) {
ptlrpc_request_free(req);
RETURN(ERR_PTR(rc));
(!it_disposition(it, DISP_OPEN_OPEN) || it->it_status != 0))
mdc_clear_replay_flag(req, it->it_status);
- DEBUG_REQ(D_RPCTRACE, req, "op: %x disposition: %x, status: %d",
+ DEBUG_REQ(D_RPCTRACE, req, "op=%x disposition=%x, status=%d",
it->it_op, it->it_disposition, it->it_status);
/* We know what to expect, so we do any byte flipping required here */
mdc_set_open_replay_data(NULL, NULL, it);
}
+ if (it_disposition(it, DISP_OPEN_CREATE) &&
+ !it_open_error(DISP_OPEN_CREATE, it)) {
+ lprocfs_counter_incr(exp->exp_obd->obd_md_stats,
+ LPROC_MD_CREATE);
+ }
+
if (body->mbo_valid & (OBD_MD_FLDIREA | OBD_MD_FLEASIZE)) {
void *eadata;
RETURN(rc);
}
+static inline bool mdc_skip_mod_rpc_slot(const struct lookup_intent *it)
+{
+ if (it != NULL &&
+ (it->it_op == IT_GETATTR || it->it_op == IT_LOOKUP ||
+ it->it_op == IT_READDIR ||
+ (it->it_op == IT_LAYOUT && !(it->it_flags & MDS_FMODE_WRITE))))
+ return true;
+ return false;
+}
+
/* We always reserve enough space in the reply packet for a stripe MD, because
* we don't know in advance the file type. */
static int mdc_enqueue_base(struct obd_export *exp,
__u64 extra_lock_flags)
{
struct obd_device *obddev = class_exp2obd(exp);
- struct ptlrpc_request *req = NULL;
+ struct ptlrpc_request *req;
__u64 flags, saved_flags = extra_lock_flags;
struct ldlm_res_id res_id;
static const union ldlm_policy_data lookup_policy = {
LASSERTF(einfo->ei_type == LDLM_FLOCK, "lock type %d\n",
einfo->ei_type);
res_id.name[3] = LDLM_FLOCK;
+ req = ldlm_enqueue_pack(exp, 0);
} else if (it->it_op & IT_OPEN) {
req = mdc_intent_open_pack(exp, it, op_data, acl_bufsize);
} else if (it->it_op & (IT_GETATTR | IT_LOOKUP)) {
req->rq_sent = ktime_get_real_seconds() + resends;
}
- /* It is important to obtain modify RPC slot first (if applicable), so
- * that threads that are waiting for a modify RPC slot are not polluting
- * our rpcs in flight counter.
- * We do not do flock request limiting, though */
- if (it) {
- mdc_get_mod_rpc_slot(req, it);
- rc = obd_get_request_slot(&obddev->u.cli);
- if (rc != 0) {
- mdc_put_mod_rpc_slot(req, it);
- mdc_clear_replay_flag(req, 0);
- ptlrpc_req_finished(req);
- RETURN(rc);
- }
- }
+ einfo->ei_enq_slot = !mdc_skip_mod_rpc_slot(it);
/* With Data-on-MDT the glimpse callback is needed too.
* It is set here in advance but not in mdc_finish_enqueue()
rc = ldlm_cli_enqueue(exp, &req, einfo, &res_id, policy, &flags, NULL,
0, lvb_type, lockh, 0);
+
if (!it) {
/* For flock requests we immediatelly return without further
delay and let caller deal with the rest, since rest of
(einfo->ei_type == LDLM_FLOCK) &&
(einfo->ei_mode == LCK_NL))
goto resend;
+ ptlrpc_req_finished(req);
RETURN(rc);
}
- obd_put_request_slot(&obddev->u.cli);
- mdc_put_mod_rpc_slot(req, it);
-
if (rc < 0) {
CDEBUG(D_INFO,
"%s: ldlm_cli_enqueue "DFID":"DFID"=%s failed: rc = %d\n",
struct obd_export *exp = ga->ga_exp;
struct md_enqueue_info *minfo = ga->ga_minfo;
struct ldlm_enqueue_info *einfo = &minfo->mi_einfo;
- struct lookup_intent *it;
- struct lustre_handle *lockh;
- struct obd_device *obddev;
- struct ldlm_reply *lockrep;
- __u64 flags = LDLM_FL_HAS_INTENT;
+ struct lookup_intent *it;
+ struct lustre_handle *lockh;
+ struct ldlm_reply *lockrep;
+ __u64 flags = LDLM_FL_HAS_INTENT;
ENTRY;
it = &minfo->mi_it;
lockh = &minfo->mi_lockh;
- obddev = class_exp2obd(exp);
-
- obd_put_request_slot(&obddev->u.cli);
if (OBD_FAIL_CHECK(OBD_FAIL_MDC_GETATTR_ENQUEUE))
rc = -ETIMEDOUT;
struct lookup_intent *it = &minfo->mi_it;
struct ptlrpc_request *req;
struct mdc_getattr_args *ga;
- struct obd_device *obddev = class_exp2obd(exp);
struct ldlm_res_id res_id;
union ldlm_policy_data policy = {
.l_inodebits = { MDS_INODELOCK_LOOKUP |
if (IS_ERR(req))
RETURN(PTR_ERR(req));
- rc = obd_get_request_slot(&obddev->u.cli);
- if (rc != 0) {
- ptlrpc_req_finished(req);
- RETURN(rc);
- }
-
/* With Data-on-MDT the glimpse callback is needed too.
* It is set here in advance but not in mdc_finish_enqueue()
* to avoid possible races. It is safe to have glimpse handler
rc = ldlm_cli_enqueue(exp, &req, &minfo->mi_einfo, &res_id, &policy,
&flags, NULL, 0, LVB_T_NONE, &minfo->mi_lockh, 1);
if (rc < 0) {
- obd_put_request_slot(&obddev->u.cli);
ptlrpc_req_finished(req);
RETURN(rc);
}
- CLASSERT(sizeof(*ga) <= sizeof(req->rq_async_args));
- ga = ptlrpc_req_async_args(req);
+ ga = ptlrpc_req_async_args(ga, req);
ga->ga_exp = exp;
ga->ga_minfo = minfo;