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