Whamcloud - gitweb
76362028a91ad3de12ab90ec8981764776437a5f
[fs/lustre-release.git] / lnet / lnet / router_proc.c
1 /*
2  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
3  *
4  * Copyright (c) 2011, 2015, Intel Corporation.
5  *
6  *   This file is part of Lustre, https://wiki.hpdd.intel.com/
7  *
8  *   Portals 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  *   Portals 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 Portals; if not, write to the Free Software
19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  *
21  */
22
23 #define DEBUG_SUBSYSTEM S_LNET
24 #include <libcfs/libcfs.h>
25 #include <lnet/lib-lnet.h>
26
27 /* This is really lnet_proc.c. You might need to update sanity test 215
28  * if any file format is changed. */
29
30 static struct ctl_table_header *lnet_table_header = NULL;
31
32 #define LNET_LOFFT_BITS         (sizeof(loff_t) * 8)
33 /*
34  * NB: max allowed LNET_CPT_BITS is 8 on 64-bit system and 2 on 32-bit system
35  */
36 #define LNET_PROC_CPT_BITS      (LNET_CPT_BITS + 1)
37 /* change version, 16 bits or 8 bits */
38 #define LNET_PROC_VER_BITS      MAX(((MIN(LNET_LOFFT_BITS, 64)) / 4), 8)
39
40 #define LNET_PROC_HASH_BITS     LNET_PEER_HASH_BITS
41 /*
42  * bits for peer hash offset
43  * NB: we don't use the highest bit of *ppos because it's signed
44  */
45 #define LNET_PROC_HOFF_BITS     (LNET_LOFFT_BITS -       \
46                                  LNET_PROC_CPT_BITS -    \
47                                  LNET_PROC_VER_BITS -    \
48                                  LNET_PROC_HASH_BITS - 1)
49 /* bits for hash index + position */
50 #define LNET_PROC_HPOS_BITS     (LNET_PROC_HASH_BITS + LNET_PROC_HOFF_BITS)
51 /* bits for peer hash table + hash version */
52 #define LNET_PROC_VPOS_BITS     (LNET_PROC_HPOS_BITS + LNET_PROC_VER_BITS)
53
54 #define LNET_PROC_CPT_MASK      ((1ULL << LNET_PROC_CPT_BITS) - 1)
55 #define LNET_PROC_VER_MASK      ((1ULL << LNET_PROC_VER_BITS) - 1)
56 #define LNET_PROC_HASH_MASK     ((1ULL << LNET_PROC_HASH_BITS) - 1)
57 #define LNET_PROC_HOFF_MASK     ((1ULL << LNET_PROC_HOFF_BITS) - 1)
58
59 #define LNET_PROC_CPT_GET(pos)                          \
60         (int)(((pos) >> LNET_PROC_VPOS_BITS) & LNET_PROC_CPT_MASK)
61
62 #define LNET_PROC_VER_GET(pos)                          \
63         (int)(((pos) >> LNET_PROC_HPOS_BITS) & LNET_PROC_VER_MASK)
64
65 #define LNET_PROC_HASH_GET(pos)                         \
66         (int)(((pos) >> LNET_PROC_HOFF_BITS) & LNET_PROC_HASH_MASK)
67
68 #define LNET_PROC_HOFF_GET(pos)                         \
69         (int)((pos) & LNET_PROC_HOFF_MASK)
70
71 #define LNET_PROC_POS_MAKE(cpt, ver, hash, off)         \
72         (((((loff_t)(cpt)) & LNET_PROC_CPT_MASK) << LNET_PROC_VPOS_BITS) |   \
73         ((((loff_t)(ver)) & LNET_PROC_VER_MASK) << LNET_PROC_HPOS_BITS) |   \
74         ((((loff_t)(hash)) & LNET_PROC_HASH_MASK) << LNET_PROC_HOFF_BITS) | \
75         ((off) & LNET_PROC_HOFF_MASK))
76
77 #define LNET_PROC_VERSION(v)    ((unsigned int)((v) & LNET_PROC_VER_MASK))
78
79 static int __proc_lnet_stats(void *data, int write,
80                              loff_t pos, void __user *buffer, int nob)
81 {
82         int              rc;
83         lnet_counters_t *ctrs;
84         int              len;
85         char            *tmpstr;
86         const int        tmpsiz = 256; /* 7 %u and 4 __u64 */
87
88         if (write) {
89                 lnet_counters_reset();
90                 return 0;
91         }
92
93         /* read */
94
95         LIBCFS_ALLOC(ctrs, sizeof(*ctrs));
96         if (ctrs == NULL)
97                 return -ENOMEM;
98
99         LIBCFS_ALLOC(tmpstr, tmpsiz);
100         if (tmpstr == NULL) {
101                 LIBCFS_FREE(ctrs, sizeof(*ctrs));
102                 return -ENOMEM;
103         }
104
105         lnet_counters_get(ctrs);
106
107         len = snprintf(tmpstr, tmpsiz,
108                        "%u %u %u %u %u %u %u %llu %llu "
109                        "%llu %llu",
110                        ctrs->msgs_alloc, ctrs->msgs_max,
111                        ctrs->errors,
112                        ctrs->send_count, ctrs->recv_count,
113                        ctrs->route_count, ctrs->drop_count,
114                        ctrs->send_length, ctrs->recv_length,
115                        ctrs->route_length, ctrs->drop_length);
116
117         if (pos >= min_t(int, len, strlen(tmpstr)))
118                 rc = 0;
119         else
120                 rc = cfs_trace_copyout_string(buffer, nob,
121                                               tmpstr + pos, "\n");
122
123         LIBCFS_FREE(tmpstr, tmpsiz);
124         LIBCFS_FREE(ctrs, sizeof(*ctrs));
125         return rc;
126 }
127
128 static int
129 proc_lnet_stats(struct ctl_table *table, int write, void __user *buffer,
130                 size_t *lenp, loff_t *ppos)
131 {
132         return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
133                                     __proc_lnet_stats);
134 }
135
136 static int
137 proc_lnet_routes(struct ctl_table *table, int write, void __user *buffer,
138                  size_t *lenp, loff_t *ppos)
139 {
140         const int       tmpsiz = 256;
141         char            *tmpstr;
142         char            *s;
143         int             rc = 0;
144         int             len;
145         int             ver;
146         int             off;
147
148         CLASSERT(sizeof(loff_t) >= 4);
149
150         off = LNET_PROC_HOFF_GET(*ppos);
151         ver = LNET_PROC_VER_GET(*ppos);
152
153         LASSERT(!write);
154
155         if (*lenp == 0)
156                 return 0;
157
158         LIBCFS_ALLOC(tmpstr, tmpsiz);
159         if (tmpstr == NULL)
160                 return -ENOMEM;
161
162         s = tmpstr; /* points to current position in tmpstr[] */
163
164         if (*ppos == 0) {
165                 s += snprintf(s, tmpstr + tmpsiz - s, "Routing %s\n",
166                               the_lnet.ln_routing ? "enabled" : "disabled");
167                 LASSERT(tmpstr + tmpsiz - s > 0);
168
169                 s += snprintf(s, tmpstr + tmpsiz - s, "%-8s %4s %8s %7s %s\n",
170                               "net", "hops", "priority", "state", "router");
171                 LASSERT(tmpstr + tmpsiz - s > 0);
172
173                 lnet_net_lock(0);
174                 ver = (unsigned int)the_lnet.ln_remote_nets_version;
175                 lnet_net_unlock(0);
176                 *ppos = LNET_PROC_POS_MAKE(0, ver, 0, off);
177         } else {
178                 struct list_head        *n;
179                 struct list_head        *r;
180                 lnet_route_t            *route = NULL;
181                 lnet_remotenet_t        *rnet  = NULL;
182                 int                     skip  = off - 1;
183                 struct list_head        *rn_list;
184                 int                     i;
185
186                 lnet_net_lock(0);
187
188                 if (ver != LNET_PROC_VERSION(the_lnet.ln_remote_nets_version)) {
189                         lnet_net_unlock(0);
190                         LIBCFS_FREE(tmpstr, tmpsiz);
191                         return -ESTALE;
192                 }
193
194                 for (i = 0; i < LNET_REMOTE_NETS_HASH_SIZE && route == NULL;
195                      i++) {
196                         rn_list = &the_lnet.ln_remote_nets_hash[i];
197
198                         n = rn_list->next;
199
200                         while (n != rn_list && route == NULL) {
201                                 rnet = list_entry(n, lnet_remotenet_t,
202                                                   lrn_list);
203
204                                 r = rnet->lrn_routes.next;
205
206                                 while (r != &rnet->lrn_routes) {
207                                         lnet_route_t *re =
208                                                 list_entry(r, lnet_route_t,
209                                                            lr_list);
210                                         if (skip == 0) {
211                                                 route = re;
212                                                 break;
213                                         }
214
215                                         skip--;
216                                         r = r->next;
217                                 }
218
219                                 n = n->next;
220                         }
221                 }
222
223                 if (route != NULL) {
224                         __u32        net        = rnet->lrn_net;
225                         __u32 hops              = route->lr_hops;
226                         unsigned int priority   = route->lr_priority;
227                         lnet_nid_t   nid        = route->lr_gateway->lpni_nid;
228                         int          alive      = lnet_is_route_alive(route);
229
230                         s += snprintf(s, tmpstr + tmpsiz - s,
231                                       "%-8s %4u %8u %7s %s\n",
232                                       libcfs_net2str(net), hops,
233                                       priority,
234                                       alive ? "up" : "down",
235                                       libcfs_nid2str(nid));
236                         LASSERT(tmpstr + tmpsiz - s > 0);
237                 }
238
239                 lnet_net_unlock(0);
240         }
241
242         len = s - tmpstr;     /* how many bytes was written */
243
244         if (len > *lenp) {    /* linux-supplied buffer is too small */
245                 rc = -EINVAL;
246         } else if (len > 0) { /* wrote something */
247                 if (copy_to_user(buffer, tmpstr, len))
248                         rc = -EFAULT;
249                 else {
250                         off += 1;
251                         *ppos = LNET_PROC_POS_MAKE(0, ver, 0, off);
252                 }
253         }
254
255         LIBCFS_FREE(tmpstr, tmpsiz);
256
257         if (rc == 0)
258                 *lenp = len;
259
260         return rc;
261 }
262
263 static int
264 proc_lnet_routers(struct ctl_table *table, int write, void __user *buffer,
265                   size_t *lenp, loff_t *ppos)
266 {
267         int        rc = 0;
268         char      *tmpstr;
269         char      *s;
270         const int  tmpsiz = 256;
271         int        len;
272         int        ver;
273         int        off;
274
275         off = LNET_PROC_HOFF_GET(*ppos);
276         ver = LNET_PROC_VER_GET(*ppos);
277
278         LASSERT(!write);
279
280         if (*lenp == 0)
281                 return 0;
282
283         LIBCFS_ALLOC(tmpstr, tmpsiz);
284         if (tmpstr == NULL)
285                 return -ENOMEM;
286
287         s = tmpstr; /* points to current position in tmpstr[] */
288
289         if (*ppos == 0) {
290                 s += snprintf(s, tmpstr + tmpsiz - s,
291                               "%-4s %7s %9s %6s %12s %9s %8s %7s %s\n",
292                               "ref", "rtr_ref", "alive_cnt", "state",
293                               "last_ping", "ping_sent", "deadline",
294                               "down_ni", "router");
295                 LASSERT(tmpstr + tmpsiz - s > 0);
296
297                 lnet_net_lock(0);
298                 ver = (unsigned int)the_lnet.ln_routers_version;
299                 lnet_net_unlock(0);
300                 *ppos = LNET_PROC_POS_MAKE(0, ver, 0, off);
301         } else {
302                 struct list_head *r;
303                 struct lnet_peer_ni *peer = NULL;
304                 int               skip = off - 1;
305
306                 lnet_net_lock(0);
307
308                 if (ver != LNET_PROC_VERSION(the_lnet.ln_routers_version)) {
309                         lnet_net_unlock(0);
310
311                         LIBCFS_FREE(tmpstr, tmpsiz);
312                         return -ESTALE;
313                 }
314
315                 r = the_lnet.ln_routers.next;
316
317                 while (r != &the_lnet.ln_routers) {
318                         struct lnet_peer_ni *lp =
319                           list_entry(r, struct lnet_peer_ni,
320                                      lpni_rtr_list);
321
322                         if (skip == 0) {
323                                 peer = lp;
324                                 break;
325                         }
326
327                         skip--;
328                         r = r->next;
329                 }
330
331                 if (peer != NULL) {
332                         lnet_nid_t nid = peer->lpni_nid;
333                         cfs_time_t now = cfs_time_current();
334                         cfs_time_t deadline = peer->lpni_ping_deadline;
335                         int nrefs     = atomic_read(&peer->lpni_refcount);
336                         int nrtrrefs  = peer->lpni_rtr_refcount;
337                         int alive_cnt = peer->lpni_alive_count;
338                         int alive     = peer->lpni_alive;
339                         int pingsent  = !peer->lpni_ping_notsent;
340                         int last_ping = cfs_duration_sec(cfs_time_sub(now,
341                                                      peer->lpni_ping_timestamp));
342                         int down_ni   = 0;
343                         lnet_route_t *rtr;
344
345                         if ((peer->lpni_ping_feats &
346                              LNET_PING_FEAT_NI_STATUS) != 0) {
347                                 list_for_each_entry(rtr, &peer->lpni_routes,
348                                                     lr_gwlist) {
349                                         /* downis on any route should be the
350                                          * number of downis on the gateway */
351                                         if (rtr->lr_downis != 0) {
352                                                 down_ni = rtr->lr_downis;
353                                                 break;
354                                         }
355                                 }
356                         }
357
358                         if (deadline == 0)
359                                 s += snprintf(s, tmpstr + tmpsiz - s,
360                                               "%-4d %7d %9d %6s %12d %9d %8s %7d %s\n",
361                                               nrefs, nrtrrefs, alive_cnt,
362                                               alive ? "up" : "down", last_ping,
363                                               pingsent, "NA", down_ni,
364                                               libcfs_nid2str(nid));
365                         else
366                                 s += snprintf(s, tmpstr + tmpsiz - s,
367                                               "%-4d %7d %9d %6s %12d %9d %8lu %7d %s\n",
368                                               nrefs, nrtrrefs, alive_cnt,
369                                               alive ? "up" : "down", last_ping,
370                                               pingsent,
371                                               cfs_duration_sec(cfs_time_sub(deadline, now)),
372                                               down_ni, libcfs_nid2str(nid));
373                         LASSERT(tmpstr + tmpsiz - s > 0);
374                 }
375
376                 lnet_net_unlock(0);
377         }
378
379         len = s - tmpstr;     /* how many bytes was written */
380
381         if (len > *lenp) {    /* linux-supplied buffer is too small */
382                 rc = -EINVAL;
383         } else if (len > 0) { /* wrote something */
384                 if (copy_to_user(buffer, tmpstr, len))
385                         rc = -EFAULT;
386                 else {
387                         off += 1;
388                         *ppos = LNET_PROC_POS_MAKE(0, ver, 0, off);
389                 }
390         }
391
392         LIBCFS_FREE(tmpstr, tmpsiz);
393
394         if (rc == 0)
395                 *lenp = len;
396
397         return rc;
398 }
399
400 /* TODO: there should be no direct access to ptable. We should add a set
401  * of APIs that give access to the ptable and its members */
402 static int
403 proc_lnet_peers(struct ctl_table *table, int write, void __user *buffer,
404                 size_t *lenp, loff_t *ppos)
405 {
406         const int               tmpsiz  = 256;
407         struct lnet_peer_table  *ptable;
408         char                    *tmpstr;
409         char                    *s;
410         int                     cpt  = LNET_PROC_CPT_GET(*ppos);
411         int                     ver  = LNET_PROC_VER_GET(*ppos);
412         int                     hash = LNET_PROC_HASH_GET(*ppos);
413         int                     hoff = LNET_PROC_HOFF_GET(*ppos);
414         int                     rc = 0;
415         int                     len;
416
417         CLASSERT(LNET_PROC_HASH_BITS >= LNET_PEER_HASH_BITS);
418         LASSERT(!write);
419
420         if (*lenp == 0)
421                 return 0;
422
423         if (cpt >= LNET_CPT_NUMBER) {
424                 *lenp = 0;
425                 return 0;
426         }
427
428         LIBCFS_ALLOC(tmpstr, tmpsiz);
429         if (tmpstr == NULL)
430                 return -ENOMEM;
431
432         s = tmpstr; /* points to current position in tmpstr[] */
433
434         if (*ppos == 0) {
435                 s += snprintf(s, tmpstr + tmpsiz - s,
436                               "%-24s %4s %5s %5s %5s %5s %5s %5s %5s %s\n",
437                               "nid", "refs", "state", "last", "max",
438                               "rtr", "min", "tx", "min", "queue");
439                 LASSERT(tmpstr + tmpsiz - s > 0);
440
441                 hoff++;
442         } else {
443                 struct lnet_peer_ni     *peer;
444                 struct list_head        *p;
445                 int                     skip;
446  again:
447                 p = NULL;
448                 peer = NULL;
449                 skip = hoff - 1;
450
451                 lnet_net_lock(cpt);
452                 ptable = the_lnet.ln_peer_tables[cpt];
453                 if (hoff == 1)
454                         ver = LNET_PROC_VERSION(ptable->pt_version);
455
456                 if (ver != LNET_PROC_VERSION(ptable->pt_version)) {
457                         lnet_net_unlock(cpt);
458                         LIBCFS_FREE(tmpstr, tmpsiz);
459                         return -ESTALE;
460                 }
461
462                 while (hash < LNET_PEER_HASH_SIZE) {
463                         if (p == NULL)
464                                 p = ptable->pt_hash[hash].next;
465
466                         while (p != &ptable->pt_hash[hash]) {
467                                 struct lnet_peer_ni *lp =
468                                   list_entry(p, struct lnet_peer_ni,
469                                              lpni_hashlist);
470                                 if (skip == 0) {
471                                         peer = lp;
472
473                                         /* minor optimization: start from idx+1
474                                          * on next iteration if we've just
475                                          * drained lpni_hashlist */
476                                         if (lp->lpni_hashlist.next ==
477                                             &ptable->pt_hash[hash]) {
478                                                 hoff = 1;
479                                                 hash++;
480                                         } else {
481                                                 hoff++;
482                                         }
483
484                                         break;
485                                 }
486
487                                 skip--;
488                                 p = lp->lpni_hashlist.next;
489                         }
490
491                         if (peer != NULL)
492                                 break;
493
494                         p = NULL;
495                         hoff = 1;
496                         hash++;
497                 }
498
499                 if (peer != NULL) {
500                         lnet_nid_t nid = peer->lpni_nid;
501                         int nrefs = atomic_read(&peer->lpni_refcount);
502                         int lastalive = -1;
503                         char *aliveness = "NA";
504                         int maxcr = peer->lpni_net->net_tunables.lct_peer_tx_credits;
505                         int txcr = peer->lpni_txcredits;
506                         int mintxcr = peer->lpni_mintxcredits;
507                         int rtrcr = peer->lpni_rtrcredits;
508                         int minrtrcr = peer->lpni_minrtrcredits;
509                         int txqnob = peer->lpni_txqnob;
510
511                         if (lnet_isrouter(peer) ||
512                             lnet_peer_aliveness_enabled(peer))
513                                 aliveness = peer->lpni_alive ? "up" : "down";
514
515                         if (lnet_peer_aliveness_enabled(peer)) {
516                                 cfs_time_t now = cfs_time_current();
517                                 cfs_duration_t delta;
518
519                                 delta = cfs_time_sub(now, peer->lpni_last_alive);
520                                 lastalive = cfs_duration_sec(delta);
521
522                                 /* No need to mess up peers contents with
523                                  * arbitrarily long integers - it suffices to
524                                  * know that lastalive is more than 10000s old
525                                  */
526                                 if (lastalive >= 10000)
527                                         lastalive = 9999;
528                         }
529
530                         lnet_net_unlock(cpt);
531
532                         s += snprintf(s, tmpstr + tmpsiz - s,
533                                       "%-24s %4d %5s %5d %5d %5d %5d %5d %5d %d\n",
534                                       libcfs_nid2str(nid), nrefs, aliveness,
535                                       lastalive, maxcr, rtrcr, minrtrcr, txcr,
536                                       mintxcr, txqnob);
537                         LASSERT(tmpstr + tmpsiz - s > 0);
538
539                 } else { /* peer is NULL */
540                         lnet_net_unlock(cpt);
541                 }
542
543                 if (hash == LNET_PEER_HASH_SIZE) {
544                         cpt++;
545                         hash = 0;
546                         hoff = 1;
547                         if (peer == NULL && cpt < LNET_CPT_NUMBER)
548                                 goto again;
549                 }
550         }
551
552         len = s - tmpstr;     /* how many bytes was written */
553
554         if (len > *lenp) {    /* linux-supplied buffer is too small */
555                 rc = -EINVAL;
556         } else if (len > 0) { /* wrote something */
557                 if (copy_to_user(buffer, tmpstr, len))
558                         rc = -EFAULT;
559                 else
560                         *ppos = LNET_PROC_POS_MAKE(cpt, ver, hash, hoff);
561         }
562
563         LIBCFS_FREE(tmpstr, tmpsiz);
564
565         if (rc == 0)
566                 *lenp = len;
567
568         return rc;
569 }
570
571 static int __proc_lnet_buffers(void *data, int write,
572                                loff_t pos, void __user *buffer, int nob)
573 {
574         char            *s;
575         char            *tmpstr;
576         int             tmpsiz;
577         int             idx;
578         int             len;
579         int             rc;
580         int             i;
581
582         LASSERT(!write);
583
584         /* (4 %d) * 4 * LNET_CPT_NUMBER */
585         tmpsiz = 64 * (LNET_NRBPOOLS + 1) * LNET_CPT_NUMBER;
586         LIBCFS_ALLOC(tmpstr, tmpsiz);
587         if (tmpstr == NULL)
588                 return -ENOMEM;
589
590         s = tmpstr; /* points to current position in tmpstr[] */
591
592         s += snprintf(s, tmpstr + tmpsiz - s,
593                       "%5s %5s %7s %7s\n",
594                       "pages", "count", "credits", "min");
595         LASSERT(tmpstr + tmpsiz - s > 0);
596
597         if (the_lnet.ln_rtrpools == NULL)
598                 goto out; /* I'm not a router */
599
600         for (idx = 0; idx < LNET_NRBPOOLS; idx++) {
601                 lnet_rtrbufpool_t *rbp;
602
603                 lnet_net_lock(LNET_LOCK_EX);
604                 cfs_percpt_for_each(rbp, i, the_lnet.ln_rtrpools) {
605                         s += snprintf(s, tmpstr + tmpsiz - s,
606                                       "%5d %5d %7d %7d\n",
607                                       rbp[idx].rbp_npages,
608                                       rbp[idx].rbp_nbuffers,
609                                       rbp[idx].rbp_credits,
610                                       rbp[idx].rbp_mincredits);
611                         LASSERT(tmpstr + tmpsiz - s > 0);
612                 }
613                 lnet_net_unlock(LNET_LOCK_EX);
614         }
615
616  out:
617         len = s - tmpstr;
618
619         if (pos >= min_t(int, len, strlen(tmpstr)))
620                 rc = 0;
621         else
622                 rc = cfs_trace_copyout_string(buffer, nob,
623                                               tmpstr + pos, NULL);
624
625         LIBCFS_FREE(tmpstr, tmpsiz);
626         return rc;
627 }
628
629 static int
630 proc_lnet_buffers(struct ctl_table *table, int write, void __user *buffer,
631                   size_t *lenp, loff_t *ppos)
632 {
633         return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
634                                     __proc_lnet_buffers);
635 }
636
637 static int
638 proc_lnet_nis(struct ctl_table *table, int write, void __user *buffer,
639               size_t *lenp, loff_t *ppos)
640 {
641         int     tmpsiz = 128 * LNET_CPT_NUMBER;
642         int        rc = 0;
643         char      *tmpstr;
644         char      *s;
645         int        len;
646
647         LASSERT(!write);
648
649         if (*lenp == 0)
650                 return 0;
651
652         LIBCFS_ALLOC(tmpstr, tmpsiz);
653         if (tmpstr == NULL)
654                 return -ENOMEM;
655
656         s = tmpstr; /* points to current position in tmpstr[] */
657
658         if (*ppos == 0) {
659                 s += snprintf(s, tmpstr + tmpsiz - s,
660                               "%-24s %6s %5s %4s %4s %4s %5s %5s %5s\n",
661                               "nid", "status", "alive", "refs", "peer",
662                               "rtr", "max", "tx", "min");
663                 LASSERT (tmpstr + tmpsiz - s > 0);
664         } else {
665                 lnet_ni_t         *ni   = NULL;
666                 int                skip = *ppos - 1;
667
668                 lnet_net_lock(0);
669
670                 ni = lnet_get_ni_idx_locked(skip);
671
672                 if (ni != NULL) {
673                         struct lnet_tx_queue    *tq;
674                         char    *stat;
675                         time64_t now = ktime_get_real_seconds();
676                         int     last_alive = -1;
677                         int     i;
678                         int     j;
679
680                         if (the_lnet.ln_routing)
681                                 last_alive = now - ni->ni_last_alive;
682
683                         /* @lo forever alive */
684                         if (ni->ni_net->net_lnd->lnd_type == LOLND)
685                                 last_alive = 0;
686
687                         lnet_ni_lock(ni);
688                         LASSERT(ni->ni_status != NULL);
689                         stat = (ni->ni_status->ns_status ==
690                                 LNET_NI_STATUS_UP) ? "up" : "down";
691                         lnet_ni_unlock(ni);
692
693                         /* we actually output credits information for
694                          * TX queue of each partition */
695                         cfs_percpt_for_each(tq, i, ni->ni_tx_queues) {
696                                 for (j = 0; ni->ni_cpts != NULL &&
697                                      j < ni->ni_ncpts; j++) {
698                                         if (i == ni->ni_cpts[j])
699                                                 break;
700                                 }
701
702                                 if (j == ni->ni_ncpts)
703                                         continue;
704
705                                 if (i != 0)
706                                         lnet_net_lock(i);
707
708                                 s += snprintf(s, tmpstr + tmpsiz - s,
709                                       "%-24s %6s %5d %4d %4d %4d %5d %5d %5d\n",
710                                       libcfs_nid2str(ni->ni_nid), stat,
711                                       last_alive, *ni->ni_refs[i],
712                                       ni->ni_net->net_tunables.lct_peer_tx_credits,
713                                       ni->ni_net->net_tunables.lct_peer_rtr_credits,
714                                       tq->tq_credits_max,
715                                       tq->tq_credits, tq->tq_credits_min);
716                                 if (i != 0)
717                                         lnet_net_unlock(i);
718                         }
719                         LASSERT(tmpstr + tmpsiz - s > 0);
720                 }
721
722                 lnet_net_unlock(0);
723         }
724
725         len = s - tmpstr;     /* how many bytes was written */
726
727         if (len > *lenp) {    /* linux-supplied buffer is too small */
728                 rc = -EINVAL;
729         } else if (len > 0) { /* wrote something */
730                 if (copy_to_user(buffer, tmpstr, len))
731                         rc = -EFAULT;
732                 else
733                         *ppos += 1;
734         }
735
736         LIBCFS_FREE(tmpstr, tmpsiz);
737
738         if (rc == 0)
739                 *lenp = len;
740
741         return rc;
742 }
743
744 struct lnet_portal_rotors {
745         int             pr_value;
746         const char      *pr_name;
747         const char      *pr_desc;
748 };
749
750 static struct lnet_portal_rotors        portal_rotors[] = {
751         {
752                 .pr_value = LNET_PTL_ROTOR_OFF,
753                 .pr_name  = "OFF",
754                 .pr_desc  = "Turn off message rotor for wildcard portals"
755         },
756         {
757                 .pr_value = LNET_PTL_ROTOR_ON,
758                 .pr_name  = "ON",
759                 .pr_desc  = "round-robin dispatch all PUT messages for "
760                             "wildcard portals"
761         },
762         {
763                 .pr_value = LNET_PTL_ROTOR_RR_RT,
764                 .pr_name  = "RR_RT",
765                 .pr_desc  = "round-robin dispatch routed PUT message for "
766                             "wildcard portals"
767         },
768         {
769                 .pr_value = LNET_PTL_ROTOR_HASH_RT,
770                 .pr_name  = "HASH_RT",
771                 .pr_desc  = "dispatch routed PUT message by hashing source "
772                             "NID for wildcard portals"
773         },
774         {
775                 .pr_value = -1,
776                 .pr_name  = NULL,
777                 .pr_desc  = NULL
778         },
779 };
780
781 static int __proc_lnet_portal_rotor(void *data, int write,
782                                     loff_t pos, void __user *buffer, int nob)
783 {
784         const int       buf_len = 128;
785         char            *buf;
786         char            *tmp;
787         int             rc;
788         int             i;
789
790         LIBCFS_ALLOC(buf, buf_len);
791         if (buf == NULL)
792                 return -ENOMEM;
793
794         if (!write) {
795                 lnet_res_lock(0);
796
797                 for (i = 0; portal_rotors[i].pr_value >= 0; i++) {
798                         if (portal_rotors[i].pr_value == portal_rotor)
799                                 break;
800                 }
801
802                 LASSERT(portal_rotors[i].pr_value == portal_rotor);
803                 lnet_res_unlock(0);
804
805                 rc = snprintf(buf, buf_len,
806                               "{\n\tportals: all\n"
807                               "\trotor: %s\n\tdescription: %s\n}",
808                               portal_rotors[i].pr_name,
809                               portal_rotors[i].pr_desc);
810
811                 if (pos >= min_t(int, rc, buf_len)) {
812                         rc = 0;
813                 } else {
814                         rc = cfs_trace_copyout_string(buffer, nob,
815                                         buf + pos, "\n");
816                 }
817                 goto out;
818         }
819
820         rc = cfs_trace_copyin_string(buf, buf_len, buffer, nob);
821         if (rc < 0)
822                 goto out;
823
824         tmp = cfs_trimwhite(buf);
825
826         rc = -EINVAL;
827         lnet_res_lock(0);
828         for (i = 0; portal_rotors[i].pr_name != NULL; i++) {
829                 if (strncasecmp(portal_rotors[i].pr_name, tmp,
830                                 strlen(portal_rotors[i].pr_name)) == 0) {
831                         portal_rotor = portal_rotors[i].pr_value;
832                         rc = 0;
833                         break;
834                 }
835         }
836         lnet_res_unlock(0);
837 out:
838         LIBCFS_FREE(buf, buf_len);
839         return rc;
840 }
841
842 static int
843 proc_lnet_portal_rotor(struct ctl_table *table, int write, void __user *buffer,
844                        size_t *lenp, loff_t *ppos)
845 {
846         return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
847                                     __proc_lnet_portal_rotor);
848 }
849
850
851 static struct ctl_table lnet_table[] = {
852         /*
853          * NB No .strategy entries have been provided since sysctl(8) prefers
854          * to go via /proc for portability.
855          */
856         {
857                 INIT_CTL_NAME
858                 .procname       = "stats",
859                 .mode           = 0644,
860                 .proc_handler   = &proc_lnet_stats,
861         },
862         {
863                 INIT_CTL_NAME
864                 .procname       = "routes",
865                 .mode           = 0444,
866                 .proc_handler   = &proc_lnet_routes,
867         },
868         {
869                 INIT_CTL_NAME
870                 .procname       = "routers",
871                 .mode           = 0444,
872                 .proc_handler   = &proc_lnet_routers,
873         },
874         {
875                 INIT_CTL_NAME
876                 .procname       = "peers",
877                 .mode           = 0444,
878                 .proc_handler   = &proc_lnet_peers,
879         },
880         {
881                 INIT_CTL_NAME
882                 .procname       = "buffers",
883                 .mode           = 0444,
884                 .proc_handler   = &proc_lnet_buffers,
885         },
886         {
887                 INIT_CTL_NAME
888                 .procname       = "nis",
889                 .mode           = 0444,
890                 .proc_handler   = &proc_lnet_nis,
891         },
892         {
893                 INIT_CTL_NAME
894                 .procname       = "portal_rotor",
895                 .mode           = 0644,
896                 .proc_handler   = &proc_lnet_portal_rotor,
897         },
898         { 0 }
899 };
900
901 static struct ctl_table top_table[] = {
902         {
903                 INIT_CTL_NAME
904                 .procname       = "lnet",
905                 .mode           = 0555,
906                 .data           = NULL,
907                 .maxlen         = 0,
908                 .child          = lnet_table,
909         },
910         { 0 }
911 };
912
913 void
914 lnet_proc_init(void)
915 {
916 #ifdef CONFIG_SYSCTL
917         if (lnet_table_header == NULL)
918                 lnet_table_header = register_sysctl_table(top_table);
919 #endif
920 }
921
922 void
923 lnet_proc_fini(void)
924 {
925 #ifdef CONFIG_SYSCTL
926         if (lnet_table_header != NULL)
927                 unregister_sysctl_table(lnet_table_header);
928
929         lnet_table_header = NULL;
930 #endif
931 }