Whamcloud - gitweb
70440e0224fcc2aa77d80bdc5dc09524768e229c
[fs/lustre-release.git] / lnet / utils / portals.c
1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=8:tabstop=8:
3  *
4  * Copyright (C) 2001, 2002 Cluster File Systems, Inc.
5  *
6  *   This file is part of Portals, http://www.sf.net/projects/lustre/
7  *
8  *   Portals is free software; you can redistribute it and/or
9  *   modify it under the terms of version 2 of the GNU General Public
10  *   License as published by the Free Software Foundation.
11  *
12  *   Portals is distributed in the hope that it will be useful,
13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *   GNU General Public License for more details.
16  *
17  *   You should have received a copy of the GNU General Public License
18  *   along with Portals; if not, write to the Free Software
19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20  *
21  */
22
23 #include <stdio.h>
24 #include <sys/types.h>
25 #ifdef HAVE_NETDB_H
26 #include <netdb.h>
27 #endif
28 #include <sys/socket.h>
29 #ifdef HAVE_NETINET_TCP_H
30 #include <netinet/tcp.h>
31 #endif
32 #include <stdlib.h>
33 #include <string.h>
34 #include <fcntl.h>
35 #include "ioctl.h"
36 #include <sys/ioctl.h>
37 #include <errno.h>
38 #include <unistd.h>
39 #include <time.h>
40 #include <stdarg.h>
41 #include <endian.h>
42 #if CRAY_PORTALS
43 #ifdef REDSTORM
44 #define __QK__
45 #endif
46 #include <portals/ipmap.h>
47 #endif
48
49 #ifdef __CYGWIN__
50
51 #include <netinet/in.h>
52
53 #endif /* __CYGWIN__ */
54  
55 #include <portals/api-support.h>
56 #include <portals/ptlctl.h>
57 #include <portals/list.h>
58 #include <portals/lib-types.h>
59 #include <portals/socknal.h>
60 #include "parser.h"
61
62 unsigned int portal_debug;
63 unsigned int portal_printk;
64
65 static unsigned int g_nal = 0;
66
67 typedef struct
68 {
69         char *name;
70         int   num;
71 } name2num_t;
72
73 static name2num_t nalnames[] = {
74         {"any",         0},
75 #if !CRAY_PORTALS
76         {"tcp",         SOCKNAL},
77         {"elan",        QSWNAL},
78         {"gm",          GMNAL},
79         {"openib",      OPENIBNAL},
80         {"iib",         IIBNAL},
81         {"vib",         VIBNAL},
82         {"lo",          LONAL},
83         {"ra",          RANAL},
84 #else
85         {"cray_kern_nal", CRAY_KERN_NAL},
86         {"cray_user_nal", CRAY_USER_NAL},
87         {"cray_qk_nal",   CRAY_QK_NAL},
88 #endif
89         {NULL,          -1}
90 };
91
92 static cfg_record_cb_t g_record_cb;
93
94 /* Convert a string boolean to an int; "enable" -> 1 */
95 int ptl_parse_bool (int *b, char *str) {
96         if (!strcasecmp (str, "no") ||
97             !strcasecmp (str, "n") ||
98             !strcasecmp (str, "off") ||
99             !strcasecmp (str, "down") ||
100             !strcasecmp (str, "disable"))
101         {
102                 *b = 0;
103                 return (0);
104         }
105         
106         if (!strcasecmp (str, "yes") ||
107             !strcasecmp (str, "y") ||
108             !strcasecmp (str, "on") ||
109             !strcasecmp (str, "up") ||
110             !strcasecmp (str, "enable"))
111         {
112                 *b = 1;
113                 return (0);
114         }
115         
116         return (-1);
117 }
118
119 /* Convert human readable size string to and int; "1k" -> 1000 */
120 int ptl_parse_size (int *sizep, char *str) {
121         int size;
122         char mod[32];
123
124         switch (sscanf (str, "%d%1[gGmMkK]", &size, mod)) {
125         default:
126                 return (-1);
127
128         case 1:
129                 *sizep = size;
130                 return (0);
131
132         case 2:
133                 switch (*mod) {
134                 case 'g':
135                 case 'G':
136                         *sizep = size << 30;
137                         return (0);
138
139                 case 'm':
140                 case 'M':
141                         *sizep = size << 20;
142                         return (0);
143
144                 case 'k':
145                 case 'K':
146                         *sizep = size << 10;
147                         return (0);
148
149                 default:
150                         *sizep = size;
151                         return (0);
152                 }
153         }
154 }
155
156 int 
157 ptl_set_cfg_record_cb(cfg_record_cb_t cb)
158 {
159         g_record_cb = cb;
160         return 0;
161 }
162
163 int 
164 pcfg_ioctl(struct portals_cfg *pcfg) 
165 {
166         int rc;
167
168         if (pcfg->pcfg_nal ==0)
169                 pcfg->pcfg_nal    = g_nal;
170
171         if (g_record_cb) {
172                 rc = g_record_cb(PORTALS_CFG_TYPE, sizeof(*pcfg), pcfg);
173         } else {
174                 struct portal_ioctl_data data;
175                 PORTAL_IOC_INIT (data);
176                 data.ioc_pbuf1   = (char*)pcfg;
177                 data.ioc_plen1   = sizeof(*pcfg);
178                 /* XXX liblustre hack XXX */
179                 data.ioc_nal_cmd = pcfg->pcfg_command;
180                 data.ioc_nid = pcfg->pcfg_nid;
181
182                 rc = l_ioctl (PORTALS_DEV_ID, IOC_PORTAL_NAL_CMD, &data);
183         }
184
185         return (rc);
186 }
187
188
189
190 static name2num_t *
191 name2num_lookup_name (name2num_t *table, char *str)
192 {
193         while (table->name != NULL)
194                 if (!strcmp (str, table->name))
195                         return (table);
196                 else
197                         table++;
198         return (NULL);
199 }
200
201 static name2num_t *
202 name2num_lookup_num (name2num_t *table, int num)
203 {
204         while (table->name != NULL)
205                 if (num == table->num)
206                         return (table);
207                 else
208                         table++;
209         return (NULL);
210 }
211
212 int
213 ptl_name2nal (char *str)
214 {
215         name2num_t *e = name2num_lookup_name (nalnames, str);
216
217         return ((e == NULL) ? -1 : e->num);
218 }
219
220 static char *
221 nal2name (int nal)
222 {
223         name2num_t *e = name2num_lookup_num (nalnames, nal);
224
225         return ((e == NULL) ? "???" : e->name);
226 }
227
228 #ifdef HAVE_GETHOSTBYNAME
229 static struct hostent *
230 ptl_gethostbyname(char * hname) {
231         struct hostent *he;
232         he = gethostbyname(hname);
233         if (!he) {
234                 switch(h_errno) {
235                 case HOST_NOT_FOUND:
236                 case NO_ADDRESS:
237                         fprintf(stderr, "Unable to resolve hostname: %s\n",
238                                 hname);
239                         break;
240                 default:
241                         fprintf(stderr, "gethostbyname error for %s: %s\n",
242                                 hname, strerror(h_errno));
243                         break;
244                 }
245                 return NULL;
246         }
247         return he;
248 }
249 #endif
250
251 int
252 ptl_parse_port (int *port, char *str)
253 {
254         char      *end;
255         
256         *port = strtol (str, &end, 0);
257
258         if (*end == 0 &&                        /* parsed whole string */
259             *port > 0 && *port < 65536)         /* minimal sanity check */
260                 return (0);
261         
262         return (-1);
263 }
264
265 int
266 ptl_parse_time (time_t *t, char *str) 
267 {
268         char          *end;
269         int            n;
270         struct tm      tm;
271         
272         *t = strtol (str, &end, 0);
273         if (*end == 0) /* parsed whole string */
274                 return (0);
275         
276         memset (&tm, 0, sizeof (tm));
277         n = sscanf (str, "%d-%d-%d-%d:%d:%d",
278                     &tm.tm_year, &tm.tm_mon, &tm.tm_mday, 
279                     &tm.tm_hour, &tm.tm_min, &tm.tm_sec);
280         if (n != 6)
281                 return (-1);
282         
283         tm.tm_mon--;                    /* convert to 0 == Jan */
284         tm.tm_year -= 1900;             /* y2k quirk */
285         tm.tm_isdst = -1;               /* dunno if it's daylight savings... */
286         
287         *t = mktime (&tm);
288         if (*t == (time_t)-1)
289                 return (-1);
290                         
291         return (0);
292 }
293
294 int
295 ptl_parse_ipquad (__u32 *ipaddrp, char *str)
296 {
297         int             a;
298         int             b;
299         int             c;
300         int             d;
301
302         if (sscanf (str, "%d.%d.%d.%d", &a, &b, &c, &d) == 4 &&
303             (a & ~0xff) == 0 && (b & ~0xff) == 0 &&
304             (c & ~0xff) == 0 && (d & ~0xff) == 0)
305         {
306                 *ipaddrp = (a<<24)|(b<<16)|(c<<8)|d;
307                 return (0);
308         }
309
310         return (-1);
311 }
312
313 int
314 ptl_parse_ipaddr (__u32 *ipaddrp, char *str)
315 {
316 #ifdef HAVE_GETHOSTBYNAME
317         struct hostent *he;
318 #endif
319
320         if (!strcmp (str, "_all_")) {
321                 *ipaddrp = 0;
322                 return (0);
323         }
324
325         if (ptl_parse_ipquad(ipaddrp, str) == 0)
326                 return (0);
327
328 #ifdef HAVE_GETHOSTBYNAME
329         if ((('a' <= str[0] && str[0] <= 'z') ||
330              ('A' <= str[0] && str[0] <= 'Z')) &&
331              (he = ptl_gethostbyname (str)) != NULL) {
332                 __u32 addr = *(__u32 *)he->h_addr;
333
334                 *ipaddrp = ntohl(addr);         /* HOST byte order */
335                 return (0);
336         }
337 #endif
338
339         return (-1);
340 }
341
342 char *
343 ptl_ipaddr_2_str (__u32 ipaddr, char *str, int lookup)
344 {
345 #ifdef HAVE_GETHOSTBYNAME
346         __u32           net_ip;
347         struct hostent *he;
348
349         if (lookup) {
350                 net_ip = htonl (ipaddr);
351                 he = gethostbyaddr (&net_ip, sizeof (net_ip), AF_INET);
352                 if (he != NULL) {
353                         strcpy(str, he->h_name);
354                         return (str);
355                 }
356         }
357 #endif
358
359         sprintf (str, "%d.%d.%d.%d",
360                  (ipaddr >> 24) & 0xff, (ipaddr >> 16) & 0xff,
361                  (ipaddr >> 8) & 0xff, ipaddr & 0xff);
362         return (str);
363 }
364
365 int
366 ptl_parse_nid (ptl_nid_t *nidp, char *str)
367 {
368         __u32               ipaddr;
369         char               *end;
370         unsigned long long  ullval;
371         
372         if (!strcmp (str, "_all_")) {
373                 *nidp = PTL_NID_ANY;
374                 return (0);
375         }
376
377         if (ptl_parse_ipaddr (&ipaddr, str) == 0) {
378 #if !CRAY_PORTALS
379                 *nidp = (ptl_nid_t)ipaddr;
380 #else
381                 *nidp = (((ptl_nid_t)ipaddr & PNAL_HOSTID_MASK) << PNAL_VNODE_SHIFT);
382 #endif
383                 return (0);
384         }
385
386         ullval = strtoull(str, &end, 0);
387         if (*end == 0) {
388                 /* parsed whole string */
389                 *nidp = (ptl_nid_t)ullval;
390                 return (0);
391         }
392
393         return (-1);
394 }
395
396 __u64 ptl_nid2u64(ptl_nid_t nid)
397 {
398         switch (sizeof (nid)) {
399         case 8:
400                 return (nid);
401         case 4:
402                 return ((__u32)nid);
403         default:
404                 fprintf(stderr, "Unexpected sizeof(ptl_nid_t) == %u\n", sizeof(nid));
405                 abort();
406                 /* notreached */
407                 return (-1);
408         }
409 }
410
411 char *
412 ptl_nid2str (char *buffer, ptl_nid_t nid)
413 {
414         __u64           nid64 = ptl_nid2u64(nid);
415 #ifdef HAVE_GETHOSTBYNAME
416         struct hostent *he = 0;
417
418         /* Don't try to resolve NIDs that are e.g. Elan host IDs.  Assume
419          * TCP addresses in the 0.x.x.x subnet are not in use.  This can
420          * happen on routers and slows things down a _lot_.  Bug 3442. */
421         if (nid & 0xff000000) {
422                 __u32 addr = htonl((__u32)nid); /* back to NETWORK byte order */
423
424                 he = gethostbyaddr((const char *)&addr, sizeof(addr), AF_INET);
425         }
426
427         if (he != NULL)
428                 sprintf(buffer, "%#x:%s", (int)(nid64 >> 32), he->h_name);
429         else
430 #endif /* HAVE_GETHOSTBYNAME */
431                 sprintf(buffer, LPX64, nid64);
432
433         return (buffer);
434 }
435
436 int g_nal_is_set () 
437 {
438         if (g_nal == 0) {
439                 fprintf (stderr, "Error: you must run the 'network' command first.\n");
440                 return (0);
441         }
442
443         return (1);
444 }
445
446 int g_nal_is_compatible (char *cmd, ...)
447 {
448         va_list       ap;
449         int           nal;
450
451         if (!g_nal_is_set ())
452                 return (0);
453
454         va_start (ap, cmd);
455
456         do {
457                 nal = va_arg (ap, int);
458         } while (nal != 0 && nal != g_nal);
459         
460         va_end (ap);
461         
462         if (g_nal == nal)
463                 return (1);
464
465         if (cmd != NULL) {
466                 /* Don't complain verbosely if we've not been passed a command
467                  * name to complain about! */
468                 fprintf (stderr, "Command %s not compatible with nal %s\n",
469                          cmd, nal2name (g_nal));
470         }
471         return (0);
472 }
473
474 int
475 sock_write (int cfd, void *buffer, int nob)
476 {
477         while (nob > 0)
478         {
479                 int rc = write (cfd, buffer, nob);
480
481                 if (rc < 0)
482                 {
483                         if (errno == EINTR)
484                                 continue;
485                         
486                         return (rc);
487                 }
488
489                 if (rc == 0)
490                 {
491                         fprintf (stderr, "Unexpected zero sock_write\n");
492                         abort();
493                 }
494
495                 nob -= rc;
496                 buffer = (char *)buffer + nob;
497         }
498         
499         return (0);
500 }
501
502 int
503 sock_read (int cfd, void *buffer, int nob)
504 {
505         while (nob > 0)
506         {
507                 int rc = read (cfd, buffer, nob);
508                 
509                 if (rc < 0)
510                 {
511                         if (errno == EINTR)
512                                 continue;
513                         
514                         return (rc);
515                 }
516                 
517                 if (rc == 0)                    /* EOF */
518                 {
519                         errno = ECONNABORTED;
520                         return (-1);
521                 }
522                 
523                 nob -= rc;
524                 buffer = (char *)buffer + nob;
525         }
526         
527         return (0);
528 }
529
530 int ptl_initialize(int argc, char **argv) 
531 {
532         register_ioc_dev(PORTALS_DEV_ID, PORTALS_DEV_PATH);
533         return 0;
534 }
535
536
537 int jt_ptl_network(int argc, char **argv)
538 {
539         name2num_t *entry;
540         int         nal;
541         
542         if (argc == 2 &&
543             (nal = ptl_name2nal (argv[1])) >= 0) {
544                 g_nal = nal;
545                 return (0);
546         }
547                 
548         fprintf(stderr, "usage: %s \n", argv[0]);
549         for (entry = nalnames; entry->name != NULL; entry++)
550                 fprintf (stderr, "%s%s", entry == nalnames ? "<" : "|", entry->name);
551         fprintf(stderr, ">\n");
552         return (-1);
553 }
554
555 int
556 jt_ptl_print_interfaces (int argc, char **argv)
557 {
558         struct portals_cfg       pcfg;
559         char                     buffer[3][64];
560         int                      index;
561         int                      rc;
562
563         if (!g_nal_is_compatible (argv[0], SOCKNAL, 0))
564                 return -1;
565
566         for (index = 0;;index++) {
567                 PCFG_INIT (pcfg, NAL_CMD_GET_INTERFACE);
568                 pcfg.pcfg_count = index;
569
570                 rc = pcfg_ioctl (&pcfg);
571                 if (rc != 0)
572                         break;
573
574                 printf ("%s: (%s/%s) npeer %d nroute %d\n",
575                         ptl_ipaddr_2_str(pcfg.pcfg_id, buffer[2], 1),
576                         ptl_ipaddr_2_str(pcfg.pcfg_id, buffer[0], 0),
577                         ptl_ipaddr_2_str(pcfg.pcfg_misc, buffer[1], 0),
578                         pcfg.pcfg_fd, pcfg.pcfg_count);
579         }
580
581         if (index == 0)
582                 printf ("<no interfaces>\n");
583         return 0;
584 }
585
586 int
587 jt_ptl_add_interface (int argc, char **argv)
588 {
589         struct portals_cfg       pcfg;
590         __u32                    ipaddr;
591         int                      rc;
592         __u32                    netmask = 0xffffff00;
593         int                      i;
594         int                      count;
595         char                    *end;
596
597         if (argc < 2 || argc > 3) {
598                 fprintf (stderr, "usage: %s ipaddr [netmask]\n", argv[0]);
599                 return 0;
600         }
601
602         if (!g_nal_is_compatible(argv[0], SOCKNAL, 0))
603                 return -1;
604
605         if (ptl_parse_ipaddr(&ipaddr, argv[1]) != 0) {
606                 fprintf (stderr, "Can't parse ip: %s\n", argv[1]);
607                 return -1;
608         }
609
610         if (argc > 2 ) {
611                 count = strtol(argv[2], &end, 0);
612                 if (count > 0 && count < 32 && *end == 0) {
613                         netmask = 0;
614                         for (i = count; i > 0; i--)
615                                 netmask = netmask|(1<<(32-i));
616                 } else if (ptl_parse_ipquad(&netmask, argv[2]) != 0) {
617                         fprintf (stderr, "Can't parse netmask: %s\n", argv[2]);
618                         return -1;
619                 }
620         }
621
622         PCFG_INIT(pcfg, NAL_CMD_ADD_INTERFACE);
623         pcfg.pcfg_id     = ipaddr;
624         pcfg.pcfg_misc   = netmask;
625
626         rc = pcfg_ioctl (&pcfg);
627         if (rc != 0) {
628                 fprintf (stderr, "failed to add interface: %s\n",
629                          strerror (errno));
630                 return -1;
631         }
632
633         return 0;
634 }
635
636 int
637 jt_ptl_del_interface (int argc, char **argv)
638 {
639         struct portals_cfg       pcfg;
640         int                      rc;
641         __u32                    ipaddr = 0;
642
643         if (argc > 2) {
644                 fprintf (stderr, "usage: %s [ipaddr]\n", argv[0]);
645                 return 0;
646         }
647
648         if (!g_nal_is_compatible(argv[0], SOCKNAL, 0))
649                 return -1;
650
651         if (argc == 2 &&
652             ptl_parse_ipaddr(&ipaddr, argv[1]) != 0) {
653                 fprintf (stderr, "Can't parse ip: %s\n", argv[1]);
654                 return -1;
655         }
656         
657         PCFG_INIT(pcfg, NAL_CMD_DEL_INTERFACE);
658         pcfg.pcfg_id = ipaddr;
659
660         rc = pcfg_ioctl (&pcfg);
661         if (rc != 0) {
662                 fprintf (stderr, "failed to delete interface: %s\n",
663                          strerror (errno));
664                 return -1;
665         }
666
667         return 0;
668 }
669
670 int
671 jt_ptl_print_peers (int argc, char **argv)
672 {
673         struct portals_cfg       pcfg;
674         char                     buffer[2][64];
675         int                      index;
676         int                      rc;
677
678         if (!g_nal_is_compatible (argv[0], SOCKNAL, RANAL, 
679                                   OPENIBNAL, IIBNAL, VIBNAL, 0))
680                 return -1;
681
682         for (index = 0;;index++) {
683                 PCFG_INIT (pcfg, NAL_CMD_GET_PEER);
684                 pcfg.pcfg_count   = index;
685
686                 rc = pcfg_ioctl (&pcfg);
687                 if (rc != 0)
688                         break;
689
690                 if (g_nal_is_compatible(NULL, SOCKNAL, 0))
691                         printf (LPX64"[%d]%s@%s:%d #%d\n",
692                                 pcfg.pcfg_nid, pcfg.pcfg_wait,
693                                 ptl_ipaddr_2_str (pcfg.pcfg_size, buffer[0], 1),
694                                 ptl_ipaddr_2_str (pcfg.pcfg_id, buffer[1], 1),
695                                 pcfg.pcfg_misc, pcfg.pcfg_count);
696                 else if (g_nal_is_compatible(NULL, RANAL, OPENIBNAL, 0))
697                         printf (LPX64"[%d]@%s:%d\n",
698                                 pcfg.pcfg_nid, pcfg.pcfg_wait,
699                                 ptl_ipaddr_2_str (pcfg.pcfg_id, buffer[1], 1),
700                                 pcfg.pcfg_misc);
701                 else
702                         printf (LPX64"[%d]\n",
703                                 pcfg.pcfg_nid, pcfg.pcfg_wait);
704         }
705
706         if (index == 0)
707                 printf ("<no peers>\n");
708         return 0;
709 }
710
711 int 
712 jt_ptl_add_peer (int argc, char **argv)
713 {
714         struct portals_cfg       pcfg;
715         ptl_nid_t                nid;
716         __u32                    ip = 0;
717         int                      port = 0;
718         int                      rc;
719
720         if (!g_nal_is_compatible (argv[0], SOCKNAL, RANAL, 
721                                   OPENIBNAL, IIBNAL, VIBNAL, 0))
722                 return -1;
723
724         if (g_nal_is_compatible(NULL, SOCKNAL, OPENIBNAL, RANAL, 0)) {
725                 if (argc != 4) {
726                         fprintf (stderr, "usage(tcp,openib,ra): %s nid ipaddr port\n", 
727                                  argv[0]);
728                         return 0;
729                 }
730         } else if (argc != 2) {
731                 fprintf (stderr, "usage(iib,vib): %s nid\n", argv[0]);
732                 return 0;
733         }
734
735         if (ptl_parse_nid (&nid, argv[1]) != 0 ||
736                 nid == PTL_NID_ANY) {
737                 fprintf (stderr, "Can't parse NID: %s\n", argv[1]);
738                 return -1;
739         }
740
741         if (g_nal_is_compatible (NULL, SOCKNAL, OPENIBNAL, RANAL, 0)) {
742                 if (ptl_parse_ipaddr (&ip, argv[2]) != 0) {
743                         fprintf (stderr, "Can't parse ip addr: %s\n", argv[2]);
744                         return -1;
745                 }
746
747                 if (ptl_parse_port (&port, argv[3]) != 0) {
748                         fprintf (stderr, "Can't parse port: %s\n", argv[3]);
749                         return -1;
750                 }
751         }
752
753         PCFG_INIT(pcfg, NAL_CMD_ADD_PEER);
754         pcfg.pcfg_nid     = nid;
755         pcfg.pcfg_id      = ip;
756         pcfg.pcfg_misc    = port;
757
758         rc = pcfg_ioctl (&pcfg);
759         if (rc != 0) {
760                 fprintf (stderr, "failed to add peer: %s\n",
761                          strerror (errno));
762                 return -1;
763         }
764         
765         return 0;
766 }
767
768 int 
769 jt_ptl_del_peer (int argc, char **argv)
770 {
771         struct portals_cfg       pcfg;
772         ptl_nid_t                nid = PTL_NID_ANY;
773         __u32                    ip = 0;
774         int                      single_share = 0;
775         int                      argidx;
776         int                      rc;
777
778         if (!g_nal_is_compatible (argv[0], SOCKNAL, RANAL, 
779                                   OPENIBNAL, IIBNAL, VIBNAL, 0))
780                 return -1;
781
782         if (g_nal_is_compatible(NULL, SOCKNAL, 0)) {
783                 if (argc > 4) {
784                         fprintf (stderr, "usage: %s [nid] [ipaddr] [single_share]\n",
785                                  argv[0]);
786                         return 0;
787                 }
788         } else if (argc > 3) {
789                 fprintf (stderr, "usage: %s [nid] [single_share]\n", argv[0]);
790                 return 0;
791         }
792                 
793         if (argc > 1 &&
794             ptl_parse_nid (&nid, argv[1]) != 0) {
795                 fprintf (stderr, "Can't parse nid: %s\n", argv[1]);
796                 return -1;
797         }
798
799         argidx = 2;
800         if (g_nal_is_compatible(NULL, SOCKNAL, 0)) {
801                 if (argc > argidx &&
802                     ptl_parse_ipaddr (&ip, argv[argidx]) != 0) {
803                         fprintf (stderr, "Can't parse ip addr: %s\n",
804                                  argv[argidx]);
805                         return -1;
806                 }
807                 argidx++;
808         }
809         
810         if (argc > argidx) {
811                 if (!strcmp (argv[argidx], "single_share")) {
812                         single_share = 1;
813                 } else {
814                         fprintf (stderr, "Unrecognised arg %s'\n", argv[3]);
815                         return -1;
816                 }
817         }
818
819         PCFG_INIT(pcfg, NAL_CMD_DEL_PEER);
820         pcfg.pcfg_nid = nid;
821         pcfg.pcfg_id = ip;
822         pcfg.pcfg_flags = single_share;
823
824         rc = pcfg_ioctl (&pcfg);
825         if (rc != 0) {
826                 fprintf (stderr, "failed to remove peer: %s\n",
827                          strerror (errno));
828                 return -1;
829         }
830         
831         return 0;
832 }
833
834 int 
835 jt_ptl_print_connections (int argc, char **argv)
836 {
837         struct portals_cfg       pcfg;
838         char                     buffer[2][64];
839         int                      index;
840         int                      rc;
841
842         if (!g_nal_is_compatible (argv[0], SOCKNAL, RANAL, 
843                                   OPENIBNAL, IIBNAL, VIBNAL, 0))
844                 return -1;
845
846         for (index = 0;;index++) {
847                 PCFG_INIT (pcfg,  NAL_CMD_GET_CONN);
848                 pcfg.pcfg_count   = index;
849                 
850                 rc = pcfg_ioctl (&pcfg);
851                 if (rc != 0)
852                         break;
853
854                 if (g_nal_is_compatible (NULL, SOCKNAL, 0))
855                         printf ("[%d]%s:"LPX64"@%s:%d:%s %d/%d %s\n",
856                                 pcfg.pcfg_gw_nal,       /* scheduler */
857                                 ptl_ipaddr_2_str (pcfg.pcfg_fd, buffer[0], 1), /* local IP addr */
858                                 pcfg.pcfg_nid, 
859                                 ptl_ipaddr_2_str (pcfg.pcfg_id, buffer[1], 1), /* remote IP addr */
860                                 pcfg.pcfg_misc,         /* remote port */
861                                 (pcfg.pcfg_flags == SOCKNAL_CONN_ANY) ? "A" :
862                                 (pcfg.pcfg_flags == SOCKNAL_CONN_CONTROL) ? "C" :
863                                 (pcfg.pcfg_flags == SOCKNAL_CONN_BULK_IN) ? "I" :
864                                 (pcfg.pcfg_flags == SOCKNAL_CONN_BULK_OUT) ? "O" : "?",
865                                 pcfg.pcfg_count,        /* tx buffer size */
866                                 pcfg.pcfg_size,         /* rx buffer size */
867                                 pcfg.pcfg_wait ? "nagle" : "nonagle");
868                 else if (g_nal_is_compatible (NULL, RANAL, 0))
869                         printf ("[%d]"LPX64"\n",
870                                 pcfg.pcfg_id,       /* device id */
871                                 pcfg.pcfg_nid);
872                 else
873                         printf (LPX64"\n",
874                                 pcfg.pcfg_nid);
875         }
876
877         if (index == 0)
878                 printf ("<no connections>\n");
879         return 0;
880 }
881
882 int jt_ptl_connect(int argc, char **argv)
883 {
884 #ifndef HAVE_CONNECT
885         /* no connect() support */
886         return -1;
887 #else /* HAVE_CONNECT */
888         struct portals_cfg pcfg;
889         struct sockaddr_in srvaddr;
890         struct sockaddr_in locaddr;
891         __u32 ipaddr;
892         char *flag;
893         int fd, rc;
894         int type = SOCKNAL_CONN_ANY;
895         int port, rport;
896         int o;
897
898         if (argc < 3) {
899                 fprintf(stderr, "usage: %s ip port [type]\n", argv[0]);
900                 return 0;
901         }
902
903         if (!g_nal_is_compatible (argv[0], SOCKNAL, 0))
904                 return -1;
905         
906         rc = ptl_parse_ipaddr (&ipaddr, argv[1]);
907         if (rc != 0) {
908                 fprintf(stderr, "Can't parse hostname: %s\n", argv[1]);
909                 return -1;
910         }
911
912         if (ptl_parse_port (&port, argv[2]) != 0) {
913                 fprintf (stderr, "Can't parse port: %s\n", argv[2]);
914                 return -1;
915         }
916
917         if (argc > 3)
918                 for (flag = argv[3]; *flag != 0; flag++)
919                         switch (*flag)
920                         {
921                         case 'I':
922                                 if (type != SOCKNAL_CONN_ANY) {
923                                         fprintf(stderr, "Can't flag type twice\n");
924                                         return -1;
925                                 }
926                                 type = SOCKNAL_CONN_BULK_IN;
927                                 break;
928
929                         case 'O':
930                                 if (type != SOCKNAL_CONN_ANY) {
931                                         fprintf(stderr, "Can't flag type twice\n");
932                                         return -1;
933                                 }
934                                 type = SOCKNAL_CONN_BULK_OUT;
935                                 break;
936
937                         case 'C':
938                                 if (type != SOCKNAL_CONN_ANY) {
939                                         fprintf(stderr, "Can't flag type twice\n");
940                                         return -1;
941                                 }
942                                 type = SOCKNAL_CONN_CONTROL;
943                                 break;
944                                 
945                         default:
946                                 fprintf (stderr, "unrecognised flag '%c'\n",
947                                          *flag);
948                                 return (-1);
949                         }
950
951         memset(&locaddr, 0, sizeof(locaddr)); 
952         locaddr.sin_family = AF_INET; 
953         locaddr.sin_addr.s_addr = INADDR_ANY;
954
955         memset(&srvaddr, 0, sizeof(srvaddr));
956         srvaddr.sin_family = AF_INET;
957         srvaddr.sin_port = htons(port);
958         srvaddr.sin_addr.s_addr = htonl(ipaddr);
959
960
961         for (rport = IPPORT_RESERVED - 1; rport > IPPORT_RESERVED / 2; --rport) {
962                 fd = socket(PF_INET, SOCK_STREAM, 0); 
963                 if ( fd < 0 ) { 
964                         fprintf(stderr, "socket() failed: %s\n", strerror(errno)); 
965                         return -1; 
966                 }
967
968                 o = 1;
969                 rc = setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, 
970                                 &o, sizeof(o));
971                 
972                 locaddr.sin_port = htons(rport);
973                 rc = bind(fd, (struct sockaddr *)&locaddr, sizeof(locaddr)); 
974                 if (rc == 0 || errno == EACCES) {
975                         rc = connect(fd, (struct sockaddr *)&srvaddr, sizeof(srvaddr));
976                         if (rc == 0) {
977                                 break;
978                         } else if (errno != EADDRINUSE) {
979                                 fprintf(stderr, "Error connecting to host: %s\n", strerror(errno));
980                                 close(fd);
981                                 return -1;
982                         }
983                 } else if (errno != EADDRINUSE) {
984                         fprintf(stderr, "Error binding to port %d: %d: %s\n", port, errno, strerror(errno));
985                         close(fd);
986                         return -1;
987                 }
988         }
989
990         if (rport == IPPORT_RESERVED / 2) {
991                 fprintf(stderr,
992                         "Warning: all privileged ports are in use.\n"); 
993                 return -1;
994         }
995
996         printf("Connected host: %s type: %s\n", 
997                argv[1],
998                (type == SOCKNAL_CONN_ANY) ? "A" :
999                (type == SOCKNAL_CONN_CONTROL) ? "C" :
1000                (type == SOCKNAL_CONN_BULK_IN) ? "I" :
1001                (type == SOCKNAL_CONN_BULK_OUT) ? "O" : "?");
1002
1003         PCFG_INIT(pcfg, NAL_CMD_REGISTER_PEER_FD);
1004         pcfg.pcfg_nal = g_nal;
1005         pcfg.pcfg_fd = fd;
1006         pcfg.pcfg_misc = type;
1007         
1008         rc = pcfg_ioctl(&pcfg);
1009         if (rc) {
1010                 fprintf(stderr, "failed to register fd with portals: %s\n", 
1011                         strerror(errno));
1012                 close (fd);
1013                 return -1;
1014         }
1015
1016         printf("Connection to %s registered with socknal\n", argv[1]);
1017
1018         rc = close(fd);
1019         if (rc)
1020                 fprintf(stderr, "close failed: %d\n", rc);
1021
1022         return 0;
1023 #endif /* HAVE_CONNECT */
1024 }
1025
1026 int jt_ptl_disconnect(int argc, char **argv)
1027 {
1028         struct portals_cfg       pcfg;
1029         ptl_nid_t                nid = PTL_NID_ANY;
1030         __u32                    ipaddr = 0;
1031         int                      rc;
1032
1033         if (argc > 3) {
1034                 fprintf(stderr, "usage: %s [nid] [ipaddr]\n", argv[0]);
1035                 return 0;
1036         }
1037
1038         if (!g_nal_is_compatible (NULL, SOCKNAL, RANAL, 
1039                                   OPENIBNAL, IIBNAL, VIBNAL, 0))
1040                 return 0;
1041
1042         if (argc >= 2 &&
1043             ptl_parse_nid (&nid, argv[1]) != 0) {
1044                 fprintf (stderr, "Can't parse nid %s\n", argv[1]);
1045                 return -1;
1046         }
1047
1048         if (g_nal_is_compatible (NULL, SOCKNAL, 0) &&
1049             argc >= 3 &&
1050             ptl_parse_ipaddr (&ipaddr, argv[2]) != 0) {
1051                 fprintf (stderr, "Can't parse ip addr %s\n", argv[2]);
1052                 return -1;
1053         }
1054
1055         PCFG_INIT(pcfg, NAL_CMD_CLOSE_CONNECTION);
1056         pcfg.pcfg_nid     = nid;
1057         pcfg.pcfg_id      = ipaddr;
1058         
1059         rc = pcfg_ioctl(&pcfg);
1060         if (rc) {
1061                 fprintf(stderr, "failed to remove connection: %s\n",
1062                         strerror(errno));
1063                 return -1;
1064         }
1065
1066         return 0;
1067 }
1068
1069 int jt_ptl_push_connection (int argc, char **argv)
1070 {
1071         struct portals_cfg       pcfg;
1072         int                      rc;
1073         ptl_nid_t                nid = PTL_NID_ANY;
1074         __u32                    ipaddr = 0;
1075
1076         if (argc > 3) {
1077                 fprintf(stderr, "usage: %s [nid] [ip]\n", argv[0]);
1078                 return 0;
1079         }
1080
1081         if (!g_nal_is_compatible (argv[0], SOCKNAL, 0))
1082                 return -1;
1083         
1084         if (argc > 1 &&
1085             ptl_parse_nid (&nid, argv[1]) != 0) {
1086                 fprintf(stderr, "Can't parse nid: %s\n", argv[1]);
1087                 return -1;
1088         }
1089                         
1090         if (argc > 2 &&
1091             ptl_parse_ipaddr (&ipaddr, argv[2]) != 0) {
1092                 fprintf(stderr, "Can't parse ipaddr: %s\n", argv[2]);
1093         }
1094
1095         PCFG_INIT(pcfg, NAL_CMD_PUSH_CONNECTION);
1096         pcfg.pcfg_nid     = nid;
1097         pcfg.pcfg_id      = ipaddr;
1098         
1099         rc = pcfg_ioctl(&pcfg);
1100         if (rc) {
1101                 fprintf(stderr, "failed to push connection: %s\n",
1102                         strerror(errno));
1103                 return -1;
1104         }
1105
1106         return 0;
1107 }
1108
1109 int 
1110 jt_ptl_print_active_txs (int argc, char **argv)
1111 {
1112         struct portals_cfg       pcfg;
1113         int                      index;
1114         int                      rc;
1115
1116         if (!g_nal_is_compatible (argv[0], QSWNAL, 0))
1117                 return -1;
1118
1119         for (index = 0;;index++) {
1120                 PCFG_INIT(pcfg, NAL_CMD_GET_TXDESC);
1121                 pcfg.pcfg_count   = index;
1122         
1123                 rc = pcfg_ioctl(&pcfg);
1124                 if (rc != 0)
1125                         break;
1126
1127                 printf ("%p: %5s payload %6d bytes to "LPX64" via "LPX64" by pid %6d: %s, %s, state %d\n",
1128                         pcfg.pcfg_pbuf1,
1129                         pcfg.pcfg_count == PTL_MSG_ACK ? "ACK" :
1130                         pcfg.pcfg_count == PTL_MSG_PUT ? "PUT" :
1131                         pcfg.pcfg_count == PTL_MSG_GET ? "GET" :
1132                         pcfg.pcfg_count == PTL_MSG_REPLY ? "REPLY" : "<wierd message>",
1133                         pcfg.pcfg_size,
1134                         pcfg.pcfg_nid,
1135                         pcfg.pcfg_nid2,
1136                         pcfg.pcfg_misc,
1137                         (pcfg.pcfg_flags & 1) ? "delayed" : "immediate",
1138                         (pcfg.pcfg_flags & 2) ? "nblk"    : "normal",
1139                         pcfg.pcfg_flags >> 2);
1140         }
1141
1142         if (index == 0)
1143                 printf ("<no active descs>\n");
1144         return 0;
1145 }
1146
1147 int jt_ptl_ping(int argc, char **argv)
1148 {
1149         int       rc;
1150         ptl_nid_t nid;
1151         long      count   = 1;
1152         long      size    = 4;
1153         long      timeout = 1;
1154         struct portal_ioctl_data data;
1155
1156         if (argc < 2) {
1157                 fprintf(stderr, "usage: %s nid [count] [size] [timeout (secs)]\n", argv[0]);
1158                 return 0;
1159         }
1160
1161         if (!g_nal_is_set())
1162                 return -1;
1163
1164         if (ptl_parse_nid (&nid, argv[1]) != 0)
1165         {
1166                 fprintf (stderr, "Can't parse nid \"%s\"\n", argv[1]);
1167                 return (-1);
1168         }
1169         
1170         if (argc > 2)
1171         {
1172                 count = atol(argv[2]);
1173
1174                 if (count < 0 || count > 20000) 
1175                 {
1176                         fprintf(stderr, "are you insane?  %ld is a crazy count.\n", count);
1177                         return -1;
1178                 }
1179         }
1180         
1181         if (argc > 3)
1182                 size= atol(argv[3]);
1183
1184         if (argc > 4)
1185                 timeout = atol (argv[4]);
1186         
1187         PORTAL_IOC_INIT (data);
1188         data.ioc_count   = count;
1189         data.ioc_size    = size;
1190         data.ioc_nid     = nid;
1191         data.ioc_nal     = g_nal;
1192         data.ioc_timeout = timeout;
1193         
1194         rc = l_ioctl(PORTALS_DEV_ID, IOC_PORTAL_PING, &data);
1195         if (rc) {
1196                 fprintf(stderr, "failed to start pinger: %s\n",
1197                         strerror(errno));
1198                 return -1;
1199         }
1200         return 0;
1201 }
1202
1203 int jt_ptl_shownid(int argc, char **argv)
1204 {
1205         struct portal_ioctl_data data;
1206         int                      rc;
1207         
1208         if (argc > 1) {
1209                 fprintf(stderr, "usage: %s\n", argv[0]);
1210                 return 0;
1211         }
1212         
1213         if (!g_nal_is_set())
1214                 return -1;
1215
1216         PORTAL_IOC_INIT (data);
1217         data.ioc_nal = g_nal;
1218         rc = l_ioctl(PORTALS_DEV_ID, IOC_PORTAL_GET_NID, &data);
1219         if (rc < 0)
1220                 fprintf(stderr, "getting my NID failed: %s\n",
1221                         strerror (errno));
1222         else
1223                 printf(LPX64"\n", data.ioc_nid);
1224         return 0;
1225 }
1226
1227 int jt_ptl_mynid(int argc, char **argv)
1228 {
1229         int rc;
1230         char hostname[1024];
1231         char *nidstr;
1232         struct portals_cfg pcfg;
1233         ptl_nid_t mynid;
1234
1235         if (argc > 2) {
1236                 fprintf(stderr, "usage: %s [NID]\n", argv[0]);
1237                 fprintf(stderr, "NID defaults to the primary IP address of the machine.\n");
1238                 return 0;
1239         }
1240
1241         if (!g_nal_is_set())
1242                 return -1;
1243
1244         if (argc >= 2)
1245                 nidstr = argv[1];
1246         else if (gethostname(hostname, sizeof(hostname)) != 0) {
1247                 fprintf(stderr, "gethostname failed: %s\n",
1248                         strerror(errno));
1249                 return -1;
1250         }
1251         else
1252                 nidstr = hostname;
1253
1254         rc = ptl_parse_nid (&mynid, nidstr);
1255         if (rc != 0) {
1256                 fprintf (stderr, "Can't convert '%s' into a NID\n", nidstr);
1257                 return -1;
1258         }
1259         
1260         PCFG_INIT(pcfg, NAL_CMD_REGISTER_MYNID);
1261         pcfg.pcfg_nid = mynid;
1262
1263         rc = pcfg_ioctl(&pcfg);
1264         if (rc < 0)
1265                 fprintf(stderr, "setting my NID failed: %s\n",
1266                        strerror(errno));
1267         else
1268                 printf("registered my nid "LPX64" (%s)\n", 
1269                        ptl_nid2u64(mynid), hostname);
1270         return 0;
1271 }
1272
1273 int
1274 jt_ptl_fail_nid (int argc, char **argv)
1275 {
1276         int                      rc;
1277         ptl_nid_t                nid;
1278         unsigned int             threshold;
1279         struct portal_ioctl_data data;
1280
1281         if (argc < 2 || argc > 3)
1282         {
1283                 fprintf (stderr, "usage: %s nid|\"_all_\" [count (0 == mend)]\n", argv[0]);
1284                 return (0);
1285         }
1286         
1287         if (!g_nal_is_set())
1288                 return (-1);
1289
1290         if (!strcmp (argv[1], "_all_"))
1291                 nid = PTL_NID_ANY;
1292         else if (ptl_parse_nid (&nid, argv[1]) != 0)
1293         {
1294                 fprintf (stderr, "Can't parse nid \"%s\"\n", argv[1]);
1295                 return (-1);
1296         }
1297
1298         if (argc < 3)
1299                 threshold = PTL_MD_THRESH_INF;
1300         else if (sscanf (argv[2], "%i", &threshold) != 1) {
1301                 fprintf (stderr, "Can't parse count \"%s\"\n", argv[2]);
1302                 return (-1);
1303         }
1304         
1305         PORTAL_IOC_INIT (data);
1306         data.ioc_nal = g_nal;
1307         data.ioc_nid = nid;
1308         data.ioc_count = threshold;
1309         
1310         rc = l_ioctl (PORTALS_DEV_ID, IOC_PORTAL_FAIL_NID, &data);
1311         if (rc < 0)
1312                 fprintf (stderr, "IOC_PORTAL_FAIL_NID failed: %s\n",
1313                          strerror (errno));
1314         else
1315                 printf ("%s %s\n", threshold == 0 ? "Unfailing" : "Failing", argv[1]);
1316         
1317         return (0);
1318 }
1319
1320 int
1321 jt_ptl_add_route (int argc, char **argv)
1322 {
1323         struct portals_cfg       pcfg;
1324         ptl_nid_t                nid1;
1325         ptl_nid_t                nid2;
1326         ptl_nid_t                gateway_nid;
1327         int                      rc;
1328         
1329         if (argc < 3)
1330         {
1331                 fprintf (stderr, "usage: %s gateway target [target]\n", argv[0]);
1332                 return (0);
1333         }
1334
1335         if (!g_nal_is_set())
1336                 return (-1);
1337
1338         if (ptl_parse_nid (&gateway_nid, argv[1]) != 0)
1339         {
1340                 fprintf (stderr, "Can't parse gateway NID \"%s\"\n", argv[1]);
1341                 return (-1);
1342         }
1343
1344         if (ptl_parse_nid (&nid1, argv[2]) != 0)
1345         {
1346                 fprintf (stderr, "Can't parse first target NID \"%s\"\n", argv[2]);
1347                 return (-1);
1348         }
1349
1350         if (argc < 4)
1351                 nid2 = nid1;
1352         else if (ptl_parse_nid (&nid2, argv[3]) != 0)
1353         {
1354                 fprintf (stderr, "Can't parse second target NID \"%s\"\n", argv[4]);
1355                 return (-1);
1356         }
1357
1358         PCFG_INIT(pcfg, NAL_CMD_ADD_ROUTE);
1359         pcfg.pcfg_nid = gateway_nid;
1360         pcfg.pcfg_nal = ROUTER;
1361         pcfg.pcfg_gw_nal = g_nal;
1362         pcfg.pcfg_nid2 = MIN (nid1, nid2);
1363         pcfg.pcfg_nid3 = MAX (nid1, nid2);
1364
1365         rc = pcfg_ioctl(&pcfg);
1366         if (rc != 0) 
1367         {
1368                 fprintf (stderr, "NAL_CMD_ADD_ROUTE failed: %s\n", strerror (errno));
1369                 return (-1);
1370         }
1371         
1372         return (0);
1373 }
1374
1375 int
1376 jt_ptl_del_route (int argc, char **argv)
1377 {
1378         struct portals_cfg       pcfg;
1379         ptl_nid_t                nid;
1380         ptl_nid_t                nid1 = PTL_NID_ANY;
1381         ptl_nid_t                nid2 = PTL_NID_ANY;
1382         int                      rc;
1383         
1384         if (argc < 2)
1385         {
1386                 fprintf (stderr, "usage: %s targetNID\n", argv[0]);
1387                 return (0);
1388         }
1389
1390         if (!g_nal_is_set())
1391                 return (-1);
1392
1393         if (ptl_parse_nid (&nid, argv[1]) != 0)
1394         {
1395                 fprintf (stderr, "Can't parse gateway NID \"%s\"\n", argv[1]);
1396                 return (-1);
1397         }
1398
1399         if (argc >= 3 &&
1400             ptl_parse_nid (&nid1, argv[2]) != 0)
1401         {
1402                 fprintf (stderr, "Can't parse target NID \"%s\"\n", argv[2]);
1403                 return (-1);
1404         }
1405
1406         if (argc < 4) {
1407                 nid2 = nid1;
1408         } else {
1409                 if (ptl_parse_nid (&nid2, argv[3]) != 0) {
1410                         fprintf (stderr, "Can't parse target NID \"%s\"\n", argv[3]);
1411                         return (-1);
1412                 }
1413
1414                 if (nid1 > nid2) {
1415                         ptl_nid_t tmp = nid1;
1416                         
1417                         nid1 = nid2;
1418                         nid2 = tmp;
1419                 }
1420         }
1421         
1422         PCFG_INIT(pcfg, NAL_CMD_DEL_ROUTE);
1423         pcfg.pcfg_nal = ROUTER;
1424         pcfg.pcfg_gw_nal = g_nal;
1425         pcfg.pcfg_nid = nid;
1426         pcfg.pcfg_nid2 = nid1;
1427         pcfg.pcfg_nid3 = nid2;
1428
1429         rc = pcfg_ioctl(&pcfg);
1430         if (rc != 0) 
1431         {
1432                 fprintf (stderr, "NAL_CMD_DEL_ROUTE ("LPX64") failed: %s\n", 
1433                          ptl_nid2u64(nid), strerror (errno));
1434                 return (-1);
1435         }
1436         
1437         return (0);
1438 }
1439
1440 int
1441 jt_ptl_notify_router (int argc, char **argv)
1442 {
1443         struct portals_cfg       pcfg;
1444         int                      enable;
1445         ptl_nid_t                nid;
1446         int                      rc;
1447         struct timeval           now;
1448         time_t                   when;
1449
1450         if (argc < 3)
1451         {
1452                 fprintf (stderr, "usage: %s targetNID <up/down> [<time>]\n", 
1453                          argv[0]);
1454                 return (0);
1455         }
1456
1457         if (ptl_parse_nid (&nid, argv[1]) != 0)
1458         {
1459                 fprintf (stderr, "Can't parse target NID \"%s\"\n", argv[1]);
1460                 return (-1);
1461         }
1462
1463         if (ptl_parse_bool (&enable, argv[2]) != 0) {
1464                 fprintf (stderr, "Can't parse boolean %s\n", argv[2]);
1465                 return (-1);
1466         }
1467
1468         gettimeofday(&now, NULL);
1469         
1470         if (argc < 4) {
1471                 when = now.tv_sec;
1472         } else if (ptl_parse_time (&when, argv[3]) != 0) {
1473                 fprintf(stderr, "Can't parse time %s\n"
1474                         "Please specify either 'YYYY-MM-DD-HH:MM:SS'\n"
1475                         "or an absolute unix time in seconds\n", argv[3]);
1476                 return (-1);
1477         } else if (when > now.tv_sec) {
1478                 fprintf (stderr, "%s specifies a time in the future\n",
1479                          argv[3]);
1480                 return (-1);
1481         }
1482
1483         PCFG_INIT(pcfg, NAL_CMD_NOTIFY_ROUTER);
1484         pcfg.pcfg_nal = ROUTER;
1485         pcfg.pcfg_gw_nal = g_nal;
1486         pcfg.pcfg_nid = nid;
1487         pcfg.pcfg_flags = enable;
1488         /* Yeuch; 'cept I need a __u64 on 64 bit machines... */
1489         pcfg.pcfg_nid3 = (__u64)when;
1490         
1491         rc = pcfg_ioctl(&pcfg);
1492         if (rc != 0) 
1493         {
1494                 fprintf (stderr, "NAL_CMD_NOTIFY_ROUTER ("LPX64") failed: %s\n",
1495                          ptl_nid2u64(nid), strerror (errno));
1496                 return (-1);
1497         }
1498         
1499         return (0);
1500 }
1501
1502 int
1503 jt_ptl_print_routes (int argc, char **argv)
1504 {
1505         char                      buffer[3][128];
1506         struct portals_cfg        pcfg;
1507         int                       rc;
1508         int                       index;
1509         int                       gateway_nal;
1510         ptl_nid_t                 gateway_nid;
1511         ptl_nid_t                 nid1;
1512         ptl_nid_t                 nid2;
1513         int                       alive;
1514
1515         for (index = 0;;index++)
1516         {
1517                 PCFG_INIT(pcfg, NAL_CMD_GET_ROUTE);
1518                 pcfg.pcfg_nal = ROUTER;
1519                 pcfg.pcfg_count = index;
1520                 
1521                 rc = pcfg_ioctl(&pcfg);
1522                 if (rc != 0)
1523                         break;
1524
1525                 gateway_nal = pcfg.pcfg_gw_nal;
1526                 gateway_nid = pcfg.pcfg_nid;
1527                 nid1 = pcfg.pcfg_nid2;
1528                 nid2 = pcfg.pcfg_nid3;
1529                 alive = pcfg.pcfg_flags;
1530
1531                 printf ("%8s %18s : %s - %s, %s\n", 
1532                         nal2name (gateway_nal), 
1533                         ptl_nid2str (buffer[0], gateway_nid),
1534                         ptl_nid2str (buffer[1], nid1),
1535                         ptl_nid2str (buffer[2], nid2),
1536                         alive ? "up" : "down");
1537         }
1538         return (0);
1539 }
1540
1541 static int
1542 lwt_control(int enable, int clear)
1543 {
1544         struct portal_ioctl_data data;
1545         int                      rc;
1546
1547         PORTAL_IOC_INIT(data);
1548         data.ioc_flags = enable;
1549         data.ioc_misc = clear;
1550
1551         rc = l_ioctl(PORTALS_DEV_ID, IOC_PORTAL_LWT_CONTROL, &data);
1552         if (rc == 0)
1553                 return (0);
1554
1555         fprintf(stderr, "IOC_PORTAL_LWT_CONTROL failed: %s\n",
1556                 strerror(errno));
1557         return (-1);
1558 }
1559
1560 static int
1561 lwt_snapshot(cycles_t *now, int *ncpu, int *totalsize, 
1562              lwt_event_t *events, int size)
1563 {
1564         struct portal_ioctl_data data;
1565         int                      rc;
1566
1567         PORTAL_IOC_INIT(data);
1568         data.ioc_pbuf1 = (char *)events;
1569         data.ioc_plen1 = size;
1570
1571         rc = l_ioctl(PORTALS_DEV_ID, IOC_PORTAL_LWT_SNAPSHOT, &data);
1572         if (rc != 0) {
1573                 fprintf(stderr, "IOC_PORTAL_LWT_SNAPSHOT failed: %s\n",
1574                         strerror(errno));
1575                 return (-1);
1576         }
1577
1578         /* crappy overloads */
1579         if (data.ioc_nid2 != sizeof(lwt_event_t) ||
1580             data.ioc_nid3 != offsetof(lwt_event_t, lwte_where)) {
1581                 fprintf(stderr,"kernel/user LWT event mismatch %d(%d),%d(%d)\n",
1582                         (int)data.ioc_nid2, sizeof(lwt_event_t),
1583                         (int)data.ioc_nid3,
1584                         (int)offsetof(lwt_event_t, lwte_where));
1585                 return (-1);
1586         }
1587
1588         LASSERT (data.ioc_count != 0);
1589         LASSERT (data.ioc_misc != 0);
1590
1591         if (now != NULL)
1592                 *now = data.ioc_nid;
1593
1594         if (ncpu != NULL)
1595                 *ncpu = data.ioc_count;
1596
1597         if (totalsize != NULL)
1598                 *totalsize = data.ioc_misc;
1599
1600         return (0);
1601 }
1602
1603 static char *
1604 lwt_get_string(char *kstr)
1605 {
1606         char                     *ustr;
1607         struct portal_ioctl_data  data;
1608         int                       size;
1609         int                       rc;
1610
1611         /* FIXME: this could maintain a symbol table since we expect to be
1612          * looking up the same strings all the time... */
1613
1614         PORTAL_IOC_INIT(data);
1615         data.ioc_pbuf1 = kstr;
1616         data.ioc_plen1 = 1;        /* non-zero just to fool portal_ioctl_is_invalid() */
1617         data.ioc_pbuf2 = NULL;
1618         data.ioc_plen2 = 0;
1619
1620         rc = l_ioctl(PORTALS_DEV_ID, IOC_PORTAL_LWT_LOOKUP_STRING, &data);
1621         if (rc != 0) {
1622                 fprintf(stderr, "IOC_PORTAL_LWT_LOOKUP_STRING failed: %s\n",
1623                         strerror(errno));
1624                 return (NULL);
1625         }
1626
1627         size = data.ioc_count;
1628         ustr = (char *)malloc(size);
1629         if (ustr == NULL) {
1630                 fprintf(stderr, "Can't allocate string storage of size %d\n",
1631                         size);
1632                 return (NULL);
1633         }
1634
1635         PORTAL_IOC_INIT(data);
1636         data.ioc_pbuf1 = kstr;
1637         data.ioc_plen1 = 1;        /* non-zero just to fool portal_ioctl_is_invalid() */
1638         data.ioc_pbuf2 = ustr;
1639         data.ioc_plen2 = size;
1640
1641         rc = l_ioctl(PORTALS_DEV_ID, IOC_PORTAL_LWT_LOOKUP_STRING, &data);
1642         if (rc != 0) {
1643                 fprintf(stderr, "IOC_PORTAL_LWT_LOOKUP_STRING failed: %s\n",
1644                         strerror(errno));
1645                 return (NULL);
1646         }
1647
1648         LASSERT(strlen(ustr) == size - 1);
1649         return (ustr);
1650 }
1651
1652 static void
1653 lwt_put_string(char *ustr)
1654 {
1655         free(ustr);
1656 }
1657
1658 static int
1659 lwt_print(FILE *f, cycles_t t0, cycles_t tlast, double mhz, int cpu, lwt_event_t *e)
1660 {
1661 #ifndef __WORDSIZE
1662 # error "__WORDSIZE not defined"
1663 #elif __WORDSIZE == 32
1664 # define XFMT "%#010lx"
1665 #elif __WORDSIZE== 64
1666 # define XFMT "%#018lx"
1667 #else
1668 # error "Unexpected __WORDSIZE"
1669 #endif
1670         char           *where = lwt_get_string(e->lwte_where);
1671
1672         if (where == NULL)
1673                 return (-1);
1674
1675         fprintf(f, XFMT" "XFMT" "XFMT" "XFMT": "XFMT" %2d %10.6f %10.2f %s\n",
1676                 e->lwte_p1, e->lwte_p2, e->lwte_p3, e->lwte_p4,
1677                 (long)e->lwte_task, cpu, (e->lwte_when - t0) / (mhz * 1000000.0),
1678                 (t0 == e->lwte_when) ? 0.0 : (e->lwte_when - tlast) / mhz,
1679                 where);
1680
1681         lwt_put_string(where);
1682
1683         return (0);
1684 #undef XFMT
1685 }
1686
1687 double
1688 get_cycles_per_usec ()
1689 {
1690         FILE      *f = fopen ("/proc/cpuinfo", "r");
1691         double     mhz;
1692         char      line[64];
1693         
1694         if (f != NULL) {
1695                 while (fgets (line, sizeof (line), f) != NULL)
1696                         if (sscanf (line, "cpu MHz : %lf", &mhz) == 1) {
1697                                 fclose (f);
1698                                 return (mhz);
1699                         }
1700                 fclose (f);
1701         }
1702
1703         fprintf (stderr, "Can't read/parse /proc/cpuinfo\n");
1704         return (1000.0);
1705 }
1706
1707 int
1708 jt_ptl_lwt(int argc, char **argv)
1709 {
1710         const int       lwt_max_cpus = 32;
1711         int             ncpus;
1712         int             totalspace;
1713         int             nevents_per_cpu;
1714         lwt_event_t    *events;
1715         lwt_event_t    *cpu_event[lwt_max_cpus + 1];
1716         lwt_event_t    *next_event[lwt_max_cpus];
1717         lwt_event_t    *first_event[lwt_max_cpus];
1718         int             cpu;
1719         lwt_event_t    *e;
1720         int             rc;
1721         int             i;
1722         double          mhz;
1723         cycles_t        t0;
1724         cycles_t        tlast;
1725         cycles_t        tnow;
1726         struct timeval  tvnow;
1727         int             printed_date = 0;
1728         int             nlines = 0;
1729         FILE           *f = stdout;
1730
1731         if (argc < 2 ||
1732             (strcmp(argv[1], "start") &&
1733              strcmp(argv[1], "stop"))) {
1734                 fprintf(stderr, 
1735                         "usage:  %s start\n"
1736                         "        %s stop [fname]\n", argv[0], argv[0]);
1737                 return (-1);
1738         }
1739         
1740         if (!strcmp(argv[1], "start")) {
1741                 /* disable */
1742                 if (lwt_control(0, 0) != 0)
1743                         return (-1);
1744
1745                 /* clear */
1746                 if (lwt_control(0, 1) != 0)
1747                         return (-1);
1748
1749                 /* enable */
1750                 if (lwt_control(1, 0) != 0)
1751                         return (-1);
1752
1753                 return (0);
1754         }
1755                 
1756         if (lwt_snapshot(NULL, &ncpus, &totalspace, NULL, 0) != 0)
1757                 return (-1);
1758
1759         if (ncpus > lwt_max_cpus) {
1760                 fprintf(stderr, "Too many cpus: %d (%d)\n", 
1761                         ncpus, lwt_max_cpus);
1762                 return (-1);
1763         }
1764
1765         events = (lwt_event_t *)malloc(totalspace);
1766         if (events == NULL) {
1767                 fprintf(stderr, "Can't allocate %d\n", totalspace);
1768                 return (-1);
1769         }
1770
1771         if (lwt_control(0, 0) != 0) {           /* disable */
1772                 free(events);
1773                 return (-1);
1774         }
1775
1776         if (lwt_snapshot(&tnow, NULL, NULL, events, totalspace)) {
1777                 free(events);
1778                 return (-1);
1779         }
1780
1781         /* we want this time to be sampled at snapshot time */
1782         gettimeofday(&tvnow, NULL);
1783
1784         if (argc > 2) {
1785                 f = fopen (argv[2], "w");
1786                 if (f == NULL) {
1787                         fprintf(stderr, "Can't open %s for writing: %s\n", argv[2], strerror (errno));
1788                         free(events);
1789                         return (-1);
1790                 }
1791         }
1792
1793         mhz = get_cycles_per_usec();
1794         
1795         /* carve events into per-cpu slices */
1796         nevents_per_cpu = totalspace / (ncpus * sizeof(lwt_event_t));
1797         for (cpu = 0; cpu <= ncpus; cpu++)
1798                 cpu_event[cpu] = &events[cpu * nevents_per_cpu];
1799
1800         /* find the earliest event on each cpu */
1801         for (cpu = 0; cpu < ncpus; cpu++) {
1802                 first_event[cpu] = NULL;
1803
1804                 for (e = cpu_event[cpu]; e < cpu_event[cpu + 1]; e++) {
1805
1806                         if (e->lwte_where == NULL) /* not an event */
1807                                 continue;
1808
1809                         if (first_event[cpu] == NULL ||
1810                             first_event[cpu]->lwte_when > e->lwte_when)
1811                                 first_event[cpu] = e;
1812                 }
1813
1814                 next_event[cpu] = first_event[cpu];
1815         }
1816
1817         t0 = tlast = 0;
1818         for (cpu = 0; cpu < ncpus; cpu++) {
1819                 e = first_event[cpu];
1820                 if (e == NULL)                  /* no events this cpu */
1821                         continue;
1822                 
1823                 if (e == cpu_event[cpu])
1824                         e = cpu_event[cpu + 1] - 1;
1825                 else 
1826                         e = e - 1;
1827                 
1828                 /* If there's an event immediately before the first one, this
1829                  * cpu wrapped its event buffer */
1830                 if (e->lwte_where == NULL)
1831                         continue;
1832          
1833                 /* We should only start outputting events from the most recent
1834                  * first event in any wrapped cpu.  Events before this time on
1835                  * other cpus won't have any events from this CPU to interleave
1836                  * with. */
1837                 if (t0 < first_event[cpu]->lwte_when)
1838                         t0 = first_event[cpu]->lwte_when;
1839         }
1840
1841         for (;;) {
1842                 /* find which cpu has the next event */
1843                 cpu = -1;
1844                 for (i = 0; i < ncpus; i++) {
1845
1846                         if (next_event[i] == NULL) /* this cpu exhausted */
1847                                 continue;
1848
1849                         if (cpu < 0 ||
1850                             next_event[i]->lwte_when < next_event[cpu]->lwte_when)
1851                                 cpu = i;
1852                 }
1853
1854                 if (cpu < 0)                    /* all cpus exhausted */
1855                         break;
1856
1857                 if (t0 == 0) {
1858                         /* no wrapped cpus and this is he first ever event */
1859                         t0 = next_event[cpu]->lwte_when;
1860                 }
1861                 
1862                 if (t0 <= next_event[cpu]->lwte_when) {
1863                         /* on or after the first event */
1864                         if (!printed_date) {
1865                                 cycles_t du = (tnow - t0) / mhz;
1866                                 time_t   then = tvnow.tv_sec - du/1000000;
1867                                 
1868                                 if (du % 1000000 > tvnow.tv_usec)
1869                                         then--;
1870
1871                                 fprintf(f, "%s", ctime(&then));
1872                                 printed_date = 1;
1873                         }
1874                         
1875                         rc = lwt_print(f, t0, tlast, mhz, cpu, next_event[cpu]);
1876                         if (rc != 0)
1877                                 break;
1878
1879                         if (++nlines % 10000 == 0 && f != stdout) {
1880                                 /* show some activity... */
1881                                 printf(".");
1882                                 fflush (stdout);
1883                         }
1884                 }
1885
1886                 tlast = next_event[cpu]->lwte_when;
1887                 
1888                 next_event[cpu]++;
1889                 if (next_event[cpu] == cpu_event[cpu + 1])
1890                         next_event[cpu] = cpu_event[cpu];
1891
1892                 if (next_event[cpu]->lwte_where == NULL ||
1893                     next_event[cpu] == first_event[cpu])
1894                         next_event[cpu] = NULL;
1895         }
1896
1897         if (f != stdout) {
1898                 printf("\n");
1899                 fclose(f);
1900         }
1901
1902         free(events);
1903         return (0);
1904 }
1905
1906 int jt_ptl_memhog(int argc, char **argv)
1907 {
1908         static int                gfp = 0;        /* sticky! */
1909
1910         struct portal_ioctl_data  data;
1911         int                       rc;
1912         int                       count;
1913         char                     *end;
1914         
1915         if (argc < 2)  {
1916                 fprintf(stderr, "usage: %s <npages> [<GFP flags>]\n", argv[0]);
1917                 return 0;
1918         }
1919
1920         count = strtol(argv[1], &end, 0);
1921         if (count < 0 || *end != 0) {
1922                 fprintf(stderr, "Can't parse page count '%s'\n", argv[1]);
1923                 return -1;
1924         }
1925
1926         if (argc >= 3) {
1927                 rc = strtol(argv[2], &end, 0);
1928                 if (*end != 0) {
1929                         fprintf(stderr, "Can't parse gfp flags '%s'\n", argv[2]);
1930                         return -1;
1931                 }
1932                 gfp = rc;
1933         }
1934         
1935         PORTAL_IOC_INIT(data);
1936         data.ioc_count = count;
1937         data.ioc_flags = gfp;
1938         rc = l_ioctl(PORTALS_DEV_ID, IOC_PORTAL_MEMHOG, &data);
1939
1940         if (rc != 0) {
1941                 fprintf(stderr, "memhog %d failed: %s\n", count, strerror(errno));
1942                 return -1;
1943         }
1944         
1945         printf("memhog %d OK\n", count);
1946         return 0;
1947 }
1948