Whamcloud - gitweb
LU-2785 osc: remove unused obd methods
[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/api-support.h>
23 #include <lnet/lnetctl.h>
24 #include <lnet/socklnd.h>
25
26 unsigned int libcfs_debug;
27 unsigned int libcfs_printk = D_CANTMASK;
28
29 static int   g_net_set;
30 static __u32 g_net;
31
32 /* Convert a string boolean to an int; "enable" -> 1 */
33 int
34 lnet_parse_bool (int *b, char *str)
35 {
36         if (!strcasecmp (str, "no") ||
37             !strcasecmp (str, "n") ||
38             !strcasecmp (str, "off") ||
39             !strcasecmp (str, "down") ||
40             !strcasecmp (str, "disable"))
41         {
42                 *b = 0;
43                 return (0);
44         }
45
46         if (!strcasecmp (str, "yes") ||
47             !strcasecmp (str, "y") ||
48             !strcasecmp (str, "on") ||
49             !strcasecmp (str, "up") ||
50             !strcasecmp (str, "enable"))
51         {
52                 *b = 1;
53                 return (0);
54         }
55
56         return (-1);
57 }
58
59 int
60 lnet_parse_port (int *port, char *str)
61 {
62         char      *end;
63
64         *port = strtol (str, &end, 0);
65
66         if (*end == 0 &&                        /* parsed whole string */
67             *port > 0 && *port < 65536)         /* minimal sanity check */
68                 return (0);
69
70         return (-1);
71 }
72
73 #ifdef HAVE_GETHOSTBYNAME
74 static struct hostent *
75 ptl_gethostbyname(char * hname) {
76         struct hostent *he;
77         he = gethostbyname(hname);
78         if (!he) {
79                 switch(h_errno) {
80                 case HOST_NOT_FOUND:
81                 case NO_ADDRESS:
82                         fprintf(stderr, "Unable to resolve hostname: %s\n",
83                                 hname);
84                         break;
85                 default:
86                         fprintf(stderr, "gethostbyname error for %s: %s\n",
87                                 hname, strerror(h_errno));
88                         break;
89                 }
90                 return NULL;
91         }
92         return he;
93 }
94 #endif
95
96 int
97 lnet_parse_ipquad (__u32 *ipaddrp, char *str)
98 {
99         int             a;
100         int             b;
101         int             c;
102         int             d;
103
104         if (sscanf (str, "%d.%d.%d.%d", &a, &b, &c, &d) == 4 &&
105             (a & ~0xff) == 0 && (b & ~0xff) == 0 &&
106             (c & ~0xff) == 0 && (d & ~0xff) == 0)
107         {
108                 *ipaddrp = (a<<24)|(b<<16)|(c<<8)|d;
109                 return (0);
110         }
111
112         return (-1);
113 }
114
115 int
116 lnet_parse_ipaddr (__u32 *ipaddrp, char *str)
117 {
118 #ifdef HAVE_GETHOSTBYNAME
119         struct hostent *he;
120 #endif
121
122         if (!strcmp (str, "_all_")) {
123                 *ipaddrp = 0;
124                 return (0);
125         }
126
127         if (lnet_parse_ipquad(ipaddrp, str) == 0)
128                 return (0);
129
130 #ifdef HAVE_GETHOSTBYNAME
131         if ((('a' <= str[0] && str[0] <= 'z') ||
132              ('A' <= str[0] && str[0] <= 'Z')) &&
133              (he = ptl_gethostbyname (str)) != NULL) {
134                 __u32 addr = *(__u32 *)he->h_addr;
135
136                 *ipaddrp = ntohl(addr);         /* HOST byte order */
137                 return (0);
138         }
139 #endif
140
141         return (-1);
142 }
143
144 char *
145 ptl_ipaddr_2_str(__u32 ipaddr, char *str, size_t strsize, int lookup)
146 {
147 #ifdef HAVE_GETHOSTBYNAME
148         __u32           net_ip;
149         struct hostent *he;
150
151         if (lookup) {
152                 net_ip = htonl (ipaddr);
153                 he = gethostbyaddr (&net_ip, sizeof (net_ip), AF_INET);
154                 if (he != NULL) {
155                         strncpy(str, he->h_name, strsize - 1);
156                         str[strsize - 1] = '\0';
157                         return (str);
158                 }
159         }
160 #endif
161
162         sprintf (str, "%d.%d.%d.%d",
163                  (ipaddr >> 24) & 0xff, (ipaddr >> 16) & 0xff,
164                  (ipaddr >> 8) & 0xff, ipaddr & 0xff);
165         return (str);
166 }
167
168 int
169 lnet_parse_time (time_t *t, char *str)
170 {
171         char          *end;
172         int            n;
173         struct tm      tm;
174
175         *t = strtol (str, &end, 0);
176         if (*end == 0) /* parsed whole string */
177                 return (0);
178
179         memset (&tm, 0, sizeof (tm));
180         n = sscanf (str, "%d-%d-%d-%d:%d:%d",
181                     &tm.tm_year, &tm.tm_mon, &tm.tm_mday,
182                     &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
183         if (n != 6)
184                 return (-1);
185
186         tm.tm_mon--;                    /* convert to 0 == Jan */
187         tm.tm_year -= 1900;             /* y2k quirk */
188         tm.tm_isdst = -1;               /* dunno if it's daylight savings... */
189
190         *t = mktime (&tm);
191         if (*t == (time_t)-1)
192                 return (-1);
193
194         return (0);
195 }
196
197 int
198 lnet_parse_nid(char *nid_str, lnet_process_id_t *id_ptr)
199 {
200         id_ptr->pid = LNET_PID_ANY;
201         id_ptr->nid = libcfs_str2nid(nid_str);
202         if (id_ptr->nid == LNET_NID_ANY) {
203                 fprintf (stderr, "Can't parse nid \"%s\"\n", nid_str);
204                 return -1;
205         }
206
207         return 0;
208 }
209
210 int g_net_is_set (char *cmd)
211 {
212         if (g_net_set)
213                 return 1;
214
215         if (cmd != NULL)
216                 fprintf(stderr,
217                         "You must run the 'network' command before '%s'.\n",
218                         cmd);
219         return 0;
220 }
221
222 int g_net_is_compatible (char *cmd, ...)
223 {
224         va_list       ap;
225         int           nal;
226
227         if (!g_net_is_set(cmd))
228                 return 0;
229
230         va_start(ap, cmd);
231
232         do {
233                 nal = va_arg (ap, int);
234                 if (nal == LNET_NETTYP(g_net)) {
235                         va_end (ap);
236                         return 1;
237                 }
238         } while (nal != 0);
239
240         va_end (ap);
241
242         if (cmd != NULL)
243                 fprintf (stderr,
244                          "Command %s not compatible with %s NAL\n",
245                          cmd,
246                          libcfs_lnd2str(LNET_NETTYP(g_net)));
247         return 0;
248 }
249
250 int ptl_initialize(int argc, char **argv)
251 {
252         register_ioc_dev(LNET_DEV_ID, LNET_DEV_PATH,
253                          LNET_DEV_MAJOR, LNET_DEV_MINOR);
254         return 0;
255 }
256
257
258 int jt_ptl_network(int argc, char **argv)
259 {
260         struct libcfs_ioctl_data data;
261         __u32                    net = LNET_NIDNET(LNET_NID_ANY);
262         int                      rc;
263
264         if (argc < 2) {
265                 fprintf(stderr, "usage: %s <net>|up|down\n", argv[0]);
266                 return 0;
267         }
268
269         if (!strcmp(argv[1], "unconfigure") ||
270             !strcmp(argv[1], "down")) {
271                 LIBCFS_IOC_INIT(data);
272                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_UNCONFIGURE, &data);
273
274                 if (rc == 0) {
275                         printf ("LNET ready to unload\n");
276                         return 0;
277                 }
278
279                 if (errno == EBUSY)
280                         fprintf(stderr, "LNET busy\n");
281                 else
282                         fprintf(stderr, "LNET unconfigure error %d: %s\n",
283                                 errno, strerror(errno));
284                 return -1;
285         }
286
287         if (!strcmp(argv[1], "configure") ||
288             !strcmp(argv[1], "up")) {
289                 LIBCFS_IOC_INIT(data);
290                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_CONFIGURE, &data);
291
292                 if (rc == 0) {
293                         printf ("LNET configured\n");
294                         return 0;
295                 }
296
297                 fprintf(stderr, "LNET configure error %d: %s\n",
298                         errno, strerror(errno));
299                 return -1;
300         }
301
302         net = libcfs_str2net(argv[1]);
303         if (net == LNET_NIDNET(LNET_NID_ANY)) {
304                 fprintf(stderr, "Can't parse net %s\n", argv[1]);
305                 return -1;
306         }
307
308         if (LNET_NETTYP(net) == CIBLND    ||
309             LNET_NETTYP(net) == OPENIBLND ||
310             LNET_NETTYP(net) == IIBLND    ||
311             LNET_NETTYP(net) == VIBLND) {
312                 fprintf(stderr, "Net %s obsoleted\n", libcfs_lnd2str(net));
313                 return -1;
314         }
315
316         g_net_set = 1;
317         g_net = net;
318         return 0;
319 }
320
321 int
322 jt_ptl_list_nids(int argc, char **argv)
323 {
324         struct libcfs_ioctl_data data;
325         int                      all = 0, return_nid = 0;
326         int                      count;
327         int                      rc;
328
329         all = (argc == 2) && (strcmp(argv[1], "all") == 0);
330         /* Hack to pass back value */
331         return_nid = (argc == 2) && (argv[1][0] == 1);
332
333         if ((argc > 2) && !(all || return_nid)) {
334                 fprintf(stderr, "usage: %s [all]\n", argv[0]);
335                 return 0;
336         }
337
338         for (count = 0;; count++) {
339                 LIBCFS_IOC_INIT (data);
340                 data.ioc_count = count;
341                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_NI, &data);
342
343                 if (rc < 0) {
344                         if ((count > 0) && (errno == ENOENT))
345                                 /* We found them all */
346                                 break;
347                         fprintf(stderr,"IOC_LIBCFS_GET_NI error %d: %s\n",
348                                 errno, strerror(errno));
349                         return -1;
350                 }
351
352                 if (all || (LNET_NETTYP(LNET_NIDNET(data.ioc_nid)) != LOLND)) {
353                         printf("%s\n", libcfs_nid2str(data.ioc_nid));
354                         if (return_nid) {
355                                 *(__u64 *)(argv[1]) = data.ioc_nid;
356                                 return_nid--;
357                         }
358                 }
359         }
360
361         return 0;
362 }
363
364 int
365 jt_ptl_which_nid (int argc, char **argv)
366 {
367         struct libcfs_ioctl_data data;
368         int          best_dist = 0;
369         int          best_order = 0;
370         lnet_nid_t   best_nid = LNET_NID_ANY;
371         int          dist;
372         int          order;
373         lnet_nid_t   nid;
374         char        *nidstr;
375         int          rc;
376         int          i;
377
378         if (argc < 2) {
379                 fprintf(stderr, "usage: %s NID [NID...]\n", argv[0]);
380                 return 0;
381         }
382
383         for (i = 1; i < argc; i++) {
384                 nidstr = argv[i];
385                 nid = libcfs_str2nid(nidstr);
386                 if (nid == LNET_NID_ANY) {
387                         fprintf(stderr, "Can't parse NID %s\n", nidstr);
388                         return -1;
389                 }
390
391                 LIBCFS_IOC_INIT(data);
392                 data.ioc_nid = nid;
393
394                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_LNET_DIST, &data);
395                 if (rc != 0) {
396                         fprintf(stderr, "Can't get distance to %s: %s\n",
397                                 nidstr, strerror(errno));
398                         return -1;
399                 }
400
401                 dist = data.ioc_u32[0];
402                 order = data.ioc_u32[1];
403
404                 if (dist < 0) {
405                         if (dist == -EHOSTUNREACH)
406                                 continue;
407
408                         fprintf(stderr, "Unexpected distance to %s: %d\n",
409                                 nidstr, dist);
410                         return -1;
411                 }
412
413                 if (best_nid == LNET_NID_ANY ||
414                     dist < best_dist ||
415                     (dist == best_dist && order < best_order)) {
416                         best_dist = dist;
417                         best_order = order;
418                         best_nid = nid;
419                 }
420         }
421
422         if (best_nid == LNET_NID_ANY) {
423                 fprintf(stderr, "No reachable NID\n");
424                 return -1;
425         }
426
427         printf("%s\n", libcfs_nid2str(best_nid));
428         return 0;
429 }
430
431 int
432 jt_ptl_print_interfaces (int argc, char **argv)
433 {
434         struct libcfs_ioctl_data data;
435         char                     buffer[3][HOST_NAME_MAX + 1];
436         int                      index;
437         int                      rc;
438
439         if (!g_net_is_compatible (argv[0], SOCKLND, 0))
440                 return -1;
441
442         for (index = 0;;index++) {
443                 LIBCFS_IOC_INIT(data);
444                 data.ioc_net   = g_net;
445                 data.ioc_count = index;
446
447                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_INTERFACE, &data);
448                 if (rc != 0)
449                         break;
450
451                 printf ("%s: (%s/%s) npeer %d nroute %d\n",
452                         ptl_ipaddr_2_str(data.ioc_u32[0], buffer[2],
453                                          sizeof(buffer[2]), 1),
454                         ptl_ipaddr_2_str(data.ioc_u32[0], buffer[0],
455                                          sizeof(buffer[0]), 0),
456                         ptl_ipaddr_2_str(data.ioc_u32[1], buffer[1],
457                                          sizeof(buffer[1]), 0),
458                         data.ioc_u32[2], data.ioc_u32[3]);
459         }
460
461         if (index == 0) {
462                 if (errno == ENOENT) {
463                         printf ("<no interfaces>\n");
464                 } else {
465                         fprintf(stderr, "Error getting interfaces: %s: "
466                                 "check dmesg.\n",
467                                 strerror(errno));
468                 }
469         }
470
471         return 0;
472 }
473
474 int
475 jt_ptl_add_interface (int argc, char **argv)
476 {
477         struct libcfs_ioctl_data data;
478         __u32                    ipaddr;
479         int                      rc;
480         __u32                    netmask = 0xffffff00;
481         int                      i;
482         int                      count;
483         char                    *end;
484
485         if (argc < 2 || argc > 3) {
486                 fprintf (stderr, "usage: %s ipaddr [netmask]\n", argv[0]);
487                 return 0;
488         }
489
490         if (!g_net_is_compatible(argv[0], SOCKLND, 0))
491                 return -1;
492
493         if (lnet_parse_ipaddr(&ipaddr, argv[1]) != 0) {
494                 fprintf (stderr, "Can't parse ip: %s\n", argv[1]);
495                 return -1;
496         }
497
498         if (argc > 2 ) {
499                 count = strtol(argv[2], &end, 0);
500                 if (count > 0 && count < 32 && *end == 0) {
501                         netmask = 0;
502                         for (i = count; i > 0; i--)
503                                 netmask = netmask|(1<<(32-i));
504                 } else if (lnet_parse_ipquad(&netmask, argv[2]) != 0) {
505                         fprintf (stderr, "Can't parse netmask: %s\n", argv[2]);
506                         return -1;
507                 }
508         }
509
510         LIBCFS_IOC_INIT(data);
511         data.ioc_net    = g_net;
512         data.ioc_u32[0] = ipaddr;
513         data.ioc_u32[1] = netmask;
514
515         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_ADD_INTERFACE, &data);
516         if (rc != 0) {
517                 fprintf (stderr, "failed to add interface: %s\n",
518                          strerror (errno));
519                 return -1;
520         }
521
522         return 0;
523 }
524
525 int
526 jt_ptl_del_interface (int argc, char **argv)
527 {
528         struct libcfs_ioctl_data data;
529         int                      rc;
530         __u32                    ipaddr = 0;
531
532         if (argc > 2) {
533                 fprintf (stderr, "usage: %s [ipaddr]\n", argv[0]);
534                 return 0;
535         }
536
537         if (!g_net_is_compatible(argv[0], SOCKLND, 0))
538                 return -1;
539
540         if (argc == 2 &&
541             lnet_parse_ipaddr(&ipaddr, argv[1]) != 0) {
542                 fprintf (stderr, "Can't parse ip: %s\n", argv[1]);
543                 return -1;
544         }
545
546         LIBCFS_IOC_INIT(data);
547         data.ioc_net    = g_net;
548         data.ioc_u32[0] = ipaddr;
549
550         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_DEL_INTERFACE, &data);
551         if (rc != 0) {
552                 fprintf (stderr, "failed to delete interface: %s\n",
553                          strerror (errno));
554                 return -1;
555         }
556
557         return 0;
558 }
559
560 int
561 jt_ptl_print_peers (int argc, char **argv)
562 {
563         struct libcfs_ioctl_data data;
564         lnet_process_id_t        id;
565         char                     buffer[2][HOST_NAME_MAX + 1];
566         int                      index;
567         int                      rc;
568
569         if (!g_net_is_compatible (argv[0], SOCKLND, RALND, MXLND,
570                                   O2IBLND, GNILND, 0))
571                 return -1;
572
573         for (index = 0;;index++) {
574                 LIBCFS_IOC_INIT(data);
575                 data.ioc_net     = g_net;
576                 data.ioc_count   = index;
577
578                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_PEER, &data);
579                 if (rc != 0)
580                         break;
581
582                 if (g_net_is_compatible(NULL, SOCKLND, 0)) {
583                         id.nid = data.ioc_nid;
584                         id.pid = data.ioc_u32[4];
585                         printf ("%-20s [%d]%s->%s:%d #%d\n",
586                                 libcfs_id2str(id), 
587                                 data.ioc_count, /* persistence */
588                                 /* my ip */
589                                 ptl_ipaddr_2_str(data.ioc_u32[2], buffer[0],
590                                                  sizeof(buffer[0]), 1),
591                                 /* peer ip */
592                                 ptl_ipaddr_2_str(data.ioc_u32[0], buffer[1],
593                                                  sizeof(buffer[1]), 1),
594                                 data.ioc_u32[1], /* peer port */
595                                 data.ioc_u32[3]); /* conn_count */
596                 } else if (g_net_is_compatible(NULL, RALND, 0)) {
597                         printf ("%-20s [%d]@%s:%d\n",
598                                 libcfs_nid2str(data.ioc_nid), /* peer nid */
599                                 data.ioc_count,   /* peer persistence */
600                                 /* peer ip */
601                                 ptl_ipaddr_2_str(data.ioc_u32[0], buffer[1],
602                                                  sizeof(buffer[1]), 1),
603                                 data.ioc_u32[1]); /* peer port */
604                 } else if (g_net_is_compatible(NULL, GNILND, 0)) {
605                         int disconn = data.ioc_flags >> 16;
606                         char *state;
607
608                         if (disconn)
609                                 state = "D";
610                         else
611                                 state = data.ioc_flags & 0xffff ? "C" : "U";
612
613                         printf ("%-20s (%d) %s [%d] "LPU64" "
614                                 "sq %d/%d tx %d/%d/%d\n",
615                                 libcfs_nid2str(data.ioc_nid), /* peer nid */
616                                 data.ioc_net, /* gemini device id */
617                                 state, /* peer is Connecting, Up, or Down */
618                                 data.ioc_count,   /* peer refcount */
619                                 data.ioc_u64[0], /* peerstamp */
620                                 data.ioc_u32[2], data.ioc_u32[3], /* tx and rx seq */
621                                 /* fmaq, nfma, nrdma */
622                                 data.ioc_u32[0], data.ioc_u32[1], data.ioc_u32[4]
623                                 );
624                 } else {
625                         printf ("%-20s [%d]\n",
626                                 libcfs_nid2str(data.ioc_nid), data.ioc_count);
627                 }
628         }
629
630         if (index == 0) {
631                 if (errno == ENOENT) {
632                         printf ("<no peers>\n");
633                 } else {
634                         fprintf(stderr, "Error getting peer list: %s: "
635                                 "check dmesg.\n",
636                                 strerror(errno));
637                 }
638         }
639         return 0;
640 }
641
642 int
643 jt_ptl_add_peer (int argc, char **argv)
644 {
645         struct libcfs_ioctl_data data;
646         lnet_nid_t               nid;
647         __u32                    ip = 0;
648         int                      port = 0;
649         int                      rc;
650
651         if (!g_net_is_compatible (argv[0], SOCKLND, RALND,
652                                   GNILND, 0))
653                 return -1;
654
655         if (argc != 4) {
656                 fprintf (stderr, "usage(tcp,ra,gni): %s nid ipaddr port\n",
657                          argv[0]);
658                 return 0;
659         }
660
661         nid = libcfs_str2nid(argv[1]);
662         if (nid == LNET_NID_ANY) {
663                 fprintf (stderr, "Can't parse NID: %s\n", argv[1]);
664                 return -1;
665         }
666
667         if (lnet_parse_ipaddr (&ip, argv[2]) != 0) {
668                 fprintf (stderr, "Can't parse ip addr: %s\n", argv[2]);
669                 return -1;
670         }
671
672         if (lnet_parse_port (&port, argv[3]) != 0) {
673                 fprintf (stderr, "Can't parse port: %s\n", argv[3]);
674                 return -1;
675         }
676
677         LIBCFS_IOC_INIT(data);
678         data.ioc_net    = g_net;
679         data.ioc_nid    = nid;
680         data.ioc_u32[0] = ip;
681         data.ioc_u32[1] = port;
682
683         rc = l_ioctl (LNET_DEV_ID, IOC_LIBCFS_ADD_PEER, &data);
684         if (rc != 0) {
685                 fprintf (stderr, "failed to add peer: %s\n",
686                          strerror (errno));
687                 return -1;
688         }
689
690         return 0;
691 }
692
693 int
694 jt_ptl_del_peer (int argc, char **argv)
695 {
696         struct libcfs_ioctl_data data;
697         lnet_nid_t               nid = LNET_NID_ANY;
698         lnet_pid_t               pid = LNET_PID_ANY;
699         __u32                    ip = 0;
700         int                      rc;
701
702         if (!g_net_is_compatible (argv[0], SOCKLND, RALND, MXLND,
703                                   O2IBLND, GNILND, 0))
704                 return -1;
705
706         if (g_net_is_compatible(NULL, SOCKLND, 0)) {
707                 if (argc > 3) {
708                         fprintf (stderr, "usage: %s [nid] [ipaddr]\n",
709                                  argv[0]);
710                         return 0;
711                 }
712         } else if (argc > 2) {
713                 fprintf (stderr, "usage: %s [nid]\n", argv[0]);
714                 return 0;
715         }
716
717         if (argc > 1 &&
718             !libcfs_str2anynid(&nid, argv[1])) {
719                 fprintf (stderr, "Can't parse nid: %s\n", argv[1]);
720                 return -1;
721         }
722
723         if (g_net_is_compatible(NULL, SOCKLND, 0)) {
724                 if (argc > 2 &&
725                     lnet_parse_ipaddr (&ip, argv[2]) != 0) {
726                         fprintf (stderr, "Can't parse ip addr: %s\n",
727                                  argv[2]);
728                         return -1;
729                 }
730         }
731
732         LIBCFS_IOC_INIT(data);
733         data.ioc_net    = g_net;
734         data.ioc_nid    = nid;
735         data.ioc_u32[0] = ip;
736         data.ioc_u32[1] = pid;
737
738         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_DEL_PEER, &data);
739         if (rc != 0) {
740                 fprintf (stderr, "failed to remove peer: %s\n",
741                          strerror (errno));
742                 return -1;
743         }
744
745         return 0;
746 }
747
748 int
749 jt_ptl_print_connections (int argc, char **argv)
750 {
751         struct libcfs_ioctl_data data;
752         lnet_process_id_t        id;
753         char                     buffer[2][HOST_NAME_MAX + 1];
754         int                      index;
755         int                      rc;
756
757         if (!g_net_is_compatible (argv[0], SOCKLND, RALND, MXLND, O2IBLND,
758                                   GNILND, 0))
759                 return -1;
760
761         for (index = 0; ; index++) {
762                 LIBCFS_IOC_INIT(data);
763                 data.ioc_net     = g_net;
764                 data.ioc_count   = index;
765
766                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_CONN, &data);
767                 if (rc != 0)
768                         break;
769
770                 if (g_net_is_compatible (NULL, SOCKLND, 0)) {
771                         id.nid = data.ioc_nid;
772                         id.pid = data.ioc_u32[6];
773                         printf ("%-20s %s[%d]%s->%s:%d %d/%d %s\n",
774                                 libcfs_id2str(id),
775                                 (data.ioc_u32[3] == SOCKLND_CONN_ANY) ? "A" :
776                                 (data.ioc_u32[3] == SOCKLND_CONN_CONTROL) ? "C" :
777                                 (data.ioc_u32[3] == SOCKLND_CONN_BULK_IN) ? "I" :
778                                 (data.ioc_u32[3] == SOCKLND_CONN_BULK_OUT) ? "O" : "?",
779                                 data.ioc_u32[4], /* scheduler */
780                                 /* local IP addr */
781                                 ptl_ipaddr_2_str(data.ioc_u32[2], buffer[0],
782                                                  sizeof(buffer[0]), 1),
783                                 /* remote IP addr */
784                                 ptl_ipaddr_2_str(data.ioc_u32[0], buffer[1],
785                                                  sizeof(buffer[1]), 1),
786                                 data.ioc_u32[1],         /* remote port */
787                                 data.ioc_count, /* tx buffer size */
788                                 data.ioc_u32[5], /* rx buffer size */
789                                 data.ioc_flags ? "nagle" : "nonagle");
790                 } else if (g_net_is_compatible (NULL, RALND, 0)) {
791                         printf ("%-20s [%d]\n",
792                                 libcfs_nid2str(data.ioc_nid),
793                                 data.ioc_u32[0] /* device id */);
794                 } else if (g_net_is_compatible (NULL, O2IBLND, 0)) {
795                         printf ("%s mtu %d\n",
796                                 libcfs_nid2str(data.ioc_nid),
797                                 data.ioc_u32[0]); /* path MTU */
798                 } else if (g_net_is_compatible (NULL, GNILND, 0)) {
799                         printf ("%-20s [%d]\n",
800                                 libcfs_nid2str(data.ioc_nid),
801                                 data.ioc_u32[0] /* device id */);
802                 } else {
803                         printf ("%s\n", libcfs_nid2str(data.ioc_nid));
804                 }
805         }
806
807         if (index == 0) {
808                 if (errno == ENOENT) {
809                         printf ("<no connections>\n");
810                 } else {
811                         fprintf(stderr, "Error getting connection list: %s: "
812                                 "check dmesg.\n",
813                                 strerror(errno));
814                 }
815         }
816         return 0;
817 }
818
819 int jt_ptl_disconnect(int argc, char **argv)
820 {
821         struct libcfs_ioctl_data data;
822         lnet_nid_t               nid = LNET_NID_ANY;
823         __u32                    ipaddr = 0;
824         int                      rc;
825
826         if (argc > 3) {
827                 fprintf(stderr, "usage: %s [nid] [ipaddr]\n", argv[0]);
828                 return 0;
829         }
830
831         if (!g_net_is_compatible (NULL, SOCKLND, RALND, MXLND, O2IBLND,
832                                   GNILND, 0))
833                 return 0;
834
835         if (argc >= 2 &&
836             !libcfs_str2anynid(&nid, argv[1])) {
837                 fprintf (stderr, "Can't parse nid %s\n", argv[1]);
838                 return -1;
839         }
840
841         if (g_net_is_compatible (NULL, SOCKLND, 0) &&
842             argc >= 3 &&
843             lnet_parse_ipaddr (&ipaddr, argv[2]) != 0) {
844                 fprintf (stderr, "Can't parse ip addr %s\n", argv[2]);
845                 return -1;
846         }
847
848         LIBCFS_IOC_INIT(data);
849         data.ioc_net     = g_net;
850         data.ioc_nid     = nid;
851         data.ioc_u32[0]  = ipaddr;
852
853         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_CLOSE_CONNECTION, &data);
854         if (rc != 0) {
855                 fprintf(stderr, "failed to remove connection: %s\n",
856                         strerror(errno));
857                 return -1;
858         }
859
860         return 0;
861 }
862
863 int jt_ptl_push_connection (int argc, char **argv)
864 {
865         struct libcfs_ioctl_data data;
866         int                      rc;
867         lnet_nid_t               nid = LNET_NID_ANY;
868
869         if (argc > 2) {
870                 fprintf(stderr, "usage: %s [nid]\n", argv[0]);
871                 return 0;
872         }
873
874         if (!g_net_is_compatible (argv[0], SOCKLND, GNILND, 0))
875                 return -1;
876
877         if (argc > 1 &&
878             !libcfs_str2anynid(&nid, argv[1])) {
879                 fprintf(stderr, "Can't parse nid: %s\n", argv[1]);
880                 return -1;
881         }
882
883         LIBCFS_IOC_INIT(data);
884         data.ioc_net     = g_net;
885         data.ioc_nid     = nid;
886
887         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_PUSH_CONNECTION, &data);
888         if (rc != 0) {
889                 fprintf(stderr, "failed to push connection: %s\n",
890                         strerror(errno));
891                 return -1;
892         }
893
894         return 0;
895 }
896
897 int
898 jt_ptl_print_active_txs (int argc, char **argv)
899 {
900         struct libcfs_ioctl_data data;
901         int                      index;
902         int                      rc;
903
904         if (!g_net_is_compatible (argv[0], QSWLND, 0))
905                 return -1;
906
907         for (index = 0;;index++) {
908                 LIBCFS_IOC_INIT(data);
909                 data.ioc_net   = g_net;
910                 data.ioc_count = index;
911
912                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_TXDESC, &data);
913                 if (rc != 0)
914                         break;
915
916                 printf ("type %u payload %6d to %s via %s by pid %6d: "
917                         "%s, %s, state %d\n",
918                         data.ioc_u32[0],
919                         data.ioc_count,
920                         libcfs_nid2str(data.ioc_nid),
921                         libcfs_nid2str(data.ioc_u64[0]),
922                         data.ioc_u32[1],
923                         (data.ioc_flags & 1) ? "delayed" : "immediate",
924                         (data.ioc_flags & 2) ? "nblk"    : "normal",
925                         data.ioc_flags >> 2);
926         }
927
928         if (index == 0) {
929                 if (errno == ENOENT) {
930                         printf ("<no active descs>\n");
931                 } else {
932                         fprintf(stderr, "Error getting active transmits list: "
933                                 "%s: check dmesg.\n",
934                                 strerror(errno));
935                 }
936         }
937         return 0;
938 }
939
940 int jt_ptl_ping(int argc, char **argv)
941 {
942         int                      rc;
943         int                      timeout;
944         lnet_process_id_t        id;
945         lnet_process_id_t        ids[16];
946         int                      maxids = sizeof(ids)/sizeof(ids[0]);
947         struct libcfs_ioctl_data data;
948         char                    *sep;
949         int                      i;
950
951         if (argc < 2) {
952                 fprintf(stderr, "usage: %s id [timeout (secs)]\n", argv[0]);
953                 return 0;
954         }
955
956         sep = strchr(argv[1], '-');
957         if (sep == NULL) {
958                 rc = lnet_parse_nid(argv[1], &id);
959                 if (rc != 0)
960                         return -1;
961         } else {
962                 char   *end;
963
964                 if (argv[1][0] == 'u' ||
965                     argv[1][0] == 'U')
966                         id.pid = strtoul(&argv[1][1], &end, 0) | LNET_PID_USERFLAG;
967                 else
968                         id.pid = strtoul(argv[1], &end, 0);
969
970                 if (end != sep) { /* assuming '-' is part of hostname */
971                         rc = lnet_parse_nid(argv[1], &id);
972                         if (rc != 0)
973                                 return -1;
974                 } else {
975                         id.nid = libcfs_str2nid(sep + 1);
976
977                         if (id.nid == LNET_NID_ANY) {
978                                 fprintf(stderr,
979                                         "Can't parse process id \"%s\"\n",
980                                         argv[1]);
981                                 return -1;
982                         }
983                 }
984         }
985
986         if (argc > 2)
987                 timeout = 1000 * atol(argv[2]);
988         else
989                 timeout = 1000;                 /* default 1 second timeout */
990
991         LIBCFS_IOC_INIT (data);
992         data.ioc_nid     = id.nid;
993         data.ioc_u32[0]  = id.pid;
994         data.ioc_u32[1]  = timeout;
995         data.ioc_plen1   = sizeof(ids);
996         data.ioc_pbuf1   = (char *)ids;
997
998         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_PING, &data);
999         if (rc != 0) {
1000                 fprintf(stderr, "failed to ping %s: %s\n",
1001                         id.pid == LNET_PID_ANY ?
1002                         libcfs_nid2str(id.nid) : libcfs_id2str(id),
1003                         strerror(errno));
1004                 return -1;
1005         }
1006
1007         for (i = 0; i < data.ioc_count && i < maxids; i++)
1008                 printf("%s\n", libcfs_id2str(ids[i]));
1009
1010         if (data.ioc_count > maxids)
1011                 printf("%d out of %d ids listed\n", maxids, data.ioc_count);
1012
1013         return 0;
1014 }
1015
1016 int jt_ptl_mynid(int argc, char **argv)
1017 {
1018         struct libcfs_ioctl_data data;
1019         lnet_nid_t               nid;
1020         int rc;
1021
1022         if (argc != 2) {
1023                 fprintf(stderr, "usage: %s NID\n", argv[0]);
1024                 return 0;
1025         }
1026
1027         nid = libcfs_str2nid(argv[1]);
1028         if (nid == LNET_NID_ANY) {
1029                 fprintf(stderr, "Can't parse NID '%s'\n", argv[1]);
1030                 return -1;
1031         }
1032
1033         LIBCFS_IOC_INIT(data);
1034         data.ioc_net = LNET_NIDNET(nid);
1035         data.ioc_nid = nid;
1036
1037         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_REGISTER_MYNID, &data);
1038         if (rc < 0)
1039                 fprintf(stderr, "setting my NID failed: %s\n",
1040                        strerror(errno));
1041         else
1042                 printf("registered my nid %s\n", libcfs_nid2str(nid));
1043
1044         return 0;
1045 }
1046
1047 int
1048 jt_ptl_fail_nid (int argc, char **argv)
1049 {
1050         int                      rc;
1051         lnet_nid_t               nid;
1052         unsigned int             threshold;
1053         struct libcfs_ioctl_data data;
1054
1055         if (argc < 2 || argc > 3)
1056         {
1057                 fprintf (stderr, "usage: %s nid|\"*\" [count (0 == mend)]\n", argv[0]);
1058                 return (0);
1059         }
1060
1061         if (!libcfs_str2anynid(&nid, argv[1]))
1062         {
1063                 fprintf (stderr, "Can't parse nid \"%s\"\n", argv[1]);
1064                 return (-1);
1065         }
1066
1067         if (argc < 3) {
1068                 threshold = LNET_MD_THRESH_INF;
1069         } else if (sscanf (argv[2], "%i", &threshold) != 1) {
1070                 fprintf (stderr, "Can't parse count \"%s\"\n", argv[2]);
1071                 return (-1);
1072         }
1073
1074         LIBCFS_IOC_INIT (data);
1075         data.ioc_nid = nid;
1076         data.ioc_count = threshold;
1077
1078         rc = l_ioctl (LNET_DEV_ID, IOC_LIBCFS_FAIL_NID, &data);
1079         if (rc < 0)
1080                 fprintf (stderr, "IOC_LIBCFS_FAIL_NID failed: %s\n",
1081                          strerror (errno));
1082         else
1083                 printf ("%s %s\n", threshold == 0 ? "Unfailing" : "Failing", argv[1]);
1084
1085         return (0);
1086 }
1087
1088 int
1089 jt_ptl_add_route (int argc, char **argv)
1090 {
1091         struct libcfs_ioctl_data data;
1092         lnet_nid_t               gateway_nid;
1093         unsigned int             hops = 1;
1094         unsigned int             priority = 0;
1095         char                    *end;
1096         int                      rc;
1097
1098         if (argc < 2 || argc > 4) {
1099                 fprintf(stderr, "usage: %s gateway [hopcount [priority]]\n",
1100                         argv[0]);
1101                 return -1;
1102         }
1103
1104         if (!g_net_is_set(argv[0]))
1105                 return (-1);
1106
1107         gateway_nid = libcfs_str2nid(argv[1]);
1108         if (gateway_nid == LNET_NID_ANY) {
1109                 fprintf (stderr, "Can't parse gateway NID \"%s\"\n", argv[1]);
1110                 return (-1);
1111         }
1112
1113         if (argc > 2) {
1114                 hops = strtoul(argv[2], &end, 0);
1115                 if (hops == 0 || hops >= 256 || (end != NULL && *end != 0)) {
1116                         fprintf(stderr, "Can't parse hopcount \"%s\"\n",
1117                                 argv[2]);
1118                         return -1;
1119                 }
1120                 if (argc == 4) {
1121                         priority = strtoul(argv[3], &end, 0);
1122                         if (end != NULL && *end != 0) {
1123                                 fprintf(stderr,
1124                                         "Can't parse priority \"%s\"\n",
1125                                         argv[3]);
1126                                 return -1;
1127                         }
1128                 }
1129         }
1130
1131         LIBCFS_IOC_INIT(data);
1132         data.ioc_net = g_net;
1133         data.ioc_count = hops;
1134         data.ioc_nid = gateway_nid;
1135         data.ioc_priority = priority;
1136
1137         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_ADD_ROUTE, &data);
1138         if (rc != 0) {
1139                 fprintf (stderr, "IOC_LIBCFS_ADD_ROUTE failed: %s\n", strerror (errno));
1140                 return (-1);
1141         }
1142
1143         return (0);
1144 }
1145
1146 int
1147 jt_ptl_del_route (int argc, char **argv)
1148 {
1149         struct libcfs_ioctl_data data;
1150         lnet_nid_t               nid;
1151         int                      rc;
1152
1153         if (argc != 2) {
1154                 fprintf (stderr, "usage: %s gatewayNID\n", argv[0]);
1155                 return (0);
1156         }
1157
1158         if (!libcfs_str2anynid(&nid, argv[1])) {
1159                 fprintf (stderr, "Can't parse gateway NID "
1160                          "\"%s\"\n", argv[1]);
1161                 return -1;
1162         }
1163
1164         LIBCFS_IOC_INIT(data);
1165         data.ioc_net = g_net_set ? g_net : LNET_NIDNET(LNET_NID_ANY);
1166         data.ioc_nid = nid;
1167
1168         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_DEL_ROUTE, &data);
1169         if (rc != 0) {
1170                 fprintf (stderr, "IOC_LIBCFS_DEL_ROUTE (%s) failed: %s\n",
1171                          libcfs_nid2str(nid), strerror (errno));
1172                 return (-1);
1173         }
1174
1175         return (0);
1176 }
1177
1178 int
1179 jt_ptl_notify_router (int argc, char **argv)
1180 {
1181         struct libcfs_ioctl_data data;
1182         int                      enable;
1183         lnet_nid_t               nid;
1184         int                      rc;
1185         struct timeval           now;
1186         time_t                   when;
1187
1188         if (argc < 3)
1189         {
1190                 fprintf (stderr, "usage: %s targetNID <up/down> [<time>]\n", 
1191                          argv[0]);
1192                 return (0);
1193         }
1194
1195         nid = libcfs_str2nid(argv[1]);
1196         if (nid == LNET_NID_ANY) {
1197                 fprintf (stderr, "Can't parse target NID \"%s\"\n", argv[1]);
1198                 return (-1);
1199         }
1200
1201         if (lnet_parse_bool (&enable, argv[2]) != 0) {
1202                 fprintf (stderr, "Can't parse boolean %s\n", argv[2]);
1203                 return (-1);
1204         }
1205
1206         gettimeofday(&now, NULL);
1207
1208         if (argc < 4) {
1209                 when = now.tv_sec;
1210         } else if (lnet_parse_time (&when, argv[3]) != 0) {
1211                 fprintf(stderr, "Can't parse time %s\n"
1212                         "Please specify either 'YYYY-MM-DD-HH:MM:SS'\n"
1213                         "or an absolute unix time in seconds\n", argv[3]);
1214                 return (-1);
1215         } else if (when > now.tv_sec) {
1216                 fprintf (stderr, "%s specifies a time in the future\n",
1217                          argv[3]);
1218                 return (-1);
1219         }
1220
1221         LIBCFS_IOC_INIT(data);
1222         data.ioc_nid = nid;
1223         data.ioc_flags = enable;
1224         /* Yeuch; 'cept I need a __u64 on 64 bit machines... */
1225         data.ioc_u64[0] = (__u64)when;
1226
1227         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_NOTIFY_ROUTER, &data);
1228         if (rc != 0) {
1229                 fprintf (stderr, "IOC_LIBCFS_NOTIFY_ROUTER (%s) failed: %s\n",
1230                          libcfs_nid2str(nid), strerror (errno));
1231                 return (-1);
1232         }
1233
1234         return (0);
1235 }
1236
1237 int
1238 jt_ptl_print_routes (int argc, char **argv)
1239 {
1240         struct libcfs_ioctl_data  data;
1241         int                       rc;
1242         int                       index;
1243         __u32                     net;
1244         lnet_nid_t                nid;
1245         unsigned int              hops;
1246         int                       alive;
1247         unsigned int              pri;
1248
1249         for (index = 0;;index++)
1250         {
1251                 LIBCFS_IOC_INIT(data);
1252                 data.ioc_count = index;
1253
1254                 rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_GET_ROUTE, &data);
1255                 if (rc != 0)
1256                         break;
1257
1258                 net     = data.ioc_net;
1259                 hops    = data.ioc_count;
1260                 nid     = data.ioc_nid;
1261                 alive   = data.ioc_flags;
1262                 pri     = data.ioc_priority;
1263
1264                 printf("net %18s hops %u gw %32s %s pri %u\n",
1265                        libcfs_net2str(net), hops,
1266                        libcfs_nid2str(nid), alive ? "up" : "down", pri);
1267         }
1268
1269         if (errno != ENOENT)
1270                 fprintf(stderr, "Error getting routes: %s: check dmesg.\n",
1271                         strerror(errno));
1272
1273         return (0);
1274 }
1275
1276 double
1277 get_cycles_per_usec ()
1278 {
1279         FILE      *f = fopen ("/proc/cpuinfo", "r");
1280         double     mhz;
1281         char      line[64];
1282
1283         if (f != NULL) {
1284                 while (fgets (line, sizeof (line), f) != NULL)
1285                         if (sscanf (line, "cpu MHz : %lf", &mhz) == 1) {
1286                                 fclose (f);
1287                                 return (mhz);
1288                         }
1289                 fclose (f);
1290         }
1291
1292         fprintf (stderr, "Can't read/parse /proc/cpuinfo\n");
1293         return (1000.0);
1294 }
1295
1296 int jt_ptl_memhog(int argc, char **argv)
1297 {
1298         static int                gfp = 0;        /* sticky! */
1299
1300         struct libcfs_ioctl_data  data;
1301         int                       rc;
1302         int                       count;
1303         char                     *end;
1304
1305         if (argc < 2)  {
1306                 fprintf(stderr, "usage: %s <npages> [<GFP flags>]\n", argv[0]);
1307                 return 0;
1308         }
1309
1310         count = strtol(argv[1], &end, 0);
1311         if (count < 0 || *end != 0) {
1312                 fprintf(stderr, "Can't parse page count '%s'\n", argv[1]);
1313                 return -1;
1314         }
1315
1316         if (argc >= 3) {
1317                 rc = strtol(argv[2], &end, 0);
1318                 if (*end != 0) {
1319                         fprintf(stderr, "Can't parse gfp flags '%s'\n", argv[2]);
1320                         return -1;
1321                 }
1322                 gfp = rc;
1323         }
1324
1325         LIBCFS_IOC_INIT(data);
1326         data.ioc_count = count;
1327         data.ioc_flags = gfp;
1328         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_MEMHOG, &data);
1329
1330         if (rc != 0) {
1331                 fprintf(stderr, "memhog %d failed: %s\n", count, strerror(errno));
1332                 return -1;
1333         }
1334
1335         printf("memhog %d OK\n", count);
1336         return 0;
1337 }
1338
1339 int jt_ptl_testprotocompat(int argc, char **argv)
1340 {
1341         struct libcfs_ioctl_data  data;
1342         int                       rc;
1343         int                       flags;
1344         char                     *end;
1345
1346         if (argc < 2)  {
1347                 fprintf(stderr, "usage: %s <number>\n", argv[0]);
1348                 return 0;
1349         }
1350
1351         flags = strtol(argv[1], &end, 0);
1352         if (flags < 0 || *end != 0) {
1353                 fprintf(stderr, "Can't parse flags '%s'\n", argv[1]);
1354                 return -1;
1355         }
1356
1357         LIBCFS_IOC_INIT(data);
1358         data.ioc_flags = flags;
1359         rc = l_ioctl(LNET_DEV_ID, IOC_LIBCFS_TESTPROTOCOMPAT, &data);
1360
1361         if (rc != 0) {
1362                 fprintf(stderr, "test proto compat %x failed: %s\n",
1363                         flags, strerror(errno));
1364                 return -1;
1365         }
1366
1367         printf("test proto compat %x OK\n", flags);
1368         return 0;
1369 }
1370
1371