lnet/utils/portals.c

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