*/
/*
* This file is part of Lustre, http://www.lustre.org/
- * Lustre is a trademark of Sun Microsystems, Inc.
*/
#define DEBUG_SUBSYSTEM S_RPC
RETURN (0);
}
-static void mdunlink_iterate_helper(struct lnet_handle_md *bd_mds, int count)
+#define mdunlink_iterate_helper(mds, count) \
+ __mdunlink_iterate_helper(mds, count, false)
+static void __mdunlink_iterate_helper(struct lnet_handle_md *bd_mds,
+ int count, bool discard)
{
int i;
for (i = 0; i < count; i++)
- LNetMDUnlink(bd_mds[i]);
+ __LNetMDUnlink(bd_mds[i], discard);
}
#ifdef HAVE_SERVER_SUPPORT
* but we must still wait_event_idle_timeout() in this case, to give
* us a chance to run server_bulk_callback()
*/
- mdunlink_iterate_helper(desc->bd_mds, desc->bd_md_max_brw);
+ __mdunlink_iterate_helper(desc->bd_mds, desc->bd_md_max_brw, true);
for (;;) {
/* Network access will complete in finite time but the HUGE
int ptlrpc_register_bulk(struct ptlrpc_request *req)
{
struct ptlrpc_bulk_desc *desc = req->rq_bulk;
- struct lnet_process_id peer;
+ struct lnet_processid peer;
int rc = 0;
int posted_md;
int total_md;
desc->bd_failure = 0;
- peer = desc->bd_import->imp_connection->c_peer;
+ peer.pid = desc->bd_import->imp_connection->c_peer.pid;
+ lnet_nid4_to_nid(desc->bd_import->imp_connection->c_peer.nid,
+ &peer.nid);
LASSERT(desc->bd_cbid.cbid_fn == client_bulk_callback);
LASSERT(desc->bd_cbid.cbid_arg == desc);
OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_BULK_ATTACH)) {
rc = -ENOMEM;
} else {
- me = LNetMEAttach(desc->bd_portal, peer, mbits, 0,
+ me = LNetMEAttach(desc->bd_portal, &peer, mbits, 0,
LNET_UNLINK, LNET_INS_AFTER);
rc = PTR_ERR_OR_ZERO(me);
}
/* Holler if peer manages to touch buffers before he knows the mbits */
if (desc->bd_refs != total_md)
CWARN("%s: Peer %s touched %d buffers while I registered\n",
- desc->bd_import->imp_obd->obd_name, libcfs_id2str(peer),
+ desc->bd_import->imp_obd->obd_name, libcfs_idstr(&peer),
total_md - desc->bd_refs);
spin_unlock(&desc->bd_lock);
LNET_ACK_REQ : LNET_NOACK_REQ,
&rs->rs_cb_id, req->rq_self, req->rq_source,
ptlrpc_req2svc(req)->srv_rep_portal,
- req->rq_xid, req->rq_reply_off, NULL);
+ req->rq_rep_mbits ? req->rq_rep_mbits : req->rq_xid,
+ req->rq_reply_off, NULL);
out:
if (unlikely(rc != 0))
ptlrpc_req_drop_rs(req);
int ptl_send_rpc(struct ptlrpc_request *request, int noreply)
{
int rc;
+ __u32 opc;
int mpflag = 0;
+ bool rep_mbits = false;
struct lnet_handle_md bulk_cookie;
+ struct lnet_processid peer;
struct ptlrpc_connection *connection;
struct lnet_me *reply_me = NULL;
struct lnet_md reply_md;
if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_DROP_RPC))
RETURN(0);
+ if (unlikely(OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_DELAY_RECOV) &&
+ lustre_msg_get_opc(request->rq_reqmsg) == MDS_CONNECT &&
+ strcmp(obd->obd_type->typ_name, LUSTRE_OSP_NAME) == 0)) {
+ RETURN(0);
+ }
+
LASSERT(request->rq_type == PTL_RPC_MSG_REQUEST);
LASSERT(request->rq_wait_ctx == 0);
"Allocating new XID for resend on EINPROGRESS");
}
- if (request->rq_bulk != NULL) {
- ptlrpc_set_bulk_mbits(request);
+ opc = lustre_msg_get_opc(request->rq_reqmsg);
+ if (opc != OST_CONNECT && opc != MDS_CONNECT &&
+ opc != MGS_CONNECT && OCD_HAS_FLAG(&imp->imp_connect_data, FLAGS2))
+ rep_mbits = imp->imp_connect_data.ocd_connect_flags2 &
+ OBD_CONNECT2_REP_MBITS;
+
+ if ((request->rq_bulk != NULL) || rep_mbits) {
+ ptlrpc_set_mbits(request);
lustre_msg_set_mbits(request->rq_reqmsg, request->rq_mbits);
}
request->rq_repmsg = NULL;
}
+ peer.pid = connection->c_peer.pid;
+ lnet_nid4_to_nid(connection->c_peer.nid, &peer.nid);
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);
+ &peer,
+ rep_mbits ? request->rq_mbits :
+ request->rq_xid,
+ 0, LNET_UNLINK, LNET_INS_AFTER);
}
if (IS_ERR(reply_me)) {
request->rq_deadline = request->rq_sent + request->rq_timeout +
ptlrpc_at_get_net_latency(request);
- ptlrpc_pinger_sending_on_import(imp);
-
DEBUG_REQ(D_INFO, request, "send flags=%x",
lustre_msg_get_flags(request->rq_reqmsg));
rc = ptl_send_buf(&request->rq_req_md_h,
int ptlrpc_register_rqbd(struct ptlrpc_request_buffer_desc *rqbd)
{
struct ptlrpc_service *service = rqbd->rqbd_svcpt->scp_service;
- static struct lnet_process_id match_id = {
- .nid = LNET_NID_ANY,
+ static struct lnet_processid match_id = {
+ .nid = LNET_ANY_NID,
.pid = LNET_PID_ANY
};
int rc;
struct lnet_md md;
struct lnet_me *me;
- CDEBUG(D_NET, "LNetMEAttach: portal %d\n",
- service->srv_req_portal);
+ CDEBUG(D_NET, "%s: registering portal %d\n", service->srv_name,
+ service->srv_req_portal);
- if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_RQBD))
- return (-ENOMEM);
+ if (OBD_FAIL_CHECK(OBD_FAIL_PTLRPC_RQBD))
+ return -ENOMEM;
/* NB: CPT affinity service should use new LNet flag LNET_INS_LOCAL,
* which means buffer can only be attached on local CPT, and LND
* threads can find it by grabbing a local lock */
me = LNetMEAttach(service->srv_req_portal,
- match_id, 0, ~0, LNET_UNLINK,
+ &match_id, 0, ~0, LNET_UNLINK,
rqbd->rqbd_svcpt->scp_cpt >= 0 ?
LNET_INS_LOCAL : LNET_INS_AFTER);
if (IS_ERR(me)) {
- CERROR("LNetMEAttach failed: %ld\n", PTR_ERR(me));
- return -ENOMEM;
+ CERROR("%s: LNetMEAttach failed: rc = %ld\n",
+ service->srv_name, PTR_ERR(me));
+ return PTR_ERR(me);
}
LASSERT(rqbd->rqbd_refcount == 0);
return 0;
}
- CERROR("ptlrpc: LNetMDAttach failed: rc = %d\n", rc);
+ CERROR("%s: LNetMDAttach failed: rc = %d\n", service->srv_name, rc);
LASSERT(rc == -ENOMEM);
- LASSERT(rc == 0);
rqbd->rqbd_refcount = 0;
- return -ENOMEM;
+ return rc;
}