{
int rc;
kgn_peer_t *peer, *new_peer;
- CFS_LIST_HEAD(zombies);
+ LIST_HEAD(zombies);
write_lock(&kgnilnd_data.kgn_peer_conn_lock);
peer = kgnilnd_find_peer_locked(nid);
/* OK to call kgnilnd_api_shutdown() to cleanup now */
kgnilnd_data.kgn_init = GNILND_INIT_DATA;
- PORTAL_MODULE_USE;
+ try_module_get(THIS_MODULE);
rwlock_init(&kgnilnd_data.kgn_peer_conn_lock);
}
kgnilnd_data.kgn_mbox_cache =
- cfs_mem_cache_create("kgn_mbox_block",
- KMALLOC_MAX_SIZE,
- 0, /* offset */
- SLAB_HWCACHE_ALIGN); /* flags */
+ kmem_cache_create("kgn_mbox_block", KMALLOC_MAX_SIZE, 0,
+ SLAB_HWCACHE_ALIGN, NULL);
if (kgnilnd_data.kgn_mbox_cache == NULL) {
CERROR("Can't create slab for physical mbox blocks\n");
rc = -ENOMEM;
}
kgnilnd_data.kgn_rx_cache =
- cfs_mem_cache_create("kgn_rx_t",
- sizeof(kgn_rx_t),
- 0, /* offset */
- 0); /* flags */
+ kmem_cache_create("kgn_rx_t", sizeof(kgn_rx_t), 0, 0, NULL);
if (kgnilnd_data.kgn_rx_cache == NULL) {
CERROR("Can't create slab for kgn_rx_t descriptors\n");
rc = -ENOMEM;
}
kgnilnd_data.kgn_tx_cache =
- cfs_mem_cache_create("kgn_tx_t",
- sizeof(kgn_tx_t),
- 0, /* offset */
- 0); /* flags */
+ kmem_cache_create("kgn_tx_t", sizeof(kgn_tx_t), 0, 0, NULL);
if (kgnilnd_data.kgn_tx_cache == NULL) {
CERROR("Can't create slab for kgn_tx_t\n");
rc = -ENOMEM;
}
kgnilnd_data.kgn_tx_phys_cache =
- cfs_mem_cache_create("kgn_tx_phys",
- LNET_MAX_IOV * sizeof(gni_mem_segment_t),
- 0, /* offset */
- 0); /* flags */
+ kmem_cache_create("kgn_tx_phys",
+ LNET_MAX_IOV * sizeof(gni_mem_segment_t),
+ 0, 0, NULL);
if (kgnilnd_data.kgn_tx_phys_cache == NULL) {
CERROR("Can't create slab for kgn_tx_phys\n");
rc = -ENOMEM;
}
kgnilnd_data.kgn_dgram_cache =
- cfs_mem_cache_create("kgn_dgram_t",
- sizeof(kgn_dgram_t),
- 0, /* offset */
- 0); /* flags */
+ kmem_cache_create("kgn_dgram_t", sizeof(kgn_dgram_t), 0, 0, NULL);
if (kgnilnd_data.kgn_dgram_cache == NULL) {
CERROR("Can't create slab for outgoing datagrams\n");
rc = -ENOMEM;
kgnilnd_free_phys_fmablk(dev);
}
- if (kgnilnd_data.kgn_mbox_cache != NULL) {
- i = cfs_mem_cache_destroy(kgnilnd_data.kgn_mbox_cache);
- LASSERTF(i == 0, "rc %d destroying kgn_mbox_cache\n", i);
- }
+ if (kgnilnd_data.kgn_mbox_cache != NULL)
+ kmem_cache_destroy(kgnilnd_data.kgn_mbox_cache);
- if (kgnilnd_data.kgn_rx_cache != NULL) {
- i = cfs_mem_cache_destroy(kgnilnd_data.kgn_rx_cache);
- LASSERTF(i == 0, "rc %d destroying kgn_rx_cache\n", i);
- }
+ if (kgnilnd_data.kgn_rx_cache != NULL)
+ kmem_cache_destroy(kgnilnd_data.kgn_rx_cache);
- if (kgnilnd_data.kgn_tx_cache != NULL) {
- i = cfs_mem_cache_destroy(kgnilnd_data.kgn_tx_cache);
- LASSERTF(i == 0, "rc %d destroying kgn_tx_cache\n", i);
- }
+ if (kgnilnd_data.kgn_tx_cache != NULL)
+ kmem_cache_destroy(kgnilnd_data.kgn_tx_cache);
- if (kgnilnd_data.kgn_tx_phys_cache != NULL) {
- i = cfs_mem_cache_destroy(kgnilnd_data.kgn_tx_phys_cache);
- LASSERTF(i == 0, "rc %d destroying kgn_tx_phys_cache\n", i);
- }
+ if (kgnilnd_data.kgn_tx_phys_cache != NULL)
+ kmem_cache_destroy(kgnilnd_data.kgn_tx_phys_cache);
- if (kgnilnd_data.kgn_dgram_cache != NULL) {
- i = cfs_mem_cache_destroy(kgnilnd_data.kgn_dgram_cache);
- LASSERTF(i == 0, "rc %d destroying kgn_dgram_cache\n", i);
- }
+ if (kgnilnd_data.kgn_dgram_cache != NULL)
+ kmem_cache_destroy(kgnilnd_data.kgn_dgram_cache);
if (kgnilnd_data.kgn_cksum_map_pages != NULL) {
for (i = 0; i < kgnilnd_data.kgn_cksum_npages; i++) {
atomic_read(&libcfs_kmemory));
kgnilnd_data.kgn_init = GNILND_INIT_NOTHING;
- PORTAL_MODULE_UNUSE;
+ module_put(THIS_MODULE);
EXIT;
}
unsigned long gnp_last_alive; /* last time I had valid comms */
int gnp_last_dgram_errno; /* last error dgrams saw */
unsigned long gnp_last_dgram_time; /* last time I tried to connect */
- unsigned long gnp_reconnect_time; /* CURRENT_SECONDS when reconnect OK */
+ unsigned long gnp_reconnect_time; /* get_seconds() when reconnect OK */
unsigned long gnp_reconnect_interval; /* exponential backoff */
atomic_t gnp_dirty_eps; /* # of old but yet to be destroyed EPs from conns */
int gnp_down; /* rca says peer down */
wait_queue_head_t kgn_reaper_waitq; /* reaper sleeps here */
spinlock_t kgn_reaper_lock; /* serialise */
- cfs_mem_cache_t *kgn_rx_cache; /* rx descriptor space */
- cfs_mem_cache_t *kgn_tx_cache; /* tx descriptor memory */
- cfs_mem_cache_t *kgn_tx_phys_cache; /* tx phys descriptor memory */
+ struct kmem_cache *kgn_rx_cache; /* rx descriptor space */
+ struct kmem_cache *kgn_tx_cache; /* tx descriptor memory */
+ struct kmem_cache *kgn_tx_phys_cache; /* tx phys descriptor memory */
atomic_t kgn_ntx; /* # tx in use */
- cfs_mem_cache_t *kgn_dgram_cache; /* outgoing datagrams */
+ struct kmem_cache *kgn_dgram_cache; /* outgoing datagrams */
struct page ***kgn_cksum_map_pages; /* page arrays for mapping pages on checksum */
__u64 kgn_cksum_npages; /* Number of pages allocated for checksumming */
(atomic_read(&kgnilnd_data.kgn_nquiesce) == \
atomic_read(&kgnilnd_data.kgn_nthreads))
-#define KGNILND_SPIN_QUIESCE \
-do { \
- /* E.T phone home */ \
- atomic_inc(&kgnilnd_data.kgn_nquiesce); \
- CDEBUG(D_NET, "Waiting for thread pause to be over...\n"); \
- while (kgnilnd_data.kgn_quiesce_trigger) { \
- set_current_state(TASK_INTERRUPTIBLE); \
- cfs_schedule_timeout_and_set_state(TASK_INTERRUPTIBLE, \
- cfs_time_seconds(1)); \
- } \
- /* Mom, my homework is done */ \
- CDEBUG(D_NET, "Waking up from thread pause\n"); \
- atomic_dec(&kgnilnd_data.kgn_nquiesce); \
+#define KGNILND_SPIN_QUIESCE \
+do { \
+ /* E.T phone home */ \
+ atomic_inc(&kgnilnd_data.kgn_nquiesce); \
+ CDEBUG(D_NET, "Waiting for thread pause to be over...\n"); \
+ while (kgnilnd_data.kgn_quiesce_trigger) { \
+ set_current_state(TASK_INTERRUPTIBLE); \
+ schedule_timeout(HZ); \
+ } \
+ /* Mom, my homework is done */ \
+ CDEBUG(D_NET, "Waking up from thread pause\n"); \
+ atomic_dec(&kgnilnd_data.kgn_nquiesce); \
} while(0)
/* use macros for addref/decref to get the calling function name in the CDEBUG */
/* we only allocate this if we need to */
if (tx->tx_phys != NULL) {
- cfs_mem_cache_free(kgnilnd_data.kgn_tx_phys_cache, tx->tx_phys);
+ kmem_cache_free(kgnilnd_data.kgn_tx_phys_cache, tx->tx_phys);
CDEBUG(D_MALLOC, "slab-freed 'tx_phys': %lu at %p.\n",
LNET_MAX_IOV * sizeof(gni_mem_segment_t), tx->tx_phys);
}
#if 0
KGNILND_POISON(tx, 0x5a, sizeof(kgn_tx_t));
#endif
- cfs_mem_cache_free(kgnilnd_data.kgn_tx_cache, tx);
+ kmem_cache_free(kgnilnd_data.kgn_tx_cache, tx);
CDEBUG(D_MALLOC, "slab-freed 'tx': %lu at %p.\n",
sizeof(*tx), tx);
}
if (CFS_FAIL_CHECK(CFS_FAIL_GNI_ALLOC_TX))
return tx;
- tx = cfs_mem_cache_alloc(kgnilnd_data.kgn_tx_cache, CFS_ALLOC_ATOMIC);
+ tx = kmem_cache_alloc(kgnilnd_data.kgn_tx_cache, GFP_ATOMIC);
if (tx == NULL) {
CERROR("failed to allocate tx\n");
return NULL;
* than kiov_len, we will also have a whole at the end of that page
* which isn't allowed */
if ((kiov[i].kiov_offset != 0 && i > 0) ||
- (kiov[i].kiov_offset + kiov[i].kiov_len != CFS_PAGE_SIZE && i < niov - 1)) {
+ (kiov[i].kiov_offset + kiov[i].kiov_len != PAGE_SIZE && i < niov - 1)) {
CNETERR("Can't make payload contiguous in I/O VM:"
"page %d, offset %u, nob %u, kiov_offset %u kiov_len %u \n",
i, offset, nob, kiov->kiov_offset, kiov->kiov_len);
LASSERT(tx->tx_buftype == GNILND_BUF_NONE);
/* only allocate this if we are going to use it */
- tx->tx_phys = cfs_mem_cache_alloc(kgnilnd_data.kgn_tx_phys_cache,
- CFS_ALLOC_ATOMIC);
+ tx->tx_phys = kmem_cache_alloc(kgnilnd_data.kgn_tx_phys_cache,
+ GFP_ATOMIC);
if (tx->tx_phys == NULL) {
CERROR("failed to allocate tx_phys\n");
rc = -ENOMEM;
error:
if (tx->tx_phys != NULL) {
- cfs_mem_cache_free(kgnilnd_data.kgn_tx_phys_cache, tx->tx_phys);
+ kmem_cache_free(kgnilnd_data.kgn_tx_phys_cache, tx->tx_phys);
CDEBUG(D_MALLOC, "slab-freed 'tx_phys': %lu at %p.\n",
sizeof(*tx->tx_phys), tx->tx_phys);
tx->tx_phys = NULL;
{
kgn_rx_t *rx;
- rx = cfs_mem_cache_alloc(kgnilnd_data.kgn_rx_cache, CFS_ALLOC_ATOMIC);
+ rx = kmem_cache_alloc(kgnilnd_data.kgn_rx_cache, GFP_ATOMIC);
if (rx == NULL) {
CERROR("failed to allocate rx\n");
return NULL;
kgnilnd_release_msg(conn);
}
- cfs_mem_cache_free(kgnilnd_data.kgn_rx_cache, rx);
+ kmem_cache_free(kgnilnd_data.kgn_rx_cache, rx);
CDEBUG(D_MALLOC, "slab-freed 'rx': %lu at %p.\n",
sizeof(*rx), rx);
struct timer_list timer;
DEFINE_WAIT(wait);
- cfs_daemonize("kgnilnd_rpr");
cfs_block_allsigs();
/* all gnilnd threads need to run fairly urgently */
{
int threadno = (long)arg;
kgn_device_t *dev;
- char name[16];
int busy_loops = 0;
unsigned long deadline = 0;
DEFINE_WAIT(wait);
dev = &kgnilnd_data.kgn_devices[(threadno + 1) % kgnilnd_data.kgn_ndevs];
-
- snprintf(name, sizeof(name), "kgnilnd_sd_%02d", threadno);
- cfs_daemonize(name);
cfs_block_allsigs();
/* all gnilnd threads need to run fairly urgently */
* as reallocating them is tough if there is memory fragmentation */
if (use_phys) {
- fma_blk->gnm_block = cfs_mem_cache_alloc(kgnilnd_data.kgn_mbox_cache, CFS_ALLOC_ATOMIC);
+ fma_blk->gnm_block = kmem_cache_alloc(kgnilnd_data.kgn_mbox_cache, GFP_ATOMIC);
if (fma_blk->gnm_block == NULL) {
CNETERR("could not allocate physical SMSG mailbox memory\n");
rc = -ENOMEM;
if (fma_blk->gnm_state == GNILND_FMABLK_VIRT) {
LIBCFS_FREE(fma_blk->gnm_block, fma_blk->gnm_blk_size);
} else {
- cfs_mem_cache_free(kgnilnd_data.kgn_mbox_cache, fma_blk->gnm_block);
+ kmem_cache_free(kgnilnd_data.kgn_mbox_cache, fma_blk->gnm_block);
}
free_desc:
LIBCFS_FREE(fma_blk, sizeof(kgn_fma_memblock_t));
fma_blk, fma_blk->gnm_block, fma_blk->gnm_mbox_size);
if (fma_blk->gnm_state == GNILND_FMABLK_PHYS) {
- cfs_mem_cache_free(kgnilnd_data.kgn_mbox_cache, fma_blk->gnm_block);
+ kmem_cache_free(kgnilnd_data.kgn_mbox_cache, fma_blk->gnm_block);
} else {
LIBCFS_FREE(fma_blk->gnm_block, fma_blk->gnm_blk_size);
}
{
kgn_dgram_t *dgram;
- dgram = cfs_mem_cache_alloc(kgnilnd_data.kgn_dgram_cache,
- CFS_ALLOC_ATOMIC);
+ dgram = kmem_cache_alloc(kgnilnd_data.kgn_dgram_cache, GFP_ATOMIC);
if (dgram == NULL)
return -ENOMEM;
dgram->gndg_magic = 0x6f5a6b5f;
atomic_dec(&dev->gnd_ndgrams);
- cfs_mem_cache_free(kgnilnd_data.kgn_dgram_cache, dgram);
+ kmem_cache_free(kgnilnd_data.kgn_dgram_cache, dgram);
CDEBUG(D_MALLOC|D_NETTRACE, "slab-freed 'dgram': %lu at %p.\n",
sizeof(*dgram), dgram);
}
kgnilnd_dgram_waitq(void *arg)
{
kgn_device_t *dev = (kgn_device_t *) arg;
- char name[16];
gni_return_t grc;
__u64 readyid;
DEFINE_WAIT(mover_done);
- snprintf(name, sizeof(name), "kgnilnd_dgn_%02d", dev->gnd_id);
- cfs_daemonize(name);
cfs_block_allsigs();
/* all gnilnd threads need to run fairly urgently */
kgnilnd_dgram_mover(void *arg)
{
kgn_device_t *dev = (kgn_device_t *)arg;
- char name[16];
int rc, did_something;
unsigned long next_purge_check = jiffies - 1;
unsigned long timeout;
unsigned long deadline = 0;
DEFINE_WAIT(wait);
- snprintf(name, sizeof(name), "kgnilnd_dg_%02d", dev->gnd_id);
- cfs_daemonize(name);
cfs_block_allsigs();
/* all gnilnd threads need to run fairly urgently */
set_user_nice(current, *kgnilnd_tunables.kgn_nice);
for (i = 0; i < LNET_MAX_IOV; i++) {
src[i].kiov_offset = 0;
- src[i].kiov_len = CFS_PAGE_SIZE;
- src[i].kiov_page = cfs_alloc_page(CFS_ALLOC_STD|CFS_ALLOC_ZERO);
+ src[i].kiov_len = PAGE_SIZE;
+ src[i].kiov_page = alloc_page(__GFP_IO | __GFP_FS | __GFP_ZERO);
if (src[i].kiov_page == NULL) {
CERROR("couldn't allocate page %d\n", i);
}
dest[i].kiov_offset = 0;
- dest[i].kiov_len = CFS_PAGE_SIZE;
- dest[i].kiov_page = cfs_alloc_page(CFS_ALLOC_STD|CFS_ALLOC_ZERO);
+ dest[i].kiov_len = PAGE_SIZE;
+ dest[i].kiov_page = alloc_page(__GFP_IO | __GFP_FS | __GFP_ZERO);
if (dest[i].kiov_page == NULL) {
CERROR("couldn't allocate page %d\n", i);
for (n = 0; n < nloops; n++) {
CDEBUG(D_BUFFS, "case %d loop %d src %d dest %d nob %d niov %d\n",
caseno, n, src[0].kiov_offset, dest[0].kiov_offset, nob, niov);
- cksum = kgnilnd_cksum_kiov(niov, src, 0, nob - n, 1);
- cksum2 = kgnilnd_cksum_kiov(niov, dest, 0, nob - n, 1);
+ cksum = kgnilnd_cksum_kiov(niov, src, 0, nob - (n % nob), 1);
+ cksum2 = kgnilnd_cksum_kiov(niov, dest, 0, nob - (n % nob), 1);
if (cksum != cksum2) {
CERROR("case %d loop %d different checksums %x expected %x\n",
CDEBUG(D_NET, "freeing %d pages\n", i);
for (i -= 1; i >= 0; i--) {
if (src[i].kiov_page != NULL) {
- cfs_free_page(src[i].kiov_page);
+ __free_page(src[i].kiov_page);
}
if (dest[i].kiov_page != NULL) {
- cfs_free_page(dest[i].kiov_page);
+ __free_page(dest[i].kiov_page);
}
}
int i = 1;
DEFINE_WAIT(wait);
- cfs_daemonize("kgnilnd_rr");
cfs_block_allsigs();
set_user_nice(current, *kgnilnd_tunables.kgn_nice);
kgnilnd_data.kgn_ruhroh_running = 1;
rs_event_t event;
lnet_nid_t nid;
- cfs_daemonize("kgnilnd_rca");
cfs_block_allsigs();
/* all gnilnd threads need to run fairly urgently */
if (krca_get_message(&rca_krt, &event) == 0) {
int node_down = GNILND_RCA_NODE_UNKNOWN;
rs_state_t state;
- CFS_LIST_HEAD(zombies);
+ LIST_HEAD(zombies);
/* Compute nodes don't care about other compute nodes
* so we don't need to create a peer.
#if defined(CONFIG_SYSCTL)
-static cfs_sysctl_table_header_t *kgnilnd_table_header = NULL;
+static struct ctl_table_header *kgnilnd_table_header = NULL;
#ifndef HAVE_SYSCTL_UNNUMBERED
enum {
int rc = 0;
ENTRY;
- rc = ll_proc_dointvec(table, write, filp, buffer, lenp, ppos);
+ rc = proc_dointvec(table, write, buffer, lenp, ppos);
if (!write) {
/* read */
RETURN(rc);
kgn_device_t *dev;
ENTRY;
- rc = ll_proc_dointvec(table, write, filp, buffer, lenp, ppos);
+ rc = proc_dointvec(table, write, buffer, lenp, ppos);
if (!write) {
/* read */
RETURN(rc);
if (!write) {
/* read */
- rc = ll_proc_dointvec(table, write, filp, buffer, lenp, ppos);
+ rc = proc_dointvec(table, write, buffer, lenp, ppos);
RETURN(rc);
}
int rc = 0;
ENTRY;
- rc = ll_proc_dointvec(table, write, filp, buffer, lenp, ppos);
+ rc = proc_dointvec(table, write, buffer, lenp, ppos);
if (!write) {
/* read */
RETURN(rc);
char command[10];
ENTRY;
- rc = ll_proc_dostring(table, write, filp, buffer, lenp, ppos);
+ rc = proc_dostring(table, write, buffer, lenp, ppos);
if (!write) {
/* read */
RETURN(rc);
}
-static cfs_sysctl_table_t kgnilnd_table[] = {
+static struct ctl_table kgnilnd_table[] = {
/*
* NB No .strategy entries have been provided since sysctl(8) prefers
* to go via /proc for portability.
{ INIT_CTL_NAME(0) }
};
-static cfs_sysctl_table_t kgnilnd_top_table[2] = {
+static struct ctl_table kgnilnd_top_table[2] = {
{
INIT_CTL_NAME(CTL_GNILND)
.procname = "kgnilnd",
void kgnilnd_insert_sysctl(void)
{
if (kgnilnd_table_header == NULL)
- kgnilnd_table_header = cfs_register_sysctl_table(kgnilnd_top_table, 0);
+ kgnilnd_table_header = register_sysctl_table(kgnilnd_top_table);
}
void kgnilnd_remove_sysctl(void)
{
if (kgnilnd_table_header != NULL)
- cfs_unregister_sysctl_table(kgnilnd_table_header);
+ unregister_sysctl_table(kgnilnd_table_header);
kgnilnd_table_header = NULL;
}
git://git.whamcloud.com / fs / lustre-release.git / commitdiff