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