lnet/utils/portals.c

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