/*
* Copyright (C) 2009-2012 Cray, Inc.
*
+ * Copyright (c) 2013, Intel Corporation.
+ *
* Author: Nic Henke <nic@cray.com>
*
* This file is part of Lustre, http://www.lustre.org.
#define DEBUG_SUBSYSTEM S_LND
#include "gnilnd.h"
#include <linux/seq_file.h>
+#include <lprocfs_status.h>
#define GNILND_PROC_STATS "stats"
#define GNILND_PROC_MDD "mdd"
#define GNILND_PROC_SMSG "smsg"
#define GNILND_PROC_CONN "conn"
+#define GNILND_PROC_PEER_CONNS "peer_conns"
#define GNILND_PROC_PEER "peer"
#define GNILND_PROC_CKSUM_TEST "cksum_test"
lnet_kiov_t *src, *dest;
struct timespec begin, end, diff;
int niov;
+ int rc = 0;
int i = 0, j = 0, n;
__u16 cksum, cksum2;
__u64 mbytes;
if (src == NULL || dest == NULL) {
CERROR("couldn't allocate iovs\n");
- GOTO(unwind, -ENOMEM);
+ GOTO(unwind, rc = -ENOMEM);
}
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_WAIT | __GFP_IO |
+ __GFP_FS | __GFP_ZERO);
if (src[i].kiov_page == NULL) {
CERROR("couldn't allocate page %d\n", i);
- GOTO(unwind, -ENOMEM);
+ GOTO(unwind, rc = -ENOMEM);
}
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_WAIT | __GFP_IO |
+ __GFP_FS | __GFP_ZERO);
if (dest[i].kiov_page == NULL) {
CERROR("couldn't allocate page %d\n", i);
- GOTO(unwind, -ENOMEM);
+ GOTO(unwind, rc = -ENOMEM);
}
}
if (niov > LNET_MAX_IOV) {
CERROR("bytes %d too large, requires niov %d > %d\n",
nob, niov, LNET_MAX_IOV);
- GOTO(unwind, -E2BIG);
+ GOTO(unwind, rc = -E2BIG);
}
/* setup real data */
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",
j, n, cksum2, cksum);
- GOTO(unwind, -ENOKEY);
+ GOTO(unwind, rc = -ENOKEY);
}
}
getnstimeofday(&end);
- mbytes = (nloops * nob * 2) / (1024*1024);
+ mbytes = ((__u64)nloops * nob * 2) / (1024*1024);
diff = kgnilnd_ts_sub(end, begin);
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);
}
}
LIBCFS_FREE(src, LNET_MAX_IOV * sizeof(lnet_kiov_t));
if (dest != NULL)
LIBCFS_FREE(dest, LNET_MAX_IOV * sizeof(lnet_kiov_t));
- return 0;
+ return rc;
}
-static int
-kgnilnd_proc_cksum_test_write(struct file *file, const char *ubuffer,
- unsigned long count, void *data)
+static ssize_t
+kgnilnd_proc_cksum_test_write(struct file *file, const char __user *ubuffer,
+ size_t count, loff_t *ppos)
{
char dummy[256 + 1] = { '\0' };
int testno, nloops, nbytes;
int rc;
+ ENTRY;
if (kgnilnd_data.kgn_init < GNILND_INIT_ALL) {
CERROR("can't run cksum test, kgnilnd is not initialized yet\n");
- return -ENOSYS;
+ RETURN(-ENOSYS);
}
if (count >= sizeof(dummy) || count == 0)
- return -EINVAL;
+ RETURN(-EINVAL);
if (copy_from_user(dummy, ubuffer, count))
- return -EFAULT;
+ RETURN(-EFAULT);
if (sscanf(dummy, "%d:%d:%d", &testno, &nloops, &nbytes) == 3) {
rc = _kgnilnd_proc_run_cksum_test(testno, nloops, nbytes);
}
static int
-kgnilnd_proc_stats_read(char *page, char **start, off_t off,
- int count, int *eof, void *data)
+kgnilnd_cksum_test_seq_open(struct inode *inode, struct file *file)
+{
+ return single_open(file, NULL, PDE_DATA(inode));
+}
+
+static const struct file_operations kgn_cksum_test_fops = {
+ .owner = THIS_MODULE,
+ .open = kgnilnd_cksum_test_seq_open,
+ .read = seq_read,
+ .write = kgnilnd_proc_cksum_test_write,
+ .llseek = seq_lseek,
+ .release = seq_release,
+};
+
+static int
+kgnilnd_stats_seq_show(struct seq_file *sf, void *v)
{
kgn_device_t *dev;
struct timeval now;
int rc;
if (kgnilnd_data.kgn_init < GNILND_INIT_ALL) {
- rc = sprintf(page,
- "kgnilnd is not initialized yet\n");
+ rc = seq_printf(sf, "kgnilnd is not initialized yet\n");
return rc;
}
smp_rmb();
do_gettimeofday(&now);
- rc = sprintf(page, "time: %lu.%lu\n"
+ rc = seq_printf(sf, "time: %lu.%lu\n"
"ntx: %d\n"
"npeers: %d\n"
"nconns: %d\n"
"nfmablk: %d\n"
"n_mdd: %d\n"
"n_mdd_held: %d\n"
+ "n_eager_allocs: %d\n"
"GART map bytes: %ld\n"
"TX queued maps: %d\n"
"TX phys nmaps: %d\n"
"SMSG fast_try: %d\n"
"SMSG fast_ok: %d\n"
"SMSG fast_block: %d\n"
- "SMSG ntx: %d\n"
- "SMSG tx_bytes: %ld\n"
- "SMSG nrx: %d\n"
- "SMSG rx_bytes: %ld\n"
- "RDMA ntx: %d\n"
- "RDMA tx_bytes: %ld\n"
- "RDMA nrx: %d\n"
- "RDMA rx_bytes: %ld\n"
+ "SMSG ntx: %u\n"
+ "SMSG tx_bytes: %lu\n"
+ "SMSG nrx: %u\n"
+ "SMSG rx_bytes: %lu\n"
+ "RDMA ntx: %u\n"
+ "RDMA tx_bytes: %lu\n"
+ "RDMA nrx: %u\n"
+ "RDMA rx_bytes: %lu\n"
"VMAP short: %d\n"
"VMAP cksum: %d\n"
- "KMAP short: %d\n",
+ "KMAP short: %d\n"
+ "RDMA REV length: %d\n"
+ "RDMA REV offset: %d\n"
+ "RDMA REV copy: %d\n",
now.tv_sec, now.tv_usec,
atomic_read(&kgnilnd_data.kgn_ntx),
atomic_read(&kgnilnd_data.kgn_npeers),
atomic_read(&dev->gnd_ndgrams),
atomic_read(&dev->gnd_nfmablk),
atomic_read(&dev->gnd_n_mdd), atomic_read(&dev->gnd_n_mdd_held),
+ atomic_read(&kgnilnd_data.kgn_neager_allocs),
atomic64_read(&dev->gnd_nbytes_map),
atomic_read(&dev->gnd_nq_map),
dev->gnd_map_nphys, dev->gnd_map_physnop * PAGE_SIZE,
atomic_read(&dev->gnd_rdma_nrx), atomic64_read(&dev->gnd_rdma_rxbytes),
atomic_read(&kgnilnd_data.kgn_nvmap_short),
atomic_read(&kgnilnd_data.kgn_nvmap_cksum),
- atomic_read(&kgnilnd_data.kgn_nkmap_short));
+ atomic_read(&kgnilnd_data.kgn_nkmap_short),
+ atomic_read(&kgnilnd_data.kgn_rev_length),
+ atomic_read(&kgnilnd_data.kgn_rev_offset),
+ atomic_read(&kgnilnd_data.kgn_rev_copy_buff));
return rc;
}
-static int
-kgnilnd_proc_stats_write(struct file *file, const char *ubuffer,
- unsigned long count, void *data)
+static ssize_t
+kgnilnd_proc_stats_write(struct file *file, const char __user *ubuffer,
+ size_t count, loff_t *ppos)
{
kgn_device_t *dev;
return count;
}
+static int
+kgnilnd_stats_seq_open(struct inode *inode, struct file *file)
+{
+ return single_open(file, kgnilnd_stats_seq_show, PDE_DATA(inode));
+}
+
+static const struct file_operations kgn_stats_fops = {
+ .owner = THIS_MODULE,
+ .open = kgnilnd_stats_seq_open,
+ .read = seq_read,
+ .write = kgnilnd_proc_stats_write,
+ .llseek = seq_lseek,
+ .release = seq_release,
+};
+
typedef struct {
kgn_device_t *gmdd_dev;
kgn_tx_t *gmdd_tx;
static int
kgnilnd_smsg_seq_open(struct inode *inode, struct file *file)
{
- struct proc_dir_entry *dp = PDE(inode);
struct seq_file *sf;
int rc;
rc = seq_open(file, &kgn_smsg_sops);
if (rc == 0) {
sf = file->private_data;
- sf->private = dp->data;
+ sf->private = PDE_DATA(inode);
}
return rc;
kgnilnd_count_list(&conn->gnc_fmaq),
atomic_read(&conn->gnc_nlive_fma),
atomic_read(&conn->gnc_nlive_rdma),
- conn->gnc_tx_seq,
+ atomic_read(&conn->gnc_tx_seq),
jiffies_to_msecs(jiffies - conn->gnc_last_tx),
jiffies_to_msecs(jiffies - conn->gnc_last_tx_cq),
- conn->gnc_rx_seq,
+ atomic_read(&conn->gnc_rx_seq),
jiffies_to_msecs(jiffies - conn->gnc_last_rx),
jiffies_to_msecs(jiffies - conn->gnc_last_rx_cq),
atomic_read(&conn->gnc_reaper_noop),
};
+#define KGN_DEBUG_PEER_NID_DEFAULT -1
+static int kgnilnd_debug_peer_nid = KGN_DEBUG_PEER_NID_DEFAULT;
+
+static ssize_t
+kgnilnd_proc_peer_conns_write(struct file *file, const char __user *ubuffer,
+ size_t count, loff_t *ppos)
+{
+ char dummy[8];
+ int rc;
+
+ if (count >= sizeof(dummy) || count == 0)
+ return -EINVAL;
+
+ if (copy_from_user(dummy, ubuffer, count))
+ return -EFAULT;
+
+ rc = sscanf(dummy, "%d", &kgnilnd_debug_peer_nid);
+
+ if (rc != 1) {
+ return -EINVAL;
+ }
+
+ RETURN(count);
+}
+
+/* debug data to print from conns associated with peer nid
+ - date/time
+ - peer nid
+ - mbox_addr (msg_buffer + mbox_offset)
+ - gnc_dgram_type
+ - gnc_in_purgatory
+ - gnc_state
+ - gnc_error
+ - gnc_peer_error
+ - gnc_tx_seq
+ - gnc_last_tx
+ - gnc_last_tx_cq
+ - gnc_rx_seq
+ - gnc_first_rx
+ - gnc_last_rx
+ - gnc_last_rx_cq
+ - gnc_tx_retrans
+ - gnc_close_sent
+ - gnc_close_recvd
+*/
+
+static int
+kgnilnd_proc_peer_conns_seq_show(struct seq_file *sf, void *v)
+{
+ kgn_peer_t *peer;
+ kgn_conn_t *conn;
+ struct tm ctm;
+ struct timespec now;
+ unsigned long jifs;
+ int rc = 0;
+
+ if (kgnilnd_debug_peer_nid == KGN_DEBUG_PEER_NID_DEFAULT) {
+ rc = seq_printf(sf, "peer_conns not initialized\n");
+ return rc;
+ }
+
+ /* sample date/time stamp - print time in UTC
+ * 2012-12-11T16:06:16.966751 123@gni ...
+ */
+ getnstimeofday(&now);
+ time_to_tm(now.tv_sec, 0, &ctm);
+ jifs = jiffies;
+
+ write_lock(&kgnilnd_data.kgn_peer_conn_lock);
+ peer = kgnilnd_find_peer_locked(kgnilnd_debug_peer_nid);
+
+ if (peer == NULL) {
+ rc = seq_printf(sf, "peer not found for this nid %d\n",
+ kgnilnd_debug_peer_nid);
+ write_unlock(&kgnilnd_data.kgn_peer_conn_lock);
+ return rc;
+ }
+
+ list_for_each_entry(conn, &peer->gnp_conns, gnc_list) {
+ rc = seq_printf(sf,
+ "%04ld-%02d-%02dT%02d:%02d:%02d.%06ld %s "
+ "mbox adr %p "
+ "dg type %s "
+ "%s "
+ "purg %d "
+ "close s/r %d/%d "
+ "err %d peer err %d "
+ "tx sq %u %dms/%dms "
+ "rx sq %u %dms/%dms/%dms "
+ "tx retran %lld\n",
+ ctm.tm_year+1900, ctm.tm_mon+1, ctm.tm_mday,
+ ctm.tm_hour, ctm.tm_min, ctm.tm_sec, now.tv_nsec,
+ libcfs_nid2str(peer->gnp_nid),
+ conn->remote_mbox_addr,
+ kgnilnd_conn_dgram_type2str(conn->gnc_dgram_type),
+ kgnilnd_conn_state2str(conn),
+ conn->gnc_in_purgatory,
+ conn->gnc_close_sent,
+ conn->gnc_close_recvd,
+ conn->gnc_error,
+ conn->gnc_peer_error,
+ atomic_read(&conn->gnc_tx_seq),
+ jiffies_to_msecs(jifs - conn->gnc_last_tx),
+ jiffies_to_msecs(jifs - conn->gnc_last_tx_cq),
+ atomic_read(&conn->gnc_rx_seq),
+ jiffies_to_msecs(jifs - conn->gnc_first_rx),
+ jiffies_to_msecs(jifs - conn->gnc_last_rx),
+ jiffies_to_msecs(jifs - conn->gnc_last_rx_cq),
+ conn->gnc_tx_retrans);
+ }
+
+ write_unlock(&kgnilnd_data.kgn_peer_conn_lock);
+ return rc;
+}
+
+static int
+kgnilnd_peer_conns_seq_open(struct inode *inode, struct file *file)
+{
+ return single_open(file, kgnilnd_proc_peer_conns_seq_show,
+ PDE_DATA(inode));
+}
+
+static const struct file_operations kgn_peer_conns_fops = {
+ .owner = THIS_MODULE,
+ .open = kgnilnd_peer_conns_seq_open,
+ .read = seq_read,
+ .write = kgnilnd_proc_peer_conns_write,
+ .llseek = seq_lseek,
+ .release = seq_release,
+};
+
static int
kgnilnd_conn_seq_open(struct inode *inode, struct file *file)
{
- struct proc_dir_entry *dp = PDE(inode);
struct seq_file *sf;
int rc;
rc = seq_open(file, &kgn_conn_sops);
if (rc == 0) {
sf = file->private_data;
- sf->private = dp->data;
+ sf->private = PDE_DATA(inode);
}
return rc;
read_unlock(&kgnilnd_data.kgn_peer_conn_lock);
- seq_printf(s, "%p->%s [%d] NIC 0x%x q %d conn %c purg %d "
+ seq_printf(s, "%p->%s [%d] %s NIC 0x%x q %d conn %c purg %d "
"last %d@%dms dgram %d@%dms "
"reconn %dms to %lus \n",
peer, libcfs_nid2str(peer->gnp_nid),
atomic_read(&peer->gnp_refcount),
+ (peer->gnp_down == GNILND_RCA_NODE_DOWN) ? "down" : "up",
peer->gnp_host_id,
kgnilnd_count_list(&peer->gnp_tx_queue),
conn_str,
static int
kgnilnd_peer_seq_open(struct inode *inode, struct file *file)
{
- struct proc_dir_entry *dp = PDE(inode);
struct seq_file *sf;
int rc;
rc = seq_open(file, &kgn_peer_sops);
if (rc == 0) {
sf = file->private_data;
- sf->private = dp->data;
+ sf->private = PDE_DATA(inode);
}
return rc;
}
/* Initialize CKSUM_TEST */
- pde = create_proc_entry(GNILND_PROC_CKSUM_TEST, 0200, kgn_proc_root);
+ pde = proc_create(GNILND_PROC_CKSUM_TEST, 0200, kgn_proc_root,
+ &kgn_cksum_test_fops);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_CKSUM_TEST);
- rc = -ENOENT;
- GOTO(remove_dir, rc);
+ GOTO(remove_dir, rc = -ENOENT);
}
- pde->data = NULL;
- pde->write_proc = kgnilnd_proc_cksum_test_write;
-
/* Initialize STATS */
- pde = create_proc_entry(GNILND_PROC_STATS, 0644, kgn_proc_root);
+ pde = proc_create(GNILND_PROC_STATS, 0644, kgn_proc_root,
+ &kgn_stats_fops);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_STATS);
- rc = -ENOENT;
- GOTO(remove_test, rc);
+ GOTO(remove_test, rc = -ENOENT);
}
- pde->data = NULL;
- pde->read_proc = kgnilnd_proc_stats_read;
- pde->write_proc = kgnilnd_proc_stats_write;
-
/* Initialize MDD */
- pde = create_proc_entry(GNILND_PROC_MDD, 0444, kgn_proc_root);
+ pde = proc_create(GNILND_PROC_MDD, 0444, kgn_proc_root, &kgn_mdd_fops);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_MDD);
- rc = -ENOENT;
- GOTO(remove_stats, rc);
+ GOTO(remove_stats, rc = -ENOENT);
}
- pde->data = NULL;
- pde->proc_fops = &kgn_mdd_fops;
-
/* Initialize SMSG */
- pde = create_proc_entry(GNILND_PROC_SMSG, 0444, kgn_proc_root);
+ pde = proc_create(GNILND_PROC_SMSG, 0444, kgn_proc_root,
+ &kgn_smsg_fops);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_SMSG);
- rc = -ENOENT;
- GOTO(remove_mdd, rc);
+ GOTO(remove_mdd, rc = -ENOENT);
}
- pde->data = NULL;
- pde->proc_fops = &kgn_smsg_fops;
-
/* Initialize CONN */
- pde = create_proc_entry(GNILND_PROC_CONN, 0444, kgn_proc_root);
+ pde = proc_create(GNILND_PROC_CONN, 0444, kgn_proc_root,
+ &kgn_conn_fops);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_CONN);
- rc = -ENOENT;
- GOTO(remove_smsg, rc);
+ GOTO(remove_smsg, rc = -ENOENT);
}
- pde->data = NULL;
- pde->proc_fops = &kgn_conn_fops;
+ /* Initialize peer conns debug */
+ pde = proc_create(GNILND_PROC_PEER_CONNS, 0644, kgn_proc_root,
+ &kgn_peer_conns_fops);
+ if (pde == NULL) {
+ CERROR("couldn't create proc entry %s\n", GNILND_PROC_PEER_CONNS);
+ GOTO(remove_conn, rc = -ENOENT);
+ }
/* Initialize PEER */
- pde = create_proc_entry(GNILND_PROC_PEER, 0444, kgn_proc_root);
+ pde = proc_create(GNILND_PROC_PEER, 0444, kgn_proc_root,
+ &kgn_peer_fops);
if (pde == NULL) {
CERROR("couldn't create proc entry %s\n", GNILND_PROC_PEER);
- rc = -ENOENT;
- GOTO(remove_conn, rc);
+ GOTO(remove_pc, rc = -ENOENT);
}
-
- pde->data = NULL;
- pde->proc_fops = &kgn_peer_fops;
RETURN_EXIT;
+remove_pc:
+ remove_proc_entry(GNILND_PROC_PEER_CONNS, kgn_proc_root);
remove_conn:
remove_proc_entry(GNILND_PROC_CONN, kgn_proc_root);
remove_smsg:
remove_test:
remove_proc_entry(GNILND_PROC_CKSUM_TEST, kgn_proc_root);
remove_dir:
- remove_proc_entry(kgn_proc_root->name, NULL);
+ remove_proc_entry(libcfs_lnd2modname(GNILND), NULL);
RETURN_EXIT;
}
void
kgnilnd_proc_fini(void)
{
+ remove_proc_entry(GNILND_PROC_PEER_CONNS, kgn_proc_root);
remove_proc_entry(GNILND_PROC_PEER, kgn_proc_root);
remove_proc_entry(GNILND_PROC_CONN, kgn_proc_root);
remove_proc_entry(GNILND_PROC_MDD, kgn_proc_root);
remove_proc_entry(GNILND_PROC_SMSG, kgn_proc_root);
remove_proc_entry(GNILND_PROC_STATS, kgn_proc_root);
remove_proc_entry(GNILND_PROC_CKSUM_TEST, kgn_proc_root);
- remove_proc_entry(kgn_proc_root->name, NULL);
+ remove_proc_entry(libcfs_lnd2modname(GNILND), NULL);
}
git://git.whamcloud.com / fs / lustre-release.git / blobdiff