Whamcloud - gitweb
LU-6142 lnet: remove most of typedefs from LNet headers
[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         struct lnet_counters *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                 struct lnet_route               *route = NULL;
181                 struct lnet_remotenet   *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, struct lnet_remotenet,
202                                                   lrn_list);
203
204                                 r = rnet->lrn_routes.next;
205
206                                 while (r != &rnet->lrn_routes) {
207                                         struct lnet_route *re =
208                                                 list_entry(r, struct lnet_route,
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 %4d %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                         struct lnet_route *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) ?
505                           peer->lpni_net->net_tunables.lct_peer_tx_credits : 0;
506                         int txcr = peer->lpni_txcredits;
507                         int mintxcr = peer->lpni_mintxcredits;
508                         int rtrcr = peer->lpni_rtrcredits;
509                         int minrtrcr = peer->lpni_minrtrcredits;
510                         int txqnob = peer->lpni_txqnob;
511
512                         if (lnet_isrouter(peer) ||
513                             lnet_peer_aliveness_enabled(peer))
514                                 aliveness = peer->lpni_alive ? "up" : "down";
515
516                         if (lnet_peer_aliveness_enabled(peer)) {
517                                 cfs_time_t now = cfs_time_current();
518                                 cfs_duration_t delta;
519
520                                 delta = cfs_time_sub(now, peer->lpni_last_alive);
521                                 lastalive = cfs_duration_sec(delta);
522
523                                 /* No need to mess up peers contents with
524                                  * arbitrarily long integers - it suffices to
525                                  * know that lastalive is more than 10000s old
526                                  */
527                                 if (lastalive >= 10000)
528                                         lastalive = 9999;
529                         }
530
531                         lnet_net_unlock(cpt);
532
533                         s += snprintf(s, tmpstr + tmpsiz - s,
534                                       "%-24s %4d %5s %5d %5d %5d %5d %5d %5d %d\n",
535                                       libcfs_nid2str(nid), nrefs, aliveness,
536                                       lastalive, maxcr, rtrcr, minrtrcr, txcr,
537                                       mintxcr, txqnob);
538                         LASSERT(tmpstr + tmpsiz - s > 0);
539
540                 } else { /* peer is NULL */
541                         lnet_net_unlock(cpt);
542                 }
543
544                 if (hash == LNET_PEER_HASH_SIZE) {
545                         cpt++;
546                         hash = 0;
547                         hoff = 1;
548                         if (peer == NULL && cpt < LNET_CPT_NUMBER)
549                                 goto again;
550                 }
551         }
552
553         len = s - tmpstr;     /* how many bytes was written */
554
555         if (len > *lenp) {    /* linux-supplied buffer is too small */
556                 rc = -EINVAL;
557         } else if (len > 0) { /* wrote something */
558                 if (copy_to_user(buffer, tmpstr, len))
559                         rc = -EFAULT;
560                 else
561                         *ppos = LNET_PROC_POS_MAKE(cpt, ver, hash, hoff);
562         }
563
564         LIBCFS_FREE(tmpstr, tmpsiz);
565
566         if (rc == 0)
567                 *lenp = len;
568
569         return rc;
570 }
571
572 static int __proc_lnet_buffers(void *data, int write,
573                                loff_t pos, void __user *buffer, int nob)
574 {
575         char            *s;
576         char            *tmpstr;
577         int             tmpsiz;
578         int             idx;
579         int             len;
580         int             rc;
581         int             i;
582
583         LASSERT(!write);
584
585         /* (4 %d) * 4 * LNET_CPT_NUMBER */
586         tmpsiz = 64 * (LNET_NRBPOOLS + 1) * LNET_CPT_NUMBER;
587         LIBCFS_ALLOC(tmpstr, tmpsiz);
588         if (tmpstr == NULL)
589                 return -ENOMEM;
590
591         s = tmpstr; /* points to current position in tmpstr[] */
592
593         s += snprintf(s, tmpstr + tmpsiz - s,
594                       "%5s %5s %7s %7s\n",
595                       "pages", "count", "credits", "min");
596         LASSERT(tmpstr + tmpsiz - s > 0);
597
598         if (the_lnet.ln_rtrpools == NULL)
599                 goto out; /* I'm not a router */
600
601         for (idx = 0; idx < LNET_NRBPOOLS; idx++) {
602                 struct lnet_rtrbufpool *rbp;
603
604                 lnet_net_lock(LNET_LOCK_EX);
605                 cfs_percpt_for_each(rbp, i, the_lnet.ln_rtrpools) {
606                         s += snprintf(s, tmpstr + tmpsiz - s,
607                                       "%5d %5d %7d %7d\n",
608                                       rbp[idx].rbp_npages,
609                                       rbp[idx].rbp_nbuffers,
610                                       rbp[idx].rbp_credits,
611                                       rbp[idx].rbp_mincredits);
612                         LASSERT(tmpstr + tmpsiz - s > 0);
613                 }
614                 lnet_net_unlock(LNET_LOCK_EX);
615         }
616
617  out:
618         len = s - tmpstr;
619
620         if (pos >= min_t(int, len, strlen(tmpstr)))
621                 rc = 0;
622         else
623                 rc = cfs_trace_copyout_string(buffer, nob,
624                                               tmpstr + pos, NULL);
625
626         LIBCFS_FREE(tmpstr, tmpsiz);
627         return rc;
628 }
629
630 static int
631 proc_lnet_buffers(struct ctl_table *table, int write, void __user *buffer,
632                   size_t *lenp, loff_t *ppos)
633 {
634         return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
635                                     __proc_lnet_buffers);
636 }
637
638 static int
639 proc_lnet_nis(struct ctl_table *table, int write, void __user *buffer,
640               size_t *lenp, loff_t *ppos)
641 {
642         int     tmpsiz = 128 * LNET_CPT_NUMBER;
643         int        rc = 0;
644         char      *tmpstr;
645         char      *s;
646         int        len;
647
648         LASSERT(!write);
649
650         if (*lenp == 0)
651                 return 0;
652
653         LIBCFS_ALLOC(tmpstr, tmpsiz);
654         if (tmpstr == NULL)
655                 return -ENOMEM;
656
657         s = tmpstr; /* points to current position in tmpstr[] */
658
659         if (*ppos == 0) {
660                 s += snprintf(s, tmpstr + tmpsiz - s,
661                               "%-24s %6s %5s %4s %4s %4s %5s %5s %5s\n",
662                               "nid", "status", "alive", "refs", "peer",
663                               "rtr", "max", "tx", "min");
664                 LASSERT (tmpstr + tmpsiz - s > 0);
665         } else {
666                 struct lnet_ni *ni   = NULL;
667                 int skip = *ppos - 1;
668
669                 lnet_net_lock(0);
670
671                 ni = lnet_get_ni_idx_locked(skip);
672
673                 if (ni != NULL) {
674                         struct lnet_tx_queue    *tq;
675                         char    *stat;
676                         time64_t now = ktime_get_real_seconds();
677                         int     last_alive = -1;
678                         int     i;
679                         int     j;
680
681                         if (the_lnet.ln_routing)
682                                 last_alive = now - ni->ni_last_alive;
683
684                         /* @lo forever alive */
685                         if (ni->ni_net->net_lnd->lnd_type == LOLND)
686                                 last_alive = 0;
687
688                         lnet_ni_lock(ni);
689                         LASSERT(ni->ni_status != NULL);
690                         stat = (ni->ni_status->ns_status ==
691                                 LNET_NI_STATUS_UP) ? "up" : "down";
692                         lnet_ni_unlock(ni);
693
694                         /* we actually output credits information for
695                          * TX queue of each partition */
696                         cfs_percpt_for_each(tq, i, ni->ni_tx_queues) {
697                                 for (j = 0; ni->ni_cpts != NULL &&
698                                      j < ni->ni_ncpts; j++) {
699                                         if (i == ni->ni_cpts[j])
700                                                 break;
701                                 }
702
703                                 if (j == ni->ni_ncpts)
704                                         continue;
705
706                                 if (i != 0)
707                                         lnet_net_lock(i);
708
709                                 s += snprintf(s, tmpstr + tmpsiz - s,
710                                       "%-24s %6s %5d %4d %4d %4d %5d %5d %5d\n",
711                                       libcfs_nid2str(ni->ni_nid), stat,
712                                       last_alive, *ni->ni_refs[i],
713                                       ni->ni_net->net_tunables.lct_peer_tx_credits,
714                                       ni->ni_net->net_tunables.lct_peer_rtr_credits,
715                                       tq->tq_credits_max,
716                                       tq->tq_credits, tq->tq_credits_min);
717                                 if (i != 0)
718                                         lnet_net_unlock(i);
719                         }
720                         LASSERT(tmpstr + tmpsiz - s > 0);
721                 }
722
723                 lnet_net_unlock(0);
724         }
725
726         len = s - tmpstr;     /* how many bytes was written */
727
728         if (len > *lenp) {    /* linux-supplied buffer is too small */
729                 rc = -EINVAL;
730         } else if (len > 0) { /* wrote something */
731                 if (copy_to_user(buffer, tmpstr, len))
732                         rc = -EFAULT;
733                 else
734                         *ppos += 1;
735         }
736
737         LIBCFS_FREE(tmpstr, tmpsiz);
738
739         if (rc == 0)
740                 *lenp = len;
741
742         return rc;
743 }
744
745 struct lnet_portal_rotors {
746         int             pr_value;
747         const char      *pr_name;
748         const char      *pr_desc;
749 };
750
751 static struct lnet_portal_rotors        portal_rotors[] = {
752         {
753                 .pr_value = LNET_PTL_ROTOR_OFF,
754                 .pr_name  = "OFF",
755                 .pr_desc  = "Turn off message rotor for wildcard portals"
756         },
757         {
758                 .pr_value = LNET_PTL_ROTOR_ON,
759                 .pr_name  = "ON",
760                 .pr_desc  = "round-robin dispatch all PUT messages for "
761                             "wildcard portals"
762         },
763         {
764                 .pr_value = LNET_PTL_ROTOR_RR_RT,
765                 .pr_name  = "RR_RT",
766                 .pr_desc  = "round-robin dispatch routed PUT message for "
767                             "wildcard portals"
768         },
769         {
770                 .pr_value = LNET_PTL_ROTOR_HASH_RT,
771                 .pr_name  = "HASH_RT",
772                 .pr_desc  = "dispatch routed PUT message by hashing source "
773                             "NID for wildcard portals"
774         },
775         {
776                 .pr_value = -1,
777                 .pr_name  = NULL,
778                 .pr_desc  = NULL
779         },
780 };
781
782 static int __proc_lnet_portal_rotor(void *data, int write,
783                                     loff_t pos, void __user *buffer, int nob)
784 {
785         const int       buf_len = 128;
786         char            *buf;
787         char            *tmp;
788         int             rc;
789         int             i;
790
791         LIBCFS_ALLOC(buf, buf_len);
792         if (buf == NULL)
793                 return -ENOMEM;
794
795         if (!write) {
796                 lnet_res_lock(0);
797
798                 for (i = 0; portal_rotors[i].pr_value >= 0; i++) {
799                         if (portal_rotors[i].pr_value == portal_rotor)
800                                 break;
801                 }
802
803                 LASSERT(portal_rotors[i].pr_value == portal_rotor);
804                 lnet_res_unlock(0);
805
806                 rc = snprintf(buf, buf_len,
807                               "{\n\tportals: all\n"
808                               "\trotor: %s\n\tdescription: %s\n}",
809                               portal_rotors[i].pr_name,
810                               portal_rotors[i].pr_desc);
811
812                 if (pos >= min_t(int, rc, buf_len)) {
813                         rc = 0;
814                 } else {
815                         rc = cfs_trace_copyout_string(buffer, nob,
816                                         buf + pos, "\n");
817                 }
818                 goto out;
819         }
820
821         rc = cfs_trace_copyin_string(buf, buf_len, buffer, nob);
822         if (rc < 0)
823                 goto out;
824
825         tmp = cfs_trimwhite(buf);
826
827         rc = -EINVAL;
828         lnet_res_lock(0);
829         for (i = 0; portal_rotors[i].pr_name != NULL; i++) {
830                 if (strncasecmp(portal_rotors[i].pr_name, tmp,
831                                 strlen(portal_rotors[i].pr_name)) == 0) {
832                         portal_rotor = portal_rotors[i].pr_value;
833                         rc = 0;
834                         break;
835                 }
836         }
837         lnet_res_unlock(0);
838 out:
839         LIBCFS_FREE(buf, buf_len);
840         return rc;
841 }
842
843 static int
844 proc_lnet_portal_rotor(struct ctl_table *table, int write, void __user *buffer,
845                        size_t *lenp, loff_t *ppos)
846 {
847         return lprocfs_call_handler(table->data, write, ppos, buffer, lenp,
848                                     __proc_lnet_portal_rotor);
849 }
850
851
852 static struct ctl_table lnet_table[] = {
853         /*
854          * NB No .strategy entries have been provided since sysctl(8) prefers
855          * to go via /proc for portability.
856          */
857         {
858                 INIT_CTL_NAME
859                 .procname       = "stats",
860                 .mode           = 0644,
861                 .proc_handler   = &proc_lnet_stats,
862         },
863         {
864                 INIT_CTL_NAME
865                 .procname       = "routes",
866                 .mode           = 0444,
867                 .proc_handler   = &proc_lnet_routes,
868         },
869         {
870                 INIT_CTL_NAME
871                 .procname       = "routers",
872                 .mode           = 0444,
873                 .proc_handler   = &proc_lnet_routers,
874         },
875         {
876                 INIT_CTL_NAME
877                 .procname       = "peers",
878                 .mode           = 0444,
879                 .proc_handler   = &proc_lnet_peers,
880         },
881         {
882                 INIT_CTL_NAME
883                 .procname       = "buffers",
884                 .mode           = 0444,
885                 .proc_handler   = &proc_lnet_buffers,
886         },
887         {
888                 INIT_CTL_NAME
889                 .procname       = "nis",
890                 .mode           = 0444,
891                 .proc_handler   = &proc_lnet_nis,
892         },
893         {
894                 INIT_CTL_NAME
895                 .procname       = "portal_rotor",
896                 .mode           = 0644,
897                 .proc_handler   = &proc_lnet_portal_rotor,
898         },
899         { 0 }
900 };
901
902 static struct ctl_table top_table[] = {
903         {
904                 INIT_CTL_NAME
905                 .procname       = "lnet",
906                 .mode           = 0555,
907                 .data           = NULL,
908                 .maxlen         = 0,
909                 .child          = lnet_table,
910         },
911         { 0 }
912 };
913
914 void
915 lnet_proc_init(void)
916 {
917 #ifdef CONFIG_SYSCTL
918         if (lnet_table_header == NULL)
919                 lnet_table_header = register_sysctl_table(top_table);
920 #endif
921 }
922
923 void
924 lnet_proc_fini(void)
925 {
926 #ifdef CONFIG_SYSCTL
927         if (lnet_table_header != NULL)
928                 unregister_sysctl_table(lnet_table_header);
929
930         lnet_table_header = NULL;
931 #endif
932 }