1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=8:tabstop=8:
4 * Copyright 2008 Sun Microsystems, Inc. All rights reserved
6 * This file is part of Portals
7 * http://sourceforge.net/projects/sandiaportals/
9 * Portals is free software; you can redistribute it and/or
10 * modify it under the terms of version 2 of the GNU General Public
11 * License as published by the Free Software Foundation.
13 * Portals is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with Portals; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #define DEBUG_SUBSYSTEM S_LNET
25 #include <libcfs/libcfs.h>
26 #include <lnet/lib-lnet.h>
28 #if defined(__KERNEL__) && defined(LNET_ROUTER)
30 #if defined(__linux__)
31 #include <linux/seq_file.h>
34 /* this is really lnet_proc.c */
36 #define LNET_PROC_ROOT "sys/lnet"
37 #define LNET_PROC_STATS LNET_PROC_ROOT"/stats"
38 #define LNET_PROC_ROUTES LNET_PROC_ROOT"/routes"
39 #define LNET_PROC_ROUTERS LNET_PROC_ROOT"/routers"
40 #define LNET_PROC_PEERS LNET_PROC_ROOT"/peers"
41 #define LNET_PROC_BUFFERS LNET_PROC_ROOT"/buffers"
42 #define LNET_PROC_NIS LNET_PROC_ROOT"/nis"
45 lnet_router_proc_stats_read (char *page, char **start, off_t off,
46 int count, int *eof, void *data)
48 lnet_counters_t *ctrs;
56 LIBCFS_ALLOC(ctrs, sizeof(*ctrs));
61 *ctrs = the_lnet.ln_counters;
65 "%u %u %u %u %u %u %u "LPU64" "LPU64" "LPU64" "LPU64"\n",
66 ctrs->msgs_alloc, ctrs->msgs_max,
68 ctrs->send_count, ctrs->recv_count,
69 ctrs->route_count, ctrs->drop_count,
70 ctrs->send_length, ctrs->recv_length,
71 ctrs->route_length, ctrs->drop_length);
73 LIBCFS_FREE(ctrs, sizeof(*ctrs));
78 lnet_router_proc_stats_write(struct file *file, const char *ubuffer,
79 unsigned long count, void *data)
82 memset(&the_lnet.ln_counters, 0, sizeof(the_lnet.ln_counters));
90 lnet_remotenet_t *lrsi_net;
91 lnet_route_t *lrsi_route;
93 } lnet_route_seq_iterator_t;
96 lnet_route_seq_seek (lnet_route_seq_iterator_t *lrsi, loff_t off)
104 lrsi->lrsi_net = NULL;
105 lrsi->lrsi_route = NULL;
112 if (lrsi->lrsi_net != NULL &&
113 lrsi->lrsi_version != the_lnet.ln_remote_nets_version) {
114 /* tables have changed */
119 if (lrsi->lrsi_net == NULL || lrsi->lrsi_off > off) {
120 /* search from start */
121 n = the_lnet.ln_remote_nets.next;
125 /* continue search */
126 n = &lrsi->lrsi_net->lrn_list;
127 r = &lrsi->lrsi_route->lr_list;
128 here = lrsi->lrsi_off;
131 lrsi->lrsi_version = the_lnet.ln_remote_nets_version;
132 lrsi->lrsi_off = off;
134 while (n != &the_lnet.ln_remote_nets) {
135 lnet_remotenet_t *rnet =
136 list_entry(n, lnet_remotenet_t, lrn_list);
139 r = rnet->lrn_routes.next;
141 while (r != &rnet->lrn_routes) {
143 list_entry(r, lnet_route_t,
147 lrsi->lrsi_net = rnet;
148 lrsi->lrsi_route = re;
161 lrsi->lrsi_net = NULL;
162 lrsi->lrsi_route = NULL;
170 lnet_route_seq_start (struct seq_file *s, loff_t *pos)
172 lnet_route_seq_iterator_t *lrsi;
175 LIBCFS_ALLOC(lrsi, sizeof(*lrsi));
179 lrsi->lrsi_net = NULL;
180 rc = lnet_route_seq_seek(lrsi, *pos);
184 LIBCFS_FREE(lrsi, sizeof(*lrsi));
189 lnet_route_seq_stop (struct seq_file *s, void *iter)
191 lnet_route_seq_iterator_t *lrsi = iter;
194 LIBCFS_FREE(lrsi, sizeof(*lrsi));
198 lnet_route_seq_next (struct seq_file *s, void *iter, loff_t *pos)
200 lnet_route_seq_iterator_t *lrsi = iter;
202 loff_t next = *pos + 1;
204 rc = lnet_route_seq_seek(lrsi, next);
206 LIBCFS_FREE(lrsi, sizeof(*lrsi));
215 lnet_route_seq_show (struct seq_file *s, void *iter)
217 lnet_route_seq_iterator_t *lrsi = iter;
223 if (lrsi->lrsi_off == 0) {
224 seq_printf(s, "Routing %s\n",
225 the_lnet.ln_routing ? "enabled" : "disabled");
226 seq_printf(s, "%-8s %4s %7s %s\n",
227 "net", "hops", "state", "router");
231 LASSERT (lrsi->lrsi_net != NULL);
232 LASSERT (lrsi->lrsi_route != NULL);
236 if (lrsi->lrsi_version != the_lnet.ln_remote_nets_version) {
241 net = lrsi->lrsi_net->lrn_net;
242 hops = lrsi->lrsi_net->lrn_hops;
243 nid = lrsi->lrsi_route->lr_gateway->lp_nid;
244 alive = lrsi->lrsi_route->lr_gateway->lp_alive;
248 seq_printf(s, "%-8s %4u %7s %s\n", libcfs_net2str(net), hops,
249 alive ? "up" : "down", libcfs_nid2str(nid));
253 static struct seq_operations lnet_routes_sops = {
254 /* start */ lnet_route_seq_start,
255 /* stop */ lnet_route_seq_stop,
256 /* next */ lnet_route_seq_next,
257 /* show */ lnet_route_seq_show,
261 lnet_route_seq_open(struct inode *inode, struct file *file)
263 struct proc_dir_entry *dp = PDE(inode);
267 rc = seq_open(file, &lnet_routes_sops);
269 sf = file->private_data;
270 sf->private = dp->data;
276 static struct file_operations lnet_routes_fops;
279 lnet_init_routes_fops(void)
281 lnet_routes_fops.owner = THIS_MODULE;
282 lnet_routes_fops.llseek = seq_lseek;
283 lnet_routes_fops.read = seq_read;
284 lnet_routes_fops.open = lnet_route_seq_open;
285 lnet_routes_fops.release = seq_release;
289 __u64 lrtrsi_version;
290 lnet_peer_t *lrtrsi_router;
292 } lnet_router_seq_iterator_t;
295 lnet_router_seq_seek (lnet_router_seq_iterator_t *lrtrsi, loff_t off)
303 lrtrsi->lrtrsi_router = NULL;
304 lrtrsi->lrtrsi_off = 0;
310 lp = lrtrsi->lrtrsi_router;
313 lrtrsi->lrtrsi_version != the_lnet.ln_routers_version) {
314 /* tables have changed */
319 if (lp == NULL || lrtrsi->lrtrsi_off > off) {
320 /* search from start */
321 r = the_lnet.ln_routers.next;
324 /* continue search */
325 r = &lp->lp_rtr_list;
326 here = lrtrsi->lrtrsi_off;
329 lrtrsi->lrtrsi_version = the_lnet.ln_routers_version;
330 lrtrsi->lrtrsi_off = off;
332 while (r != &the_lnet.ln_routers) {
333 lnet_peer_t *rtr = list_entry(r,
338 lrtrsi->lrtrsi_router = rtr;
347 lrtrsi->lrtrsi_router = NULL;
355 lnet_router_seq_start (struct seq_file *s, loff_t *pos)
357 lnet_router_seq_iterator_t *lrtrsi;
360 LIBCFS_ALLOC(lrtrsi, sizeof(*lrtrsi));
364 lrtrsi->lrtrsi_router = NULL;
365 rc = lnet_router_seq_seek(lrtrsi, *pos);
369 LIBCFS_FREE(lrtrsi, sizeof(*lrtrsi));
374 lnet_router_seq_stop (struct seq_file *s, void *iter)
376 lnet_router_seq_iterator_t *lrtrsi = iter;
379 LIBCFS_FREE(lrtrsi, sizeof(*lrtrsi));
383 lnet_router_seq_next (struct seq_file *s, void *iter, loff_t *pos)
385 lnet_router_seq_iterator_t *lrtrsi = iter;
387 loff_t next = *pos + 1;
389 rc = lnet_router_seq_seek(lrtrsi, next);
391 LIBCFS_FREE(lrtrsi, sizeof(*lrtrsi));
400 lnet_router_seq_show (struct seq_file *s, void *iter)
402 lnet_router_seq_iterator_t *lrtrsi = iter;
411 if (lrtrsi->lrtrsi_off == 0) {
412 seq_printf(s, "%-4s %7s %9s %6s %12s %s\n",
413 "ref", "rtr_ref", "alive_cnt", "state", "last_ping", "router");
417 lp = lrtrsi->lrtrsi_router;
418 LASSERT (lp != NULL);
422 if (lrtrsi->lrtrsi_version != the_lnet.ln_routers_version) {
428 alive = lp->lp_alive;
429 alive_cnt = lp->lp_alive_count;
430 nrefs = lp->lp_refcount;
431 nrtrrefs = lp->lp_rtr_refcount;
432 last_ping = lp->lp_ping_timestamp;
437 "%-4d %7d %9d %6s %12lu %s\n", nrefs, nrtrrefs,
438 alive_cnt, alive ? "up" : "down",
439 last_ping, libcfs_nid2str(nid));
443 static struct seq_operations lnet_routers_sops = {
444 /* start */ lnet_router_seq_start,
445 /* stop */ lnet_router_seq_stop,
446 /* next */ lnet_router_seq_next,
447 /* show */ lnet_router_seq_show,
451 lnet_router_seq_open(struct inode *inode, struct file *file)
453 struct proc_dir_entry *dp = PDE(inode);
457 rc = seq_open(file, &lnet_routers_sops);
459 sf = file->private_data;
460 sf->private = dp->data;
466 static struct file_operations lnet_routers_fops;
469 lnet_init_routers_fops(void)
471 lnet_routers_fops.owner = THIS_MODULE;
472 lnet_routers_fops.llseek = seq_lseek;
473 lnet_routers_fops.read = seq_read;
474 lnet_routers_fops.open = lnet_router_seq_open;
475 lnet_routers_fops.release = seq_release;
479 unsigned long long lpsi_version;
481 lnet_peer_t *lpsi_peer;
483 } lnet_peer_seq_iterator_t;
486 lnet_peer_seq_seek (lnet_peer_seq_iterator_t *lpsi, loff_t off)
495 lpsi->lpsi_peer = NULL;
502 if (lpsi->lpsi_peer != NULL &&
503 lpsi->lpsi_version != the_lnet.ln_peertable_version) {
504 /* tables have changed */
509 if (lpsi->lpsi_peer == NULL ||
510 lpsi->lpsi_off > off) {
511 /* search from start */
516 /* continue search */
517 idx = lpsi->lpsi_idx;
518 p = &lpsi->lpsi_peer->lp_hashlist;
519 here = lpsi->lpsi_off;
522 lpsi->lpsi_version = the_lnet.ln_peertable_version;
523 lpsi->lpsi_off = off;
525 while (idx < LNET_PEER_HASHSIZE) {
527 p = the_lnet.ln_peer_hash[idx].next;
529 while (p != &the_lnet.ln_peer_hash[idx]) {
530 lnet_peer_t *lp = list_entry(p, lnet_peer_t,
534 lpsi->lpsi_idx = idx;
535 lpsi->lpsi_peer = lp;
541 p = lp->lp_hashlist.next;
549 lpsi->lpsi_peer = NULL;
557 lnet_peer_seq_start (struct seq_file *s, loff_t *pos)
559 lnet_peer_seq_iterator_t *lpsi;
562 LIBCFS_ALLOC(lpsi, sizeof(*lpsi));
567 lpsi->lpsi_peer = NULL;
568 rc = lnet_peer_seq_seek(lpsi, *pos);
572 LIBCFS_FREE(lpsi, sizeof(*lpsi));
577 lnet_peer_seq_stop (struct seq_file *s, void *iter)
579 lnet_peer_seq_iterator_t *lpsi = iter;
582 LIBCFS_FREE(lpsi, sizeof(*lpsi));
586 lnet_peer_seq_next (struct seq_file *s, void *iter, loff_t *pos)
588 lnet_peer_seq_iterator_t *lpsi = iter;
590 loff_t next = *pos + 1;
592 rc = lnet_peer_seq_seek(lpsi, next);
594 LIBCFS_FREE(lpsi, sizeof(*lpsi));
603 lnet_peer_seq_show (struct seq_file *s, void *iter)
605 lnet_peer_seq_iterator_t *lpsi = iter;
618 if (lpsi->lpsi_off == 0) {
619 seq_printf(s, "%-24s %4s %5s %5s %5s %5s %5s %5s %s\n",
620 "nid", "refs", "state", "max",
621 "rtr", "min", "tx", "min", "queue");
625 LASSERT (lpsi->lpsi_peer != NULL);
629 if (lpsi->lpsi_version != the_lnet.ln_peertable_version) {
634 lp = lpsi->lpsi_peer;
637 maxcr = lp->lp_ni->ni_peertxcredits;
638 txcr = lp->lp_txcredits;
639 mintxcr = lp->lp_mintxcredits;
640 rtrcr = lp->lp_rtrcredits;
641 minrtrcr = lp->lp_minrtrcredits;
642 rtr = lnet_isrouter(lp);
643 alive = lp->lp_alive;
644 txqnob = lp->lp_txqnob;
645 nrefs = lp->lp_refcount;
649 seq_printf(s, "%-24s %4d %5s %5d %5d %5d %5d %5d %d\n",
650 libcfs_nid2str(nid), nrefs,
651 !rtr ? "~rtr" : (alive ? "up" : "down"),
652 maxcr, rtrcr, minrtrcr, txcr, mintxcr, txqnob);
656 static struct seq_operations lnet_peer_sops = {
657 /* start */ lnet_peer_seq_start,
658 /* stop */ lnet_peer_seq_stop,
659 /* next */ lnet_peer_seq_next,
660 /* show */ lnet_peer_seq_show,
664 lnet_peer_seq_open(struct inode *inode, struct file *file)
666 struct proc_dir_entry *dp = PDE(inode);
670 rc = seq_open(file, &lnet_peer_sops);
672 sf = file->private_data;
673 sf->private = dp->data;
679 static struct file_operations lnet_peer_fops;
682 lnet_init_peer_fops(void)
684 lnet_peer_fops.owner = THIS_MODULE;
685 lnet_peer_fops.llseek = seq_lseek;
686 lnet_peer_fops.read = seq_read;
687 lnet_peer_fops.open = lnet_peer_seq_open;
688 lnet_peer_fops.release = seq_release;
694 } lnet_buffer_seq_iterator_t;
697 lnet_buffer_seq_seek (lnet_buffer_seq_iterator_t *lbsi, loff_t off)
711 if (lbsi->lbsi_idx < 0 ||
712 lbsi->lbsi_off > off) {
713 /* search from start */
717 /* continue search */
718 idx = lbsi->lbsi_idx;
719 here = lbsi->lbsi_off;
722 lbsi->lbsi_off = off;
724 while (idx < LNET_NRBPOOLS) {
726 lbsi->lbsi_idx = idx;
742 lnet_buffer_seq_start (struct seq_file *s, loff_t *pos)
744 lnet_buffer_seq_iterator_t *lbsi;
747 LIBCFS_ALLOC(lbsi, sizeof(*lbsi));
752 rc = lnet_buffer_seq_seek(lbsi, *pos);
756 LIBCFS_FREE(lbsi, sizeof(*lbsi));
761 lnet_buffer_seq_stop (struct seq_file *s, void *iter)
763 lnet_buffer_seq_iterator_t *lbsi = iter;
766 LIBCFS_FREE(lbsi, sizeof(*lbsi));
770 lnet_buffer_seq_next (struct seq_file *s, void *iter, loff_t *pos)
772 lnet_buffer_seq_iterator_t *lbsi = iter;
774 loff_t next = *pos + 1;
776 rc = lnet_buffer_seq_seek(lbsi, next);
778 LIBCFS_FREE(lbsi, sizeof(*lbsi));
787 lnet_buffer_seq_show (struct seq_file *s, void *iter)
789 lnet_buffer_seq_iterator_t *lbsi = iter;
790 lnet_rtrbufpool_t *rbp;
796 if (lbsi->lbsi_off == 0) {
797 seq_printf(s, "%5s %5s %7s %7s\n",
798 "pages", "count", "credits", "min");
802 LASSERT (lbsi->lbsi_idx >= 0 && lbsi->lbsi_idx < LNET_NRBPOOLS);
806 rbp = &the_lnet.ln_rtrpools[lbsi->lbsi_idx];
808 npages = rbp->rbp_npages;
809 nbuf = rbp->rbp_nbuffers;
810 cr = rbp->rbp_credits;
811 mincr = rbp->rbp_mincredits;
815 seq_printf(s, "%5d %5d %7d %7d\n",
816 npages, nbuf, cr, mincr);
820 static struct seq_operations lnet_buffer_sops = {
821 /* start */ lnet_buffer_seq_start,
822 /* stop */ lnet_buffer_seq_stop,
823 /* next */ lnet_buffer_seq_next,
824 /* show */ lnet_buffer_seq_show,
828 lnet_buffer_seq_open(struct inode *inode, struct file *file)
830 struct proc_dir_entry *dp = PDE(inode);
834 rc = seq_open(file, &lnet_buffer_sops);
836 sf = file->private_data;
837 sf->private = dp->data;
843 static struct file_operations lnet_buffers_fops;
846 lnet_init_buffers_fops(void)
848 lnet_buffers_fops.owner = THIS_MODULE;
849 lnet_buffers_fops.llseek = seq_lseek;
850 lnet_buffers_fops.read = seq_read;
851 lnet_buffers_fops.open = lnet_buffer_seq_open;
852 lnet_buffers_fops.release = seq_release;
858 } lnet_ni_seq_iterator_t;
861 lnet_ni_seq_seek (lnet_ni_seq_iterator_t *lnsi, loff_t off)
868 lnsi->lnsi_ni = NULL;
875 if (lnsi->lnsi_ni == NULL ||
876 lnsi->lnsi_off > off) {
877 /* search from start */
881 /* continue search */
882 n = &lnsi->lnsi_ni->ni_list;
883 here = lnsi->lnsi_off;
886 lnsi->lnsi_off = off;
889 n = the_lnet.ln_nis.next;
891 while (n != &the_lnet.ln_nis) {
893 lnsi->lnsi_ni = list_entry(n, lnet_ni_t, ni_list);
901 lnsi->lnsi_ni = NULL;
909 lnet_ni_seq_start (struct seq_file *s, loff_t *pos)
911 lnet_ni_seq_iterator_t *lnsi;
914 LIBCFS_ALLOC(lnsi, sizeof(*lnsi));
918 lnsi->lnsi_ni = NULL;
919 rc = lnet_ni_seq_seek(lnsi, *pos);
923 LIBCFS_FREE(lnsi, sizeof(*lnsi));
928 lnet_ni_seq_stop (struct seq_file *s, void *iter)
930 lnet_ni_seq_iterator_t *lnsi = iter;
933 LIBCFS_FREE(lnsi, sizeof(*lnsi));
937 lnet_ni_seq_next (struct seq_file *s, void *iter, loff_t *pos)
939 lnet_ni_seq_iterator_t *lnsi = iter;
941 loff_t next = *pos + 1;
943 rc = lnet_ni_seq_seek(lnsi, next);
945 LIBCFS_FREE(lnsi, sizeof(*lnsi));
954 lnet_ni_seq_show (struct seq_file *s, void *iter)
956 lnet_ni_seq_iterator_t *lnsi = iter;
965 if (lnsi->lnsi_off == 0) {
966 seq_printf(s, "%-24s %4s %4s %5s %5s %5s\n",
967 "nid", "refs", "peer", "max", "tx", "min");
971 LASSERT (lnsi->lnsi_ni != NULL);
977 maxtxcr = ni->ni_maxtxcredits;
978 txcr = ni->ni_txcredits;
979 mintxcr = ni->ni_mintxcredits;
980 npeertxcr = ni->ni_peertxcredits;
982 nref = ni->ni_refcount;
986 seq_printf(s, "%-24s %4d %4d %5d %5d %5d\n",
987 libcfs_nid2str(nid), nref,
988 npeertxcr, maxtxcr, txcr, mintxcr);
992 static struct seq_operations lnet_ni_sops = {
993 /* start */ lnet_ni_seq_start,
994 /* stop */ lnet_ni_seq_stop,
995 /* next */ lnet_ni_seq_next,
996 /* show */ lnet_ni_seq_show,
1000 lnet_ni_seq_open(struct inode *inode, struct file *file)
1002 struct proc_dir_entry *dp = PDE(inode);
1003 struct seq_file *sf;
1006 rc = seq_open(file, &lnet_ni_sops);
1008 sf = file->private_data;
1009 sf->private = dp->data;
1015 static struct file_operations lnet_ni_fops;
1018 lnet_init_ni_fops(void)
1020 lnet_ni_fops.owner = THIS_MODULE;
1021 lnet_ni_fops.llseek = seq_lseek;
1022 lnet_ni_fops.read = seq_read;
1023 lnet_ni_fops.open = lnet_ni_seq_open;
1024 lnet_ni_fops.release = seq_release;
1028 lnet_proc_init(void)
1030 struct proc_dir_entry *pde;
1033 pde = proc_mkdir(LNET_PROC_ROOT, NULL);
1035 CERROR("couldn't create "LNET_PROC_ROOT"\n");
1039 /* Initialize LNET_PROC_STATS */
1040 pde = create_proc_entry (LNET_PROC_STATS, 0644, NULL);
1042 CERROR("couldn't create proc entry %s\n", LNET_PROC_STATS);
1047 pde->read_proc = lnet_router_proc_stats_read;
1048 pde->write_proc = lnet_router_proc_stats_write;
1050 /* Initialize LNET_PROC_ROUTES */
1051 pde = create_proc_entry (LNET_PROC_ROUTES, 0444, NULL);
1053 CERROR("couldn't create proc entry %s\n", LNET_PROC_ROUTES);
1057 lnet_init_routes_fops();
1058 pde->proc_fops = &lnet_routes_fops;
1061 /* Initialize LNET_PROC_ROUTERS */
1062 pde = create_proc_entry (LNET_PROC_ROUTERS, 0444, NULL);
1064 CERROR("couldn't create proc entry %s\n", LNET_PROC_ROUTERS);
1068 lnet_init_routers_fops();
1069 pde->proc_fops = &lnet_routers_fops;
1072 /* Initialize LNET_PROC_PEERS */
1073 pde = create_proc_entry (LNET_PROC_PEERS, 0444, NULL);
1075 CERROR("couldn't create proc entry %s\n", LNET_PROC_PEERS);
1079 lnet_init_peer_fops();
1080 pde->proc_fops = &lnet_peer_fops;
1083 /* Initialize LNET_PROC_BUFFERS */
1084 pde = create_proc_entry (LNET_PROC_BUFFERS, 0444, NULL);
1086 CERROR("couldn't create proc entry %s\n", LNET_PROC_BUFFERS);
1090 lnet_init_buffers_fops();
1091 pde->proc_fops = &lnet_buffers_fops;
1094 /* Initialize LNET_PROC_NIS */
1095 pde = create_proc_entry (LNET_PROC_NIS, 0444, NULL);
1097 CERROR("couldn't create proc entry %s\n", LNET_PROC_NIS);
1101 lnet_init_ni_fops();
1102 pde->proc_fops = &lnet_ni_fops;
1107 lnet_proc_fini(void)
1109 remove_proc_entry(LNET_PROC_STATS, 0);
1110 remove_proc_entry(LNET_PROC_ROUTES, 0);
1111 remove_proc_entry(LNET_PROC_ROUTERS, 0);
1112 remove_proc_entry(LNET_PROC_PEERS, 0);
1113 remove_proc_entry(LNET_PROC_BUFFERS, 0);
1114 remove_proc_entry(LNET_PROC_NIS, 0);
1116 remove_proc_entry(LNET_PROC_ROOT, 0);
1123 lnet_proc_init(void)
1128 lnet_proc_fini(void)