Whamcloud - gitweb
LU-5435 lnet: LNet drop rule implementation
[fs/lustre-release.git] / lnet / utils / portals.c
1 /*
2  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
3  *
4  *   This file is part of Portals, http://www.sf.net/projects/lustre/
5  *
6  *   Portals is free software; you can redistribute it and/or
7  *   modify it under the terms of version 2 of the GNU General Public
8  *   License as published by the Free Software Foundation.
9  *
10  *   Portals is distributed in the hope that it will be useful,
11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *   GNU General Public License for more details.
14  *
15  *   You should have received a copy of the GNU General Public License
16  *   along with Portals; if not, write to the Free Software
17  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  *
19  */
20
21 #include <libcfs/libcfsutil.h>
22 #include <lnet/nidstr.h>
23 #include <lnet/lnetctl.h>
24 #include <lnet/socklnd.h>
25 #include <lnet/lib-dlc.h>
26
27 unsigned int libcfs_debug;
28 unsigned int libcfs_printk = D_CANTMASK;
29
30 static int   g_net_set;
31 static __u32 g_net;
32
33 #define IOC_BUF_SIZE    8192
34 static char local_buf[IOC_BUF_SIZE];
35 static char *ioc_buf = local_buf;
36
37 /* Convert a string boolean to an int; "enable" -> 1 */
38 int
39 lnet_parse_bool (int *b, char *str)
40 {
41         if (!strcasecmp (str, "no") ||
42             !strcasecmp (str, "n") ||
43             !strcasecmp (str, "off") ||
44             !strcasecmp (str, "down") ||
45             !strcasecmp (str, "disable"))
46         {
47                 *b = 0;
48                 return (0);
49         }
50
51         if (!strcasecmp (str, "yes") ||
52             !strcasecmp (str, "y") ||
53             !strcasecmp (str, "on") ||
54             !strcasecmp (str, "up") ||
55             !strcasecmp (str, "enable"))
56         {
57                 *b = 1;
58                 return (0);
59         }
60
61         return (-1);
62 }
63
64 int
65 lnet_parse_port (int *port, char *str)
66 {
67         char      *end;
68
69         *port = strtol (str, &end, 0);
70
71         if (*end == 0 &&                        /* parsed whole string */
72             *port > 0 && *port < 65536)         /* minimal sanity check */
73                 return (0);
74
75         return (-1);
76 }
77
78 #ifdef HAVE_GETHOSTBYNAME
79 static struct hostent *
80 ptl_gethostbyname(char * hname) {
81         struct hostent *he;
82         he = gethostbyname(hname);
83         if (!he) {
84                 switch(h_errno) {
85                 case HOST_NOT_FOUND:
86                 case NO_ADDRESS:
87                         fprintf(stderr, "Unable to resolve hostname: %s\n",
88                                 hname);
89                         break;
90                 default:
91                         fprintf(stderr, "gethostbyname error for %s: %s\n",
92                                 hname, strerror(h_errno));
93                         break;
94                 }
95                 return NULL;
96         }
97         return he;
98 }
99 #endif
100
101 int
102 lnet_parse_ipquad (__u32 *ipaddrp, char *str)
103 {
104         int             a;
105         int             b;
106         int             c;
107         int             d;
108
109         if (sscanf (str, "%d.%d.%d.%d", &a, &b, &c, &d) == 4 &&
110             (a & ~0xff) == 0 && (b & ~0xff) == 0 &&
111             (c & ~0xff) == 0 && (d & ~0xff) == 0)
112         {
113                 *ipaddrp = (a<<24)|(b<<16)|(c<<8)|d;
114                 return (0);
115         }
116
117         return (-1);
118 }
119
120 int
121 lnet_parse_ipaddr (__u32 *ipaddrp, char *str)
122 {
123 #ifdef HAVE_GETHOSTBYNAME
124         struct hostent *he;
125 #endif
126
127         if (!strcmp (str, "_all_")) {
128                 *ipaddrp = 0;
129                 return (0);
130         }
131
132         if (lnet_parse_ipquad(ipaddrp, str) == 0)
133                 return (0);
134
135 #ifdef HAVE_GETHOSTBYNAME
136         if ((('a' <= str[0] && str[0] <= 'z') ||
137              ('A' <= str[0] && str[0] <= 'Z')) &&
138              (he = ptl_gethostbyname (str)) != NULL) {
139                 __u32 addr = *(__u32 *)he->h_addr;
140
141                 *ipaddrp = ntohl(addr);         /* HOST byte order */
142                 return (0);
143         }
144 #endif
145
146         return (-1);
147 }
148
149 char *
150 ptl_ipaddr_2_str(__u32 ipaddr, char *str, size_t strsize, int lookup)
151 {
152 #ifdef HAVE_GETHOSTBYNAME
153         __u32           net_ip;
154         struct hostent *he;
155
156         if (lookup) {
157                 net_ip = htonl (ipaddr);
158                 he = gethostbyaddr (&net_ip, sizeof (net_ip), AF_INET);
159                 if (he != NULL) {
160                         strlcpy(str, he->h_name, strsize);
161                         return (str);
162                 }
163         }
164 #endif
165
166         sprintf (str, "%d.%d.%d.%d",
167                  (ipaddr >> 24) & 0xff, (ipaddr >> 16) & 0xff,
168                  (ipaddr >> 8) & 0xff, ipaddr & 0xff);
169         return (str);
170 }
171
172 int
173 lnet_parse_time (time_t *t, char *str)
174 {
175         char          *end;
176         int            n;
177         struct tm      tm;
178
179         *t = strtol (str, &end, 0);
180         if (*end == 0) /* parsed whole string */
181                 return (0);
182
183         memset (&tm, 0, sizeof (tm));
184         n = sscanf (str, "%d-%d-%d-%d:%d:%d",
185                     &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
186                     &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
187         if (n != 6)
188                 return (-1);
189
190         tm.tm_mon--;                    /* convert to 0 == Jan */
191         tm.tm_year -= 1900;             /* y2k quirk */
192         tm.tm_isdst = -1;               /* dunno if it's daylight savings... */
193
194         *t = mktime (&tm);
195         if (*t == (time_t)-1)
196                 return (-1);
197
198         return (0);
199 }
200
201 int
202 lnet_parse_nid(char *nid_str, lnet_process_id_t *id_ptr)
203 {
204         id_ptr->pid = LNET_PID_ANY;
205         id_ptr->nid = libcfs_str2nid(nid_str);
206         if (id_ptr->nid == LNET_NID_ANY) {
207                 fprintf (stderr, "Can't parse nid \"%s\"\n", nid_str);
208                 return -1;
209         }
210
211         return 0;
212 }
213
214 int g_net_is_set (char *cmd)
215 {
216         if (g_net_set)
217                 return 1;
218
219         if (cmd != NULL)
220                 fprintf(stderr,
221                         "You must run the 'network' command before '%s'.\n",
222                         cmd);
223         return 0;
224 }
225
226 int g_net_is_compatible (char *cmd, ...)
227 {
228         va_list       ap;
229         int           nal;
230
231         if (!g_net_is_set(cmd))
232                 return 0;
233
234         va_start(ap, cmd);
235
236         do {
237                 nal = va_arg (ap, int);
238                 if (nal == LNET_NETTYP(g_net)) {
239                         va_end (ap);
240                         return 1;
241                 }
242         } while (nal != 0);
243
244         va_end (ap);
245
246         if (cmd != NULL)
247                 fprintf (stderr,
248                          "Command %s not compatible with %s NAL\n",
249                          cmd,
250                          libcfs_lnd2str(LNET_NETTYP(g_net)));
251         return 0;
252 }
253
254 int ptl_initialize(int argc, char **argv)
255 {
256         register_ioc_dev(LNET_DEV_ID, LNET_DEV_PATH,
257                          LNET_DEV_MAJOR, LNET_DEV_MINOR);
258         return 0;
259 }
260
261
262 int jt_ptl_network(int argc, char **argv)
263 {
264         struct libcfs_ioctl_data data;
265         __u32                    net = LNET_NIDNET(LNET_NID_ANY);
266         int                      rc;
267
268         if (argc < 2) {
269                 fprintf(stderr, "usage: %s <net>|up|down\n", argv[0]);
270                 return 0;
271         }
272
273         if (!strcmp(argv[1], "unconfigure") ||
274             !strcmp(argv[1], "down")) {
275                 LIBCFS_IOC_INIT(data);
276                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_UNCONFIGURE, &data);
277
278                 if (rc == 0) {
279                         printf ("LNET ready to unload\n");
280                         return 0;
281                 }
282
283                 if (errno == EBUSY)
284                         fprintf(stderr, "LNET busy\n");
285                 else
286                         fprintf(stderr, "LNET unconfigure error %d: %s\n",
287                                 errno, strerror(errno));
288                 return -1;
289         }
290
291         if (!strcmp(argv[1], "configure") ||
292             !strcmp(argv[1], "up")) {
293                 LIBCFS_IOC_INIT(data);
294                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_CONFIGURE, &data);
295
296                 if (rc == 0) {
297                         printf ("LNET configured\n");
298                         return 0;
299                 }
300
301                 fprintf(stderr, "LNET configure error %d: %s\n",
302                         errno, strerror(errno));
303                 return -1;
304         }
305
306         net = libcfs_str2net(argv[1]);
307         if (net == LNET_NIDNET(LNET_NID_ANY)) {
308                 fprintf(stderr, "Can't parse net %s\n", argv[1]);
309                 return -1;
310         }
311
312         if (LNET_NETTYP(net) == CIBLND    ||
313             LNET_NETTYP(net) == OPENIBLND ||
314             LNET_NETTYP(net) == IIBLND    ||
315             LNET_NETTYP(net) == VIBLND) {
316                 fprintf(stderr, "Net %s obsoleted\n", libcfs_lnd2str(net));
317                 return -1;
318         }
319
320         g_net_set = 1;
321         g_net = net;
322         return 0;
323 }
324
325 int
326 jt_ptl_list_nids(int argc, char **argv)
327 {
328         struct libcfs_ioctl_data data;
329         int                      all = 0, return_nid = 0;
330         int                      count;
331         int                      rc;
332
333         all = (argc == 2) && (strcmp(argv[1], "all") == 0);
334         /* Hack to pass back value */
335         return_nid = (argc == 2) && (argv[1][0] == 1);
336
337         if ((argc > 2) && !(all || return_nid)) {
338                 fprintf(stderr, "usage: %s [all]\n", argv[0]);
339                 return 0;
340         }
341
342         for (count = 0;; count++) {
343                 LIBCFS_IOC_INIT (data);
344                 data.ioc_count = count;
345                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_NI, &data);
346
347                 if (rc < 0) {
348                         if ((count > 0) && (errno == ENOENT))
349                                 /* We found them all */
350                                 break;
351                         fprintf(stderr,"IOC_LIBCFS_GET_NI error %d: %s\n",
352                                 errno, strerror(errno));
353                         return -1;
354                 }
355
356                 if (all || (LNET_NETTYP(LNET_NIDNET(data.ioc_nid)) != LOLND)) {
357                         printf("%s\n", libcfs_nid2str(data.ioc_nid));
358                         if (return_nid) {
359                                 *(__u64 *)(argv[1]) = data.ioc_nid;
360                                 return_nid--;
361                         }
362                 }
363         }
364
365         return 0;
366 }
367
368 int
369 jt_ptl_which_nid (int argc, char **argv)
370 {
371         struct libcfs_ioctl_data data;
372         int          best_dist = 0;
373         int          best_order = 0;
374         lnet_nid_t   best_nid = LNET_NID_ANY;
375         int          dist;
376         int          order;
377         lnet_nid_t   nid;
378         char        *nidstr;
379         int          rc;
380         int          i;
381
382         if (argc < 2) {
383                 fprintf(stderr, "usage: %s NID [NID...]\n", argv[0]);
384                 return 0;
385         }
386
387         for (i = 1; i < argc; i++) {
388                 nidstr = argv[i];
389                 nid = libcfs_str2nid(nidstr);
390                 if (nid == LNET_NID_ANY) {
391                         fprintf(stderr, "Can't parse NID %s\n", nidstr);
392                         return -1;
393                 }
394
395                 LIBCFS_IOC_INIT(data);
396                 data.ioc_nid = nid;
397
398                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_LNET_DIST, &data);
399                 if (rc != 0) {
400                         fprintf(stderr, "Can't get distance to %s: %s\n",
401                                 nidstr, strerror(errno));
402                         return -1;
403                 }
404
405                 dist = data.ioc_u32[0];
406                 order = data.ioc_u32[1];
407
408                 if (dist < 0) {
409                         if (dist == -EHOSTUNREACH)
410                                 continue;
411
412                         fprintf(stderr, "Unexpected distance to %s: %d\n",
413                                 nidstr, dist);
414                         return -1;
415                 }
416
417                 if (best_nid == LNET_NID_ANY ||
418                     dist < best_dist ||
419                     (dist == best_dist && order < best_order)) {
420                         best_dist = dist;
421                         best_order = order;
422                         best_nid = nid;
423                 }
424         }
425
426         if (best_nid == LNET_NID_ANY) {
427                 fprintf(stderr, "No reachable NID\n");
428                 return -1;
429         }
430
431         printf("%s\n", libcfs_nid2str(best_nid));
432         return 0;
433 }
434
435 int
436 jt_ptl_print_interfaces (int argc, char **argv)
437 {
438         struct libcfs_ioctl_data data;
439         char                     buffer[3][HOST_NAME_MAX + 1];
440         int                      index;
441         int                      rc;
442
443         if (!g_net_is_compatible (argv[0], SOCKLND, 0))
444                 return -1;
445
446         for (index = 0;;index++) {
447                 LIBCFS_IOC_INIT(data);
448                 data.ioc_net   = g_net;
449                 data.ioc_count = index;
450
451                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_INTERFACE, &data);
452                 if (rc != 0)
453                         break;
454
455                 printf ("%s: (%s/%s) npeer %d nroute %d\n",
456                         ptl_ipaddr_2_str(data.ioc_u32[0], buffer[2],
457                                          sizeof(buffer[2]), 1),
458                         ptl_ipaddr_2_str(data.ioc_u32[0], buffer[0],
459                                          sizeof(buffer[0]), 0),
460                         ptl_ipaddr_2_str(data.ioc_u32[1], buffer[1],
461                                          sizeof(buffer[1]), 0),
462                         data.ioc_u32[2], data.ioc_u32[3]);
463         }
464
465         if (index == 0) {
466                 if (errno == ENOENT) {
467                         printf ("<no interfaces>\n");
468                 } else {
469                         fprintf(stderr, "Error getting interfaces: %s: "
470                                 "check dmesg.\n",
471                                 strerror(errno));
472                 }
473         }
474
475         return 0;
476 }
477
478 int
479 jt_ptl_add_interface (int argc, char **argv)
480 {
481         struct libcfs_ioctl_data data;
482         __u32                    ipaddr;
483         int                      rc;
484         __u32                    netmask = 0xffffff00;
485         int                      i;
486         int                      count;
487         char                    *end;
488
489         if (argc < 2 || argc > 3) {
490                 fprintf (stderr, "usage: %s ipaddr [netmask]\n", argv[0]);
491                 return 0;
492         }
493
494         if (!g_net_is_compatible(argv[0], SOCKLND, 0))
495                 return -1;
496
497         if (lnet_parse_ipaddr(&ipaddr, argv[1]) != 0) {
498                 fprintf (stderr, "Can't parse ip: %s\n", argv[1]);
499                 return -1;
500         }
501
502         if (argc > 2 ) {
503                 count = strtol(argv[2], &end, 0);
504                 if (count > 0 && count < 32 && *end == 0) {
505                         netmask = 0;
506                         for (i = count; i > 0; i--)
507                                 netmask = netmask|(1<<(32-i));
508                 } else if (lnet_parse_ipquad(&netmask, argv[2]) != 0) {
509                         fprintf (stderr, "Can't parse netmask: %s\n", argv[2]);
510                         return -1;
511                 }
512         }
513
514         LIBCFS_IOC_INIT(data);
515         data.ioc_net    = g_net;
516         data.ioc_u32[0] = ipaddr;
517         data.ioc_u32[1] = netmask;
518
519         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_ADD_INTERFACE, &data);
520         if (rc != 0) {
521                 fprintf (stderr, "failed to add interface: %s\n",
522                          strerror (errno));
523                 return -1;
524         }
525
526         return 0;
527 }
528
529 int
530 jt_ptl_del_interface (int argc, char **argv)
531 {
532         struct libcfs_ioctl_data data;
533         int                      rc;
534         __u32                    ipaddr = 0;
535
536         if (argc > 2) {
537                 fprintf (stderr, "usage: %s [ipaddr]\n", argv[0]);
538                 return 0;
539         }
540
541         if (!g_net_is_compatible(argv[0], SOCKLND, 0))
542                 return -1;
543
544         if (argc == 2 &&
545             lnet_parse_ipaddr(&ipaddr, argv[1]) != 0) {
546                 fprintf (stderr, "Can't parse ip: %s\n", argv[1]);
547                 return -1;
548         }
549
550         LIBCFS_IOC_INIT(data);
551         data.ioc_net    = g_net;
552         data.ioc_u32[0] = ipaddr;
553
554         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_DEL_INTERFACE, &data);
555         if (rc != 0) {
556                 fprintf (stderr, "failed to delete interface: %s\n",
557                          strerror (errno));
558                 return -1;
559         }
560
561         return 0;
562 }
563
564 int
565 jt_ptl_print_peers (int argc, char **argv)
566 {
567         struct libcfs_ioctl_data data;
568         lnet_process_id_t        id;
569         char                     buffer[2][HOST_NAME_MAX + 1];
570         int                      index;
571         int                      rc;
572
573         if (!g_net_is_compatible (argv[0], SOCKLND, RALND, MXLND,
574                                   O2IBLND, GNILND, 0))
575                 return -1;
576
577         for (index = 0;;index++) {
578                 LIBCFS_IOC_INIT(data);
579                 data.ioc_net     = g_net;
580                 data.ioc_count   = index;
581
582                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_PEER, &data);
583                 if (rc != 0)
584                         break;
585
586                 if (g_net_is_compatible(NULL, SOCKLND, 0)) {
587                         id.nid = data.ioc_nid;
588                         id.pid = data.ioc_u32[4];
589                         printf ("%-20s [%d]%s->%s:%d #%d\n",
590                                 libcfs_id2str(id), 
591                                 data.ioc_count, /* persistence */
592                                 /* my ip */
593                                 ptl_ipaddr_2_str(data.ioc_u32[2], buffer[0],
594                                                  sizeof(buffer[0]), 1),
595                                 /* peer ip */
596                                 ptl_ipaddr_2_str(data.ioc_u32[0], buffer[1],
597                                                  sizeof(buffer[1]), 1),
598                                 data.ioc_u32[1], /* peer port */
599                                 data.ioc_u32[3]); /* conn_count */
600                 } else if (g_net_is_compatible(NULL, RALND, 0)) {
601                         printf ("%-20s [%d]@%s:%d\n",
602                                 libcfs_nid2str(data.ioc_nid), /* peer nid */
603                                 data.ioc_count,   /* peer persistence */
604                                 /* peer ip */
605                                 ptl_ipaddr_2_str(data.ioc_u32[0], buffer[1],
606                                                  sizeof(buffer[1]), 1),
607                                 data.ioc_u32[1]); /* peer port */
608                 } else if (g_net_is_compatible(NULL, GNILND, 0)) {
609                         int disconn = data.ioc_flags >> 16;
610                         char *state;
611
612                         if (disconn)
613                                 state = "D";
614                         else
615                                 state = data.ioc_flags & 0xffff ? "C" : "U";
616
617                         printf ("%-20s (%d) %s [%d] "LPU64" "
618                                 "sq %d/%d tx %d/%d/%d\n",
619                                 libcfs_nid2str(data.ioc_nid), /* peer nid */
620                                 data.ioc_net, /* gemini device id */
621                                 state, /* peer is Connecting, Up, or Down */
622                                 data.ioc_count,   /* peer refcount */
623                                 data.ioc_u64[0], /* peerstamp */
624                                 data.ioc_u32[2], data.ioc_u32[3], /* tx and rx seq */
625                                 /* fmaq, nfma, nrdma */
626                                 data.ioc_u32[0], data.ioc_u32[1], data.ioc_u32[4]
627                                 );
628                 } else {
629                         printf ("%-20s [%d]\n",
630                                 libcfs_nid2str(data.ioc_nid), data.ioc_count);
631                 }
632         }
633
634         if (index == 0) {
635                 if (errno == ENOENT) {
636                         printf ("<no peers>\n");
637                 } else {
638                         fprintf(stderr, "Error getting peer list: %s: "
639                                 "check dmesg.\n",
640                                 strerror(errno));
641                 }
642         }
643         return 0;
644 }
645
646 int
647 jt_ptl_add_peer (int argc, char **argv)
648 {
649         struct libcfs_ioctl_data data;
650         lnet_nid_t               nid;
651         __u32                    ip = 0;
652         int                      port = 0;
653         int                      rc;
654
655         if (!g_net_is_compatible (argv[0], SOCKLND, RALND,
656                                   GNILND, 0))
657                 return -1;
658
659         if (argc != 4) {
660                 fprintf (stderr, "usage(tcp,ra,gni): %s nid ipaddr port\n",
661                          argv[0]);
662                 return 0;
663         }
664
665         nid = libcfs_str2nid(argv[1]);
666         if (nid == LNET_NID_ANY) {
667                 fprintf (stderr, "Can't parse NID: %s\n", argv[1]);
668                 return -1;
669         }
670
671         if (lnet_parse_ipaddr (&ip, argv[2]) != 0) {
672                 fprintf (stderr, "Can't parse ip addr: %s\n", argv[2]);
673                 return -1;
674         }
675
676         if (lnet_parse_port (&port, argv[3]) != 0) {
677                 fprintf (stderr, "Can't parse port: %s\n", argv[3]);
678                 return -1;
679         }
680
681         LIBCFS_IOC_INIT(data);
682         data.ioc_net    = g_net;
683         data.ioc_nid    = nid;
684         data.ioc_u32[0] = ip;
685         data.ioc_u32[1] = port;
686
687         rc = l_ioctl (LNET_DEV_ID, IOC_LIBCFS_ADD_PEER, &data);
688         if (rc != 0) {
689                 fprintf (stderr, "failed to add peer: %s\n",
690                          strerror (errno));
691                 return -1;
692         }
693
694         return 0;
695 }
696
697 int
698 jt_ptl_del_peer (int argc, char **argv)
699 {
700         struct libcfs_ioctl_data data;
701         lnet_nid_t               nid = LNET_NID_ANY;
702         lnet_pid_t               pid = LNET_PID_ANY;
703         __u32                    ip = 0;
704         int                      rc;
705
706         if (!g_net_is_compatible (argv[0], SOCKLND, RALND, MXLND,
707                                   O2IBLND, GNILND, 0))
708                 return -1;
709
710         if (g_net_is_compatible(NULL, SOCKLND, 0)) {
711                 if (argc > 3) {
712                         fprintf (stderr, "usage: %s [nid] [ipaddr]\n",
713                                  argv[0]);
714                         return 0;
715                 }
716         } else if (argc > 2) {
717                 fprintf (stderr, "usage: %s [nid]\n", argv[0]);
718                 return 0;
719         }
720
721         if (argc > 1 &&
722             !libcfs_str2anynid(&nid, argv[1])) {
723                 fprintf (stderr, "Can't parse nid: %s\n", argv[1]);
724                 return -1;
725         }
726
727         if (g_net_is_compatible(NULL, SOCKLND, 0)) {
728                 if (argc > 2 &&
729                     lnet_parse_ipaddr (&ip, argv[2]) != 0) {
730                         fprintf (stderr, "Can't parse ip addr: %s\n",
731                                  argv[2]);
732                         return -1;
733                 }
734         }
735
736         LIBCFS_IOC_INIT(data);
737         data.ioc_net    = g_net;
738         data.ioc_nid    = nid;
739         data.ioc_u32[0] = ip;
740         data.ioc_u32[1] = pid;
741
742         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_DEL_PEER, &data);
743         if (rc != 0) {
744                 fprintf (stderr, "failed to remove peer: %s\n",
745                          strerror (errno));
746                 return -1;
747         }
748
749         return 0;
750 }
751
752 int
753 jt_ptl_print_connections (int argc, char **argv)
754 {
755         struct libcfs_ioctl_data data;
756         lnet_process_id_t        id;
757         char                     buffer[2][HOST_NAME_MAX + 1];
758         int                      index;
759         int                      rc;
760
761         if (!g_net_is_compatible (argv[0], SOCKLND, RALND, MXLND, O2IBLND,
762                                   GNILND, 0))
763                 return -1;
764
765         for (index = 0; ; index++) {
766                 LIBCFS_IOC_INIT(data);
767                 data.ioc_net     = g_net;
768                 data.ioc_count   = index;
769
770                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_CONN, &data);
771                 if (rc != 0)
772                         break;
773
774                 if (g_net_is_compatible (NULL, SOCKLND, 0)) {
775                         id.nid = data.ioc_nid;
776                         id.pid = data.ioc_u32[6];
777                         printf ("%-20s %s[%d]%s->%s:%d %d/%d %s\n",
778                                 libcfs_id2str(id),
779                                 (data.ioc_u32[3] == SOCKLND_CONN_ANY) ? "A" :
780                                 (data.ioc_u32[3] == SOCKLND_CONN_CONTROL) ? "C" :
781                                 (data.ioc_u32[3] == SOCKLND_CONN_BULK_IN) ? "I" :
782                                 (data.ioc_u32[3] == SOCKLND_CONN_BULK_OUT) ? "O" : "?",
783                                 data.ioc_u32[4], /* scheduler */
784                                 /* local IP addr */
785                                 ptl_ipaddr_2_str(data.ioc_u32[2], buffer[0],
786                                                  sizeof(buffer[0]), 1),
787                                 /* remote IP addr */
788                                 ptl_ipaddr_2_str(data.ioc_u32[0], buffer[1],
789                                                  sizeof(buffer[1]), 1),
790                                 data.ioc_u32[1],         /* remote port */
791                                 data.ioc_count, /* tx buffer size */
792                                 data.ioc_u32[5], /* rx buffer size */
793                                 data.ioc_flags ? "nagle" : "nonagle");
794                 } else if (g_net_is_compatible (NULL, RALND, 0)) {
795                         printf ("%-20s [%d]\n",
796                                 libcfs_nid2str(data.ioc_nid),
797                                 data.ioc_u32[0] /* device id */);
798                 } else if (g_net_is_compatible (NULL, O2IBLND, 0)) {
799                         printf ("%s mtu %d\n",
800                                 libcfs_nid2str(data.ioc_nid),
801                                 data.ioc_u32[0]); /* path MTU */
802                 } else if (g_net_is_compatible (NULL, GNILND, 0)) {
803                         printf ("%-20s [%d]\n",
804                                 libcfs_nid2str(data.ioc_nid),
805                                 data.ioc_u32[0] /* device id */);
806                 } else {
807                         printf ("%s\n", libcfs_nid2str(data.ioc_nid));
808                 }
809         }
810
811         if (index == 0) {
812                 if (errno == ENOENT) {
813                         printf ("<no connections>\n");
814                 } else {
815                         fprintf(stderr, "Error getting connection list: %s: "
816                                 "check dmesg.\n",
817                                 strerror(errno));
818                 }
819         }
820         return 0;
821 }
822
823 int jt_ptl_disconnect(int argc, char **argv)
824 {
825         struct libcfs_ioctl_data data;
826         lnet_nid_t               nid = LNET_NID_ANY;
827         __u32                    ipaddr = 0;
828         int                      rc;
829
830         if (argc > 3) {
831                 fprintf(stderr, "usage: %s [nid] [ipaddr]\n", argv[0]);
832                 return 0;
833         }
834
835         if (!g_net_is_compatible (NULL, SOCKLND, RALND, MXLND, O2IBLND,
836                                   GNILND, 0))
837                 return 0;
838
839         if (argc >= 2 &&
840             !libcfs_str2anynid(&nid, argv[1])) {
841                 fprintf (stderr, "Can't parse nid %s\n", argv[1]);
842                 return -1;
843         }
844
845         if (g_net_is_compatible (NULL, SOCKLND, 0) &&
846             argc >= 3 &&
847             lnet_parse_ipaddr (&ipaddr, argv[2]) != 0) {
848                 fprintf (stderr, "Can't parse ip addr %s\n", argv[2]);
849                 return -1;
850         }
851
852         LIBCFS_IOC_INIT(data);
853         data.ioc_net     = g_net;
854         data.ioc_nid     = nid;
855         data.ioc_u32[0]  = ipaddr;
856
857         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_CLOSE_CONNECTION, &data);
858         if (rc != 0) {
859                 fprintf(stderr, "failed to remove connection: %s\n",
860                         strerror(errno));
861                 return -1;
862         }
863
864         return 0;
865 }
866
867 int jt_ptl_push_connection (int argc, char **argv)
868 {
869         struct libcfs_ioctl_data data;
870         int                      rc;
871         lnet_nid_t               nid = LNET_NID_ANY;
872
873         if (argc > 2) {
874                 fprintf(stderr, "usage: %s [nid]\n", argv[0]);
875                 return 0;
876         }
877
878         if (!g_net_is_compatible (argv[0], SOCKLND, GNILND, 0))
879                 return -1;
880
881         if (argc > 1 &&
882             !libcfs_str2anynid(&nid, argv[1])) {
883                 fprintf(stderr, "Can't parse nid: %s\n", argv[1]);
884                 return -1;
885         }
886
887         LIBCFS_IOC_INIT(data);
888         data.ioc_net     = g_net;
889         data.ioc_nid     = nid;
890
891         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_PUSH_CONNECTION, &data);
892         if (rc != 0) {
893                 fprintf(stderr, "failed to push connection: %s\n",
894                         strerror(errno));
895                 return -1;
896         }
897
898         return 0;
899 }
900
901 int
902 jt_ptl_print_active_txs (int argc, char **argv)
903 {
904         struct libcfs_ioctl_data data;
905         int                      index;
906         int                      rc;
907
908         if (!g_net_is_compatible (argv[0], QSWLND, 0))
909                 return -1;
910
911         for (index = 0;;index++) {
912                 LIBCFS_IOC_INIT(data);
913                 data.ioc_net   = g_net;
914                 data.ioc_count = index;
915
916                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_TXDESC, &data);
917                 if (rc != 0)
918                         break;
919
920                 printf ("type %u payload %6d to %s via %s by pid %6d: "
921                         "%s, %s, state %d\n",
922                         data.ioc_u32[0],
923                         data.ioc_count,
924                         libcfs_nid2str(data.ioc_nid),
925                         libcfs_nid2str(data.ioc_u64[0]),
926                         data.ioc_u32[1],
927                         (data.ioc_flags & 1) ? "delayed" : "immediate",
928                         (data.ioc_flags & 2) ? "nblk"    : "normal",
929                         data.ioc_flags >> 2);
930         }
931
932         if (index == 0) {
933                 if (errno == ENOENT) {
934                         printf ("<no active descs>\n");
935                 } else {
936                         fprintf(stderr, "Error getting active transmits list: "
937                                 "%s: check dmesg.\n",
938                                 strerror(errno));
939                 }
940         }
941         return 0;
942 }
943
944 int jt_ptl_ping(int argc, char **argv)
945 {
946         int                      rc;
947         int                      timeout;
948         lnet_process_id_t        id;
949         lnet_process_id_t        ids[16];
950         int                      maxids = sizeof(ids)/sizeof(ids[0]);
951         struct libcfs_ioctl_data data;
952         char                    *sep;
953         int                      i;
954
955         if (argc < 2) {
956                 fprintf(stderr, "usage: %s id [timeout (secs)]\n", argv[0]);
957                 return 0;
958         }
959
960         sep = strchr(argv[1], '-');
961         if (sep == NULL) {
962                 rc = lnet_parse_nid(argv[1], &id);
963                 if (rc != 0)
964                         return -1;
965         } else {
966                 char   *end;
967
968                 if (argv[1][0] == 'u' ||
969                     argv[1][0] == 'U')
970                         id.pid = strtoul(&argv[1][1], &end, 0) | LNET_PID_USERFLAG;
971                 else
972                         id.pid = strtoul(argv[1], &end, 0);
973
974                 if (end != sep) { /* assuming '-' is part of hostname */
975                         rc = lnet_parse_nid(argv[1], &id);
976                         if (rc != 0)
977                                 return -1;
978                 } else {
979                         id.nid = libcfs_str2nid(sep + 1);
980
981                         if (id.nid == LNET_NID_ANY) {
982                                 fprintf(stderr,
983                                         "Can't parse process id \"%s\"\n",
984                                         argv[1]);
985                                 return -1;
986                         }
987                 }
988         }
989
990         if (argc > 2)
991                 timeout = 1000 * atol(argv[2]);
992         else
993                 timeout = 1000;                 /* default 1 second timeout */
994
995         LIBCFS_IOC_INIT (data);
996         data.ioc_nid     = id.nid;
997         data.ioc_u32[0]  = id.pid;
998         data.ioc_u32[1]  = timeout;
999         data.ioc_plen1   = sizeof(ids);
1000         data.ioc_pbuf1   = (char *)ids;
1001
1002         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_PING, &data);
1003         if (rc != 0) {
1004                 fprintf(stderr, "failed to ping %s: %s\n",
1005                         id.pid == LNET_PID_ANY ?
1006                         libcfs_nid2str(id.nid) : libcfs_id2str(id),
1007                         strerror(errno));
1008                 return -1;
1009         }
1010
1011         for (i = 0; i < data.ioc_count && i < maxids; i++)
1012                 printf("%s\n", libcfs_id2str(ids[i]));
1013
1014         if (data.ioc_count > maxids)
1015                 printf("%d out of %d ids listed\n", maxids, data.ioc_count);
1016
1017         return 0;
1018 }
1019
1020 int jt_ptl_mynid(int argc, char **argv)
1021 {
1022         struct libcfs_ioctl_data data;
1023         lnet_nid_t               nid;
1024         int rc;
1025
1026         if (argc != 2) {
1027                 fprintf(stderr, "usage: %s NID\n", argv[0]);
1028                 return 0;
1029         }
1030
1031         nid = libcfs_str2nid(argv[1]);
1032         if (nid == LNET_NID_ANY) {
1033                 fprintf(stderr, "Can't parse NID '%s'\n", argv[1]);
1034                 return -1;
1035         }
1036
1037         LIBCFS_IOC_INIT(data);
1038         data.ioc_net = LNET_NIDNET(nid);
1039         data.ioc_nid = nid;
1040
1041         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_REGISTER_MYNID, &data);
1042         if (rc < 0)
1043                 fprintf(stderr, "setting my NID failed: %s\n",
1044                        strerror(errno));
1045         else
1046                 printf("registered my nid %s\n", libcfs_nid2str(nid));
1047
1048         return 0;
1049 }
1050
1051 int
1052 jt_ptl_fail_nid (int argc, char **argv)
1053 {
1054         int                      rc;
1055         lnet_nid_t               nid;
1056         int                      threshold;
1057         struct libcfs_ioctl_data data;
1058
1059         if (argc < 2 || argc > 3)
1060         {
1061                 fprintf (stderr, "usage: %s nid|\"*\" [count (0 == mend)]\n", argv[0]);
1062                 return (0);
1063         }
1064
1065         if (!libcfs_str2anynid(&nid, argv[1]))
1066         {
1067                 fprintf (stderr, "Can't parse nid \"%s\"\n", argv[1]);
1068                 return (-1);
1069         }
1070
1071         if (argc < 3) {
1072                 threshold = LNET_MD_THRESH_INF;
1073         } else if (sscanf(argv[2], "%i", &threshold) != 1) {
1074                 fprintf (stderr, "Can't parse count \"%s\"\n", argv[2]);
1075                 return (-1);
1076         }
1077
1078         LIBCFS_IOC_INIT (data);
1079         data.ioc_nid = nid;
1080         data.ioc_count = threshold;
1081
1082         rc = l_ioctl (LNET_DEV_ID, IOC_LIBCFS_FAIL_NID, &data);
1083         if (rc < 0)
1084                 fprintf (stderr, "IOC_LIBCFS_FAIL_NID failed: %s\n",
1085                          strerror (errno));
1086         else
1087                 printf ("%s %s\n", threshold == 0 ? "Unfailing" : "Failing", argv[1]);
1088
1089         return (0);
1090 }
1091
1092 int
1093 jt_ptl_add_route (int argc, char **argv)
1094 {
1095         struct lnet_ioctl_config_data data;
1096         lnet_nid_t               gateway_nid;
1097         unsigned int             hops = 1;
1098         unsigned int             priority = 0;
1099         char                    *end;
1100         int                      rc;
1101
1102         if (argc < 2 || argc > 4) {
1103                 fprintf(stderr, "usage: %s gateway [hopcount [priority]]\n",
1104                         argv[0]);
1105                 return -1;
1106         }
1107
1108         if (g_net_is_set(argv[0]) == 0)
1109                 return -1;
1110
1111         gateway_nid = libcfs_str2nid(argv[1]);
1112         if (gateway_nid == LNET_NID_ANY) {
1113                 fprintf(stderr, "Can't parse gateway NID \"%s\"\n", argv[1]);
1114                 return -1;
1115         }
1116
1117         if (argc > 2) {
1118                 hops = strtoul(argv[2], &end, 0);
1119                 if (hops == 0 || hops >= 256 || (end != NULL && *end != 0)) {
1120                         fprintf(stderr, "Can't parse hopcount \"%s\"\n",
1121                                 argv[2]);
1122                         return -1;
1123                 }
1124                 if (argc == 4) {
1125                         priority = strtoul(argv[3], &end, 0);
1126                         if (end != NULL && *end != 0) {
1127                                 fprintf(stderr,
1128                                         "Can't parse priority \"%s\"\n",
1129                                         argv[3]);
1130                                 return -1;
1131                         }
1132                 }
1133         }
1134
1135         LIBCFS_IOC_INIT_V2(data, cfg_hdr);
1136         data.cfg_net = g_net;
1137         data.cfg_config_u.cfg_route.rtr_hop = hops;
1138         data.cfg_nid = gateway_nid;
1139         data.cfg_config_u.cfg_route.rtr_priority = priority;
1140
1141         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_ADD_ROUTE, &data);
1142         if (rc != 0) {
1143                 fprintf(stderr, "IOC_LIBCFS_ADD_ROUTE failed: %s\n",
1144                         strerror(errno));
1145                 return -1;
1146         }
1147
1148         return 0;
1149 }
1150
1151 int
1152 jt_ptl_del_route (int argc, char **argv)
1153 {
1154         struct lnet_ioctl_config_data data;
1155         lnet_nid_t               nid;
1156         int                      rc;
1157
1158         if (argc != 2) {
1159                 fprintf(stderr, "usage: %s gatewayNID\n", argv[0]);
1160                 return 0;
1161         }
1162
1163         if (libcfs_str2anynid(&nid, argv[1]) == 0) {
1164                 fprintf(stderr, "Can't parse gateway NID "
1165                         "\"%s\"\n", argv[1]);
1166                 return -1;
1167         }
1168
1169         LIBCFS_IOC_INIT_V2(data, cfg_hdr);
1170         data.cfg_net = g_net_set ? g_net : LNET_NIDNET(LNET_NID_ANY);
1171         data.cfg_nid = nid;
1172
1173         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_DEL_ROUTE, &data);
1174         if (rc != 0) {
1175                 fprintf(stderr, "IOC_LIBCFS_DEL_ROUTE (%s) failed: %s\n",
1176                         libcfs_nid2str(nid), strerror(errno));
1177                 return -1;
1178         }
1179
1180         return 0;
1181 }
1182
1183 int
1184 jt_ptl_notify_router (int argc, char **argv)
1185 {
1186         struct libcfs_ioctl_data data;
1187         int                      enable;
1188         lnet_nid_t               nid;
1189         int                      rc;
1190         struct timeval           now;
1191         time_t                   when;
1192
1193         if (argc < 3)
1194         {
1195                 fprintf (stderr, "usage: %s targetNID <up/down> [<time>]\n", 
1196                          argv[0]);
1197                 return (0);
1198         }
1199
1200         nid = libcfs_str2nid(argv[1]);
1201         if (nid == LNET_NID_ANY) {
1202                 fprintf (stderr, "Can't parse target NID \"%s\"\n", argv[1]);
1203                 return (-1);
1204         }
1205
1206         if (lnet_parse_bool (&enable, argv[2]) != 0) {
1207                 fprintf (stderr, "Can't parse boolean %s\n", argv[2]);
1208                 return (-1);
1209         }
1210
1211         gettimeofday(&now, NULL);
1212
1213         if (argc < 4) {
1214                 when = now.tv_sec;
1215         } else if (lnet_parse_time (&when, argv[3]) != 0) {
1216                 fprintf(stderr, "Can't parse time %s\n"
1217                         "Please specify either 'YYYY-MM-DD-HH:MM:SS'\n"
1218                         "or an absolute unix time in seconds\n", argv[3]);
1219                 return (-1);
1220         } else if (when > now.tv_sec) {
1221                 fprintf (stderr, "%s specifies a time in the future\n",
1222                          argv[3]);
1223                 return (-1);
1224         }
1225
1226         LIBCFS_IOC_INIT(data);
1227         data.ioc_nid = nid;
1228         data.ioc_flags = enable;
1229         /* Yeuch; 'cept I need a __u64 on 64 bit machines... */
1230         data.ioc_u64[0] = (__u64)when;
1231
1232         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_NOTIFY_ROUTER, &data);
1233         if (rc != 0) {
1234                 fprintf (stderr, "IOC_LIBCFS_NOTIFY_ROUTER (%s) failed: %s\n",
1235                          libcfs_nid2str(nid), strerror (errno));
1236                 return (-1);
1237         }
1238
1239         return (0);
1240 }
1241
1242 int
1243 jt_ptl_print_routes (int argc, char **argv)
1244 {
1245         struct lnet_ioctl_config_data  data;
1246         int                       rc;
1247         int                       index;
1248         __u32                     net;
1249         lnet_nid_t                nid;
1250         unsigned int              hops;
1251         int                       alive;
1252         unsigned int              pri;
1253
1254         for (index = 0; ; index++) {
1255                 LIBCFS_IOC_INIT_V2(data, cfg_hdr);
1256                 data.cfg_count = index;
1257
1258                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_ROUTE, &data);
1259                 if (rc != 0)
1260                         break;
1261
1262                 net     = data.cfg_net;
1263                 hops    = data.cfg_config_u.cfg_route.rtr_hop;
1264                 nid     = data.cfg_nid;
1265                 alive   = data.cfg_config_u.cfg_route.rtr_flags;
1266                 pri     = data.cfg_config_u.cfg_route.rtr_priority;
1267
1268                 printf("net %18s hops %u gw %32s %s pri %u\n",
1269                        libcfs_net2str(net), hops,
1270                        libcfs_nid2str(nid), alive ? "up" : "down", pri);
1271         }
1272
1273         if (errno != ENOENT)
1274                 fprintf(stderr, "Error getting routes: %s: check dmesg.\n",
1275                         strerror(errno));
1276
1277         return 0;
1278 }
1279
1280 static int
1281 fault_attr_nid_parse(char *str, lnet_nid_t *nid_p)
1282 {
1283         lnet_nid_t nid;
1284         __u32      net;
1285         int        rc = 0;
1286
1287         /* NB: can't support range ipaddress except * and *@net */
1288         if (strlen(str) > 2 && str[0] == '*' && str[1] == '@') {
1289                 net = libcfs_str2net(str + 2);
1290                 if (net == LNET_NIDNET(LNET_NID_ANY))
1291                         goto failed;
1292
1293                 nid = LNET_MKNID(net, LNET_NIDADDR(LNET_NID_ANY));
1294         } else {
1295                 rc = libcfs_str2anynid(&nid, str);
1296                 if (!rc)
1297                         goto failed;
1298         }
1299
1300         *nid_p = nid;
1301         return 0;
1302 failed:
1303         fprintf(stderr, "Invalid NID : %s\n", str);
1304         return -1;
1305 }
1306
1307 static int
1308 fault_attr_msg_parse(char *msg_str, __u32 *mask_p)
1309 {
1310         if (!strcasecmp(msg_str, "put")) {
1311                 *mask_p |= LNET_PUT_BIT;
1312                 return 0;
1313
1314         } else if (!strcasecmp(msg_str, "ack")) {
1315                 *mask_p |= LNET_ACK_BIT;
1316                 return 0;
1317
1318         } else if (!strcasecmp(msg_str, "get")) {
1319                 *mask_p |= LNET_GET_BIT;
1320                 return 0;
1321
1322         } else if (!strcasecmp(msg_str, "reply")) {
1323                 *mask_p |= LNET_REPLY_BIT;
1324                 return 0;
1325         }
1326
1327         fprintf(stderr, "unknown message type %s\n", msg_str);
1328         return -1;
1329 }
1330
1331 static int
1332 fault_attr_ptl_parse(char *ptl_str, __u64 *mask_p)
1333 {
1334         unsigned long rc = strtoul(optarg, NULL, 0);
1335
1336         if (rc >= 64) {
1337                 fprintf(stderr, "invalid portal: %lu\n", rc);
1338                 return -1;
1339         }
1340
1341         *mask_p |= (1ULL << rc);
1342         return 0;
1343 }
1344
1345 static int
1346 fault_simul_rule_add(__u32 opc, char *name, int argc, char **argv)
1347 {
1348         struct libcfs_ioctl_data  data = {{0}};
1349         struct lnet_fault_attr    attr;
1350         char                     *optstr;
1351         int                       rc;
1352
1353         static struct option opts[] = {
1354                 {"source",      required_argument,      0,      's'},
1355                 {"dest",        required_argument,      0,      'd'},
1356                 {"rate",        required_argument,      0,      'r'},
1357                 {"interval",    required_argument,      0,      'i'},
1358                 {"portal",      required_argument,      0,      'p'},
1359                 {"message",     required_argument,      0,      'm'},
1360                 {0, 0, 0, 0}
1361         };
1362
1363         if (argc == 1) {
1364                 fprintf(stderr, "Failed, please provide source, destination "
1365                                 "and rate of rule\n");
1366                 return -1;
1367         }
1368
1369         optstr = "s:d:r:i:p:m:";
1370         memset(&attr, 0, sizeof(attr));
1371         while (1) {
1372                 char c = getopt_long(argc, argv, optstr, opts, NULL);
1373
1374                 if (c == -1)
1375                         break;
1376
1377                 switch (c) {
1378                 case 's': /* source NID/NET */
1379                         rc = fault_attr_nid_parse(optarg, &attr.fa_src);
1380                         if (rc != 0)
1381                                 goto getopt_failed;
1382                         break;
1383
1384                 case 'd': /* dest NID/NET */
1385                         rc = fault_attr_nid_parse(optarg, &attr.fa_dst);
1386                         if (rc != 0)
1387                                 goto getopt_failed;
1388                         break;
1389
1390                 case 'r': /* drop rate */
1391                         attr.u.drop.da_rate = strtoul(optarg, NULL, 0);
1392                         break;
1393
1394                 case 'i': /* time interval (# seconds) for message drop */
1395                         attr.u.drop.da_interval = strtoul(optarg, NULL, 0);
1396                         break;
1397
1398                 case 'p': /* portal to filter */
1399                         rc = fault_attr_ptl_parse(optarg, &attr.fa_ptl_mask);
1400                         if (rc != 0)
1401                                 goto getopt_failed;
1402                         break;
1403
1404                 case 'm': /* message types to filter */
1405                         rc = fault_attr_msg_parse(optarg, &attr.fa_msg_mask);
1406                         if (rc != 0)
1407                                 goto getopt_failed;
1408                         break;
1409
1410                 default:
1411                         fprintf(stderr, "error: %s: option '%s' "
1412                                 "unrecognized\n", argv[0], argv[optind - 1]);
1413                         goto getopt_failed;
1414                 }
1415         }
1416         optind = 1;
1417
1418         if ((attr.u.drop.da_rate == 0) == (attr.u.drop.da_interval == 0)) {
1419                 fprintf(stderr, "please provide drop rate or interval\n");
1420                 return -1;
1421         }
1422
1423         if (attr.fa_src == 0 || attr.fa_dst == 0) {
1424                 fprintf(stderr, "Please provide both source and destination "
1425                                 "of %s rule\n", name);
1426                 return -1;
1427         }
1428
1429         data.ioc_flags = opc;
1430         data.ioc_inllen1 = sizeof(attr);
1431         data.ioc_inlbuf1 = (char *)&attr;
1432         if (libcfs_ioctl_pack(&data, &ioc_buf, IOC_BUF_SIZE) != 0) {
1433                 fprintf(stderr, "libcfs_ioctl_pack failed\n");
1434                 return -1;
1435         }
1436
1437         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_LNET_FAULT, ioc_buf);
1438         if (rc != 0) {
1439                 fprintf(stderr, "add %s rule %s->%s failed: %s\n",
1440                         name, libcfs_nid2str(attr.fa_src),
1441                         libcfs_nid2str(attr.fa_dst), strerror(errno));
1442                 return -1;
1443         }
1444
1445         printf("Added %s rule %s->%s (1/%d)\n",
1446                name, libcfs_nid2str(attr.fa_src),
1447                libcfs_nid2str(attr.fa_dst), attr.u.drop.da_rate);
1448         return 0;
1449
1450 getopt_failed:
1451         optind = 1;
1452         return -1;
1453 }
1454
1455 int
1456 jt_ptl_drop_add(int argc, char **argv)
1457 {
1458         return fault_simul_rule_add(LNET_CTL_DROP_ADD, "drop", argc, argv);
1459 }
1460
1461 static int
1462 fault_simul_rule_del(__u32 opc, char *name, int argc, char **argv)
1463 {
1464         struct libcfs_ioctl_data data = {{0}};
1465         struct lnet_fault_attr   attr;
1466         bool                     all = false;
1467         int                      rc;
1468
1469         static struct option opts[] = {
1470                 {"source",      required_argument,      0,      's'},
1471                 {"dest",        required_argument,      0,      'd'},
1472                 {"all",         no_argument,            0,      'a'},
1473                 {0, 0, 0, 0}
1474         };
1475
1476         if (argc == 1) {
1477                 fprintf(stderr, "Failed, please provide source and "
1478                                 "destination of rule\n");
1479                 return -1;
1480         }
1481
1482         memset(&attr, 0, sizeof(attr));
1483         while (1) {
1484                 char c = getopt_long(argc, argv, "s:d:a", opts, NULL);
1485
1486                 if (c == -1 || all)
1487                         break;
1488
1489                 switch (c) {
1490                 case 's':
1491                         rc = fault_attr_nid_parse(optarg, &attr.fa_src);
1492                         if (rc != 0)
1493                                 goto getopt_failed;
1494                         break;
1495                 case 'd':
1496                         rc = fault_attr_nid_parse(optarg, &attr.fa_dst);
1497                         if (rc != 0)
1498                                 goto getopt_failed;
1499                         break;
1500                 case 'a':
1501                         attr.fa_src = attr.fa_dst = 0;
1502                         all = true;
1503                         break;
1504                 default:
1505                         fprintf(stderr, "error: %s: option '%s' "
1506                                 "unrecognized\n", argv[0], argv[optind - 1]);
1507                         goto getopt_failed;
1508                 }
1509         }
1510         optind = 1;
1511
1512         data.ioc_flags = opc;
1513         data.ioc_inllen1 = sizeof(attr);
1514         data.ioc_inlbuf1 = (char *)&attr;
1515         if (libcfs_ioctl_pack(&data, &ioc_buf, IOC_BUF_SIZE) != 0) {
1516                 fprintf(stderr, "libcfs_ioctl_pack failed\n");
1517                 return -1;
1518         }
1519
1520         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_LNET_FAULT, ioc_buf);
1521         if (rc != 0) {
1522                 fprintf(stderr, "remove %s rule %s->%s failed: %s\n", name,
1523                         all ? "all" : libcfs_nid2str(attr.fa_src),
1524                         all ? "all" : libcfs_nid2str(attr.fa_dst),
1525                         strerror(errno));
1526                 return -1;
1527         }
1528
1529         libcfs_ioctl_unpack(&data, ioc_buf);
1530         printf("Removed %d %s rules\n", data.ioc_count, name);
1531         return 0;
1532
1533 getopt_failed:
1534         optind = 1;
1535         return -1;
1536 }
1537
1538 int
1539 jt_ptl_drop_del(int argc, char **argv)
1540 {
1541         return fault_simul_rule_del(LNET_CTL_DROP_DEL, "drop", argc, argv);
1542 }
1543
1544 static int
1545 fault_simul_rule_reset(__u32 opc, char *name, int argc, char **argv)
1546 {
1547         struct libcfs_ioctl_data   data = {{0}};
1548         int                        rc;
1549
1550         LIBCFS_IOC_INIT(data);
1551         data.ioc_flags = opc;
1552
1553         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_LNET_FAULT, &data);
1554         if (rc != 0) {
1555                 fprintf(stderr, "failed to reset %s stats: %s\n",
1556                         name, strerror(errno));
1557                 return -1;
1558         }
1559         return 0;
1560 }
1561
1562 int
1563 jt_ptl_drop_reset(int argc, char **argv)
1564 {
1565         return fault_simul_rule_reset(LNET_CTL_DROP_RESET, "drop", argc, argv);
1566 }
1567
1568 static int
1569 fault_simul_rule_list(__u32 opc, char *name, int argc, char **argv)
1570 {
1571         struct libcfs_ioctl_data data = {{0}};
1572         struct lnet_fault_attr   attr;
1573         struct lnet_fault_stat   stat;
1574         int                      pos;
1575
1576         printf("LNet %s rules:\n", name);
1577         for (pos = 0;; pos++) {
1578                 int             rc;
1579
1580                 memset(&attr, 0, sizeof(attr));
1581                 memset(&stat, 0, sizeof(stat));
1582
1583                 data.ioc_count = pos;
1584                 data.ioc_flags = opc;
1585                 data.ioc_inllen1 = sizeof(attr);
1586                 data.ioc_inlbuf1 = (char *)&attr;
1587                 data.ioc_inllen2 = sizeof(stat);
1588                 data.ioc_inlbuf2 = (char *)&stat;
1589                 if (libcfs_ioctl_pack(&data, &ioc_buf, IOC_BUF_SIZE) != 0) {
1590                         fprintf(stderr, "libcfs_ioctl_pack failed\n");
1591                         return -1;
1592                 }
1593
1594                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_LNET_FAULT, ioc_buf);
1595                 if (rc != 0)
1596                         break;
1597
1598                 libcfs_ioctl_unpack(&data, ioc_buf);
1599
1600                 if (opc == LNET_CTL_DROP_LIST) {
1601                         printf("%s->%s (1/%d | %d) ptl "LPX64", msg %x, "
1602                                LPU64"/"LPU64", PUT "LPU64", ACK "LPU64", GET "
1603                                LPU64", REP "LPU64"\n",
1604                                libcfs_nid2str(attr.fa_src),
1605                                libcfs_nid2str(attr.fa_dst),
1606                                attr.u.drop.da_rate, attr.u.drop.da_interval,
1607                                attr.fa_ptl_mask, attr.fa_msg_mask,
1608                                stat.u.drop.ds_dropped, stat.fs_count,
1609                                stat.fs_put, stat.fs_ack,
1610                                stat.fs_get, stat.fs_reply);
1611                 }
1612         }
1613         printf("found total %d\n", pos);
1614
1615         return 0;
1616 }
1617
1618 int
1619 jt_ptl_drop_list(int argc, char **argv)
1620 {
1621         return fault_simul_rule_list(LNET_CTL_DROP_LIST, "drop", argc, argv);
1622 }
1623
1624 double
1625 get_cycles_per_usec ()
1626 {
1627         FILE      *f = fopen ("/proc/cpuinfo", "r");
1628         double     mhz;
1629         char      line[64];
1630
1631         if (f != NULL) {
1632                 while (fgets (line, sizeof (line), f) != NULL)
1633                         if (sscanf (line, "cpu MHz : %lf", &mhz) == 1) {
1634                                 fclose (f);
1635                                 return (mhz);
1636                         }
1637                 fclose (f);
1638         }
1639
1640         fprintf (stderr, "Can't read/parse /proc/cpuinfo\n");
1641         return (1000.0);
1642 }
1643
1644 int jt_ptl_memhog(int argc, char **argv)
1645 {
1646         static int                gfp = 0;        /* sticky! */
1647
1648         struct libcfs_ioctl_data  data;
1649         int                       rc;
1650         int                       count;
1651         char                     *end;
1652
1653         if (argc < 2)  {
1654                 fprintf(stderr, "usage: %s <npages> [<GFP flags>]\n", argv[0]);
1655                 return 0;
1656         }
1657
1658         count = strtol(argv[1], &end, 0);
1659         if (count < 0 || *end != 0) {
1660                 fprintf(stderr, "Can't parse page count '%s'\n", argv[1]);
1661                 return -1;
1662         }
1663
1664         if (argc >= 3) {
1665                 rc = strtol(argv[2], &end, 0);
1666                 if (*end != 0) {
1667                         fprintf(stderr, "Can't parse gfp flags '%s'\n", argv[2]);
1668                         return -1;
1669                 }
1670                 gfp = rc;
1671         }
1672
1673         LIBCFS_IOC_INIT(data);
1674         data.ioc_count = count;
1675         data.ioc_flags = gfp;
1676         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_MEMHOG, &data);
1677
1678         if (rc != 0) {
1679                 fprintf(stderr, "memhog %d failed: %s\n", count, strerror(errno));
1680                 return -1;
1681         }
1682
1683         printf("memhog %d OK\n", count);
1684         return 0;
1685 }
1686
1687 int jt_ptl_testprotocompat(int argc, char **argv)
1688 {
1689         struct libcfs_ioctl_data  data;
1690         int                       rc;
1691         int                       flags;
1692         char                     *end;
1693
1694         if (argc < 2)  {
1695                 fprintf(stderr, "usage: %s <number>\n", argv[0]);
1696                 return 0;
1697         }
1698
1699         flags = strtol(argv[1], &end, 0);
1700         if (flags < 0 || *end != 0) {
1701                 fprintf(stderr, "Can't parse flags '%s'\n", argv[1]);
1702                 return -1;
1703         }
1704
1705         LIBCFS_IOC_INIT(data);
1706         data.ioc_flags = flags;
1707         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_TESTPROTOCOMPAT, &data);
1708
1709         if (rc != 0) {
1710                 fprintf(stderr, "test proto compat %x failed: %s\n",
1711                         flags, strerror(errno));
1712                 return -1;
1713         }
1714
1715         printf("test proto compat %x OK\n", flags);
1716         return 0;
1717 }
1718
1719