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