cl->cli_reply_portal = rep_portal;
cl->cli_name = name;
}
+EXPORT_SYMBOL(ptlrpc_init_client);
/**
* Return PortalRPC connection for remore uud \a uuid
return c;
}
+EXPORT_SYMBOL(ptlrpc_uuid_to_connection);
/**
* Allocate and initialize new bulk descriptor
return desc;
}
+EXPORT_SYMBOL(ptlrpc_prep_bulk_imp);
/**
* Add a page \a page to the bulk descriptor \a desc.
* Data to transfer in the page starts at offset \a pageoffset and
* amount of data to transfer from the page is \a len
*/
-void ptlrpc_prep_bulk_page(struct ptlrpc_bulk_desc *desc,
- cfs_page_t *page, int pageoffset, int len)
+void __ptlrpc_prep_bulk_page(struct ptlrpc_bulk_desc *desc,
+ cfs_page_t *page, int pageoffset, int len, int pin)
{
LASSERT(desc->bd_iov_count < desc->bd_max_iov);
LASSERT(page != NULL);
desc->bd_nob += len;
- cfs_page_pin(page);
+ if (pin)
+ cfs_page_pin(page);
+
ptlrpc_add_bulk_page(desc, page, pageoffset, len);
}
+EXPORT_SYMBOL(__ptlrpc_prep_bulk_page);
/**
* Uninitialize and free bulk descriptor \a desc.
* Works on bulk descriptors both from server and client side.
*/
-void ptlrpc_free_bulk(struct ptlrpc_bulk_desc *desc)
+void __ptlrpc_free_bulk(struct ptlrpc_bulk_desc *desc, int unpin)
{
int i;
ENTRY;
else
class_import_put(desc->bd_import);
- for (i = 0; i < desc->bd_iov_count ; i++)
- cfs_page_unpin(desc->bd_iov[i].kiov_page);
+ if (unpin) {
+ for (i = 0; i < desc->bd_iov_count ; i++)
+ cfs_page_unpin(desc->bd_iov[i].kiov_page);
+ }
OBD_FREE(desc, offsetof(struct ptlrpc_bulk_desc,
bd_iov[desc->bd_max_iov]));
EXIT;
}
+EXPORT_SYMBOL(__ptlrpc_free_bulk);
/**
* Set server timelimit for this req, i.e. how long are we willing to wait
reqmsg*/
lustre_msg_set_timeout(req->rq_reqmsg, req->rq_timeout);
}
+EXPORT_SYMBOL(ptlrpc_at_set_req_timeout);
/* Adjust max service estimate based on server value */
static void ptlrpc_at_adj_service(struct ptlrpc_request *req,
cfs_spin_unlock(&pool->prp_lock);
OBD_FREE(pool, sizeof(*pool));
}
+EXPORT_SYMBOL(ptlrpc_free_rq_pool);
/**
* Allocates, initializes and adds \a num_rq requests to the pool \a pool
cfs_spin_unlock(&pool->prp_lock);
return;
}
+EXPORT_SYMBOL(ptlrpc_add_rqs_to_pool);
/**
* Create and initialize new request pool with given attributes:
}
return pool;
}
+EXPORT_SYMBOL(ptlrpc_init_rq_pool);
/**
* Fetches one request from pool \a pool
return rc;
}
+EXPORT_SYMBOL(ptlrpc_request_pack);
/**
* Helper function to allocate new request on import \a imp
{
return ptlrpc_request_alloc_internal(imp, NULL, format);
}
+EXPORT_SYMBOL(ptlrpc_request_alloc);
/**
* Allocate new request structure for import \a imp from pool \a pool and
{
return ptlrpc_request_alloc_internal(imp, pool, format);
}
+EXPORT_SYMBOL(ptlrpc_request_alloc_pool);
/**
* For requests not from pool, free memory of the request structure.
else
OBD_FREE_PTR(request);
}
+EXPORT_SYMBOL(ptlrpc_request_free);
/**
* Allocate new request for operatione \a opcode and immediatelly pack it for
}
return req;
}
+EXPORT_SYMBOL(ptlrpc_request_alloc_pack);
/**
* Prepare request (fetched from pool \a poolif not NULL) on import \a imp
}
return request;
}
+EXPORT_SYMBOL(ptlrpc_prep_req_pool);
/**
* Same as ptlrpc_prep_req_pool, but without pool
return ptlrpc_prep_req_pool(imp, version, opcode, count, lengths, bufs,
NULL);
}
+EXPORT_SYMBOL(ptlrpc_prep_req);
/**
* Allocate "fake" request that would not be sent anywhere in the end.
RETURN(request);
}
+EXPORT_SYMBOL(ptlrpc_prep_fakereq);
/**
* Indicate that processing of "fake" request is finished.
cfs_waitq_signal(&set->set_waitq);
ptlrpc_req_finished(req);
}
+EXPORT_SYMBOL(ptlrpc_fakereq_finished);
/**
* Allocate and initialize new request set structure.
RETURN(set);
}
+EXPORT_SYMBOL(ptlrpc_prep_set);
/**
* Allocate and initialize new request set structure with flow control
ptlrpc_reqset_put(set);
EXIT;
}
+EXPORT_SYMBOL(ptlrpc_set_destroy);
/**
* Add a callback function \a fn to the set.
RETURN(0);
}
+EXPORT_SYMBOL(ptlrpc_set_add_cb);
/**
* Add a new request to the general purpose request set.
void ptlrpc_set_add_req(struct ptlrpc_request_set *set,
struct ptlrpc_request *req)
{
- char jobid[JOBSTATS_JOBID_SIZE];
LASSERT(cfs_list_empty(&req->rq_set_chain));
/* The set takes over the caller's request reference */
cfs_atomic_inc(&set->set_remaining);
req->rq_queued_time = cfs_time_current();
- if (req->rq_reqmsg) {
- lustre_get_jobid(jobid);
- lustre_msg_set_jobid(req->rq_reqmsg, jobid);
- }
+ if (req->rq_reqmsg != NULL)
+ lustre_msg_set_jobid(req->rq_reqmsg, NULL);
if (set->set_producer != NULL)
/* If the request set has a producer callback, the RPC must be
* sent straight away */
ptlrpc_send_new_req(req);
}
+EXPORT_SYMBOL(ptlrpc_set_add_req);
/**
* Add a request to a request with dedicated server thread
cfs_waitq_signal(&pc->pc_partners[i]->pc_set->set_waitq);
}
}
+EXPORT_SYMBOL(ptlrpc_set_add_new_req);
/**
* Based on the current state of the import, determine if the request
if (lustre_msg_get_type(req->rq_repmsg) == PTL_RPC_MSG_ERR) {
struct obd_import *imp = req->rq_import;
__u32 opc = lustre_msg_get_opc(req->rq_reqmsg);
- LCONSOLE_ERROR_MSG(0x011,"an error occurred while communicating"
- " with %s. The %s operation failed with %d\n",
- libcfs_nid2str(imp->imp_connection->c_peer.nid),
- ll_opcode2str(opc), err);
- RETURN(err < 0 ? err : -EINVAL);
- }
-
- if (err < 0) {
- DEBUG_REQ(D_INFO, req, "status is %d", err);
- } else if (err > 0) {
- /* XXX: translate this error from net to host */
- DEBUG_REQ(D_INFO, req, "status is %d", err);
- }
-
- if (lustre_msg_get_type(req->rq_repmsg) == PTL_RPC_MSG_ERR) {
- struct obd_import *imp = req->rq_import;
- __u32 opc = lustre_msg_get_opc(req->rq_reqmsg);
-
if (ptlrpc_console_allow(req))
LCONSOLE_ERROR_MSG(0x011,"an error occurred while "
"communicating with %s. The %s "
libcfs_nid2str(
imp->imp_connection->c_peer.nid),
ll_opcode2str(opc), err);
-
RETURN(err < 0 ? err : -EINVAL);
}
+ if (err < 0) {
+ DEBUG_REQ(D_INFO, req, "status is %d", err);
+ } else if (err > 0) {
+ /* XXX: translate this error from net to host */
+ DEBUG_REQ(D_INFO, req, "status is %d", err);
+ }
+
RETURN(err);
}
ptlrpc_rqphase_move(req, RQ_PHASE_COMPLETE);
- CDEBUG(D_RPCTRACE, "Completed RPC pname:cluuid:pid:xid:nid:"
- "opc %s:%s:%d:"LPU64":%s:%d\n", cfs_curproc_comm(),
- imp->imp_obd->obd_uuid.uuid,
- req->rq_reqmsg ? lustre_msg_get_status(req->rq_reqmsg):-1,
- req->rq_xid,
- libcfs_nid2str(imp->imp_connection->c_peer.nid),
- req->rq_reqmsg ? lustre_msg_get_opc(req->rq_reqmsg) : -1);
+ CDEBUG(req->rq_reqmsg != NULL ? D_RPCTRACE : 0,
+ "Completed RPC pname:cluuid:pid:xid:nid:"
+ "opc %s:%s:%d:"LPU64":%s:%d\n",
+ cfs_curproc_comm(), imp->imp_obd->obd_uuid.uuid,
+ lustre_msg_get_status(req->rq_reqmsg), req->rq_xid,
+ libcfs_nid2str(imp->imp_connection->c_peer.nid),
+ lustre_msg_get_opc(req->rq_reqmsg));
cfs_spin_lock(&imp->imp_lock);
/* Request already may be not on sending or delaying list. This
/* If we hit an error, we want to recover promptly. */
RETURN(cfs_atomic_read(&set->set_remaining) == 0 || force_timer_recalc);
}
+EXPORT_SYMBOL(ptlrpc_check_set);
/**
* Time out request \a req. is \a async_unlink is set, that means do not wait
*/
RETURN(1);
}
+EXPORT_SYMBOL(ptlrpc_expired_set);
/**
* Sets rq_intr flag in \a req under spinlock.
req->rq_intr = 1;
cfs_spin_unlock(&req->rq_lock);
}
+EXPORT_SYMBOL(ptlrpc_mark_interrupted);
/**
* Interrupts (sets interrupted flag) all uncompleted requests in
ptlrpc_mark_interrupted(req);
}
}
+EXPORT_SYMBOL(ptlrpc_interrupted_set);
/**
* Get the smallest timeout in the set; this does NOT set a timeout.
}
RETURN(timeout);
}
+EXPORT_SYMBOL(ptlrpc_set_next_timeout);
/**
* Send all unset request from the set and then wait untill all
RETURN(rc);
}
+EXPORT_SYMBOL(ptlrpc_set_wait);
/**
* Helper fuction for request freeing.
LASSERT_SPIN_LOCKED(&request->rq_import->imp_lock);
(void)__ptlrpc_req_finished(request, 1);
}
+EXPORT_SYMBOL(ptlrpc_req_finished_with_imp_lock);
/**
* Helper function
{
__ptlrpc_req_finished(request, 0);
}
+EXPORT_SYMBOL(ptlrpc_req_finished);
/**
* Returns xid of a \a request
}
RETURN(0);
}
+EXPORT_SYMBOL(ptlrpc_unregister_reply);
/**
* Iterates through replay_list on import and prunes
EXIT;
return;
}
+EXPORT_SYMBOL(ptlrpc_cleanup_client);
/**
* Schedule previously sent request for resend.
ptlrpc_client_wake_req(req);
cfs_spin_unlock(&req->rq_lock);
}
+EXPORT_SYMBOL(ptlrpc_resend_req);
/* XXX: this function and rq_status are currently unused */
void ptlrpc_restart_req(struct ptlrpc_request *req)
ptlrpc_client_wake_req(req);
cfs_spin_unlock(&req->rq_lock);
}
+EXPORT_SYMBOL(ptlrpc_restart_req);
/**
* Grab additional reference on a request \a req
cfs_atomic_inc(&req->rq_refcount);
RETURN(req);
}
+EXPORT_SYMBOL(ptlrpc_request_addref);
/**
* Add a request to import replay_list.
cfs_list_add(&req->rq_replay_list, &imp->imp_replay_list);
}
+EXPORT_SYMBOL(ptlrpc_retain_replayable_request);
/**
* Send request and wait until it completes.
RETURN(rc);
}
+EXPORT_SYMBOL(ptlrpc_queue_wait);
struct ptlrpc_replay_async_args {
int praa_old_state;
ptlrpcd_add_req(req, PDL_POLICY_LOCAL, -1);
RETURN(0);
}
+EXPORT_SYMBOL(ptlrpc_replay_req);
/**
* Aborts all in-flight request on import \a imp sending and delayed lists
EXIT;
}
+EXPORT_SYMBOL(ptlrpc_abort_inflight);
/**
* Abort all uncompleted requests in request set \a set
cfs_spin_unlock(&ptlrpc_last_xid_lock);
return tmp;
}
+EXPORT_SYMBOL(ptlrpc_next_xid);
/**
* Get a glimpse at what next xid value might have been.
git://git.whamcloud.com / fs / lustre-release.git / blobdiff