lustre/utils/obd.c

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  19  *
  20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  21  * CA 95054 USA or visit www.sun.com if you need additional information or
  22  * have any questions.
  23  *
  24  * GPL HEADER END
  25  */
  26 /*
  27  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  28  * Use is subject to license terms.
  29  *
  30  * Copyright (c) 2011, 2013, Intel Corporation.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * lustre/utils/obd.c
  37  *
  38  * Author: Peter J. Braam <braam@clusterfs.com>
  39  * Author: Phil Schwan <phil@clusterfs.com>
  40  * Author: Andreas Dilger <adilger@clusterfs.com>
  41  * Author: Robert Read <rread@clusterfs.com>
  42  */
  43
  44 #include <sys/ioctl.h>
  45 #include <sys/socket.h>
  46 #include <sys/stat.h>
  47 #include <sys/time.h>
  48 #include <sys/types.h>
  49 #include <sys/un.h>
  50 #include <sys/wait.h>
  51
  52 #include <ctype.h>
  53 #include <errno.h>
  54 #include <fcntl.h>
  55 #include <glob.h>
  56 #include <signal.h>
  57 #include <stdarg.h>
  58 #include <stdbool.h>
  59 #include <stdio.h>
  60 #include <stdlib.h>
  61 #include <string.h>
  62 #include <time.h>
  63 #include <unistd.h>
  64
  65 #include "obdctl.h"
  66 #include <libcfs/libcfs.h>
  67 #include <lnet/lnet.h>
  68 #include <lustre/lustre_idl.h>
  69 #include <lustre_cfg.h>
  70 #include <lustre_ioctl.h>
  71 #include <lustre/lustre_build_version.h>
  72
  73 #include <lnet/lnetctl.h>
  74 #include <libcfs/libcfsutil.h>
  75 #include <lustre/lustreapi.h>
  76
  77 #define MAX_STRING_SIZE 128
  78 #define DEVICES_LIST "/proc/fs/lustre/devices"
  79
  80 #if HAVE_LIBPTHREAD
  81 #include <sys/ipc.h>
  82 #include <sys/shm.h>
  83 #include <pthread.h>
  84
  85 #define MAX_THREADS 4096
  86 #define MAX_BASE_ID 0xffffffff
  87 #define NIDSTRING_LENGTH 64
  88 struct shared_data {
  89         l_mutex_t mutex;
  90         l_cond_t  cond;
  91         int       stopping;
  92         struct {
  93                 __u64 counters[MAX_THREADS];
  94                 __u64 offsets[MAX_THREADS];
  95                 int   thr_running;
  96                 int   start_barrier;
  97                 int   stop_barrier;
  98                 struct timeval start_time;
  99                 struct timeval end_time;
 100         } body;
 101 };
 102
 103 static struct shared_data *shared_data;
 104 static __u64 counter_snapshot[2][MAX_THREADS];
 105 static int prev_valid;
 106 static struct timeval prev_time;
 107 static int thread;
 108 static int nthreads;
 109 #else
 110 const int thread = 0;
 111 const int nthreads = 1;
 112 #endif
 113
 114 static int cur_device = -1;
 115
 116 static int l2_ioctl(int dev_id, int opc, void *buf)
 117 {
 118         return l_ioctl(dev_id, opc, buf);
 119 }
 120
 121 int lcfg_ioctl(char * func, int dev_id, struct lustre_cfg *lcfg)
 122 {
 123         struct obd_ioctl_data data;
 124         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
 125         int rc;
 126
 127         memset(&data, 0, sizeof(data));
 128         data.ioc_dev = cur_device;
 129         data.ioc_type = LUSTRE_CFG_TYPE;
 130         data.ioc_plen1 = lustre_cfg_len(lcfg->lcfg_bufcount,
 131                                         lcfg->lcfg_buflens);
 132         data.ioc_pbuf1 = (void *)lcfg;
 133         memset(buf, 0, sizeof(rawbuf));
 134         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
 135         if (rc) {
 136                 fprintf(stderr, "error: %s: invalid ioctl\n",
 137                         jt_cmdname(func));
 138                 return rc;
 139         }
 140
 141         rc =  l_ioctl(dev_id, OBD_IOC_PROCESS_CFG, buf);
 142
 143         return rc;
 144 }
 145
 146 static int do_device(char *func, char *devname);
 147
 148 static int get_mgs_device()
 149 {
 150         char mgs[] = "$MGS";
 151         static int mgs_device = -1;
 152
 153         if (mgs_device == -1) {
 154                 int rc;
 155                 do_disconnect(NULL, 1);
 156                 rc = do_device("mgsioc", mgs);
 157                 if (rc) {
 158                         fprintf(stderr,
 159                                 "This command must be run on the MGS.\n");
 160                         errno = ENODEV;
 161                         return -1;
 162                 }
 163                 mgs_device = cur_device;
 164         }
 165         return mgs_device;
 166 }
 167
 168 /* Returns -1 on error with errno set */
 169 int lcfg_mgs_ioctl(char *func, int dev_id, struct lustre_cfg *lcfg)
 170 {
 171         struct obd_ioctl_data data;
 172         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
 173         int rc;
 174
 175         memset(&data, 0, sizeof(data));
 176         rc = data.ioc_dev = get_mgs_device();
 177         if (rc < 0)
 178                 goto out;
 179         data.ioc_type = LUSTRE_CFG_TYPE;
 180         data.ioc_plen1 = lustre_cfg_len(lcfg->lcfg_bufcount,
 181                                         lcfg->lcfg_buflens);
 182         data.ioc_pbuf1 = (void *)lcfg;
 183         memset(buf, 0, sizeof(rawbuf));
 184         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
 185         if (rc) {
 186                 fprintf(stderr, "error: %s: invalid ioctl\n",
 187                         jt_cmdname(func));
 188                 return rc;
 189         }
 190
 191         rc = l_ioctl(dev_id, OBD_IOC_PARAM, buf);
 192 out:
 193         if (rc) {
 194                 if (errno == ENOSYS)
 195                         fprintf(stderr, "Make sure cfg_device is set first.\n");
 196         }
 197         return rc;
 198 }
 199
 200 char *obdo_print(struct obdo *obd)
 201 {
 202         char buf[1024];
 203
 204         sprintf(buf, "id: "LPX64"\ngrp: "LPX64"\natime: "LPU64"\nmtime: "LPU64
 205                 "\nctime: "LPU64"\nsize: "LPU64"\nblocks: "LPU64
 206                 "\nblksize: %u\nmode: %o\nuid: %d\ngid: %d\nflags: %x\n"
 207                 "misc: %x\nnlink: %d,\nvalid "LPX64"\n",
 208                 ostid_id(&obd->o_oi), ostid_seq(&obd->o_oi), obd->o_atime,
 209                 obd->o_mtime, obd->o_ctime,
 210                 obd->o_size, obd->o_blocks, obd->o_blksize, obd->o_mode,
 211                 obd->o_uid, obd->o_gid, obd->o_flags, obd->o_misc,
 212                 obd->o_nlink, obd->o_valid);
 213         return strdup(buf);
 214 }
 215
 216
 217 #define BAD_VERBOSE (-999999999)
 218
 219 #define N2D_OFF 0x100      /* So we can tell between error codes and devices */
 220
 221 static int do_name2dev(char *func, char *name)
 222 {
 223         struct obd_ioctl_data data;
 224         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
 225         int rc;
 226
 227         memset(&data, 0, sizeof(data));
 228         data.ioc_dev = cur_device;
 229         data.ioc_inllen1 = strlen(name) + 1;
 230         data.ioc_inlbuf1 = name;
 231
 232         memset(buf, 0, sizeof(rawbuf));
 233         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
 234         if (rc < 0) {
 235                 fprintf(stderr, "error: %s: invalid ioctl\n",
 236                         jt_cmdname(func));
 237                 return -rc;
 238         }
 239         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_NAME2DEV, buf);
 240         if (rc < 0)
 241                 return errno;
 242         rc = obd_ioctl_unpack(&data, buf, sizeof(rawbuf));
 243         if (rc) {
 244                 fprintf(stderr, "error: %s: invalid reply\n",
 245                         jt_cmdname(func));
 246                 return rc;
 247         }
 248
 249         return data.ioc_dev + N2D_OFF;
 250 }
 251
 252 /*
 253  * resolve a device name to a device number.
 254  * supports a number, $name or %uuid.
 255  */
 256 int parse_devname(char *func, char *name)
 257 {
 258         int rc;
 259         int ret = -1;
 260
 261         if (!name)
 262                 return ret;
 263         if (isdigit(name[0])) {
 264                 ret = strtoul(name, NULL, 0);
 265         } else {
 266                 if (name[0] == '$' || name[0] == '%')
 267                         name++;
 268                 rc = do_name2dev(func, name);
 269                 if (rc >= N2D_OFF) {
 270                         ret = rc - N2D_OFF;
 271                         // printf("Name %s is device %d\n", name, ret);
 272                 } else {
 273                         fprintf(stderr, "No device found for name %s: %s\n",
 274                                 name, strerror(rc));
 275                 }
 276         }
 277         return ret;
 278 }
 279
 280 char *jt_cmdname(char *func)
 281 {
 282         static char buf[512];
 283
 284         if (thread) {
 285                 sprintf(buf, "%s-%d", func, thread);
 286                 return buf;
 287         }
 288
 289         return func;
 290 }
 291
 292 #define difftime(a, b)                                  \
 293         ((a)->tv_sec - (b)->tv_sec +                    \
 294          ((a)->tv_usec - (b)->tv_usec) / 1000000.0)
 295
 296 static int be_verbose(int verbose, struct timeval *next_time,
 297                       __u64 num, __u64 *next_num, int num_total)
 298 {
 299         struct timeval now;
 300
 301         if (!verbose)
 302                 return 0;
 303
 304         if (next_time != NULL)
 305                 gettimeofday(&now, NULL);
 306
 307         /* A positive verbosity means to print every X iterations */
 308         if (verbose > 0 && (num >= *next_num || num >= num_total)) {
 309                 *next_num += verbose;
 310                 if (next_time) {
 311                         next_time->tv_sec = now.tv_sec - verbose;
 312                         next_time->tv_usec = now.tv_usec;
 313                 }
 314                 return 1;
 315         }
 316
 317         /* A negative verbosity means to print at most each X seconds */
 318         if (verbose < 0 && next_time != NULL &&
 319             difftime(&now, next_time) >= 0.0){
 320                 next_time->tv_sec = now.tv_sec - verbose;
 321                 next_time->tv_usec = now.tv_usec;
 322                 *next_num = num;
 323                 return 1;
 324         }
 325
 326         return 0;
 327 }
 328
 329 static int get_verbose(char *func, const char *arg)
 330 {
 331         int verbose;
 332         char *end;
 333
 334         if (!arg || arg[0] == 'v')
 335                 verbose = 1;
 336         else if (arg[0] == 's' || arg[0] == 'q')
 337                 verbose = 0;
 338         else {
 339                 verbose = (int)strtoul(arg, &end, 0);
 340                 if (*end) {
 341                         fprintf(stderr, "error: %s: bad verbose option '%s'\n",
 342                                 jt_cmdname(func), arg);
 343                         return BAD_VERBOSE;
 344                 }
 345         }
 346
 347         if (verbose < 0)
 348                 printf("Print status every %d seconds\n", -verbose);
 349         else if (verbose == 1)
 350                 printf("Print status every operation\n");
 351         else if (verbose > 1)
 352                 printf("Print status every %d operations\n", verbose);
 353
 354         return verbose;
 355 }
 356
 357 int do_disconnect(char *func, int verbose)
 358 {
 359         lcfg_set_devname(NULL);
 360         cur_device = -1;
 361         return 0;
 362 }
 363
 364 #ifdef MAX_THREADS
 365 static int shmem_setup(void)
 366 {
 367         pthread_mutexattr_t mattr;
 368         pthread_condattr_t  cattr;
 369         int                 rc;
 370         int                 shmid;
 371
 372         /* Create new segment */
 373         shmid = shmget(IPC_PRIVATE, sizeof(*shared_data), 0600);
 374         if (shmid == -1) {
 375                 fprintf(stderr, "Can't create shared data: %s\n",
 376                         strerror(errno));
 377                 return errno;
 378         }
 379
 380         /* Attatch to new segment */
 381         shared_data = (struct shared_data *)shmat(shmid, NULL, 0);
 382
 383         if (shared_data == (struct shared_data *)(-1)) {
 384                 fprintf(stderr, "Can't attach shared data: %s\n",
 385                         strerror(errno));
 386                 shared_data = NULL;
 387                 return errno;
 388         }
 389
 390         /* Mark segment as destroyed, so it will disappear when we exit.
 391          * Forks will inherit attached segments, so we should be OK.
 392          */
 393         if (shmctl(shmid, IPC_RMID, NULL) == -1) {
 394                 fprintf(stderr, "Can't destroy shared data: %s\n",
 395                         strerror(errno));
 396                 return errno;
 397         }
 398
 399         pthread_mutexattr_init(&mattr);
 400         pthread_condattr_init(&cattr);
 401
 402         rc = pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
 403         if (rc != 0) {
 404                 fprintf(stderr, "Can't set shared mutex attr\n");
 405                 goto out;
 406         }
 407
 408         rc = pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_SHARED);
 409         if (rc != 0) {
 410                 fprintf(stderr, "Can't set shared cond attr\n");
 411                 goto out;
 412         }
 413
 414         pthread_mutex_init(&shared_data->mutex, &mattr);
 415         pthread_cond_init(&shared_data->cond, &cattr);
 416 out:
 417         pthread_mutexattr_destroy(&mattr);
 418         pthread_condattr_destroy(&cattr);
 419
 420         return rc;
 421 }
 422
 423 static inline void shmem_lock(void)
 424 {
 425         l_mutex_lock(&shared_data->mutex);
 426 }
 427
 428 static inline void shmem_unlock(void)
 429 {
 430         l_mutex_unlock(&shared_data->mutex);
 431 }
 432
 433 static inline void shmem_wait(void)
 434 {
 435         l_cond_wait(&shared_data->cond, &shared_data->mutex);
 436 }
 437
 438 static inline void shmem_wakeup_all(void)
 439 {
 440         l_cond_broadcast(&shared_data->cond);
 441 }
 442
 443 static inline void shmem_reset(int total_threads)
 444 {
 445         if (shared_data == NULL)
 446                 return;
 447
 448         memset(&shared_data->body, 0, sizeof(shared_data->body));
 449         memset(counter_snapshot, 0, sizeof(counter_snapshot));
 450         prev_valid = 0;
 451         shared_data->stopping = 0;
 452         shared_data->body.start_barrier = total_threads;
 453         shared_data->body.stop_barrier = total_threads;
 454 }
 455
 456 static inline void shmem_bump(__u32 counter)
 457 {
 458         static bool running_not_bumped = true;
 459
 460         if (shared_data == NULL || thread <= 0 || thread > MAX_THREADS)
 461                 return;
 462
 463         shmem_lock();
 464         shared_data->body.counters[thread - 1] += counter;
 465         if (running_not_bumped) {
 466                 shared_data->body.thr_running++;
 467                 running_not_bumped = false;
 468         }
 469         shmem_unlock();
 470 }
 471
 472 static void shmem_total(int total_threads)
 473 {
 474         __u64 total = 0;
 475         double secs;
 476         int i;
 477
 478         if (shared_data == NULL || total_threads > MAX_THREADS)
 479                 return;
 480
 481         shmem_lock();
 482         for (i = 0; i < total_threads; i++)
 483                 total += shared_data->body.counters[i];
 484
 485         secs = difftime(&shared_data->body.end_time,
 486                         &shared_data->body.start_time);
 487         shmem_unlock();
 488
 489         printf("Total: total "LPU64" threads %d sec %f %f/second\n",
 490                total, total_threads, secs, total / secs);
 491
 492         return;
 493 }
 494
 495 static void shmem_snap(int total_threads, int live_threads)
 496 {
 497         struct timeval this_time;
 498         int non_zero = 0;
 499         __u64 total = 0;
 500         double secs;
 501         int running;
 502         int i;
 503
 504         if (shared_data == NULL || total_threads > MAX_THREADS)
 505                 return;
 506
 507         shmem_lock();
 508         memcpy(counter_snapshot[0], shared_data->body.counters,
 509                total_threads * sizeof(counter_snapshot[0][0]));
 510         running = shared_data->body.thr_running;
 511         shmem_unlock();
 512
 513         gettimeofday(&this_time, NULL);
 514
 515         for (i = 0; i < total_threads; i++) {
 516                 long long this_count =
 517                         counter_snapshot[0][i] - counter_snapshot[1][i];
 518
 519                 if (this_count != 0) {
 520                         non_zero++;
 521                         total += this_count;
 522                 }
 523         }
 524
 525         secs = difftime(&this_time, &prev_time);
 526         if (prev_valid && secs > 1.0)    /* someone screwed with the time? */
 527                 printf("%d/%d Total: %f/second\n", non_zero, total_threads,
 528                        total / secs);
 529
 530         memcpy(counter_snapshot[1], counter_snapshot[0],
 531                total_threads * sizeof(counter_snapshot[0][0]));
 532         prev_time = this_time;
 533         if (!prev_valid &&
 534             running == total_threads)
 535                 prev_valid = 1;
 536 }
 537
 538 static void shmem_stop(void)
 539 {
 540         if (shared_data == NULL)
 541                 return;
 542
 543         shared_data->stopping = 1;
 544 }
 545
 546 static void shmem_cleanup(void)
 547 {
 548         if (shared_data == NULL)
 549                 return;
 550
 551         shmem_stop();
 552
 553         pthread_mutex_destroy(&shared_data->mutex);
 554         pthread_cond_destroy(&shared_data->cond);
 555 }
 556
 557 static int shmem_running(void)
 558 {
 559         return (shared_data == NULL || !shared_data->stopping);
 560 }
 561
 562 static void shmem_end_time_locked(void)
 563 {
 564         shared_data->body.stop_barrier--;
 565         if (shared_data->body.stop_barrier == 0)
 566                 gettimeofday(&shared_data->body.end_time, NULL);
 567 }
 568
 569 static void shmem_start_time_locked(void)
 570 {
 571         shared_data->body.start_barrier--;
 572         if (shared_data->body.start_barrier == 0) {
 573                 shmem_wakeup_all();
 574                 gettimeofday(&shared_data->body.start_time, NULL);
 575         } else {
 576                 shmem_wait();
 577         }
 578 }
 579
 580 #else
 581 static int shmem_setup(void)
 582 {
 583         return 0;
 584 }
 585
 586 static inline void shmem_reset(int total_threads)
 587 {
 588 }
 589
 590 static inline void shmem_bump(__u32 counters)
 591 {
 592 }
 593
 594 static void shmem_lock()
 595 {
 596 }
 597
 598 static void shmem_unlock()
 599 {
 600 }
 601
 602 static void shmem_cleanup(void)
 603 {
 604 }
 605
 606 static int shmem_running(void)
 607 {
 608         return 1;
 609 }
 610 #endif
 611
 612 extern command_t cmdlist[];
 613
 614 static int do_device(char *func, char *devname)
 615 {
 616         int dev;
 617
 618         dev = parse_devname(func, devname);
 619         if (dev < 0)
 620                 return -1;
 621
 622         lcfg_set_devname(devname);
 623         cur_device = dev;
 624         return 0;
 625 }
 626
 627 int jt_obd_get_device()
 628 {
 629         return cur_device;
 630 }
 631
 632 int jt_obd_device(int argc, char **argv)
 633 {
 634         int rc;
 635
 636         if (argc > 2)
 637                 return CMD_HELP;
 638
 639         if (argc == 1) {
 640                 printf("current device is %d - %s\n",
 641                        cur_device, lcfg_get_devname() ? : "not set");
 642                 return 0;
 643         }
 644         rc = do_device("device", argv[1]);
 645         return rc;
 646 }
 647
 648 int jt_opt_device(int argc, char **argv)
 649 {
 650         int ret;
 651         int rc;
 652
 653         if (argc < 3)
 654                 return CMD_HELP;
 655
 656         rc = do_device("device", argv[1]);
 657
 658         if (!rc)
 659                 rc = Parser_execarg(argc - 2, argv + 2, cmdlist);
 660
 661         ret = do_disconnect(argv[0], 0);
 662         if (!rc)
 663                 rc = ret;
 664
 665         return rc;
 666 }
 667
 668 #ifdef MAX_THREADS
 669 static void parent_sighandler (int sig)
 670 {
 671         return;
 672 }
 673
 674 int jt_opt_threads(int argc, char **argv)
 675 {
 676         static char      cmdstr[128];
 677         sigset_t         saveset;
 678         sigset_t         sigset;
 679         struct sigaction sigact;
 680         struct sigaction saveact1;
 681         struct sigaction saveact2;
 682         unsigned long    threads;
 683         __u64            next_thread;
 684         int verbose;
 685         int rc = 0;
 686         int report_count = -1;
 687         char *end;
 688         int i;
 689
 690         if (argc < 5)
 691                 return CMD_HELP;
 692
 693         threads = strtoul(argv[1], &end, 0);
 694
 695         if (*end == '.')
 696                 report_count = strtoul(end + 1, &end, 0);
 697
 698         if (*end || threads > MAX_THREADS) {
 699                 fprintf(stderr, "error: %s: invalid thread count '%s'\n",
 700                         jt_cmdname(argv[0]), argv[1]);
 701                 return CMD_HELP;
 702         }
 703
 704         verbose = get_verbose(argv[0], argv[2]);
 705         if (verbose == BAD_VERBOSE)
 706                 return CMD_HELP;
 707
 708         if (verbose != 0) {
 709                 snprintf(cmdstr, sizeof(cmdstr), "%s", argv[4]);
 710                 for (i = 5; i < argc; i++)
 711                         snprintf(cmdstr + strlen(cmdstr), sizeof(cmdstr),
 712                                  " %s", argv[i]);
 713
 714                 printf("%s: starting %ld threads on device %s running %s\n",
 715                        argv[0], threads, argv[3], cmdstr);
 716         }
 717
 718         shmem_reset(threads);
 719
 720         sigemptyset(&sigset);
 721         sigaddset(&sigset, SIGALRM);
 722         sigaddset(&sigset, SIGCHLD);
 723         sigprocmask(SIG_BLOCK, &sigset, &saveset);
 724
 725         nthreads = threads;
 726
 727         for (i = 1, next_thread = verbose; i <= threads; i++) {
 728                 rc = fork();
 729                 if (rc < 0) {
 730                         fprintf(stderr, "error: %s: #%d - %s\n", argv[0], i,
 731                                 strerror(rc = errno));
 732                         break;
 733                 } else if (rc == 0) {
 734                         sigprocmask(SIG_SETMASK, &saveset, NULL);
 735
 736                         thread = i;
 737                         argv[2] = "--device";
 738                         exit(jt_opt_device(argc - 2, argv + 2));
 739                 } else if (be_verbose(verbose, NULL, i, &next_thread, threads))
 740                         printf("%s: thread #%d (PID %d) started\n",
 741                                argv[0], i, rc);
 742                 rc = 0;
 743         }
 744
 745         if (!thread) {          /* parent process */
 746                 int live_threads = threads;
 747
 748                 sigemptyset(&sigset);
 749                 sigemptyset(&sigact.sa_mask);
 750                 sigact.sa_handler = parent_sighandler;
 751                 sigact.sa_flags = 0;
 752
 753                 sigaction(SIGALRM, &sigact, &saveact1);
 754                 sigaction(SIGCHLD, &sigact, &saveact2);
 755
 756                 while (live_threads > 0) {
 757                         int status;
 758                         pid_t ret;
 759
 760                         if (verbose < 0)        /* periodic stats */
 761                                 alarm(-verbose);
 762
 763                         sigsuspend(&sigset);
 764                         alarm(0);
 765
 766                         while (live_threads > 0) {
 767                                 ret = waitpid(0, &status, WNOHANG);
 768                                 if (ret == 0)
 769                                         break;
 770
 771                                 if (ret < 0) {
 772                                         fprintf(stderr, "error: %s: wait - %s\n",
 773                                                 argv[0], strerror(errno));
 774                                         if (!rc)
 775                                                 rc = errno;
 776                                         continue;
 777                                 } else {
 778                                         /*
 779                                          * This is a hack.  We _should_ be able
 780                                          * to use WIFEXITED(status) to see if
 781                                          * there was an error, but it appears
 782                                          * to be broken and it always returns 1
 783                                          * (OK).  See wait(2).
 784                                          */
 785                                         int err = WEXITSTATUS(status);
 786                                         if (err || WIFSIGNALED(status))
 787                                                 fprintf(stderr,
 788                                                         "%s: PID %d had rc=%d\n",
 789                                                         argv[0], ret, err);
 790                                         if (!rc)
 791                                                 rc = err;
 792
 793                                         live_threads--;
 794                                 }
 795                         }
 796
 797                         /* Show stats while all threads running */
 798                         if (verbose < 0) {
 799                                 shmem_snap(threads, live_threads);
 800                                 if (report_count > 0 && --report_count == 0)
 801                                         shmem_stop();
 802                         }
 803                 }
 804                 sigaction(SIGCHLD, &saveact2, NULL);
 805                 sigaction(SIGALRM, &saveact1, NULL);
 806         }
 807
 808         shmem_total(threads);
 809         sigprocmask(SIG_SETMASK, &saveset, NULL);
 810
 811         return rc;
 812 }
 813 #else
 814 int jt_opt_threads(int argc, char **argv)
 815 {
 816         fprintf(stderr, "%s not-supported in a single-threaded runtime\n",
 817                 jt_cmdname(argv[0]));
 818         return CMD_HELP;
 819 }
 820 #endif
 821
 822 int jt_opt_net(int argc, char **argv)
 823 {
 824         char *arg2[3];
 825         int rc;
 826
 827         if (argc < 3)
 828                 return CMD_HELP;
 829
 830         arg2[0] = argv[0];
 831         arg2[1] = argv[1];
 832         arg2[2] = NULL;
 833         rc = jt_ptl_network (2, arg2);
 834
 835         if (!rc)
 836                 rc = Parser_execarg(argc - 2, argv + 2, cmdlist);
 837
 838         return rc;
 839 }
 840
 841 int jt_obd_no_transno(int argc, char **argv)
 842 {
 843         struct obd_ioctl_data data;
 844         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
 845         int rc;
 846
 847         memset(&data, 0, sizeof(data));
 848         data.ioc_dev = cur_device;
 849
 850         if (argc != 1)
 851                 return CMD_HELP;
 852
 853         memset(buf, 0, sizeof(rawbuf));
 854         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
 855         if (rc) {
 856                 fprintf(stderr, "error: %s: invalid ioctl\n",
 857                         jt_cmdname(argv[0]));
 858                 return rc;
 859         }
 860         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_NO_TRANSNO, buf);
 861         if (rc < 0)
 862                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 863                         strerror(rc = errno));
 864
 865         return rc;
 866 }
 867
 868 int jt_obd_set_readonly(int argc, char **argv)
 869 {
 870         struct obd_ioctl_data data;
 871         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
 872         int rc;
 873
 874         memset(&data, 0, sizeof(data));
 875         data.ioc_dev = cur_device;
 876
 877         if (argc != 1)
 878                 return CMD_HELP;
 879
 880         memset(buf, 0, sizeof(rawbuf));
 881         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
 882         if (rc) {
 883                 fprintf(stderr, "error: %s: invalid ioctl\n",
 884                         jt_cmdname(argv[0]));
 885                 return rc;
 886         }
 887         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_SET_READONLY, buf);
 888         if (rc < 0)
 889                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 890                         strerror(rc = errno));
 891
 892         return rc;
 893 }
 894
 895 int jt_obd_abort_recovery(int argc, char **argv)
 896 {
 897         struct obd_ioctl_data data;
 898         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
 899         int rc;
 900
 901         memset(&data, 0, sizeof(data));
 902         data.ioc_dev = cur_device;
 903
 904         if (argc != 1)
 905                 return CMD_HELP;
 906
 907         memset(buf, 0, sizeof(rawbuf));
 908         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
 909         if (rc) {
 910                 fprintf(stderr, "error: %s: invalid ioctl\n",
 911                         jt_cmdname(argv[0]));
 912                 return rc;
 913         }
 914         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_ABORT_RECOVERY, buf);
 915         if (rc < 0)
 916                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 917                         strerror(rc = errno));
 918
 919         return rc;
 920 }
 921
 922 int jt_get_version(int argc, char **argv)
 923 {
 924         int rc;
 925         char rawbuf[MAX_IOC_BUFLEN];
 926         char *version;
 927
 928         if (argc != 1)
 929                 return CMD_HELP;
 930
 931         rc = llapi_get_version(rawbuf, MAX_IOC_BUFLEN, &version);
 932         if (rc)
 933                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 934                         strerror(-rc));
 935         else
 936                 printf("Lustre version: %s\n", version);
 937
 938         printf("lctl   version: %s\n", BUILD_VERSION);
 939         return rc;
 940 }
 941
 942 /*
 943  * Print an obd device line with the ost_conn_uuid inserted, if the obd
 944  * is an osc.
 945  */
 946 static void print_obd_line(char *s)
 947 {
 948         char buf[MAX_STRING_SIZE];
 949         char obd_name[MAX_OBD_NAME];
 950         FILE *fp = NULL;
 951         char *ptr;
 952
 953         if (sscanf(s, " %*d %*s osc %s %*s %*d ", obd_name) == 0)
 954                 goto try_mdc;
 955         snprintf(buf, sizeof(buf),
 956                  "/proc/fs/lustre/osc/%s/ost_conn_uuid", obd_name);
 957         if ((fp = fopen(buf, "r")) == NULL)
 958                 goto try_mdc;
 959         goto got_one;
 960
 961 try_mdc:
 962         if (sscanf(s, " %*d %*s mdc %s %*s %*d ", obd_name) == 0)
 963                 goto fail;
 964         snprintf(buf, sizeof(buf),
 965                  "/proc/fs/lustre/mdc/%s/mds_conn_uuid", obd_name);
 966         if ((fp = fopen(buf, "r")) == NULL)
 967                 goto fail;
 968
 969 got_one:
 970         /* should not ignore fgets(3)'s return value */
 971         if (!fgets(buf, sizeof(buf), fp)) {
 972                 fprintf(stderr, "reading from %s: %s", buf, strerror(errno));
 973                 fclose(fp);
 974                 return;
 975         }
 976         fclose(fp);
 977
 978         /* trim trailing newlines */
 979         ptr = strrchr(buf, '\n');
 980         if (ptr) *ptr = '\0';
 981         ptr = strrchr(s, '\n');
 982         if (ptr) *ptr = '\0';
 983
 984         printf("%s %s\n", s, buf);
 985         return;
 986
 987 fail:
 988         printf("%s", s);
 989         return;
 990 }
 991
 992 /* get device list by ioctl */
 993 int jt_obd_list_ioctl(int argc, char **argv)
 994 {
 995         int rc, index;
 996         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
 997         struct obd_ioctl_data *data = (struct obd_ioctl_data *)buf;
 998
 999         if (argc > 2)
1000                 return CMD_HELP;
1001         /* Just ignore a -t option.  Only supported with /proc. */
1002         else if (argc == 2 && strcmp(argv[1], "-t") != 0)
1003                 return CMD_HELP;
1004
1005         for (index = 0;; index++) {
1006                 memset(buf, 0, sizeof(rawbuf));
1007                 data->ioc_version = OBD_IOCTL_VERSION;
1008                 data->ioc_inllen1 =
1009                         sizeof(rawbuf) - cfs_size_round(sizeof(*data));
1010                 data->ioc_inlbuf1 = buf + cfs_size_round(sizeof(*data));
1011                 data->ioc_len = obd_ioctl_packlen(data);
1012                 data->ioc_count = index;
1013
1014                 rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_GETDEVICE, buf);
1015                 if (rc != 0)
1016                         break;
1017                 printf("%s\n", (char *)data->ioc_bulk);
1018         }
1019         if (rc != 0) {
1020                 if (errno == ENOENT)
1021                         /* no device or the last device */
1022                         rc = 0;
1023                 else
1024                         fprintf(stderr, "Error getting device list: %s: "
1025                                 "check dmesg.\n", strerror(errno));
1026         }
1027         return rc;
1028 }
1029
1030 int jt_obd_list(int argc, char **argv)
1031 {
1032         int rc;
1033         char buf[MAX_STRING_SIZE];
1034         FILE *fp = NULL;
1035         int print_obd = 0;
1036
1037         if (argc > 2)
1038                 return CMD_HELP;
1039         else if (argc == 2) {
1040                 if (strcmp(argv[1], "-t") == 0)
1041                         print_obd = 1;
1042                 else
1043                         return CMD_HELP;
1044         }
1045
1046         fp = fopen(DEVICES_LIST, "r");
1047         if (fp == NULL) {
1048                 fprintf(stderr, "error: %s: %s opening "DEVICES_LIST"\n",
1049                         jt_cmdname(argv[0]), strerror(rc =  errno));
1050                 return jt_obd_list_ioctl(argc, argv);
1051         }
1052
1053         while (fgets(buf, sizeof(buf), fp) != NULL)
1054                 if (print_obd)
1055                         print_obd_line(buf);
1056                 else
1057                         printf("%s", buf);
1058
1059         fclose(fp);
1060         return 0;
1061 }
1062
1063 struct jt_fid_space {
1064         obd_seq jt_seq;
1065         obd_id  jt_id;
1066         int     jt_width;
1067 };
1068
1069 int jt_obd_alloc_fids(struct jt_fid_space *space, struct lu_fid *fid,
1070                       __u64 *count)
1071 {
1072         int rc;
1073
1074         if (space->jt_seq == 0 || space->jt_id == space->jt_width) {
1075                 struct obd_ioctl_data  data;
1076                 char rawbuf[MAX_IOC_BUFLEN];
1077                 char *buf = rawbuf;
1078                 __u64 seqnr;
1079                 int max_count;
1080
1081                 memset(&data, 0, sizeof(data));
1082                 data.ioc_dev = cur_device;
1083
1084                 data.ioc_pbuf1 = (char *)&seqnr;
1085                 data.ioc_plen1 = sizeof(seqnr);
1086
1087                 data.ioc_pbuf2 = (char *)&max_count;
1088                 data.ioc_plen2 = sizeof(max_count);
1089
1090                 memset(buf, 0, sizeof(rawbuf));
1091                 rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
1092                 if (rc) {
1093                         fprintf(stderr, "error: invalid ioctl rc = %d\n", rc);
1094                         return rc;
1095                 }
1096
1097                 rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_ECHO_ALLOC_SEQ, buf);
1098                 if (rc) {
1099                         fprintf(stderr, "ioctl error: rc = %d\n", rc);
1100                         return rc;
1101                 }
1102
1103                 space->jt_seq = *(__u64 *)data.ioc_pbuf1;
1104                 space->jt_width = *(int *)data.ioc_pbuf2;
1105                 space->jt_id = 1;
1106         }
1107         fid->f_seq = space->jt_seq;
1108         fid->f_oid = space->jt_id;
1109         fid->f_ver = 0;
1110
1111         space->jt_id = min(space->jt_id + *count, space->jt_width);
1112
1113         *count = space->jt_id - fid->f_oid;
1114         return 0;
1115 }
1116
1117 #define MD_STEP_COUNT 1000
1118 int jt_obd_md_common(int argc, char **argv, int cmd)
1119 {
1120         struct obd_ioctl_data  data;
1121         struct timeval         start;
1122         struct timeval         end_time;
1123         char                   rawbuf[MAX_IOC_BUFLEN];
1124         char                  *buf = rawbuf;
1125         int                    mode = 0000644;
1126         int                    create_mode;
1127         int                    rc = 0;
1128         char                  *parent_basedir = NULL;
1129         char                   dirname[4096];
1130         int                    parent_base_id = 0;
1131         int                    parent_count = 1;
1132         __u64                  child_base_id = -1;
1133         int                    stripe_count = 0;
1134         int                    stripe_index = -1;
1135         int                    count = 0;
1136         char                  *end;
1137         __u64                  seconds = 0;
1138         double                 diff;
1139         int                    c;
1140         __u64                  total_count = 0;
1141         char                  *name = NULL;
1142         struct jt_fid_space    fid_space = {0};
1143         int                    version = 0;
1144         struct option          long_opts[] = {
1145                 {"child_base_id",     required_argument, 0, 'b'},
1146                 {"stripe_count",      required_argument, 0, 'c'},
1147                 {"parent_basedir",    required_argument, 0, 'd'},
1148                 {"parent_dircount",   required_argument, 0, 'D'},
1149                 {"stripe_index",      required_argument, 0, 'i'},
1150                 {"mode",              required_argument, 0, 'm'},
1151                 {"count",             required_argument, 0, 'n'},
1152                 {"time",              required_argument, 0, 't'},
1153                 {"version",           no_argument,       0, 'v'},
1154                 {0, 0, 0, 0}
1155         };
1156
1157         optind = 0;
1158         while ((c = getopt_long(argc, argv, "b:c:d:D:m:n:t:v",
1159                                 long_opts, NULL)) >= 0) {
1160                 switch (c) {
1161                 case 'b':
1162                         child_base_id = strtoull(optarg, &end, 0);
1163                         if (*end) {
1164                                 fprintf(stderr, "error: %s: bad child_base_id"
1165                                         " '%s'\n", jt_cmdname(argv[0]), optarg);
1166                                 return CMD_HELP;
1167                         }
1168                         break;
1169                 case 'c':
1170                         stripe_count = strtoul(optarg, &end, 0);
1171                         if (*end) {
1172                                 fprintf(stderr, "error: %s: bad stripe count"
1173                                         " '%s'\n", jt_cmdname(argv[0]), optarg);
1174                                 return CMD_HELP;
1175                         }
1176                         break;
1177                 case 'd':
1178                         parent_basedir = optarg;
1179                         break;
1180                 case 'D':
1181                         parent_count = strtoul(optarg, &end, 0);
1182                         if (*end) {
1183                                 fprintf(stderr, "error: %s: bad parent count"
1184                                         " '%s'\n", jt_cmdname(argv[0]), optarg);
1185                                 return CMD_HELP;
1186                         }
1187                         break;
1188                 case 'i':
1189                         stripe_index = strtoul(optarg, &end, 0);
1190                         if (*end) {
1191                                 fprintf(stderr, "error: %s: bad stripe index"
1192                                         " '%s'\n", jt_cmdname(argv[0]), optarg);
1193                                 return CMD_HELP;
1194                         }
1195                         break;
1196                 case 'm':
1197                         mode = strtoul(optarg, &end, 0);
1198                         if (*end) {
1199                                 fprintf(stderr, "error: %s: bad mode '%s'\n",
1200                                         jt_cmdname(argv[0]), optarg);
1201                                 return CMD_HELP;
1202                         }
1203                         break;
1204                 case 'n':
1205                         total_count = strtoul(optarg, &end, 0);
1206                         if (*end || total_count == 0) {
1207                                 fprintf(stderr, "%s: bad child count '%s'\n",
1208                                         jt_cmdname(argv[0]), optarg);
1209                                 return CMD_HELP;
1210                         }
1211                         break;
1212                 case 't':
1213                         seconds = strtoull(optarg, &end, 0);
1214                         if (*end) {
1215                                 fprintf(stderr, "error: %s: seconds '%s'\n",
1216                                         jt_cmdname(argv[0]), optarg);
1217                                 return CMD_HELP;
1218                         }
1219                         break;
1220                 case 'v':
1221                         version = 1;
1222                         break;
1223                 default:
1224                         fprintf(stderr, "error: %s: option '%s' "
1225                                 "unrecognized\n", argv[0], argv[optind - 1]);
1226                         return CMD_HELP;
1227                 }
1228         }
1229
1230         memset(&data, 0, sizeof(data));
1231         data.ioc_dev = cur_device;
1232         if (child_base_id == -1) {
1233                 if (optind >= argc)
1234                         return CMD_HELP;
1235                 name = argv[optind];
1236                 total_count = 1;
1237         } else {
1238                 if (optind < argc) {
1239                         fprintf(stderr, "child_base_id and name can not"
1240                                         " specified at the same time\n");
1241                         return CMD_HELP;
1242                 }
1243         }
1244
1245         if (stripe_count == 0 && stripe_index != -1) {
1246                 fprintf(stderr, "If stripe_count is 0, stripe_index can not"
1247                                 "be specified\n");
1248                 return CMD_HELP;
1249         }
1250
1251         if (total_count == 0 && seconds == 0) {
1252                 fprintf(stderr, "count or seconds needs to be indicated\n");
1253                 return CMD_HELP;
1254         }
1255
1256         if (parent_count <= 0) {
1257                 fprintf(stderr, "parent count must < 0\n");
1258                 return CMD_HELP;
1259         }
1260
1261 #ifdef MAX_THREADS
1262         if (thread) {
1263                 shmem_lock();
1264                 /* threads interleave */
1265                 if (parent_base_id != -1)
1266                         parent_base_id += (thread - 1) % parent_count;
1267
1268                 if (child_base_id != -1)
1269                         child_base_id +=  (thread - 1) * \
1270                                           (MAX_BASE_ID / nthreads);
1271
1272                 shmem_start_time_locked();
1273                 shmem_unlock();
1274         }
1275 #endif
1276         /* If parent directory is not specified, try to get the directory
1277          * from name */
1278         if (parent_basedir == NULL) {
1279                 char *last_lash;
1280                 if (name == NULL) {
1281                         fprintf(stderr, "parent_basedir or name must be"
1282                                         "indicated!\n");
1283                         return CMD_HELP;
1284                 }
1285                 /*Get directory and name from name*/
1286                 last_lash = strrchr(name, '/');
1287                 if (last_lash == NULL || name[0] != '/') {
1288                         fprintf(stderr, "Can not locate %s\n", name);
1289                         return CMD_HELP;
1290                 }
1291
1292                 if (last_lash == name) {
1293                         sprintf(dirname, "%s", "/");
1294                         name++;
1295                 } else {
1296                         int namelen = (unsigned long)last_lash -
1297                                       (unsigned long)name + 1;
1298                         snprintf(dirname, namelen, "%s", name);
1299                         name = last_lash + 1;
1300                 }
1301
1302                 data.ioc_pbuf1 = dirname;
1303                 data.ioc_plen1 = strlen(dirname);
1304
1305                 data.ioc_pbuf2 = name;
1306                 data.ioc_plen2 = strlen(name);
1307         } else {
1308                 if (name != NULL) {
1309                         data.ioc_pbuf2 = name;
1310                         data.ioc_plen2 = strlen(name);
1311                 }
1312                 if (parent_base_id > 0)
1313                         sprintf(dirname, "%s%d", parent_basedir,
1314                                 parent_base_id);
1315                 else
1316                         sprintf(dirname, "%s", parent_basedir);
1317                 data.ioc_pbuf1 = dirname;
1318                 data.ioc_plen1 = strlen(dirname);
1319         }
1320
1321         if (cmd == ECHO_MD_MKDIR || cmd == ECHO_MD_RMDIR)
1322                 create_mode = S_IFDIR;
1323         else
1324                 create_mode = S_IFREG;
1325
1326         data.ioc_obdo1.o_mode = mode | S_IFDIR;
1327         data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE |
1328                                  OBD_MD_FLFLAGS | OBD_MD_FLGROUP;
1329         data.ioc_command = cmd;
1330
1331         gettimeofday(&start, NULL);
1332         while (shmem_running()) {
1333                 struct lu_fid fid = { 0 };
1334
1335                 if (child_base_id != -1)
1336                         data.ioc_obdo2.o_oi.oi.oi_id = child_base_id;
1337                 data.ioc_obdo2.o_mode = mode | create_mode;
1338                 data.ioc_obdo2.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE |
1339                                          OBD_MD_FLMODE | OBD_MD_FLFLAGS |
1340                                          OBD_MD_FLGROUP;
1341                 data.ioc_obdo2.o_misc = stripe_count;
1342                 data.ioc_obdo2.o_stripe_idx = stripe_index;
1343
1344                 if (total_count > 0) {
1345                         if ((total_count - count) > MD_STEP_COUNT)
1346                                 data.ioc_count = MD_STEP_COUNT;
1347                         else
1348                                 data.ioc_count = total_count - count;
1349                 } else {
1350                         data.ioc_count = MD_STEP_COUNT;
1351                 }
1352
1353                 if (cmd == ECHO_MD_CREATE || cmd == ECHO_MD_MKDIR) {
1354                         /*Allocate fids for the create */
1355                         rc = jt_obd_alloc_fids(&fid_space, &fid,
1356                                                &data.ioc_count);
1357                         if (rc) {
1358                                 fprintf(stderr, "Allocate fids error %d.\n",rc);
1359                                 return rc;
1360                         }
1361                         fid_to_ostid(&fid, &data.ioc_obdo1.o_oi);
1362                 }
1363
1364                 child_base_id += data.ioc_count;
1365                 count += data.ioc_count;
1366
1367                 memset(buf, 0, sizeof(rawbuf));
1368                 rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
1369                 if (rc) {
1370                         fprintf(stderr, "error: %s: invalid ioctl %d\n",
1371                                 jt_cmdname(argv[0]), rc);
1372                         return rc;
1373                 }
1374
1375                 rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_ECHO_MD, buf);
1376                 if (rc) {
1377                         fprintf(stderr, "error: %s: %s\n",
1378                                 jt_cmdname(argv[0]), strerror(rc = errno));
1379                         return rc;
1380                 }
1381                 shmem_bump(data.ioc_count);
1382
1383                 gettimeofday(&end_time, NULL);
1384                 diff = difftime(&end_time, &start);
1385                 if (seconds > 0 && (__u64)diff > seconds)
1386                         break;
1387
1388                 if (count >= total_count && total_count > 0)
1389                         break;
1390         }
1391
1392         if (count > 0 && version) {
1393                 gettimeofday(&end_time, NULL);
1394                 diff = difftime(&end_time, &start);
1395                 printf("%s: %d in %.3fs (%.3f /s): %s",
1396                         jt_cmdname(argv[0]), count, diff,
1397                         (double)count/diff, ctime(&end_time.tv_sec));
1398         }
1399
1400 #ifdef MAX_THREADS
1401         if (thread) {
1402                 shmem_lock();
1403                 shmem_end_time_locked();
1404                 shmem_unlock();
1405         }
1406 #endif
1407         return rc;
1408 }
1409
1410 int jt_obd_test_create(int argc, char **argv)
1411 {
1412         return jt_obd_md_common(argc, argv, ECHO_MD_CREATE);
1413 }
1414
1415 int jt_obd_test_mkdir(int argc, char **argv)
1416 {
1417         return jt_obd_md_common(argc, argv, ECHO_MD_MKDIR);
1418 }
1419
1420 int jt_obd_test_destroy(int argc, char **argv)
1421 {
1422         return jt_obd_md_common(argc, argv, ECHO_MD_DESTROY);
1423 }
1424
1425 int jt_obd_test_rmdir(int argc, char **argv)
1426 {
1427         return jt_obd_md_common(argc, argv, ECHO_MD_RMDIR);
1428 }
1429
1430 int jt_obd_test_lookup(int argc, char **argv)
1431 {
1432         return jt_obd_md_common(argc, argv, ECHO_MD_LOOKUP);
1433 }
1434
1435 int jt_obd_test_setxattr(int argc, char **argv)
1436 {
1437         return jt_obd_md_common(argc, argv, ECHO_MD_SETATTR);
1438 }
1439
1440 int jt_obd_test_md_getattr(int argc, char **argv)
1441 {
1442         return jt_obd_md_common(argc, argv, ECHO_MD_GETATTR);
1443 }
1444
1445 int jt_obd_create(int argc, char **argv)
1446 {
1447         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
1448         struct obd_ioctl_data data;
1449         struct timeval next_time;
1450         __u64 count = 1, next_count, base_id = 1;
1451         int verbose = 1, mode = 0100644, rc = 0, i;
1452         char *end;
1453
1454         memset(&data, 0, sizeof(data));
1455         data.ioc_dev = cur_device;
1456         if (argc < 2 || argc > 4)
1457                 return CMD_HELP;
1458
1459         count = strtoull(argv[1], &end, 0);
1460         if (*end) {
1461                 fprintf(stderr, "error: %s: invalid iteration count '%s'\n",
1462                         jt_cmdname(argv[0]), argv[1]);
1463                 return CMD_HELP;
1464         }
1465
1466         if (argc > 2) {
1467                 mode = strtoul(argv[2], &end, 0);
1468                 if (*end) {
1469                         fprintf(stderr, "error: %s: invalid mode '%s'\n",
1470                                 jt_cmdname(argv[0]), argv[2]);
1471                         return CMD_HELP;
1472                 }
1473                 if (!(mode & S_IFMT))
1474                         mode |= S_IFREG;
1475         }
1476
1477         if (argc > 3) {
1478                 verbose = get_verbose(argv[0], argv[3]);
1479                 if (verbose == BAD_VERBOSE)
1480                         return CMD_HELP;
1481         }
1482
1483         printf("%s: "LPD64" objects\n", jt_cmdname(argv[0]), count);
1484         gettimeofday(&next_time, NULL);
1485         next_time.tv_sec -= verbose;
1486
1487         ostid_set_seq_echo(&data.ioc_obdo1.o_oi);
1488         for (i = 1, next_count = verbose; i <= count && shmem_running(); i++) {
1489                 data.ioc_obdo1.o_mode = mode;
1490                 ostid_set_id(&data.ioc_obdo1.o_oi, base_id);
1491                 data.ioc_obdo1.o_uid = 0;
1492                 data.ioc_obdo1.o_gid = 0;
1493                 data.ioc_obdo1.o_valid = OBD_MD_FLTYPE | OBD_MD_FLMODE |
1494                                          OBD_MD_FLID | OBD_MD_FLUID |
1495                                          OBD_MD_FLGID | OBD_MD_FLGROUP;
1496
1497                 memset(buf, 0, sizeof(rawbuf));
1498                 rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
1499                 if (rc) {
1500                         fprintf(stderr, "error: %s: invalid ioctl\n",
1501                                 jt_cmdname(argv[0]));
1502                         return rc;
1503                 }
1504                 rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_CREATE, buf);
1505                 obd_ioctl_unpack(&data, buf, sizeof(rawbuf));
1506                 shmem_bump(1);
1507                 if (rc < 0) {
1508                         fprintf(stderr, "error: %s: #%d - %s\n",
1509                                 jt_cmdname(argv[0]), i, strerror(rc = errno));
1510                         break;
1511                 }
1512                 if (!(data.ioc_obdo1.o_valid & OBD_MD_FLID)) {
1513                         fprintf(stderr,"error: %s: oid not valid #%d:"LPX64"\n",
1514                                 jt_cmdname(argv[0]), i, data.ioc_obdo1.o_valid);
1515                         rc = EINVAL;
1516                         break;
1517                 }
1518
1519                 if (be_verbose(verbose, &next_time, i, &next_count, count))
1520                         printf("%s: #%d is object id "LPX64"\n",
1521                                jt_cmdname(argv[0]), i,
1522                                ostid_id(&data.ioc_obdo1.o_oi));
1523         }
1524         return rc;
1525 }
1526
1527 int jt_obd_setattr(int argc, char **argv)
1528 {
1529         struct obd_ioctl_data data;
1530         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
1531         char *end;
1532         int rc;
1533
1534         memset(&data, 0, sizeof(data));
1535         data.ioc_dev = cur_device;
1536         if (argc != 2)
1537                 return CMD_HELP;
1538
1539         ostid_set_seq_echo(&data.ioc_obdo1.o_oi);
1540         ostid_set_id(&data.ioc_obdo1.o_oi, strtoull(argv[1], &end, 0));
1541         if (*end) {
1542                 fprintf(stderr, "error: %s: invalid objid '%s'\n",
1543                         jt_cmdname(argv[0]), argv[1]);
1544                 return CMD_HELP;
1545         }
1546         data.ioc_obdo1.o_mode = S_IFREG | strtoul(argv[2], &end, 0);
1547         if (*end) {
1548                 fprintf(stderr, "error: %s: invalid mode '%s'\n",
1549                         jt_cmdname(argv[0]), argv[2]);
1550                 return CMD_HELP;
1551         }
1552         data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE;
1553
1554         memset(buf, 0, sizeof(rawbuf));
1555         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
1556         if (rc) {
1557                 fprintf(stderr, "error: %s: invalid ioctl\n",
1558                         jt_cmdname(argv[0]));
1559                 return rc;
1560         }
1561         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_SETATTR, buf);
1562         if (rc < 0)
1563                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
1564                         strerror(rc = errno));
1565
1566         return rc;
1567 }
1568
1569 int jt_obd_test_setattr(int argc, char **argv)
1570 {
1571         struct obd_ioctl_data data;
1572         struct timeval start, next_time;
1573         __u64 i, count, next_count;
1574         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
1575         int verbose = 1;
1576         obd_id objid = 3;
1577         char *end;
1578         int rc = 0;
1579
1580         if (argc < 2 || argc > 4)
1581                 return CMD_HELP;
1582
1583         memset(&data, 0, sizeof(data));
1584         data.ioc_dev = cur_device;
1585         count = strtoull(argv[1], &end, 0);
1586         if (*end) {
1587                 fprintf(stderr, "error: %s: invalid iteration count '%s'\n",
1588                         jt_cmdname(argv[0]), argv[1]);
1589                 return CMD_HELP;
1590         }
1591
1592         if (argc >= 3) {
1593                 verbose = get_verbose(argv[0], argv[2]);
1594                 if (verbose == BAD_VERBOSE)
1595                         return CMD_HELP;
1596         }
1597
1598         if (argc >= 4) {
1599                 if (argv[3][0] == 't') {
1600                         objid = strtoull(argv[3] + 1, &end, 0);
1601                         if (thread)
1602                                 objid += thread - 1;
1603                 } else
1604                         objid = strtoull(argv[3], &end, 0);
1605                 if (*end) {
1606                         fprintf(stderr, "error: %s: invalid objid '%s'\n",
1607                                 jt_cmdname(argv[0]), argv[3]);
1608                         return CMD_HELP;
1609                 }
1610         }
1611
1612         gettimeofday(&start, NULL);
1613         next_time.tv_sec = start.tv_sec - verbose;
1614         next_time.tv_usec = start.tv_usec;
1615         if (verbose != 0)
1616                 printf("%s: setting "LPD64" attrs (objid "LPX64"): %s",
1617                        jt_cmdname(argv[0]), count, objid, ctime(&start.tv_sec));
1618
1619         ostid_set_seq_echo(&data.ioc_obdo1.o_oi);
1620         for (i = 1, next_count = verbose; i <= count && shmem_running(); i++) {
1621                 ostid_set_id(&data.ioc_obdo1.o_oi, objid);
1622                 data.ioc_obdo1.o_mode = S_IFREG;
1623                 data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE;
1624                 memset(buf, 0, sizeof(rawbuf));
1625                 rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
1626                 if (rc) {
1627                         fprintf(stderr, "error: %s: invalid ioctl\n",
1628                                 jt_cmdname(argv[0]));
1629                         return rc;
1630                 }
1631                 rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_SETATTR, &data);
1632                 shmem_bump(1);
1633                 if (rc < 0) {
1634                         fprintf(stderr, "error: %s: #"LPD64" - %d:%s\n",
1635                                 jt_cmdname(argv[0]), i, errno, strerror(rc = errno));
1636                         break;
1637                 } else {
1638                         if (be_verbose
1639                             (verbose, &next_time, i, &next_count, count))
1640                                 printf("%s: set attr #"LPD64"\n",
1641                                        jt_cmdname(argv[0]), i);
1642                 }
1643         }
1644
1645         if (!rc) {
1646                 struct timeval end;
1647                 double diff;
1648
1649                 gettimeofday(&end, NULL);
1650
1651                 diff = difftime(&end, &start);
1652
1653                 --i;
1654                 if (verbose != 0)
1655                         printf("%s: "LPD64" attrs in %.3fs (%.3f attr/s): %s",
1656                                jt_cmdname(argv[0]), i, diff, i / diff,
1657                                ctime(&end.tv_sec));
1658         }
1659         return rc;
1660 }
1661
1662 int jt_obd_destroy(int argc, char **argv)
1663 {
1664         struct obd_ioctl_data data;
1665         struct timeval next_time;
1666         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
1667         __u64 count = 1, next_count;
1668         int verbose = 1;
1669         __u64 id;
1670         char *end;
1671         int rc = 0, i;
1672
1673         memset(&data, 0, sizeof(data));
1674         data.ioc_dev = cur_device;
1675         if (argc < 2 || argc > 4)
1676                 return CMD_HELP;
1677
1678         id = strtoull(argv[1], &end, 0);
1679         if (*end || id == 0 || errno != 0) {
1680                 fprintf(stderr, "error: %s: invalid objid '%s'\n",
1681                         jt_cmdname(argv[0]), argv[1]);
1682                 return CMD_HELP;
1683         }
1684         if (argc > 2) {
1685                 count = strtoull(argv[2], &end, 0);
1686                 if (*end) {
1687                         fprintf(stderr,
1688                                 "error: %s: invalid iteration count '%s'\n",
1689                                 jt_cmdname(argv[0]), argv[2]);
1690                         return CMD_HELP;
1691                 }
1692         }
1693
1694         if (argc > 3) {
1695                 verbose = get_verbose(argv[0], argv[3]);
1696                 if (verbose == BAD_VERBOSE)
1697                         return CMD_HELP;
1698         }
1699
1700         printf("%s: "LPD64" objects\n", jt_cmdname(argv[0]), count);
1701         gettimeofday(&next_time, NULL);
1702         next_time.tv_sec -= verbose;
1703
1704         ostid_set_seq_echo(&data.ioc_obdo1.o_oi);
1705         for (i = 1, next_count = verbose; i <= count && shmem_running(); i++, id++) {
1706                 ostid_set_id(&data.ioc_obdo1.o_oi, id);
1707                 data.ioc_obdo1.o_mode = S_IFREG | 0644;
1708                 data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLMODE;
1709
1710                 memset(buf, 0, sizeof(rawbuf));
1711                 rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
1712                 if (rc) {
1713                         fprintf(stderr, "error: %s: invalid ioctl\n",
1714                                 jt_cmdname(argv[0]));
1715                         return rc;
1716                 }
1717                 rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_DESTROY, buf);
1718                 obd_ioctl_unpack(&data, buf, sizeof(rawbuf));
1719                 shmem_bump(1);
1720                 if (rc < 0) {
1721                         fprintf(stderr, "error: %s: objid "LPX64": %s\n",
1722                                 jt_cmdname(argv[0]), id, strerror(rc = errno));
1723                         break;
1724                 }
1725
1726                 if (be_verbose(verbose, &next_time, i, &next_count, count))
1727                         printf("%s: #%d is object id "LPX64"\n",
1728                                jt_cmdname(argv[0]), i, id);
1729         }
1730
1731         return rc;
1732 }
1733
1734 int jt_obd_getattr(int argc, char **argv)
1735 {
1736         struct obd_ioctl_data data;
1737         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
1738         char *end;
1739         int rc;
1740
1741         if (argc != 2)
1742                 return CMD_HELP;
1743
1744         memset(&data, 0, sizeof(data));
1745         data.ioc_dev = cur_device;
1746         ostid_set_seq_echo(&data.ioc_obdo1.o_oi);
1747         ostid_set_id(&data.ioc_obdo1.o_oi, strtoull(argv[1], &end, 0));
1748         if (*end) {
1749                 fprintf(stderr, "error: %s: invalid objid '%s'\n",
1750                         jt_cmdname(argv[0]), argv[1]);
1751                 return CMD_HELP;
1752         }
1753         /* to help obd filter */
1754         data.ioc_obdo1.o_mode = 0100644;
1755         data.ioc_obdo1.o_valid = 0xffffffff;
1756         printf("%s: object id "LPX64"\n", jt_cmdname(argv[0]),
1757                ostid_id(&data.ioc_obdo1.o_oi));
1758
1759         memset(buf, 0, sizeof(rawbuf));
1760         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
1761         if (rc) {
1762                 fprintf(stderr, "error: %s: invalid ioctl\n",
1763                         jt_cmdname(argv[0]));
1764                 return rc;
1765         }
1766         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_GETATTR, buf);
1767         obd_ioctl_unpack(&data, buf, sizeof(rawbuf));
1768         if (rc) {
1769                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
1770                         strerror(rc = errno));
1771         } else {
1772                 printf("%s: object id "LPU64", mode %o\n", jt_cmdname(argv[0]),
1773                        ostid_id(&data.ioc_obdo1.o_oi), data.ioc_obdo1.o_mode);
1774         }
1775         return rc;
1776 }
1777
1778 int jt_obd_test_getattr(int argc, char **argv)
1779 {
1780         struct obd_ioctl_data data;
1781         struct timeval start, next_time;
1782         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
1783         __u64 i, count, next_count;
1784         int verbose = 1;
1785         obd_id objid = 3;
1786         char *end;
1787         int rc = 0;
1788
1789         if (argc < 2 || argc > 4)
1790                 return CMD_HELP;
1791
1792         memset(&data, 0, sizeof(data));
1793         data.ioc_dev = cur_device;
1794         count = strtoull(argv[1], &end, 0);
1795         if (*end) {
1796                 fprintf(stderr, "error: %s: invalid iteration count '%s'\n",
1797                         jt_cmdname(argv[0]), argv[1]);
1798                 return CMD_HELP;
1799         }
1800
1801         if (argc >= 3) {
1802                 verbose = get_verbose(argv[0], argv[2]);
1803                 if (verbose == BAD_VERBOSE)
1804                         return CMD_HELP;
1805         }
1806
1807         if (argc >= 4) {
1808                 if (argv[3][0] == 't') {
1809                         objid = strtoull(argv[3] + 1, &end, 0);
1810                         if (thread)
1811                                 objid += thread - 1;
1812                 } else
1813                         objid = strtoull(argv[3], &end, 0);
1814                 if (*end) {
1815                         fprintf(stderr, "error: %s: invalid objid '%s'\n",
1816                                 jt_cmdname(argv[0]), argv[3]);
1817                         return CMD_HELP;
1818                 }
1819         }
1820
1821         gettimeofday(&start, NULL);
1822         next_time.tv_sec = start.tv_sec - verbose;
1823         next_time.tv_usec = start.tv_usec;
1824         if (verbose != 0)
1825                 printf("%s: getting "LPD64" attrs (objid "LPX64"): %s",
1826                        jt_cmdname(argv[0]), count, objid, ctime(&start.tv_sec));
1827
1828         ostid_set_seq_echo(&data.ioc_obdo1.o_oi);
1829         for (i = 1, next_count = verbose; i <= count && shmem_running(); i++) {
1830                 ostid_set_id(&data.ioc_obdo1.o_oi, objid);
1831                 data.ioc_obdo1.o_mode = S_IFREG;
1832                 data.ioc_obdo1.o_valid = 0xffffffff;
1833                 memset(buf, 0, sizeof(rawbuf));
1834                 rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
1835                 if (rc) {
1836                         fprintf(stderr, "error: %s: invalid ioctl\n",
1837                                 jt_cmdname(argv[0]));
1838                         return rc;
1839                 }
1840                 rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_GETATTR, &data);
1841                 shmem_bump(1);
1842                 if (rc < 0) {
1843                         fprintf(stderr, "error: %s: #"LPD64" - %d:%s\n",
1844                                 jt_cmdname(argv[0]), i, errno, strerror(rc = errno));
1845                         break;
1846                 } else {
1847                         if (be_verbose
1848                             (verbose, &next_time, i, &next_count, count))
1849                                 printf("%s: got attr #"LPD64"\n",
1850                                        jt_cmdname(argv[0]), i);
1851                 }
1852         }
1853
1854         if (!rc) {
1855                 struct timeval end;
1856                 double diff;
1857
1858                 gettimeofday(&end, NULL);
1859
1860                 diff = difftime(&end, &start);
1861
1862                 --i;
1863                 if (verbose != 0)
1864                         printf("%s: "LPD64" attrs in %.3fs (%.3f attr/s): %s",
1865                                jt_cmdname(argv[0]), i, diff, i / diff,
1866                                ctime(&end.tv_sec));
1867         }
1868         return rc;
1869 }
1870
1871 /* test_brw <cnt>                                               count
1872         <r|w[r(repeat)x(noverify)]>                             mode
1873         <q|v|#(print interval)>                                 verbosity
1874         <npages[+offset]>                                       blocksize
1875         <[[<interleave_threads>]t(inc obj by thread#)]obj>      object
1876         [p|g<args>]                                             batch */
1877 int jt_obd_test_brw(int argc, char **argv)
1878 {
1879         struct obd_ioctl_data data;
1880         struct timeval start, next_time;
1881         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
1882         __u64 count, next_count, len, stride, thr_offset = 0, objid = 3;
1883         int write = 0, verbose = 1, cmd, i, rc = 0, pages = 1;
1884         int offset_pages = 0;
1885         long n;
1886         int repeat_offset = 0;
1887         unsigned long long ull;
1888         int  nthr_per_obj = 0;
1889         int  verify = 1;
1890         int  obj_idx = 0;
1891         char *end;
1892
1893         if (argc < 2 || argc > 7) {
1894                 fprintf(stderr, "error: %s: bad number of arguments: %d\n",
1895                         jt_cmdname(argv[0]), argc);
1896                 return CMD_HELP;
1897         }
1898
1899         count = strtoull(argv[1], &end, 0);
1900         if (*end) {
1901                 fprintf(stderr, "error: %s: bad iteration count '%s'\n",
1902                         jt_cmdname(argv[0]), argv[1]);
1903                 return CMD_HELP;
1904         }
1905
1906         if (argc >= 3) {
1907                 if (argv[2][0] == 'w' || argv[2][0] == '1')
1908                         write = 1;
1909                 /* else it's a read */
1910
1911                 if (argv[2][0] != 0)
1912                         for (i = 1; argv[2][i] != 0; i++)
1913                                 switch (argv[2][i]) {
1914                                 case 'r':
1915                                         repeat_offset = 1;
1916                                         break;
1917
1918                                 case 'x':
1919                                         verify = 0;
1920                                         break;
1921
1922                                 default:
1923                                         fprintf (stderr, "Can't parse cmd '%s'\n",
1924                                                  argv[2]);
1925                                         return CMD_HELP;
1926                                 }
1927         }
1928
1929         if (argc >= 4) {
1930                 verbose = get_verbose(argv[0], argv[3]);
1931                 if (verbose == BAD_VERBOSE)
1932                         return CMD_HELP;
1933         }
1934
1935         if (argc >= 5) {
1936                 pages = strtoul(argv[4], &end, 0);
1937
1938                 if (*end == '+')
1939                         offset_pages = strtoul(end + 1, &end, 0);
1940
1941                 if (*end != 0 ||
1942                     offset_pages < 0 || offset_pages >= pages) {
1943                         fprintf(stderr, "error: %s: bad npages[+offset] parameter '%s'\n",
1944                                 jt_cmdname(argv[0]), argv[4]);
1945                         return CMD_HELP;
1946                 }
1947         }
1948
1949         if (argc >= 6) {
1950                 if (thread &&
1951                     (n = strtol(argv[5], &end, 0)) > 0 &&
1952                     *end == 't' &&
1953                     (ull = strtoull(end + 1, &end, 0)) > 0 &&
1954                     *end == 0) {
1955                         nthr_per_obj = n;
1956                         objid = ull;
1957                 } else if (thread &&
1958                            argv[5][0] == 't') {
1959                         nthr_per_obj = 1;
1960                         objid = strtoull(argv[5] + 1, &end, 0);
1961                 } else {
1962                         nthr_per_obj = 0;
1963                         objid = strtoull(argv[5], &end, 0);
1964                 }
1965                 if (*end) {
1966                         fprintf(stderr, "error: %s: bad objid '%s'\n",
1967                                 jt_cmdname(argv[0]), argv[5]);
1968                         return CMD_HELP;
1969                 }
1970         }
1971
1972         memset(&data, 0, sizeof(data));
1973         data.ioc_dev = cur_device;
1974
1975         /* communicate the 'type' of brw test and batching to echo_client.
1976          * don't start.  we'd love to refactor this lctl->echo_client
1977          * interface */
1978         data.ioc_pbuf1 = (void *)1;
1979         data.ioc_plen1 = 1;
1980
1981         if (argc >= 7) {
1982                 switch(argv[6][0]) {
1983                         case 'g': /* plug and unplug */
1984                                 data.ioc_pbuf1 = (void *)2;
1985                                 data.ioc_plen1 = strtoull(argv[6] + 1, &end,
1986                                                           0);
1987                                 break;
1988                         case 'p': /* prep and commit */
1989                                 data.ioc_pbuf1 = (void *)3;
1990                                 data.ioc_plen1 = strtoull(argv[6] + 1, &end,
1991                                                           0);
1992                                 break;
1993                         default:
1994                                 fprintf(stderr, "error: %s: batching '%s' "
1995                                         "needs to specify 'p' or 'g'\n",
1996                                         jt_cmdname(argv[0]), argv[6]);
1997                                 return CMD_HELP;
1998                 }
1999
2000                 if (*end) {
2001                         fprintf(stderr, "error: %s: bad batching '%s'\n",
2002                                 jt_cmdname(argv[0]), argv[6]);
2003                         return CMD_HELP;
2004                 }
2005                 data.ioc_plen1 *= getpagesize();
2006         }
2007
2008         len = pages * getpagesize();
2009         thr_offset = offset_pages * getpagesize();
2010         stride = len;
2011
2012 #ifdef MAX_THREADS
2013         if (thread) {
2014                 shmem_lock ();
2015                 if (nthr_per_obj != 0) {
2016                         /* threads interleave */
2017                         obj_idx = (thread - 1)/nthr_per_obj;
2018                         objid += obj_idx;
2019                         stride *= nthr_per_obj;
2020                         if ((thread - 1) % nthr_per_obj == 0) {
2021                                 shared_data->body.offsets[obj_idx] =
2022                                         stride + thr_offset;
2023                         }
2024                         thr_offset += ((thread - 1) % nthr_per_obj) * len;
2025                 } else {
2026                         /* threads disjoint */
2027                         thr_offset += (thread - 1) * len;
2028                 }
2029
2030                 shmem_start_time_locked();
2031                 shmem_unlock ();
2032         }
2033 #endif
2034
2035         ostid_set_seq_echo(&data.ioc_obdo1.o_oi);
2036         ostid_set_id(&data.ioc_obdo1.o_oi, objid);
2037         data.ioc_obdo1.o_mode = S_IFREG;
2038         data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE |
2039                                  OBD_MD_FLFLAGS | OBD_MD_FLGROUP;
2040         data.ioc_obdo1.o_flags = (verify ? OBD_FL_DEBUG_CHECK : 0);
2041         data.ioc_count = len;
2042         data.ioc_offset = (repeat_offset ? 0 : thr_offset);
2043
2044         gettimeofday(&start, NULL);
2045         next_time.tv_sec = start.tv_sec - verbose;
2046         next_time.tv_usec = start.tv_usec;
2047
2048         if (verbose != 0)
2049                 printf("%s: %s "LPU64"x%d pages (obj "LPX64", off "LPU64"): %s",
2050                        jt_cmdname(argv[0]), write ? "writing" : "reading", count,
2051                        pages, objid, data.ioc_offset, ctime(&start.tv_sec));
2052
2053         cmd = write ? OBD_IOC_BRW_WRITE : OBD_IOC_BRW_READ;
2054         for (i = 1, next_count = verbose; i <= count && shmem_running(); i++) {
2055                 data.ioc_obdo1.o_valid &= ~(OBD_MD_FLBLOCKS|OBD_MD_FLGRANT);
2056                 memset(buf, 0, sizeof(rawbuf));
2057                 rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
2058                 if (rc) {
2059                         fprintf(stderr, "error: %s: invalid ioctl\n",
2060                                 jt_cmdname(argv[0]));
2061                         return rc;
2062                 }
2063                 rc = l2_ioctl(OBD_DEV_ID, cmd, buf);
2064                 shmem_bump(1);
2065                 if (rc) {
2066                         fprintf(stderr, "error: %s: #%d - %s on %s\n",
2067                                 jt_cmdname(argv[0]), i, strerror(rc = errno),
2068                                 write ? "write" : "read");
2069                         break;
2070                 } else if (be_verbose(verbose, &next_time,i, &next_count,count)) {
2071                         shmem_lock ();
2072                         printf("%s: %s number %d @ "LPD64":"LPU64" for %d\n",
2073                                jt_cmdname(argv[0]), write ? "write" : "read", i,
2074                                ostid_id(&data.ioc_obdo1.o_oi), data.ioc_offset,
2075                                (int)(pages * getpagesize()));
2076                         shmem_unlock ();
2077                 }
2078
2079                 if (!repeat_offset) {
2080 #ifdef MAX_THREADS
2081                         if (stride == len) {
2082                                 data.ioc_offset += stride;
2083                         } else if (i < count) {
2084                                 shmem_lock ();
2085                                 data.ioc_offset =
2086                                         shared_data->body.offsets[obj_idx];
2087                                 shared_data->body.offsets[obj_idx] += len;
2088                                 shmem_unlock ();
2089                         }
2090 #else
2091                         data.ioc_offset += len;
2092                         obj_idx = 0; /* avoids an unused var warning */
2093 #endif
2094                 }
2095         }
2096
2097         if (!rc) {
2098                 struct timeval end;
2099                 double diff;
2100
2101                 gettimeofday(&end, NULL);
2102
2103                 diff = difftime(&end, &start);
2104
2105                 --i;
2106                 if (verbose != 0)
2107                         printf("%s: %s %dx%d pages in %.3fs (%.3f MB/s): %s",
2108                                jt_cmdname(argv[0]), write ? "wrote" : "read",
2109                                i, pages, diff,
2110                                ((double)i * pages * getpagesize()) /
2111                                (diff * 1048576.0),
2112                                ctime(&end.tv_sec));
2113         }
2114
2115 #ifdef MAX_THREADS
2116         if (thread) {
2117                 shmem_lock();
2118                 shmem_end_time_locked();
2119                 shmem_unlock();
2120         }
2121 #endif
2122         return rc;
2123 }
2124
2125 int jt_obd_lov_getconfig(int argc, char **argv)
2126 {
2127         struct obd_ioctl_data data;
2128         struct lov_desc desc;
2129         struct obd_uuid *uuidarray;
2130         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2131         __u32 *obdgens;
2132         char *path;
2133         int rc, fd;
2134
2135         memset(&data, 0, sizeof(data));
2136         data.ioc_dev = cur_device;
2137
2138         if (argc != 2)
2139                 return CMD_HELP;
2140
2141         path = argv[1];
2142         fd = open(path, O_RDONLY);
2143         if (fd < 0) {
2144                 fprintf(stderr, "open \"%s\" failed: %s\n", path,
2145                         strerror(errno));
2146                 return -errno;
2147         }
2148
2149         memset(&desc, 0, sizeof(desc));
2150         obd_str2uuid(&desc.ld_uuid, argv[1]);
2151         desc.ld_tgt_count = ((OBD_MAX_IOCTL_BUFFER-sizeof(data)-sizeof(desc)) /
2152                              (sizeof(*uuidarray) + sizeof(*obdgens)));
2153
2154 repeat:
2155         uuidarray = calloc(desc.ld_tgt_count, sizeof(*uuidarray));
2156         if (!uuidarray) {
2157                 fprintf(stderr, "error: %s: no memory for %d uuid's\n",
2158                         jt_cmdname(argv[0]), desc.ld_tgt_count);
2159                 rc = -ENOMEM;
2160                 goto out;
2161         }
2162         obdgens = calloc(desc.ld_tgt_count, sizeof(*obdgens));
2163         if (!obdgens) {
2164                 fprintf(stderr, "error: %s: no memory for %d generation #'s\n",
2165                         jt_cmdname(argv[0]), desc.ld_tgt_count);
2166                 rc = -ENOMEM;
2167                 goto out_uuidarray;
2168         }
2169
2170         memset(buf, 0, sizeof(rawbuf));
2171         data.ioc_inllen1 = sizeof(desc);
2172         data.ioc_inlbuf1 = (char *)&desc;
2173         data.ioc_inllen2 = desc.ld_tgt_count * sizeof(*uuidarray);
2174         data.ioc_inlbuf2 = (char *)uuidarray;
2175         data.ioc_inllen3 = desc.ld_tgt_count * sizeof(*obdgens);
2176         data.ioc_inlbuf3 = (char *)obdgens;
2177
2178         if (obd_ioctl_pack(&data, &buf, sizeof(rawbuf))) {
2179                 fprintf(stderr, "error: %s: invalid ioctl\n",
2180                         jt_cmdname(argv[0]));
2181                 rc = -EINVAL;
2182                 goto out_obdgens;
2183         }
2184         rc = ioctl(fd, OBD_IOC_LOV_GET_CONFIG, buf);
2185         if (rc == -ENOSPC) {
2186                 free(uuidarray);
2187                 free(obdgens);
2188                 goto repeat;
2189         } else if (rc) {
2190                 fprintf(stderr, "error: %s: ioctl error: %s\n",
2191                         jt_cmdname(argv[0]), strerror(rc = errno));
2192         } else {
2193                 struct obd_uuid *uuidp;
2194                 __u32 *genp;
2195                 int i;
2196
2197                 if (obd_ioctl_unpack(&data, buf, sizeof(rawbuf))) {
2198                         fprintf(stderr, "error: %s: invalid reply\n",
2199                                 jt_cmdname(argv[0]));
2200                         rc = -EINVAL;
2201                         goto out;
2202                 }
2203                 if (desc.ld_default_stripe_count == (__u32)-1)
2204                         printf("default_stripe_count: %d\n", -1);
2205                 else
2206                         printf("default_stripe_count: %u\n",
2207                                desc.ld_default_stripe_count);
2208                 printf("default_stripe_size: "LPU64"\n",
2209                        desc.ld_default_stripe_size);
2210                 printf("default_stripe_offset: "LPU64"\n",
2211                        desc.ld_default_stripe_offset);
2212                 printf("default_stripe_pattern: %u\n", desc.ld_pattern);
2213                 printf("obd_count: %u\n", desc.ld_tgt_count);
2214                 printf("OBDS:\tobdidx\t\tobdgen\t\t obduuid\n");
2215                 uuidp = uuidarray;
2216                 genp = obdgens;
2217                 for (i = 0; i < desc.ld_tgt_count; i++, uuidp++, genp++)
2218                         printf("\t%6u\t%14u\t\t %s\n", i, *genp, (char *)uuidp);
2219         }
2220 out_obdgens:
2221         free(obdgens);
2222 out_uuidarray:
2223         free(uuidarray);
2224 out:
2225         close(fd);
2226         return rc;
2227 }
2228
2229 static int do_activate(int argc, char **argv, int flag)
2230 {
2231         struct obd_ioctl_data data;
2232         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2233         int rc;
2234
2235         memset(&data, 0, sizeof(data));
2236         data.ioc_dev = cur_device;
2237         if (argc != 1)
2238                 return CMD_HELP;
2239
2240         /* reuse offset for 'active' */
2241         data.ioc_offset = flag;
2242
2243         memset(buf, 0, sizeof(rawbuf));
2244         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
2245         if (rc) {
2246                 fprintf(stderr, "error: %s: invalid ioctl\n",
2247                         jt_cmdname(argv[0]));
2248                 return rc;
2249         }
2250         rc = l2_ioctl(OBD_DEV_ID, IOC_OSC_SET_ACTIVE, buf);
2251         if (rc)
2252                 fprintf(stderr, "error: %s: failed: %s\n",
2253                         jt_cmdname(argv[0]), strerror(rc = errno));
2254
2255         return rc;
2256 }
2257
2258 /**
2259  * Replace nids for given device.
2260  * lctl replace_nids <devicename> <nid1>[,nid2,nid3]
2261  * Command should be started on MGS server.
2262  * Only MGS server should be started (command execution
2263  * returns error in another cases). Command mount
2264  * -t lustre <MDT partition> -o nosvc <mount point>
2265  * can be used for that.
2266  *
2267  * llogs for MDTs and clients are processed. All
2268  * records copied as is except add_uuid and setup. This records
2269  * are skipped and recorded with new nids and uuid.
2270  *
2271  * \see mgs_replace_nids
2272  * \see mgs_replace_nids_log
2273  * \see mgs_replace_handler
2274  */
2275 int jt_replace_nids(int argc, char **argv)
2276 {
2277         int rc;
2278         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2279         struct obd_ioctl_data data;
2280
2281         memset(&data, 0, sizeof(data));
2282         data.ioc_dev = get_mgs_device();
2283         if (argc != 3)
2284                 return CMD_HELP;
2285
2286         data.ioc_inllen1 = strlen(argv[1]) + 1;
2287         data.ioc_inlbuf1 = argv[1];
2288
2289         data.ioc_inllen2 = strlen(argv[2]) + 1;
2290         data.ioc_inlbuf2 = argv[2];
2291         memset(buf, 0, sizeof(rawbuf));
2292         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
2293         if (rc) {
2294                 fprintf(stderr, "error: %s: invalid ioctl\n",
2295                         jt_cmdname(argv[0]));
2296                 return rc;
2297         }
2298
2299         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_REPLACE_NIDS, buf);
2300         if (rc < 0) {
2301                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
2302                         strerror(rc = errno));
2303         }
2304
2305         return rc;
2306 }
2307
2308 int jt_obd_deactivate(int argc, char **argv)
2309 {
2310         return do_activate(argc, argv, 0);
2311 }
2312
2313 int jt_obd_activate(int argc, char **argv)
2314 {
2315         return do_activate(argc, argv, 1);
2316 }
2317
2318 int jt_obd_recover(int argc, char **argv)
2319 {
2320         int rc;
2321         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2322         struct obd_ioctl_data data;
2323
2324         memset(&data, 0, sizeof(data));
2325         data.ioc_dev = cur_device;
2326         if (argc > 2)
2327                 return CMD_HELP;
2328
2329         if (argc == 2) {
2330                 data.ioc_inllen1 = strlen(argv[1]) + 1;
2331                 data.ioc_inlbuf1 = argv[1];
2332         }
2333
2334         memset(buf, 0, sizeof(rawbuf));
2335         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
2336         if (rc) {
2337                 fprintf(stderr, "error: %s: invalid ioctl\n",
2338                         jt_cmdname(argv[0]));
2339                 return rc;
2340         }
2341         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_CLIENT_RECOVER, buf);
2342         if (rc < 0) {
2343                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
2344                         strerror(rc = errno));
2345         }
2346
2347         return rc;
2348 }
2349
2350 int jt_obd_mdc_lookup(int argc, char **argv)
2351 {
2352         struct obd_ioctl_data data;
2353         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2354         char *parent, *child;
2355         int rc, fd, verbose = 1;
2356
2357         if (argc < 3 || argc > 4)
2358                 return CMD_HELP;
2359
2360         parent = argv[1];
2361         child = argv[2];
2362         if (argc == 4)
2363                 verbose = get_verbose(argv[0], argv[3]);
2364
2365         memset(&data, 0, sizeof(data));
2366         data.ioc_dev = cur_device;
2367
2368         data.ioc_inllen1 = strlen(child) + 1;
2369         data.ioc_inlbuf1 = child;
2370
2371         memset(buf, 0, sizeof(rawbuf));
2372         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
2373         if (rc) {
2374                 fprintf(stderr, "error: %s: invalid ioctl\n",
2375                         jt_cmdname(argv[0]));
2376                 return rc;
2377         }
2378
2379         fd = open(parent, O_RDONLY);
2380         if (fd < 0) {
2381                 fprintf(stderr, "open \"%s\" failed: %s\n", parent,
2382                         strerror(errno));
2383                 return -1;
2384         }
2385
2386         rc = ioctl(fd, IOC_MDC_LOOKUP, buf);
2387         if (rc < 0) {
2388                 fprintf(stderr, "error: %s: ioctl error: %s\n",
2389                         jt_cmdname(argv[0]), strerror(rc = errno));
2390         }
2391         close(fd);
2392
2393         if (verbose) {
2394                 rc = obd_ioctl_unpack(&data, buf, sizeof(rawbuf));
2395                 if (rc) {
2396                         fprintf(stderr, "error: %s: invalid reply\n",
2397                                 jt_cmdname(argv[0]));
2398                         return rc;
2399                 }
2400                 printf("%s: mode %o uid %d gid %d\n", child,
2401                        data.ioc_obdo1.o_mode, data.ioc_obdo1.o_uid,
2402                        data.ioc_obdo1.o_gid);
2403         }
2404
2405         return rc;
2406 }
2407
2408 int jt_cfg_dump_log(int argc, char **argv)
2409 {
2410         struct obd_ioctl_data data;
2411         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2412         int rc;
2413
2414         if (argc != 2)
2415                 return CMD_HELP;
2416
2417         memset(&data, 0, sizeof(data));
2418         data.ioc_dev = cur_device;
2419         data.ioc_inllen1 = strlen(argv[1]) + 1;
2420         data.ioc_inlbuf1 = argv[1];
2421
2422         memset(buf, 0, sizeof(rawbuf));
2423         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
2424         if (rc) {
2425                 fprintf(stderr, "error: %s: invalid ioctl\n",
2426                         jt_cmdname(argv[0]));
2427                 return rc;
2428         }
2429         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_DUMP_LOG, buf);
2430         if (rc < 0)
2431                 fprintf(stderr, "OBD_IOC_DUMP_LOG failed: %s\n",
2432                         strerror(errno));
2433
2434         return rc;
2435 }
2436
2437 int jt_llog_catlist(int argc, char **argv)
2438 {
2439         struct obd_ioctl_data data;
2440         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2441         int rc;
2442
2443         if (argc != 1)
2444                 return CMD_HELP;
2445
2446         memset(&data, 0, sizeof(data));
2447         data.ioc_dev = cur_device;
2448         data.ioc_inllen1 = sizeof(rawbuf) - cfs_size_round(sizeof(data));
2449         memset(buf, 0, sizeof(rawbuf));
2450         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
2451         if (rc) {
2452                 fprintf(stderr, "error: %s: invalid ioctl\n",
2453                         jt_cmdname(argv[0]));
2454                 return rc;
2455         }
2456         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_CATLOGLIST, buf);
2457         if (rc == 0)
2458                 fprintf(stdout, "%s", ((struct obd_ioctl_data*)buf)->ioc_bulk);
2459         else
2460                 fprintf(stderr, "OBD_IOC_CATLOGLIST failed: %s\n",
2461                         strerror(errno));
2462
2463         return rc;
2464 }
2465
2466 int jt_llog_info(int argc, char **argv)
2467 {
2468         struct obd_ioctl_data data;
2469         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2470         int rc;
2471
2472         if (argc != 2)
2473                 return CMD_HELP;
2474
2475         memset(&data, 0, sizeof(data));
2476         data.ioc_dev = cur_device;
2477         data.ioc_inllen1 = strlen(argv[1]) + 1;
2478         data.ioc_inlbuf1 = argv[1];
2479         data.ioc_inllen2 = sizeof(rawbuf) - cfs_size_round(sizeof(data)) -
2480                 cfs_size_round(data.ioc_inllen1);
2481         memset(buf, 0, sizeof(rawbuf));
2482         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
2483         if (rc) {
2484                 fprintf(stderr, "error: %s: invalid ioctl\n",
2485                         jt_cmdname(argv[0]));
2486                 return rc;
2487         }
2488
2489         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_INFO, buf);
2490         if (rc == 0)
2491                 fprintf(stdout, "%s", ((struct obd_ioctl_data*)buf)->ioc_bulk);
2492         else
2493                 fprintf(stderr, "OBD_IOC_LLOG_INFO failed: %s\n",
2494                         strerror(errno));
2495
2496         return rc;
2497 }
2498
2499 int jt_llog_print(int argc, char **argv)
2500 {
2501         struct obd_ioctl_data data;
2502         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2503         int rc;
2504
2505         if (argc != 2 && argc != 4)
2506                 return CMD_HELP;
2507
2508         memset(&data, 0, sizeof(data));
2509         data.ioc_dev = cur_device;
2510         data.ioc_inllen1 = strlen(argv[1]) + 1;
2511         data.ioc_inlbuf1 = argv[1];
2512         if (argc == 4) {
2513                 data.ioc_inllen2 = strlen(argv[2]) + 1;
2514                 data.ioc_inlbuf2 = argv[2];
2515                 data.ioc_inllen3 = strlen(argv[3]) + 1;
2516                 data.ioc_inlbuf3 = argv[3];
2517         } else {
2518                 char from[2] = "1", to[3] = "-1";
2519                 data.ioc_inllen2 = strlen(from) + 1;
2520                 data.ioc_inlbuf2 = from;
2521                 data.ioc_inllen3 = strlen(to) + 1;
2522                 data.ioc_inlbuf3 = to;
2523         }
2524         data.ioc_inllen4 = sizeof(rawbuf) - cfs_size_round(sizeof(data)) -
2525                 cfs_size_round(data.ioc_inllen1) -
2526                 cfs_size_round(data.ioc_inllen2) -
2527                 cfs_size_round(data.ioc_inllen3);
2528         memset(buf, 0, sizeof(rawbuf));
2529         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
2530         if (rc) {
2531                 fprintf(stderr, "error: %s: invalid ioctl\n",
2532                         jt_cmdname(argv[0]));
2533                 return rc;
2534         }
2535
2536         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_PRINT, buf);
2537         if (rc == 0)
2538                 fprintf(stdout, "%s", ((struct obd_ioctl_data*)buf)->ioc_bulk);
2539         else
2540                 fprintf(stderr, "OBD_IOC_LLOG_PRINT failed: %s\n",
2541                         strerror(errno));
2542
2543         return rc;
2544 }
2545
2546 static int llog_cancel_parse_optional(int argc, char **argv,
2547                                       struct obd_ioctl_data *data)
2548 {
2549         int cOpt;
2550         const char *const short_options = "c:l:i:h";
2551         const struct option long_options[] = {
2552                 {"catalog", required_argument, NULL, 'c'},
2553                 {"log_id", required_argument, NULL, 'l'},
2554                 {"log_idx", required_argument, NULL, 'i'},
2555                 {"help", no_argument, NULL, 'h'},
2556                 {NULL, 0, NULL, 0}
2557         };
2558
2559         /* sanity check */
2560         if (!data || argc <= 1) {
2561                 return -1;
2562         }
2563
2564         /*now process command line arguments*/
2565         while ((cOpt = getopt_long(argc, argv, short_options,
2566                                         long_options, NULL)) != -1) {
2567                 switch (cOpt) {
2568                 case 'c':
2569                         data->ioc_inllen1 = strlen(optarg) + 1;
2570                         data->ioc_inlbuf1 = optarg;
2571                         break;
2572
2573                 case 'l':
2574                         data->ioc_inllen2 = strlen(optarg) + 1;
2575                         data->ioc_inlbuf2 = optarg;
2576                         break;
2577
2578                 case 'i':
2579                         data->ioc_inllen3 = strlen(optarg) + 1;
2580                         data->ioc_inlbuf3 = optarg;
2581                         break;
2582
2583                 case 'h':
2584                 default:
2585                         return -1;
2586                 }
2587         }
2588
2589         if ((data->ioc_inlbuf1 == NULL) || (data->ioc_inlbuf3 == NULL)) {
2590                 /* missing mandatory parameters */
2591                 return -1;
2592         }
2593
2594         return 0;
2595 }
2596
2597 int jt_llog_cancel(int argc, char **argv)
2598 {
2599         struct obd_ioctl_data data;
2600         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2601         int rc, i;
2602
2603         /* check that the arguments provided are either all
2604          * optional or all positional.  No mixing allowed
2605          *
2606          * if argc is 4 or 3 then check all arguments to ensure that none
2607          * of them start with a '-'.  If so then this is invalid.
2608          * Otherwise if arg is > 4 then assume that this is optional
2609          * arguments, and parse as such ignoring any thing that's not
2610          * optional.  The result is that user must use optional arguments
2611          * for all mandatory parameters.  Code will ignore all other args
2612          *
2613          * The positional arguments option should eventually be phased out.
2614          */
2615         memset(&data, 0, sizeof(data));
2616         data.ioc_dev = cur_device;
2617
2618         if (argc == 3 || argc == 4) {
2619                 for (i = 1; i < argc; i++) {
2620                         if (argv[i][0] == '-')
2621                                 return CMD_HELP;
2622                 }
2623                 data.ioc_inllen1 = strlen(argv[1]) + 1;
2624                 data.ioc_inlbuf1 = argv[1];
2625                 if (argc == 4) {
2626                         data.ioc_inllen2 = strlen(argv[2]) + 1;
2627                         data.ioc_inlbuf2 = argv[2];
2628                         data.ioc_inllen3 = strlen(argv[3]) + 1;
2629                         data.ioc_inlbuf3 = argv[3];
2630                 } else {
2631                         data.ioc_inllen3 = strlen(argv[2]) + 1;
2632                         data.ioc_inlbuf3 = argv[2];
2633                 }
2634         } else {
2635                 if (llog_cancel_parse_optional(argc, argv, &data) != 0)
2636                         return CMD_HELP;
2637         }
2638
2639         memset(buf, 0, sizeof(rawbuf));
2640         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
2641         if (rc) {
2642                 fprintf(stderr, "error: %s: invalid ioctl\n",
2643                         jt_cmdname(argv[0]));
2644                 return rc;
2645         }
2646
2647         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_CANCEL, buf);
2648         if (rc == 0)
2649                 fprintf(stdout, "index %s was canceled.\n",
2650                         argc == 4 ? argv[3] : argv[2]);
2651         else
2652                 fprintf(stderr, "OBD_IOC_LLOG_CANCEL failed: %s\n",
2653                         strerror(errno));
2654
2655         return rc;
2656 }
2657
2658 int jt_llog_check(int argc, char **argv)
2659 {
2660         struct obd_ioctl_data data;
2661         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2662         int rc;
2663
2664         if (argc != 2 && argc != 4)
2665                 return CMD_HELP;
2666
2667         memset(&data, 0, sizeof(data));
2668         data.ioc_dev = cur_device;
2669         data.ioc_inllen1 = strlen(argv[1]) + 1;
2670         data.ioc_inlbuf1 = argv[1];
2671         if (argc == 4) {
2672                 data.ioc_inllen2 = strlen(argv[2]) + 1;
2673                 data.ioc_inlbuf2 = argv[2];
2674                 data.ioc_inllen3 = strlen(argv[3]) + 1;
2675                 data.ioc_inlbuf3 = argv[3];
2676         } else {
2677                 char from[2] = "1", to[3] = "-1";
2678                 data.ioc_inllen2 = strlen(from) + 1;
2679                 data.ioc_inlbuf2 = from;
2680                 data.ioc_inllen3 = strlen(to) + 1;
2681                 data.ioc_inlbuf3 = to;
2682         }
2683         data.ioc_inllen4 = sizeof(rawbuf) - cfs_size_round(sizeof(data)) -
2684                 cfs_size_round(data.ioc_inllen1) -
2685                 cfs_size_round(data.ioc_inllen2) -
2686                 cfs_size_round(data.ioc_inllen3);
2687         memset(buf, 0, sizeof(rawbuf));
2688         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
2689         if (rc) {
2690                 fprintf(stderr, "error: %s: invalid ioctl\n",
2691                         jt_cmdname(argv[0]));
2692                 return rc;
2693         }
2694
2695         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_CHECK, buf);
2696         if (rc == 0)
2697                 fprintf(stdout, "%s", ((struct obd_ioctl_data*)buf)->ioc_bulk);
2698         else
2699                 fprintf(stderr, "OBD_IOC_LLOG_CHECK failed: %s\n",
2700                         strerror(errno));
2701         return rc;
2702 }
2703
2704 int jt_llog_remove(int argc, char **argv)
2705 {
2706         struct obd_ioctl_data data;
2707         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2708         int rc;
2709
2710         if (argc != 3 && argc != 2)
2711                 return CMD_HELP;
2712
2713         memset(&data, 0, sizeof(data));
2714         data.ioc_dev = cur_device;
2715         data.ioc_inllen1 = strlen(argv[1]) + 1;
2716         data.ioc_inlbuf1 = argv[1];
2717         if (argc == 3){
2718                 data.ioc_inllen2 = strlen(argv[2]) + 1;
2719                 data.ioc_inlbuf2 = argv[2];
2720         }
2721         memset(buf, 0, sizeof(rawbuf));
2722         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
2723         if (rc) {
2724                 fprintf(stderr, "error: %s: invalid ioctl\n",
2725                         jt_cmdname(argv[0]));
2726                 return rc;
2727         }
2728
2729         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_REMOVE, buf);
2730         if (rc == 0) {
2731                 if (argc == 2)
2732                         fprintf(stdout, "log %s is removed.\n", argv[1]);
2733                 else
2734                         fprintf(stdout, "the log in catalog %s is removed. \n",
2735                                 argv[1]);
2736         } else
2737                 fprintf(stderr, "OBD_IOC_LLOG_REMOVE failed: %s\n",
2738                         strerror(errno));
2739
2740         return rc;
2741 }
2742
2743 /* attach a regular file to virtual block device.
2744  * return vaule:
2745  *  -1: fatal error
2746  *  1: error, it always means the command run failed
2747  *  0: success
2748  */
2749 static int jt_blockdev_run_process(const char *file, char *argv[])
2750 {
2751         pid_t pid;
2752         int rc;
2753
2754         pid = vfork();
2755         if (pid == 0) { /* child process */
2756                 /* don't print error messages */
2757                 close(1), close(2);
2758                 (void)execvp(file, argv);
2759                 exit(-1);
2760         } else if (pid > 0) {
2761                 int status;
2762
2763                 rc = waitpid(pid, &status, 0);
2764                 if (rc < 0 || !WIFEXITED(status))
2765                         return -1;
2766
2767                 return WEXITSTATUS(status);
2768         }
2769
2770         return -1;
2771 }
2772
2773 static int jt_blockdev_find_module(const char *module)
2774 {
2775         FILE *fp;
2776         int found = 0;
2777         char buf[1024];
2778         char *ptr;
2779
2780         fp = fopen("/proc/modules", "r");
2781         if (fp == NULL)
2782                 return -1;
2783
2784         while (fgets(buf, 1024, fp) != NULL) {
2785                 ptr = strchr(buf, ' ');
2786                 if (ptr != NULL)
2787                         *ptr = 0;
2788                 if (strcmp(module, buf) == 0) {
2789                         found = 1;
2790                         break;
2791                 }
2792         }
2793         fclose(fp);
2794
2795         return found;
2796 }
2797
2798 static int jt_blockdev_probe_module(const char *module)
2799 {
2800         char buf[1024];
2801         char *argv[10];
2802         int c, rc;
2803
2804         if (jt_blockdev_find_module(module) == 1)
2805                 return 0;
2806
2807         /* run modprobe first */
2808         c = 0;
2809         argv[c++] = "/sbin/modprobe";
2810         argv[c++] = "-q";
2811         argv[c++] = (char *)module;
2812         argv[c++] = NULL;
2813         rc = jt_blockdev_run_process("modprobe", argv);
2814         if (rc != 1)
2815                 return rc;
2816
2817         /* cannot find the module in default directory ... */
2818         sprintf(buf, "../llite/%s.ko", module);
2819         c = 0;
2820         argv[c++] = "/sbin/insmod";
2821         argv[c++] = buf;
2822         argv[c++] = NULL;
2823         rc = jt_blockdev_run_process("insmod", argv);
2824         return rc ? -1 : 0;
2825 }
2826
2827 int jt_blockdev_attach(int argc, char **argv)
2828 {
2829         int rc, fd;
2830         struct stat st;
2831         char *filename, *devname;
2832         unsigned long dev;
2833
2834         if (argc != 3)
2835                 return CMD_HELP;
2836
2837         if (jt_blockdev_probe_module("llite_lloop") < 0) {
2838                 fprintf(stderr, "error: cannot find module llite_lloop.(k)o\n");
2839                 return ENOENT;
2840         }
2841
2842         filename = argv[1];
2843         devname = argv[2];
2844
2845         fd = open(filename, O_RDWR);
2846         if (fd < 0) {
2847                 fprintf(stderr, "file %s can't be opened(%s)\n\n",
2848                         filename, strerror(errno));
2849                 return CMD_HELP;
2850         }
2851
2852         rc = ioctl(fd, LL_IOC_LLOOP_ATTACH, &dev);
2853         if (rc < 0) {
2854                 rc = errno;
2855                 fprintf(stderr, "attach error(%s)\n", strerror(rc));
2856                 goto out;
2857         }
2858
2859         rc = stat(devname, &st);
2860         if (rc == 0 && (!S_ISBLK(st.st_mode) || st.st_rdev != dev)) {
2861                 rc = EEXIST;
2862         } else if (rc < 0) {
2863                 if (errno == ENOENT &&
2864                     !mknod(devname, S_IFBLK|S_IRUSR|S_IWUSR, dev))
2865                         rc = 0;
2866                 else
2867                         rc = errno;
2868         }
2869
2870         if (rc) {
2871                 fprintf(stderr, "error: the file %s could be attached to block "
2872                                 "device %X but creating %s failed: %s\n"
2873                                 "now detaching the block device..",
2874                         filename, (int)dev, devname, strerror(rc));
2875
2876                 (void)ioctl(fd, LL_IOC_LLOOP_DETACH_BYDEV, dev);
2877                 fprintf(stderr, "%s\n", strerror(errno));
2878         }
2879 out:
2880         close(fd);
2881         return -rc;
2882 }
2883
2884 int jt_blockdev_detach(int argc, char **argv)
2885 {
2886         char *filename;
2887         int rc, fd;
2888
2889         if (argc != 2)
2890                 return CMD_HELP;
2891
2892         filename = argv[1];
2893         fd = open(filename, O_RDONLY);
2894         if (fd < 0) {
2895                 fprintf(stderr, "cannot open file %s error %s\n",
2896                         filename, strerror(errno));
2897                 return CMD_HELP;
2898         }
2899
2900         rc = ioctl(fd, LL_IOC_LLOOP_DETACH, 0);
2901         if (rc < 0) {
2902                 rc = errno;
2903                 fprintf(stderr, "detach error(%s)\n", strerror(rc));
2904         } else {
2905                 (void)unlink(filename);
2906         }
2907
2908         close(fd);
2909         return -rc;
2910 }
2911
2912 int jt_blockdev_info(int argc, char **argv)
2913 {
2914         char *filename;
2915         int rc, fd;
2916         struct lu_fid fid;
2917
2918         if (argc != 2)
2919                 return CMD_HELP;
2920
2921         filename = argv[1];
2922         fd = open(filename, O_RDONLY);
2923         if (fd < 0) {
2924                 fprintf(stderr, "cannot open file %s error: %s\n",
2925                         filename, strerror(errno));
2926                 return CMD_HELP;
2927         }
2928
2929         rc = ioctl(fd, LL_IOC_LLOOP_INFO, &fid);
2930         if (rc < 0) {
2931                 rc = errno;
2932                 fprintf(stderr, "error: %s\n", strerror(errno));
2933                 goto out;
2934         }
2935         fprintf(stdout, "lloop device info: ");
2936         if (fid_is_zero(&fid))
2937                 fprintf(stdout, "Not attached\n");
2938         else
2939                 fprintf(stdout, "attached to inode "DFID"\n", PFID(&fid));
2940 out:
2941         close(fd);
2942         return -rc;
2943 }
2944
2945 static void signal_server(int sig)
2946 {
2947         if (sig == SIGINT) {
2948                 do_disconnect("sigint", 1);
2949                 exit(1);
2950         } else
2951                 fprintf(stderr, "%s: got signal %d\n", jt_cmdname("sigint"), sig);
2952 }
2953
2954 int obd_initialize(int argc, char **argv)
2955 {
2956         if (shmem_setup() != 0)
2957                 return -1;
2958
2959         register_ioc_dev(OBD_DEV_ID, OBD_DEV_PATH,
2960                          OBD_DEV_MAJOR, OBD_DEV_MINOR);
2961
2962         return 0;
2963 }
2964
2965 void obd_finalize(int argc, char **argv)
2966 {
2967         struct sigaction sigact;
2968
2969         /* sigact initialization */
2970         sigact.sa_handler = signal_server;
2971         sigfillset(&sigact.sa_mask);
2972         sigact.sa_flags = SA_RESTART;
2973         /* coverity[uninit_use_in_call] */
2974         sigaction(SIGINT, &sigact, NULL);
2975
2976         shmem_cleanup();
2977         do_disconnect(argv[0], 1);
2978 }
2979
2980 static int check_pool_cmd(enum lcfg_command_type cmd,
2981                           char *fsname, char *poolname,
2982                           char *ostname)
2983 {
2984         int rc;
2985
2986         rc = llapi_search_ost(fsname, poolname, ostname);
2987         if (rc < 0 && (cmd != LCFG_POOL_NEW)) {
2988                 fprintf(stderr, "Pool %s.%s not found\n",
2989                         fsname, poolname);
2990                 return rc;
2991         }
2992
2993         switch (cmd) {
2994         case LCFG_POOL_NEW: {
2995                 LASSERT(ostname == NULL);
2996                 if (rc >= 0) {
2997                         fprintf(stderr, "Pool %s.%s already exists\n",
2998                                 fsname, poolname);
2999                         return -EEXIST;
3000                 }
3001                 return 0;
3002         }
3003         case LCFG_POOL_DEL: {
3004                 LASSERT(ostname == NULL);
3005                 if (rc == 1) {
3006                         fprintf(stderr, "Pool %s.%s not empty, "
3007                                 "please remove all members\n",
3008                                 fsname, poolname);
3009                         return -ENOTEMPTY;
3010                 }
3011                 return 0;
3012         }
3013         case LCFG_POOL_ADD: {
3014                 if (rc == 1) {
3015                         fprintf(stderr, "OST %s is already in pool %s.%s\n",
3016                                 ostname, fsname, poolname);
3017                         return -EEXIST;
3018                 }
3019                 rc = llapi_search_ost(fsname, NULL, ostname);
3020                 if (rc == 0) {
3021                         fprintf(stderr, "OST %s is not part of the '%s' fs.\n",
3022                                 ostname, fsname);
3023                         return -ENOENT;
3024                 }
3025                 return 0;
3026         }
3027         case LCFG_POOL_REM: {
3028                 if (rc == 0) {
3029                         fprintf(stderr, "OST %s not found in pool %s.%s\n",
3030                                 ostname, fsname, poolname);
3031                         return -ENOENT;
3032                 }
3033                 return 0;
3034         }
3035         default:
3036                 break;
3037         } /* switch */
3038         return -EINVAL;
3039 }
3040
3041 /* This check only verifies that the changes have been "pushed out" to
3042    the client successfully.  This involves waiting for a config update,
3043    and so may fail because of problems in that code or post-command
3044    network loss. So reporting a warning is appropriate, but not a failure.
3045 */
3046 static int check_pool_cmd_result(enum lcfg_command_type cmd,
3047                                  char *fsname, char *poolname,
3048                                  char *ostname)
3049 {
3050         int cpt = 10;
3051         int rc = 0;
3052
3053         switch (cmd) {
3054         case LCFG_POOL_NEW: {
3055                 do {
3056                         rc = llapi_search_ost(fsname, poolname, NULL);
3057                         if (rc == -ENODEV)
3058                                 return rc;
3059                         if (rc < 0)
3060                                 sleep(2);
3061                         cpt--;
3062                 } while ((rc < 0) && (cpt > 0));
3063                 if (rc >= 0) {
3064                         fprintf(stderr, "Pool %s.%s created\n",
3065                                 fsname, poolname);
3066                         return 0;
3067                 } else {
3068                         fprintf(stderr, "Warning, pool %s.%s not found\n",
3069                                 fsname, poolname);
3070                         return -ENOENT;
3071                 }
3072         }
3073         case LCFG_POOL_DEL: {
3074                 do {
3075                         rc = llapi_search_ost(fsname, poolname, NULL);
3076                         if (rc == -ENODEV)
3077                                 return rc;
3078                         if (rc >= 0)
3079                                 sleep(2);
3080                         cpt--;
3081                 } while ((rc >= 0) && (cpt > 0));
3082                 if (rc < 0) {
3083                         fprintf(stderr, "Pool %s.%s destroyed\n",
3084                                 fsname, poolname);
3085                         return 0;
3086                 } else {
3087                         fprintf(stderr, "Warning, pool %s.%s still found\n",
3088                                 fsname, poolname);
3089                         return -EEXIST;
3090                 }
3091         }
3092         case LCFG_POOL_ADD: {
3093                 do {
3094                         rc = llapi_search_ost(fsname, poolname, ostname);
3095                         if (rc == -ENODEV)
3096                                 return rc;
3097                         if (rc != 1)
3098                                 sleep(2);
3099                         cpt--;
3100                 } while ((rc != 1) && (cpt > 0));
3101                 if (rc == 1) {
3102                         fprintf(stderr, "OST %s added to pool %s.%s\n",
3103                                 ostname, fsname, poolname);
3104                         return 0;
3105                 } else {
3106                         fprintf(stderr, "Warning, OST %s not found in pool %s.%s\n",
3107                                 ostname, fsname, poolname);
3108                         return -ENOENT;
3109                 }
3110         }
3111         case LCFG_POOL_REM: {
3112                 do {
3113                         rc = llapi_search_ost(fsname, poolname, ostname);
3114                         if (rc == -ENODEV)
3115                                 return rc;
3116                         if (rc == 1)
3117                                 sleep(2);
3118                         cpt--;
3119                 } while ((rc == 1) && (cpt > 0));
3120                 if (rc != 1) {
3121                         fprintf(stderr, "OST %s removed from pool %s.%s\n",
3122                                 ostname, fsname, poolname);
3123                         return 0;
3124                 } else {
3125                         fprintf(stderr, "Warning, OST %s still found in pool %s.%s\n",
3126                                 ostname, fsname, poolname);
3127                         return -EEXIST;
3128                 }
3129         }
3130         default:
3131                 break;
3132         }
3133         return -EINVAL;
3134 }
3135
3136 static int check_and_complete_ostname(char *fsname, char *ostname)
3137 {
3138         char *ptr;
3139         char real_ostname[MAX_OBD_NAME + 1];
3140         char i;
3141
3142         /* if OST name does not start with fsname, we add it */
3143         /* if not check if the fsname is the right one */
3144         ptr = strchr(ostname, '-');
3145         if (ptr == NULL) {
3146                 sprintf(real_ostname, "%s-%s", fsname, ostname);
3147         } else if (strncmp(ostname, fsname, strlen(fsname)) != 0) {
3148                 fprintf(stderr, "%s does not start with fsname %s\n",
3149                         ostname, fsname);
3150                 return -EINVAL;
3151         } else {
3152                 if (strlen(ostname) > sizeof(real_ostname)-1)
3153                         return -E2BIG;
3154                 strncpy(real_ostname, ostname, sizeof(real_ostname));
3155         }
3156         /* real_ostname is fsname-????? */
3157         ptr = real_ostname + strlen(fsname) + 1;
3158         if (strncmp(ptr, "OST", 3) != 0) {
3159                 fprintf(stderr, "%s does not start by %s-OST nor OST\n",
3160                         ostname, fsname);
3161                 return -EINVAL;
3162         }
3163         /* real_ostname is fsname-OST????? */
3164         ptr += 3;
3165         for (i = 0; i < 4; i++) {
3166                 if (!isxdigit(*ptr)) {
3167                         fprintf(stderr,
3168                                 "ost's index in %s is not an hexa number\n",
3169                                 ostname);
3170                         return -EINVAL;
3171                 }
3172                 ptr++;
3173         }
3174         /* real_ostname is fsname-OSTXXXX????? */
3175         /* if OST name does not end with _UUID, we add it */
3176         if (*ptr == '\0') {
3177                 strcat(real_ostname, "_UUID");
3178         } else if (strcmp(ptr, "_UUID") != 0) {
3179                 fprintf(stderr,
3180                         "ostname %s does not end with _UUID\n", ostname);
3181                 return -EINVAL;
3182         }
3183         /* real_ostname is fsname-OSTXXXX_UUID */
3184         strcpy(ostname, real_ostname);
3185         return 0;
3186 }
3187
3188 /* returns 0 or -errno */
3189 static int pool_cmd(enum lcfg_command_type cmd,
3190                     char *cmdname, char *fullpoolname,
3191                     char *fsname, char *poolname, char *ostname)
3192 {
3193         int rc = 0;
3194         struct obd_ioctl_data data;
3195         struct lustre_cfg_bufs bufs;
3196         struct lustre_cfg *lcfg;
3197         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
3198
3199         rc = check_pool_cmd(cmd, fsname, poolname, ostname);
3200         if (rc == -ENODEV)
3201                 fprintf(stderr, "Can't verify pool command since there "
3202                         "is no local MDT or client, proceeding anyhow...\n");
3203         else if (rc)
3204                 return rc;
3205
3206         lustre_cfg_bufs_reset(&bufs, NULL);
3207         lustre_cfg_bufs_set_string(&bufs, 0, cmdname);
3208         lustre_cfg_bufs_set_string(&bufs, 1, fullpoolname);
3209         if (ostname != NULL)
3210                 lustre_cfg_bufs_set_string(&bufs, 2, ostname);
3211
3212         lcfg = lustre_cfg_new(cmd, &bufs);
3213         if (IS_ERR(lcfg)) {
3214                 rc = PTR_ERR(lcfg);
3215                 return rc;
3216         }
3217
3218         memset(&data, 0, sizeof(data));
3219         rc = data.ioc_dev = get_mgs_device();
3220         if (rc < 0)
3221                 goto out;
3222
3223         data.ioc_type = LUSTRE_CFG_TYPE;
3224         data.ioc_plen1 = lustre_cfg_len(lcfg->lcfg_bufcount,
3225                                         lcfg->lcfg_buflens);
3226         data.ioc_pbuf1 = (void *)lcfg;
3227
3228         memset(buf, 0, sizeof(rawbuf));
3229         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
3230         if (rc) {
3231                 fprintf(stderr, "error: %s: invalid ioctl\n",
3232                         jt_cmdname(cmdname));
3233                 return rc;
3234         }
3235         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_POOL, buf);
3236 out:
3237         if (rc)
3238                 rc = -errno;
3239         lustre_cfg_free(lcfg);
3240         return rc;
3241 }
3242
3243 /**
3244  * Format and send the ioctl to the MGS.
3245  *
3246  * \param       cmd             IOCTL to send
3247  * \param       ret_data        void pointer to return anything from
3248  *                              ioctl
3249  * \param       num_args        number of arguments to pack into the
3250  *                              ioctl buffer
3251  * \param       argv[]          variable number of string arguments
3252  *
3253  * \retval                      0 on success
3254  */
3255 static int nodemap_cmd(enum lcfg_command_type cmd, void *ret_data,
3256                        unsigned int ret_size, ...)
3257 {
3258         va_list                 ap;
3259         char                    *arg;
3260         int                     i = 0;
3261         struct lustre_cfg_bufs  bufs;
3262         struct obd_ioctl_data   data;
3263         struct lustre_cfg       *lcfg;
3264         char                    rawbuf[MAX_IOC_BUFLEN];
3265         char                    *buf = rawbuf;
3266         int                     rc = 0;
3267
3268         lustre_cfg_bufs_reset(&bufs, NULL);
3269
3270         va_start(ap, ret_size);
3271         arg = va_arg(ap, char *);
3272         while (arg != NULL) {
3273                 lustre_cfg_bufs_set_string(&bufs, i, arg);
3274                 i++;
3275                 arg = va_arg(ap, char *);
3276         }
3277         va_end(ap);
3278
3279         lcfg = lustre_cfg_new(cmd, &bufs);
3280
3281         if (IS_ERR(lcfg)) {
3282                 rc = PTR_ERR(lcfg);
3283                 return rc;
3284         }
3285
3286         memset(&data, 0, sizeof(data));
3287         rc = data.ioc_dev = get_mgs_device();
3288         if (rc < 0)
3289                 goto out;
3290
3291         data.ioc_type = LUSTRE_CFG_TYPE;
3292         data.ioc_plen1 = lustre_cfg_len(lcfg->lcfg_bufcount,
3293                          lcfg->lcfg_buflens);
3294         data.ioc_pbuf1 = (void *)lcfg;
3295
3296         memset(buf, 0, sizeof(rawbuf));
3297         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
3298         if (rc != 0) {
3299                 fprintf(stderr, "error: invalid ioctl: %08x errno: %d with "
3300                                "rc=%d\n", cmd, errno, rc);
3301                 goto out;
3302         }
3303
3304         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_NODEMAP, buf);
3305         if (rc != 0) {
3306                 fprintf(stderr, "error: invalid ioctl: %08x errno: %d with "
3307                                "rc=%d\n", cmd, errno, rc);
3308                 goto out;
3309         }
3310
3311         if (ret_data != NULL) {
3312                 rc = obd_ioctl_unpack(&data, buf, sizeof(rawbuf));
3313                 if (rc != 0)
3314                         goto out;
3315
3316                 memcpy(ret_data, data.ioc_pbuf1, data.ioc_plen1);
3317                 if (ret_data == NULL || sizeof(ret_data) != ret_size)
3318                         rc = -errno;
3319         }
3320 out:
3321         lustre_cfg_free(lcfg);
3322
3323         return rc;
3324 }
3325
3326 /**
3327  * activate nodemap functions
3328  *
3329  * \param       argc            number of args
3330  * \param       argv[]          variable string arguments
3331  *
3332  * argv[0]                      1 for activate or 0 for deactivate
3333  *
3334  * \retval                      0 on success
3335  */
3336 int jt_nodemap_activate(int argc, char **argv)
3337 {
3338         int rc;
3339
3340         rc = nodemap_cmd(LCFG_NODEMAP_ACTIVATE, NULL, 0, argv[0], argv[1],
3341                          NULL);
3342
3343         if (rc != 0) {
3344                 errno = -rc;
3345                 perror(argv[0]);
3346         }
3347
3348         return rc;
3349 }
3350
3351 /**
3352  * add a nodemap
3353  *
3354  * \param       argc            number of args
3355  * \param       argv[]          variable string arguments
3356  *
3357  * argv[0]                      nodemap name
3358  *
3359  * \retval                      0 on success
3360  */
3361 int jt_nodemap_add(int argc, char **argv)
3362 {
3363         int rc;
3364
3365         rc = llapi_nodemap_exists(argv[1]);
3366         if (rc == 0) {
3367                 fprintf(stderr, "error: %s existing nodemap name\n", argv[1]);
3368                 return 1;
3369         }
3370
3371         rc = nodemap_cmd(LCFG_NODEMAP_ADD, NULL, 0, argv[0], argv[1], NULL);
3372
3373         if (rc != 0) {
3374                 errno = -rc;
3375                 perror(argv[0]);
3376         }
3377
3378         return rc;
3379 }
3380
3381 /**
3382  * delete a nodemap
3383  *
3384  * \param       argc            number of args
3385  * \param       argv[]          variable string arguments
3386  *
3387  * argv[0]                      nodemap name
3388  *
3389  * \retval                      0 on success
3390  */
3391 int jt_nodemap_del(int argc, char **argv)
3392 {
3393         int rc;
3394
3395         rc = llapi_nodemap_exists(argv[1]);
3396         if (rc != 0) {
3397                 fprintf(stderr, "error: %s not existing nodemap name\n",
3398                         argv[1]);
3399                 return rc;
3400         }
3401         rc = nodemap_cmd(LCFG_NODEMAP_DEL, NULL, 0, argv[0], argv[1], NULL);
3402
3403         if (rc != 0) {
3404                 errno = -rc;
3405                 perror(argv[0]);
3406         }
3407
3408         return rc;
3409 }
3410
3411 /**
3412  * test a nid for nodemap membership
3413  *
3414  * \param       argc            number of args
3415  * \param       argv[]          variable string arguments
3416  *
3417  * argv[0]                      properly formatted nid
3418  *
3419  * \retval                      0 on success
3420  */
3421 int jt_nodemap_test_nid(int argc, char **argv)
3422 {
3423
3424         char    rawbuf[MAX_IOC_BUFLEN];
3425         int     rc;
3426
3427         rc = nodemap_cmd(LCFG_NODEMAP_TEST_NID, &rawbuf, sizeof(rawbuf),
3428                          argv[0], argv[1], NULL);
3429         if (rc == 0)
3430                 printf("%s\n", (char *)rawbuf);
3431
3432         return rc;
3433 }
3434
3435 /**
3436  * test a nodemap id pair for mapping
3437  *
3438  * \param       argc            number of args
3439  * \param       argv[[]         variable string arguments
3440  *
3441  * \retval                      0 on success
3442  *
3443  * The argv array should contain the nodemap name, the id
3444  * to checking the mapping on, and the id type (UID or GID)
3445  *
3446  */
3447 int jt_nodemap_test_id(int argc, char **argv)
3448 {
3449         char    rawbuf[MAX_IOC_BUFLEN];
3450         char    *nidstr = NULL;
3451         char    *idstr = NULL;
3452         char    *typestr = NULL;
3453         int     rc = 0;
3454         int     c;
3455
3456         static struct option long_options[] = {
3457                 {
3458                         .name           = "nid",
3459                         .has_arg        = required_argument,
3460                         .flag           = 0,
3461                         .val            = 'n',
3462                 },
3463                 {
3464                         .name           = "idtype",
3465                         .has_arg        = required_argument,
3466                         .flag           = 0,
3467                         .val            = 't',
3468                 },
3469                 {
3470                         .name           = "id",
3471                         .has_arg        = required_argument,
3472                         .flag           = 0,
3473                         .val            = 'i',
3474                 },
3475                 {
3476                         NULL
3477                 }
3478         };
3479
3480         while ((c = getopt_long(argc, argv, "n:t:i:",
3481                                 long_options, NULL)) != -1) {
3482                 switch (c) {
3483                 case 'n':
3484                         nidstr = optarg;
3485                         break;
3486                 case 't':
3487                         typestr = optarg;
3488                         break;
3489                 case 'i':
3490                         idstr = optarg;
3491                         break;
3492                 }
3493         }
3494
3495         if (nidstr == NULL || typestr == NULL || idstr == NULL) {
3496                 fprintf(stderr, "usage: nodemap_test_id --nid <nid> "
3497                                 "--idtype [uid|gid] --id <id>\n");
3498                 return -1;
3499         }
3500
3501         rc = nodemap_cmd(LCFG_NODEMAP_TEST_ID, &rawbuf, sizeof(rawbuf),
3502                          argv[0], nidstr, typestr, idstr);
3503         if (rc == 0)
3504                 printf("%s\n", (char *)rawbuf);
3505
3506         return rc;
3507 }
3508
3509 /**
3510  * add an nid range to a nodemap
3511  *
3512  * \param       argc            number of args
3513  * \param       argv[]          variable string arguments
3514  *
3515  * --name                       nodemap name
3516  * --range                      properly formatted nid range
3517  *
3518  * \retval                      0 on success
3519  */
3520 int jt_nodemap_add_range(int argc, char **argv)
3521 {
3522         char                    *nodemap_name = NULL;
3523         char                    *nodemap_range = NULL;
3524         struct list_head        nidlist;
3525         char                    min_nid[LNET_NIDSTR_SIZE + 1];
3526         char                    max_nid[LNET_NIDSTR_SIZE + 1];
3527         char                    nid_range[2 * LNET_NIDSTR_SIZE + 2];
3528         int                     rc = 0;
3529         int                     c;
3530
3531         static struct option long_options[] = {
3532                 {
3533                         .name           = "name",
3534                         .has_arg        = required_argument,
3535                         .flag           = 0,
3536                         .val            = 'n',
3537                 },
3538                 {
3539                         .name           = "range",
3540                         .has_arg        = required_argument,
3541                         .flag           = 0,
3542                         .val            = 'r',
3543                 },
3544                 {
3545                         NULL
3546                 }
3547         };
3548
3549         INIT_LIST_HEAD(&nidlist);
3550
3551         while ((c = getopt_long(argc, argv, "n:r:",
3552                                 long_options, NULL)) != -1) {
3553                 switch (c) {
3554                 case 'n':
3555                         nodemap_name = optarg;
3556                         break;
3557                 case 'r':
3558                         nodemap_range = optarg;
3559                         break;
3560                 }
3561         }
3562
3563         if (nodemap_name == NULL || nodemap_range == NULL) {
3564                 fprintf(stderr, "usage: nodemap_add_range --name <name> "
3565                                 "--range <range>\n");
3566                 return -1;
3567         }
3568
3569         if (cfs_parse_nidlist(nodemap_range, strlen(nodemap_range),
3570                               &nidlist) <= 0) {
3571                 fprintf(stderr, "error: %s: can't parse nid range: %s\n",
3572                         jt_cmdname(argv[0]), nodemap_range);
3573                 return -1;
3574         }
3575
3576         if (!cfs_nidrange_is_contiguous(&nidlist)) {
3577                 fprintf(stderr, "error: %s: nodemap ranges must be "
3578                         "contiguous\n", jt_cmdname(argv[0]));
3579                 return -1;
3580         }
3581
3582         cfs_nidrange_find_min_max(&nidlist, &min_nid[0], &max_nid[0],
3583                                   LNET_NIDSTR_SIZE);
3584         snprintf(nid_range, sizeof(nid_range), "%s:%s", min_nid, max_nid);
3585
3586         rc = nodemap_cmd(LCFG_NODEMAP_ADD_RANGE, NULL, 0, argv[0],
3587                          nodemap_name, nid_range, NULL);
3588         if (rc != 0) {
3589                 errno = -rc;
3590                 fprintf(stderr, "error: %s: cannot add range '%s' to nodemap "
3591                                 "'%s': rc = %d\n",
3592                         jt_cmdname(argv[0]), nodemap_range, nodemap_name, rc);
3593         }
3594
3595         return rc;
3596 }
3597
3598 /**
3599  * delete an nid range to a nodemap
3600  *
3601  * \param       argc            number of args
3602  * \param       argv[]          variable string arguments
3603  *
3604  * --name                       nodemap name
3605  * --range                      properly formatted nid range
3606  *
3607  * \retval                      0 on success
3608  */
3609 int jt_nodemap_del_range(int argc, char **argv)
3610 {
3611         char                    *nodemap_name = NULL;
3612         char                    *nodemap_range = NULL;
3613         struct list_head        nidlist;
3614         char                    min_nid[LNET_NIDSTR_SIZE + 1];
3615         char                    max_nid[LNET_NIDSTR_SIZE + 1];
3616         char                    nid_range[2 * LNET_NIDSTR_SIZE + 2];
3617         int                     rc = 0;
3618         int                     c;
3619
3620         static struct option long_options[] = {
3621                 {
3622                         .name           = "name",
3623                         .has_arg        = required_argument,
3624                         .flag           = 0,
3625                         .val            = 'n',
3626                 },
3627                 {
3628                         .name           = "range",
3629                         .has_arg        = required_argument,
3630                         .flag           = 0,
3631                         .val            = 'r',
3632                 },
3633                 {
3634                         NULL
3635                 }
3636         };
3637
3638         INIT_LIST_HEAD(&nidlist);
3639
3640         while ((c = getopt_long(argc, argv, "n:r:",
3641                                 long_options, NULL)) != -1) {
3642                 switch (c) {
3643                 case 'n':
3644                         nodemap_name = optarg;
3645                         break;
3646                 case 'r':
3647                         nodemap_range = optarg;
3648                         break;
3649                 }
3650         }
3651
3652         if (nodemap_name == NULL || nodemap_range == NULL) {
3653                 fprintf(stderr, "usage: nodemap_del_range --name <name> "
3654                                 "--range <range>\n");
3655                 return -1;
3656         }
3657
3658         if (cfs_parse_nidlist(nodemap_range, strlen(nodemap_range),
3659                               &nidlist) <= 0) {
3660                 fprintf(stderr, "error: %s: can't parse nid range: %s\n",
3661                         jt_cmdname(argv[0]), nodemap_range);
3662                 return -1;
3663         }
3664
3665         if (!cfs_nidrange_is_contiguous(&nidlist)) {
3666                 fprintf(stderr, "error: %s: nodemap ranges must be "
3667                         "contiguous\n", jt_cmdname(argv[0]));
3668                 return -1;
3669         }
3670
3671         cfs_nidrange_find_min_max(&nidlist, &min_nid[0], &max_nid[0],
3672                                   LNET_NIDSTR_SIZE);
3673         snprintf(nid_range, sizeof(nid_range), "%s:%s", min_nid, max_nid);
3674
3675         rc = nodemap_cmd(LCFG_NODEMAP_DEL_RANGE, NULL, 0, argv[0],
3676                          nodemap_name, nid_range, NULL);
3677         if (rc != 0) {
3678                 errno = -rc;
3679                 fprintf(stderr, "error: %s: cannot delete range '%s' to "
3680                                "nodemap '%s': rc = %d\n",
3681                         jt_cmdname(argv[0]), nodemap_range, nodemap_name, rc);
3682         }
3683
3684         return rc;
3685 }
3686
3687 /**
3688  * modify a nodemap's behavior
3689  *
3690  * \param       argc            number of args
3691  * \param       argv[]          variable string arguments
3692  *
3693  * --name                       nodemap name
3694  * --property                   nodemap property to change
3695  *                              admin, trusted, squash_uid, squash_gid)
3696  * --value                      value to set property
3697  *
3698  * \retval                      0 on success
3699  */
3700 int jt_nodemap_modify(int argc, char **argv)
3701 {
3702         int                     c;
3703         int                     rc = 0;
3704         enum lcfg_command_type  cmd = 0;
3705         char                    *nodemap_name = NULL;
3706         char                    *param = NULL;
3707         char                    *value = NULL;
3708
3709         static struct option long_options[] = {
3710                 {
3711                         .name           = "name",
3712                         .has_arg        = required_argument,
3713                         .flag           = 0,
3714                         .val            = 'n',
3715                 },
3716                 {
3717                         .name           = "property",
3718                         .has_arg        = required_argument,
3719                         .flag           = 0,
3720                         .val            = 'p',
3721                 },
3722                 {
3723                         .name           = "value",
3724                         .has_arg        = required_argument,
3725                         .flag           = 0,
3726                         .val            = 'v',
3727                 },
3728                 {
3729                         NULL
3730                 }
3731         };
3732
3733         while ((c = getopt_long(argc, argv, "n:p:v:",
3734                                 long_options, NULL)) != -1) {
3735                 switch (c) {
3736                 case 'n':
3737                         nodemap_name = optarg;
3738                         break;
3739                 case 'p':
3740                         param = optarg;
3741                         break;
3742                 case 'v':
3743                         value = optarg;
3744                         break;
3745                 }
3746         }
3747
3748         if (nodemap_name == NULL || param == NULL || value == NULL) {
3749                 fprintf(stderr, "usage: nodemap_modify --name <name> "
3750                                 "--property <range> --value <value>\n");
3751                 return -1;
3752         }
3753
3754         if (strcmp("admin", param) == 0) {
3755                 cmd = LCFG_NODEMAP_ADMIN;
3756         } else if (strcmp("trusted", param) == 0) {
3757                 cmd = LCFG_NODEMAP_TRUSTED;
3758         } else if (strcmp("squash_uid", param) == 0) {
3759                 cmd = LCFG_NODEMAP_SQUASH_UID;
3760         } else if (strcmp("squash_gid", param) == 0) {
3761                 cmd = LCFG_NODEMAP_SQUASH_GID;
3762         } else {
3763                 fprintf(stderr, "error: %s: nodemap_modify invalid "
3764                                 "subcommand: %s\n",
3765                         jt_cmdname(argv[0]), param);
3766                 return -1;
3767         }
3768
3769         rc = nodemap_cmd(cmd, NULL, 0, argv[0], nodemap_name, param,
3770                          value, NULL);
3771         if (rc != 0) {
3772                 errno = -rc;
3773                 fprintf(stderr, "error: %s: cannot modify nodemap '%s' "
3774                                "to param '%s': value '%s': rc = %d\n",
3775                         jt_cmdname(argv[0]), nodemap_name, param, value, rc);
3776         }
3777
3778         return rc;
3779 }
3780
3781 int jt_nodemap_add_idmap(int argc, char **argv)
3782 {
3783         int                     c;
3784         enum                    lcfg_command_type cmd = 0;
3785         char                    *nodemap_name = NULL;
3786         char                    *idmap = NULL;
3787         char                    *idtype = NULL;
3788         int                     rc = 0;
3789
3790         static struct option long_options[] = {
3791                 {
3792                         .name           = "name",
3793                         .has_arg        = required_argument,
3794                         .flag           = 0,
3795                         .val            = 'n',
3796                 },
3797                 {
3798                         .name           = "idmap",
3799                         .has_arg        = required_argument,
3800                         .flag           = 0,
3801                         .val            = 'm',
3802                 },
3803                 {
3804                         .name           = "idtype",
3805                         .has_arg        = required_argument,
3806                         .flag           = 0,
3807                         .val            = 'i',
3808                 },
3809                 {
3810                         NULL
3811                 }
3812         };
3813
3814         while ((c = getopt_long(argc, argv, "n:m:i:",
3815                                 long_options, NULL)) != -1) {
3816                 switch (c) {
3817                 case 'n':
3818                         nodemap_name = optarg;
3819                         break;
3820                 case 'm':
3821                         idmap = optarg;
3822                         break;
3823                 case 'i':
3824                         idtype = optarg;
3825                         break;
3826                 }
3827         }
3828
3829         if (nodemap_name == NULL || idmap == NULL || idtype == NULL) {
3830                 fprintf(stderr, "usage: %s --name <name> --idtype [uid | gid]"
3831                         " --idmap <client id>:<filesystem id>\n", argv[0]);
3832                 return -1;
3833         }
3834
3835         if (strcmp("uid", idtype) == 0) {
3836                 cmd = LCFG_NODEMAP_ADD_UIDMAP;
3837         } else if (strcmp("gid", idtype) == 0) {
3838                 cmd = LCFG_NODEMAP_ADD_GIDMAP;
3839         } else {
3840                 fprintf(stderr, "usage: %s --name <name> --idtype [uid | gid]"
3841                         " --idmap <client id>:<filesystem id>\n", argv[0]);
3842                 return -1;
3843         }
3844
3845         rc = nodemap_cmd(cmd, NULL, 0, argv[0], nodemap_name, idmap, NULL);
3846         if (rc != 0) {
3847                 errno = -rc;
3848                 fprintf(stderr, "cannot add %smap '%s' to nodemap '%s'"
3849                         ": rc = %d\n", idtype, idmap, nodemap_name, rc);
3850         }
3851
3852         return rc;
3853 }
3854
3855 int jt_nodemap_del_idmap(int argc, char **argv)
3856 {
3857         int                     c;
3858         enum                    lcfg_command_type cmd = 0;
3859         char                    *nodemap_name = NULL;
3860         char                    *idmap = NULL;
3861         char                    *idtype = NULL;
3862         int                     rc = 0;
3863
3864         static struct option long_options[] = {
3865                 {
3866                         .name           = "name",
3867                         .has_arg        = required_argument,
3868                         .flag           = 0,
3869                         .val            = 'n',
3870                 },
3871                 {
3872                         .name           = "idmap",
3873                         .has_arg        = required_argument,
3874                         .flag           = 0,
3875                         .val            = 'm',
3876                 },
3877                 {
3878                         .name           = "idtype",
3879                         .has_arg        = required_argument,
3880                         .flag           = 0,
3881                         .val            = 'i',
3882                 },
3883                 {
3884                         NULL
3885                 }
3886         };
3887
3888         while ((c = getopt_long(argc, argv, "n:m:i:",
3889                                 long_options, NULL)) != -1) {
3890                 switch (c) {
3891                 case 'n':
3892                         nodemap_name = optarg;
3893                         break;
3894                 case 'm':
3895                         idmap = optarg;
3896                         break;
3897                 case 'i':
3898                         idtype = optarg;
3899                         break;
3900                 }
3901         }
3902
3903         if (nodemap_name == NULL || idmap == NULL || idtype == NULL) {
3904                 fprintf(stderr, "usage: %s --name <name> --idtype [uid | gid]"
3905                         " --idmap <client id>:<filesystem id>\n", argv[0]);
3906                 return -1;
3907         }
3908
3909         if (strcmp("uid", idtype) == 0)
3910                 cmd = LCFG_NODEMAP_DEL_UIDMAP;
3911         else
3912                 cmd = LCFG_NODEMAP_DEL_GIDMAP;
3913
3914         rc = nodemap_cmd(cmd, NULL, 0, argv[0], nodemap_name, idmap, NULL);
3915         if (rc != 0) {
3916                 errno = -rc;
3917                 fprintf(stderr, "cannot add %smap '%s' to nodemap '%s'"
3918                         ": rc = %d\n", idtype, idmap, nodemap_name, rc);
3919         }
3920
3921         return rc;
3922 }
3923
3924 /*
3925  * this function tranforms a rule [start-end/step] into an array
3926  * of matching numbers
3927  * supported forms are:
3928  * [start]                : just this number
3929  * [start-end]            : all numbers from start to end
3930  * [start-end/step]       : numbers from start to end with increment of step
3931  * on return, format contains a printf format string which can be used
3932  * to generate all the strings
3933  */
3934 static int get_array_idx(char *rule, char *format, int **array)
3935 {
3936         char *start, *end, *ptr;
3937         unsigned int lo, hi, step;
3938         int array_sz = 0;
3939         int i, array_idx;
3940         int rc;
3941
3942         start = strchr(rule, '[');
3943         end = strchr(rule, ']');
3944         if ((start == NULL) || (end == NULL)) {
3945                 *array = malloc(sizeof(int));
3946                 if (*array == NULL)
3947                         return 0;
3948                 strcpy(format, rule);
3949                 array_sz = 1;
3950                 return array_sz;
3951         }
3952         *start = '\0';
3953         *end = '\0';
3954         end++;
3955         start++;
3956         /* put in format the printf format (the rule without the range) */
3957         sprintf(format, "%s%%.4x%s", rule, end);
3958
3959         array_idx = 0;
3960         array_sz = 0;
3961         *array = NULL;
3962         /* loop on , separator */
3963         do {
3964                 /* extract the 3 fields */
3965                 rc = sscanf(start, "%x-%x/%u", &lo, &hi, &step);
3966                 switch (rc) {
3967                 case 0: {
3968                         return 0;
3969                 }
3970                 case 1: {
3971                         array_sz++;
3972                         *array = realloc(*array, array_sz * sizeof(int));
3973                         if (*array == NULL)
3974                                 return 0;
3975                         (*array)[array_idx] = lo;
3976                         array_idx++;
3977                         break;
3978                 }
3979                 case 2: {
3980                         step = 1;
3981                         /* do not break to share code with case 3: */
3982                 }
3983                 case 3: {
3984                         if ((hi < lo) || (step == 0))
3985                                 return 0;
3986                         array_sz += (hi - lo) / step + 1;
3987                         *array = realloc(*array, sizeof(int) * array_sz);
3988                         if (*array == NULL)
3989                                 return 0;
3990                         for (i = lo; i <= hi; i+=step, array_idx++)
3991                                 (*array)[array_idx] = i;
3992                         break;
3993                 }
3994                 }
3995                 ptr = strchr(start, ',');
3996                 if (ptr != NULL)
3997                         start = ptr + 1;
3998
3999         } while (ptr != NULL);
4000         return array_sz;
4001 }
4002
4003 static int extract_fsname_poolname(char *arg, char *fsname, char *poolname)
4004 {
4005         char *ptr;
4006         int len;
4007         int rc;
4008
4009         strcpy(fsname, arg);
4010         ptr = strchr(fsname, '.');
4011         if (ptr == NULL) {
4012                 fprintf(stderr, ". is missing in %s\n", fsname);
4013                 rc = -EINVAL;
4014                 goto err;
4015         }
4016
4017         len = ptr - fsname;
4018         if (len == 0) {
4019                 fprintf(stderr, "fsname is empty\n");
4020                 rc = -EINVAL;
4021                 goto err;
4022         }
4023
4024         len = strlen(ptr + 1);
4025         if (len == 0) {
4026                 fprintf(stderr, "poolname is empty\n");
4027                 rc = -EINVAL;
4028                 goto err;
4029         }
4030         if (len > LOV_MAXPOOLNAME) {
4031                 fprintf(stderr,
4032                         "poolname %s is too long (length is %d max is %d)\n",
4033                         ptr + 1, len, LOV_MAXPOOLNAME);
4034                 rc = -ENAMETOOLONG;
4035                 goto err;
4036         }
4037         strncpy(poolname, ptr + 1, LOV_MAXPOOLNAME);
4038         poolname[LOV_MAXPOOLNAME] = '\0';
4039         *ptr = '\0';
4040         return 0;
4041
4042 err:
4043         fprintf(stderr, "argument %s must be <fsname>.<poolname>\n", arg);
4044         return rc;
4045 }
4046
4047 int jt_pool_cmd(int argc, char **argv)
4048 {
4049         enum lcfg_command_type cmd;
4050         char fsname[PATH_MAX + 1];
4051         char poolname[LOV_MAXPOOLNAME + 1];
4052         char *ostnames_buf = NULL;
4053         int i, rc;
4054         int *array = NULL, array_sz;
4055         struct {
4056                 int     rc;
4057                 char   *ostname;
4058         } *cmds = NULL;
4059
4060         switch (argc) {
4061         case 0:
4062         case 1: return CMD_HELP;
4063         case 2: {
4064                 if (strcmp("pool_new", argv[0]) == 0)
4065                         cmd = LCFG_POOL_NEW;
4066                 else if (strcmp("pool_destroy", argv[0]) == 0)
4067                         cmd = LCFG_POOL_DEL;
4068                 else if (strcmp("pool_list", argv[0]) == 0)
4069                          return llapi_poollist(argv[1]);
4070                 else return CMD_HELP;
4071
4072                 rc = extract_fsname_poolname(argv[1], fsname, poolname);
4073                 if (rc)
4074                         break;
4075
4076                 rc = pool_cmd(cmd, argv[0], argv[1], fsname, poolname, NULL);
4077                 if (rc)
4078                         break;
4079
4080                 check_pool_cmd_result(cmd, fsname, poolname, NULL);
4081                 break;
4082         }
4083         default: {
4084                 char format[2*MAX_OBD_NAME];
4085
4086                 if (strcmp("pool_remove", argv[0]) == 0) {
4087                         cmd = LCFG_POOL_REM;
4088                 } else if (strcmp("pool_add", argv[0]) == 0) {
4089                         cmd = LCFG_POOL_ADD;
4090                 } else {
4091                         return CMD_HELP;
4092                 }
4093
4094                 rc = extract_fsname_poolname(argv[1], fsname, poolname);
4095                 if (rc)
4096                         break;
4097
4098                 for (i = 2; i < argc; i++) {
4099                         int j;
4100
4101                         array_sz = get_array_idx(argv[i], format, &array);
4102                         if (array_sz == 0)
4103                                 return CMD_HELP;
4104
4105                         cmds = malloc(array_sz * sizeof(cmds[0]));
4106                         if (cmds != NULL) {
4107                                 ostnames_buf = malloc(array_sz *
4108                                                       (MAX_OBD_NAME + 1));
4109                         } else {
4110                                 free(array);
4111                                 rc = -ENOMEM;
4112                                 goto out;
4113                         }
4114
4115                         for (j = 0; j < array_sz; j++) {
4116                                 char ostname[MAX_OBD_NAME + 1];
4117
4118                                 snprintf(ostname, MAX_OBD_NAME, format,
4119                                          array[j]);
4120                                 ostname[MAX_OBD_NAME] = '\0';
4121
4122                                 rc = check_and_complete_ostname(fsname,ostname);
4123                                 if (rc) {
4124                                         free(array);
4125                                         free(cmds);
4126                                         if (ostnames_buf)
4127                                                 free(ostnames_buf);
4128                                         goto out;
4129                                 }
4130                                 if (ostnames_buf != NULL) {
4131                                         cmds[j].ostname =
4132                                           &ostnames_buf[(MAX_OBD_NAME + 1) * j];
4133                                         strcpy(cmds[j].ostname, ostname);
4134                                 } else {
4135                                         cmds[j].ostname = NULL;
4136                                 }
4137                                 cmds[j].rc = pool_cmd(cmd, argv[0], argv[1],
4138                                                       fsname, poolname,
4139                                                       ostname);
4140                                 /* Return an err if any of the add/dels fail */
4141                                 if (!rc)
4142                                         rc = cmds[j].rc;
4143                         }
4144                         for (j = 0; j < array_sz; j++) {
4145                                 if (!cmds[j].rc) {
4146                                         char ostname[MAX_OBD_NAME + 1];
4147
4148                                         if (!cmds[j].ostname) {
4149                                                 snprintf(ostname, MAX_OBD_NAME,
4150                                                          format, array[j]);
4151                                                 ostname[MAX_OBD_NAME] = '\0';
4152                                                 check_and_complete_ostname(
4153                                                         fsname, ostname);
4154                                         } else {
4155                                                 strcpy(ostname,
4156                                                        cmds[j].ostname);
4157                                         }
4158                                         check_pool_cmd_result(cmd, fsname,
4159                                                               poolname,ostname);
4160                                 }
4161                         }
4162                         if (array_sz > 0)
4163                                 free(array);
4164                         if (cmds)
4165                                 free(cmds);
4166                         if (ostnames_buf != NULL)
4167                                 free(ostnames_buf);
4168                 }
4169                 /* fall through */
4170         }
4171         } /* switch */
4172
4173 out:
4174         if (rc != 0) {
4175                 errno = -rc;
4176                 perror(argv[0]);
4177         }
4178
4179         return rc;
4180 }
4181
4182 int jt_get_obj_version(int argc, char **argv)
4183 {
4184         struct lu_fid fid;
4185         struct obd_ioctl_data data;
4186         __u64 version, id = ULLONG_MAX, group = ULLONG_MAX;
4187         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf, *fidstr;
4188         int rc, c;
4189
4190         while ((c = getopt(argc, argv, "i:g:")) != -1) {
4191                 switch (c) {
4192                 case 'i':
4193                         id = strtoull(optarg, NULL, 0);
4194                         break;
4195                 case 'g':
4196                         group = strtoull(optarg, NULL, 0);
4197                         break;
4198                 default:
4199                         return CMD_HELP;
4200                 }
4201         }
4202
4203         argc -= optind;
4204         argv += optind;
4205
4206         if (!(id != ULLONG_MAX && group != ULLONG_MAX && argc == 0) &&
4207             !(id == ULLONG_MAX && group == ULLONG_MAX && argc == 1))
4208                 return CMD_HELP;
4209
4210         memset(&data, 0, sizeof data);
4211         data.ioc_dev = cur_device;
4212         if (argc == 1) {
4213                 fidstr = *argv;
4214                 while (*fidstr == '[')
4215                         fidstr++;
4216                 sscanf(fidstr, SFID, RFID(&fid));
4217
4218                 data.ioc_inlbuf1 = (char *) &fid;
4219                 data.ioc_inllen1 = sizeof fid;
4220         } else {
4221                 data.ioc_inlbuf3 = (char *) &id;
4222                 data.ioc_inllen3 = sizeof id;
4223                 data.ioc_inlbuf4 = (char *) &group;
4224                 data.ioc_inllen4 = sizeof group;
4225         }
4226         data.ioc_inlbuf2 = (char *) &version;
4227         data.ioc_inllen2 = sizeof version;
4228
4229         memset(buf, 0, sizeof *buf);
4230         rc = obd_ioctl_pack(&data, &buf, sizeof rawbuf);
4231         if (rc) {
4232                 fprintf(stderr, "error: %s: packing ioctl arguments: %s\n",
4233                         jt_cmdname(argv[0]), strerror(-rc));
4234                 return rc;
4235         }
4236
4237         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_GET_OBJ_VERSION, buf);
4238         if (rc == -1) {
4239                 fprintf(stderr, "error: %s: ioctl: %s\n",
4240                         jt_cmdname(argv[0]), strerror(errno));
4241                 return -errno;
4242         }
4243
4244         obd_ioctl_unpack(&data, buf, sizeof rawbuf);
4245         printf(LPX64"\n", version);
4246         return 0;
4247 }
4248
4249 void  llapi_ping_target(char *obd_type, char *obd_name,
4250                         char *obd_uuid, void *args)
4251 {
4252         int  rc;
4253         struct obd_ioctl_data data;
4254         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
4255
4256         memset(&data, 0, sizeof(data));
4257         data.ioc_inlbuf4 = obd_name;
4258         data.ioc_inllen4 = strlen(obd_name) + 1;
4259         data.ioc_dev = OBD_DEV_BY_DEVNAME;
4260         memset(buf, 0, sizeof(rawbuf));
4261         if (obd_ioctl_pack(&data, &buf, sizeof(rawbuf))) {
4262                 fprintf(stderr, "error: invalid ioctl\n");
4263                 return;
4264         }
4265         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_PING_TARGET, buf);
4266         if (rc)
4267                 rc = errno;
4268         if (rc == ENOTCONN || rc == ESHUTDOWN) {
4269                 printf("%s: INACTIVE\n", obd_name);
4270         } else if (rc) {
4271                 printf("%s: check error: %s\n",
4272                         obd_name, strerror(errno));
4273         } else {
4274                 printf("%s: active\n", obd_name);
4275         }
4276 }
4277
4278 int jt_changelog_register(int argc, char **argv)
4279 {
4280         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
4281         struct obd_ioctl_data data;
4282         char devname[30];
4283         int rc;
4284
4285         if (argc > 2)
4286                 return CMD_HELP;
4287         else if (argc == 2 && strcmp(argv[1], "-n") != 0)
4288                 return CMD_HELP;
4289         if (cur_device < 0)
4290                 return CMD_HELP;
4291
4292         memset(&data, 0, sizeof(data));
4293         data.ioc_dev = cur_device;
4294         memset(buf, 0, sizeof(rawbuf));
4295         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
4296         if (rc) {
4297                 fprintf(stderr, "error: %s: invalid ioctl\n",
4298                         jt_cmdname(argv[0]));
4299                return rc;
4300         }
4301
4302         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_CHANGELOG_REG, buf);
4303         if (rc < 0) {
4304                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
4305                         strerror(rc = errno));
4306                 return rc;
4307         }
4308         obd_ioctl_unpack(&data, buf, sizeof(rawbuf));
4309
4310         if (data.ioc_u32_1 == 0) {
4311                 fprintf(stderr, "received invalid userid!\n");
4312                 return -EPROTO;
4313         }
4314
4315         if (lcfg_get_devname() != NULL) {
4316                 if (strlen(lcfg_get_devname()) > sizeof(devname)-1) {
4317                         fprintf(stderr, "Dev name too long\n");
4318                         return -E2BIG;
4319                 }
4320                 strncpy(devname, lcfg_get_devname(), sizeof(devname));
4321         } else {
4322                 if (snprintf(devname, sizeof(devname), "dev %d", cur_device) >=
4323                     sizeof(devname)) {
4324                         fprintf(stderr, "Dev name too long\n");
4325                         return -E2BIG;
4326                 }
4327         }
4328
4329         if (argc == 2)
4330                 /* -n means bare name */
4331                 printf(CHANGELOG_USER_PREFIX"%u\n", data.ioc_u32_1);
4332         else
4333                 printf("%s: Registered changelog userid '"CHANGELOG_USER_PREFIX
4334                        "%u'\n", devname, data.ioc_u32_1);
4335         return 0;
4336 }
4337
4338 int jt_changelog_deregister(int argc, char **argv)
4339 {
4340         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
4341         struct obd_ioctl_data data;
4342         char devname[30];
4343         int id, rc;
4344
4345         if (argc != 2 || cur_device < 0)
4346                 return CMD_HELP;
4347
4348         id = strtol(argv[1] + strlen(CHANGELOG_USER_PREFIX), NULL, 10);
4349         if ((id == 0) || (strncmp(argv[1], CHANGELOG_USER_PREFIX,
4350                                   strlen(CHANGELOG_USER_PREFIX)) != 0)) {
4351                 fprintf(stderr, "expecting id of the form '"
4352                         CHANGELOG_USER_PREFIX"<num>'; got '%s'\n", argv[1]);
4353                 return CMD_HELP;
4354         }
4355
4356         memset(&data, 0, sizeof(data));
4357         data.ioc_dev = cur_device;
4358         data.ioc_u32_1 = id;
4359         memset(buf, 0, sizeof(rawbuf));
4360         rc = obd_ioctl_pack(&data, &buf, sizeof(rawbuf));
4361         if (rc) {
4362                 fprintf(stderr, "error: %s: invalid ioctl\n",
4363                         jt_cmdname(argv[0]));
4364                 return rc;
4365         }
4366
4367         rc = l2_ioctl(OBD_DEV_ID, OBD_IOC_CHANGELOG_DEREG, buf);
4368         if (rc < 0) {
4369                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
4370                         strerror(rc = errno));
4371                 return rc;
4372         }
4373         obd_ioctl_unpack(&data, buf, sizeof(rawbuf));
4374
4375         if (data.ioc_u32_1 != id) {
4376                 fprintf(stderr, "No changelog user '%s'.  Blocking user"
4377                         " is '"CHANGELOG_USER_PREFIX"%d'.\n", argv[1],
4378                         data.ioc_u32_1);
4379                 return -ENOENT;
4380         }
4381
4382         if (lcfg_get_devname() != NULL) {
4383                 if (strlen(lcfg_get_devname()) > sizeof(devname)-1) {
4384                         fprintf(stderr, "Dev name too long\n");
4385                         return -E2BIG;
4386                 }
4387                 strncpy(devname, lcfg_get_devname(), sizeof(devname));
4388         } else {
4389                 if (snprintf(devname, sizeof(devname), "dev %d", cur_device) >=
4390                     sizeof(devname)) {
4391                         fprintf(stderr, "Dev name too long\n");
4392                         return -E2BIG;
4393                 }
4394         }
4395
4396         printf("%s: Deregistered changelog user '"CHANGELOG_USER_PREFIX"%d'\n",
4397                devname, data.ioc_u32_1);
4398         return 0;
4399 }
4400
4401