*/
#define DEBUG_SUBSYSTEM S_RPC
+#include <libcfs/linux/linux-mem.h>
#include <obd_support.h>
#include <lustre_net.h>
#include <lustre_lib.h>
md.threshold = (ack == LNET_ACK_REQ) ? 2 : 1;
md.options = PTLRPC_MD_OPTIONS;
md.user_ptr = cbid;
- md.eq_handle = ptlrpc_eq;
+ md.handler = ptlrpc_handler;
LNetInvalidateMDHandle(&md.bulk_handle);
if (bulk_cookie) {
ack = LNET_NOACK_REQ;
}
- rc = LNetMDBind (md, LNET_UNLINK, mdh);
+ rc = LNetMDBind(&md, LNET_UNLINK, mdh);
if (unlikely(rc != 0)) {
CERROR ("LNetMDBind failed: %d\n", rc);
LASSERT (rc == -ENOMEM);
CDEBUG(D_NET, "Sending %d bytes to portal %d, xid %lld, offset %u\n",
len, portal, xid, offset);
+ percpu_ref_get(&ptlrpc_pending);
+
rc = LNetPut(self, *mdh, ack,
peer_id, portal, xid, offset, 0);
if (unlikely(rc != 0)) {
desc->bd_failure = 0;
md.user_ptr = &desc->bd_cbid;
- md.eq_handle = ptlrpc_eq;
+ md.handler = ptlrpc_handler;
md.threshold = 2; /* SENT and ACK/REPLY */
for (posted_md = 0; posted_md < total_md; mbits++) {
* page-aligned. Otherwise we'd have to send client bulk
* sizes over and split server buffer accordingly */
ptlrpc_fill_bulk_md(&md, desc, posted_md);
- rc = LNetMDBind(md, LNET_UNLINK, &desc->bd_mds[posted_md]);
+ rc = LNetMDBind(&md, LNET_UNLINK, &desc->bd_mds[posted_md]);
if (rc != 0) {
CERROR("%s: LNetMDBind failed for MD %u: rc = %d\n",
exp->exp_obd->obd_name, posted_md, rc);
}
break;
}
+ percpu_ref_get(&ptlrpc_pending);
/* sanity.sh 224c: lets skip last md */
if (posted_md == desc->bd_md_max_brw - 1)
for (;;) {
/* Network access will complete in finite time but the HUGE
* timeout lets us CWARN for visibility of sluggish NALs */
- int seconds = LONG_UNLINK;
+ int seconds = PTLRPC_REQ_LONG_UNLINK;
while (seconds > 0 &&
wait_event_idle_timeout(desc->bd_waitq,
desc->bd_last_mbits = mbits;
desc->bd_md_count = total_md;
md.user_ptr = &desc->bd_cbid;
- md.eq_handle = ptlrpc_eq;
+ md.handler = ptlrpc_handler;
md.threshold = 1; /* PUT or GET */
for (posted_md = 0; posted_md < total_md; posted_md++, mbits++) {
posted_md, rc);
break;
}
+ percpu_ref_get(&ptlrpc_pending);
/* About to let the network at it... */
- rc = LNetMDAttach(me, md, LNET_UNLINK,
+ rc = LNetMDAttach(me, &md, LNET_UNLINK,
&desc->bd_mds[posted_md]);
if (rc != 0) {
CERROR("%s: LNetMDAttach failed x%llu/%d: rc = %d\n",
LASSERT(!in_interrupt()); /* might sleep */
+ if (desc)
+ desc->bd_registered = 0;
+
/* Let's setup deadline for reply unlink. */
if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_LONG_BULK_UNLINK) &&
async && req->rq_bulk_deadline == 0 && cfs_fail_val == 0)
- req->rq_bulk_deadline = ktime_get_real_seconds() + LONG_UNLINK;
+ req->rq_bulk_deadline = ktime_get_real_seconds() +
+ PTLRPC_REQ_LONG_UNLINK;
if (ptlrpc_client_bulk_active(req) == 0) /* completed or */
RETURN(1); /* never registered */
* Network access will complete in finite time but the HUGE
* timeout lets us CWARN for visibility of sluggish NALs.
*/
- int seconds = LONG_UNLINK;
+ int seconds = PTLRPC_REQ_LONG_UNLINK;
while (seconds > 0 &&
wait_event_idle_timeout(*wq,
{
struct ptlrpc_service_part *svcpt = req->rq_rqbd->rqbd_svcpt;
struct ptlrpc_service *svc = svcpt->scp_service;
- int service_time = max_t(int, ktime_get_real_seconds() -
- req->rq_arrival_time.tv_sec, 1);
+ timeout_t service_timeout;
+ service_timeout = clamp_t(timeout_t, ktime_get_real_seconds() -
+ req->rq_arrival_time.tv_sec, 1,
+ (AT_OFF ? obd_timeout * 3 / 2 : at_max));
if (!(flags & PTLRPC_REPLY_EARLY) &&
(req->rq_type != PTL_RPC_MSG_ERR) &&
(req->rq_reqmsg != NULL) &&
(MSG_RESENT | MSG_REPLAY |
MSG_REQ_REPLAY_DONE | MSG_LOCK_REPLAY_DONE))) {
/* early replies, errors and recovery requests don't count
- * toward our service time estimate */
- int oldse = at_measured(&svcpt->scp_at_estimate, service_time);
+ * toward our service time estimate
+ */
+ timeout_t oldse = at_measured(&svcpt->scp_at_estimate,
+ service_timeout);
if (oldse != 0) {
DEBUG_REQ(D_ADAPTTO, req,
}
}
/* Report actual service time for client latency calc */
- lustre_msg_set_service_time(req->rq_repmsg, service_time);
+ lustre_msg_set_service_timeout(req->rq_repmsg, service_timeout);
/* Report service time estimate for future client reqs, but report 0
* (to be ignored by client) if it's an error reply during recovery.
* b=15815
req->rq_export->exp_obd->obd_recovering)) {
lustre_msg_set_timeout(req->rq_repmsg, 0);
} else {
- time64_t timeout;
+ timeout_t timeout;
if (req->rq_export && req->rq_reqmsg != NULL &&
(flags & PTLRPC_REPLY_EARLY) &&
timeout = ktime_get_real_seconds() -
req->rq_arrival_time.tv_sec +
- min_t(time64_t, at_extra,
+ min_t(timeout_t, at_extra,
exp_obd->obd_recovery_timeout / 4);
} else {
timeout = at_get(&svcpt->scp_at_estimate);
request->rq_resend_cb(request, &request->rq_async_args);
}
if (request->rq_memalloc)
- mpflag = cfs_memory_pressure_get_and_set();
+ mpflag = memalloc_noreclaim_save();
rc = sptlrpc_cli_wrap_request(request);
if (rc)
request->rq_repmsg = NULL;
}
- reply_me = LNetMEAttach(request->rq_reply_portal,
- connection->c_peer, request->rq_xid, 0,
- LNET_UNLINK, LNET_INS_AFTER);
+ if (request->rq_bulk &&
+ OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_BULK_REPLY_ATTACH)) {
+ reply_me = ERR_PTR(-ENOMEM);
+ } else {
+ reply_me = LNetMEAttach(request->rq_reply_portal,
+ connection->c_peer,
+ request->rq_xid, 0,
+ LNET_UNLINK, LNET_INS_AFTER);
+ }
+
if (IS_ERR(reply_me)) {
rc = PTR_ERR(reply_me);
CERROR("LNetMEAttach failed: %d\n", rc);
LNET_MD_MANAGE_REMOTE |
LNET_MD_TRUNCATE; /* allow to make EOVERFLOW error */;
reply_md.user_ptr = &request->rq_reply_cbid;
- reply_md.eq_handle = ptlrpc_eq;
+ reply_md.handler = ptlrpc_handler;
/* We must see the unlink callback to set rq_reply_unlinked,
* so we can't auto-unlink */
- rc = LNetMDAttach(reply_me, reply_md, LNET_RETAIN,
+ rc = LNetMDAttach(reply_me, &reply_md, LNET_RETAIN,
&request->rq_reply_md_h);
if (rc != 0) {
CERROR("LNetMDAttach failed: %d\n", rc);
/* ...but the MD attach didn't succeed... */
request->rq_receiving_reply = 0;
spin_unlock(&request->rq_lock);
- GOTO(cleanup_me, rc = -ENOMEM);
- }
+ GOTO(cleanup_me, rc = -ENOMEM);
+ }
+ percpu_ref_get(&ptlrpc_pending);
- CDEBUG(D_NET, "Setup reply buffer: %u bytes, xid %llu"
- ", portal %u\n",
- request->rq_repbuf_len, request->rq_xid,
- request->rq_reply_portal);
- }
+ CDEBUG(D_NET,
+ "Setup reply buffer: %u bytes, xid %llu, portal %u\n",
+ request->rq_repbuf_len, request->rq_xid,
+ request->rq_reply_portal);
+ }
/* add references on request for request_out_callback */
ptlrpc_request_addref(request);
cleanup_bulk:
/* We do sync unlink here as there was no real transfer here so
* the chance to have long unlink to sluggish net is smaller here. */
- ptlrpc_unregister_bulk(request, 0);
- if (request->rq_bulk != NULL)
- request->rq_bulk->bd_registered = 0;
+ ptlrpc_unregister_bulk(request, 0);
out:
if (rc == -ENOMEM) {
/* set rq_sent so that this request is treated
}
if (request->rq_memalloc)
- cfs_memory_pressure_restore(mpflag);
+ memalloc_noreclaim_restore(mpflag);
return rc;
}
md.threshold = LNET_MD_THRESH_INF;
md.options = PTLRPC_MD_OPTIONS | LNET_MD_OP_PUT | LNET_MD_MAX_SIZE;
md.user_ptr = &rqbd->rqbd_cbid;
- md.eq_handle = ptlrpc_eq;
+ md.handler = ptlrpc_handler;
- rc = LNetMDAttach(me, md, LNET_UNLINK, &rqbd->rqbd_md_h);
- if (rc == 0)
+ rc = LNetMDAttach(me, &md, LNET_UNLINK, &rqbd->rqbd_md_h);
+ if (rc == 0) {
+ percpu_ref_get(&ptlrpc_pending);
return 0;
+ }
- CERROR("LNetMDAttach failed: %d;\n", rc);
+ CERROR("ptlrpc: LNetMDAttach failed: rc = %d\n", rc);
LASSERT(rc == -ENOMEM);
LNetMEUnlink(me);
LASSERT(rc == 0);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff