Whamcloud - gitweb
LU-4069 build: cleanup from GOTO(label, -ERRNO)
[fs/lustre-release.git] / lnet / klnds / gnilnd / gnilnd_proc.c
1 /*
2  * Copyright (C) 2009-2012 Cray, Inc.
3  *
4  *   Author: Nic Henke <nic@cray.com>
5  *
6  *   This file is part of Lustre, http://www.lustre.org.
7  *
8  *   Lustre is free software; you can redistribute it and/or
9  *   modify it under the terms of version 2 of the GNU General Public
10  *   License as published by the Free Software Foundation.
11  *
12  *   Lustre is distributed in the hope that it will be useful,
13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *   GNU General Public License for more details.
16  *
17  *   You should have received a copy of the GNU General Public License
18  *   along with Lustre; if not, write to the Free Software
19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  */
21
22 /* this code liberated and modified from lnet/lnet/router_proc.c */
23
24 #define DEBUG_SUBSYSTEM S_LND
25 #include "gnilnd.h"
26 #include <linux/seq_file.h>
27
28 #define GNILND_PROC_STATS       "stats"
29 #define GNILND_PROC_MDD         "mdd"
30 #define GNILND_PROC_SMSG        "smsg"
31 #define GNILND_PROC_CONN        "conn"
32 #define GNILND_PROC_PEER_CONNS  "peer_conns"
33 #define GNILND_PROC_PEER        "peer"
34 #define GNILND_PROC_CKSUM_TEST  "cksum_test"
35
36 static int
37 _kgnilnd_proc_run_cksum_test(int caseno, int nloops, int nob)
38 {
39         lnet_kiov_t              *src, *dest;
40         struct timespec          begin, end, diff;
41         int                      niov;
42         int                      rc = 0;
43         int                      i = 0, j = 0, n;
44         __u16                    cksum, cksum2;
45         __u64                    mbytes;
46
47         LIBCFS_ALLOC(src, LNET_MAX_IOV * sizeof(lnet_kiov_t));
48         LIBCFS_ALLOC(dest, LNET_MAX_IOV * sizeof(lnet_kiov_t));
49
50         if (src == NULL || dest == NULL) {
51                 CERROR("couldn't allocate iovs\n");
52                 GOTO(unwind, rc = -ENOMEM);
53         }
54
55         for (i = 0; i < LNET_MAX_IOV; i++) {
56                 src[i].kiov_offset = 0;
57                 src[i].kiov_len = PAGE_SIZE;
58                 src[i].kiov_page = alloc_page(__GFP_IO | __GFP_FS | __GFP_ZERO);
59
60                 if (src[i].kiov_page == NULL) {
61                         CERROR("couldn't allocate page %d\n", i);
62                         GOTO(unwind, rc = -ENOMEM);
63                 }
64
65                 dest[i].kiov_offset = 0;
66                 dest[i].kiov_len = PAGE_SIZE;
67                 dest[i].kiov_page = alloc_page(__GFP_IO | __GFP_FS | __GFP_ZERO);
68
69                 if (dest[i].kiov_page == NULL) {
70                         CERROR("couldn't allocate page %d\n", i);
71                         GOTO(unwind, rc = -ENOMEM);
72                 }
73         }
74
75         /* add extra 2 pages - one for offset of src, 2nd to allow dest offset */
76         niov = (nob / PAGE_SIZE) + 2;
77         if (niov > LNET_MAX_IOV) {
78                 CERROR("bytes %d too large, requires niov %d > %d\n",
79                         nob, niov, LNET_MAX_IOV);
80                 GOTO(unwind, rc = -E2BIG);
81         }
82
83         /* setup real data */
84         src[0].kiov_offset = 317;
85         dest[0].kiov_offset = 592;
86         switch (caseno) {
87         default:
88                 /* odd -> even */
89                 break;
90         case 1:
91                 /* odd -> odd */
92                 dest[0].kiov_offset -= 1;
93                 break;
94         case 2:
95                 /* even -> even */
96                 src[0].kiov_offset += 1;
97                 break;
98         case 3:
99                 /* even -> odd */
100                 src[0].kiov_offset += 1;
101                 dest[0].kiov_offset -= 1;
102         }
103         src[0].kiov_len = PAGE_SIZE - src[0].kiov_offset;
104         dest[0].kiov_len = PAGE_SIZE - dest[0].kiov_offset;
105
106         for (i = 0; i < niov; i++) {
107                 memset(page_address(src[i].kiov_page) + src[i].kiov_offset,
108                        0xf0 + i, src[i].kiov_len);
109         }
110
111         lnet_copy_kiov2kiov(niov, dest, 0, niov, src, 0, nob);
112
113         getnstimeofday(&begin);
114
115         for (n = 0; n < nloops; n++) {
116                 CDEBUG(D_BUFFS, "case %d loop %d src %d dest %d nob %d niov %d\n",
117                        caseno, n, src[0].kiov_offset, dest[0].kiov_offset, nob, niov);
118                 cksum = kgnilnd_cksum_kiov(niov, src, 0, nob - (n % nob), 1);
119                 cksum2 = kgnilnd_cksum_kiov(niov, dest, 0, nob - (n % nob), 1);
120
121                 if (cksum != cksum2) {
122                         CERROR("case %d loop %d different checksums %x expected %x\n",
123                                j, n, cksum2, cksum);
124                         GOTO(unwind, rc = -ENOKEY);
125                 }
126         }
127
128         getnstimeofday(&end);
129
130         mbytes = (nloops * nob * 2) / (1024*1024);
131
132         diff = kgnilnd_ts_sub(end, begin);
133
134         LCONSOLE_INFO("running "LPD64"MB took %ld.%ld seconds\n",
135                       mbytes, diff.tv_sec, diff.tv_nsec);
136
137 unwind:
138         CDEBUG(D_NET, "freeing %d pages\n", i);
139         for (i -= 1; i >= 0; i--) {
140                 if (src[i].kiov_page != NULL) {
141                         __free_page(src[i].kiov_page);
142                 }
143                 if (dest[i].kiov_page != NULL) {
144                         __free_page(dest[i].kiov_page);
145                 }
146         }
147
148         if (src != NULL)
149                 LIBCFS_FREE(src, LNET_MAX_IOV * sizeof(lnet_kiov_t));
150         if (dest != NULL)
151                 LIBCFS_FREE(dest, LNET_MAX_IOV * sizeof(lnet_kiov_t));
152         return rc;
153 }
154
155 static int
156 kgnilnd_proc_cksum_test_write(struct file *file, const char *ubuffer,
157                               unsigned long count, void *data)
158 {
159         char                    dummy[256 + 1] = { '\0' };
160         int                     testno, nloops, nbytes;
161         int                     rc;
162         ENTRY;
163
164         if (kgnilnd_data.kgn_init < GNILND_INIT_ALL) {
165                 CERROR("can't run cksum test, kgnilnd is not initialized yet\n");
166                 RETURN(-ENOSYS);
167         }
168
169         if (count >= sizeof(dummy) || count == 0)
170                 RETURN(-EINVAL);
171
172         if (copy_from_user(dummy, ubuffer, count))
173                 RETURN(-EFAULT);
174
175         if (sscanf(dummy, "%d:%d:%d", &testno, &nloops, &nbytes) == 3) {
176                 rc = _kgnilnd_proc_run_cksum_test(testno, nloops, nbytes);
177                 if (rc < 0) {
178                         RETURN(rc);
179                 } else {
180                         /* spurious, but lets us know the parse was ok */
181                         RETURN(count);
182                 }
183         }
184         RETURN(count);
185 }
186
187 static int
188 kgnilnd_proc_stats_read(char *page, char **start, off_t off,
189                              int count, int *eof, void *data)
190 {
191         kgn_device_t           *dev;
192         struct timeval          now;
193         int                     rc;
194
195         if (kgnilnd_data.kgn_init < GNILND_INIT_ALL) {
196                 rc = sprintf(page,
197                         "kgnilnd is not initialized yet\n");
198                 return rc;
199         }
200
201         /* only do the first device */
202         dev = &kgnilnd_data.kgn_devices[0];
203
204         /* sampling is racy, but so is reading this file! */
205         smp_rmb();
206         do_gettimeofday(&now);
207
208         rc = sprintf(page, "time: %lu.%lu\n"
209                            "ntx: %d\n"
210                            "npeers: %d\n"
211                            "nconns: %d\n"
212                            "nEPs: %d\n"
213                            "ndgrams: %d\n"
214                            "nfmablk: %d\n"
215                            "n_mdd: %d\n"
216                            "n_mdd_held: %d\n"
217                            "GART map bytes: %ld\n"
218                            "TX queued maps: %d\n"
219                            "TX phys nmaps: %d\n"
220                            "TX phys bytes: %lu\n"
221                            "TX virt nmaps: %d\n"
222                            "TX virt bytes: "LPU64"\n"
223                            "RDMAQ bytes_auth: %ld\n"
224                            "RDMAQ bytes_left: %ld\n"
225                            "RDMAQ nstalls: %d\n"
226                            "dev mutex delay: %ld\n"
227                            "dev n_yield: %d\n"
228                            "dev n_schedule: %d\n"
229                            "SMSG fast_try: %d\n"
230                            "SMSG fast_ok: %d\n"
231                            "SMSG fast_block: %d\n"
232                            "SMSG ntx: %d\n"
233                            "SMSG tx_bytes: %ld\n"
234                            "SMSG nrx: %d\n"
235                            "SMSG rx_bytes: %ld\n"
236                            "RDMA ntx: %d\n"
237                            "RDMA tx_bytes: %ld\n"
238                            "RDMA nrx: %d\n"
239                            "RDMA rx_bytes: %ld\n"
240                            "VMAP short: %d\n"
241                            "VMAP cksum: %d\n"
242                            "KMAP short: %d\n"
243                            "RDMA REV length: %d\n"
244                            "RDMA REV offset: %d\n"
245                            "RDMA REV copy: %d\n",
246                 now.tv_sec, now.tv_usec,
247                 atomic_read(&kgnilnd_data.kgn_ntx),
248                 atomic_read(&kgnilnd_data.kgn_npeers),
249                 atomic_read(&kgnilnd_data.kgn_nconns),
250                 atomic_read(&dev->gnd_neps),
251                 atomic_read(&dev->gnd_ndgrams),
252                 atomic_read(&dev->gnd_nfmablk),
253                 atomic_read(&dev->gnd_n_mdd), atomic_read(&dev->gnd_n_mdd_held),
254                 atomic64_read(&dev->gnd_nbytes_map),
255                 atomic_read(&dev->gnd_nq_map),
256                 dev->gnd_map_nphys, dev->gnd_map_physnop * PAGE_SIZE,
257                 dev->gnd_map_nvirt, dev->gnd_map_virtnob,
258                 atomic64_read(&dev->gnd_rdmaq_bytes_out),
259                 atomic64_read(&dev->gnd_rdmaq_bytes_ok),
260                 atomic_read(&dev->gnd_rdmaq_nstalls),
261                 dev->gnd_mutex_delay,
262                 atomic_read(&dev->gnd_n_yield), atomic_read(&dev->gnd_n_schedule),
263                 atomic_read(&dev->gnd_fast_try), atomic_read(&dev->gnd_fast_ok),
264                 atomic_read(&dev->gnd_fast_block),
265                 atomic_read(&dev->gnd_short_ntx), atomic64_read(&dev->gnd_short_txbytes),
266                 atomic_read(&dev->gnd_short_nrx), atomic64_read(&dev->gnd_short_rxbytes),
267                 atomic_read(&dev->gnd_rdma_ntx), atomic64_read(&dev->gnd_rdma_txbytes),
268                 atomic_read(&dev->gnd_rdma_nrx), atomic64_read(&dev->gnd_rdma_rxbytes),
269                 atomic_read(&kgnilnd_data.kgn_nvmap_short),
270                 atomic_read(&kgnilnd_data.kgn_nvmap_cksum),
271                 atomic_read(&kgnilnd_data.kgn_nkmap_short),
272                 atomic_read(&kgnilnd_data.kgn_rev_length),
273                 atomic_read(&kgnilnd_data.kgn_rev_offset),
274                 atomic_read(&kgnilnd_data.kgn_rev_copy_buff));
275
276         return rc;
277 }
278
279 static int
280 kgnilnd_proc_stats_write(struct file *file, const char *ubuffer,
281                      unsigned long count, void *data)
282 {
283         kgn_device_t           *dev;
284
285         if (kgnilnd_data.kgn_init < GNILND_INIT_ALL) {
286                 CERROR("kgnilnd is not initialized for stats write\n");
287                 return -EINVAL;
288         }
289
290         /* only do the first device */
291         dev = &kgnilnd_data.kgn_devices[0];
292
293         atomic_set(&dev->gnd_short_ntx, 0);
294         atomic_set(&dev->gnd_short_nrx, 0);
295         atomic64_set(&dev->gnd_short_txbytes, 0);
296         atomic64_set(&dev->gnd_short_rxbytes, 0);
297         atomic_set(&dev->gnd_rdma_ntx, 0);
298         atomic_set(&dev->gnd_rdma_nrx, 0);
299         atomic_set(&dev->gnd_fast_ok, 0);
300         atomic_set(&dev->gnd_fast_try, 0);
301         atomic_set(&dev->gnd_fast_block, 0);
302         atomic64_set(&dev->gnd_rdma_txbytes, 0);
303         atomic64_set(&dev->gnd_rdma_rxbytes, 0);
304         atomic_set(&dev->gnd_rdmaq_nstalls, 0);
305         set_mb(dev->gnd_mutex_delay, 0);
306         atomic_set(&dev->gnd_n_yield, 0);
307         atomic_set(&dev->gnd_n_schedule, 0);
308         atomic_set(&kgnilnd_data.kgn_nvmap_short, 0);
309         atomic_set(&kgnilnd_data.kgn_nvmap_cksum, 0);
310         atomic_set(&kgnilnd_data.kgn_nkmap_short, 0);
311         /* sampling is racy, but so is writing this file! */
312         smp_wmb();
313         return count;
314 }
315
316 typedef struct {
317         kgn_device_t           *gmdd_dev;
318         kgn_tx_t               *gmdd_tx;
319         loff_t                  gmdd_off;
320 } kgn_mdd_seq_iter_t;
321
322 int
323 kgnilnd_mdd_seq_seek(kgn_mdd_seq_iter_t *gseq, loff_t off)
324 {
325         kgn_tx_t                *tx;
326         struct list_head        *r;
327         loff_t                  here;
328         int                     rc = 0;
329
330         if (off == 0) {
331                 gseq->gmdd_tx = NULL;
332                 gseq->gmdd_off = 0;
333                 return 0;
334         }
335
336         tx = gseq->gmdd_tx;
337
338         if (tx == NULL || gseq->gmdd_off > off) {
339                 /* search from start */
340                 r = gseq->gmdd_dev->gnd_map_list.next;
341                 here = 1;
342         } else {
343                 /* continue current search */
344                 r = &tx->tx_map_list;
345                 here = gseq->gmdd_off;
346         }
347
348         gseq->gmdd_off = off;
349
350         while (r != &gseq->gmdd_dev->gnd_map_list) {
351                 kgn_tx_t      *t;
352
353                 t = list_entry(r, kgn_tx_t, tx_map_list);
354
355                 if (here == off) {
356                         gseq->gmdd_tx = t;
357                         rc = 0;
358                         goto out;
359                 }
360                 r = r->next;
361                 here++;
362         }
363
364         gseq->gmdd_tx = NULL;
365         rc = -ENOENT;
366 out:
367         return rc;
368 }
369
370 static void *
371 kgnilnd_mdd_seq_start(struct seq_file *s, loff_t *pos)
372 {
373
374         kgn_mdd_seq_iter_t      *gseq;
375         int                      rc;
376
377         if (kgnilnd_data.kgn_init < GNILND_INIT_ALL) {
378                 return NULL;
379         }
380
381         LIBCFS_ALLOC(gseq, sizeof(*gseq));
382         if (gseq == NULL) {
383                 CERROR("could not allocate mdd sequence iterator\n");
384                 return NULL;
385         }
386
387         /* only doing device 0 for now */
388         gseq->gmdd_dev = &kgnilnd_data.kgn_devices[0];
389         gseq->gmdd_tx = NULL;
390
391         /* need to lock map while we poke - huge disturbance
392          * but without it, no way to get the data printed */
393         spin_lock(&gseq->gmdd_dev->gnd_map_lock);
394
395         /* set private to gseq for stop */
396         s->private = gseq;
397
398         rc = kgnilnd_mdd_seq_seek(gseq, *pos);
399         if (rc == 0)
400                 return gseq;
401         else
402                 return NULL;
403 }
404
405 static void
406 kgnilnd_mdd_seq_stop(struct seq_file *s, void *iter)
407 {
408         kgn_mdd_seq_iter_t     *gseq = s->private;
409
410         if (gseq != NULL) {
411                 spin_unlock(&gseq->gmdd_dev->gnd_map_lock);
412                 LIBCFS_FREE(gseq, sizeof(*gseq));
413         }
414 }
415
416 static void *
417 kgnilnd_mdd_seq_next(struct seq_file *s, void *iter, loff_t *pos)
418 {
419         kgn_mdd_seq_iter_t     *gseq = iter;
420         int                     rc;
421         loff_t                  next = *pos + 1;
422
423         rc = kgnilnd_mdd_seq_seek(gseq, next);
424         if (rc != 0) {
425                 return NULL;
426         }
427         *pos = next;
428         return gseq;
429 }
430
431 static int
432 kgnilnd_mdd_seq_show(struct seq_file *s, void *iter)
433 {
434         kgn_mdd_seq_iter_t     *gseq = iter;
435         kgn_tx_t               *tx;
436         __u64                   nob;
437         __u32                   physnop;
438         int                     id;
439         int                     buftype;
440         gni_mem_handle_t        hndl;
441
442         if (gseq->gmdd_off == 0) {
443                 seq_printf(s, "%s %22s %16s %8s %8s %37s\n",
444                         "tx", "tx_id", "nob", "physnop",
445                         "buftype", "mem handle");
446                 return 0;
447         }
448
449         tx = gseq->gmdd_tx;
450         LASSERT(tx != NULL);
451
452         id = tx->tx_id.txe_smsg_id;
453         nob = tx->tx_nob;
454         physnop = tx->tx_phys_npages;
455         buftype = tx->tx_buftype;
456         hndl.qword1 = tx->tx_map_key.qword1;
457         hndl.qword2 = tx->tx_map_key.qword2;
458
459         seq_printf(s, "%p %x %16"LPF64"u %8d %#8x "LPX64"."LPX64"x\n",
460                 tx, id, nob, physnop, buftype,
461                 hndl.qword1, hndl.qword2);
462
463         return 0;
464 }
465
466 static struct seq_operations kgn_mdd_sops = {
467         .start = kgnilnd_mdd_seq_start,
468         .stop  = kgnilnd_mdd_seq_stop,
469         .next  = kgnilnd_mdd_seq_next,
470         .show  = kgnilnd_mdd_seq_show,
471
472 };
473
474 static int
475 kgnilnd_mdd_seq_open(struct inode *inode, struct file *file)
476 {
477         struct seq_file       *sf;
478         int                    rc;
479
480         rc = seq_open(file, &kgn_mdd_sops);
481         if (rc == 0) {
482                 sf = file->private_data;
483
484                 /* NULL means we've not yet open() */
485                 sf->private = NULL;
486         }
487         return rc;
488 }
489
490 static struct file_operations kgn_mdd_fops = {
491         .owner   = THIS_MODULE,
492         .open    = kgnilnd_mdd_seq_open,
493         .read    = seq_read,
494         .llseek  = seq_lseek,
495         .release = seq_release,
496 };
497
498 typedef struct {
499         __u64                   gsmsg_version;
500         kgn_device_t           *gsmsg_dev;
501         kgn_fma_memblock_t     *gsmsg_fmablk;
502         loff_t                  gsmsg_off;
503 } kgn_smsg_seq_iter_t;
504
505 int
506 kgnilnd_smsg_seq_seek(kgn_smsg_seq_iter_t *gseq, loff_t off)
507 {
508         kgn_fma_memblock_t             *fmablk;
509         kgn_device_t                   *dev;
510         struct list_head               *r;
511         loff_t                          here;
512         int                             rc = 0;
513
514         /* offset 0 is the header, so we start real entries at
515          * here == off == 1 */
516         if (off == 0) {
517                 gseq->gsmsg_fmablk = NULL;
518                 gseq->gsmsg_off = 0;
519                 return 0;
520         }
521
522         fmablk = gseq->gsmsg_fmablk;
523         dev = gseq->gsmsg_dev;
524
525         spin_lock(&dev->gnd_fmablk_lock);
526
527         if (fmablk != NULL &&
528                 gseq->gsmsg_version != atomic_read(&dev->gnd_fmablk_vers)) {
529                 /* list changed */
530                 rc = -ESTALE;
531                 goto out;
532         }
533
534         if (fmablk == NULL || gseq->gsmsg_off > off) {
535                 /* search from start */
536                 r = dev->gnd_fma_buffs.next;
537                 here = 1;
538         } else {
539                 /* continue current search */
540                 r = &fmablk->gnm_bufflist;
541                 here = gseq->gsmsg_off;
542         }
543
544         gseq->gsmsg_version = atomic_read(&dev->gnd_fmablk_vers);
545         gseq->gsmsg_off = off;
546
547         while (r != &dev->gnd_fma_buffs) {
548                 kgn_fma_memblock_t      *t;
549
550                 t = list_entry(r, kgn_fma_memblock_t, gnm_bufflist);
551
552                 if (here == off) {
553                         gseq->gsmsg_fmablk = t;
554                         rc = 0;
555                         goto out;
556                 }
557                 r = r->next;
558                 here++;
559         }
560
561         gseq->gsmsg_fmablk = NULL;
562         rc = -ENOENT;
563 out:
564         spin_unlock(&dev->gnd_fmablk_lock);
565         return rc;
566 }
567
568 static void *
569 kgnilnd_smsg_seq_start(struct seq_file *s, loff_t *pos)
570 {
571
572         kgn_smsg_seq_iter_t     *gseq;
573         int                      rc;
574
575         if (kgnilnd_data.kgn_init < GNILND_INIT_ALL) {
576                 return NULL;
577         }
578
579         LIBCFS_ALLOC(gseq, sizeof(*gseq));
580         if (gseq == NULL) {
581                 CERROR("could not allocate smsg sequence iterator\n");
582                 return NULL;
583         }
584
585         /* only doing device 0 for now */
586         gseq->gsmsg_dev = &kgnilnd_data.kgn_devices[0];
587         gseq->gsmsg_fmablk = NULL;
588         rc = kgnilnd_smsg_seq_seek(gseq, *pos);
589         if (rc == 0)
590                 return gseq;
591
592         LIBCFS_FREE(gseq, sizeof(*gseq));
593         return NULL;
594 }
595
596 static void
597 kgnilnd_smsg_seq_stop(struct seq_file *s, void *iter)
598 {
599         kgn_smsg_seq_iter_t     *gseq = iter;
600
601         if (gseq != NULL)
602                 LIBCFS_FREE(gseq, sizeof(*gseq));
603 }
604
605 static void *
606 kgnilnd_smsg_seq_next(struct seq_file *s, void *iter, loff_t *pos)
607 {
608         kgn_smsg_seq_iter_t    *gseq = iter;
609         int                     rc;
610         loff_t                  next = *pos + 1;
611
612         rc = kgnilnd_smsg_seq_seek(gseq, next);
613         if (rc != 0) {
614                 LIBCFS_FREE(gseq, sizeof(*gseq));
615                 return NULL;
616         }
617         *pos = next;
618         return gseq;
619 }
620
621 static int
622 kgnilnd_smsg_seq_show(struct seq_file *s, void *iter)
623 {
624         kgn_smsg_seq_iter_t    *gseq = iter;
625         kgn_fma_memblock_t     *fmablk;
626         kgn_device_t           *dev;
627         int                     avail_mboxs, held_mboxs, num_mboxs;
628         unsigned int            blk_size;
629         int                     live;
630         kgn_fmablk_state_t      state;
631         gni_mem_handle_t        hndl;
632
633         if (gseq->gsmsg_off == 0) {
634                 seq_printf(s, "%5s %4s %6s/%5s/%5s %9s %18s %37s\n",
635                         "blk#", "type", "avail", "held", "total", "size",
636                         "fmablk", "mem handle");
637                 return 0;
638         }
639
640         fmablk = gseq->gsmsg_fmablk;
641         dev = gseq->gsmsg_dev;
642         LASSERT(fmablk != NULL);
643
644         spin_lock(&dev->gnd_fmablk_lock);
645
646         if (gseq->gsmsg_version != atomic_read(&dev->gnd_fmablk_vers)) {
647                 /* list changed */
648                 spin_unlock(&dev->gnd_fmablk_lock);
649                 return -ESTALE;
650         }
651
652         live = fmablk->gnm_hold_timeout == 0;
653         /* none are available if it isn't live... */
654         avail_mboxs = live ? fmablk->gnm_avail_mboxs : 0;
655         held_mboxs = fmablk->gnm_held_mboxs;
656         num_mboxs = fmablk->gnm_num_mboxs;
657         blk_size = fmablk->gnm_blk_size;
658         state = fmablk->gnm_state;
659         hndl.qword1 = fmablk->gnm_hndl.qword1;
660         hndl.qword2 = fmablk->gnm_hndl.qword2;
661
662         spin_unlock(&dev->gnd_fmablk_lock);
663
664         if (live) {
665                 seq_printf(s, "%5d %4s %6d/%5d/%5d %9d %18p   "LPX64"."LPX64"\n",
666                            (int) gseq->gsmsg_off, kgnilnd_fmablk_state2str(state),
667                            avail_mboxs, held_mboxs, num_mboxs, blk_size,
668                            fmablk, hndl.qword1, hndl.qword2);
669         } else {
670                 seq_printf(s, "%5d %4s %6d/%5d/%5d %9d %18p %37s\n",
671                            (int) gseq->gsmsg_off, kgnilnd_fmablk_state2str(state),
672                            avail_mboxs, held_mboxs, num_mboxs, blk_size,
673                            fmablk, "PURGATORY.HOLD");
674         }
675
676         return 0;
677 }
678
679 static struct seq_operations kgn_smsg_sops = {
680         .start = kgnilnd_smsg_seq_start,
681         .stop  = kgnilnd_smsg_seq_stop,
682         .next  = kgnilnd_smsg_seq_next,
683         .show  = kgnilnd_smsg_seq_show,
684
685 };
686
687 static int
688 kgnilnd_smsg_seq_open(struct inode *inode, struct file *file)
689 {
690         struct proc_dir_entry *dp = PDE(inode);
691         struct seq_file       *sf;
692         int                    rc;
693
694         rc = seq_open(file, &kgn_smsg_sops);
695         if (rc == 0) {
696                 sf = file->private_data;
697                 sf->private = dp->data;
698         }
699
700         return rc;
701 }
702
703 static struct file_operations kgn_smsg_fops = {
704         .owner   = THIS_MODULE,
705         .open    = kgnilnd_smsg_seq_open,
706         .read    = seq_read,
707         .llseek  = seq_lseek,
708         .release = seq_release,
709 };
710
711 typedef struct {
712         __u64                   gconn_version;
713         struct list_head       *gconn_list;
714         kgn_conn_t             *gconn_conn;
715         loff_t                  gconn_off;
716         int                     gconn_hashidx;
717 } kgn_conn_seq_iter_t;
718
719 int
720 kgnilnd_conn_seq_seek(kgn_conn_seq_iter_t *gseq, loff_t off)
721 {
722         struct list_head       *list, *tmp;
723         loff_t                  here = 0;
724         int                     rc = 0;
725
726         if (off == 0) {
727                 gseq->gconn_hashidx = 0;
728                 gseq->gconn_list = NULL;
729         }
730
731         if (off > atomic_read(&kgnilnd_data.kgn_nconns)) {
732                 gseq->gconn_list = NULL;
733                 rc = -ENOENT;
734         }
735
736         read_lock(&kgnilnd_data.kgn_peer_conn_lock);
737         if (gseq->gconn_list != NULL &&
738                 gseq->gconn_version != kgnilnd_data.kgn_conn_version) {
739                 /* list changed */
740                 rc = -ESTALE;
741                 goto out;
742         }
743
744         if ((gseq->gconn_list == NULL) ||
745                 (gseq->gconn_off > off) ||
746                 (gseq->gconn_hashidx >= *kgnilnd_tunables.kgn_peer_hash_size)) {
747                 /* search from start */
748                 gseq->gconn_hashidx = 0;
749                 list = &kgnilnd_data.kgn_conns[gseq->gconn_hashidx];
750                 here = 0;
751         } else {
752                 /* continue current search */
753                 list = gseq->gconn_list;
754         }
755
756         gseq->gconn_version = kgnilnd_data.kgn_conn_version;
757         gseq->gconn_off = off;
758
759 start_list:
760
761         list_for_each(tmp, list) {
762                 if (here == off) {
763                         kgn_conn_t *conn;
764                         conn = list_entry(tmp, kgn_conn_t, gnc_hashlist);
765                         gseq->gconn_conn = conn;
766                         rc = 0;
767                         goto out;
768                 }
769                 here++;
770         }
771         /* if we got through this hash bucket with 'off' still to go, try next*/
772         gseq->gconn_hashidx++;
773         if ((here <= off) &&
774                 (gseq->gconn_hashidx < *kgnilnd_tunables.kgn_peer_hash_size)) {
775                 list = &kgnilnd_data.kgn_conns[gseq->gconn_hashidx];
776                 goto start_list;
777         }
778
779         gseq->gconn_list = NULL;
780         rc = -ENOENT;
781 out:
782         read_unlock(&kgnilnd_data.kgn_peer_conn_lock);
783         return rc;
784 }
785
786 static void *
787 kgnilnd_conn_seq_start(struct seq_file *s, loff_t *pos)
788 {
789
790         kgn_conn_seq_iter_t     *gseq;
791         int                      rc;
792
793         if (kgnilnd_data.kgn_init < GNILND_INIT_ALL) {
794                 return NULL;
795         }
796
797         LIBCFS_ALLOC(gseq, sizeof(*gseq));
798         if (gseq == NULL) {
799                 CERROR("could not allocate conn sequence iterator\n");
800                 return NULL;
801         }
802
803         /* only doing device 0 for now */
804         gseq->gconn_list = NULL;
805         rc = kgnilnd_conn_seq_seek(gseq, *pos);
806         if (rc == 0)
807                 return gseq;
808
809         LIBCFS_FREE(gseq, sizeof(*gseq));
810         return NULL;
811 }
812
813 static void
814 kgnilnd_conn_seq_stop(struct seq_file *s, void *iter)
815 {
816         kgn_conn_seq_iter_t     *gseq = iter;
817
818         if (gseq != NULL)
819                 LIBCFS_FREE(gseq, sizeof(*gseq));
820 }
821
822 static void *
823 kgnilnd_conn_seq_next(struct seq_file *s, void *iter, loff_t *pos)
824 {
825         kgn_conn_seq_iter_t    *gseq = iter;
826         int                     rc;
827         loff_t                  next = *pos + 1;
828
829         rc = kgnilnd_conn_seq_seek(gseq, next);
830         if (rc != 0) {
831                 LIBCFS_FREE(gseq, sizeof(*gseq));
832                 return NULL;
833         }
834         *pos = next;
835         return gseq;
836 }
837
838 static int
839 kgnilnd_conn_seq_show(struct seq_file *s, void *iter)
840 {
841         kgn_conn_seq_iter_t    *gseq = iter;
842         kgn_peer_t             *peer = NULL;
843         kgn_conn_t             *conn;
844
845         /* there is no header data for conns, so offset 0 is the first
846          * real entry. */
847
848         conn = gseq->gconn_conn;
849         LASSERT(conn != NULL);
850
851         read_lock(&kgnilnd_data.kgn_peer_conn_lock);
852         if (gseq->gconn_list != NULL &&
853                 gseq->gconn_version != kgnilnd_data.kgn_conn_version) {
854                 /* list changed */
855                 read_unlock(&kgnilnd_data.kgn_peer_conn_lock);
856                 return -ESTALE;
857         }
858
859         /* instead of saving off the data, just refcount */
860         kgnilnd_conn_addref(conn);
861         if (conn->gnc_peer) {
862                 /* don't use link - after unlock it could get nuked */
863                 peer = conn->gnc_peer;
864                 kgnilnd_peer_addref(peer);
865         }
866
867         read_unlock(&kgnilnd_data.kgn_peer_conn_lock);
868
869         seq_printf(s, "%p->%s [%d] q %d/%d/%d "
870                 "tx sq %u %dms/%dms "
871                 "rx sq %u %dms/%dms "
872                 "noop r/s %d/%d w/s/cq %lds/%lds/%lds "
873                 "sched a/d %lds/%lds "
874                 "tx_re "LPD64" TO %ds %s\n",
875                 conn, peer ? libcfs_nid2str(peer->gnp_nid) : "<?>",
876                 atomic_read(&conn->gnc_refcount),
877                 kgnilnd_count_list(&conn->gnc_fmaq),
878                 atomic_read(&conn->gnc_nlive_fma),
879                 atomic_read(&conn->gnc_nlive_rdma),
880                 conn->gnc_tx_seq,
881                 jiffies_to_msecs(jiffies - conn->gnc_last_tx),
882                 jiffies_to_msecs(jiffies - conn->gnc_last_tx_cq),
883                 conn->gnc_rx_seq,
884                 jiffies_to_msecs(jiffies - conn->gnc_last_rx),
885                 jiffies_to_msecs(jiffies - conn->gnc_last_rx_cq),
886                 atomic_read(&conn->gnc_reaper_noop),
887                 atomic_read(&conn->gnc_sched_noop),
888                 cfs_duration_sec(jiffies - conn->gnc_last_noop_want),
889                 cfs_duration_sec(jiffies - conn->gnc_last_noop_sent),
890                 cfs_duration_sec(jiffies - conn->gnc_last_noop_cq),
891                 cfs_duration_sec(jiffies - conn->gnc_last_sched_ask),
892                 cfs_duration_sec(jiffies - conn->gnc_last_sched_do),
893                 conn->gnc_tx_retrans, conn->gnc_timeout,
894                 kgnilnd_conn_state2str(conn));
895
896         if (peer)
897                 kgnilnd_peer_decref(peer);
898         kgnilnd_conn_decref(conn);
899
900         return 0;
901 }
902
903 static struct seq_operations kgn_conn_sops = {
904         .start = kgnilnd_conn_seq_start,
905         .stop  = kgnilnd_conn_seq_stop,
906         .next  = kgnilnd_conn_seq_next,
907         .show  = kgnilnd_conn_seq_show,
908
909 };
910
911 #define KGN_DEBUG_PEER_NID_DEFAULT -1
912 static int kgnilnd_debug_peer_nid = KGN_DEBUG_PEER_NID_DEFAULT;
913
914 static int
915 kgnilnd_proc_peer_conns_write(struct file *file, const char *ubuffer,
916                               unsigned long count, void *data)
917 {
918         char dummy[8];
919         int  rc;
920
921         if (count >= sizeof(dummy) || count == 0)
922                 return -EINVAL;
923
924         if (copy_from_user(dummy, ubuffer, count))
925                 return -EFAULT;
926
927         rc = sscanf(dummy, "%d", &kgnilnd_debug_peer_nid);
928
929         if (rc != 1) {
930                 return -EINVAL;
931         }
932
933         RETURN(count);
934 }
935
936 /* debug data to print from conns associated with peer nid
937   -  date/time
938   -  peer nid
939   -  mbox_addr (msg_buffer + mbox_offset)
940   -  gnc_dgram_type
941   -  gnc_in_purgatory
942   -  gnc_state
943   -  gnc_error
944   -  gnc_peer_error
945   -  gnc_tx_seq
946   -  gnc_last_tx
947   -  gnc_last_tx_cq
948   -  gnc_rx_seq
949   -  gnc_first_rx
950   -  gnc_last_rx
951   -  gnc_last_rx_cq
952   -  gnc_tx_retrans
953   -  gnc_close_sent
954   -  gnc_close_recvd
955 */
956
957 static int
958 kgnilnd_proc_peer_conns_read(char *page, char **start, off_t off,
959                              int count, int *eof, void *data)
960 {
961         kgn_peer_t      *peer;
962         kgn_conn_t      *conn;
963         struct tm       ctm;
964         struct timespec now;
965         unsigned long   jifs;
966         int             len = 0;
967         int             rc;
968
969         if (kgnilnd_debug_peer_nid == KGN_DEBUG_PEER_NID_DEFAULT) {
970                 rc = sprintf(page, "peer_conns not initialized\n");
971                 return rc;
972         }
973
974         /* sample date/time stamp - print time in UTC
975          * 2012-12-11T16:06:16.966751 123@gni ...
976          */
977         getnstimeofday(&now);
978         time_to_tm(now.tv_sec, 0, &ctm);
979         jifs = jiffies;
980
981         write_lock(&kgnilnd_data.kgn_peer_conn_lock);
982         peer = kgnilnd_find_peer_locked(kgnilnd_debug_peer_nid);
983
984         if (peer == NULL) {
985                 rc = sprintf(page, "peer not found for this nid %d\n",
986                              kgnilnd_debug_peer_nid);
987                 write_unlock(&kgnilnd_data.kgn_peer_conn_lock);
988                 return rc;
989         }
990
991         list_for_each_entry(conn, &peer->gnp_conns, gnc_list) {
992                 len += scnprintf(page, count - len,
993                         "%04ld-%02d-%02dT%02d:%02d:%02d.%06ld %s "
994                         "mbox adr %p "
995                         "dg type %s "
996                         "%s "
997                         "purg %d "
998                         "close s/r %d/%d "
999                         "err %d peer err %d "
1000                         "tx sq %u %dms/%dms "
1001                         "rx sq %u %dms/%dms/%dms "
1002                         "tx retran %lld\n",
1003                         ctm.tm_year+1900, ctm.tm_mon+1, ctm.tm_mday,
1004                         ctm.tm_hour, ctm.tm_min, ctm.tm_sec, now.tv_nsec,
1005                         libcfs_nid2str(peer->gnp_nid),
1006                         conn->remote_mbox_addr,
1007                         kgnilnd_conn_dgram_type2str(conn->gnc_dgram_type),
1008                         kgnilnd_conn_state2str(conn),
1009                         conn->gnc_in_purgatory,
1010                         conn->gnc_close_sent,
1011                         conn->gnc_close_recvd,
1012                         conn->gnc_error,
1013                         conn->gnc_peer_error,
1014                         conn->gnc_tx_seq,
1015                         jiffies_to_msecs(jifs - conn->gnc_last_tx),
1016                         jiffies_to_msecs(jifs - conn->gnc_last_tx_cq),
1017                         conn->gnc_rx_seq,
1018                         jiffies_to_msecs(jifs - conn->gnc_first_rx),
1019                         jiffies_to_msecs(jifs - conn->gnc_last_rx),
1020                         jiffies_to_msecs(jifs - conn->gnc_last_rx_cq),
1021                         conn->gnc_tx_retrans);
1022         }
1023
1024         write_unlock(&kgnilnd_data.kgn_peer_conn_lock);
1025         return len;
1026 }
1027
1028 static int
1029 kgnilnd_conn_seq_open(struct inode *inode, struct file *file)
1030 {
1031         struct proc_dir_entry *dp = PDE(inode);
1032         struct seq_file       *sf;
1033         int                    rc;
1034
1035         rc = seq_open(file, &kgn_conn_sops);
1036         if (rc == 0) {
1037                 sf = file->private_data;
1038                 sf->private = dp->data;
1039         }
1040
1041         return rc;
1042 }
1043
1044 static struct file_operations kgn_conn_fops = {
1045         .owner   = THIS_MODULE,
1046         .open    = kgnilnd_conn_seq_open,
1047         .read    = seq_read,
1048         .llseek  = seq_lseek,
1049         .release = seq_release,
1050 };
1051
1052 typedef struct {
1053         __u64                   gpeer_version;
1054         struct list_head       *gpeer_list;
1055         kgn_peer_t             *gpeer_peer;
1056         loff_t                  gpeer_off;
1057         int                     gpeer_hashidx;
1058 } kgn_peer_seq_iter_t;
1059
1060 int
1061 kgnilnd_peer_seq_seek(kgn_peer_seq_iter_t *gseq, loff_t off)
1062 {
1063         struct list_head       *list, *tmp;
1064         loff_t                  here = 0;
1065         int                     rc = 0;
1066
1067         if (off == 0) {
1068                 gseq->gpeer_hashidx = 0;
1069                 gseq->gpeer_list = NULL;
1070         }
1071
1072         if (off > atomic_read(&kgnilnd_data.kgn_npeers)) {
1073                 gseq->gpeer_list = NULL;
1074                 rc = -ENOENT;
1075         }
1076
1077         read_lock(&kgnilnd_data.kgn_peer_conn_lock);
1078         if (gseq->gpeer_list != NULL &&
1079                 gseq->gpeer_version != kgnilnd_data.kgn_peer_version) {
1080                 /* list changed */
1081                 rc = -ESTALE;
1082                 goto out;
1083         }
1084
1085         if ((gseq->gpeer_list == NULL) ||
1086                 (gseq->gpeer_off > off) ||
1087                 (gseq->gpeer_hashidx >= *kgnilnd_tunables.kgn_peer_hash_size)) {
1088                 /* search from start */
1089                 gseq->gpeer_hashidx = 0;
1090                 list = &kgnilnd_data.kgn_peers[gseq->gpeer_hashidx];
1091                 here = 0;
1092         } else {
1093                 /* continue current search */
1094                 list = gseq->gpeer_list;
1095         }
1096
1097         gseq->gpeer_version = kgnilnd_data.kgn_peer_version;
1098         gseq->gpeer_off = off;
1099
1100 start_list:
1101
1102         list_for_each(tmp, list) {
1103                 if (here == off) {
1104                         kgn_peer_t *peer;
1105                         peer = list_entry(tmp, kgn_peer_t, gnp_list);
1106                         gseq->gpeer_peer = peer;
1107                         rc = 0;
1108                         goto out;
1109                 }
1110                 here++;
1111         }
1112         /* if we got through this hash bucket with 'off' still to go, try next*/
1113         gseq->gpeer_hashidx++;
1114         if ((here <= off) &&
1115                 (gseq->gpeer_hashidx < *kgnilnd_tunables.kgn_peer_hash_size)) {
1116                 list = &kgnilnd_data.kgn_peers[gseq->gpeer_hashidx];
1117                 goto start_list;
1118         }
1119
1120         gseq->gpeer_list = NULL;
1121         rc = -ENOENT;
1122 out:
1123         read_unlock(&kgnilnd_data.kgn_peer_conn_lock);
1124         return rc;
1125 }
1126
1127 static void *
1128 kgnilnd_peer_seq_start(struct seq_file *s, loff_t *pos)
1129 {
1130
1131         kgn_peer_seq_iter_t     *gseq;
1132         int                      rc;
1133
1134         if (kgnilnd_data.kgn_init < GNILND_INIT_ALL) {
1135                 return NULL;
1136         }
1137
1138         LIBCFS_ALLOC(gseq, sizeof(*gseq));
1139         if (gseq == NULL) {
1140                 CERROR("could not allocate peer sequence iterator\n");
1141                 return NULL;
1142         }
1143
1144         /* only doing device 0 for now */
1145         gseq->gpeer_list = NULL;
1146         rc = kgnilnd_peer_seq_seek(gseq, *pos);
1147         if (rc == 0)
1148                 return gseq;
1149
1150         LIBCFS_FREE(gseq, sizeof(*gseq));
1151         return NULL;
1152 }
1153
1154 static void
1155 kgnilnd_peer_seq_stop(struct seq_file *s, void *iter)
1156 {
1157         kgn_peer_seq_iter_t     *gseq = iter;
1158
1159         if (gseq != NULL)
1160                 LIBCFS_FREE(gseq, sizeof(*gseq));
1161 }
1162
1163 static void *
1164 kgnilnd_peer_seq_next(struct seq_file *s, void *iter, loff_t *pos)
1165 {
1166         kgn_peer_seq_iter_t    *gseq = iter;
1167         int                     rc;
1168         loff_t                  next = *pos + 1;
1169
1170         rc = kgnilnd_peer_seq_seek(gseq, next);
1171         if (rc != 0) {
1172                 LIBCFS_FREE(gseq, sizeof(*gseq));
1173                 return NULL;
1174         }
1175         *pos = next;
1176         return gseq;
1177 }
1178
1179 static int
1180 kgnilnd_peer_seq_show(struct seq_file *s, void *iter)
1181 {
1182         kgn_peer_seq_iter_t    *gseq = iter;
1183         kgn_peer_t             *peer;
1184         kgn_conn_t             *conn;
1185         char                   conn_str;
1186         int                    purg_count = 0;
1187         /* there is no header data for peers, so offset 0 is the first
1188          * real entry. */
1189
1190         peer = gseq->gpeer_peer;
1191         LASSERT(peer != NULL);
1192
1193         read_lock(&kgnilnd_data.kgn_peer_conn_lock);
1194         if (gseq->gpeer_list != NULL &&
1195                 gseq->gpeer_version != kgnilnd_data.kgn_peer_version) {
1196                 /* list changed */
1197                 read_unlock(&kgnilnd_data.kgn_peer_conn_lock);
1198                 return -ESTALE;
1199         }
1200
1201         /* instead of saving off the data, just refcount */
1202         kgnilnd_peer_addref(peer);
1203         conn = kgnilnd_find_conn_locked(peer);
1204
1205         if (peer->gnp_connecting) {
1206                 conn_str = 'S';
1207         } else if (conn != NULL) {
1208                 conn_str = 'C';
1209         } else {
1210                 conn_str = 'D';
1211         }
1212
1213         list_for_each_entry(conn, &peer->gnp_conns, gnc_list) {
1214                 if (conn->gnc_in_purgatory) {
1215                         purg_count++;
1216                 }
1217         }
1218
1219         read_unlock(&kgnilnd_data.kgn_peer_conn_lock);
1220
1221         seq_printf(s, "%p->%s [%d] %s NIC 0x%x q %d conn %c purg %d "
1222                 "last %d@%dms dgram %d@%dms "
1223                 "reconn %dms to %lus \n",
1224                 peer, libcfs_nid2str(peer->gnp_nid),
1225                 atomic_read(&peer->gnp_refcount),
1226                 (peer->gnp_down == GNILND_RCA_NODE_DOWN) ? "down" : "up",
1227                 peer->gnp_host_id,
1228                 kgnilnd_count_list(&peer->gnp_tx_queue),
1229                 conn_str,
1230                 purg_count,
1231                 peer->gnp_last_errno,
1232                 jiffies_to_msecs(jiffies - peer->gnp_last_alive),
1233                 peer->gnp_last_dgram_errno,
1234                 jiffies_to_msecs(jiffies - peer->gnp_last_dgram_time),
1235                 peer->gnp_reconnect_interval != 0
1236                         ? jiffies_to_msecs(jiffies - peer->gnp_reconnect_time)
1237                         : 0,
1238                 peer->gnp_reconnect_interval);
1239
1240         kgnilnd_peer_decref(peer);
1241
1242         return 0;
1243 }
1244
1245 static struct seq_operations kgn_peer_sops = {
1246         .start = kgnilnd_peer_seq_start,
1247         .stop  = kgnilnd_peer_seq_stop,
1248         .next  = kgnilnd_peer_seq_next,
1249         .show  = kgnilnd_peer_seq_show,
1250 };
1251
1252 static int
1253 kgnilnd_peer_seq_open(struct inode *inode, struct file *file)
1254 {
1255         struct proc_dir_entry *dp = PDE(inode);
1256         struct seq_file       *sf;
1257         int                    rc;
1258
1259         rc = seq_open(file, &kgn_peer_sops);
1260         if (rc == 0) {
1261                 sf = file->private_data;
1262                 sf->private = dp->data;
1263         }
1264
1265         return rc;
1266 }
1267
1268 static struct file_operations kgn_peer_fops = {
1269         .owner   = THIS_MODULE,
1270         .open    = kgnilnd_peer_seq_open,
1271         .read    = seq_read,
1272         .llseek  = seq_lseek,
1273         .release = seq_release,
1274 };
1275
1276 static struct proc_dir_entry *kgn_proc_root;
1277
1278 void
1279 kgnilnd_proc_init(void)
1280 {
1281         struct proc_dir_entry *pde;
1282         int             rc = 0;
1283         ENTRY;
1284
1285         /* setup dir */
1286         kgn_proc_root = proc_mkdir(libcfs_lnd2modname(GNILND), NULL);
1287         if (kgn_proc_root == NULL) {
1288                 CERROR("couldn't create proc dir %s\n",
1289                         libcfs_lnd2modname(GNILND));
1290                 return;
1291         }
1292
1293         /* Initialize CKSUM_TEST */
1294         pde = create_proc_entry(GNILND_PROC_CKSUM_TEST, 0200, kgn_proc_root);
1295         if (pde == NULL) {
1296                 CERROR("couldn't create proc entry %s\n", GNILND_PROC_CKSUM_TEST);
1297                 GOTO(remove_dir, rc = -ENOENT);
1298         }
1299
1300         pde->data = NULL;
1301         pde->write_proc = kgnilnd_proc_cksum_test_write;
1302
1303         /* Initialize STATS */
1304         pde = create_proc_entry(GNILND_PROC_STATS, 0644, kgn_proc_root);
1305         if (pde == NULL) {
1306                 CERROR("couldn't create proc entry %s\n", GNILND_PROC_STATS);
1307                 GOTO(remove_test, rc = -ENOENT);
1308         }
1309
1310         pde->data = NULL;
1311         pde->read_proc = kgnilnd_proc_stats_read;
1312         pde->write_proc = kgnilnd_proc_stats_write;
1313
1314         /* Initialize MDD */
1315         pde = create_proc_entry(GNILND_PROC_MDD, 0444, kgn_proc_root);
1316         if (pde == NULL) {
1317                 CERROR("couldn't create proc entry %s\n", GNILND_PROC_MDD);
1318                 GOTO(remove_stats, rc = -ENOENT);
1319         }
1320
1321         pde->data = NULL;
1322         pde->proc_fops = &kgn_mdd_fops;
1323
1324         /* Initialize SMSG */
1325         pde = create_proc_entry(GNILND_PROC_SMSG, 0444, kgn_proc_root);
1326         if (pde == NULL) {
1327                 CERROR("couldn't create proc entry %s\n", GNILND_PROC_SMSG);
1328                 GOTO(remove_mdd, rc = -ENOENT);
1329         }
1330
1331         pde->data = NULL;
1332         pde->proc_fops = &kgn_smsg_fops;
1333
1334         /* Initialize CONN */
1335         pde = create_proc_entry(GNILND_PROC_CONN, 0444, kgn_proc_root);
1336         if (pde == NULL) {
1337                 CERROR("couldn't create proc entry %s\n", GNILND_PROC_CONN);
1338                 GOTO(remove_smsg, rc = -ENOENT);
1339         }
1340
1341         pde->data = NULL;
1342         pde->proc_fops = &kgn_conn_fops;
1343
1344         /* Initialize peer conns debug */
1345         pde = create_proc_entry(GNILND_PROC_PEER_CONNS, 0644, kgn_proc_root);
1346         if (pde == NULL) {
1347                 CERROR("couldn't create proc entry %s\n", GNILND_PROC_PEER_CONNS);
1348                 GOTO(remove_conn, rc = -ENOENT);
1349         }
1350
1351         pde->data = NULL;
1352         pde->read_proc = kgnilnd_proc_peer_conns_read;
1353         pde->write_proc = kgnilnd_proc_peer_conns_write;
1354
1355         /* Initialize PEER */
1356         pde = create_proc_entry(GNILND_PROC_PEER, 0444, kgn_proc_root);
1357         if (pde == NULL) {
1358                 CERROR("couldn't create proc entry %s\n", GNILND_PROC_PEER);
1359                 GOTO(remove_pc, rc = -ENOENT);
1360         }
1361
1362         pde->data = NULL;
1363         pde->proc_fops = &kgn_peer_fops;
1364         RETURN_EXIT;
1365
1366 remove_pc:
1367         remove_proc_entry(GNILND_PROC_PEER_CONNS, kgn_proc_root);
1368 remove_conn:
1369         remove_proc_entry(GNILND_PROC_CONN, kgn_proc_root);
1370 remove_smsg:
1371         remove_proc_entry(GNILND_PROC_SMSG, kgn_proc_root);
1372 remove_mdd:
1373         remove_proc_entry(GNILND_PROC_MDD, kgn_proc_root);
1374 remove_stats:
1375         remove_proc_entry(GNILND_PROC_STATS, kgn_proc_root);
1376 remove_test:
1377         remove_proc_entry(GNILND_PROC_CKSUM_TEST, kgn_proc_root);
1378 remove_dir:
1379         remove_proc_entry(kgn_proc_root->name, NULL);
1380
1381         RETURN_EXIT;
1382 }
1383
1384 void
1385 kgnilnd_proc_fini(void)
1386 {
1387         remove_proc_entry(GNILND_PROC_PEER_CONNS, kgn_proc_root);
1388         remove_proc_entry(GNILND_PROC_PEER, kgn_proc_root);
1389         remove_proc_entry(GNILND_PROC_CONN, kgn_proc_root);
1390         remove_proc_entry(GNILND_PROC_MDD, kgn_proc_root);
1391         remove_proc_entry(GNILND_PROC_SMSG, kgn_proc_root);
1392         remove_proc_entry(GNILND_PROC_STATS, kgn_proc_root);
1393         remove_proc_entry(GNILND_PROC_CKSUM_TEST, kgn_proc_root);
1394         remove_proc_entry(kgn_proc_root->name, NULL);
1395 }