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