lustre/utils/obdctl.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (C) 2002 Cluster File Systems, Inc.
   5  *   Author: Peter J. Braam <braam@clusterfs.com>
   6  *   Author: Phil Schwan <phil@clusterfs.com>
   7  *
   8  *   This file is part of Lustre, http://www.lustre.org.
   9  *
  10  *   Lustre is free software; you can redistribute it and/or
  11  *   modify it under the terms of version 2 of the GNU General Public
  12  *   License as published by the Free Software Foundation.
  13  *
  14  *   Lustre is distributed in the hope that it will be useful,
  15  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *   GNU General Public License for more details.
  18  *
  19  *   You should have received a copy of the GNU General Public License
  20  *   along with Lustre; if not, write to the Free Software
  21  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  *
  23  */
  24
  25
  26 #include <stdlib.h>
  27 #include <sys/ioctl.h>
  28 #include <fcntl.h>
  29 #include <sys/socket.h>
  30 #include <sys/types.h>
  31 #include <sys/wait.h>
  32 #include <sys/stat.h>
  33 #include <stdio.h>
  34 #include <stdarg.h>
  35 #include <signal.h>
  36 #define printk printf
  37
  38 #include <linux/lustre_lib.h>
  39 #include <linux/lustre_idl.h>
  40 #include <linux/lustre_dlm.h>
  41
  42 #include <libxml/xmlmemory.h>
  43 #include <libxml/parser.h>
  44
  45 #include <unistd.h>
  46 #include <sys/un.h>
  47 #include <time.h>
  48 #include <sys/time.h>
  49 #include <netinet/in.h>
  50 #include <errno.h>
  51 #include <string.h>
  52
  53 #define __KERNEL__
  54 #include <linux/list.h>
  55 #undef __KERNEL__
  56
  57 #include "parser.h"
  58 #include <stdio.h>
  59
  60 static int jt_newdev(int argc, char **argv);
  61 static int jt_attach(int argc, char **argv);
  62 static int jt_setup(int argc, char **argv);
  63
  64
  65 int fd = -1;
  66 int connid = -1;
  67 char rawbuf[8192];
  68 char *buf = rawbuf;
  69 int max = 8192;
  70 int thread;
  71 int rc = 0;
  72
  73 #define IOCINIT(data)                                                   \
  74 do {                                                                    \
  75         memset(&data, 0, sizeof(data));                                 \
  76         data.ioc_version = OBD_IOCTL_VERSION;                           \
  77         data.ioc_conn1 = connid;                                        \
  78         data.ioc_len = sizeof(data);                                    \
  79         if (fd < 0) {                                                   \
  80                 fprintf(stderr, "No device open, use device\n");        \
  81                 return 1;                                               \
  82         }                                                               \
  83 } while (0)
  84
  85 /*
  86     pack "LL LL LL LL LL LL LL L L L L L L L L L a60 a60 L L L",
  87     $obdo->{id}, 0,
  88     $obdo->{gr}, 0,
  89     $obdo->{atime}, 0,
  90     $obdo->{mtime}, 0 ,
  91     $obdo->{ctime}, 0,
  92     $obdo->{size}, 0,
  93     $obdo->{blocks}, 0,
  94     $obdo->{blksize},
  95     $obdo->{mode},
  96     $obdo->{uid},
  97     $obdo->{gid},
  98     $obdo->{flags},
  99     $obdo->{obdflags},
 100     $obdo->{nlink},
 101     $obdo->{generation},
 102     $obdo->{valid},
 103     $obdo->{inline},
 104     $obdo->{obdmd},
 105     0, 0, # struct list_head
 106     0;  #  struct obd_ops
 107 }
 108
 109 */
 110
 111 char * obdo_print(struct obdo *obd)
 112 {
 113         char buf[1024];
 114
 115         sprintf(buf, "id: %Ld\ngrp: %Ld\natime: %Ld\nmtime: %Ld\nctime: %Ld\n"
 116                 "size: %Ld\nblocks: %Ld\nblksize: %d\nmode: %o\nuid: %d\n"
 117                 "gid: %d\nflags: %x\nobdflags: %x\nnlink: %d,\nvalid %x\n",
 118                 obd->o_id,
 119                 obd->o_gr,
 120                 obd->o_atime,
 121                 obd->o_mtime,
 122                 obd->o_ctime,
 123                 obd->o_size,
 124                 obd->o_blocks,
 125                 obd->o_blksize,
 126                 obd->o_mode,
 127                 obd->o_uid,
 128                 obd->o_gid,
 129                 obd->o_flags,
 130                 obd->o_obdflags,
 131                 obd->o_nlink,
 132                 obd->o_valid);
 133         return strdup(buf);
 134 }
 135
 136 static char *cmdname(char *func)
 137 {
 138         static char buf[512];
 139
 140         if (thread) {
 141                 sprintf(buf, "%s-%d", func, thread);
 142                 return buf;
 143         }
 144
 145         return func;
 146 }
 147
 148 int getfd(char *func)
 149 {
 150         if (fd == -1)
 151                 fd = open("/dev/obd", O_RDWR);
 152         if (fd == -1) {
 153                 fprintf(stderr, "error: %s: opening /dev/obd: %s\n",
 154                         cmdname(func), strerror(errno));
 155                 return -1;
 156         }
 157         return 0;
 158 }
 159
 160 #if 1
 161 #define difftime(a, b)                                          \
 162         ((double)(a)->tv_sec - (b)->tv_sec +                    \
 163          ((double)((a)->tv_usec - (b)->tv_usec) / 1000000))
 164 #else
 165
 166 #define difftime(a, b)  (((a)->tv_sec - (b)->tv_sec) + \
 167                         (((a)->tv_usec - (b)->tv_usec) / 1000000))
 168 #endif
 169
 170 static int be_verbose(int verbose, struct timeval *next_time,
 171                       int num, int *next_num, int num_total)
 172 {
 173         struct timeval now;
 174
 175         if (!verbose)
 176                 return 0;
 177
 178         if (next_time != NULL)
 179                 gettimeofday(&now, NULL);
 180
 181         /* A positive verbosity means to print every X iterations */
 182         if (verbose > 0 &&
 183             (next_num == NULL || num >= *next_num || num >= num_total)) {
 184                 *next_num += verbose;
 185                 if (next_time) {
 186                         next_time->tv_sec = now.tv_sec - verbose;
 187                         next_time->tv_usec = now.tv_usec;
 188                 }
 189                 return 1;
 190         }
 191
 192         /* A negative verbosity means to print at most each X seconds */
 193         if (verbose < 0 && next_time != NULL && difftime(&now, next_time) >= 0){
 194                 next_time->tv_sec = now.tv_sec - verbose;
 195                 next_time->tv_usec = now.tv_usec;
 196                 if (next_num)
 197                         *next_num = num;
 198                 return 1;
 199         }
 200
 201         return 0;
 202 }
 203
 204 static int get_verbose(const char *arg)
 205 {
 206         int verbose;
 207
 208         if (!arg || arg[0] == 'v')
 209                 verbose = 1;
 210         else if (arg[0] == 's' || arg[0] == 'q')
 211                 verbose = 0;
 212         else
 213                 verbose = (int) strtoul(arg, NULL, 0);
 214
 215         if (verbose < 0)
 216                 printf("Print status every %d seconds\n", -verbose);
 217         else if (verbose == 1)
 218                 printf("Print status every operation\n");
 219         else if (verbose > 1)
 220                 printf("Print status every %d operations\n", verbose);
 221
 222         return verbose;
 223 }
 224
 225 static int do_disconnect(char *func, int verbose)
 226 {
 227         struct obd_ioctl_data data;
 228
 229         if (connid == -1)
 230                 return 0;
 231
 232         IOCINIT(data);
 233
 234         rc = ioctl(fd, OBD_IOC_DISCONNECT , &data);
 235         if (rc < 0) {
 236                 fprintf(stderr, "error: %s: %x %s\n", cmdname(func),
 237                         OBD_IOC_DISCONNECT, strerror(errno));
 238         } else {
 239                 if (verbose)
 240                         printf("%s: disconnected connid %d\n", cmdname(func),
 241                                connid);
 242                 connid = -1;
 243         }
 244
 245         return rc;
 246 }
 247
 248 extern command_t cmdlist[];
 249
 250 static int xml_command(char *cmd, ...) {
 251         va_list args;
 252         char *arg, *cmds[8];
 253         int i = 1, j;
 254
 255         cmds[0] = cmd;
 256         va_start(args, cmd);
 257
 258         while (((arg = va_arg(args, char *)) != NULL) && (i < 8)) {
 259                 cmds[i] = arg;
 260                 i++;
 261         }
 262
 263         va_end(args);
 264
 265         printf("obdctl > ");
 266         for (j = 0; j < i; j++)
 267           printf("%s ", cmds[j]);
 268
 269         printf("\n");
 270
 271         return Parser_execarg(i, cmds, cmdlist);
 272 }
 273
 274 static network_t *xml_network(xmlDocPtr doc, xmlNodePtr root) {
 275         xmlNodePtr cur = root->xmlChildrenNode;
 276         network_t *net;
 277
 278         if ((net = (network_t *)calloc(1, sizeof(network_t))) == NULL) {
 279                 printf("error: unable to malloc network_t\n");
 280                 return NULL;
 281         }
 282
 283         net->type = xmlGetProp(root, "type");
 284         if (net->type == NULL) {
 285                 printf("error: type attrib required (tcp, elan, myrinet)\n");
 286                 free(net);
 287                 return NULL;
 288         }
 289
 290         while (cur != NULL) {
 291                 if (!xmlStrcmp(cur->name, "server"))
 292                         net->server = xmlNodeGetContent(cur);
 293
 294                 if (!xmlStrcmp(cur->name, "port"))
 295                         net->port = atoi(xmlNodeGetContent(cur));
 296
 297                 cur = cur->next;
 298         }
 299
 300         if (net->server == NULL) {
 301                 printf("error: <server> tag required\n");
 302                 free(net);
 303                 return NULL;
 304         }
 305
 306         return net;
 307 }
 308
 309 static int xml_mds(xmlDocPtr doc, xmlNodePtr root,
 310                    char *serv_id, char *serv_uuid) {
 311         xmlNodePtr cur = root->xmlChildrenNode;
 312         char *fstype = NULL, *device = NULL;
 313         int rc;
 314
 315         printf("--- Setting up MDS ---\n");
 316         while (cur != NULL) {
 317                 if (!xmlStrcmp(cur->name, "fstype"))
 318                         fstype = xmlNodeGetContent(cur);
 319
 320                 if (!xmlStrcmp(cur->name, "device"))
 321                         device = xmlNodeGetContent(cur);
 322
 323                 cur = cur->next;
 324         }
 325
 326         if ((fstype == NULL) || (device == NULL)) {
 327                 printf("error: <fstype> and <device> tags required\n");
 328                 return -1;
 329         }
 330
 331         if ((rc = xml_command("newdev", NULL)) != 0)
 332                 return rc;
 333
 334         if ((rc = xml_command("attach", "mds", "MDSDEV", NULL)) != 0)
 335                 return rc;
 336
 337         if ((rc = xml_command("setup", device, fstype, NULL)) != 0)
 338                 return rc;
 339
 340         return 0;
 341 }
 342
 343 static int xml_obd(xmlDocPtr doc, xmlNodePtr root,
 344                    char *serv_id, char *serv_uuid) {
 345         xmlNodePtr cur = root->xmlChildrenNode;
 346         char *obdtype, *format = NULL, *fstype = NULL, *device = NULL;
 347         int rc;
 348
 349         obdtype = xmlGetProp(root, "type");
 350         printf("--- Setting up OBD ---\n");
 351
 352         while (cur != NULL) {
 353                 if (!xmlStrcmp(cur->name, "fstype"))
 354                         fstype = xmlNodeGetContent(cur);
 355
 356                 if (!xmlStrcmp(cur->name, "device"))
 357                         device = xmlNodeGetContent(cur);
 358
 359                 if (!xmlStrcmp(cur->name, "autoformat"))
 360                         format = xmlNodeGetContent(cur);
 361
 362                 cur = cur->next;
 363         }
 364
 365         if ((obdtype == NULL) || (fstype == NULL) || (device == NULL)) {
 366                 printf("error: 'type' attrib and <fstype> and <device> tags required\n");
 367                 return -1;
 368         }
 369
 370         /* FIXME: Building and configuring loopback devices should go here
 371          * but is currently unsupported.  You'll have to use the scripts
 372          * for now until support is added, or specify a real device.
 373          */
 374
 375         if ((rc = xml_command("newdev", NULL)) != 0)
 376                 return rc;
 377
 378         if ((rc = xml_command("attach", obdtype, "OBDDEV", NULL)) != 0)
 379                 return rc;
 380
 381         if ((rc = xml_command("setup", device, fstype, NULL)) != 0)
 382                 return rc;
 383
 384         return 0;
 385 }
 386
 387 static int xml_ost(xmlDocPtr doc, xmlNodePtr root,
 388                    char *serv_id, char *serv_uuid) {
 389         int rc;
 390
 391         printf("--- Setting up OST ---\n");
 392         if ((rc = xml_command("newdev", NULL)) != 0)
 393                 return rc;
 394
 395         if ((rc = xml_command("attach", "ost", "OSTDEV", NULL)) != 0)
 396                 return rc;
 397
 398         if ((rc = xml_command("setup", "$OBDDEV", NULL)) != 0)
 399                 return rc;
 400
 401         return 0;
 402 }
 403
 404 static int xml_osc(xmlDocPtr doc, xmlNodePtr root,
 405                    char *serv_id, char *serv_uuid) {
 406         xmlNodePtr cur = root->xmlChildrenNode;
 407         network_t *net = NULL;
 408         int rc = 0;
 409
 410         printf("--- Setting up OSC ---\n");
 411         while (cur != NULL) {
 412                 if (!xmlStrcmp(cur->name, "network")) {
 413                         net = xml_network(doc, cur);
 414                         if (net == NULL)
 415                                 return -1;
 416                 }
 417                 cur = cur->next;
 418         }
 419
 420         if (net == NULL) {
 421                 printf("error: <network> tag required\n");
 422                 return -1;
 423         }
 424
 425         if ((rc = xml_command("newdev", NULL)) != 0) {
 426                 rc = -1;
 427                 goto xml_osc_error;
 428         }
 429
 430         if ((rc = xml_command("attach", "osc", "OSCDEV", NULL)) != 0) {
 431                 rc = -1;
 432                 goto xml_osc_error;
 433         }
 434
 435         if ((rc = xml_command("setup", "OSTDEV", net->server, NULL)) != 0) {
 436                 rc = -1;
 437                 goto xml_osc_error;
 438         }
 439
 440 xml_osc_error:
 441         free(net);
 442         return rc;
 443 }
 444
 445 static int xml_mdc(xmlDocPtr doc, xmlNodePtr root,
 446                    char *serv_id, char *serv_uuid) {
 447         xmlNodePtr cur = root->xmlChildrenNode;
 448         network_t *net = NULL;
 449         int rc = 0;
 450
 451         printf("--- Setting up MDC ---\n");
 452         while (cur != NULL) {
 453                 if (!xmlStrcmp(cur->name, "network")) {
 454                         net = xml_network(doc, cur);
 455                         if (net == NULL)
 456                                 return -1;
 457                 }
 458                 cur = cur->next;
 459         }
 460
 461         if (net == NULL) {
 462                 printf("error: <network> tag required\n");
 463                 return -1;
 464         }
 465
 466         if ((rc = xml_command("newdev", NULL)) != 0) {
 467                 rc = -1;
 468                 goto xml_mdc_error;
 469         }
 470
 471         if ((rc = xml_command("attach", "mdc", "MDCDEV", NULL)) != 0) {
 472                 rc = -1;
 473                 goto xml_mdc_error;
 474         }
 475
 476         if ((rc = xml_command("setup", "MDSDEV", net->server, NULL)) != 0) {
 477                 rc = -1;
 478                 goto xml_mdc_error;
 479         }
 480
 481 xml_mdc_error:
 482         free(net);
 483         return rc;
 484 }
 485
 486 static int xml_lov(xmlDocPtr doc, xmlNodePtr root,
 487                    char *serv_id, char *serv_uuid) {
 488         printf("--- Setting up LOV ---\n");
 489         return 0;
 490 }
 491
 492 static int xml_router(xmlDocPtr doc, xmlNodePtr root,
 493                    char *serv_id, char *serv_uuid) {
 494         printf("--- Setting up ROUTER ---\n");
 495         return 0;
 496 }
 497
 498 static int xml_ldlm(xmlDocPtr doc, xmlNodePtr root,
 499                    char *serv_id, char *serv_uuid) {
 500         int rc;
 501
 502         printf("--- Setting up LDLM ---\n");
 503         if ((rc = xml_command("newdev", NULL)) != 0)
 504                 return rc;
 505
 506         if ((rc = xml_command("attach", "ldlm", "LDLMDEV", NULL)) != 0)
 507                 return rc;
 508
 509         if ((rc = xml_command("setup", NULL)) != 0)
 510                 return rc;
 511
 512         return 0;
 513 }
 514
 515 static int xml_service(xmlDocPtr doc, xmlNodePtr root,
 516                        int serv_num, char *serv_id, char *serv_uuid) {
 517         xmlNodePtr cur = root;
 518         char *id, *uuid;
 519
 520         while (cur != NULL) {
 521                 id = xmlGetProp(cur, "id");
 522                 uuid = xmlGetProp(cur, "uuid");
 523
 524                 if (xmlStrcmp(id, serv_id) ||
 525                     xmlStrcmp(uuid, serv_uuid)) {
 526                         cur = cur->next;
 527                         continue;
 528                 }
 529
 530                 if (!xmlStrcmp(cur->name, "mds"))
 531                         return xml_mds(doc, cur, serv_id, serv_uuid);
 532                 else if (!xmlStrcmp(cur->name, "obd"))
 533                         return xml_obd(doc, cur, serv_id, serv_uuid);
 534                 else if (!xmlStrcmp(cur->name, "ost"))
 535                         return xml_ost(doc, cur, serv_id, serv_uuid);
 536                 else if (!xmlStrcmp(cur->name, "osc"))
 537                         return xml_osc(doc, cur, serv_id, serv_uuid);
 538                 else if (!xmlStrcmp(cur->name, "mdc"))
 539                         return xml_mdc(doc, cur, serv_id, serv_uuid);
 540                 else if (!xmlStrcmp(cur->name, "lov"))
 541                         return xml_lov(doc, cur, serv_id, serv_uuid);
 542                 else if (!xmlStrcmp(cur->name, "router"))
 543                         return xml_router(doc, cur, serv_id, serv_uuid);
 544                 else if (!xmlStrcmp(cur->name, "ldlm"))
 545                         return xml_ldlm(doc, cur, serv_id, serv_uuid);
 546                 else
 547                         return -1;
 548
 549                 cur = cur->next;
 550         }
 551
 552         printf("error: No XML config branch for id=%s uuid=%s\n",
 553                 serv_id, serv_uuid);
 554         return -1;
 555 }
 556
 557 static int xml_profile(xmlDocPtr doc, xmlNodePtr root,
 558                        int prof_num, char *prof_id, char *prof_uuid) {
 559         xmlNodePtr parent, cur = root;
 560         char *id, *uuid, *srv_id, *srv_uuid;
 561         int rc = 0, num;
 562
 563         while (cur != NULL) {
 564                 id = xmlGetProp(cur, "id");
 565                 uuid = xmlGetProp(cur, "uuid");
 566
 567                 if (xmlStrcmp(cur->name, "profile") ||
 568                     xmlStrcmp(id, prof_id)          ||
 569                     xmlStrcmp(uuid, prof_uuid)) {
 570                         cur = cur->next;
 571                         continue;
 572                 }
 573
 574                 /* FIXME: Doesn't understand mountpoints yet
 575                  *        xml_mountpoint(doc, root, ...);
 576                  */
 577
 578                 /* Setup each service in turn
 579                  * FIXME: Should be sorted by "num" attr, we shouldn't
 580                  *        assume they're in order in the XML document.
 581                  */
 582                 parent = cur;
 583                 cur = cur->xmlChildrenNode;
 584                 while (cur != NULL) {
 585                         if (!xmlStrcmp(cur->name, "service_id")) {
 586                                 num = atoi(xmlGetProp(cur, "num"));
 587                                 rc = xml_service(doc, root, num,
 588                                         srv_id = xmlGetProp(cur, "id"),
 589                                         srv_uuid = xmlGetProp(cur, "uuid"));
 590                                 if (rc != 0) {
 591                                         printf("error: service config\n");
 592                                         return rc;
 593                                 }
 594                         }
 595
 596                         cur = cur->next;
 597                 }
 598
 599                 cur = parent->next;
 600         }
 601
 602         return rc;
 603 }
 604
 605 static int xml_node(xmlDocPtr doc, xmlNodePtr root) {
 606         xmlNodePtr parent, cur = root;
 607         char *id, *uuid;
 608         int rc = 0, num;
 609
 610         /* Walk the node tags looking for ours */
 611         while (cur != NULL) {
 612                 if (xmlStrcmp(cur->name, "node")) {
 613                         cur = cur->next;
 614                         continue;
 615                 }
 616
 617                 id = xmlGetProp(cur, "id");
 618                 if (id == NULL)
 619                         return -1;
 620
 621                 uuid = xmlGetProp(cur, "uuid");
 622                 if (uuid == NULL)
 623                         return -1;
 624
 625                 /* FIXME: Verify our ID and UUID against /etc/lustre/id
 626                  *        so we're sure we are who we think we are.
 627                  */
 628
 629                 /* Setup each profile in turn
 630                  * FIXME: Should be sorted by "num" attr, we shouldn't
 631                  *        assume they're in order in the XML document.
 632                  */
 633                 parent = cur;
 634                 cur = cur->xmlChildrenNode;
 635                 while (cur != NULL) {
 636                         if (!xmlStrcmp(cur->name, "profile_id")) {
 637                                 num = atoi(xmlGetProp(cur, "num"));
 638                                 rc = xml_profile(doc, root, num,
 639                                                  xmlGetProp(cur, "id"),
 640                                                  xmlGetProp(cur, "uuid"));
 641                                 if (rc != 0)
 642                                         return rc;
 643                         }
 644
 645                         cur = cur->next;
 646                 }
 647
 648                 cur = parent->next;
 649         }
 650
 651         return rc;
 652 }
 653
 654 static int do_xml(char *func, char *file)
 655 {
 656         xmlDocPtr doc;
 657         xmlNodePtr cur;
 658         int rc;
 659
 660         doc = xmlParseFile(file);
 661         if (doc == NULL) {
 662                 fprintf(stderr, "error: Unable to parse XML\n");
 663                 return -1;
 664         }
 665
 666         cur = xmlDocGetRootElement(doc);
 667         if (cur == NULL) {
 668                 fprintf(stderr, "error: Empty XML\n");
 669                 xmlFreeDoc(doc);
 670                 return -1;
 671         }
 672
 673         if (xmlStrcmp(cur->name, (const xmlChar *)"lustre")) {
 674                 fprintf(stderr, "error: Root node != <lustre>\n");
 675                 xmlFreeDoc(doc);
 676                 return -1;
 677         }
 678
 679         /* FIXME: Validate the XML against the DTD here */
 680
 681         /* FIXME: Merge all the text nodes under each branch and
 682          *        prune empty nodes.  Just to make the parsing more
 683          *        tolerant, the exact location of nested tags isn't
 684          *        critical for this.
 685          */
 686
 687         rc = xml_node(doc, cur->xmlChildrenNode);
 688         xmlFreeDoc(doc);
 689
 690         return rc;
 691 }
 692
 693 static int do_device(char *func, int dev)
 694 {
 695         struct obd_ioctl_data data;
 696
 697         memset(&data, 0, sizeof(data));
 698
 699         data.ioc_dev = dev;
 700
 701         if (getfd(func))
 702                 return -1;
 703
 704         if (obd_ioctl_pack(&data, &buf, max)) {
 705                 fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(func));
 706                 return -2;
 707         }
 708
 709         return ioctl(fd, OBD_IOC_DEVICE , buf);
 710 }
 711
 712 static int jt_device(int argc, char **argv)
 713 {
 714         do_disconnect(argv[0], 1);
 715
 716         if (argc != 2) {
 717                 fprintf(stderr, "usage: %s devno\n", cmdname(argv[0]));
 718                 return -1;
 719         }
 720
 721         rc = do_device(argv[0], strtoul(argv[1], NULL, 0));
 722
 723         if (rc < 0)
 724                 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
 725                         strerror(rc = errno));
 726
 727         return rc;
 728 }
 729
 730 static int jt_connect(int argc, char **argv)
 731 {
 732         struct obd_ioctl_data data;
 733
 734         IOCINIT(data);
 735
 736         do_disconnect(argv[0], 1);
 737
 738         if (argc != 1) {
 739                 fprintf(stderr, "usage: %s\n", cmdname(argv[0]));
 740                 return -1;
 741         }
 742
 743         rc = ioctl(fd, OBD_IOC_CONNECT , &data);
 744         if (rc < 0)
 745                 fprintf(stderr, "error: %s: %x %s\n", cmdname(argv[0]),
 746                         OBD_IOC_CONNECT, strerror(rc = errno));
 747         else
 748                 connid = data.ioc_conn1;
 749
 750         return rc;
 751 }
 752
 753 static int jt_disconnect(int argc, char **argv)
 754 {
 755         if (argc != 1) {
 756                 fprintf(stderr, "usage: %s\n", cmdname(argv[0]));
 757                 return -1;
 758         }
 759
 760         return do_disconnect(argv[0], 0);
 761 }
 762
 763 static int jt__xml(int argc, char **argv)
 764 {
 765         if (argc < 2) {
 766                 fprintf(stderr, "usage: %s <xml file> <command [args ...]>\n",
 767                         cmdname(argv[0]));
 768                 return -1;
 769         }
 770
 771         return do_xml("xml", argv[1]);
 772 }
 773
 774 static int jt__device(int argc, char **argv)
 775 {
 776         char *arg2[3];
 777         int ret;
 778
 779         if (argc < 3) {
 780                 fprintf(stderr, "usage: %s devno <command [args ...]>\n",
 781                         cmdname(argv[0]));
 782                 return -1;
 783         }
 784
 785         rc = do_device("device", strtoul(argv[1], NULL, 0));
 786
 787         if (!rc) {
 788                 arg2[0] = "connect";
 789                 arg2[1] = NULL;
 790                 rc = jt_connect(1, arg2);
 791         }
 792
 793         if (!rc)
 794                 rc = Parser_execarg(argc - 2, argv + 2, cmdlist);
 795
 796         ret = do_disconnect(argv[0], 0);
 797         if (!rc)
 798                 rc = ret;
 799
 800         return rc;
 801 }
 802
 803 static int jt__threads(int argc, char **argv)
 804 {
 805         int threads, next_thread;
 806         int verbose;
 807         int i, j;
 808
 809         if (argc < 5) {
 810                 fprintf(stderr,
 811                         "usage: %s numthreads verbose devno <cmd [args ...]>\n",
 812                         argv[0]);
 813                 return -1;
 814         }
 815
 816         threads = strtoul(argv[1], NULL, 0);
 817
 818         verbose = get_verbose(argv[2]);
 819
 820         printf("%s: starting %d threads on device %s running %s\n",
 821                argv[0], threads, argv[3], argv[4]);
 822
 823         for (i = 1, next_thread = verbose; i <= threads; i++) {
 824                 rc = fork();
 825                 if (rc < 0) {
 826                         fprintf(stderr, "error: %s: #%d - %s\n", argv[0], i,
 827                                 strerror(rc = errno));
 828                         break;
 829                 } else if (rc == 0) {
 830                         thread = i;
 831                         argv[2] = "--device";
 832                         return jt__device(argc - 2, argv + 2);
 833                 } else if (be_verbose(verbose, NULL, i, &next_thread, threads))
 834                         printf("%s: thread #%d (PID %d) started\n",
 835                                argv[0], i, rc);
 836                 rc = 0;
 837         }
 838
 839         if (!thread) { /* parent process */
 840                 if (!verbose)
 841                         printf("%s: started %d threads\n\n", argv[0], i - 1);
 842                 else
 843                         printf("\n");
 844
 845                 for (j = 1; j < i; j++) {
 846                         int status;
 847                         int ret = wait(&status);
 848
 849                         if (ret < 0) {
 850                                 fprintf(stderr, "error: %s: wait - %s\n",
 851                                         argv[0], strerror(errno));
 852                                 if (!rc)
 853                                         rc = errno;
 854                         } else {
 855                                 /*
 856                                  * This is a hack.  We _should_ be able to use
 857                                  * WIFEXITED(status) to see if there was an
 858                                  * error, but it appears to be broken and it
 859                                  * always returns 1 (OK).  See wait(2).
 860                                  */
 861                                 int err = WEXITSTATUS(status);
 862                                 if (err)
 863                                         fprintf(stderr,
 864                                                 "%s: PID %d had rc=%d\n",
 865                                                 argv[0], ret, err);
 866                                 if (!rc)
 867                                         rc = err;
 868                         }
 869                 }
 870         }
 871
 872         return rc;
 873 }
 874
 875 static int jt_detach(int argc, char **argv)
 876 {
 877         struct obd_ioctl_data data;
 878
 879         IOCINIT(data);
 880
 881         if (argc != 1) {
 882                 fprintf(stderr, "usage: %s\n", cmdname(argv[0]));
 883                 return -1;
 884         }
 885
 886         if (obd_ioctl_pack(&data, &buf, max)) {
 887                 fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
 888                 return -2;
 889         }
 890
 891         rc = ioctl(fd, OBD_IOC_DETACH , buf);
 892         if (rc < 0)
 893                 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
 894                         strerror(rc=errno));
 895
 896         return rc;
 897 }
 898
 899 static int jt_cleanup(int argc, char **argv)
 900 {
 901         struct obd_ioctl_data data;
 902
 903         IOCINIT(data);
 904
 905         if (argc != 1) {
 906                 fprintf(stderr, "usage: %s\n", cmdname(argv[0]));
 907                 return -1;
 908         }
 909
 910         rc = ioctl(fd, OBD_IOC_CLEANUP , &data);
 911         if (rc < 0)
 912                 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
 913                         strerror(rc=errno));
 914
 915         return rc;
 916 }
 917
 918 static int jt_newdev(int argc, char **argv)
 919 {
 920         struct obd_ioctl_data data;
 921
 922         if (getfd(argv[0]))
 923                 return -1;
 924
 925         IOCINIT(data);
 926
 927         if (argc != 1) {
 928                 fprintf(stderr, "usage: %s\n", cmdname(argv[0]));
 929                 return -1;
 930         }
 931
 932         rc = ioctl(fd, OBD_IOC_NEWDEV , &data);
 933         if (rc < 0)
 934                 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
 935                         strerror(rc=errno));
 936         else {
 937                 printf("Current device set to %d\n", data.ioc_dev);
 938         }
 939
 940         return rc;
 941 }
 942
 943 static int jt_attach(int argc, char **argv)
 944 {
 945         struct obd_ioctl_data data;
 946
 947         IOCINIT(data);
 948
 949         if (argc != 2 && argc != 3) {
 950                 fprintf(stderr, "usage: %s type [name [uuid]]\n",
 951                         cmdname(argv[0]));
 952                 return -1;
 953         }
 954
 955         data.ioc_inllen1 =  strlen(argv[1]) + 1;
 956         data.ioc_inlbuf1 = argv[1];
 957         if (argc == 3) {
 958                 data.ioc_inllen2 = strlen(argv[2]) + 1;
 959                 data.ioc_inlbuf2 = argv[2];
 960         }
 961
 962         if (obd_ioctl_pack(&data, &buf, max)) {
 963                 fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
 964                 return -2;
 965         }
 966
 967         rc = ioctl(fd, OBD_IOC_ATTACH , buf);
 968         if (rc < 0)
 969                 fprintf(stderr, "error: %s: %x %s\n", cmdname(argv[0]),
 970                         OBD_IOC_ATTACH, strerror(rc = errno));
 971         else if (argc == 3) {
 972                 char name[1024];
 973                 if (strlen(argv[2]) > 128) {
 974                         printf("Name too long to set environment\n");
 975                         return -EINVAL;
 976                 }
 977                 snprintf(name, 512, "LUSTRE_DEV_%s", argv[2]);
 978                 rc = setenv(name, argv[1], 1);
 979                 if (rc) {
 980                         printf("error setting env variable %s\n", name);
 981                 }
 982         }
 983
 984         return rc;
 985 }
 986
 987 #define N2D_OFF 0x100    /* So we can tell between error codes and devices */
 988
 989 static int do_name2dev(char *func, char *name)
 990 {
 991         struct obd_ioctl_data data;
 992
 993         if (getfd(func))
 994                 return -1;
 995
 996         IOCINIT(data);
 997
 998         data.ioc_inllen1 = strlen(name) + 1;
 999         data.ioc_inlbuf1 = name;
1000
1001         if (obd_ioctl_pack(&data, &buf, max)) {
1002                 fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(func));
1003                 return -2;
1004         }
1005         rc = ioctl(fd, OBD_IOC_NAME2DEV , buf);
1006         if (rc < 0) {
1007                 fprintf(stderr, "error: %s: %s - %s\n", cmdname(func),
1008                         name, strerror(rc = errno));
1009                 return rc;
1010         }
1011
1012         memcpy((char *)(&data), buf, sizeof(data));
1013
1014         return data.ioc_dev + N2D_OFF;
1015 }
1016
1017 static int jt_name2dev(int argc, char **argv)
1018 {
1019         if (argc != 2) {
1020                 fprintf(stderr, "usage: %s name\n", cmdname(argv[0]));
1021                 return -1;
1022         }
1023
1024         rc = do_name2dev(argv[0], argv[1]);
1025         if (rc >= N2D_OFF) {
1026                 int dev = rc - N2D_OFF;
1027                 rc = do_device(argv[0], dev);
1028                 if (rc == 0)
1029                         printf("%d\n", dev);
1030         }
1031         return rc;
1032 }
1033
1034 static int jt_setup(int argc, char **argv)
1035 {
1036         struct obd_ioctl_data data;
1037
1038         IOCINIT(data);
1039
1040         if ( argc > 3) {
1041                 fprintf(stderr, "usage: %s [device] [fstype]\n",
1042                         cmdname(argv[0]));
1043                 return -1;
1044         }
1045
1046         data.ioc_dev = -1;
1047         if (argc > 1) {
1048                 if (argv[1][0] == '$') {
1049                         rc = do_name2dev(argv[0], argv[1] + 1);
1050                         if (rc >= N2D_OFF) {
1051                                 printf("%s is device %d\n", argv[1],
1052                                        rc - N2D_OFF);
1053                                 data.ioc_dev = rc - N2D_OFF;
1054                         }
1055                 } else
1056                         data.ioc_dev = strtoul(argv[1], NULL, 0);
1057                 data.ioc_inllen1 = strlen(argv[1]) + 1;
1058                 data.ioc_inlbuf1 = argv[1];
1059         }
1060         if ( argc == 3 ) {
1061                 data.ioc_inllen2 = strlen(argv[2]) + 1;
1062                 data.ioc_inlbuf2 = argv[2];
1063         }
1064
1065         if (obd_ioctl_pack(&data, &buf, max)) {
1066                 fprintf(stderr, "error: %s: invalid ioctl\n", cmdname(argv[0]));
1067                 return -2;
1068         }
1069         rc = ioctl(fd, OBD_IOC_SETUP , buf);
1070         if (rc < 0)
1071                 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
1072                         strerror(rc = errno));
1073
1074         return rc;
1075 }
1076
1077
1078 static int jt_create(int argc, char **argv)
1079 {
1080         struct obd_ioctl_data data;
1081         struct timeval next_time;
1082         int count = 1, next_count;
1083         int verbose;
1084         int i;
1085
1086         IOCINIT(data);
1087         if (argc < 2 || argc > 4) {
1088                 fprintf(stderr, "usage: %s num [mode] [verbose]\n",
1089                         cmdname(argv[0]));
1090                 return -1;
1091         }
1092         count = strtoul(argv[1], NULL, 0);
1093
1094         if (argc > 2)
1095                 data.ioc_obdo1.o_mode = strtoul(argv[2], NULL, 0);
1096         else
1097                 data.ioc_obdo1.o_mode = 0100644;
1098         data.ioc_obdo1.o_valid = OBD_MD_FLMODE;
1099
1100         verbose = get_verbose(argv[3]);
1101
1102         printf("%s: %d obdos\n", cmdname(argv[0]), count);
1103         gettimeofday(&next_time, NULL);
1104         next_time.tv_sec -= verbose;
1105
1106         for (i = 1, next_count = verbose; i <= count ; i++) {
1107                 rc = ioctl(fd, OBD_IOC_CREATE , &data);
1108                 if (rc < 0) {
1109                         fprintf(stderr, "error: %s: #%d - %s\n",
1110                                 cmdname(argv[0]), i, strerror(rc = errno));
1111                         break;
1112                 }
1113                 if (be_verbose(verbose, &next_time, i, &next_count, count))
1114                         printf("%s: #%d is object id %Ld\n", cmdname(argv[0]),
1115                                i, data.ioc_obdo1.o_id);
1116         }
1117         return rc;
1118 }
1119
1120 static int jt_setattr(int argc, char **argv)
1121 {
1122         struct obd_ioctl_data data;
1123
1124         IOCINIT(data);
1125         if (argc != 2) {
1126                 fprintf(stderr, "usage: %s id mode\n", cmdname(argv[0]));
1127                 return -1;
1128         }
1129
1130         data.ioc_obdo1.o_id = strtoul(argv[1], NULL, 0);
1131         data.ioc_obdo1.o_mode = S_IFREG | strtoul(argv[2], NULL, 0);
1132         data.ioc_obdo1.o_valid = OBD_MD_FLMODE;
1133
1134         rc = ioctl(fd, OBD_IOC_SETATTR , &data);
1135         if (rc < 0)
1136                 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
1137                         strerror(rc = errno));
1138
1139         return rc;
1140 }
1141
1142 static int jt_destroy(int argc, char **argv)
1143 {
1144         struct obd_ioctl_data data;
1145
1146         IOCINIT(data);
1147         if (argc != 2) {
1148                 fprintf(stderr, "usage: %s id\n", cmdname(argv[0]));
1149                 return -1;
1150         }
1151
1152         data.ioc_obdo1.o_id = strtoul(argv[1], NULL, 0);
1153         data.ioc_obdo1.o_mode = S_IFREG|0644;
1154
1155         rc = ioctl(fd, OBD_IOC_DESTROY , &data);
1156         if (rc < 0)
1157                 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
1158                         strerror(rc = errno));
1159
1160         return rc;
1161 }
1162
1163 static int jt_getattr(int argc, char **argv)
1164 {
1165         struct obd_ioctl_data data;
1166
1167         if (argc != 2) {
1168                 fprintf(stderr, "usage: %s id\n", cmdname(argv[0]));
1169                 return -1;
1170         }
1171
1172         IOCINIT(data);
1173         data.ioc_obdo1.o_id = strtoul(argv[1], NULL, 0);
1174         /* to help obd filter */
1175         data.ioc_obdo1.o_mode = 0100644;
1176         data.ioc_obdo1.o_valid = 0xffffffff;
1177         printf("%s: object id %Ld\n", cmdname(argv[0]), data.ioc_obdo1.o_id);
1178
1179         rc = ioctl(fd, OBD_IOC_GETATTR , &data);
1180         if (rc) {
1181                 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
1182                         strerror(rc=errno));
1183         } else {
1184                 printf("%s: object id %Ld, mode %o\n", cmdname(argv[0]),
1185                        data.ioc_obdo1.o_id, data.ioc_obdo1.o_mode);
1186         }
1187         return rc;
1188 }
1189
1190 static int jt_test_getattr(int argc, char **argv)
1191 {
1192         struct obd_ioctl_data data;
1193         struct timeval start, next_time;
1194         int i, count, next_count;
1195         int verbose;
1196
1197         if (argc != 2 && argc != 3) {
1198                 fprintf(stderr, "usage: %s count [verbose]\n",cmdname(argv[0]));
1199                 return -1;
1200         }
1201
1202         IOCINIT(data);
1203         count = strtoul(argv[1], NULL, 0);
1204
1205         if (argc == 3)
1206                 verbose = get_verbose(argv[2]);
1207         else
1208                 verbose = 1;
1209
1210         data.ioc_obdo1.o_valid = 0xffffffff;
1211         data.ioc_obdo1.o_id = 2;
1212         gettimeofday(&start, NULL);
1213         next_time.tv_sec = start.tv_sec - verbose;
1214         next_time.tv_usec = start.tv_usec;
1215         printf("%s: getting %d attrs (testing only): %s", cmdname(argv[0]),
1216                count, ctime(&start.tv_sec));
1217
1218         for (i = 1, next_count = verbose; i <= count; i++) {
1219                 rc = ioctl(fd, OBD_IOC_GETATTR , &data);
1220                 if (rc < 0) {
1221                         fprintf(stderr, "error: %s: #%d - %s\n",
1222                                 cmdname(argv[0]), i, strerror(rc = errno));
1223                         break;
1224                 } else {
1225                         if (be_verbose(verbose, &next_time, i,&next_count,count))
1226                         printf("%s: got attr #%d\n", cmdname(argv[0]), i);
1227                 }
1228         }
1229
1230         if (!rc) {
1231                 struct timeval end;
1232                 double diff;
1233
1234                 gettimeofday(&end, NULL);
1235
1236                 diff = difftime(&end, &start);
1237
1238                 --i;
1239                 printf("%s: %d attrs in %.4gs (%.4g attr/s): %s",
1240                        cmdname(argv[0]), i, diff, (double)i / diff,
1241                        ctime(&end.tv_sec));
1242         }
1243         return rc;
1244 }
1245
1246 static int jt_test_brw(int argc, char **argv)
1247 {
1248         struct obd_ioctl_data data;
1249         struct timeval start, next_time;
1250         char *bulk, *b;
1251         int pages = 1, obdos = 1, count, next_count;
1252         int verbose = 1, write = 0, rw;
1253         int i, o, p;
1254         int len;
1255
1256         if (argc < 2 || argc > 6) {
1257                 fprintf(stderr,
1258                         "usage: %s count [write [verbose [pages [obdos]]]]\n",
1259                         cmdname(argv[0]));
1260                 return -1;
1261         }
1262
1263         count = strtoul(argv[1], NULL, 0);
1264
1265         if (argc >= 3) {
1266                 if (argv[2][0] == 'w' || argv[2][0] == '1')
1267                         write = 1;
1268                 else if (argv[2][0] == 'r' || argv[2][0] == '0')
1269                         write = 0;
1270
1271                 verbose = get_verbose(argv[3]);
1272         }
1273
1274         if (argc >= 5)
1275                 pages = strtoul(argv[4], NULL, 0);
1276         if (argc >= 6)
1277                 obdos = strtoul(argv[5], NULL, 0);
1278
1279         if (obdos != 1 && obdos != 2) {
1280                 fprintf(stderr, "error: %s: only 1 or 2 obdos supported\n",
1281                         cmdname(argv[0]));
1282                 return -2;
1283         }
1284
1285         len = pages * PAGE_SIZE;
1286
1287         bulk = calloc(obdos, len);
1288         if (!bulk) {
1289                 fprintf(stderr, "error: %s: no memory allocating %dx%d pages\n",
1290                         cmdname(argv[0]), obdos, pages);
1291                 return -2;
1292         }
1293         IOCINIT(data);
1294         data.ioc_conn2 = connid;
1295         data.ioc_obdo1.o_id = 2;
1296         data.ioc_count = len;
1297         data.ioc_offset = 0;
1298         data.ioc_plen1 = len;
1299         data.ioc_pbuf1 = bulk;
1300         if (obdos > 1) {
1301                 data.ioc_obdo2.o_id = 3;
1302                 data.ioc_plen2 = len;
1303                 data.ioc_pbuf2 = bulk + len;
1304         }
1305
1306         gettimeofday(&start, NULL);
1307         next_time.tv_sec = start.tv_sec - verbose;
1308         next_time.tv_usec = start.tv_usec;
1309
1310         printf("%s: %s %d (%dx%d pages) (testing only): %s",
1311                cmdname(argv[0]), write ? "writing" : "reading",
1312                count, obdos, pages, ctime(&start.tv_sec));
1313
1314         /*
1315          * We will put in the start time (and loop count inside the loop)
1316          * at the beginning of each page so that we will be able to validate
1317          * (at some later time) whether the data actually made it or not.
1318          *
1319          * XXX we do not currently use any of this memory in OBD_IOC_BRW_*
1320          *     just to avoid the overhead of the copy_{to,from}_user.  It
1321          *     can be fixed if we ever need to send real data around.
1322          */
1323         for (o = 0, b = bulk; o < obdos; o++)
1324                 for (p = 0; p < pages; p++, b += PAGE_SIZE)
1325                         memcpy(b, &start, sizeof(start));
1326
1327         rw = write ? OBD_IOC_BRW_WRITE : OBD_IOC_BRW_READ;
1328         for (i = 1, next_count = verbose; i <= count; i++) {
1329                 if (write) {
1330                         b = bulk + sizeof(struct timeval);
1331                         for (o = 0; o < obdos; o++)
1332                                 for (p = 0; p < pages; p++, b += PAGE_SIZE)
1333                                         memcpy(b, &count, sizeof(count));
1334                 }
1335
1336                 rc = ioctl(fd, rw, &data);
1337                 if (rc) {
1338                         fprintf(stderr, "error: %s: #%d - %s on %s\n",
1339                                 cmdname(argv[0]), i, strerror(rc = errno),
1340                                 write ? "write" : "read");
1341                         break;
1342                 } else if (be_verbose(verbose, &next_time, i,&next_count,count))
1343                         printf("%s: %s number %d\n", cmdname(argv[0]),
1344                                write ? "write" : "read", i);
1345         }
1346
1347         free(bulk);
1348
1349         if (!rc) {
1350                 struct timeval end;
1351                 double diff;
1352
1353                 gettimeofday(&end, NULL);
1354
1355                 diff = difftime(&end, &start);
1356
1357                 --i;
1358                 printf("%s: %s %dx%dx%d pages in %.4gs (%.4g pg/s): %s",
1359                        cmdname(argv[0]), write ? "wrote" : "read", obdos,
1360                        pages, i, diff, (double)obdos * i * pages / diff,
1361                        ctime(&end.tv_sec));
1362         }
1363         return rc;
1364 }
1365
1366 static int jt_test_ldlm(int argc, char **argv)
1367 {
1368         struct obd_ioctl_data data;
1369
1370         IOCINIT(data);
1371         if (argc != 1) {
1372                 fprintf(stderr, "usage: %s\n", cmdname(argv[0]));
1373                 return 1;
1374         }
1375
1376         rc = ioctl(fd, IOC_LDLM_TEST, &data);
1377         if (rc)
1378                 fprintf(stderr, "error: %s: test failed: %s\n",
1379                         cmdname(argv[0]), strerror(rc = errno));
1380         return rc;
1381 }
1382
1383 static int jt_newconn(int argc, char **argv)
1384 {
1385         struct obd_ioctl_data data;
1386
1387         IOCINIT(data);
1388         if (argc != 1) {
1389                 fprintf(stderr, "usage: %s\n", cmdname(argv[0]));
1390                 return -1;
1391         }
1392
1393         rc = ioctl(fd, OBD_IOC_RECOVD_NEWCONN , &data);
1394         if (rc < 0)
1395                 fprintf(stderr, "error: %s: %s\n", cmdname(argv[0]),
1396                         strerror(rc = errno));
1397
1398         return rc;
1399 }
1400
1401 static int jt_quit(int argc, char **argv)
1402 {
1403         Parser_quit(argc, argv);
1404
1405         return rc;
1406 }
1407
1408 command_t cmdlist[] = {
1409         /* Metacommands */
1410         {"--xml", jt__xml, 0, "--xml <xml file> <command [args ...]>"},
1411         {"--device", jt__device, 0, "--device <devno> <command [args ...]>"},
1412         {"--threads", jt__threads, 0,
1413                 "--threads <threads> <devno> <command [args ...]>"},
1414
1415         /* Device configuration commands */
1416         {"newdev", jt_newdev, 0, "set device to a new unused obd (no args)"},
1417         {"device", jt_device, 0, "set current device (args device_no name)"},
1418         {"name2dev", jt_name2dev, 0, "set device by name (args name)"},
1419         {"attach", jt_attach, 0, "name the type of device (args: type data"},
1420         {"setup", jt_setup, 0, "setup device (args: <blkdev> [data]"},
1421         {"detach", jt_detach, 0, "detach the current device (arg: )"},
1422         {"cleanup", jt_cleanup, 0, "cleanup the current device (arg: )"},
1423
1424         /* Session commands */
1425         {"connect", jt_connect, 0, "connect - get a connection to device"},
1426         {"disconnect", jt_disconnect, 0,
1427                 "disconnect - break connection to device"},
1428
1429         /* Session operations */
1430         {"create", jt_create, 0, "create [count [mode [verbose]]]"},
1431         {"destroy", jt_destroy, 0, "destroy <id>"},
1432         {"getattr", jt_getattr, 0, "getattr <id>"},
1433         {"setattr", jt_setattr, 0, "setattr <id> <mode>"},
1434         {"newconn", jt_newconn, 0, "newconn [newuuid]"},
1435         {"test_getattr", jt_test_getattr, 0, "test_getattr <count> [verbose]"},
1436         {"test_brw", jt_test_brw, 0, "test_brw <count> [write [verbose]]"},
1437         {"test_ldlm", jt_test_ldlm, 0, "test lock manager (no args)"},
1438
1439         /* User interface commands */
1440         {"help", Parser_help, 0, "help"},
1441         {"exit", jt_quit, 0, "quit"},
1442         {"quit", jt_quit, 0, "quit"},
1443         { 0, 0, 0, NULL }
1444 };
1445
1446
1447 static void signal_server(int sig)
1448 {
1449         if (sig == SIGINT) {
1450                 do_disconnect("sigint", 1);
1451                 exit(1);
1452         } else {
1453                 fprintf(stderr, "%s: got signal %d\n", cmdname("sigint"), sig);
1454         }
1455 }
1456
1457 int main(int argc, char **argv)
1458 {
1459         struct sigaction sigact;
1460
1461         sigact.sa_handler = signal_server;
1462         sigfillset(&sigact.sa_mask);
1463         sigact.sa_flags = SA_RESTART;
1464         sigaction(SIGINT, &sigact, NULL);
1465
1466
1467         if (argc > 1) {
1468                 rc = Parser_execarg(argc - 1, argv + 1, cmdlist);
1469         } else {
1470                 Parser_init("obdctl > ", cmdlist);
1471                 rc = Parser_commands();
1472         }
1473
1474         do_disconnect(argv[0], 1);
1475         return rc;
1476 }
1477