lnet/utils/portals.c

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