} srpc_state_t;
struct smoketest_rpc {
- spinlock_t rpc_glock; /* global lock */
+ cfs_spinlock_t rpc_glock; /* global lock */
srpc_service_t *rpc_services[SRPC_SERVICE_MAX_ID + 1];
lnet_handle_eq_t rpc_lnet_eq; /* _the_ LNet event queue */
srpc_state_t rpc_state;
void srpc_get_counters (srpc_counters_t *cnt)
{
- spin_lock(&srpc_data.rpc_glock);
+ cfs_spin_lock(&srpc_data.rpc_glock);
*cnt = srpc_data.rpc_counters;
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
}
void srpc_set_counters (const srpc_counters_t *cnt)
{
- spin_lock(&srpc_data.rpc_glock);
+ cfs_spin_lock(&srpc_data.rpc_glock);
srpc_data.rpc_counters = *cnt;
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
}
void
{
__u64 id;
- spin_lock(&srpc_data.rpc_glock);
+ cfs_spin_lock(&srpc_data.rpc_glock);
id = srpc_data.rpc_matchbits++;
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
return id;
}
LASSERT (sv->sv_concur > 0);
LASSERT (0 <= id && id <= SRPC_SERVICE_MAX_ID);
- spin_lock(&srpc_data.rpc_glock);
+ cfs_spin_lock(&srpc_data.rpc_glock);
LASSERT (srpc_data.rpc_state == SRPC_STATE_RUNNING);
if (srpc_data.rpc_services[id] != NULL) {
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
return -EBUSY;
}
srpc_data.rpc_services[id] = sv;
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
sv->sv_nprune = 0;
sv->sv_nposted_msg = 0;
sv->sv_shuttingdown = 0;
- spin_lock_init(&sv->sv_lock);
+ cfs_spin_lock_init(&sv->sv_lock);
CFS_INIT_LIST_HEAD(&sv->sv_free_rpcq);
CFS_INIT_LIST_HEAD(&sv->sv_active_rpcq);
CFS_INIT_LIST_HEAD(&sv->sv_posted_msgq);
LIBCFS_ALLOC(rpc, sizeof(*rpc));
if (rpc == NULL) goto enomem;
- list_add(&rpc->srpc_list, &sv->sv_free_rpcq);
+ cfs_list_add(&rpc->srpc_list, &sv->sv_free_rpcq);
}
CDEBUG (D_NET, "Adding service: id %d, name %s, concurrency %d\n",
return 0;
enomem:
- while (!list_empty(&sv->sv_free_rpcq)) {
- rpc = list_entry(sv->sv_free_rpcq.next,
- srpc_server_rpc_t, srpc_list);
- list_del(&rpc->srpc_list);
+ while (!cfs_list_empty(&sv->sv_free_rpcq)) {
+ rpc = cfs_list_entry(sv->sv_free_rpcq.next,
+ srpc_server_rpc_t, srpc_list);
+ cfs_list_del(&rpc->srpc_list);
LIBCFS_FREE(rpc, sizeof(*rpc));
}
- spin_lock(&srpc_data.rpc_glock);
+ cfs_spin_lock(&srpc_data.rpc_glock);
srpc_data.rpc_services[id] = NULL;
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
return -ENOMEM;
}
{
int id = sv->sv_id;
- spin_lock(&srpc_data.rpc_glock);
+ cfs_spin_lock(&srpc_data.rpc_glock);
if (srpc_data.rpc_services[id] != sv) {
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
return -ENOENT;
}
srpc_data.rpc_services[id] = NULL;
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
return 0;
}
LASSERT (!sv->sv_shuttingdown);
LNetInvalidateHandle(&buf->buf_mdh);
- list_add(&buf->buf_list, &sv->sv_posted_msgq);
+ cfs_list_add(&buf->buf_list, &sv->sv_posted_msgq);
sv->sv_nposted_msg++;
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
rc = srpc_post_passive_rqtbuf(sv->sv_id, msg, sizeof(*msg),
&buf->buf_mdh, &sv->sv_ev);
* msg and its event handler has been called. So we must add
* buf to sv_posted_msgq _before_ dropping sv_lock */
- spin_lock(&sv->sv_lock);
+ cfs_spin_lock(&sv->sv_lock);
if (rc == 0) {
if (sv->sv_shuttingdown) {
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
/* srpc_shutdown_service might have tried to unlink me
* when my buf_mdh was still invalid */
LNetMDUnlink(buf->buf_mdh);
- spin_lock(&sv->sv_lock);
+ cfs_spin_lock(&sv->sv_lock);
}
return 0;
}
sv->sv_nposted_msg--;
if (sv->sv_shuttingdown) return rc;
- list_del(&buf->buf_list);
+ cfs_list_del(&buf->buf_list);
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
LIBCFS_FREE(buf, sizeof(*buf));
- spin_lock(&sv->sv_lock);
+ cfs_spin_lock(&sv->sv_lock);
return rc;
}
LIBCFS_ALLOC(buf, sizeof(*buf));
if (buf == NULL) break;
- spin_lock(&sv->sv_lock);
+ cfs_spin_lock(&sv->sv_lock);
rc = srpc_service_post_buffer(sv, buf);
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
if (rc != 0) break;
}
LASSERTF (nbuffer > 0,
"nbuffer must be positive: %d\n", nbuffer);
- spin_lock(&sv->sv_lock);
+ cfs_spin_lock(&sv->sv_lock);
LASSERT (sv->sv_nprune >= 0);
LASSERT (!sv->sv_shuttingdown);
sv->sv_nprune += nbuffer;
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
return;
}
srpc_server_rpc_t *rpc;
srpc_buffer_t *buf;
- spin_lock(&sv->sv_lock);
+ cfs_spin_lock(&sv->sv_lock);
LASSERT (sv->sv_shuttingdown); /* srpc_shutdown_service called */
- if (sv->sv_nposted_msg != 0 || !list_empty(&sv->sv_active_rpcq)) {
+ if (sv->sv_nposted_msg != 0 || !cfs_list_empty(&sv->sv_active_rpcq)) {
CDEBUG (D_NET,
"waiting for %d posted buffers to unlink and "
"in-flight RPCs to die.\n",
sv->sv_nposted_msg);
- if (!list_empty(&sv->sv_active_rpcq)) {
- rpc = list_entry(sv->sv_active_rpcq.next,
- srpc_server_rpc_t, srpc_list);
+ if (!cfs_list_empty(&sv->sv_active_rpcq)) {
+ rpc = cfs_list_entry(sv->sv_active_rpcq.next,
+ srpc_server_rpc_t, srpc_list);
CDEBUG (D_NETERROR,
"Active RPC %p on shutdown: sv %s, peer %s, "
"wi %s scheduled %d running %d, "
rpc->srpc_ev.ev_lnet);
}
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
return 0;
}
- spin_unlock(&sv->sv_lock); /* no lock needed from now on */
+ cfs_spin_unlock(&sv->sv_lock); /* no lock needed from now on */
for (;;) {
- struct list_head *q;
+ cfs_list_t *q;
- if (!list_empty(&sv->sv_posted_msgq))
+ if (!cfs_list_empty(&sv->sv_posted_msgq))
q = &sv->sv_posted_msgq;
- else if (!list_empty(&sv->sv_blocked_msgq))
+ else if (!cfs_list_empty(&sv->sv_blocked_msgq))
q = &sv->sv_blocked_msgq;
else
break;
- buf = list_entry(q->next, srpc_buffer_t, buf_list);
- list_del(&buf->buf_list);
+ buf = cfs_list_entry(q->next, srpc_buffer_t, buf_list);
+ cfs_list_del(&buf->buf_list);
LIBCFS_FREE(buf, sizeof(*buf));
}
- while (!list_empty(&sv->sv_free_rpcq)) {
- rpc = list_entry(sv->sv_free_rpcq.next,
- srpc_server_rpc_t, srpc_list);
- list_del(&rpc->srpc_list);
+ while (!cfs_list_empty(&sv->sv_free_rpcq)) {
+ rpc = cfs_list_entry(sv->sv_free_rpcq.next,
+ srpc_server_rpc_t, srpc_list);
+ cfs_list_del(&rpc->srpc_list);
LIBCFS_FREE(rpc, sizeof(*rpc));
}
sv->sv_nprune--;
free:
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
LIBCFS_FREE(buf, sizeof(*buf));
- spin_lock(&sv->sv_lock);
+ cfs_spin_lock(&sv->sv_lock);
}
/* called with srpc_service_t::sv_lock held */
{
srpc_server_rpc_t *rpc;
- spin_lock(&sv->sv_lock);
+ cfs_spin_lock(&sv->sv_lock);
CDEBUG(D_NET, "Aborting service: id %d, name %s\n",
sv->sv_id, sv->sv_name);
/* schedule in-flight RPCs to notice the abort, NB:
* racing with incoming RPCs; complete fix should make test
* RPCs carry session ID in its headers */
- list_for_each_entry (rpc, &sv->sv_active_rpcq, srpc_list) {
+ cfs_list_for_each_entry (rpc, &sv->sv_active_rpcq, srpc_list) {
rpc->srpc_aborted = 1;
srpc_schedule_server_rpc(rpc);
}
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
return;
}
srpc_server_rpc_t *rpc;
srpc_buffer_t *buf;
- spin_lock(&sv->sv_lock);
+ cfs_spin_lock(&sv->sv_lock);
CDEBUG(D_NET, "Shutting down service: id %d, name %s\n",
sv->sv_id, sv->sv_name);
srpc_schedule_server_rpc(rpc);
}
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
/* OK to traverse sv_posted_msgq without lock, since no one
* touches sv_posted_msgq now */
swi_state2str(rpc->srpc_wi.wi_state), status);
if (status != 0) {
- spin_lock(&srpc_data.rpc_glock);
+ cfs_spin_lock(&srpc_data.rpc_glock);
srpc_data.rpc_counters.rpcs_dropped++;
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
}
if (rpc->srpc_done != NULL)
(*rpc->srpc_done) (rpc);
LASSERT (rpc->srpc_bulk == NULL);
- spin_lock(&sv->sv_lock);
+ cfs_spin_lock(&sv->sv_lock);
if (rpc->srpc_reqstbuf != NULL) {
/* NB might drop sv_lock in srpc_service_recycle_buffer, but
rpc->srpc_reqstbuf = NULL;
}
- list_del(&rpc->srpc_list); /* from sv->sv_active_rpcq */
+ cfs_list_del(&rpc->srpc_list); /* from sv->sv_active_rpcq */
/*
* No one can schedule me now since:
LASSERT (rpc->srpc_ev.ev_fired);
swi_kill_workitem(&rpc->srpc_wi);
- if (!sv->sv_shuttingdown && !list_empty(&sv->sv_blocked_msgq)) {
- buffer = list_entry(sv->sv_blocked_msgq.next,
+ if (!sv->sv_shuttingdown && !cfs_list_empty(&sv->sv_blocked_msgq)) {
+ buffer = cfs_list_entry(sv->sv_blocked_msgq.next,
srpc_buffer_t, buf_list);
- list_del(&buffer->buf_list);
+ cfs_list_del(&buffer->buf_list);
srpc_init_server_rpc(rpc, sv, buffer);
- list_add_tail(&rpc->srpc_list, &sv->sv_active_rpcq);
+ cfs_list_add_tail(&rpc->srpc_list, &sv->sv_active_rpcq);
srpc_schedule_server_rpc(rpc);
} else {
- list_add(&rpc->srpc_list, &sv->sv_free_rpcq);
+ cfs_list_add(&rpc->srpc_list, &sv->sv_free_rpcq);
}
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
return;
}
LASSERT (wi == &rpc->srpc_wi);
- spin_lock(&sv->sv_lock);
+ cfs_spin_lock(&sv->sv_lock);
if (sv->sv_shuttingdown || rpc->srpc_aborted) {
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
if (rpc->srpc_bulk != NULL)
LNetMDUnlink(rpc->srpc_bulk->bk_mdh);
return 0;
}
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
switch (wi->wi_state) {
default:
rpc->crpc_service, libcfs_id2str(rpc->crpc_dest),
rpc->crpc_timeout);
- spin_lock(&rpc->crpc_lock);
+ cfs_spin_lock(&rpc->crpc_lock);
rpc->crpc_timeout = 0;
srpc_abort_rpc(rpc, -ETIMEDOUT);
- spin_unlock(&rpc->crpc_lock);
+ cfs_spin_unlock(&rpc->crpc_lock);
- spin_lock(&srpc_data.rpc_glock);
+ cfs_spin_lock(&srpc_data.rpc_glock);
srpc_data.rpc_counters.rpcs_expired++;
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
return;
}
#ifdef __KERNEL__
/* timer detonated, wait for it to explode */
while (rpc->crpc_timeout != 0) {
- spin_unlock(&rpc->crpc_lock);
+ cfs_spin_unlock(&rpc->crpc_lock);
cfs_schedule();
- spin_lock(&rpc->crpc_lock);
+ cfs_spin_lock(&rpc->crpc_lock);
}
#else
LBUG(); /* impossible in single-threaded runtime */
LASSERT (status != 0 || wi->wi_state == SWI_STATE_DONE);
- spin_lock(&rpc->crpc_lock);
+ cfs_spin_lock(&rpc->crpc_lock);
rpc->crpc_closed = 1;
if (rpc->crpc_status == 0)
LASSERT (!srpc_event_pending(rpc));
swi_kill_workitem(wi);
- spin_unlock(&rpc->crpc_lock);
+ cfs_spin_unlock(&rpc->crpc_lock);
(*rpc->crpc_done) (rpc);
return;
LASSERT (rpc != NULL);
LASSERT (wi == &rpc->crpc_wi);
- spin_lock(&rpc->crpc_lock);
+ cfs_spin_lock(&rpc->crpc_lock);
if (rpc->crpc_aborted) {
- spin_unlock(&rpc->crpc_lock);
+ cfs_spin_unlock(&rpc->crpc_lock);
goto abort;
}
- spin_unlock(&rpc->crpc_lock);
+ cfs_spin_unlock(&rpc->crpc_lock);
switch (wi->wi_state) {
default:
}
if (rc != 0) {
- spin_lock(&rpc->crpc_lock);
+ cfs_spin_lock(&rpc->crpc_lock);
srpc_abort_rpc(rpc, rc);
- spin_unlock(&rpc->crpc_lock);
+ cfs_spin_unlock(&rpc->crpc_lock);
}
abort:
LASSERT (buffer != NULL);
rpyid = buffer->buf_msg.msg_body.reqst.rpyid;
- spin_lock(&sv->sv_lock);
+ cfs_spin_lock(&sv->sv_lock);
if (!sv->sv_shuttingdown &&
sv->sv_id > SRPC_FRAMEWORK_SERVICE_MAX_ID) {
rpc->srpc_reqstbuf = NULL;
}
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
ev->ev_fired = 0;
ev->ev_data = rpc;
srpc_msg_t *msg;
srpc_msg_type_t type;
- LASSERT (!in_interrupt());
+ LASSERT (!cfs_in_interrupt());
if (ev->status != 0) {
- spin_lock(&srpc_data.rpc_glock);
+ cfs_spin_lock(&srpc_data.rpc_glock);
srpc_data.rpc_counters.errors++;
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
}
rpcev->ev_lnet = ev->type;
LBUG ();
case SRPC_REQUEST_SENT:
if (ev->status == 0 && ev->type != LNET_EVENT_UNLINK) {
- spin_lock(&srpc_data.rpc_glock);
+ cfs_spin_lock(&srpc_data.rpc_glock);
srpc_data.rpc_counters.rpcs_sent++;
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
}
case SRPC_REPLY_RCVD:
case SRPC_BULK_REQ_RCVD:
LBUG ();
}
- spin_lock(&crpc->crpc_lock);
+ cfs_spin_lock(&crpc->crpc_lock);
LASSERT (rpcev->ev_fired == 0);
rpcev->ev_fired = 1;
-EINTR : ev->status;
swi_schedule_workitem(&crpc->crpc_wi);
- spin_unlock(&crpc->crpc_lock);
+ cfs_spin_unlock(&crpc->crpc_lock);
break;
case SRPC_REQUEST_RCVD:
LASSERT (rpcev == &sv->sv_ev);
- spin_lock(&sv->sv_lock);
+ cfs_spin_lock(&sv->sv_lock);
LASSERT (ev->unlinked);
LASSERT (ev->type == LNET_EVENT_PUT ||
if (sv->sv_shuttingdown) {
/* Leave buffer on sv->sv_posted_msgq since
* srpc_finish_service needs to traverse it. */
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
break;
}
- list_del(&buffer->buf_list); /* from sv->sv_posted_msgq */
+ cfs_list_del(&buffer->buf_list); /* from sv->sv_posted_msgq */
msg = &buffer->buf_msg;
type = srpc_service2request(sv->sv_id);
msg->msg_magic = 0;
}
- if (!list_empty(&sv->sv_free_rpcq)) {
- srpc = list_entry(sv->sv_free_rpcq.next,
- srpc_server_rpc_t, srpc_list);
- list_del(&srpc->srpc_list);
+ if (!cfs_list_empty(&sv->sv_free_rpcq)) {
+ srpc = cfs_list_entry(sv->sv_free_rpcq.next,
+ srpc_server_rpc_t, srpc_list);
+ cfs_list_del(&srpc->srpc_list);
srpc_init_server_rpc(srpc, sv, buffer);
- list_add_tail(&srpc->srpc_list, &sv->sv_active_rpcq);
+ cfs_list_add_tail(&srpc->srpc_list,
+ &sv->sv_active_rpcq);
srpc_schedule_server_rpc(srpc);
} else {
- list_add_tail(&buffer->buf_list, &sv->sv_blocked_msgq);
+ cfs_list_add_tail(&buffer->buf_list,
+ &sv->sv_blocked_msgq);
}
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
- spin_lock(&srpc_data.rpc_glock);
+ cfs_spin_lock(&srpc_data.rpc_glock);
srpc_data.rpc_counters.rpcs_rcvd++;
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
break;
case SRPC_BULK_GET_RPLD:
case SRPC_BULK_PUT_SENT:
if (ev->status == 0 && ev->type != LNET_EVENT_UNLINK) {
- spin_lock(&srpc_data.rpc_glock);
+ cfs_spin_lock(&srpc_data.rpc_glock);
if (rpcev->ev_type == SRPC_BULK_GET_RPLD)
srpc_data.rpc_counters.bulk_get += ev->mlength;
else
srpc_data.rpc_counters.bulk_put += ev->mlength;
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
}
case SRPC_REPLY_SENT:
srpc = rpcev->ev_data;
LASSERT (rpcev == &srpc->srpc_ev);
- spin_lock(&sv->sv_lock);
+ cfs_spin_lock(&sv->sv_lock);
rpcev->ev_fired = 1;
rpcev->ev_status = (ev->type == LNET_EVENT_UNLINK) ?
-EINTR : ev->status;
srpc_schedule_server_rpc(srpc);
- spin_unlock(&sv->sv_lock);
+ cfs_spin_unlock(&sv->sv_lock);
break;
}
int rc;
memset(&srpc_data, 0, sizeof(struct smoketest_rpc));
- spin_lock_init(&srpc_data.rpc_glock);
+ cfs_spin_lock_init(&srpc_data.rpc_glock);
/* 1 second pause to avoid timestamp reuse */
cfs_pause(cfs_time_seconds(1));
default:
LBUG ();
case SRPC_STATE_RUNNING:
- spin_lock(&srpc_data.rpc_glock);
+ cfs_spin_lock(&srpc_data.rpc_glock);
for (i = 0; i <= SRPC_SERVICE_MAX_ID; i++) {
srpc_service_t *sv = srpc_data.rpc_services[i];
i, sv->sv_name);
}
- spin_unlock(&srpc_data.rpc_glock);
+ cfs_spin_unlock(&srpc_data.rpc_glock);
stt_shutdown();
git://git.whamcloud.com / fs / lustre-release.git / blobdiff