}
int
-srpc_add_bulk_page(srpc_bulk_t *bk, cfs_page_t *pg, int i, int nob)
+srpc_add_bulk_page(srpc_bulk_t *bk, struct page *pg, int i, int nob)
{
- nob = min(nob, (int)CFS_PAGE_SIZE);
+ nob = min(nob, (int)PAGE_CACHE_SIZE);
LASSERT(nob > 0);
LASSERT(i >= 0 && i < bk->bk_niov);
bk->bk_pages[i] = pg;
bk->bk_iovs[i].iov_len = nob;
- bk->bk_iovs[i].iov_base = cfs_page_address(pg);
+ bk->bk_iovs[i].iov_base = page_address(pg);
#endif
return nob;
}
srpc_free_bulk (srpc_bulk_t *bk)
{
int i;
- cfs_page_t *pg;
+ struct page *pg;
LASSERT (bk != NULL);
#ifndef __KERNEL__
#endif
if (pg == NULL) break;
- cfs_free_page(pg);
+ __free_page(pg);
}
#ifndef __KERNEL__
- LIBCFS_FREE(bk->bk_pages, sizeof(cfs_page_t *) * bk->bk_niov);
+ LIBCFS_FREE(bk->bk_pages, sizeof(struct page *) * bk->bk_niov);
#endif
LIBCFS_FREE(bk, offsetof(srpc_bulk_t, bk_iovs[bk->bk_niov]));
return;
srpc_alloc_bulk(int cpt, unsigned bulk_npg, unsigned bulk_len, int sink)
{
srpc_bulk_t *bk;
- cfs_page_t **pages;
int i;
LASSERT(bulk_npg > 0 && bulk_npg <= LNET_MAX_IOV);
bk->bk_len = bulk_len;
bk->bk_niov = bulk_npg;
#ifndef __KERNEL__
- LIBCFS_CPT_ALLOC(pages, lnet_cpt_table(), cpt,
- sizeof(cfs_page_t *) * bulk_npg);
- if (pages == NULL) {
- LIBCFS_FREE(bk, offsetof(srpc_bulk_t, bk_iovs[bulk_npg]));
- CERROR("Can't allocate page array for %d pages\n", bulk_npg);
- return NULL;
- }
+ {
+ struct page **pages;
+
+ LIBCFS_CPT_ALLOC(pages, lnet_cpt_table(), cpt,
+ sizeof(struct page *) * bulk_npg);
+ if (pages == NULL) {
+ LIBCFS_FREE(bk, offsetof(srpc_bulk_t,
+ bk_iovs[bulk_npg]));
+ CERROR("Can't allocate page array for %d pages\n",
+ bulk_npg);
+ return NULL;
+ }
- memset(pages, 0, sizeof(cfs_page_t *) * bulk_npg);
- bk->bk_pages = pages;
-#else
- UNUSED(pages);
+ memset(pages, 0, sizeof(struct page *) * bulk_npg);
+ bk->bk_pages = pages;
+ }
#endif
for (i = 0; i < bulk_npg; i++) {
- cfs_page_t *pg;
+ struct page *pg;
int nob;
- pg = cfs_page_cpt_alloc(lnet_cpt_table(), cpt, CFS_ALLOC_STD);
+ pg = cfs_page_cpt_alloc(lnet_cpt_table(), cpt, GFP_IOFS);
if (pg == NULL) {
CERROR("Can't allocate page %d of %d\n", i, bulk_npg);
srpc_free_bulk(bk);
struct srpc_service_cd *scd;
struct srpc_server_rpc *rpc;
struct srpc_buffer *buf;
- cfs_list_t *q;
+ struct list_head *q;
int i;
if (svc->sv_cpt_data == NULL)
cfs_percpt_for_each(scd, i, svc->sv_cpt_data) {
while (1) {
- if (!cfs_list_empty(&scd->scd_buf_posted))
+ if (!list_empty(&scd->scd_buf_posted))
q = &scd->scd_buf_posted;
- else if (!cfs_list_empty(&scd->scd_buf_blocked))
+ else if (!list_empty(&scd->scd_buf_blocked))
q = &scd->scd_buf_blocked;
else
break;
- while (!cfs_list_empty(q)) {
- buf = cfs_list_entry(q->next,
+ while (!list_empty(q)) {
+ buf = list_entry(q->next,
struct srpc_buffer,
buf_list);
- cfs_list_del(&buf->buf_list);
+ list_del(&buf->buf_list);
LIBCFS_FREE(buf, sizeof(*buf));
}
}
- LASSERT(cfs_list_empty(&scd->scd_rpc_active));
+ LASSERT(list_empty(&scd->scd_rpc_active));
- while (!cfs_list_empty(&scd->scd_rpc_free)) {
- rpc = cfs_list_entry(scd->scd_rpc_free.next,
+ while (!list_empty(&scd->scd_rpc_free)) {
+ rpc = list_entry(scd->scd_rpc_free.next,
struct srpc_server_rpc,
srpc_list);
- cfs_list_del(&rpc->srpc_list);
+ list_del(&rpc->srpc_list);
LIBCFS_FREE(rpc, sizeof(*rpc));
}
}
scd->scd_cpt = i;
scd->scd_svc = svc;
spin_lock_init(&scd->scd_lock);
- CFS_INIT_LIST_HEAD(&scd->scd_rpc_free);
- CFS_INIT_LIST_HEAD(&scd->scd_rpc_active);
- CFS_INIT_LIST_HEAD(&scd->scd_buf_posted);
- CFS_INIT_LIST_HEAD(&scd->scd_buf_blocked);
+ INIT_LIST_HEAD(&scd->scd_rpc_free);
+ INIT_LIST_HEAD(&scd->scd_rpc_active);
+ INIT_LIST_HEAD(&scd->scd_buf_posted);
+ INIT_LIST_HEAD(&scd->scd_buf_blocked);
scd->scd_ev.ev_data = scd;
scd->scd_ev.ev_type = SRPC_REQUEST_RCVD;
srpc_service_fini(svc);
return -ENOMEM;
}
- cfs_list_add(&rpc->srpc_list, &scd->scd_rpc_free);
+ list_add(&rpc->srpc_list, &scd->scd_rpc_free);
}
}
int rc;
LNetInvalidateHandle(&buf->buf_mdh);
- cfs_list_add(&buf->buf_list, &scd->scd_buf_posted);
+ list_add(&buf->buf_list, &scd->scd_buf_posted);
scd->scd_buf_nposted++;
spin_unlock(&scd->scd_lock);
if (sv->sv_shuttingdown)
return rc; /* don't allow to change scd_buf_posted */
- cfs_list_del(&buf->buf_list);
+ list_del(&buf->buf_list);
spin_unlock(&scd->scd_lock);
LIBCFS_FREE(buf, sizeof(*buf));
return 0;
}
- if (cfs_list_empty(&scd->scd_rpc_active)) {
+ if (list_empty(&scd->scd_rpc_active)) {
spin_unlock(&scd->scd_lock);
continue;
}
- rpc = cfs_list_entry(scd->scd_rpc_active.next,
+ rpc = list_entry(scd->scd_rpc_active.next,
struct srpc_server_rpc, srpc_list);
CNETERR("Active RPC %p on shutdown: sv %s, peer %s, "
"wi %s scheduled %d running %d, "
/* 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 */
- cfs_list_for_each_entry(rpc, &scd->scd_rpc_active, srpc_list) {
+ list_for_each_entry(rpc, &scd->scd_rpc_active, srpc_list) {
rpc->srpc_aborted = 1;
swi_schedule_workitem(&rpc->srpc_wi);
}
spin_lock(&scd->scd_lock);
/* schedule in-flight RPCs to notice the shutdown */
- cfs_list_for_each_entry(rpc, &scd->scd_rpc_active, srpc_list)
+ list_for_each_entry(rpc, &scd->scd_rpc_active, srpc_list)
swi_schedule_workitem(&rpc->srpc_wi);
spin_unlock(&scd->scd_lock);
/* OK to traverse scd_buf_posted without lock, since no one
* touches scd_buf_posted now */
- cfs_list_for_each_entry(buf, &scd->scd_buf_posted, buf_list)
+ list_for_each_entry(buf, &scd->scd_buf_posted, buf_list)
LNetMDUnlink(buf->buf_mdh);
}
}
rpc->srpc_reqstbuf = NULL;
}
- cfs_list_del(&rpc->srpc_list); /* from scd->scd_rpc_active */
+ list_del(&rpc->srpc_list); /* from scd->scd_rpc_active */
/*
* No one can schedule me now since:
LASSERT(rpc->srpc_ev.ev_fired);
swi_exit_workitem(&rpc->srpc_wi);
- if (!sv->sv_shuttingdown && !cfs_list_empty(&scd->scd_buf_blocked)) {
- buffer = cfs_list_entry(scd->scd_buf_blocked.next,
+ if (!sv->sv_shuttingdown && !list_empty(&scd->scd_buf_blocked)) {
+ buffer = list_entry(scd->scd_buf_blocked.next,
srpc_buffer_t, buf_list);
- cfs_list_del(&buffer->buf_list);
+ list_del(&buffer->buf_list);
srpc_init_server_rpc(rpc, scd, buffer);
- cfs_list_add_tail(&rpc->srpc_list, &scd->scd_rpc_active);
+ list_add_tail(&rpc->srpc_list, &scd->scd_rpc_active);
swi_schedule_workitem(&rpc->srpc_wi);
} else {
- cfs_list_add(&rpc->srpc_list, &scd->scd_rpc_free);
+ list_add(&rpc->srpc_list, &scd->scd_rpc_free);
}
spin_unlock(&scd->scd_lock);
}
inline void
-srpc_add_client_rpc_timer (srpc_client_rpc_t *rpc)
+srpc_add_client_rpc_timer(srpc_client_rpc_t *rpc)
{
- stt_timer_t *timer = &rpc->crpc_timer;
+ stt_timer_t *timer = &rpc->crpc_timer;
- if (rpc->crpc_timeout == 0) return;
+ if (rpc->crpc_timeout == 0)
+ return;
- CFS_INIT_LIST_HEAD(&timer->stt_list);
- timer->stt_data = rpc;
- timer->stt_func = srpc_client_rpc_expired;
- timer->stt_expires = cfs_time_add(rpc->crpc_timeout,
- cfs_time_current_sec());
- stt_add_timer(timer);
- return;
+ INIT_LIST_HEAD(&timer->stt_list);
+ timer->stt_data = rpc;
+ timer->stt_func = srpc_client_rpc_expired;
+ timer->stt_expires = cfs_time_add(rpc->crpc_timeout,
+ cfs_time_current_sec());
+ stt_add_timer(timer);
+ return;
}
/*
while (rpc->crpc_timeout != 0) {
spin_unlock(&rpc->crpc_lock);
- cfs_schedule();
+ schedule();
spin_lock(&rpc->crpc_lock);
}
srpc_lnet_ev_handler(lnet_event_t *ev)
{
struct srpc_service_cd *scd;
- srpc_event_t *rpcev = ev->md.user_ptr;
- srpc_client_rpc_t *crpc;
- srpc_server_rpc_t *srpc;
- srpc_buffer_t *buffer;
- srpc_service_t *sv;
- srpc_msg_t *msg;
- srpc_msg_type_t type;
+ srpc_event_t *rpcev = ev->md.user_ptr;
+ srpc_client_rpc_t *crpc;
+ srpc_server_rpc_t *srpc;
+ srpc_buffer_t *buffer;
+ srpc_service_t *sv;
+ srpc_msg_t *msg;
+ srpc_msg_type_t type;
- LASSERT (!cfs_in_interrupt());
+ LASSERT (!in_interrupt());
- if (ev->status != 0) {
+ if (ev->status != 0) {
spin_lock(&srpc_data.rpc_glock);
srpc_data.rpc_counters.errors++;
spin_unlock(&srpc_data.rpc_glock);
- }
+ }
rpcev->ev_lnet = ev->type;
swi_schedule_workitem(&scd->scd_buf_wi);
}
- cfs_list_del(&buffer->buf_list); /* from scd->scd_buf_posted */
- msg = &buffer->buf_msg;
- type = srpc_service2request(sv->sv_id);
+ list_del(&buffer->buf_list); /* from scd->scd_buf_posted */
+ msg = &buffer->buf_msg;
+ type = srpc_service2request(sv->sv_id);
if (ev->status != 0 || ev->mlength != sizeof(*msg) ||
(msg->msg_type != type &&
msg->msg_magic = 0;
}
- if (!cfs_list_empty(&scd->scd_rpc_free)) {
- srpc = cfs_list_entry(scd->scd_rpc_free.next,
- struct srpc_server_rpc,
- srpc_list);
- cfs_list_del(&srpc->srpc_list);
+ if (!list_empty(&scd->scd_rpc_free)) {
+ srpc = list_entry(scd->scd_rpc_free.next,
+ struct srpc_server_rpc,
+ srpc_list);
+ list_del(&srpc->srpc_list);
srpc_init_server_rpc(srpc, scd, buffer);
- cfs_list_add_tail(&srpc->srpc_list,
- &scd->scd_rpc_active);
+ list_add_tail(&srpc->srpc_list,
+ &scd->scd_rpc_active);
swi_schedule_workitem(&srpc->srpc_wi);
} else {
- cfs_list_add_tail(&buffer->buf_list,
- &scd->scd_buf_blocked);
+ list_add_tail(&buffer->buf_list,
+ &scd->scd_buf_blocked);
}
spin_unlock(&scd->scd_lock);
git://git.whamcloud.com / fs / lustre-release.git / blobdiff