lustre/utils/obd.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  *   Author: Andreas Dilger <adilger@clusterfs.com>
   8  *   Author: Robert Read <rread@clusterfs.com>
   9  *
  10  *   This file is part of Lustre, http://www.lustre.org.
  11  *
  12  *   Lustre is free software; you can redistribute it and/or
  13  *   modify it under the terms of version 2 of the GNU General Public
  14  *   License as published by the Free Software Foundation.
  15  *
  16  *   Lustre is distributed in the hope that it will be useful,
  17  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *   GNU General Public License for more details.
  20  *
  21  *   You should have received a copy of the GNU General Public License
  22  *   along with Lustre; if not, write to the Free Software
  23  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  *
  25  */
  26
  27
  28 #include <stdlib.h>
  29 #include <sys/ioctl.h>
  30 #include <fcntl.h>
  31 #include <sys/socket.h>
  32 #include <sys/types.h>
  33 #include <sys/wait.h>
  34 #include <sys/stat.h>
  35 #include <stdio.h>
  36 #include <stdarg.h>
  37 #include <signal.h>
  38
  39 #include "obdctl.h"
  40
  41 #include <linux/obd.h>          /* for struct lov_stripe_md */
  42 #include <linux/lustre_build_version.h>
  43
  44 #include <unistd.h>
  45 #include <sys/un.h>
  46 #include <time.h>
  47 #include <sys/time.h>
  48 #include <errno.h>
  49 #include <string.h>
  50
  51 #include <asm/page.h>           /* needed for PAGE_SIZE - rread */
  52
  53 #define __KERNEL__
  54 #include <linux/list.h>
  55 #undef __KERNEL__
  56
  57 #include <portals/ptlctl.h>
  58 #include "parser.h"
  59 #include <stdio.h>
  60
  61 #define SHMEM_STATS 1
  62 #if SHMEM_STATS
  63 # include <sys/ipc.h>
  64 # include <sys/shm.h>
  65
  66 # define MAX_SHMEM_COUNT 1024
  67 static long long *shared_counters;
  68 static long long counter_snapshot[2][MAX_SHMEM_COUNT];
  69 struct timeval prev_time;
  70 #endif
  71
  72 static int jt_recording;
  73 static uint64_t conn_cookie = -1;
  74 static char rawbuf[8192];
  75 static char *buf = rawbuf;
  76 static int max = sizeof(rawbuf);
  77
  78 static int thread;
  79
  80 union lsm_buffer {
  81         char                 space [4096];
  82         struct lov_stripe_md lsm;
  83 } lsm_buffer;
  84
  85 static int l2_ioctl(int dev_id, int opc, void *buf)
  86 {
  87 //        if (jt_recording) {
  88 //                struct obd_ioctl_data *data = buf;
  89 //                data->ioc_command = opc;
  90 //                opc = OBD_IOC_DORECORD;
  91 //        }
  92         return l_ioctl(dev_id, opc, buf);
  93 }
  94
  95 #define IOC_INIT(data)                                                  \
  96 do {                                                                    \
  97         memset(&data, 0, sizeof(data));                                 \
  98         data.ioc_cookie = conn_cookie;                                  \
  99 } while (0)
 100
 101 #define IOC_PACK(func, data)                                            \
 102 do {                                                                    \
 103         memset(buf, 0, sizeof(rawbuf));                                 \
 104         if (obd_ioctl_pack(&data, &buf, max)) {                         \
 105                 fprintf(stderr, "error: %s: invalid ioctl\n",           \
 106                         jt_cmdname(func));                                 \
 107                 return -2;                                              \
 108         }                                                               \
 109 } while (0)
 110
 111 #define IOC_UNPACK(func, data)                                          \
 112 do {                                                                    \
 113         if (obd_ioctl_unpack(&data, buf, max)) {                        \
 114                 fprintf(stderr, "error: %s: invalid reply\n",           \
 115                         jt_cmdname(func));                                 \
 116                 return -2;                                              \
 117         }                                                               \
 118 } while (0)
 119
 120 int obd_record(enum cfg_record_type type, int len, void *ptr)
 121 {
 122         struct obd_ioctl_data data;
 123
 124         IOC_INIT(data);
 125         data.ioc_type = type;
 126         data.ioc_plen1 = len;
 127         data.ioc_pbuf1 = ptr;
 128         IOC_PACK("obd_record", data);
 129
 130         return  l_ioctl(OBD_DEV_ID, OBD_IOC_DORECORD, &data);
 131 }
 132
 133 int lcfg_ioctl(char * func, int dev_id, struct lustre_cfg *lcfg)
 134 {
 135         int opc;
 136         char lcfg_rawbuf[8192];
 137         char * lcfg_buf= lcfg_rawbuf;
 138         struct obd_ioctl_data data;
 139         int len;
 140         int rc;
 141
 142         memset(lcfg_buf, 0, sizeof(lcfg_rawbuf));
 143         if (lustre_cfg_pack(lcfg, &lcfg_buf, sizeof(lcfg_rawbuf), &len)) {
 144                 fprintf(stderr, "error: %s: invalid ioctl\n",
 145                         jt_cmdname(func));
 146                 return -2;
 147         }
 148
 149         IOC_INIT(data);
 150         data.ioc_type = LUSTRE_CFG_TYPE;
 151         data.ioc_plen1 = len;
 152         data.ioc_pbuf1 = lcfg_buf;
 153         IOC_PACK(func, data);
 154
 155         if (jt_recording)
 156                 opc = OBD_IOC_DORECORD;
 157         else
 158                 opc = OBD_IOC_PROCESS_CFG;
 159
 160         rc =  l_ioctl(dev_id, opc, buf);
 161         if (rc == 0)
 162                 rc = lustre_cfg_unpack(lcfg, lcfg_buf, sizeof(lcfg_rawbuf));
 163
 164         return rc;
 165 }
 166
 167 char *obdo_print(struct obdo *obd)
 168 {
 169         char buf[1024];
 170
 171         sprintf(buf, "id: "LPX64"\ngrp: "LPX64"\natime: "LPU64"\nmtime: "LPU64
 172                 "\nctime: "LPU64"\nsize: "LPU64"\nblocks: "LPU64
 173                 "\nblksize: %u\nmode: %o\nuid: %d\ngid: %d\nflags: %x\n"
 174                 "obdflags: %x\nnlink: %d,\nvalid %x\n",
 175                 obd->o_id, obd->o_gr, obd->o_atime, obd->o_mtime, obd->o_ctime,
 176                 obd->o_size, obd->o_blocks, obd->o_blksize, obd->o_mode,
 177                 obd->o_uid, obd->o_gid, obd->o_flags, obd->o_obdflags,
 178                 obd->o_nlink, obd->o_valid);
 179         return strdup(buf);
 180 }
 181
 182
 183 #define BAD_VERBOSE (-999999999)
 184
 185 #define N2D_OFF 0x100      /* So we can tell between error codes and devices */
 186
 187 static int do_name2dev(char *func, char *name)
 188 {
 189         struct obd_ioctl_data data;
 190         int rc;
 191
 192         IOC_INIT(data);
 193
 194         data.ioc_inllen1 = strlen(name) + 1;
 195         data.ioc_inlbuf1 = name;
 196
 197         IOC_PACK(func, data);
 198         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_NAME2DEV, buf);
 199         if (rc < 0)
 200                 return errno;
 201         IOC_UNPACK(func, data);
 202
 203         return data.ioc_dev + N2D_OFF;
 204 }
 205
 206 /*
 207  * resolve a device name to a device number.
 208  * supports a number, $name or %uuid.
 209  */
 210 int parse_devname(char *func, char *name)
 211 {
 212         int rc;
 213         int ret = -1;
 214
 215         if (!name)
 216                 return ret;
 217         if (name[0] == '$' || name[0] == '%') {
 218                 name++;
 219                 rc = do_name2dev(func, name);
 220                 if (rc >= N2D_OFF) {
 221                         ret = rc - N2D_OFF;
 222                         printf("Name %s is device %d\n", name, ret);
 223                 } else {
 224                         printf("No device found for name %s: %s\n",
 225                                name, strerror(rc));
 226                 }
 227         } else {
 228                 /* Assume it's a number.  This means that bogus strings become
 229                  * 0.  I might care about that some day. */
 230                 ret = strtoul(name, NULL, 0);
 231                 printf("Selected device %d\n", ret);
 232         }
 233
 234         return ret;
 235 }
 236
 237 static char *
 238 lsm_string (struct lov_stripe_md *lsm)
 239 {
 240         static char buffer[4096];
 241         char       *p = buffer;
 242         int         space = sizeof (buffer);
 243         int         i;
 244         int         nob;
 245
 246         *p = 0;
 247         space--;
 248
 249         nob = snprintf(p, space, LPX64, lsm->lsm_object_id);
 250         p += nob;
 251         space -= nob;
 252
 253         if (lsm->lsm_stripe_count != 0) {
 254                 nob = snprintf (p, space, "=%u#%u",
 255                                 lsm->lsm_stripe_size,
 256                                 lsm->lsm_stripe_count);
 257                 p += nob;
 258                 space -= nob;
 259
 260                 for (i = 0; i < lsm->lsm_stripe_count; i++) {
 261                         nob = snprintf (p, space, "@%u:"LPX64,
 262                                         lsm->lsm_oinfo[i].loi_ost_idx,
 263                                         lsm->lsm_oinfo[i].loi_id);
 264                         p += nob;
 265                         space -= nob;
 266                 }
 267         }
 268
 269         if (space == 0) {                       /* probable overflow */
 270                 fprintf (stderr, "lsm_string() overflowed buffer\n");
 271                 abort ();
 272         }
 273
 274         return (buffer);
 275 }
 276
 277 static void
 278 reset_lsmb (union lsm_buffer *lsmb)
 279 {
 280         memset (lsmb->space, 0, sizeof (lsmb->space));
 281         lsmb->lsm.lsm_magic = LOV_MAGIC;
 282 }
 283
 284 static int
 285 parse_lsm (union lsm_buffer *lsmb, char *string)
 286 {
 287         struct lov_stripe_md *lsm = &lsmb->lsm;
 288         char                 *end;
 289         int                   i;
 290
 291         /*
 292          * object_id[=size#count[@offset:id]*]
 293          */
 294
 295         reset_lsmb (lsmb);
 296
 297         lsm->lsm_object_id = strtoull (string, &end, 0);
 298         if (end == string)
 299                 return (-1);
 300         string = end;
 301
 302         if (*string == 0)
 303                 return (0);
 304
 305         if (*string != '=')
 306                 return (-1);
 307         string++;
 308
 309         lsm->lsm_stripe_size = strtoul (string, &end, 0);
 310         if (end == string)
 311                 return (-1);
 312         string = end;
 313
 314         if (*string != '#')
 315                 return (-1);
 316         string++;
 317
 318         lsm->lsm_stripe_count = strtoul (string, &end, 0);
 319         if (end == string)
 320                 return (-1);
 321         string = end;
 322
 323         if (*string == 0)               /* don't have to specify obj ids */
 324                 return (0);
 325
 326         for (i = 0; i < lsm->lsm_stripe_count; i++) {
 327                 if (*string != '@')
 328                         return (-1);
 329                 string++;
 330                 lsm->lsm_oinfo[i].loi_ost_idx = strtoul(string, &end, 0);
 331                 if (*end != ':')
 332                         return (-1);
 333                 string = end + 1;
 334                 lsm->lsm_oinfo[i].loi_id = strtoull(string, &end, 0);
 335                 string = end;
 336         }
 337
 338         if (*string != 0)
 339                 return (-1);
 340
 341         return (0);
 342 }
 343
 344 char *jt_cmdname(char *func)
 345 {
 346         static char buf[512];
 347
 348         if (thread) {
 349                 sprintf(buf, "%s-%d", func, thread);
 350                 return buf;
 351         }
 352
 353         return func;
 354 }
 355
 356 #define difftime(a, b)                                  \
 357         ((a)->tv_sec - (b)->tv_sec +                    \
 358          ((a)->tv_usec - (b)->tv_usec) / 1000000.0)
 359
 360 static int be_verbose(int verbose, struct timeval *next_time,
 361                       __u64 num, __u64 *next_num, int num_total)
 362 {
 363         struct timeval now;
 364
 365         if (!verbose)
 366                 return 0;
 367
 368         if (next_time != NULL)
 369                 gettimeofday(&now, NULL);
 370
 371         /* A positive verbosity means to print every X iterations */
 372         if (verbose > 0 &&
 373             (next_num == NULL || num >= *next_num || num >= num_total)) {
 374                 *next_num += verbose;
 375                 if (next_time) {
 376                         next_time->tv_sec = now.tv_sec - verbose;
 377                         next_time->tv_usec = now.tv_usec;
 378                 }
 379                 return 1;
 380         }
 381
 382         /* A negative verbosity means to print at most each X seconds */
 383         if (verbose < 0 && next_time != NULL &&
 384             difftime(&now, next_time) >= 0.0){
 385                 next_time->tv_sec = now.tv_sec - verbose;
 386                 next_time->tv_usec = now.tv_usec;
 387                 if (next_num)
 388                         *next_num = num;
 389                 return 1;
 390         }
 391
 392         return 0;
 393 }
 394
 395 static int get_verbose(char *func, const char *arg)
 396 {
 397         int verbose;
 398         char *end;
 399
 400         if (!arg || arg[0] == 'v')
 401                 verbose = 1;
 402         else if (arg[0] == 's' || arg[0] == 'q')
 403                 verbose = 0;
 404         else {
 405                 verbose = (int)strtoul(arg, &end, 0);
 406                 if (*end) {
 407                         fprintf(stderr, "error: %s: bad verbose option '%s'\n",
 408                                 jt_cmdname(func), arg);
 409                         return BAD_VERBOSE;
 410                 }
 411         }
 412
 413         if (verbose < 0)
 414                 printf("Print status every %d seconds\n", -verbose);
 415         else if (verbose == 1)
 416                 printf("Print status every operation\n");
 417         else if (verbose > 1)
 418                 printf("Print status every %d operations\n", verbose);
 419
 420         return verbose;
 421 }
 422
 423 int do_disconnect(char *func, int verbose)
 424 {
 425         return 0;
 426 }
 427
 428 #if SHMEM_STATS
 429 static void shmem_setup(void)
 430 {
 431         /* Create new segment */
 432         int shmid = shmget(IPC_PRIVATE, sizeof(counter_snapshot[0]), 0600);
 433
 434         if (shmid == -1) {
 435                 fprintf(stderr, "Can't create shared memory counters: %s\n",
 436                         strerror(errno));
 437                 return;
 438         }
 439
 440         /* Attatch to new segment */
 441         shared_counters = (long long *)shmat(shmid, NULL, 0);
 442
 443         if (shared_counters == (long long *)(-1)) {
 444                 fprintf(stderr, "Can't attach shared memory counters: %s\n",
 445                         strerror(errno));
 446                 shared_counters = NULL;
 447                 return;
 448         }
 449
 450         /* Mark segment as destroyed, so it will disappear when we exit.
 451          * Forks will inherit attached segments, so we should be OK.
 452          */
 453         if (shmctl(shmid, IPC_RMID, NULL) == -1) {
 454                 fprintf(stderr, "Can't destroy shared memory counters: %s\n",
 455                         strerror(errno));
 456         }
 457 }
 458
 459 static inline void shmem_reset(void)
 460 {
 461         if (shared_counters == NULL)
 462                 return;
 463
 464         memset(shared_counters, 0, sizeof(counter_snapshot[0]));
 465         memset(counter_snapshot, 0, sizeof(counter_snapshot));
 466         gettimeofday(&prev_time, NULL);
 467 }
 468
 469 static inline void shmem_bump(void)
 470 {
 471         if (shared_counters == NULL || thread <= 0 || thread > MAX_SHMEM_COUNT)
 472                 return;
 473
 474         shared_counters[thread - 1]++;
 475 }
 476
 477 static void shmem_snap(int n)
 478 {
 479         struct timeval this_time;
 480         int non_zero = 0;
 481         long long total = 0;
 482         double secs;
 483         int i;
 484
 485         if (shared_counters == NULL || n > MAX_SHMEM_COUNT)
 486                 return;
 487
 488         memcpy(counter_snapshot[1], counter_snapshot[0],
 489                n * sizeof(counter_snapshot[0][0]));
 490         memcpy(counter_snapshot[0], shared_counters,
 491                n * sizeof(counter_snapshot[0][0]));
 492         gettimeofday(&this_time, NULL);
 493
 494         for (i = 0; i < n; i++) {
 495                 long long this_count =
 496                         counter_snapshot[0][i] - counter_snapshot[1][i];
 497
 498                 if (this_count != 0) {
 499                         non_zero++;
 500                         total += this_count;
 501                 }
 502         }
 503
 504         secs = (this_time.tv_sec + this_time.tv_usec / 1000000.0) -
 505                 (prev_time.tv_sec + prev_time.tv_usec / 1000000.0);
 506
 507         printf("%d/%d Total: %f/second\n", non_zero, n, total / secs);
 508
 509         prev_time = this_time;
 510 }
 511
 512 #define SHMEM_SETUP()   shmem_setup()
 513 #define SHMEM_RESET()   shmem_reset()
 514 #define SHMEM_BUMP()    shmem_bump()
 515 #define SHMEM_SNAP(n)   shmem_snap(n)
 516 #else
 517 #define SHMEM_SETUP()
 518 #define SHMEM_RESET()
 519 #define SHMEM_BUMP()
 520 #define SHMEM_SNAP(n)
 521 #endif
 522
 523 extern command_t cmdlist[];
 524
 525 static int do_device(char *func, int dev)
 526 {
 527         struct obd_ioctl_data data;
 528
 529         memset(&data, 0, sizeof(data));
 530
 531         data.ioc_dev = dev;
 532
 533         IOC_PACK(func, data);
 534         return l2_ioctl(OBD_DEV_ID, OBD_IOC_DEVICE, buf);
 535 }
 536
 537 int jt_obd_device(int argc, char **argv)
 538 {
 539         int rc, dev;
 540         do_disconnect(argv[0], 1);
 541
 542         if (argc != 2)
 543                 return CMD_HELP;
 544
 545         dev = parse_devname(argv[0], argv[1]);
 546         if (dev < 0)
 547                 return -1;
 548
 549         rc = do_device(argv[0], dev);
 550         if (rc < 0)
 551                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 552                         strerror(rc = errno));
 553
 554         return rc;
 555 }
 556
 557 int jt_obd_connect(int argc, char **argv)
 558 {
 559         struct obd_ioctl_data data;
 560         int rc;
 561
 562         IOC_INIT(data);
 563
 564         do_disconnect(argv[0], 1);
 565
 566         /* XXX TODO: implement timeout per lctl usage for probe */
 567         if (argc != 1)
 568                 return CMD_HELP;
 569
 570         IOC_PACK(argv[0], data);
 571         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_CONNECT, buf);
 572         IOC_UNPACK(argv[0], data);
 573         if (rc < 0)
 574                 fprintf(stderr, "error: %s: OBD_IOC_CONNECT %s\n",
 575                         jt_cmdname(argv[0]), strerror(rc = errno));
 576         else
 577                 conn_cookie = data.ioc_cookie;
 578         return rc;
 579 }
 580
 581 int jt_obd_disconnect(int argc, char **argv)
 582 {
 583         if (argc != 1)
 584                 return CMD_HELP;
 585
 586         if (conn_cookie == -1)
 587                 return 0;
 588
 589         return do_disconnect(argv[0], 0);
 590 }
 591
 592 int jt_opt_device(int argc, char **argv)
 593 {
 594         char *arg2[3];
 595         int ret;
 596         int rc;
 597
 598         if (argc < 3)
 599                 return CMD_HELP;
 600
 601         rc = do_device("device", parse_devname(argv[0], argv[1]));
 602
 603         if (!rc) {
 604                 arg2[0] = "connect";
 605                 arg2[1] = NULL;
 606                 rc = jt_obd_connect(1, arg2);
 607         }
 608
 609         if (!rc)
 610                 rc = Parser_execarg(argc - 2, argv + 2, cmdlist);
 611
 612         ret = do_disconnect(argv[0], 0);
 613         if (!rc)
 614                 rc = ret;
 615
 616         return rc;
 617 }
 618
 619 int jt_opt_threads(int argc, char **argv)
 620 {
 621         __u64 threads, next_thread;
 622         int verbose;
 623         int rc = 0;
 624         char *end;
 625         int i;
 626
 627         if (argc < 5)
 628                 return CMD_HELP;
 629
 630         threads = strtoull(argv[1], &end, 0);
 631         if (*end) {
 632                 fprintf(stderr, "error: %s: invalid page count '%s'\n",
 633                         jt_cmdname(argv[0]), argv[1]);
 634                 return CMD_HELP;
 635         }
 636
 637         verbose = get_verbose(argv[0], argv[2]);
 638         if (verbose == BAD_VERBOSE)
 639                 return CMD_HELP;
 640
 641         if (verbose != 0)
 642                 printf("%s: starting "LPD64" threads on device %s running %s\n",
 643                        argv[0], threads, argv[3], argv[4]);
 644
 645         SHMEM_RESET();
 646
 647         for (i = 1, next_thread = verbose; i <= threads; i++) {
 648                 rc = fork();
 649                 if (rc < 0) {
 650                         fprintf(stderr, "error: %s: #%d - %s\n", argv[0], i,
 651                                 strerror(rc = errno));
 652                         break;
 653                 } else if (rc == 0) {
 654                         thread = i;
 655                         argv[2] = "--device";
 656                         return jt_opt_device(argc - 2, argv + 2);
 657                 } else if (be_verbose(verbose, NULL, i, &next_thread, threads))
 658                         printf("%s: thread #%d (PID %d) started\n",
 659                                argv[0], i, rc);
 660                 rc = 0;
 661         }
 662
 663         if (!thread) {          /* parent process */
 664                 int live_threads = threads;
 665
 666                 while (live_threads > 0) {
 667                         int status;
 668                         pid_t ret;
 669
 670                         ret = waitpid(0, &status, verbose < 0 ? WNOHANG : 0);
 671                         if (ret == 0) {
 672                                 if (verbose >= 0)
 673                                         abort();
 674
 675                                 sleep(-verbose);
 676                                 SHMEM_SNAP(threads);
 677                                 continue;
 678                         }
 679
 680                         if (ret < 0) {
 681                                 fprintf(stderr, "error: %s: wait - %s\n",
 682                                         argv[0], strerror(errno));
 683                                 if (!rc)
 684                                         rc = errno;
 685                         } else {
 686                                 /*
 687                                  * This is a hack.  We _should_ be able to use
 688                                  * WIFEXITED(status) to see if there was an
 689                                  * error, but it appears to be broken and it
 690                                  * always returns 1 (OK).  See wait(2).
 691                                  */
 692                                 int err = WEXITSTATUS(status);
 693                                 if (err || WIFSIGNALED(status))
 694                                         fprintf(stderr,
 695                                                 "%s: PID %d had rc=%d\n",
 696                                                 argv[0], ret, err);
 697                                 if (!rc)
 698                                         rc = err;
 699
 700                                 live_threads--;
 701                         }
 702                 }
 703         }
 704
 705         return rc;
 706 }
 707
 708 int jt_opt_net(int argc, char **argv)
 709 {
 710         char *arg2[3];
 711         int rc;
 712
 713         if (argc < 3)
 714                 return CMD_HELP;
 715
 716         arg2[0] = argv[0];
 717         arg2[1] = argv[1];
 718         arg2[2] = NULL;
 719         rc = jt_ptl_network (2, arg2);
 720
 721         if (!rc)
 722                 rc = Parser_execarg(argc - 2, argv + 2, cmdlist);
 723
 724         return rc;
 725 }
 726
 727 int jt_obd_no_transno(int argc, char **argv)
 728 {
 729         struct obd_ioctl_data data;
 730         int rc;
 731
 732         IOC_INIT(data);
 733
 734         if (argc != 1)
 735                 return CMD_HELP;
 736
 737         IOC_PACK(argv[0], data);
 738         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_NO_TRANSNO, buf);
 739         if (rc < 0)
 740                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 741                         strerror(rc = errno));
 742
 743         return rc;
 744 }
 745
 746 int jt_obd_set_readonly(int argc, char **argv)
 747 {
 748         struct obd_ioctl_data data;
 749         int rc;
 750
 751         IOC_INIT(data);
 752
 753         if (argc != 1)
 754                 return CMD_HELP;
 755
 756         IOC_PACK(argv[0], data);
 757         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_SET_READONLY, buf);
 758         if (rc < 0)
 759                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 760                         strerror(rc = errno));
 761
 762         return rc;
 763 }
 764
 765 int jt_obd_abort_recovery(int argc, char **argv)
 766 {
 767         struct obd_ioctl_data data;
 768         int rc;
 769
 770         IOC_INIT(data);
 771
 772         if (argc != 1)
 773                 return CMD_HELP;
 774
 775         IOC_PACK(argv[0], data);
 776         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_ABORT_RECOVERY, buf);
 777         if (rc < 0)
 778                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 779                         strerror(rc = errno));
 780
 781         return rc;
 782 }
 783
 784 int jt_get_version(int argc, char **argv)
 785 {
 786         int rc;
 787         char buf[8192];
 788         struct obd_ioctl_data *data = (struct obd_ioctl_data *)buf;
 789
 790         if (argc != 1)
 791                 return CMD_HELP;
 792
 793         memset(buf, 0, sizeof(buf));
 794         data->ioc_version = OBD_IOCTL_VERSION;
 795         data->ioc_cookie = conn_cookie;
 796         data->ioc_inllen1 = sizeof(buf) - size_round(sizeof(*data));
 797         data->ioc_len = obd_ioctl_packlen(data);
 798
 799         rc = l2_ioctl(OBD_DEV_ID, OBD_GET_VERSION, buf);
 800         if (rc < 0)
 801                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 802                         strerror(rc = errno));
 803         else {
 804                 printf("Lustre version: %s\n", data->ioc_bulk);
 805         }
 806
 807         printf("lctl   version: %s\n", BUILD_VERSION);
 808         return rc;
 809 }
 810
 811 int jt_obd_list(int argc, char **argv)
 812 {
 813         int rc;
 814         char buf[OBD_MAX_IOCTL_BUFFER];
 815         struct obd_ioctl_data *data = (struct obd_ioctl_data *)buf;
 816
 817         if (argc != 1)
 818                 return CMD_HELP;
 819
 820         memset(buf, 0, sizeof(buf));
 821         data->ioc_version = OBD_IOCTL_VERSION;
 822         data->ioc_cookie = conn_cookie;
 823         data->ioc_inllen1 = sizeof(buf) - size_round(sizeof(*data));
 824         data->ioc_len = obd_ioctl_packlen(data);
 825
 826         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_LIST, data);
 827         if (rc < 0)
 828                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 829                         strerror(rc = errno));
 830         else {
 831                 printf("%s", data->ioc_bulk);
 832         }
 833
 834         return rc;
 835 }
 836
 837 /* Get echo client's stripe meta-data for the given object
 838  */
 839 int jt_obd_get_stripe (int argc, char **argv)
 840 {
 841         struct obd_ioctl_data data;
 842         __u64 id;
 843         int   rc;
 844         char *end;
 845
 846         if (argc != 2)
 847                 return (CMD_HELP);
 848
 849         id = strtoull (argv[1], &end, 0);
 850         if (*end) {
 851                 fprintf (stderr, "Error: %s: invalid object id '%s'\n",
 852                          jt_cmdname (argv[0]), argv[1]);
 853                 return (CMD_HELP);
 854         }
 855
 856         memset (&lsm_buffer, 0, sizeof (lsm_buffer));
 857
 858         IOC_INIT (data);
 859         data.ioc_obdo1.o_id = id;
 860         data.ioc_obdo1.o_mode = S_IFREG | 0644;
 861         data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLMODE;
 862         data.ioc_pbuf1 = (char *)&lsm_buffer;
 863         data.ioc_plen1 = sizeof (lsm_buffer);
 864
 865         IOC_PACK(argv[0], data);
 866         rc = l2_ioctl(OBD_DEV_ID, ECHO_IOC_GET_STRIPE, buf);
 867         IOC_UNPACK(argv[0], data);
 868
 869         if (rc != 0) {
 870                 fprintf (stderr, "Error: %s: rc %d(%s)\n",
 871                          jt_cmdname (argv[0]), rc, strerror (errno));
 872                 return (rc);
 873         }
 874
 875         printf ("%s\n", lsm_string (&lsm_buffer.lsm));
 876
 877         return (rc);
 878 }
 879
 880 /* Set stripe meta-data for 1 or more objects.  Object must be new to
 881  * this echo client instance.
 882  */
 883 int jt_obd_set_stripe (int argc, char **argv)
 884 {
 885         struct obd_ioctl_data data;
 886         char *end;
 887         int count = 1;
 888         int i;
 889         int rc;
 890
 891         if (argc < 2 || argc > 3)
 892                 return CMD_HELP;
 893
 894         rc = parse_lsm (&lsm_buffer, argv[1]);
 895         if (rc != 0) {
 896                 fprintf (stderr, "error: %s: invalid object '%s'\n",
 897                          jt_cmdname (argv[0]), argv[1]);
 898                 return CMD_HELP;
 899         }
 900
 901         if (argc > 2) {
 902                 count = strtol (argv[2], &end, 0);
 903                 if (*end != 0) {
 904                         fprintf (stderr, "error: %s: invalid count '%s'\n",
 905                                  jt_cmdname (argv[0]), argv[1]);
 906                         return CMD_HELP;
 907                 }
 908         }
 909
 910         for (i = 0; i < count; i++) {
 911                 IOC_INIT (data);
 912                 data.ioc_obdo1.o_id = lsm_buffer.lsm.lsm_object_id + i;
 913                 data.ioc_obdo1.o_mode = S_IFREG | 0644;
 914                 data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLMODE;
 915                 data.ioc_pbuf1 = (char *)&lsm_buffer;
 916                 data.ioc_plen1 = sizeof (lsm_buffer);
 917
 918                 IOC_PACK (argv[0], data);
 919                 rc = l2_ioctl (OBD_DEV_ID, ECHO_IOC_SET_STRIPE, buf);
 920                 IOC_UNPACK (argv[0], data);
 921
 922                 if (rc != 0) {
 923                         fprintf (stderr, "Error: %s: rc %d(%s)\n",
 924                                  jt_cmdname (argv[0]), rc, strerror (errno));
 925                         return (rc);
 926                 }
 927         }
 928
 929         return (0);
 930 }
 931
 932 /* Clear stripe meta-data info for an object on this echo-client instance
 933  */
 934 int jt_obd_unset_stripe (int argc, char **argv)
 935 {
 936         struct obd_ioctl_data data;
 937         char *end;
 938         obd_id id;
 939         int rc;
 940
 941         if (argc != 2)
 942                 return CMD_HELP;
 943
 944         id = strtoull (argv[1], &end, 0);
 945         if (*end != 0) {
 946                 fprintf (stderr, "error: %s: invalid object id '%s'\n",
 947                          jt_cmdname (argv[0]), argv[1]);
 948                 return CMD_HELP;
 949         }
 950
 951         IOC_INIT (data);
 952         data.ioc_obdo1.o_id = id;
 953         data.ioc_obdo1.o_mode = S_IFREG | 0644;
 954         data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLMODE;
 955
 956         IOC_PACK (argv[0], data);
 957         rc = l2_ioctl (OBD_DEV_ID, ECHO_IOC_SET_STRIPE, buf);
 958         IOC_UNPACK (argv[0], data);
 959
 960         if (rc != 0)
 961                 fprintf (stderr, "Error: %s: rc %d(%s)\n",
 962                          jt_cmdname (argv[0]), rc, strerror (errno));
 963
 964         return (0);
 965 }
 966
 967 /* Create one or more objects, arg[4] may describe stripe meta-data.  If
 968  * not, defaults assumed.  This echo-client instance stashes the stripe
 969  * object ids.  Use get_stripe on this node to print full lsm and
 970  * set_stripe on another node to cut/paste between nodes.
 971  */
 972 int jt_obd_create(int argc, char **argv)
 973 {
 974         struct obd_ioctl_data data;
 975         struct timeval next_time;
 976         __u64 count = 1, next_count, base_id = 0;
 977         int verbose = 1, mode = 0100644, rc = 0, i, valid_lsm = 0;
 978         char *end;
 979
 980         IOC_INIT(data);
 981         if (argc < 2 || argc > 5)
 982                 return CMD_HELP;
 983
 984         count = strtoull(argv[1], &end, 0);
 985         if (*end) {
 986                 fprintf(stderr, "error: %s: invalid iteration count '%s'\n",
 987                         jt_cmdname(argv[0]), argv[1]);
 988                 return CMD_HELP;
 989         }
 990
 991         if (argc > 2) {
 992                 mode = strtoul(argv[2], &end, 0);
 993                 if (*end) {
 994                         fprintf(stderr, "error: %s: invalid mode '%s'\n",
 995                                 jt_cmdname(argv[0]), argv[2]);
 996                         return CMD_HELP;
 997                 }
 998                 if (!(mode & S_IFMT))
 999                         mode |= S_IFREG;
1000         }
1001
1002         if (argc > 3) {
1003                 verbose = get_verbose(argv[0], argv[3]);
1004                 if (verbose == BAD_VERBOSE)
1005                         return CMD_HELP;
1006         }
1007
1008         if (argc < 5)
1009                 reset_lsmb (&lsm_buffer);       /* will set default */
1010         else {
1011                 rc = parse_lsm (&lsm_buffer, argv[4]);
1012                 if (rc != 0) {
1013                         fprintf(stderr, "error: %s: invalid lsm '%s'\n",
1014                                 jt_cmdname(argv[0]), argv[4]);
1015                         return CMD_HELP;
1016                 }
1017                 base_id = lsm_buffer.lsm.lsm_object_id;
1018                 valid_lsm = 1;
1019         }
1020
1021         printf("%s: "LPD64" objects\n", jt_cmdname(argv[0]), count);
1022         gettimeofday(&next_time, NULL);
1023         next_time.tv_sec -= verbose;
1024
1025         for (i = 1, next_count = verbose; i <= count; i++) {
1026                 data.ioc_obdo1.o_mode = mode;
1027                 data.ioc_obdo1.o_id = base_id;
1028                 data.ioc_obdo1.o_uid = 0;
1029                 data.ioc_obdo1.o_gid = 0;
1030                 data.ioc_obdo1.o_valid = OBD_MD_FLTYPE | OBD_MD_FLMODE |
1031                         OBD_MD_FLID | OBD_MD_FLUID | OBD_MD_FLGID;
1032
1033                 if (valid_lsm) {
1034                         data.ioc_plen1 = sizeof lsm_buffer;
1035                         data.ioc_pbuf1 = (char *)&lsm_buffer;
1036                 }
1037
1038                 IOC_PACK(argv[0], data);
1039                 rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_CREATE, buf);
1040                 IOC_UNPACK(argv[0], data);
1041                 SHMEM_BUMP();
1042                 if (rc < 0) {
1043                         fprintf(stderr, "error: %s: #%d - %s\n",
1044                                 jt_cmdname(argv[0]), i, strerror(rc = errno));
1045                         break;
1046                 }
1047                 if (!(data.ioc_obdo1.o_valid & OBD_MD_FLID)) {
1048                         fprintf(stderr, "error: %s: objid not valid #%d:%08x\n",
1049                                 jt_cmdname(argv[0]), i, data.ioc_obdo1.o_valid);
1050                         rc = EINVAL;
1051                         break;
1052                 }
1053
1054                 if (be_verbose(verbose, &next_time, i, &next_count, count))
1055                         printf("%s: #%d is object id "LPX64"\n",
1056                                 jt_cmdname(argv[0]), i, data.ioc_obdo1.o_id);
1057         }
1058         return rc;
1059 }
1060
1061 int jt_obd_setattr(int argc, char **argv)
1062 {
1063         struct obd_ioctl_data data;
1064         char *end;
1065         int rc;
1066
1067         IOC_INIT(data);
1068         if (argc != 2)
1069                 return CMD_HELP;
1070
1071         data.ioc_obdo1.o_id = strtoull(argv[1], &end, 0);
1072         if (*end) {
1073                 fprintf(stderr, "error: %s: invalid objid '%s'\n",
1074                         jt_cmdname(argv[0]), argv[1]);
1075                 return CMD_HELP;
1076         }
1077         data.ioc_obdo1.o_mode = S_IFREG | strtoul(argv[2], &end, 0);
1078         if (*end) {
1079                 fprintf(stderr, "error: %s: invalid mode '%s'\n",
1080                         jt_cmdname(argv[0]), argv[2]);
1081                 return CMD_HELP;
1082         }
1083         data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE;
1084
1085         IOC_PACK(argv[0], data);
1086         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_SETATTR, buf);
1087         if (rc < 0)
1088                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
1089                         strerror(rc = errno));
1090
1091         return rc;
1092 }
1093
1094 int jt_obd_destroy(int argc, char **argv)
1095 {
1096         struct obd_ioctl_data data;
1097         struct timeval next_time;
1098         __u64 count = 1, next_count;
1099         int verbose = 1;
1100         __u64 id;
1101         char *end;
1102         int rc = 0, i;
1103
1104         IOC_INIT(data);
1105         if (argc < 2 || argc > 4)
1106                 return CMD_HELP;
1107
1108         id = strtoull(argv[1], &end, 0);
1109         if (*end) {
1110                 fprintf(stderr, "error: %s: invalid objid '%s'\n",
1111                         jt_cmdname(argv[0]), argv[1]);
1112                 return CMD_HELP;
1113         }
1114         if (argc > 2) {
1115                 count = strtoull(argv[2], &end, 0);
1116                 if (*end) {
1117                         fprintf(stderr,
1118                                 "error: %s: invalid iteration count '%s'\n",
1119                                 jt_cmdname(argv[0]), argv[2]);
1120                         return CMD_HELP;
1121                 }
1122         }
1123
1124         if (argc > 3) {
1125                 verbose = get_verbose(argv[0], argv[3]);
1126                 if (verbose == BAD_VERBOSE)
1127                         return CMD_HELP;
1128         }
1129
1130         printf("%s: "LPD64" objects\n", jt_cmdname(argv[0]), count);
1131         gettimeofday(&next_time, NULL);
1132         next_time.tv_sec -= verbose;
1133
1134         for (i = 1, next_count = verbose; i <= count; i++, id++) {
1135                 data.ioc_obdo1.o_id = id;
1136                 data.ioc_obdo1.o_mode = S_IFREG | 0644;
1137                 data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLMODE;
1138
1139                 IOC_PACK(argv[0], data);
1140                 rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_DESTROY, buf);
1141                 IOC_UNPACK(argv[0], data);
1142                 SHMEM_BUMP();
1143                 if (rc < 0) {
1144                         fprintf(stderr, "error: %s: objid "LPX64": %s\n",
1145                                 jt_cmdname(argv[0]), id, strerror(rc = errno));
1146                         break;
1147                 }
1148
1149                 if (be_verbose(verbose, &next_time, i, &next_count, count))
1150                         printf("%s: #%d is object id "LPX64"\n",
1151                                jt_cmdname(argv[0]), i, id);
1152         }
1153
1154         return rc;
1155 }
1156
1157 int jt_obd_getattr(int argc, char **argv)
1158 {
1159         struct obd_ioctl_data data;
1160         char *end;
1161         int rc;
1162
1163         if (argc != 2)
1164                 return CMD_HELP;
1165
1166         IOC_INIT(data);
1167         data.ioc_obdo1.o_id = strtoull(argv[1], &end, 0);
1168         if (*end) {
1169                 fprintf(stderr, "error: %s: invalid objid '%s'\n",
1170                         jt_cmdname(argv[0]), argv[1]);
1171                 return CMD_HELP;
1172         }
1173         /* to help obd filter */
1174         data.ioc_obdo1.o_mode = 0100644;
1175         data.ioc_obdo1.o_valid = 0xffffffff;
1176         printf("%s: object id "LPX64"\n", jt_cmdname(argv[0]),data.ioc_obdo1.o_id);
1177
1178         IOC_PACK(argv[0], data);
1179         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_GETATTR, buf);
1180         IOC_UNPACK(argv[0], data);
1181         if (rc) {
1182                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
1183                         strerror(rc = errno));
1184         } else {
1185                 printf("%s: object id "LPX64", mode %o\n", jt_cmdname(argv[0]),
1186                        data.ioc_obdo1.o_id, data.ioc_obdo1.o_mode);
1187         }
1188         return rc;
1189 }
1190
1191 int jt_obd_test_getattr(int argc, char **argv)
1192 {
1193         struct obd_ioctl_data data;
1194         struct timeval start, next_time;
1195         __u64 i, count, next_count;
1196         int verbose = 1;
1197         obd_id objid = 3;
1198         char *end;
1199         int rc = 0;
1200
1201         if (argc < 2 && argc > 4)
1202                 return CMD_HELP;
1203
1204         IOC_INIT(data);
1205         count = strtoull(argv[1], &end, 0);
1206         if (*end) {
1207                 fprintf(stderr, "error: %s: invalid iteration count '%s'\n",
1208                         jt_cmdname(argv[0]), argv[1]);
1209                 return CMD_HELP;
1210         }
1211
1212         if (argc >= 3) {
1213                 verbose = get_verbose(argv[0], argv[2]);
1214                 if (verbose == BAD_VERBOSE)
1215                         return CMD_HELP;
1216         }
1217
1218         if (argc >= 4) {
1219                 if (argv[3][0] == 't') {
1220                         objid = strtoull(argv[3] + 1, &end, 0);
1221                         if (thread)
1222                                 objid += thread - 1;
1223                 } else
1224                         objid = strtoull(argv[3], &end, 0);
1225                 if (*end) {
1226                         fprintf(stderr, "error: %s: invalid objid '%s'\n",
1227                                 jt_cmdname(argv[0]), argv[3]);
1228                         return CMD_HELP;
1229                 }
1230         }
1231
1232         gettimeofday(&start, NULL);
1233         next_time.tv_sec = start.tv_sec - verbose;
1234         next_time.tv_usec = start.tv_usec;
1235         if (verbose != 0)
1236                 printf("%s: getting "LPD64" attrs (objid "LPX64"): %s",
1237                        jt_cmdname(argv[0]), count, objid, ctime(&start.tv_sec));
1238
1239         for (i = 1, next_count = verbose; i <= count; i++) {
1240                 data.ioc_obdo1.o_id = objid;
1241                 data.ioc_obdo1.o_mode = S_IFREG;
1242                 data.ioc_obdo1.o_valid = 0xffffffff;
1243                 IOC_PACK(argv[0], data);
1244                 rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_GETATTR, &data);
1245                 SHMEM_BUMP();
1246                 if (rc < 0) {
1247                         fprintf(stderr, "error: %s: #"LPD64" - %d:%s\n",
1248                                 jt_cmdname(argv[0]), i, errno, strerror(rc = errno));
1249                         break;
1250                 } else {
1251                         if (be_verbose
1252                             (verbose, &next_time, i, &next_count, count))
1253                                 printf("%s: got attr #"LPD64"\n",
1254                                        jt_cmdname(argv[0]), i);
1255                 }
1256         }
1257
1258         if (!rc) {
1259                 struct timeval end;
1260                 double diff;
1261
1262                 gettimeofday(&end, NULL);
1263
1264                 diff = difftime(&end, &start);
1265
1266                 --i;
1267                 if (verbose != 0)
1268                         printf("%s: "LPD64" attrs in %.3fs (%.3f attr/s): %s",
1269                                jt_cmdname(argv[0]), i, diff, i / diff,
1270                                ctime(&end.tv_sec));
1271         }
1272         return rc;
1273 }
1274
1275 int jt_obd_test_brw(int argc, char **argv)
1276 {
1277         struct obd_ioctl_data data;
1278         struct timeval start, next_time;
1279         __u64 count, next_count, len, thr_offset = 0, objid = 3;
1280         int write = 0, verbose = 1, cmd, i, rc = 0, pages = 1;
1281         char *end;
1282
1283         if (argc < 2 || argc > 7) {
1284                 fprintf(stderr, "error: %s: bad number of arguments: %d\n",
1285                         jt_cmdname(argv[0]), argc);
1286                 return CMD_HELP;
1287         }
1288
1289         /* make each thread write to a different offset */
1290         if (argv[1][0] == 't') {
1291                 count = strtoull(argv[1] + 1, &end, 0);
1292                 if (thread)
1293                         thr_offset = thread - 1;
1294         } else
1295                 count = strtoull(argv[1], &end, 0);
1296
1297         if (*end) {
1298                 fprintf(stderr, "error: %s: bad iteration count '%s'\n",
1299                         jt_cmdname(argv[0]), argv[1]);
1300                 return CMD_HELP;
1301         }
1302
1303         if (argc >= 3) {
1304                 if (argv[2][0] == 'w' || argv[2][0] == '1')
1305                         write = 1;
1306                 else if (argv[2][0] == 'r' || argv[2][0] == '0')
1307                         write = 0;
1308         }
1309
1310         if (argc >= 4) {
1311                 verbose = get_verbose(argv[0], argv[3]);
1312                 if (verbose == BAD_VERBOSE)
1313                         return CMD_HELP;
1314         }
1315
1316         if (argc >= 5) {
1317                 pages = strtoul(argv[4], &end, 0);
1318                 if (*end) {
1319                         fprintf(stderr, "error: %s: bad page count '%s'\n",
1320                                 jt_cmdname(argv[0]), argv[4]);
1321                         return CMD_HELP;
1322                 }
1323         }
1324         if (argc >= 6) {
1325                 if (argv[5][0] == 't') {
1326                         objid = strtoull(argv[5] + 1, &end, 0);
1327                         if (thread)
1328                                 objid += thread - 1;
1329                 } else
1330                         objid = strtoull(argv[5], &end, 0);
1331                 if (*end) {
1332                         fprintf(stderr, "error: %s: bad objid '%s'\n",
1333                                 jt_cmdname(argv[0]), argv[5]);
1334                         return CMD_HELP;
1335                 }
1336         }
1337
1338         IOC_INIT(data);
1339
1340         /* communicate the 'type' of brw test and batching to echo_client.
1341          * don't start.  we'd love to refactor this lctl->echo_client
1342          * interface */
1343         data.ioc_pbuf1 = (void *)1;
1344         data.ioc_plen1 = 1;
1345
1346         if (argc >= 7) {
1347                 switch(argv[6][0]) {
1348                         case 'g': /* plug and unplug */
1349                                 data.ioc_pbuf1 = (void *)2;
1350                                 data.ioc_plen1 = strtoull(argv[6] + 1, &end,
1351                                                           0);
1352                                 break;
1353                         case 'p': /* prep and commit */
1354                                 data.ioc_pbuf1 = (void *)3;
1355                                 data.ioc_plen1 = strtoull(argv[6] + 1, &end,
1356                                                           0);
1357                                 break;
1358                         default:
1359                                 fprintf(stderr, "error: %s: batching '%s' "
1360                                         "needs to specify 'p' or 'g'\n",
1361                                         jt_cmdname(argv[0]), argv[6]);
1362                                 return CMD_HELP;
1363                 }
1364
1365                 if (*end) {
1366                         fprintf(stderr, "error: %s: bad batching '%s'\n",
1367                                 jt_cmdname(argv[0]), argv[6]);
1368                         return CMD_HELP;
1369                 }
1370                 data.ioc_plen1 *= PAGE_SIZE;
1371         }
1372
1373         len = pages * PAGE_SIZE;
1374
1375         data.ioc_obdo1.o_id = objid;
1376         data.ioc_obdo1.o_mode = S_IFREG;
1377         data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE;
1378         data.ioc_count = len;
1379         data.ioc_offset = thr_offset * len * count;
1380
1381         gettimeofday(&start, NULL);
1382         next_time.tv_sec = start.tv_sec - verbose;
1383         next_time.tv_usec = start.tv_usec;
1384
1385         if (verbose != 0)
1386                 printf("%s: %s "LPU64"x%d pages (obj "LPX64", off "LPU64"): %s",
1387                        jt_cmdname(argv[0]), write ? "writing" : "reading", count,
1388                        pages, objid, data.ioc_offset, ctime(&start.tv_sec));
1389
1390         cmd = write ? OBD_IOC_BRW_WRITE : OBD_IOC_BRW_READ;
1391         for (i = 1, next_count = verbose; i <= count; i++) {
1392                 data.ioc_obdo1.o_valid &= ~(OBD_MD_FLBLOCKS|OBD_MD_FLGRANT);
1393                 IOC_PACK(argv[0], data);
1394                 rc = l2_ioctl(OBD_DEV_ID, cmd, buf);
1395                 SHMEM_BUMP();
1396                 if (rc) {
1397                         fprintf(stderr, "error: %s: #%d - %s on %s\n",
1398                                 jt_cmdname(argv[0]), i, strerror(rc = errno),
1399                                 write ? "write" : "read");
1400                         break;
1401                 } else if (be_verbose(verbose, &next_time,i, &next_count,count))
1402                         printf("%s: %s number %dx%d\n", jt_cmdname(argv[0]),
1403                                write ? "write" : "read", i, pages);
1404
1405                 data.ioc_offset += len;
1406         }
1407
1408         if (!rc) {
1409                 struct timeval end;
1410                 double diff;
1411
1412                 gettimeofday(&end, NULL);
1413
1414                 diff = difftime(&end, &start);
1415
1416                 --i;
1417                 if (verbose != 0)
1418                         printf("%s: %s %dx%d pages in %.3fs (%.3f MB/s): %s",
1419                                jt_cmdname(argv[0]), write ? "wrote" : "read",
1420                                i, pages, diff,
1421                                ((double)i * pages * getpagesize()) /
1422                                (diff * 1048576.0),
1423                                ctime(&end.tv_sec));
1424         }
1425
1426         return rc;
1427 }
1428
1429 int jt_obd_lov_getconfig(int argc, char **argv)
1430 {
1431         struct obd_ioctl_data data;
1432         struct lov_desc desc;
1433         struct obd_uuid *uuidarray;
1434         char *path;
1435         int rc, fd;
1436
1437         IOC_INIT(data);
1438
1439         if (argc != 2)
1440                 return CMD_HELP;
1441
1442         path = argv[1];
1443         fd = open(path, O_RDONLY);
1444         if (fd < 0) {
1445                 fprintf(stderr, "open \"%s\" failed: %s\n", path,
1446                         strerror(errno));
1447                 return -1;
1448         }
1449
1450         memset(&desc, 0, sizeof(desc));
1451         obd_str2uuid(&desc.ld_uuid, argv[1]);
1452         desc.ld_tgt_count = ((OBD_MAX_IOCTL_BUFFER-sizeof(data)-sizeof(desc)) /
1453                              sizeof(*uuidarray));
1454
1455 repeat:
1456         uuidarray = calloc(desc.ld_tgt_count, sizeof(*uuidarray));
1457         if (!uuidarray) {
1458                 fprintf(stderr, "error: %s: no memory for %d uuid's\n",
1459                         jt_cmdname(argv[0]), desc.ld_tgt_count);
1460                 rc = -ENOMEM;
1461                 goto out;
1462         }
1463
1464         data.ioc_inllen1 = sizeof(desc);
1465         data.ioc_inlbuf1 = (char *)&desc;
1466         data.ioc_inllen2 = desc.ld_tgt_count * sizeof(*uuidarray);
1467         data.ioc_inlbuf2 = (char *)uuidarray;
1468
1469         if (obd_ioctl_pack(&data, &buf, max)) {
1470                 fprintf(stderr, "error: %s: invalid ioctl\n",
1471                         jt_cmdname(argv[0]));
1472                 rc = -EINVAL;
1473                 goto out;
1474         }
1475         rc = ioctl(fd, OBD_IOC_LOV_GET_CONFIG, buf);
1476         if (rc == -ENOSPC) {
1477                 free(uuidarray);
1478                 goto repeat;
1479         } else if (rc) {
1480                 fprintf(stderr, "error: %s: ioctl error: %s\n",
1481                         jt_cmdname(argv[0]), strerror(rc = errno));
1482         } else {
1483                 struct obd_uuid *ptr;
1484                 int i;
1485
1486                 if (obd_ioctl_unpack(&data, buf, max)) {
1487                         fprintf(stderr, "error: %s: invalid reply\n",
1488                                 jt_cmdname(argv[0]));
1489                         rc = -EINVAL;
1490                         goto out;
1491                 }
1492                 printf("default_stripe_count: %u\n",
1493                        desc.ld_default_stripe_count);
1494                 printf("default_stripe_size: "LPU64"\n",
1495                        desc.ld_default_stripe_size);
1496                 printf("default_stripe_offset: "LPU64"\n",
1497                        desc.ld_default_stripe_offset);
1498                 printf("default_stripe_pattern: %u\n", desc.ld_pattern);
1499                 printf("obd_count: %u\n", desc.ld_tgt_count);
1500                 for (i = 0, ptr = uuidarray; i < desc.ld_tgt_count; i++, ptr++)
1501                         printf("%u: %s\n", i, (char *)ptr);
1502         }
1503 out:
1504         free(uuidarray);
1505         close(fd);
1506         return rc;
1507 }
1508
1509 int jt_obd_test_ldlm(int argc, char **argv)
1510 {
1511         struct obd_ioctl_data data;
1512         int rc;
1513
1514         IOC_INIT(data);
1515         if (argc != 1)
1516                 return CMD_HELP;
1517
1518         IOC_PACK(argv[0], data);
1519         rc = l2_ioctl(OBD_DEV_ID, IOC_LDLM_TEST, buf);
1520         if (rc)
1521                 fprintf(stderr, "error: %s: test failed: %s\n",
1522                         jt_cmdname(argv[0]), strerror(rc = errno));
1523         return rc;
1524 }
1525
1526 int jt_obd_dump_ldlm(int argc, char **argv)
1527 {
1528         struct obd_ioctl_data data;
1529         int rc;
1530
1531         IOC_INIT(data);
1532         if (argc != 1)
1533                 return CMD_HELP;
1534
1535         IOC_PACK(argv[0], data);
1536         rc = l2_ioctl(OBD_DEV_ID, IOC_LDLM_DUMP, buf);
1537         if (rc)
1538                 fprintf(stderr, "error: %s failed: %s\n",
1539                         jt_cmdname(argv[0]), strerror(rc = errno));
1540         return rc;
1541 }
1542
1543 int jt_obd_ldlm_regress_start(int argc, char **argv)
1544 {
1545         int rc;
1546         struct obd_ioctl_data data;
1547         char argstring[200];
1548         int i, count = sizeof(argstring) - 1;
1549
1550         IOC_INIT(data);
1551         if (argc > 5)
1552                 return CMD_HELP;
1553
1554         argstring[0] = '\0';
1555         for (i = 1; i < argc; i++) {
1556                 strncat(argstring, " ", count);
1557                 count--;
1558                 strncat(argstring, argv[i], count);
1559                 count -= strlen(argv[i]);
1560         }
1561
1562         if (strlen(argstring)) {
1563                 data.ioc_inlbuf1 = argstring;
1564                 data.ioc_inllen1 = strlen(argstring) + 1;
1565         }
1566
1567         IOC_PACK(argv[0], data);
1568         rc = l2_ioctl(OBD_DEV_ID, IOC_LDLM_REGRESS_START, buf);
1569         if (rc)
1570                 fprintf(stderr, "error: %s: test failed: %s\n",
1571                         jt_cmdname(argv[0]), strerror(rc = errno));
1572
1573         return rc;
1574 }
1575
1576 int jt_obd_ldlm_regress_stop(int argc, char **argv)
1577 {
1578         int rc;
1579         struct obd_ioctl_data data;
1580         IOC_INIT(data);
1581
1582         if (argc != 1)
1583                 return CMD_HELP;
1584
1585         IOC_PACK(argv[0], data);
1586         rc = l2_ioctl(OBD_DEV_ID, IOC_LDLM_REGRESS_STOP, buf);
1587
1588         if (rc)
1589                 fprintf(stderr, "error: %s: test failed: %s\n",
1590                         jt_cmdname(argv[0]), strerror(rc = errno));
1591         return rc;
1592 }
1593
1594 static int do_activate(int argc, char **argv, int flag)
1595 {
1596         struct obd_ioctl_data data;
1597         int rc;
1598
1599         IOC_INIT(data);
1600         if (argc != 1)
1601                 return CMD_HELP;
1602
1603         /* reuse offset for 'active' */
1604         data.ioc_offset = flag;
1605
1606         IOC_PACK(argv[0], data);
1607         rc = l2_ioctl(OBD_DEV_ID, IOC_OSC_SET_ACTIVE, buf);
1608         if (rc)
1609                 fprintf(stderr, "error: %s: failed: %s\n",
1610                         jt_cmdname(argv[0]), strerror(rc = errno));
1611
1612         return rc;
1613 }
1614
1615 int jt_obd_deactivate(int argc, char **argv)
1616 {
1617         return do_activate(argc, argv, 0);
1618 }
1619
1620 int jt_obd_activate(int argc, char **argv)
1621 {
1622         return do_activate(argc, argv, 1);
1623 }
1624
1625 int jt_obd_recover(int argc, char **argv)
1626 {
1627         int rc;
1628         struct obd_ioctl_data data;
1629
1630         IOC_INIT(data);
1631         if (argc > 2)
1632                 return CMD_HELP;
1633
1634         if (argc == 2) {
1635                 data.ioc_inllen1 = strlen(argv[1]) + 1;
1636                 data.ioc_inlbuf1 = argv[1];
1637         }
1638
1639         IOC_PACK(argv[0], data);
1640         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_CLIENT_RECOVER, buf);
1641         if (rc < 0) {
1642                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
1643                         strerror(rc = errno));
1644         }
1645
1646         return rc;
1647 }
1648
1649 int jt_obd_mdc_lookup(int argc, char **argv)
1650 {
1651         struct obd_ioctl_data data;
1652         char *parent, *child;
1653         int rc, fd, verbose = 1;
1654
1655         if (argc < 3 || argc > 4)
1656                 return CMD_HELP;
1657
1658         parent = argv[1];
1659         child = argv[2];
1660         if (argc == 4)
1661                 verbose = get_verbose(argv[0], argv[3]);
1662
1663         IOC_INIT(data);
1664
1665         data.ioc_inllen1 = strlen(child) + 1;
1666         data.ioc_inlbuf1 = child;
1667
1668         IOC_PACK(argv[0], data);
1669
1670         fd = open(parent, O_RDONLY);
1671         if (fd < 0) {
1672                 fprintf(stderr, "open \"%s\" failed: %s\n", parent,
1673                         strerror(errno));
1674                 return -1;
1675         }
1676
1677         rc = ioctl(fd, IOC_MDC_LOOKUP, buf);
1678         if (rc < 0) {
1679                 fprintf(stderr, "error: %s: ioctl error: %s\n",
1680                         jt_cmdname(argv[0]), strerror(rc = errno));
1681         }
1682         close(fd);
1683
1684         if (verbose) {
1685                 IOC_UNPACK(argv[0], data);
1686                 printf("%s: mode %o uid %d gid %d\n", child,
1687                        data.ioc_obdo1.o_mode, data.ioc_obdo1.o_uid,
1688                        data.ioc_obdo1.o_gid);
1689         }
1690
1691         return rc;
1692 }
1693
1694
1695 int jt_obd_close_uuid(int argc, char **argv)
1696 {
1697         int rc, nal;
1698         struct obd_ioctl_data data;
1699
1700         if (argc != 3) {
1701                 fprintf(stderr, "usage: %s <uuid> <net-type>\n", argv[0]);
1702                 return 0;
1703         }
1704
1705         nal = ptl_name2nal(argv[2]);
1706
1707         if (nal <= 0) {
1708                 fprintf (stderr, "Can't parse NAL %s\n", argv[2]);
1709                 return -1;
1710         }
1711
1712         IOC_INIT(data);
1713         data.ioc_inllen1 = strlen(argv[1]) + 1;
1714         data.ioc_inlbuf1 = argv[1];
1715         data.ioc_nal = nal;
1716
1717         IOC_PACK(argv[0], data);
1718         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_CLOSE_UUID, buf);
1719         if (rc) {
1720                 fprintf(stderr, "IOC_PORTAL_CLOSE_UUID failed: %s\n",
1721                         strerror(errno));
1722                 return -1;
1723         }
1724         return 0;
1725 }
1726
1727
1728 int jt_cfg_record(int argc, char **argv)
1729 {
1730         struct obd_ioctl_data data;
1731         int rc;
1732
1733         IOC_INIT(data);
1734
1735         if (argc != 2)
1736                 return CMD_HELP;
1737
1738         data.ioc_inllen1 = strlen(argv[1]) + 1;
1739         data.ioc_inlbuf1 = argv[1];
1740
1741         IOC_PACK(argv[0], data);
1742         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_RECORD, buf);
1743         if (rc == 0) {
1744                 jt_recording = 1;
1745                 ptl_set_cfg_record_cb(obd_record);
1746         } else {
1747                 fprintf(stderr, "OBD_IOC_RECORD failed: %s\n",
1748                         strerror(errno));
1749         }
1750
1751         return rc;
1752 }
1753
1754 int jt_cfg_parse(int argc, char **argv)
1755 {
1756         struct obd_ioctl_data data;
1757         int rc;
1758
1759         IOC_INIT(data);
1760
1761         if (argc != 2)
1762                 return CMD_HELP;
1763
1764         data.ioc_inllen1 = strlen(argv[1]) + 1;
1765         data.ioc_inlbuf1 = argv[1];
1766
1767         IOC_PACK(argv[0], data);
1768         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_PARSE, buf);
1769         if (rc < 0)
1770                 fprintf(stderr, "OBD_IOC_PARSE failed: %s\n",
1771                         strerror(errno));
1772
1773         return rc;
1774 }
1775
1776
1777 int jt_cfg_dump_log(int argc, char **argv)
1778 {
1779         struct obd_ioctl_data data;
1780         int rc;
1781
1782         IOC_INIT(data);
1783
1784         if (argc != 2)
1785                 return CMD_HELP;
1786
1787         data.ioc_inllen1 = strlen(argv[1]) + 1;
1788         data.ioc_inlbuf1 = argv[1];
1789
1790         IOC_PACK(argv[0], data);
1791         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_DUMP_LOG, buf);
1792         if (rc < 0)
1793                 fprintf(stderr, "OBD_IOC_DUMP_LOG failed: %s\n",
1794                         strerror(errno));
1795
1796         return rc;
1797 }
1798
1799
1800 int jt_cfg_endrecord(int argc, char **argv)
1801 {
1802         struct obd_ioctl_data data;
1803         int rc;
1804
1805         IOC_INIT(data);
1806
1807         if (argc != 1)
1808                 return CMD_HELP;
1809
1810         if (!jt_recording) {
1811                 fprintf(stderr, "Not recording, so endrecord doesn't make sense.\n");
1812                 return 0;
1813         }
1814
1815         IOC_PACK(argv[0], data);
1816         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_ENDRECORD, buf);
1817         if (rc == 0) {
1818                 jt_recording = 0;
1819                 ptl_set_cfg_record_cb(NULL);
1820         } else {
1821                 fprintf(stderr, "OBD_IOC_ENDRECORD failed: %s\n",
1822                         strerror(errno));
1823         }
1824         return rc;
1825 }
1826
1827 int jt_llog_catlist(int argc, char **argv)
1828 {
1829         struct obd_ioctl_data data;
1830         int rc;
1831
1832         if (argc != 1)
1833                 return CMD_HELP;
1834
1835         IOC_INIT(data);
1836         data.ioc_inllen1 = max - size_round(sizeof(data));
1837         IOC_PACK(argv[0], data);
1838
1839         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_CATLOGLIST, buf);
1840         if (rc == 0)
1841                 fprintf(stdout, "%s", ((struct obd_ioctl_data*)buf)->ioc_bulk);
1842         else
1843                 fprintf(stderr, "OBD_IOC_CATLOGLIST failed: %s\n",
1844                         strerror(errno));
1845
1846         return rc;
1847 }
1848
1849 int jt_llog_info(int argc, char **argv)
1850 {
1851         struct obd_ioctl_data data;
1852         int rc;
1853
1854         if (argc != 2)
1855                 return CMD_HELP;
1856
1857         IOC_INIT(data);
1858         data.ioc_inllen1 = strlen(argv[1]) + 1;
1859         data.ioc_inlbuf1 = argv[1];
1860         data.ioc_inllen2 = max - size_round(sizeof(data)) -
1861                 size_round(data.ioc_inllen1);
1862         IOC_PACK(argv[0], data);
1863
1864         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_INFO, buf);
1865         if (rc == 0)
1866                 fprintf(stdout, "%s", ((struct obd_ioctl_data*)buf)->ioc_bulk);
1867         else
1868                 fprintf(stderr, "OBD_IOC_LLOG_INFO failed: %s\n",
1869                         strerror(errno));
1870
1871         return rc;
1872 }
1873
1874 int jt_llog_print(int argc, char **argv)
1875 {
1876         struct obd_ioctl_data data;
1877         int rc;
1878
1879         if (argc != 2 && argc != 4)
1880                 return CMD_HELP;
1881
1882         IOC_INIT(data);
1883         data.ioc_inllen1 = strlen(argv[1]) + 1;
1884         data.ioc_inlbuf1 = argv[1];
1885         if (argc == 4) {
1886                 data.ioc_inllen2 = strlen(argv[2]) + 1;
1887                 data.ioc_inlbuf2 = argv[2];
1888                 data.ioc_inllen3 = strlen(argv[3]) + 1;
1889                 data.ioc_inlbuf3 = argv[3];
1890         } else {
1891                 char from[2] = "1", to[3] = "-1";
1892                 data.ioc_inllen2 = strlen(from) + 1;
1893                 data.ioc_inlbuf2 = from;
1894                 data.ioc_inllen3 = strlen(to) + 1;
1895                 data.ioc_inlbuf3 = to;
1896         }
1897         data.ioc_inllen4 = max - size_round(sizeof(data)) -
1898                 size_round(data.ioc_inllen1) -
1899                 size_round(data.ioc_inllen2) -
1900                 size_round(data.ioc_inllen3);
1901         IOC_PACK(argv[0], data);
1902
1903         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_PRINT, buf);
1904         if (rc == 0)
1905                 fprintf(stdout, "%s", ((struct obd_ioctl_data*)buf)->ioc_bulk);
1906         else
1907                 fprintf(stderr, "OBD_IOC_LLOG_PRINT failed: %s\n",
1908                         strerror(errno));
1909
1910         return rc;
1911 }
1912
1913 int jt_llog_cancel(int argc, char **argv)
1914 {
1915         struct obd_ioctl_data data;
1916         int rc;
1917
1918         if (argc != 4)
1919                 return CMD_HELP;
1920
1921         IOC_INIT(data);
1922         data.ioc_inllen1 = strlen(argv[1]) + 1;
1923         data.ioc_inlbuf1 = argv[1];
1924         data.ioc_inllen2 = strlen(argv[2]) + 1;
1925         data.ioc_inlbuf2 = argv[2];
1926         data.ioc_inllen3 = strlen(argv[3]) + 1;
1927         data.ioc_inlbuf3 = argv[3];
1928         IOC_PACK(argv[0], data);
1929
1930         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_CANCEL, buf);
1931         if (rc == 0)
1932                 fprintf(stdout, "index %s be canceled.\n", argv[3]);
1933         else
1934                 fprintf(stderr, "OBD_IOC_LLOG_CANCEL failed: %s\n",
1935                         strerror(errno));
1936
1937         return rc;
1938
1939 }
1940 int jt_llog_check(int argc, char **argv)
1941 {
1942         struct obd_ioctl_data data;
1943         int rc;
1944
1945         if (argc != 2 && argc != 4)
1946                 return CMD_HELP;
1947
1948         IOC_INIT(data);
1949         data.ioc_inllen1 = strlen(argv[1]) + 1;
1950         data.ioc_inlbuf1 = argv[1];
1951         if (argc == 4) {
1952                 data.ioc_inllen2 = strlen(argv[2]) + 1;
1953                 data.ioc_inlbuf2 = argv[2];
1954                 data.ioc_inllen3 = strlen(argv[3]) + 1;
1955                 data.ioc_inlbuf3 = argv[3];
1956         } else {
1957                 char from[2] = "1", to[3] = "-1";
1958                 data.ioc_inllen2 = strlen(from) + 1;
1959                 data.ioc_inlbuf2 = from;
1960                 data.ioc_inllen3 = strlen(to) + 1;
1961                 data.ioc_inlbuf3 = to;
1962         }
1963         data.ioc_inllen4 = max - size_round(sizeof(data)) -
1964                 size_round(data.ioc_inllen1) -
1965                 size_round(data.ioc_inllen2) -
1966                 size_round(data.ioc_inllen3);
1967         IOC_PACK(argv[0], data);
1968
1969         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_CHECK, buf);
1970         if (rc == 0)
1971                 fprintf(stdout, "%s", ((struct obd_ioctl_data*)buf)->ioc_bulk);
1972         else
1973                 fprintf(stderr, "OBD_IOC_LLOG_CHECK failed: %s\n",
1974                         strerror(errno));
1975         return rc;
1976 }
1977
1978 int jt_llog_remove(int argc, char **argv)
1979 {
1980         struct obd_ioctl_data data;
1981         int rc;
1982
1983         if (argc != 3 && argc != 2)
1984                 return CMD_HELP;
1985
1986         IOC_INIT(data);
1987         data.ioc_inllen1 = strlen(argv[1]) + 1;
1988         data.ioc_inlbuf1 = argv[1];
1989         if (argc == 3){
1990                 data.ioc_inllen2 = strlen(argv[2]) + 1;
1991                 data.ioc_inlbuf2 = argv[2];
1992         }
1993         IOC_PACK(argv[0], data);
1994
1995         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_REMOVE, buf);
1996         if (rc == 0) {
1997                 if (argc == 3)
1998                         fprintf(stdout, "log %s are removed.\n", argv[2]);
1999                 else
2000                         fprintf(stdout, "the log in catlog %s are removed. \n", argv[1]);
2001         } else
2002                 fprintf(stderr, "OBD_IOC_LLOG_REMOVE failed: %s\n",
2003                         strerror(errno));
2004
2005         return rc;
2006 }
2007
2008 static void signal_server(int sig)
2009 {
2010         if (sig == SIGINT) {
2011                 do_disconnect("sigint", 1);
2012                 exit(1);
2013         } else
2014                 fprintf(stderr, "%s: got signal %d\n", jt_cmdname("sigint"), sig);
2015 }
2016
2017 int obd_initialize(int argc, char **argv)
2018 {
2019         SHMEM_SETUP();
2020         register_ioc_dev(OBD_DEV_ID, OBD_DEV_PATH);
2021
2022         return 0;
2023 }
2024
2025
2026 void obd_finalize(int argc, char **argv)
2027 {
2028         struct sigaction sigact;
2029
2030         sigact.sa_handler = signal_server;
2031         sigfillset(&sigact.sa_mask);
2032         sigact.sa_flags = SA_RESTART;
2033         sigaction(SIGINT, &sigact, NULL);
2034
2035         if (jt_recording) {
2036                 printf("END RECORD\n");
2037                 jt_cfg_endrecord(argc, argv);
2038         }
2039
2040         do_disconnect(argv[0], 1);
2041 }