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.gnu.org/licenses/gpl-2.0.html
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
  24  * Use is subject to license terms.
  25  *
  26  * Copyright (c) 2011, 2017, Intel Corporation.
  27  */
  28 /*
  29  * This file is part of Lustre, http://www.lustre.org/
  30  *
  31  * lustre/utils/obd.c
  32  *
  33  * Author: Peter J. Braam <braam@clusterfs.com>
  34  * Author: Phil Schwan <phil@clusterfs.com>
  35  * Author: Andreas Dilger <adilger@clusterfs.com>
  36  * Author: Robert Read <rread@clusterfs.com>
  37  */
  38
  39 #include <sys/ioctl.h>
  40 #include <sys/socket.h>
  41 #include <sys/stat.h>
  42 #include <sys/time.h>
  43 #include <sys/types.h>
  44 #include <sys/un.h>
  45 #include <sys/wait.h>
  46
  47 #include <ctype.h>
  48 #include <errno.h>
  49 #include <fcntl.h>
  50 #include <getopt.h>
  51 #include <signal.h>
  52 #include <stdarg.h>
  53 #include <stdbool.h>
  54 #include <stdio.h>
  55 #include <stdlib.h>
  56 #include <string.h>
  57 #include <time.h>
  58 #include <unistd.h>
  59 #include <limits.h>
  60 #include "obdctl.h"
  61 #include "lustreapi_internal.h"
  62 #include <libcfs/util/list.h>
  63 #include <libcfs/util/ioctl.h>
  64 #include <libcfs/util/param.h>
  65 #include <libcfs/util/parser.h>
  66 #include <libcfs/util/string.h>
  67
  68 #include <linux/lnet/nidstr.h>
  69 #include <linux/lnet/lnetctl.h>
  70 #ifdef HAVE_SERVER_SUPPPORT
  71 #include <linux/lustre/lustre_barrier_user.h>
  72 #include <linux/lustre/lustre_disk.h>
  73 #endif
  74 #include <linux/lustre/lustre_cfg.h>
  75 #include <linux/lustre/lustre_ioctl.h>
  76 #include <linux/lustre/lustre_ostid.h>
  77 #include <linux/lustre/lustre_param.h>
  78 #include <linux/lustre/lustre_ver.h>
  79
  80 #include <lustre/lustreapi.h>
  81
  82 #define MAX_STRING_SIZE 128
  83
  84 #if HAVE_LIBPTHREAD
  85 #include <sys/ipc.h>
  86 #include <sys/shm.h>
  87 #include <pthread.h>
  88
  89 #define MAX_THREADS 4096
  90 #define MAX_BASE_ID 0xffffffff
  91 #define NIDSTRING_LENGTH 64
  92 struct shared_data {
  93         pthread_mutex_t mutex;
  94         pthread_cond_t  cond;
  95         int       stopping;
  96         struct {
  97                 __u64 counters[MAX_THREADS];
  98                 __u64 offsets[MAX_THREADS];
  99                 int   thr_running;
 100                 int   start_barrier;
 101                 int   stop_barrier;
 102                 struct timeval start_time;
 103                 struct timeval end_time;
 104         } body;
 105 };
 106
 107 static struct shared_data *shared_data;
 108 static __u64 counter_snapshot[2][MAX_THREADS];
 109 static int prev_valid;
 110 static struct timeval prev_time;
 111 static int thread;
 112 static int nthreads;
 113 #else
 114 const int thread;
 115 const int nthreads = 1;
 116 #endif
 117
 118 static int cur_device = -1;
 119
 120 int lcfg_ioctl(char *func, int dev_id, struct lustre_cfg *lcfg)
 121 {
 122         struct obd_ioctl_data data;
 123         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
 124         int rc;
 125
 126         memset(&data, 0, sizeof(data));
 127         data.ioc_dev = cur_device;
 128         data.ioc_type = LUSTRE_CFG_TYPE;
 129         data.ioc_plen1 = lustre_cfg_len(lcfg->lcfg_bufcount,
 130                                         lcfg->lcfg_buflens);
 131         data.ioc_pbuf1 = (void *)lcfg;
 132         memset(buf, 0, sizeof(rawbuf));
 133         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
 134         if (rc) {
 135                 fprintf(stderr, "error: %s: invalid ioctl\n", jt_cmdname(func));
 136                 return rc;
 137         }
 138
 139         rc =  l_ioctl(dev_id, OBD_IOC_PROCESS_CFG, buf);
 140
 141         return rc;
 142 }
 143
 144 static int do_device(char *func, char *devname);
 145
 146 static int get_mgs_device(void)
 147 {
 148         char mgs[] = "$MGS";
 149         static int mgs_device = -1;
 150
 151         if (mgs_device == -1) {
 152                 int rc;
 153
 154                 do_disconnect(NULL, 1);
 155                 rc = do_device("mgsioc", mgs);
 156                 if (rc) {
 157                         fprintf(stderr,
 158                                 "This command must be run on the MGS.\n");
 159                         errno = ENODEV;
 160                         return -1;
 161                 }
 162                 mgs_device = cur_device;
 163         }
 164         return mgs_device;
 165 }
 166
 167 /* Returns -1 on error with errno set */
 168 int lcfg_mgs_ioctl(char *func, int dev_id, struct lustre_cfg *lcfg)
 169 {
 170         struct obd_ioctl_data data;
 171         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
 172         int rc;
 173
 174         memset(&data, 0, sizeof(data));
 175         rc = data.ioc_dev = get_mgs_device();
 176         if (rc < 0)
 177                 goto out;
 178         data.ioc_type = LUSTRE_CFG_TYPE;
 179         data.ioc_plen1 = lustre_cfg_len(lcfg->lcfg_bufcount,
 180                                         lcfg->lcfg_buflens);
 181         data.ioc_pbuf1 = (void *)lcfg;
 182         memset(buf, 0, sizeof(rawbuf));
 183         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
 184         if (rc) {
 185                 fprintf(stderr, "error: %s: invalid ioctl\n", jt_cmdname(func));
 186                 return rc;
 187         }
 188
 189         rc = l_ioctl(dev_id, OBD_IOC_PARAM, buf);
 190 out:
 191         if (rc && errno == ENOSYS)
 192                 fprintf(stderr, "Make sure cfg_device is set first.\n");
 193
 194         return rc;
 195 }
 196
 197 char *obdo_print(struct obdo *obd)
 198 {
 199         char buf[1024];
 200
 201         snprintf(buf, sizeof(buf), "id: %#jx\ngrp: %#jx\natime: %ju\n"
 202                  "mtime: %ju\nctime: %ju\nsize: %ju\nblocks: %ju"
 203                  "\nblksize: %u\nmode: %o\nuid: %d\ngid: %d\nflags: %x\n"
 204                  "misc: %x\nnlink: %d,\nvalid %#jx\n",
 205                  (uintmax_t)ostid_id(&obd->o_oi),
 206                  (uintmax_t)ostid_seq(&obd->o_oi),
 207                  (uintmax_t)obd->o_atime, (uintmax_t)obd->o_mtime,
 208                  (uintmax_t)obd->o_ctime, (uintmax_t)obd->o_size,
 209                  (uintmax_t)obd->o_blocks, obd->o_blksize, obd->o_mode,
 210                  obd->o_uid, obd->o_gid, obd->o_flags, obd->o_misc,
 211                  obd->o_nlink, (uintmax_t)obd->o_valid);
 212         return strdup(buf);
 213 }
 214
 215 #define BAD_VERBOSE (-999999999)
 216
 217 #define N2D_OFF 0x100      /* So we can tell between error codes and devices */
 218
 219 static int do_name2dev(char *func, char *name)
 220 {
 221         struct obd_ioctl_data data;
 222         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
 223         int rc;
 224
 225         memset(&data, 0, sizeof(data));
 226         data.ioc_dev = cur_device;
 227         data.ioc_inllen1 = strlen(name) + 1;
 228         data.ioc_inlbuf1 = name;
 229
 230         memset(buf, 0, sizeof(rawbuf));
 231         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
 232         if (rc < 0) {
 233                 fprintf(stderr, "error: %s: invalid ioctl\n", jt_cmdname(func));
 234                 return -rc;
 235         }
 236         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_NAME2DEV, buf);
 237         if (rc < 0)
 238                 return errno;
 239         rc = llapi_ioctl_unpack(&data, buf, sizeof(rawbuf));
 240         if (rc) {
 241                 fprintf(stderr, "error: %s: invalid reply\n", jt_cmdname(func));
 242                 return rc;
 243         }
 244
 245         return data.ioc_dev + N2D_OFF;
 246 }
 247
 248 /*
 249  * resolve a device name to a device number.
 250  * supports a number, $name or %uuid.
 251  */
 252 int parse_devname(char *func, char *name)
 253 {
 254         int rc;
 255         int ret = -1;
 256         int try_digit;
 257
 258         if (!name)
 259                 return ret;
 260
 261         try_digit = isdigit(name[0]);
 262
 263         if (name[0] == '$' || name[0] == '%')
 264                 name++;
 265
 266         rc = do_name2dev(func, name);
 267         if (rc >= N2D_OFF)
 268                 return rc - N2D_OFF;
 269
 270         if (try_digit)
 271                 ret = strtoul(name, NULL, 0);
 272         else
 273                 fprintf(stderr, "No device found for name %s: %s\n",
 274                         name, strerror(rc));
 275         return ret;
 276 }
 277
 278 char *jt_cmdname(char *func)
 279 {
 280         static char buf[512];
 281
 282         if (thread) {
 283                 sprintf(buf, "%s-%d", func, thread);
 284                 return buf;
 285         }
 286
 287         return func;
 288 }
 289
 290 #define difftime(a, b)                                  \
 291         ((a)->tv_sec - (b)->tv_sec +                    \
 292          ((a)->tv_usec - (b)->tv_usec) / 1000000.0)
 293
 294 static int be_verbose(int verbose, struct timeval *next_time,
 295                       __u64 num, __u64 *next_num, int num_total)
 296 {
 297         struct timeval now;
 298
 299         if (!verbose)
 300                 return 0;
 301
 302         if (next_time)
 303                 gettimeofday(&now, NULL);
 304
 305         /* A positive verbosity means to print every X iterations */
 306         if (verbose > 0 && (num >= *next_num || num >= num_total)) {
 307                 *next_num += verbose;
 308                 if (next_time) {
 309                         next_time->tv_sec = now.tv_sec - verbose;
 310                         next_time->tv_usec = now.tv_usec;
 311                 }
 312                 return 1;
 313         }
 314
 315         /* A negative verbosity means to print at most each X seconds */
 316         if (verbose < 0 && next_time && difftime(&now, next_time) >= 0.0) {
 317                 next_time->tv_sec = now.tv_sec - verbose;
 318                 next_time->tv_usec = now.tv_usec;
 319                 *next_num = num;
 320                 return 1;
 321         }
 322
 323         return 0;
 324 }
 325
 326 static int get_verbose(char *func, const char *arg)
 327 {
 328         int verbose;
 329         char *end;
 330
 331         if (!arg || arg[0] == 'v') {
 332                 verbose = 1;
 333         } else if (arg[0] == 's' || arg[0] == 'q') {
 334                 verbose = 0;
 335         } else {
 336                 verbose = (int)strtoul(arg, &end, 0);
 337                 if (*end) {
 338                         fprintf(stderr, "error: %s: bad verbose option '%s'\n",
 339                                 jt_cmdname(func), arg);
 340                         return BAD_VERBOSE;
 341                 }
 342         }
 343
 344         if (verbose < 0)
 345                 printf("Print status every %d seconds\n", -verbose);
 346         else if (verbose == 1)
 347                 printf("Print status every operation\n");
 348         else if (verbose > 1)
 349                 printf("Print status every %d operations\n", verbose);
 350
 351         return verbose;
 352 }
 353
 354 int do_disconnect(char *func, int verbose)
 355 {
 356         lcfg_set_devname(NULL);
 357         cur_device = -1;
 358         return 0;
 359 }
 360
 361 #ifdef MAX_THREADS
 362 static int shmem_setup(void)
 363 {
 364         pthread_mutexattr_t mattr;
 365         pthread_condattr_t  cattr;
 366         int rc;
 367         int shmid;
 368
 369         /* Create new segment */
 370         shmid = shmget(IPC_PRIVATE, sizeof(*shared_data), 0600);
 371         if (shmid == -1) {
 372                 fprintf(stderr, "Can't create shared data: %s\n",
 373                         strerror(errno));
 374                 return errno;
 375         }
 376
 377         /* Attatch to new segment */
 378         shared_data = (struct shared_data *)shmat(shmid, NULL, 0);
 379
 380         if (shared_data == (struct shared_data *)(-1)) {
 381                 fprintf(stderr, "Can't attach shared data: %s\n",
 382                         strerror(errno));
 383                 shared_data = NULL;
 384                 return errno;
 385         }
 386
 387         /*
 388          * Mark segment as destroyed, so it will disappear when we exit.
 389          * Forks will inherit attached segments, so we should be OK.
 390          */
 391         if (shmctl(shmid, IPC_RMID, NULL) == -1) {
 392                 fprintf(stderr, "Can't destroy shared data: %s\n",
 393                         strerror(errno));
 394                 return errno;
 395         }
 396
 397         pthread_mutexattr_init(&mattr);
 398         pthread_condattr_init(&cattr);
 399
 400         rc = pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
 401         if (rc != 0) {
 402                 fprintf(stderr, "Can't set shared mutex attr\n");
 403                 goto out;
 404         }
 405
 406         rc = pthread_condattr_setpshared(&cattr, PTHREAD_PROCESS_SHARED);
 407         if (rc != 0) {
 408                 fprintf(stderr, "Can't set shared cond attr\n");
 409                 goto out;
 410         }
 411
 412         pthread_mutex_init(&shared_data->mutex, &mattr);
 413         pthread_cond_init(&shared_data->cond, &cattr);
 414 out:
 415         pthread_mutexattr_destroy(&mattr);
 416         pthread_condattr_destroy(&cattr);
 417
 418         return rc;
 419 }
 420
 421 static inline void shmem_lock(void)
 422 {
 423         pthread_mutex_lock(&shared_data->mutex);
 424 }
 425
 426 static inline void shmem_unlock(void)
 427 {
 428         pthread_mutex_unlock(&shared_data->mutex);
 429 }
 430
 431 static inline void shmem_wait(void)
 432 {
 433         pthread_cond_wait(&shared_data->cond, &shared_data->mutex);
 434 }
 435
 436 static inline void shmem_wakeup_all(void)
 437 {
 438         pthread_cond_broadcast(&shared_data->cond);
 439 }
 440
 441 static inline void shmem_reset(int total_threads)
 442 {
 443         if (!shared_data)
 444                 return;
 445
 446         memset(&shared_data->body, 0, sizeof(shared_data->body));
 447         memset(counter_snapshot, 0, sizeof(counter_snapshot));
 448         prev_valid = 0;
 449         shared_data->stopping = 0;
 450         shared_data->body.start_barrier = total_threads;
 451         shared_data->body.stop_barrier = total_threads;
 452 }
 453
 454 static inline void shmem_bump(__u32 counter)
 455 {
 456         static bool running_not_bumped = true;
 457
 458         if (!shared_data || thread <= 0 || thread > MAX_THREADS)
 459                 return;
 460
 461         shmem_lock();
 462         shared_data->body.counters[thread - 1] += counter;
 463         if (running_not_bumped) {
 464                 shared_data->body.thr_running++;
 465                 running_not_bumped = false;
 466         }
 467         shmem_unlock();
 468 }
 469
 470 static void shmem_total(int total_threads)
 471 {
 472         __u64 total = 0;
 473         double secs;
 474         int i;
 475
 476         if (!shared_data || total_threads > MAX_THREADS)
 477                 return;
 478
 479         shmem_lock();
 480         for (i = 0; i < total_threads; i++)
 481                 total += shared_data->body.counters[i];
 482
 483         secs = difftime(&shared_data->body.end_time,
 484                         &shared_data->body.start_time);
 485         shmem_unlock();
 486
 487         printf("Total: total %ju threads %d sec %f %f/second\n",
 488                (uintmax_t)total, total_threads, secs, total / secs);
 489 }
 490
 491 static void shmem_snap(int total_threads, int live_threads)
 492 {
 493         struct timeval this_time;
 494         int non_zero = 0;
 495         __u64 total = 0;
 496         double secs;
 497         int running;
 498         int i;
 499
 500         if (!shared_data || total_threads > MAX_THREADS)
 501                 return;
 502
 503         shmem_lock();
 504         memcpy(counter_snapshot[0], shared_data->body.counters,
 505                total_threads * sizeof(counter_snapshot[0][0]));
 506         running = shared_data->body.thr_running;
 507         shmem_unlock();
 508
 509         gettimeofday(&this_time, NULL);
 510
 511         for (i = 0; i < total_threads; i++) {
 512                 long long this_count =
 513                         counter_snapshot[0][i] - counter_snapshot[1][i];
 514
 515                 if (this_count != 0) {
 516                         non_zero++;
 517                         total += this_count;
 518                 }
 519         }
 520
 521         secs = difftime(&this_time, &prev_time);
 522         if (prev_valid && secs > 1.0) {   /* someone screwed with the time? */
 523                 printf("%d/%d Total: %f/second\n", non_zero, total_threads,
 524                        total / secs);
 525
 526                 memcpy(counter_snapshot[1], counter_snapshot[0],
 527                        total_threads * sizeof(counter_snapshot[0][0]));
 528                 prev_time = this_time;
 529         }
 530         if (!prev_valid && running == total_threads) {
 531                 prev_valid = 1;
 532                 /* drop counters when all threads were started */
 533                 memcpy(counter_snapshot[1], counter_snapshot[0],
 534                        total_threads * sizeof(counter_snapshot[0][0]));
 535                 prev_time = this_time;
 536         }
 537 }
 538
 539 static void shmem_stop(void)
 540 {
 541         if (!shared_data)
 542                 return;
 543
 544         shared_data->stopping = 1;
 545 }
 546
 547 static void shmem_cleanup(void)
 548 {
 549         if (!shared_data)
 550                 return;
 551
 552         shmem_stop();
 553
 554         pthread_mutex_destroy(&shared_data->mutex);
 555         pthread_cond_destroy(&shared_data->cond);
 556 }
 557
 558 static int shmem_running(void)
 559 {
 560         return (!shared_data || !shared_data->stopping);
 561 }
 562
 563 static void shmem_end_time_locked(void)
 564 {
 565         shared_data->body.stop_barrier--;
 566         if (shared_data->body.stop_barrier == 0)
 567                 gettimeofday(&shared_data->body.end_time, NULL);
 568 }
 569
 570 static void shmem_start_time_locked(void)
 571 {
 572         shared_data->body.start_barrier--;
 573         if (shared_data->body.start_barrier == 0) {
 574                 shmem_wakeup_all();
 575                 gettimeofday(&shared_data->body.start_time, NULL);
 576         } else {
 577                 shmem_wait();
 578         }
 579 }
 580
 581 #else
 582 static int shmem_setup(void)
 583 {
 584         return 0;
 585 }
 586
 587 static inline void shmem_reset(int total_threads)
 588 {
 589 }
 590
 591 static inline void shmem_bump(__u32 counters)
 592 {
 593 }
 594
 595 static void shmem_lock(void)
 596 {
 597 }
 598
 599 static void shmem_unlock(void)
 600 {
 601 }
 602
 603 static void shmem_cleanup(void)
 604 {
 605 }
 606
 607 static int shmem_running(void)
 608 {
 609         return 1;
 610 }
 611 #endif
 612
 613 extern command_t cmdlist[];
 614
 615 static int do_device(char *func, char *devname)
 616 {
 617         int dev;
 618
 619         dev = parse_devname(func, devname);
 620         if (dev < 0)
 621                 return -1;
 622
 623         lcfg_set_devname(devname);
 624         cur_device = dev;
 625         return 0;
 626 }
 627
 628 int jt_obd_get_device(void)
 629 {
 630         return cur_device;
 631 }
 632
 633 int jt_obd_device(int argc, char **argv)
 634 {
 635         int rc;
 636
 637         if (argc > 2)
 638                 return CMD_HELP;
 639
 640         if (argc == 1) {
 641                 printf("current device is %d - %s\n",
 642                        cur_device, lcfg_get_devname() ? : "not set");
 643                 return 0;
 644         }
 645         rc = do_device("device", argv[1]);
 646         return rc;
 647 }
 648
 649 int jt_opt_device(int argc, char **argv)
 650 {
 651         int ret;
 652         int rc;
 653
 654         if (argc < 3)
 655                 return CMD_HELP;
 656
 657         rc = do_device("device", argv[1]);
 658
 659         if (!rc)
 660                 rc = Parser_execarg(argc - 2, argv + 2, cmdlist);
 661
 662         ret = do_disconnect(argv[0], 0);
 663         if (!rc)
 664                 rc = ret;
 665
 666         return rc;
 667 }
 668
 669 #ifdef MAX_THREADS
 670 static void parent_sighandler(int sig)
 671 {
 672 }
 673
 674 int jt_opt_threads(int argc, char **argv)
 675 {
 676         static char      cmdstr[129];
 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),
 712                                  sizeof(cmdstr) - strlen(cmdstr),
 713                                  " %s", argv[i]);
 714
 715                 printf("%s: starting %ld threads on device %s running %s\n",
 716                        argv[0], threads, argv[3], cmdstr);
 717         }
 718
 719         shmem_reset(threads);
 720
 721         sigemptyset(&sigset);
 722         sigaddset(&sigset, SIGALRM);
 723         sigaddset(&sigset, SIGCHLD);
 724         sigprocmask(SIG_BLOCK, &sigset, &saveset);
 725
 726         nthreads = threads;
 727
 728         for (i = 1, next_thread = verbose; i <= threads; i++) {
 729                 rc = fork();
 730                 if (rc < 0) {
 731                         fprintf(stderr, "error: %s: #%d - %s\n", argv[0], i,
 732                                 strerror(rc = errno));
 733                         break;
 734                 } else if (rc == 0) {
 735                         sigprocmask(SIG_SETMASK, &saveset, NULL);
 736
 737                         thread = i;
 738                         argv[2] = "--device";
 739                         exit(jt_opt_device(argc - 2, argv + 2));
 740                 } else if (be_verbose(verbose, NULL, i, &next_thread, threads))
 741                         printf("%s: thread #%d (PID %d) started\n",
 742                                argv[0], i, rc);
 743                 rc = 0;
 744         }
 745
 746         if (!thread) {          /* parent process */
 747                 int live_threads = threads;
 748
 749                 sigemptyset(&sigset);
 750                 sigemptyset(&sigact.sa_mask);
 751                 sigact.sa_handler = parent_sighandler;
 752                 sigact.sa_flags = 0;
 753
 754                 sigaction(SIGALRM, &sigact, &saveact1);
 755                 sigaction(SIGCHLD, &sigact, &saveact2);
 756
 757                 while (live_threads > 0) {
 758                         int status;
 759                         pid_t ret;
 760
 761                         if (verbose < 0)        /* periodic stats */
 762                                 alarm(-verbose);
 763
 764                         sigsuspend(&sigset);
 765                         alarm(0);
 766
 767                         while (live_threads > 0) {
 768                                 ret = waitpid(0, &status, WNOHANG);
 769                                 if (ret == 0)
 770                                         break;
 771
 772                                 if (ret < 0) {
 773                                         fprintf(stderr,
 774                                                 "error: %s: wait - %s\n",
 775                                                 argv[0], strerror(errno));
 776                                         if (!rc)
 777                                                 rc = errno;
 778                                         continue;
 779                                 } else {
 780                                         /*
 781                                          * This is a hack.  We _should_ be able
 782                                          * to use WIFEXITED(status) to see if
 783                                          * there was an error, but it appears
 784                                          * to be broken and it always returns 1
 785                                          * (OK).  See wait(2).
 786                                          */
 787                                         int err = WEXITSTATUS(status);
 788
 789                                         if (err || WIFSIGNALED(status))
 790                                                 fprintf(stderr,
 791                                                         "%s: PID %d had rc=%d\n",
 792                                                         argv[0], ret, err);
 793                                         if (!rc)
 794                                                 rc = err;
 795
 796                                         live_threads--;
 797                                 }
 798                         }
 799
 800                         /* Show stats while all threads running */
 801                         if (verbose < 0) {
 802                                 shmem_snap(threads, live_threads);
 803                                 if (report_count > 0 && --report_count == 0)
 804                                         shmem_stop();
 805                         }
 806                 }
 807                 sigaction(SIGCHLD, &saveact2, NULL);
 808                 sigaction(SIGALRM, &saveact1, NULL);
 809         }
 810
 811         shmem_total(threads);
 812         sigprocmask(SIG_SETMASK, &saveset, NULL);
 813
 814         return rc;
 815 }
 816 #else
 817 int jt_opt_threads(int argc, char **argv)
 818 {
 819         fprintf(stderr, "%s not-supported in a single-threaded runtime\n",
 820                 jt_cmdname(argv[0]));
 821         return CMD_HELP;
 822 }
 823 #endif
 824
 825 int jt_opt_net(int argc, char **argv)
 826 {
 827         char *arg2[3];
 828         int rc;
 829
 830         if (argc < 3)
 831                 return CMD_HELP;
 832
 833         arg2[0] = argv[0];
 834         arg2[1] = argv[1];
 835         arg2[2] = NULL;
 836         rc = jt_ptl_network(2, arg2);
 837
 838         if (!rc)
 839                 rc = Parser_execarg(argc - 2, argv + 2, cmdlist);
 840
 841         return rc;
 842 }
 843
 844 #ifdef HAVE_SERVER_SUPPORT
 845 /*
 846  * Place this here so we can build tools that work with
 847  * older Lustre versions
 848  */
 849 #ifndef OBD_IOC_NO_TRANSNO
 850 #define OBD_IOC_NO_TRANSNO      _IOW('f', 140, OBD_IOC_DATA_TYPE)
 851 #endif
 852
 853 int jt_obd_no_transno(int argc, char **argv)
 854 {
 855         struct obd_ioctl_data data;
 856         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
 857         glob_t path;
 858         int count;
 859         int fd;
 860         int rc;
 861
 862         if (argc != 1)
 863                 return CMD_HELP;
 864
 865         memset(buf, 0, sizeof(rawbuf));
 866
 867         rc = cfs_get_param_paths(&path, "no_transno");
 868         if (rc != 0)
 869                 goto old_ioctl;
 870
 871         fd = open(path.gl_pathv[0], O_WRONLY);
 872         if (fd < 0) {
 873                 cfs_free_param_data(&path);
 874                 goto old_ioctl;
 875         }
 876
 877         snprintf(rawbuf, sizeof(rawbuf), "%d", cur_device);
 878
 879         count = write(fd, rawbuf, strlen(rawbuf));
 880         if (count < 0)
 881                 rc = errno;
 882
 883         cfs_free_param_data(&path);
 884         close(fd);
 885         if (rc)
 886                 goto old_ioctl;
 887
 888         return 0;
 889
 890 old_ioctl:
 891 #if LUSTRE_VERSION_CODE < OBD_OCD_VERSION(3, 0, 53, 0)
 892         memset(&data, 0, sizeof(data));
 893         data.ioc_dev = cur_device;
 894
 895         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
 896         if (rc) {
 897                 fprintf(stderr, "error: %s: invalid ioctl\n",
 898                         jt_cmdname(argv[0]));
 899                 return rc;
 900         }
 901         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_NO_TRANSNO, buf);
 902         if (rc < 0)
 903                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 904                         strerror(rc = errno));
 905 #endif
 906         return rc;
 907 }
 908
 909 int jt_obd_set_readonly(int argc, char **argv)
 910 {
 911         struct obd_ioctl_data data;
 912         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
 913         int rc;
 914
 915         memset(&data, 0, sizeof(data));
 916         data.ioc_dev = cur_device;
 917
 918         if (argc != 1)
 919                 return CMD_HELP;
 920
 921         memset(buf, 0, sizeof(rawbuf));
 922         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
 923         if (rc) {
 924                 fprintf(stderr, "error: %s: invalid ioctl\n",
 925                         jt_cmdname(argv[0]));
 926                 return rc;
 927         }
 928         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_SET_READONLY, buf);
 929         if (rc < 0)
 930                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 931                         strerror(rc = errno));
 932
 933         return rc;
 934 }
 935
 936 static int obd_abort_recovery(char *cmd, enum obd_abort_recovery_flags flags)
 937 {
 938         struct obd_ioctl_data data = {
 939                 .ioc_dev = cur_device,
 940                 .ioc_type = flags,
 941         };
 942         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
 943         int rc;
 944
 945         memset(buf, 0, sizeof(rawbuf));
 946         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
 947         if (rc) {
 948                 fprintf(stderr, "error: %s: invalid ioctl\n",
 949                         jt_cmdname(cmd));
 950                 return rc;
 951         }
 952         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_ABORT_RECOVERY, buf);
 953         if (rc < 0)
 954                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(cmd),
 955                         strerror(rc = errno));
 956
 957         return rc;
 958 }
 959
 960 int jt_obd_abort_recovery(int argc, char **argv)
 961 {
 962         if (argc != 1)
 963                 return CMD_HELP;
 964
 965         return obd_abort_recovery(argv[0], OBD_FLG_ABORT_RECOV_OST);
 966 }
 967
 968 int jt_obd_abort_recovery_mdt(int argc, char **argv)
 969 {
 970         if (argc != 1)
 971                 return CMD_HELP;
 972
 973         return obd_abort_recovery(argv[0], OBD_FLG_ABORT_RECOV_MDT);
 974 }
 975 #else /* ! HAVE_SERVER_SUPPROT */
 976 int jt_obd_no_transno(int argc, char **argv)
 977 {
 978         if (argc != 1)
 979                 return CMD_HELP;
 980
 981         fprintf(stderr, "error: %s: invalid ioctl\n",
 982                 jt_cmdname(argv[0]));
 983         return -EOPNOTSUPP;
 984 }
 985
 986 int jt_obd_set_readonly(int argc, char **argv)
 987 {
 988         if (argc != 1)
 989                 return CMD_HELP;
 990
 991         fprintf(stderr, "error: %s: invalid ioctl\n",
 992                 jt_cmdname(argv[0]));
 993         return -EOPNOTSUPP;
 994 }
 995
 996 int jt_obd_abort_recovery(int argc, char **argv)
 997 {
 998         if (argc != 1)
 999                 return CMD_HELP;
1000
1001         fprintf(stderr, "error: %s: invalid ioctl\n",
1002                 jt_cmdname(argv[0]));
1003         return -EOPNOTSUPP;
1004 }
1005
1006 int jt_obd_abort_recovery_mdt(int argc, char **argv)
1007 {
1008         if (argc != 1)
1009                 return CMD_HELP;
1010
1011         fprintf(stderr, "error: %s: invalid ioctl\n",
1012                 jt_cmdname(argv[0]));
1013         return -EOPNOTSUPP;
1014 }
1015 #endif /* HAVE_SERVER_SUPPORT */
1016
1017 int jt_get_version(int argc, char **argv)
1018 {
1019         char version[128];
1020         int rc;
1021
1022         if (argc != 1)
1023                 return CMD_HELP;
1024
1025         rc = llapi_get_version_string(version, sizeof(version));
1026         if (rc)
1027                 printf("Lustre version: %s\n", LUSTRE_VERSION_STRING);
1028         else
1029                 printf("Lustre version: %s\n", version);
1030
1031         return 0;
1032 }
1033
1034 static void print_obd_line(char *s)
1035 {
1036         const char *param = "osc/%s/ost_conn_uuid";
1037         char buf[MAX_STRING_SIZE];
1038         char obd_name[MAX_OBD_NAME];
1039         FILE *fp = NULL;
1040         glob_t path;
1041         char *ptr;
1042 retry:
1043         /* obd device type is the first 3 characters of param name */
1044         snprintf(buf, sizeof(buf), " %%*d %%*s %.3s %%%zus %%*s %%*d ",
1045                  param, sizeof(obd_name) - 1);
1046         if (sscanf(s, buf, obd_name) == 0)
1047                 goto try_mdc;
1048         if (cfs_get_param_paths(&path, param, obd_name) != 0)
1049                 goto try_mdc;
1050         fp = fopen(path.gl_pathv[0], "r");
1051         if (!fp) {
1052                 /* need to free path data before retry */
1053                 cfs_free_param_data(&path);
1054 try_mdc:
1055                 if (param[0] == 'o') { /* failed with osc, try mdc */
1056                         param = "mdc/%s/mds_conn_uuid";
1057                         goto retry;
1058                 }
1059                 buf[0] = '\0';
1060                 goto fail_print;
1061         }
1062
1063         /* should not ignore fgets(3)'s return value */
1064         if (!fgets(buf, sizeof(buf), fp)) {
1065                 fprintf(stderr, "reading from %s: %s", buf, strerror(errno));
1066                 goto fail_close;
1067         }
1068
1069 fail_close:
1070         fclose(fp);
1071         cfs_free_param_data(&path);
1072
1073         /* trim trailing newlines */
1074         ptr = strrchr(buf, '\n');
1075         if (ptr)
1076                 *ptr = '\0';
1077 fail_print:
1078         ptr = strrchr(s, '\n');
1079         if (ptr)
1080                 *ptr = '\0';
1081         printf("%s%s%s\n", s, buf[0] ? " " : "", buf);
1082 }
1083
1084 /* get device list by ioctl */
1085 int jt_obd_list_ioctl(int argc, char **argv)
1086 {
1087         int rc, index;
1088         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
1089         struct obd_ioctl_data *data = (struct obd_ioctl_data *)buf;
1090
1091         if (argc > 2)
1092                 return CMD_HELP;
1093         /* Just ignore a -t option.  Only supported with /proc. */
1094         else if (argc == 2 && strcmp(argv[1], "-t") != 0)
1095                 return CMD_HELP;
1096
1097         for (index = 0;; index++) {
1098                 memset(buf, 0, sizeof(rawbuf));
1099                 data->ioc_version = OBD_IOCTL_VERSION;
1100                 data->ioc_inllen1 =
1101                         sizeof(rawbuf) - __ALIGN_KERNEL(sizeof(*data), 8);
1102                 data->ioc_inlbuf1 = buf + __ALIGN_KERNEL(sizeof(*data), 8);
1103                 data->ioc_len = obd_ioctl_packlen(data);
1104                 data->ioc_count = index;
1105
1106                 rc = l_ioctl(OBD_DEV_ID, OBD_IOC_GETDEVICE, buf);
1107                 if (rc != 0)
1108                         break;
1109                 printf("%s\n", (char *)data->ioc_bulk);
1110         }
1111         if (rc != 0) {
1112                 if (errno == ENOENT)
1113                         /* no device or the last device */
1114                         rc = 0;
1115                 else
1116                         fprintf(stderr,
1117                                 "Error getting device list: %s: check dmesg\n",
1118                                 strerror(errno));
1119         }
1120         return rc;
1121 }
1122
1123 int jt_obd_list(int argc, char **argv)
1124 {
1125         char buf[MAX_STRING_SIZE];
1126         int print_obd = 0;
1127         glob_t path;
1128         FILE *fp;
1129
1130         if (argc > 2)
1131                 return CMD_HELP;
1132
1133         if (argc == 2) {
1134                 if (strcmp(argv[1], "-t") == 0)
1135                         print_obd = 1;
1136                 else
1137                         return CMD_HELP;
1138         }
1139
1140         if (cfs_get_param_paths(&path, "devices") ||
1141             !(fp = fopen(path.gl_pathv[0], "r"))) {
1142                 cfs_free_param_data(&path);
1143
1144                 return jt_obd_list_ioctl(argc, argv);
1145         }
1146
1147         while (fgets(buf, sizeof(buf), fp) != NULL)
1148                 if (print_obd)
1149                         print_obd_line(buf);
1150                 else
1151                         printf("%s", buf);
1152
1153         cfs_free_param_data(&path);
1154         fclose(fp);
1155         return 0;
1156 }
1157
1158 struct jt_fid_space {
1159         __u64   jt_seq;
1160         __u64   jt_id;
1161         int     jt_width;
1162 };
1163
1164 int jt_obd_alloc_fids(struct jt_fid_space *space, struct lu_fid *fid,
1165                       __u64 *count)
1166 {
1167         int rc;
1168
1169         if (space->jt_seq == 0 || space->jt_id == space->jt_width) {
1170                 struct obd_ioctl_data  data;
1171                 char rawbuf[MAX_IOC_BUFLEN];
1172                 char *buf = rawbuf;
1173                 __u64 seqnr;
1174                 int max_count;
1175
1176                 memset(&data, 0, sizeof(data));
1177                 data.ioc_dev = cur_device;
1178
1179                 data.ioc_pbuf1 = (char *)&seqnr;
1180                 data.ioc_plen1 = sizeof(seqnr);
1181
1182                 data.ioc_pbuf2 = (char *)&max_count;
1183                 data.ioc_plen2 = sizeof(max_count);
1184
1185                 memset(buf, 0, sizeof(rawbuf));
1186                 rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
1187                 if (rc) {
1188                         fprintf(stderr, "error: invalid ioctl rc = %d\n", rc);
1189                         return rc;
1190                 }
1191
1192                 rc = l_ioctl(OBD_DEV_ID, OBD_IOC_ECHO_ALLOC_SEQ, buf);
1193                 if (rc) {
1194                         fprintf(stderr, "ioctl error: rc = %d\n", rc);
1195                         return rc;
1196                 }
1197
1198                 space->jt_seq = *(__u64 *)data.ioc_pbuf1;
1199                 space->jt_width = *(int *)data.ioc_pbuf2;
1200                 space->jt_id = 1;
1201         }
1202         fid->f_seq = space->jt_seq;
1203         fid->f_oid = space->jt_id;
1204         fid->f_ver = 0;
1205
1206         space->jt_id = space->jt_id + *count;
1207         if (space->jt_id > space->jt_width)
1208                 space->jt_id = space->jt_width;
1209
1210         *count = space->jt_id - fid->f_oid;
1211         return 0;
1212 }
1213
1214 #define MD_STEP_COUNT 1000
1215 int jt_obd_md_common(int argc, char **argv, int cmd)
1216 {
1217         struct obd_ioctl_data  data;
1218         struct timeval         start;
1219         struct timeval         end_time;
1220         char rawbuf[MAX_IOC_BUFLEN];
1221         char *buf = rawbuf;
1222         int mode = 0000644;
1223         int create_mode;
1224         int rc = 0;
1225         char *parent_basedir = NULL;
1226         char dirname[4096];
1227         int parent_base_id = 0;
1228         int parent_count = 1;
1229         __u64 child_base_id = -1;
1230         int stripe_count = 0;
1231         int stripe_index = -1;
1232         int count = 0;
1233         char *end;
1234         __u64 seconds = 0;
1235         double diff;
1236         int c;
1237         __u64 total_count = 0;
1238         char *name = NULL;
1239         struct jt_fid_space fid_space = {0};
1240         int version = 0;
1241         struct option long_opts[] = {
1242         { .val = 'b',   .name = "child_base_id",
1243                                                 .has_arg = required_argument },
1244         { .val = 'c',   .name = "stripe_count",
1245                                                 .has_arg = required_argument },
1246         { .val = 'd',   .name = "parent_basedir",
1247                                                 .has_arg = required_argument },
1248         { .val = 'D',   .name = "parent_dircount",
1249                                                 .has_arg = required_argument },
1250         { .val = 'i',   .name = "stripe_index", .has_arg = required_argument },
1251         { .val = 'm',   .name = "mode",         .has_arg = required_argument },
1252         { .val = 'n',   .name = "count",        .has_arg = required_argument },
1253         { .val = 't',   .name = "time",         .has_arg = required_argument },
1254         { .val = 'v',   .name = "version",      .has_arg = no_argument },
1255         { .name = NULL } };
1256
1257         while ((c = getopt_long(argc, argv, "b:c:d:D:m:n:t:v",
1258                                 long_opts, NULL)) >= 0) {
1259                 switch (c) {
1260                 case 'b':
1261                         child_base_id = strtoull(optarg, &end, 0);
1262                         if (*end) {
1263                                 fprintf(stderr,
1264                                         "error: %s: bad child_base_id '%s'\n",
1265                                         jt_cmdname(argv[0]), optarg);
1266                                 return CMD_HELP;
1267                         }
1268                         break;
1269                 case 'c':
1270                         stripe_count = strtoul(optarg, &end, 0);
1271                         if (*end) {
1272                                 fprintf(stderr,
1273                                         "error: %s: bad stripe count '%s'\n",
1274                                         jt_cmdname(argv[0]), optarg);
1275                                 return CMD_HELP;
1276                         }
1277                         break;
1278                 case 'd':
1279                         parent_basedir = optarg;
1280                         break;
1281                 case 'D':
1282                         parent_count = strtoul(optarg, &end, 0);
1283                         if (*end) {
1284                                 fprintf(stderr,
1285                                         "error: %s: bad parent count '%s'\n",
1286                                         jt_cmdname(argv[0]), optarg);
1287                                 return CMD_HELP;
1288                         }
1289                         break;
1290                 case 'i':
1291                         stripe_index = strtoul(optarg, &end, 0);
1292                         if (*end) {
1293                                 fprintf(stderr,
1294                                         "error: %s: bad stripe index '%s'\n",
1295                                         jt_cmdname(argv[0]), optarg);
1296                                 return CMD_HELP;
1297                         }
1298                         break;
1299                 case 'm':
1300                         mode = strtoul(optarg, &end, 0);
1301                         if (*end) {
1302                                 fprintf(stderr, "error: %s: bad mode '%s'\n",
1303                                         jt_cmdname(argv[0]), optarg);
1304                                 return CMD_HELP;
1305                         }
1306                         break;
1307                 case 'n':
1308                         total_count = strtoul(optarg, &end, 0);
1309                         if (*end || total_count == 0) {
1310                                 fprintf(stderr, "%s: bad child count '%s'\n",
1311                                         jt_cmdname(argv[0]), optarg);
1312                                 return CMD_HELP;
1313                         }
1314                         break;
1315                 case 't':
1316                         seconds = strtoull(optarg, &end, 0);
1317                         if (*end) {
1318                                 fprintf(stderr, "error: %s: seconds '%s'\n",
1319                                         jt_cmdname(argv[0]), optarg);
1320                                 return CMD_HELP;
1321                         }
1322                         break;
1323                 case 'v':
1324                         version = 1;
1325                         break;
1326                 default:
1327                         fprintf(stderr,
1328                                 "error: %s: option '%s' unrecognized\n",
1329                                 argv[0], argv[optind - 1]);
1330                         return CMD_HELP;
1331                 }
1332         }
1333
1334         memset(&data, 0, sizeof(data));
1335         data.ioc_dev = cur_device;
1336         if (child_base_id == -1) {
1337                 if (optind >= argc)
1338                         return CMD_HELP;
1339                 name = argv[optind];
1340                 total_count = 1;
1341         } else {
1342                 if (optind < argc) {
1343                         fprintf(stderr,
1344                                 "child_base_id and name can not specified at the same time\n");
1345                         return CMD_HELP;
1346                 }
1347         }
1348
1349         if (stripe_count == 0 && stripe_index != -1) {
1350                 fprintf(stderr,
1351                         "If stripe_count is 0, stripe_index can not be specified\n");
1352                 return CMD_HELP;
1353         }
1354
1355         if (total_count == 0 && seconds == 0) {
1356                 fprintf(stderr, "count or seconds needs to be indicated\n");
1357                 return CMD_HELP;
1358         }
1359
1360         if (parent_count <= 0) {
1361                 fprintf(stderr, "parent count must < 0\n");
1362                 return CMD_HELP;
1363         }
1364
1365 #ifdef MAX_THREADS
1366         if (thread) {
1367                 shmem_lock();
1368                 /* threads interleave */
1369                 if (parent_base_id != -1)
1370                         parent_base_id += (thread - 1) % parent_count;
1371
1372                 if (child_base_id != -1)
1373                         child_base_id +=  (thread - 1) *
1374                                 (MAX_BASE_ID / nthreads);
1375
1376                 shmem_start_time_locked();
1377                 shmem_unlock();
1378         }
1379 #endif
1380         /*
1381          * If parent directory is not specified, try to get the directory
1382          * from name
1383          */
1384         if (!parent_basedir) {
1385                 char *last_lash;
1386
1387                 if (!name) {
1388                         fprintf(stderr,
1389                                 "parent_basedir or name must be indicated!\n");
1390                         return CMD_HELP;
1391                 }
1392                 /*Get directory and name from name*/
1393                 last_lash = strrchr(name, '/');
1394                 if (!last_lash || name[0] != '/') {
1395                         fprintf(stderr, "Can not locate %s\n", name);
1396                         return CMD_HELP;
1397                 }
1398
1399                 if (last_lash == name) {
1400                         sprintf(dirname, "%s", "/");
1401                         name++;
1402                 } else {
1403                         int namelen = (unsigned long)last_lash -
1404                                       (unsigned long)name + 1;
1405                         snprintf(dirname, namelen, "%s", name);
1406                         name = last_lash + 1;
1407                 }
1408
1409                 data.ioc_pbuf1 = dirname;
1410                 data.ioc_plen1 = strlen(dirname);
1411
1412                 data.ioc_pbuf2 = name;
1413                 data.ioc_plen2 = strlen(name);
1414         } else {
1415                 if (name) {
1416                         data.ioc_pbuf2 = name;
1417                         data.ioc_plen2 = strlen(name);
1418                 }
1419                 if (parent_base_id > 0)
1420                         sprintf(dirname, "%s%d", parent_basedir,
1421                                 parent_base_id);
1422                 else
1423                         sprintf(dirname, "%s", parent_basedir);
1424                 data.ioc_pbuf1 = dirname;
1425                 data.ioc_plen1 = strlen(dirname);
1426         }
1427
1428         if (cmd == ECHO_MD_MKDIR || cmd == ECHO_MD_RMDIR)
1429                 create_mode = S_IFDIR;
1430         else
1431                 create_mode = S_IFREG;
1432
1433         data.ioc_obdo1.o_mode = mode | S_IFDIR;
1434         data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE |
1435                                  OBD_MD_FLFLAGS | OBD_MD_FLGROUP;
1436         data.ioc_command = cmd;
1437
1438         gettimeofday(&start, NULL);
1439         while (shmem_running()) {
1440                 struct lu_fid fid = { 0 };
1441
1442                 if (child_base_id != -1)
1443                         data.ioc_obdo2.o_oi.oi.oi_id = child_base_id;
1444                 data.ioc_obdo2.o_mode = mode | create_mode;
1445                 data.ioc_obdo2.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE |
1446                                          OBD_MD_FLMODE | OBD_MD_FLFLAGS |
1447                                          OBD_MD_FLGROUP;
1448                 data.ioc_obdo2.o_misc = stripe_count;
1449                 data.ioc_obdo2.o_stripe_idx = stripe_index;
1450
1451                 if (total_count > 0) {
1452                         if ((total_count - count) > MD_STEP_COUNT)
1453                                 data.ioc_count = MD_STEP_COUNT;
1454                         else
1455                                 data.ioc_count = total_count - count;
1456                 } else {
1457                         data.ioc_count = MD_STEP_COUNT;
1458                 }
1459
1460                 if (cmd == ECHO_MD_CREATE || cmd == ECHO_MD_MKDIR) {
1461                         /*Allocate fids for the create */
1462                         rc = jt_obd_alloc_fids(&fid_space, &fid,
1463                                                &data.ioc_count);
1464                         if (rc) {
1465                                 fprintf(stderr, "Allocate fids error %d.\n",
1466                                         rc);
1467                                 return rc;
1468                         }
1469                         data.ioc_obdo1.o_oi.oi_fid = fid;
1470                 }
1471
1472                 child_base_id += data.ioc_count;
1473                 count += data.ioc_count;
1474
1475                 memset(buf, 0, sizeof(rawbuf));
1476                 rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
1477                 if (rc) {
1478                         fprintf(stderr, "error: %s: invalid ioctl %d\n",
1479                                 jt_cmdname(argv[0]), rc);
1480                         return rc;
1481                 }
1482
1483                 rc = l_ioctl(OBD_DEV_ID, OBD_IOC_ECHO_MD, buf);
1484                 if (rc) {
1485                         fprintf(stderr, "error: %s: %s\n",
1486                                 jt_cmdname(argv[0]), strerror(rc = errno));
1487                         return rc;
1488                 }
1489                 shmem_bump(data.ioc_count);
1490
1491                 gettimeofday(&end_time, NULL);
1492                 diff = difftime(&end_time, &start);
1493                 if (seconds > 0 && (__u64)diff > seconds)
1494                         break;
1495
1496                 if (count >= total_count && total_count > 0)
1497                         break;
1498         }
1499
1500         if (count > 0 && version) {
1501                 gettimeofday(&end_time, NULL);
1502                 diff = difftime(&end_time, &start);
1503                 printf("%s: %d in %.3fs (%.3f /s): %s",
1504                        jt_cmdname(argv[0]), count, diff,
1505                        (double)count / diff, ctime(&end_time.tv_sec));
1506         }
1507
1508 #ifdef MAX_THREADS
1509         if (thread) {
1510                 shmem_lock();
1511                 shmem_end_time_locked();
1512                 shmem_unlock();
1513         }
1514 #endif
1515         return rc;
1516 }
1517
1518 int jt_obd_test_create(int argc, char **argv)
1519 {
1520         return jt_obd_md_common(argc, argv, ECHO_MD_CREATE);
1521 }
1522
1523 int jt_obd_test_mkdir(int argc, char **argv)
1524 {
1525         return jt_obd_md_common(argc, argv, ECHO_MD_MKDIR);
1526 }
1527
1528 int jt_obd_test_destroy(int argc, char **argv)
1529 {
1530         return jt_obd_md_common(argc, argv, ECHO_MD_DESTROY);
1531 }
1532
1533 int jt_obd_test_rmdir(int argc, char **argv)
1534 {
1535         return jt_obd_md_common(argc, argv, ECHO_MD_RMDIR);
1536 }
1537
1538 int jt_obd_test_lookup(int argc, char **argv)
1539 {
1540         return jt_obd_md_common(argc, argv, ECHO_MD_LOOKUP);
1541 }
1542
1543 int jt_obd_test_setxattr(int argc, char **argv)
1544 {
1545         return jt_obd_md_common(argc, argv, ECHO_MD_SETATTR);
1546 }
1547
1548 int jt_obd_test_md_getattr(int argc, char **argv)
1549 {
1550         return jt_obd_md_common(argc, argv, ECHO_MD_GETATTR);
1551 }
1552
1553 int jt_obd_create(int argc, char **argv)
1554 {
1555         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
1556         struct obd_ioctl_data data;
1557         struct timeval next_time;
1558         __u64 count = 1, next_count, base_id = 1;
1559         int verbose = 1, mode = 0100644, rc = 0, i;
1560         char *end;
1561
1562         memset(&data, 0, sizeof(data));
1563         data.ioc_dev = cur_device;
1564         if (argc < 2 || argc > 4)
1565                 return CMD_HELP;
1566
1567         count = strtoull(argv[1], &end, 0);
1568         if (*end) {
1569                 fprintf(stderr, "error: %s: invalid iteration count '%s'\n",
1570                         jt_cmdname(argv[0]), argv[1]);
1571                 return CMD_HELP;
1572         }
1573
1574         if (argc > 2) {
1575                 mode = strtoul(argv[2], &end, 0);
1576                 if (*end) {
1577                         fprintf(stderr, "error: %s: invalid mode '%s'\n",
1578                                 jt_cmdname(argv[0]), argv[2]);
1579                         return CMD_HELP;
1580                 }
1581                 if (!(mode & S_IFMT))
1582                         mode |= S_IFREG;
1583         }
1584
1585         if (argc > 3) {
1586                 verbose = get_verbose(argv[0], argv[3]);
1587                 if (verbose == BAD_VERBOSE)
1588                         return CMD_HELP;
1589         }
1590
1591         printf("%s: %jd objects\n", jt_cmdname(argv[0]), (uintmax_t)count);
1592         gettimeofday(&next_time, NULL);
1593         next_time.tv_sec -= verbose;
1594
1595         ostid_set_seq_echo(&data.ioc_obdo1.o_oi);
1596         for (i = 1, next_count = verbose; i <= count && shmem_running(); i++) {
1597                 /*
1598                  * base_id is 1 so we don't need to worry about it being
1599                  * greater than OBIF_MAX_OID
1600                  */
1601                 data.ioc_obdo1.o_oi.oi_fid.f_oid = base_id;
1602                 data.ioc_obdo1.o_mode = mode;
1603                 data.ioc_obdo1.o_uid = 0;
1604                 data.ioc_obdo1.o_gid = 0;
1605                 data.ioc_obdo1.o_projid = 0;
1606                 data.ioc_obdo1.o_valid = OBD_MD_FLTYPE | OBD_MD_FLMODE |
1607                                          OBD_MD_FLID | OBD_MD_FLUID |
1608                                          OBD_MD_FLGID | OBD_MD_FLGROUP |
1609                                          OBD_MD_FLPROJID;
1610
1611                 memset(buf, 0, sizeof(rawbuf));
1612                 rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
1613                 if (rc) {
1614                         fprintf(stderr, "error: %s: invalid ioctl\n",
1615                                 jt_cmdname(argv[0]));
1616                         return rc;
1617                 }
1618                 rc = l_ioctl(OBD_DEV_ID, OBD_IOC_CREATE, buf);
1619                 llapi_ioctl_unpack(&data, buf, sizeof(rawbuf));
1620                 shmem_bump(1);
1621                 if (rc < 0) {
1622                         fprintf(stderr, "error: %s: #%d - %s\n",
1623                                 jt_cmdname(argv[0]), i, strerror(rc = errno));
1624                         break;
1625                 }
1626                 if (!(data.ioc_obdo1.o_valid & OBD_MD_FLID)) {
1627                         fprintf(stderr, "error: %s: oid not valid #%d:%#jx\n",
1628                                 jt_cmdname(argv[0]), i,
1629                                 (uintmax_t)data.ioc_obdo1.o_valid);
1630                         rc = EINVAL;
1631                         break;
1632                 }
1633
1634                 if (be_verbose(verbose, &next_time, i, &next_count, count))
1635                         printf("%s: #%d is object id %#jx\n",
1636                                jt_cmdname(argv[0]), i,
1637                                (uintmax_t)ostid_id(&data.ioc_obdo1.o_oi));
1638         }
1639
1640         return rc;
1641 }
1642
1643 int jt_obd_setattr(int argc, char **argv)
1644 {
1645         struct obd_ioctl_data data;
1646         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
1647         __u64 objid;
1648         char *end;
1649         int mode;
1650         int rc;
1651
1652         memset(&data, 0, sizeof(data));
1653         data.ioc_dev = cur_device;
1654         if (argc != 2)
1655                 return CMD_HELP;
1656
1657         objid = strtoull(argv[1], &end, 0);
1658         if (*end) {
1659                 fprintf(stderr, "error: %s: objid '%s' is not a number\n",
1660                         jt_cmdname(argv[0]), argv[1]);
1661                 return CMD_HELP;
1662         }
1663
1664         if (objid >= OBIF_MAX_OID) {
1665                 fprintf(stderr, "error: %s: invalid objid '%s'\n",
1666                         jt_cmdname(argv[0]), argv[1]);
1667                 return CMD_HELP;
1668         }
1669
1670         mode = strtoul(argv[2], &end, 0);
1671         if (*end) {
1672                 fprintf(stderr, "error: %s: invalid mode '%s'\n",
1673                         jt_cmdname(argv[0]), argv[2]);
1674                 return CMD_HELP;
1675         }
1676
1677         ostid_set_seq_echo(&data.ioc_obdo1.o_oi);
1678         data.ioc_obdo1.o_mode = S_IFREG | mode;
1679         data.ioc_obdo1.o_oi.oi_fid.f_oid = objid;
1680         data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE;
1681
1682         memset(buf, 0, sizeof(rawbuf));
1683         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
1684         if (rc) {
1685                 fprintf(stderr, "error: %s: invalid ioctl\n",
1686                         jt_cmdname(argv[0]));
1687                 return rc;
1688         }
1689         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_SETATTR, buf);
1690         if (rc < 0)
1691                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
1692                         strerror(rc = errno));
1693
1694         return rc;
1695 }
1696
1697 int jt_obd_test_setattr(int argc, char **argv)
1698 {
1699         struct obd_ioctl_data data;
1700         struct timeval start, next_time;
1701         __u64 i, count, next_count;
1702         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
1703         int verbose = 1;
1704         __u64 objid = 3;
1705         char *end;
1706         int rc = 0;
1707
1708         if (argc < 2 || argc > 4)
1709                 return CMD_HELP;
1710
1711         memset(&data, 0, sizeof(data));
1712         data.ioc_dev = cur_device;
1713         count = strtoull(argv[1], &end, 0);
1714         if (*end) {
1715                 fprintf(stderr, "error: %s: invalid iteration count '%s'\n",
1716                         jt_cmdname(argv[0]), argv[1]);
1717                 return CMD_HELP;
1718         }
1719
1720         if (argc >= 3) {
1721                 verbose = get_verbose(argv[0], argv[2]);
1722                 if (verbose == BAD_VERBOSE)
1723                         return CMD_HELP;
1724         }
1725
1726         if (argc >= 4) {
1727                 if (argv[3][0] == 't') {
1728                         objid = strtoull(argv[3] + 1, &end, 0);
1729                         if (thread)
1730                                 objid += thread - 1;
1731                 } else {
1732                         objid = strtoull(argv[3], &end, 0);
1733                 }
1734                 if (*end) {
1735                         fprintf(stderr, "error: %s: invalid objid '%s'\n",
1736                                 jt_cmdname(argv[0]), argv[3]);
1737                         return CMD_HELP;
1738                 }
1739         }
1740
1741         gettimeofday(&start, NULL);
1742         next_time.tv_sec = start.tv_sec - verbose;
1743         next_time.tv_usec = start.tv_usec;
1744         if (verbose != 0)
1745                 printf("%s: setting %jd attrs (objid %#jx): %s",
1746                        jt_cmdname(argv[0]), (uintmax_t)count,
1747                        (uintmax_t)objid, ctime(&start.tv_sec));
1748
1749         ostid_set_seq_echo(&data.ioc_obdo1.o_oi);
1750         for (i = 1, next_count = verbose; i <= count && shmem_running(); i++) {
1751                 if (objid >= OBIF_MAX_OID) {
1752                         fprintf(stderr, "errr: %s: invalid objid '%llu'\n",
1753                                 jt_cmdname(argv[0]), (unsigned long long)objid);
1754                         return -E2BIG;
1755                 }
1756
1757                 data.ioc_obdo1.o_oi.oi_fid.f_oid = objid;
1758                 data.ioc_obdo1.o_mode = S_IFREG;
1759                 data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE |
1760                                          OBD_MD_FLMODE;
1761                 memset(buf, 0, sizeof(rawbuf));
1762                 rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
1763                 if (rc) {
1764                         fprintf(stderr, "error: %s: invalid ioctl\n",
1765                                 jt_cmdname(argv[0]));
1766                         return rc;
1767                 }
1768                 rc = l_ioctl(OBD_DEV_ID, OBD_IOC_SETATTR, &data);
1769                 shmem_bump(1);
1770                 if (rc < 0) {
1771                         fprintf(stderr, "error: %s: #%jd - %d:%s\n",
1772                                 jt_cmdname(argv[0]), (uintmax_t)i,
1773                                 errno, strerror(rc = errno));
1774                         break;
1775                 }
1776                 if (be_verbose(verbose, &next_time, i, &next_count, count))
1777                         printf("%s: set attr #%jd\n",
1778                                jt_cmdname(argv[0]), (uintmax_t)i);
1779         }
1780
1781         if (!rc) {
1782                 struct timeval end;
1783                 double diff;
1784
1785                 gettimeofday(&end, NULL);
1786
1787                 diff = difftime(&end, &start);
1788
1789                 --i;
1790                 if (verbose != 0)
1791                         printf("%s: %jd attrs in %.3fs (%.3f attr/s): %s",
1792                                jt_cmdname(argv[0]), (uintmax_t)i, diff,
1793                                i / diff, ctime(&end.tv_sec));
1794         }
1795         return rc;
1796 }
1797
1798 int jt_obd_destroy(int argc, char **argv)
1799 {
1800         struct obd_ioctl_data data;
1801         struct timeval next_time;
1802         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
1803         __u64 count = 1, next_count;
1804         int verbose = 1;
1805         __u64 id;
1806         char *end;
1807         int rc = 0, i;
1808
1809         memset(&data, 0, sizeof(data));
1810         data.ioc_dev = cur_device;
1811         if (argc < 2 || argc > 4)
1812                 return CMD_HELP;
1813
1814         errno = 0;
1815         id = strtoull(argv[1], &end, 0);
1816         if (*end || id == 0 || errno != 0) {
1817                 fprintf(stderr, "error: %s: invalid objid '%s'\n",
1818                         jt_cmdname(argv[0]), argv[1]);
1819                 return CMD_HELP;
1820         }
1821         if (argc > 2) {
1822                 count = strtoull(argv[2], &end, 0);
1823                 if (*end) {
1824                         fprintf(stderr,
1825                                 "error: %s: invalid iteration count '%s'\n",
1826                                 jt_cmdname(argv[0]), argv[2]);
1827                         return CMD_HELP;
1828                 }
1829         }
1830
1831         if (argc > 3) {
1832                 verbose = get_verbose(argv[0], argv[3]);
1833                 if (verbose == BAD_VERBOSE)
1834                         return CMD_HELP;
1835         }
1836
1837         printf("%s: %jd objects\n", jt_cmdname(argv[0]), (uintmax_t)count);
1838         gettimeofday(&next_time, NULL);
1839         next_time.tv_sec -= verbose;
1840
1841         ostid_set_seq_echo(&data.ioc_obdo1.o_oi);
1842         for (i = 1, next_count = verbose; i <= count && shmem_running();
1843              i++, id++) {
1844                 if (id >= OBIF_MAX_OID) {
1845                         fprintf(stderr, "errr: %s: invalid objid '%llu'\n",
1846                                 jt_cmdname(argv[0]), (unsigned long long)id);
1847                         return -E2BIG;
1848                 }
1849
1850                 data.ioc_obdo1.o_oi.oi_fid.f_oid = id;
1851                 data.ioc_obdo1.o_mode = S_IFREG | 0644;
1852                 data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLMODE;
1853
1854                 memset(buf, 0, sizeof(rawbuf));
1855                 rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
1856                 if (rc) {
1857                         fprintf(stderr, "error: %s: invalid ioctl\n",
1858                                 jt_cmdname(argv[0]));
1859                         return rc;
1860                 }
1861                 rc = l_ioctl(OBD_DEV_ID, OBD_IOC_DESTROY, buf);
1862                 llapi_ioctl_unpack(&data, buf, sizeof(rawbuf));
1863                 shmem_bump(1);
1864                 if (rc < 0) {
1865                         fprintf(stderr, "error: %s: objid %#jx: %s\n",
1866                                 jt_cmdname(argv[0]), (uintmax_t)id,
1867                                 strerror(rc = errno));
1868                         break;
1869                 }
1870
1871                 if (be_verbose(verbose, &next_time, i, &next_count, count))
1872                         printf("%s: #%d is object id %#jx\n",
1873                                jt_cmdname(argv[0]), i, (uintmax_t)id);
1874         }
1875
1876         return rc;
1877 }
1878
1879 int jt_obd_getattr(int argc, char **argv)
1880 {
1881         struct obd_ioctl_data data;
1882         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
1883         __u64 objid;
1884         char *end;
1885         int rc;
1886
1887         if (argc != 2)
1888                 return CMD_HELP;
1889
1890         objid = strtoull(argv[1], &end, 0);
1891         if (*end) {
1892                 fprintf(stderr, "error: %s: objid '%s' is not a number\n",
1893                         jt_cmdname(argv[0]), argv[1]);
1894                 return CMD_HELP;
1895         }
1896
1897         if (objid >= OBIF_MAX_OID) {
1898                 fprintf(stderr, "error: %s: invalid objid '%s'\n",
1899                         jt_cmdname(argv[0]), argv[1]);
1900                 return CMD_HELP;
1901         }
1902
1903         memset(&data, 0, sizeof(data));
1904         data.ioc_dev = cur_device;
1905         ostid_set_seq_echo(&data.ioc_obdo1.o_oi);
1906         data.ioc_obdo1.o_oi.oi_fid.f_oid = objid;
1907         /* to help obd filter */
1908         data.ioc_obdo1.o_mode = 0100644;
1909         data.ioc_obdo1.o_valid = 0xffffffff;
1910         printf("%s: object id %#jx\n", jt_cmdname(argv[0]),
1911                (uintmax_t)ostid_id(&data.ioc_obdo1.o_oi));
1912
1913         memset(buf, 0, sizeof(rawbuf));
1914         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
1915         if (rc) {
1916                 fprintf(stderr, "error: %s: invalid ioctl\n",
1917                         jt_cmdname(argv[0]));
1918                 return rc;
1919         }
1920         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_GETATTR, buf);
1921         llapi_ioctl_unpack(&data, buf, sizeof(rawbuf));
1922         if (rc) {
1923                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
1924                         strerror(rc = errno));
1925         } else {
1926                 printf("%s: object id %ju, mode %o\n", jt_cmdname(argv[0]),
1927                        (uintmax_t)ostid_id(&data.ioc_obdo1.o_oi),
1928                        data.ioc_obdo1.o_mode);
1929         }
1930         return rc;
1931 }
1932
1933 int jt_obd_test_getattr(int argc, char **argv)
1934 {
1935         struct obd_ioctl_data data;
1936         struct timeval start, next_time;
1937         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
1938         __u64 i, count, next_count;
1939         int verbose = 1;
1940         __u64 objid = 3;
1941         char *end;
1942         int rc = 0;
1943
1944         if (argc < 2 || argc > 4)
1945                 return CMD_HELP;
1946
1947         memset(&data, 0, sizeof(data));
1948         data.ioc_dev = cur_device;
1949         count = strtoull(argv[1], &end, 0);
1950         if (*end) {
1951                 fprintf(stderr, "error: %s: invalid iteration count '%s'\n",
1952                         jt_cmdname(argv[0]), argv[1]);
1953                 return CMD_HELP;
1954         }
1955
1956         if (argc >= 3) {
1957                 verbose = get_verbose(argv[0], argv[2]);
1958                 if (verbose == BAD_VERBOSE)
1959                         return CMD_HELP;
1960         }
1961
1962         if (argc >= 4) {
1963                 if (argv[3][0] == 't') {
1964                         objid = strtoull(argv[3] + 1, &end, 0);
1965                         if (thread)
1966                                 objid += thread - 1;
1967                 } else {
1968                         objid = strtoull(argv[3], &end, 0);
1969                 }
1970                 if (*end) {
1971                         fprintf(stderr, "error: %s: invalid objid '%s'\n",
1972                                 jt_cmdname(argv[0]), argv[3]);
1973                         return CMD_HELP;
1974                 }
1975         }
1976
1977         gettimeofday(&start, NULL);
1978         next_time.tv_sec = start.tv_sec - verbose;
1979         next_time.tv_usec = start.tv_usec;
1980         if (verbose != 0)
1981                 printf("%s: getting %jd attrs (objid %#jx): %s",
1982                        jt_cmdname(argv[0]), (uintmax_t)count,
1983                        (uintmax_t)objid, ctime(&start.tv_sec));
1984
1985         ostid_set_seq_echo(&data.ioc_obdo1.o_oi);
1986         for (i = 1, next_count = verbose; i <= count && shmem_running(); i++) {
1987                 if (objid >= OBIF_MAX_OID) {
1988                         fprintf(stderr, "errr: %s: invalid objid '%llu'\n",
1989                                 jt_cmdname(argv[0]), (unsigned long long)objid);
1990                         return -E2BIG;
1991                 }
1992
1993                 data.ioc_obdo1.o_oi.oi_fid.f_oid = objid;
1994                 data.ioc_obdo1.o_mode = S_IFREG;
1995                 data.ioc_obdo1.o_valid = 0xffffffff;
1996                 memset(buf, 0, sizeof(rawbuf));
1997                 rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
1998                 if (rc) {
1999                         fprintf(stderr, "error: %s: invalid ioctl\n",
2000                                 jt_cmdname(argv[0]));
2001                         return rc;
2002                 }
2003                 rc = l_ioctl(OBD_DEV_ID, OBD_IOC_GETATTR, &data);
2004                 shmem_bump(1);
2005                 if (rc < 0) {
2006                         fprintf(stderr, "error: %s: #%jd - %d:%s\n",
2007                                 jt_cmdname(argv[0]), (uintmax_t)i,
2008                                 errno, strerror(rc = errno));
2009                         break;
2010                 }
2011                 if (be_verbose(verbose, &next_time, i, &next_count, count))
2012                         printf("%s: got attr #%jd\n",
2013                                jt_cmdname(argv[0]), (uintmax_t)i);
2014         }
2015
2016         if (!rc) {
2017                 struct timeval end;
2018                 double diff;
2019
2020                 gettimeofday(&end, NULL);
2021
2022                 diff = difftime(&end, &start);
2023
2024                 --i;
2025                 if (verbose != 0)
2026                         printf("%s: %jd attrs in %.3fs (%.3f attr/s): %s",
2027                                jt_cmdname(argv[0]), (uintmax_t)i, diff,
2028                                i / diff, ctime(&end.tv_sec));
2029         }
2030
2031         return rc;
2032 }
2033
2034 /*
2035  * test_brw <cnt>                                               count
2036  *      <r|w[r(repeat)x(noverify)]>                             mode
2037  *      <q|v|#(print interval)>                                 verbosity
2038  *      <npages[+offset]>                                       blocksize
2039  *      <[[<interleave_threads>]t(inc obj by thread#)]obj>      object
2040  *      [p|g<args>]                                             batch
2041  */
2042 int jt_obd_test_brw(int argc, char **argv)
2043 {
2044         struct obd_ioctl_data data;
2045         struct timeval start, next_time;
2046         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2047         __u64 count, next_count, len, stride, thr_offset = 0, objid = 3;
2048         int write = 0, verbose = 1, cmd, i, rc = 0, pages = 1;
2049         int offset_pages = 0;
2050         long n;
2051         int repeat_offset = 0;
2052         unsigned long long ull;
2053         int  nthr_per_obj = 0;
2054         int  verify = 1;
2055         int  obj_idx = 0;
2056         char *end;
2057
2058         if (argc < 2 || argc > 7) {
2059                 fprintf(stderr, "error: %s: bad number of arguments: %d\n",
2060                         jt_cmdname(argv[0]), argc);
2061                 return CMD_HELP;
2062         }
2063
2064         count = strtoull(argv[1], &end, 0);
2065         if (*end) {
2066                 fprintf(stderr, "error: %s: bad iteration count '%s'\n",
2067                         jt_cmdname(argv[0]), argv[1]);
2068                 return CMD_HELP;
2069         }
2070
2071         if (argc >= 3) {
2072                 if (argv[2][0] == 'w' || argv[2][0] == '1')
2073                         write = 1;
2074                 /* else it's a read */
2075
2076                 if (argv[2][0] != 0)
2077                         for (i = 1; argv[2][i] != 0; i++)
2078                                 switch (argv[2][i]) {
2079                                 case 'r':
2080                                         repeat_offset = 1;
2081                                         break;
2082
2083                                 case 'x':
2084                                         verify = 0;
2085                                         break;
2086
2087                                 default:
2088                                         fprintf(stderr,
2089                                                 "Can't parse cmd '%s'\n",
2090                                                 argv[2]);
2091                                         return CMD_HELP;
2092                                 }
2093         }
2094
2095         if (argc >= 4) {
2096                 verbose = get_verbose(argv[0], argv[3]);
2097                 if (verbose == BAD_VERBOSE)
2098                         return CMD_HELP;
2099         }
2100
2101         if (argc >= 5) {
2102                 pages = strtoul(argv[4], &end, 0);
2103
2104                 if (*end == '+')
2105                         offset_pages = strtoul(end + 1, &end, 0);
2106
2107                 if (*end != 0 || offset_pages < 0 || offset_pages >= pages) {
2108                         fprintf(stderr, "error: %s: bad npages[+offset] parameter '%s'\n",
2109                                 jt_cmdname(argv[0]), argv[4]);
2110                         return CMD_HELP;
2111                 }
2112         }
2113
2114         if (argc >= 6) {
2115                 if (thread && (n = strtol(argv[5], &end, 0)) > 0 &&
2116                     *end == 't' && (ull = strtoull(end + 1, &end, 0)) > 0 &&
2117                     *end == 0) {
2118                         nthr_per_obj = n;
2119                         objid = ull;
2120                 } else if (thread && argv[5][0] == 't') {
2121                         nthr_per_obj = 1;
2122                         objid = strtoull(argv[5] + 1, &end, 0);
2123                 } else {
2124                         nthr_per_obj = 0;
2125                         objid = strtoull(argv[5], &end, 0);
2126                 }
2127                 if (*end) {
2128                         fprintf(stderr, "error: %s: bad objid '%s'\n",
2129                                 jt_cmdname(argv[0]), argv[5]);
2130                         return CMD_HELP;
2131                 }
2132         }
2133
2134         memset(&data, 0, sizeof(data));
2135         data.ioc_dev = cur_device;
2136
2137         /*
2138          * communicate the 'type' of brw test and batching to echo_client.
2139          * don't start.  we'd love to refactor this lctl->echo_client
2140          * interface
2141          */
2142         data.ioc_pbuf1 = (void *)1;
2143         data.ioc_plen1 = 1;
2144
2145         if (argc >= 7) {
2146                 switch (argv[6][0]) {
2147                 case 'g': /* plug and unplug */
2148                         data.ioc_pbuf1 = (void *)2;
2149                         data.ioc_plen1 = strtoull(argv[6] + 1, &end, 0);
2150                         break;
2151                 case 'p': /* prep and commit */
2152                         data.ioc_pbuf1 = (void *)3;
2153                         data.ioc_plen1 = strtoull(argv[6] + 1, &end, 0);
2154                         break;
2155                 default:
2156                         fprintf(stderr,
2157                                 "error: %s: batching '%s' needs to specify 'p' or 'g'\n",
2158                                 jt_cmdname(argv[0]), argv[6]);
2159                         return CMD_HELP;
2160                 }
2161
2162                 if (*end) {
2163                         fprintf(stderr, "error: %s: bad batching '%s'\n",
2164                                 jt_cmdname(argv[0]), argv[6]);
2165                         return CMD_HELP;
2166                 }
2167                 data.ioc_plen1 *= getpagesize();
2168         }
2169
2170         len = pages * getpagesize();
2171         thr_offset = offset_pages * getpagesize();
2172         stride = len;
2173
2174 #ifdef MAX_THREADS
2175         if (thread) {
2176                 shmem_lock();
2177                 if (nthr_per_obj != 0) {
2178                         /* threads interleave */
2179                         obj_idx = (thread - 1) / nthr_per_obj;
2180                         objid += obj_idx;
2181                         stride *= nthr_per_obj;
2182                         if ((thread - 1) % nthr_per_obj == 0) {
2183                                 shared_data->body.offsets[obj_idx] =
2184                                         stride + thr_offset;
2185                         }
2186                         thr_offset += ((thread - 1) % nthr_per_obj) * len;
2187                 } else {
2188                         /* threads disjoint */
2189                         thr_offset += (thread - 1) * len;
2190                 }
2191
2192                 shmem_start_time_locked();
2193                 shmem_unlock();
2194         }
2195 #endif
2196
2197         ostid_set_seq_echo(&data.ioc_obdo1.o_oi);
2198         if (objid >= OBIF_MAX_OID) {
2199                 fprintf(stderr, "errr: %s: invalid objid '%llu'\n",
2200                         jt_cmdname(argv[0]), (unsigned long long)objid);
2201                 return -E2BIG;
2202         }
2203
2204         data.ioc_obdo1.o_oi.oi_fid.f_oid = objid;
2205         data.ioc_obdo1.o_mode = S_IFREG;
2206         data.ioc_obdo1.o_valid = OBD_MD_FLID | OBD_MD_FLTYPE | OBD_MD_FLMODE |
2207                                  OBD_MD_FLFLAGS | OBD_MD_FLGROUP;
2208         data.ioc_obdo1.o_flags = (verify ? OBD_FL_DEBUG_CHECK : 0);
2209         data.ioc_count = len;
2210         data.ioc_offset = (repeat_offset ? 0 : thr_offset);
2211
2212         gettimeofday(&start, NULL);
2213         next_time.tv_sec = start.tv_sec - verbose;
2214         next_time.tv_usec = start.tv_usec;
2215
2216         if (verbose != 0)
2217                 printf("%s: %s %jux%d pages (obj %#jx, off %ju): %s",
2218                        jt_cmdname(argv[0]), write ? "writing" : "reading",
2219                        (uintmax_t)count, pages, (uintmax_t)objid,
2220                        (uintmax_t)data.ioc_offset, ctime(&start.tv_sec));
2221
2222         cmd = write ? OBD_IOC_BRW_WRITE : OBD_IOC_BRW_READ;
2223         for (i = 1, next_count = verbose; i <= count && shmem_running(); i++) {
2224                 data.ioc_obdo1.o_valid &= ~(OBD_MD_FLBLOCKS | OBD_MD_FLGRANT);
2225                 memset(buf, 0, sizeof(rawbuf));
2226                 rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
2227                 if (rc) {
2228                         fprintf(stderr, "error: %s: invalid ioctl\n",
2229                                 jt_cmdname(argv[0]));
2230                         return rc;
2231                 }
2232                 rc = l_ioctl(OBD_DEV_ID, cmd, buf);
2233                 shmem_bump(1);
2234                 if (rc) {
2235                         fprintf(stderr, "error: %s: #%d - %s on %s\n",
2236                                 jt_cmdname(argv[0]), i, strerror(rc = errno),
2237                                 write ? "write" : "read");
2238                         break;
2239                 } else if (be_verbose(verbose, &next_time, i,
2240                                       &next_count, count)) {
2241                         shmem_lock();
2242                         printf("%s: %s number %d @ %jd:%ju for %d\n",
2243                                jt_cmdname(argv[0]), write ? "write" : "read", i,
2244                                (uintmax_t)ostid_id(&data.ioc_obdo1.o_oi),
2245                                (uintmax_t)data.ioc_offset,
2246                                (int)(pages * getpagesize()));
2247                         shmem_unlock();
2248                 }
2249
2250                 if (!repeat_offset) {
2251 #ifdef MAX_THREADS
2252                         if (stride == len) {
2253                                 data.ioc_offset += stride;
2254                         } else if (i < count) {
2255                                 shmem_lock();
2256                                 data.ioc_offset =
2257                                         shared_data->body.offsets[obj_idx];
2258                                 shared_data->body.offsets[obj_idx] += len;
2259                                 shmem_unlock();
2260                         }
2261 #else
2262                         data.ioc_offset += len;
2263                         obj_idx = 0; /* avoids an unused var warning */
2264 #endif
2265                 }
2266         }
2267
2268         if (!rc) {
2269                 struct timeval end;
2270                 double diff;
2271
2272                 gettimeofday(&end, NULL);
2273
2274                 diff = difftime(&end, &start);
2275
2276                 --i;
2277                 if (verbose != 0)
2278                         printf("%s: %s %dx%d pages in %.3fs (%.3f MB/s): %s",
2279                                jt_cmdname(argv[0]), write ? "wrote" : "read",
2280                                i, pages, diff,
2281                                ((double)i * pages * getpagesize()) /
2282                                (diff * 1048576.0), ctime(&end.tv_sec));
2283         }
2284
2285 #ifdef MAX_THREADS
2286         if (thread) {
2287                 shmem_lock();
2288                 shmem_end_time_locked();
2289                 shmem_unlock();
2290         }
2291 #endif
2292         return rc;
2293 }
2294
2295 static int do_activate(int argc, char **argv, int flag)
2296 {
2297         struct obd_ioctl_data data;
2298         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2299         int rc;
2300
2301         memset(&data, 0, sizeof(data));
2302         data.ioc_dev = cur_device;
2303         if (argc != 1)
2304                 return CMD_HELP;
2305
2306         /* reuse offset for 'active' */
2307         data.ioc_offset = flag;
2308
2309         memset(buf, 0, sizeof(rawbuf));
2310         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
2311         if (rc) {
2312                 fprintf(stderr, "error: %s: invalid ioctl\n",
2313                         jt_cmdname(argv[0]));
2314                 return rc;
2315         }
2316         rc = l_ioctl(OBD_DEV_ID, IOC_OSC_SET_ACTIVE, buf);
2317         if (rc)
2318                 fprintf(stderr, "error: %s: failed: %s\n",
2319                         jt_cmdname(argv[0]), strerror(rc = errno));
2320
2321         return rc;
2322 }
2323
2324 /**
2325  * Replace nids for given device.
2326  * lctl replace_nids <devicename> <nid1>[,nid2,nid3]
2327  * Command should be started on MGS server.
2328  * Only MGS server should be started (command execution
2329  * returns error in another cases). Command mount
2330  * -t lustre <MDT partition> -o nosvc <mount point>
2331  * can be used for that.
2332  *
2333  * llogs for MDTs and clients are processed. All
2334  * records copied as is except add_uuid and setup. This records
2335  * are skipped and recorded with new nids and uuid.
2336  *
2337  * \see mgs_replace_nids
2338  * \see mgs_replace_log
2339  * \see mgs_replace_nids_handler
2340  */
2341 int jt_replace_nids(int argc, char **argv)
2342 {
2343         int rc;
2344         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2345         struct obd_ioctl_data data;
2346
2347         memset(&data, 0, sizeof(data));
2348         data.ioc_dev = get_mgs_device();
2349         if (argc != 3)
2350                 return CMD_HELP;
2351
2352         data.ioc_inllen1 = strlen(argv[1]) + 1;
2353         data.ioc_inlbuf1 = argv[1];
2354
2355         data.ioc_inllen2 = strlen(argv[2]) + 1;
2356         data.ioc_inlbuf2 = argv[2];
2357         memset(buf, 0, sizeof(rawbuf));
2358         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
2359         if (rc) {
2360                 fprintf(stderr, "error: %s: invalid ioctl\n",
2361                         jt_cmdname(argv[0]));
2362                 return rc;
2363         }
2364
2365         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_REPLACE_NIDS, buf);
2366         if (rc < 0) {
2367                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
2368                         strerror(rc = errno));
2369         }
2370
2371         return rc;
2372 }
2373
2374 int jt_obd_deactivate(int argc, char **argv)
2375 {
2376         return do_activate(argc, argv, 0);
2377 }
2378
2379 int jt_obd_activate(int argc, char **argv)
2380 {
2381         return do_activate(argc, argv, 1);
2382 }
2383
2384 int jt_obd_recover(int argc, char **argv)
2385 {
2386         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2387         struct obd_ioctl_data data;
2388         int rc;
2389
2390         memset(&data, 0, sizeof(data));
2391         data.ioc_dev = cur_device;
2392         if (argc > 2)
2393                 return CMD_HELP;
2394
2395         if (argc == 2) {
2396                 data.ioc_inllen1 = strlen(argv[1]) + 1;
2397                 data.ioc_inlbuf1 = argv[1];
2398         }
2399
2400         memset(buf, 0, sizeof(rawbuf));
2401         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
2402         if (rc) {
2403                 fprintf(stderr, "error: %s: invalid ioctl\n",
2404                         jt_cmdname(argv[0]));
2405                 return rc;
2406         }
2407         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_CLIENT_RECOVER, buf);
2408         if (rc < 0) {
2409                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
2410                         strerror(rc = errno));
2411         }
2412
2413         return rc;
2414 }
2415
2416 int jt_obd_mdc_lookup(int argc, char **argv)
2417 {
2418         struct obd_ioctl_data data;
2419         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2420         char *parent, *child;
2421         int rc, fd, verbose = 1;
2422
2423         if (argc < 3 || argc > 4)
2424                 return CMD_HELP;
2425
2426         parent = argv[1];
2427         child = argv[2];
2428         if (argc == 4)
2429                 verbose = get_verbose(argv[0], argv[3]);
2430
2431         memset(&data, 0, sizeof(data));
2432         data.ioc_dev = cur_device;
2433
2434         data.ioc_inllen1 = strlen(child) + 1;
2435         data.ioc_inlbuf1 = child;
2436
2437         memset(buf, 0, sizeof(rawbuf));
2438         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
2439         if (rc) {
2440                 fprintf(stderr, "error: %s: invalid ioctl\n",
2441                         jt_cmdname(argv[0]));
2442                 return rc;
2443         }
2444
2445         fd = open(parent, O_RDONLY);
2446         if (fd < 0) {
2447                 fprintf(stderr, "open \"%s\" failed: %s\n", parent,
2448                         strerror(errno));
2449                 return -1;
2450         }
2451
2452         rc = ioctl(fd, IOC_MDC_LOOKUP, buf);
2453         if (rc < 0) {
2454                 fprintf(stderr, "error: %s: ioctl error: %s\n",
2455                         jt_cmdname(argv[0]), strerror(rc = errno));
2456         }
2457         close(fd);
2458
2459         if (verbose) {
2460                 rc = llapi_ioctl_unpack(&data, buf, sizeof(rawbuf));
2461                 if (rc) {
2462                         fprintf(stderr, "error: %s: invalid reply\n",
2463                                 jt_cmdname(argv[0]));
2464                         return rc;
2465                 }
2466                 printf("%s: mode %o uid %d gid %d\n",
2467                        child, data.ioc_obdo1.o_mode, data.ioc_obdo1.o_uid,
2468                        data.ioc_obdo1.o_gid);
2469         }
2470
2471         return rc;
2472 }
2473
2474 #ifdef HAVE_SERVER_SUPPORT
2475 /**
2476  * Clear config logs for given device or filesystem.
2477  * lctl clear_conf <devicename|fsname>
2478  * Command has to be run on MGS node having MGS device mounted with -o
2479  * nosvc.
2480  *
2481  * Configuration logs for filesystem or one particular log is
2482  * processed. New log is created, original log is read, its records
2483  * marked SKIP do not get copied to new log. Others are copied as-is.
2484  * Original file is renamed to log.${time}.bak.
2485  *
2486  * \see mgs_clear_configs
2487  * \see mgs_replace_log
2488  * \see mgs_clear_config_handler
2489  **/
2490 int jt_lcfg_clear(int argc, char **argv)
2491 {
2492         int rc;
2493         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2494         struct obd_ioctl_data data;
2495
2496         memset(&data, 0, sizeof(data));
2497         data.ioc_dev = get_mgs_device();
2498         if (argc != 2)
2499                 return CMD_HELP;
2500
2501         data.ioc_inllen1 = strlen(argv[1]) + 1;
2502         data.ioc_inlbuf1 = argv[1];
2503
2504         memset(buf, 0, sizeof(rawbuf));
2505         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
2506         if (rc) {
2507                 fprintf(stderr, "error: %s: invalid ioctl\n",
2508                         jt_cmdname(argv[0]));
2509                 return rc;
2510         }
2511
2512         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_CLEAR_CONFIGS, buf);
2513         if (rc < 0) {
2514                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
2515                         strerror(rc = errno));
2516         }
2517
2518         return rc;
2519 }
2520
2521 int jt_lcfg_fork(int argc, char **argv)
2522 {
2523         struct obd_ioctl_data data;
2524         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2525         int rc;
2526
2527         if (argc != 3)
2528                 return CMD_HELP;
2529
2530         memset(&data, 0, sizeof(data));
2531         data.ioc_dev = get_mgs_device();
2532         data.ioc_inllen1 = strlen(argv[1]) + 1;
2533         data.ioc_inlbuf1 = argv[1];
2534         data.ioc_inllen2 = strlen(argv[2]) + 1;
2535         data.ioc_inlbuf2 = argv[2];
2536
2537         memset(buf, 0, sizeof(rawbuf));
2538         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
2539         if (rc) {
2540                 fprintf(stderr, "error: %s: invalid ioctl\n",
2541                         jt_cmdname(argv[0]));
2542                 return rc;
2543         }
2544
2545         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LCFG_FORK, buf);
2546         if (rc < 0)
2547                 fprintf(stderr, "error: %s: OBD_IOC_LCFG_FORK failed: %s\n",
2548                         jt_cmdname(argv[0]), strerror(errno));
2549
2550         return rc;
2551 }
2552
2553 int jt_lcfg_erase(int argc, char **argv)
2554 {
2555         struct obd_ioctl_data data;
2556         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2557         int rc;
2558
2559         if (argc == 3) {
2560                 if (strncmp(argv[2], "-q", strlen("-q")) != 0 &&
2561                     strncmp(argv[2], "--quiet", strlen("--quiet")) != 0)
2562                         return CMD_HELP;
2563         } else if (argc != 2) {
2564                 return CMD_HELP;
2565         }
2566
2567         memset(&data, 0, sizeof(data));
2568         data.ioc_dev = get_mgs_device();
2569         data.ioc_inllen1 = strlen(argv[1]) + 1;
2570         data.ioc_inlbuf1 = argv[1];
2571
2572         memset(buf, 0, sizeof(rawbuf));
2573         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
2574         if (rc) {
2575                 fprintf(stderr, "error: %s: invalid ioctl\n",
2576                         jt_cmdname(argv[0]));
2577                 return rc;
2578         }
2579
2580         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LCFG_ERASE, buf);
2581         if (rc < 0)
2582                 fprintf(stderr, "error: %s: OBD_IOC_LCFG_ERASE failed: %s\n",
2583                         jt_cmdname(argv[0]), strerror(errno));
2584
2585         return rc;
2586 }
2587 #else /* !HAVE_SERVER_SUPPORT */
2588 int jt_lcfg_clear(int argc, char **argv)
2589 {
2590         if (argc != 2)
2591                 return CMD_HELP;
2592
2593         fprintf(stderr, "error: %s: invalid ioctl\n",
2594                 jt_cmdname(argv[0]));
2595         return -EOPNOTSUPP;
2596 }
2597
2598 int jt_lcfg_fork(int argc, char **argv)
2599 {
2600         if (argc != 3)
2601                 return CMD_HELP;
2602
2603         fprintf(stderr, "error: %s: invalid ioctl\n",
2604                 jt_cmdname(argv[0]));
2605         return -EOPNOTSUPP;
2606 }
2607
2608 int jt_lcfg_erase(int argc, char **argv)
2609 {
2610         if (argc != 3)
2611                 return CMD_HELP;
2612
2613         fprintf(stderr, "error: %s: invalid ioctl\n",
2614                 jt_cmdname(argv[0]));
2615         return -EOPNOTSUPP;
2616 }
2617 #endif /* HAVE_SERVER_SUPPORT */
2618
2619 enum llog_default_dev_op {
2620         LLOG_DFLT_MGS_SET = 0,
2621         LLOG_DFLT_DEV_RESET
2622 };
2623
2624 static int llog_default_device(enum llog_default_dev_op op)
2625 {
2626         int rc = 0;
2627         static int dflt_dev = -1;
2628
2629         if (op == LLOG_DFLT_MGS_SET && (cur_device == -1)) {
2630                 char mgs[] = "$MGS";
2631
2632                 rc = do_device("llog_default_device", mgs);
2633                 dflt_dev = cur_device;
2634
2635         } else if (op == LLOG_DFLT_DEV_RESET && (dflt_dev != -1)) {
2636                 do_disconnect(NULL, 1);
2637                 dflt_dev = -1;
2638         }
2639
2640         return rc;
2641 }
2642
2643 int jt_llog_catlist(int argc, char **argv)
2644 {
2645         struct obd_ioctl_data data;
2646         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2647         char *tmp = NULL;
2648         int start = 0;
2649         int rc;
2650
2651         if (argc != 1)
2652                 return CMD_HELP;
2653
2654         if (llog_default_device(LLOG_DFLT_MGS_SET))
2655                 return CMD_INCOMPLETE;
2656
2657         do {
2658                 memset(&data, 0, sizeof(data));
2659                 data.ioc_dev = cur_device;
2660                 data.ioc_inllen1 = sizeof(rawbuf) -
2661                                    __ALIGN_KERNEL(sizeof(data), 8);
2662                 data.ioc_count = start;
2663                 memset(buf, 0, sizeof(rawbuf));
2664                 rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
2665                 if (rc) {
2666                         fprintf(stderr, "error: %s: invalid ioctl\n",
2667                                 jt_cmdname(argv[0]));
2668                         goto err;
2669                 }
2670                 rc = l_ioctl(OBD_DEV_ID, OBD_IOC_CATLOGLIST, buf);
2671                 if (rc < 0)
2672                         break;
2673                 tmp = ((struct obd_ioctl_data *)buf)->ioc_bulk;
2674                 if (strlen(tmp) > 0)
2675                         fprintf(stdout, "%s", tmp);
2676                 else
2677                         break;
2678                 start = ((struct obd_ioctl_data *)buf)->ioc_count;
2679         } while (start);
2680
2681         if (rc < 0)
2682                 fprintf(stderr, "OBD_IOC_CATLOGLIST failed: %s\n",
2683                         strerror(errno));
2684
2685 err:
2686         llog_default_device(LLOG_DFLT_DEV_RESET);
2687
2688         return rc;
2689 }
2690
2691 int jt_llog_info(int argc, char **argv)
2692 {
2693         const struct option long_opts[] = {
2694         /* Allow optional "--catalog" for compatibility with llog commands. */
2695         { .val = 'c',   .name = "catalog",      .has_arg = required_argument },
2696         { .val = 'h',   .name = "help",         .has_arg = no_argument },
2697         { .name = NULL } };
2698         struct obd_ioctl_data data = { 0 };
2699         char rawbuf[MAX_IOC_BUFLEN] = "", *buf = rawbuf;
2700         char *cmd = argv[0];
2701         char *catalog = NULL;
2702         int rc, c;
2703
2704         while ((c = getopt_long(argc, argv, "c:h", long_opts, NULL)) != -1) {
2705                 switch (c) {
2706                 case 'c':
2707                         catalog = optarg;
2708                         break;
2709                 case 'h':
2710                 default:
2711                         return CMD_HELP;
2712                 }
2713         }
2714         argc -= optind;
2715         argv += optind;
2716         /* support "logname" positional parameter */
2717         if (argc == 1) {
2718                 if (catalog) {
2719                         fprintf(stderr,
2720                                 "%s: catalog is set, unknown argument '%s'\n",
2721                                 cmd, optarg);
2722                         return CMD_HELP;
2723                 }
2724                 catalog = argv[0];
2725         } else if (!catalog || argc > 1) {
2726                 return CMD_HELP;
2727         }
2728
2729         /* Manage default device */
2730         if (llog_default_device(LLOG_DFLT_MGS_SET))
2731                 return CMD_INCOMPLETE;
2732
2733         data.ioc_dev = cur_device;
2734         data.ioc_inllen1 = strlen(catalog) + 1;
2735         data.ioc_inlbuf1 = catalog;
2736         data.ioc_inllen2 = sizeof(rawbuf) - __ALIGN_KERNEL(sizeof(data), 8) -
2737                            __ALIGN_KERNEL(data.ioc_inllen1, 8);
2738         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
2739         if (rc) {
2740                 fprintf(stderr, "%s: ioctl_pack failed for catalog '%s': %s\n",
2741                         jt_cmdname(cmd), catalog, strerror(-rc));
2742                 goto err;
2743         }
2744
2745         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_INFO, buf);
2746         if (rc == 0)
2747                 fprintf(stdout, "%s", ((struct obd_ioctl_data *)buf)->ioc_bulk);
2748         else
2749                 fprintf(stderr, "%s: OBD_IOC_LLOG_INFO failed: %s\n",
2750                         jt_cmdname(cmd), strerror(errno));
2751
2752 err:
2753         llog_default_device(LLOG_DFLT_DEV_RESET);
2754
2755         return rc;
2756 }
2757
2758 int jt_llog_print_cb(const char *record, void *private)
2759 {
2760         printf("%s\n", record);
2761
2762         return 0;
2763 }
2764
2765 static int
2766 llog_process_records(int (record_cb)(const char *record, void *private),
2767                      const char *record, void *private, bool reverse)
2768 {
2769         char *ptr = NULL;
2770         char *tmp = NULL;
2771         int rc = 0;
2772
2773         if (!reverse) {
2774                 do {
2775                         ptr = strchr(record, '\n');
2776                         if (ptr)
2777                                 *ptr = '\0';
2778                         rc = record_cb(record, private);
2779                         if (rc)
2780                                 goto out;
2781                         if (ptr)
2782                                 record = ptr + 1;
2783                 } while (ptr && *(ptr + 1));
2784         } else {
2785                 tmp = (char *)record;
2786
2787                 ptr = strrchr(record, '\n');
2788                 if (ptr)
2789                         *ptr = '\0';
2790                 else
2791                         goto out;
2792                 while ((ptr = strrchr(record, '\n'))) {
2793                         tmp = ptr + 1;
2794                         *ptr = '\0';
2795                         rc = record_cb(tmp, private);
2796                         if (rc)
2797                                 goto out;
2798                 };
2799                 rc = record_cb(record, private);
2800                 if (rc)
2801                         goto out;
2802         }
2803 out:
2804         return rc;
2805 }
2806
2807 /**
2808  * Iterate over llog records, typically YAML-formatted configuration logs
2809  *
2810  * \param logname[in]   name of llog file or FID
2811  * \param start[in]     first record to process
2812  * \param end[in]       last record to process (inclusive)
2813  * \param cb[in]        callback for records. Return -ve error, or +ve abort.
2814  * \param private[in,out] private data passed to the \a record_cb function
2815  * \param reverse[in]   print the llog records from the beginning or the end
2816  *
2817  * \retval              0 on success
2818  *                      others handled by the caller
2819  */
2820 int jt_llog_print_iter(char *logname, long start, long end,
2821                        int (record_cb)(const char *record, void *private),
2822                        void *private, bool reverse)
2823 {
2824         struct obd_ioctl_data data = { 0 };
2825         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
2826         char startbuf[16], endbuf[16];
2827         static long inc = sizeof(rawbuf) / 128;
2828         long rec;
2829         int rc = 0;
2830
2831         if (end == -1)
2832                 end = 0x7fffffff;
2833
2834         data.ioc_dev = cur_device;
2835         data.ioc_inlbuf1 = logname;
2836         data.ioc_inllen1 = strlen(logname) + 1;
2837
2838         /*
2839          * Estimate about 128 characters per configuration record.  Not all
2840          * records will be printed in any case, so they should easily fit.  If
2841          * not, the kernel will return -EOVERFLOW and ask for fewer records.
2842          *
2843          * We don't want to request records from the kernel one-at-a-time, as
2844          * it restarts the config llog iteration from the beginning, so we
2845          * fetch multiple records from the kernel per call and split locally.
2846          */
2847         for (rec = start; rec < end; rec += inc) {
2848                 char *record = ((struct obd_ioctl_data *)buf)->ioc_bulk;
2849
2850 retry:
2851                 snprintf(startbuf, sizeof(startbuf), "%lu", rec);
2852                 snprintf(endbuf, sizeof(endbuf), "%lu",
2853                          end < rec + inc - 1 ? end : rec + inc - 1);
2854
2855                 /* start and end record numbers are passed as ASCII digits */
2856                 data.ioc_inlbuf2 = startbuf;
2857                 data.ioc_inllen2 = strlen(startbuf) + 1;
2858                 data.ioc_inlbuf3 = endbuf;
2859                 data.ioc_inllen3 = strlen(endbuf) + 1;
2860
2861                 data.ioc_inllen4 = sizeof(rawbuf) -
2862                         __ALIGN_KERNEL(sizeof(data), 8) -
2863                         __ALIGN_KERNEL(data.ioc_inllen1, 8) -
2864                         __ALIGN_KERNEL(data.ioc_inllen2, 8) -
2865                         __ALIGN_KERNEL(data.ioc_inllen3, 8);
2866                 memset(buf, 0, sizeof(rawbuf));
2867                 rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
2868                 if (rc) {
2869                         fprintf(stderr, "%s: invalid ioctl data\n", logname);
2870                         goto out;
2871                 }
2872
2873                 rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_PRINT, buf);
2874                 if (rc == -EOVERFLOW && inc > 2) {
2875                         inc /= 2;
2876                         goto retry;
2877                 }
2878                 if (rc) {
2879                         fprintf(stderr, "%s: OBD_IOC_LLOG_PRINT failed: %s\n",
2880                                 logname, strerror(errno));
2881                         rc = -errno;
2882                         goto out;
2883                 }
2884
2885                 /* There is no "end of list" marker, record was not modified */
2886                 if (strcmp(record, logname) == 0)
2887                         break;
2888
2889                 rc = llog_process_records(record_cb, record, private, reverse);
2890                 if (rc)
2891                         goto out;
2892         }
2893
2894 out:
2895         return rc;
2896 }
2897
2898 static int llog_parse_catalog_start_end(int *argc, char **argv[],
2899                                         char **catalog, long *start, long *end)
2900 {
2901         const struct option long_opts[] = {
2902         /* the --catalog option is not required, just for consistency */
2903         { .val = 'c',   .name = "catalog",      .has_arg = required_argument },
2904         { .val = 'e',   .name = "end",          .has_arg = required_argument },
2905         { .val = 'h',   .name = "help",         .has_arg = no_argument },
2906         { .val = 's',   .name = "start",        .has_arg = required_argument },
2907         { .name = NULL } };
2908         char *cmd = (*argv)[0];
2909         char *endp;
2910         int c;
2911
2912         if (!catalog || !start || !end)
2913                 return -EINVAL;
2914
2915         /* now process command line arguments*/
2916         while ((c = getopt_long(*argc, *argv, "c:e:hs:",
2917                                 long_opts, NULL)) != -1) {
2918                 switch (c) {
2919                 case 'c':
2920                         *catalog = optarg;
2921                         break;
2922                 case 'e':
2923                         *end = strtol(optarg, &endp, 0);
2924                         if (*endp != '\0') {
2925                                 fprintf(stderr, "%s: bad end value '%s'\n",
2926                                         cmd, optarg);
2927                                 return CMD_HELP;
2928                         }
2929                         break;
2930                 case 's':
2931                         *start = strtol(optarg, &endp, 0);
2932                         if (*endp != '\0') {
2933                                 fprintf(stderr, "%s: bad start value '%s'\n",
2934                                         cmd, optarg);
2935                                 return CMD_HELP;
2936                         }
2937                         break;
2938                 case 'h':
2939                 default:
2940                         return CMD_HELP;
2941                 }
2942         }
2943         *argc -= optind;
2944         *argv += optind;
2945
2946         /*
2947          * support old optional positional parameters only if they were
2948          * not already specified with named arguments: logname [start [end]]
2949          */
2950         if (*argc >= 1) {
2951                 if (*catalog) {
2952                         fprintf(stderr,
2953                                 "%s: logname is set, unknown argument '%s'\n",
2954                                 cmd, (*argv)[0]);
2955                         return CMD_HELP;
2956                 }
2957                 *catalog = (*argv)[0];
2958                 (*argc)--;
2959                 (*argv)++;
2960         }
2961
2962         if (*catalog == NULL) {
2963                 fprintf(stderr, "%s: no logname specified\n", cmd);
2964                 return CMD_HELP;
2965         }
2966
2967         if (*argc >= 1) {
2968                 if (*start != 1) {
2969                         fprintf(stderr,
2970                                 "%s: --start is set, unknown argument '%s'\n",
2971                                 cmd, (*argv)[0]);
2972                         return CMD_HELP;
2973                 }
2974
2975                 *start = strtol((*argv)[0], &endp, 0);
2976                 if (*endp != '\0') {
2977                         fprintf(stderr, "%s: bad start value '%s'\n",
2978                                 cmd, (*argv)[0]);
2979                         return CMD_HELP;
2980                 }
2981                 (*argc)--;
2982                 (*argv)++;
2983         }
2984         if (*argc >= 1) {
2985                 if (*end != -1) {
2986                         fprintf(stderr,
2987                                 "%s: --end is set, unknown argument '%s'\n",
2988                                 cmd, (*argv)[0]);
2989                         return CMD_HELP;
2990                 }
2991
2992                 *end = strtol((*argv)[0], &endp, 0);
2993                 if (*endp != '\0') {
2994                         fprintf(stderr, "%s: bad end value '%s'\n",
2995                                 cmd, (*argv)[0]);
2996                         return CMD_HELP;
2997                 }
2998                 (*argc)--;
2999                 (*argv)++;
3000         }
3001         if (*argc > 1) {
3002                 fprintf(stderr, "%s: unknown argument '%s'\n", cmd, (*argv)[0]);
3003                 return CMD_HELP;
3004         }
3005
3006         if (*end != -1 && *end < *start) {
3007                 fprintf(stderr, "%s: end '%lu' less than than start '%lu'\n",
3008                         cmd, *end, *start);
3009                 return CMD_HELP;
3010         }
3011
3012         return 0;
3013 }
3014
3015 int jt_llog_print(int argc, char **argv)
3016 {
3017         char *catalog = NULL;
3018         long start = 1, end = -1;
3019         int rc;
3020
3021         rc = llog_parse_catalog_start_end(&argc, &argv, &catalog, &start, &end);
3022         if (rc)
3023                 return rc;
3024
3025         if (llog_default_device(LLOG_DFLT_MGS_SET))
3026                 return CMD_INCOMPLETE;
3027
3028         rc = jt_llog_print_iter(catalog, start, end, jt_llog_print_cb,
3029                                 NULL, false);
3030
3031         llog_default_device(LLOG_DFLT_DEV_RESET);
3032
3033         return rc;
3034 }
3035
3036 /*
3037  * Parse catalog, log ID, and optionally a log index with either optional
3038  * arguments or positional arguments.  Only the initial catalog argument
3039  * may be positional with other optional arguments.
3040  *
3041  * The positional arguments option should eventually be phased out.
3042  */
3043 static int llog_parse_catalog_log_idx(int *argc, char ***argv, const char *opts,
3044                                       int max_args, struct obd_ioctl_data *data)
3045 {
3046         const struct option long_opts[] = {
3047         /* the --catalog option is not required, just for consistency */
3048         { .val = 'c',   .name = "catalog",      .has_arg = required_argument },
3049         { .val = 'h',   .name = "help",         .has_arg = no_argument },
3050         { .val = 'i',   .name = "log_idx",      .has_arg = required_argument },
3051         { .val = 'l',   .name = "log_id",       .has_arg = required_argument },
3052         { .name = NULL } };
3053         int c;
3054
3055         /* sanity check */
3056         if (!data || *argc <= 1)
3057                 return -1;
3058
3059         data->ioc_dev = cur_device;
3060
3061         /* now process command line arguments*/
3062         while ((c = getopt_long(*argc, *argv, opts, long_opts, NULL)) != -1) {
3063                 switch (c) {
3064                 case 'c':
3065                         data->ioc_inllen1 = strlen(optarg) + 1;
3066                         data->ioc_inlbuf1 = optarg;
3067                         break;
3068                 case 'i':
3069                         data->ioc_inllen3 = strlen(optarg) + 1;
3070                         data->ioc_inlbuf3 = optarg;
3071                         break;
3072                 case 'l': /* The log_id option isn't currently needed for
3073                            * cancel as mdt_iocontrol() handles IOC_LLOG_CANCEL,
3074                            * but we may as well keep it for now.
3075                            */
3076                         data->ioc_inllen2 = strlen(optarg) + 1;
3077                         data->ioc_inlbuf2 = optarg;
3078                         break;
3079                 case 'h':
3080                 default:
3081                         return CMD_HELP;
3082                 }
3083         }
3084
3085         *argc -= optind;
3086         *argv += optind;
3087
3088         /* Allow catalog to be specified as first option without --catalog */
3089         if (!data->ioc_inlbuf1 && *argc > 0) {
3090                 data->ioc_inlbuf1 = (*argv)[0];
3091                 data->ioc_inllen1 = strlen((*argv)[0]) + 1;
3092                 (*argc)--;
3093                 (*argv)++;
3094         }
3095
3096         return 0;
3097 }
3098
3099 int jt_llog_cancel(int argc, char **argv)
3100 {
3101         struct obd_ioctl_data data = { 0 };
3102         char rawbuf[MAX_IOC_BUFLEN] = "", *buf = rawbuf;
3103         char *cmd = argv[0];
3104         int rc;
3105
3106         /* Manage default device */
3107         if (llog_default_device(LLOG_DFLT_MGS_SET))
3108                 return CMD_INCOMPLETE;
3109
3110         /* Parse catalog file (in inlbuf1) and named parameters */
3111         rc = llog_parse_catalog_log_idx(&argc, &argv, "c:hi:l:", 3, &data);
3112
3113         /*
3114          * Handle old positional parameters if not using named parameters,
3115          * either "<catalog> <log_idx>" or "<catalog> <log_id> <log_idx>".
3116          * It was "inlbuf3 = log_idx", and "inlbuf2 = log_id" (ignored by
3117          * config log cancel), and shows why I hate positional parameters.
3118          */
3119         if (argc == 1) {
3120                 data.ioc_inllen3 = strlen(argv[0]) + 1;
3121                 data.ioc_inlbuf3 = argv[0];
3122         } else if (argc == 2) {
3123                 data.ioc_inllen2 = strlen(argv[0]) + 1;
3124                 data.ioc_inlbuf2 = argv[0];
3125                 data.ioc_inllen3 = strlen(argv[1]) + 1;
3126                 data.ioc_inlbuf3 = argv[1];
3127         }
3128
3129         if (!data.ioc_inlbuf1 || !data.ioc_inlbuf3) {
3130                 /* missing mandatory parameters */
3131                 rc = CMD_HELP;
3132                 goto err;
3133         }
3134
3135         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
3136         if (rc) {
3137                 fprintf(stderr, "%s: ioctl_pack for catalog '%s' failed: %s\n",
3138                         jt_cmdname(cmd), data.ioc_inlbuf1, strerror(-rc));
3139                 goto err;
3140         }
3141
3142         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_CANCEL, buf);
3143         if (rc)
3144                 fprintf(stderr, "%s: cancel catalog '%s:%s' failed: %s\n",
3145                         jt_cmdname(cmd), data.ioc_inlbuf1, data.ioc_inlbuf3,
3146                         strerror(errno));
3147
3148 err:
3149         llog_default_device(LLOG_DFLT_DEV_RESET);
3150         return rc;
3151 }
3152
3153 int jt_llog_check(int argc, char **argv)
3154 {
3155         struct obd_ioctl_data data = { 0 };
3156         char rawbuf[MAX_IOC_BUFLEN] = "", *buf = rawbuf;
3157         char *catalog = NULL;
3158         char startbuf[16], endbuf[16];
3159         long start = 1, end = -1;
3160         char *cmd = argv[0];
3161         int rc;
3162
3163         rc = llog_parse_catalog_start_end(&argc, &argv, &catalog, &start, &end);
3164         if (rc)
3165                 return rc;
3166
3167         if (llog_default_device(LLOG_DFLT_MGS_SET))
3168                 return CMD_INCOMPLETE;
3169
3170         if (end == -1)
3171                 end = 0x7fffffff;
3172
3173         data.ioc_dev = cur_device;
3174         data.ioc_inllen1 = strlen(catalog) + 1;
3175         data.ioc_inlbuf1 = catalog;
3176
3177         snprintf(startbuf, sizeof(startbuf), "%lu", start);
3178         snprintf(endbuf, sizeof(endbuf), "%lu", end);
3179         /* start and end record numbers are passed as ASCII digits */
3180         data.ioc_inllen2 = strlen(startbuf) + 1;
3181         data.ioc_inlbuf2 = startbuf;
3182         data.ioc_inllen3 = strlen(endbuf) + 1;
3183         data.ioc_inlbuf3 = endbuf;
3184
3185         data.ioc_inllen4 = sizeof(rawbuf) - __ALIGN_KERNEL(sizeof(data), 8) -
3186                            __ALIGN_KERNEL(data.ioc_inllen1, 8) -
3187                            __ALIGN_KERNEL(data.ioc_inllen2, 8) -
3188                            __ALIGN_KERNEL(data.ioc_inllen3, 8);
3189         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
3190         if (rc) {
3191                 fprintf(stderr, "%s: ioctl_pack failed for catalog '%s': %s\n",
3192                         jt_cmdname(cmd), data.ioc_inlbuf1, strerror(-rc));
3193                 goto err;
3194         }
3195
3196         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_CHECK, buf);
3197         if (rc == 0)
3198                 fprintf(stdout, "%s", ((struct obd_ioctl_data *)buf)->ioc_bulk);
3199         else
3200                 fprintf(stderr, "%s: OBD_IOC_LLOG_CHECK failed: %s\n",
3201                         jt_cmdname(cmd), strerror(errno));
3202 err:
3203         llog_default_device(LLOG_DFLT_DEV_RESET);
3204         return rc;
3205 }
3206
3207 int jt_llog_remove(int argc, char **argv)
3208 {
3209         struct obd_ioctl_data data = { 0 };
3210         char rawbuf[MAX_IOC_BUFLEN] = "", *buf = rawbuf;
3211         char *cmd = argv[0];
3212         int rc;
3213
3214         if (llog_default_device(LLOG_DFLT_MGS_SET))
3215                 return CMD_INCOMPLETE;
3216
3217         rc = llog_parse_catalog_log_idx(&argc, &argv, "c:hl:", 2, &data);
3218         if (rc)
3219                 goto err;
3220
3221         if (argc == 1) {
3222                 if (data.ioc_inlbuf2) {
3223                         fprintf(stderr,
3224                                 "%s: --log_id is set, unknown argument '%s'\n",
3225                                 jt_cmdname(cmd), argv[0]);
3226                         rc = CMD_HELP;
3227                         goto err;
3228                 }
3229
3230                 data.ioc_inllen2 = strlen(argv[0]) + 1;
3231                 data.ioc_inlbuf2 = argv[0];
3232         }
3233
3234         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
3235         if (rc) {
3236                 fprintf(stderr, "%s: ioctl_pack for catalog '%s' failed: %s\n",
3237                         jt_cmdname(cmd), data.ioc_inlbuf1, strerror(-rc));
3238                 goto err;
3239         }
3240
3241         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_REMOVE, buf);
3242         if (rc)
3243                 fprintf(stderr, "%s: cancel catalog '%s:%s' failed: %s\n",
3244                         jt_cmdname(cmd), data.ioc_inlbuf1, data.ioc_inlbuf2,
3245                         strerror(-rc));
3246
3247 err:
3248         llog_default_device(LLOG_DFLT_DEV_RESET);
3249         return rc;
3250 }
3251
3252 static void signal_server(int sig)
3253 {
3254         if (sig == SIGINT) {
3255                 do_disconnect("sigint", 1);
3256                 exit(1);
3257         } else {
3258                 fprintf(stderr, "%s: got signal %d\n", jt_cmdname("sigint"),
3259                         sig);
3260         }
3261 }
3262
3263 int obd_initialize(int argc, char **argv)
3264 {
3265         if (shmem_setup() != 0)
3266                 return -1;
3267
3268         register_ioc_dev(OBD_DEV_ID, OBD_DEV_PATH);
3269
3270         return 0;
3271 }
3272
3273 void obd_finalize(int argc, char **argv)
3274 {
3275         struct sigaction sigact;
3276
3277         /* sigact initialization */
3278         sigact.sa_handler = signal_server;
3279         sigfillset(&sigact.sa_mask);
3280         sigact.sa_flags = SA_RESTART;
3281         /* coverity[uninit_use_in_call] */
3282         sigaction(SIGINT, &sigact, NULL);
3283
3284         shmem_cleanup();
3285         do_disconnect(argv[0], 1);
3286 }
3287
3288 /**
3289  * Get the index of the last llog record
3290  *
3291  * logid:            [0x3:0xa:0x0]:0
3292  * flags:            4 (plain)
3293  * records_count:    57
3294  * last_index:       57
3295  *
3296  * \param logname[in]   pointer to config log name
3297  *
3298  * \retval              > 0 on success
3299  *                      <= 0 on error
3300  */
3301 static long llog_last_index(char *logname)
3302 {
3303         struct obd_ioctl_data data = { 0 };
3304         char rawbuf[MAX_IOC_BUFLEN] = "", *buf = rawbuf;
3305         char *last_index;
3306         long rc;
3307
3308         data.ioc_dev = cur_device;
3309         data.ioc_inllen1 = strlen(logname) + 1;
3310         data.ioc_inlbuf1 = logname;
3311         data.ioc_inllen2 = sizeof(rawbuf) - __ALIGN_KERNEL(sizeof(data), 8) -
3312                            __ALIGN_KERNEL(data.ioc_inllen1, 8);
3313         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
3314         if (rc) {
3315                 fprintf(stderr, "%s: ioctl_pack failed for catalog '%s': %s\n",
3316                         __func__, logname, strerror(-rc));
3317                 return rc;
3318         }
3319
3320         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_LLOG_INFO, buf);
3321         if (rc == 0) {
3322                 last_index = strstr(((struct obd_ioctl_data *)buf)->ioc_bulk,
3323                                     "last_index:");
3324                 return strtol(last_index + 11, NULL, 10);
3325         }
3326
3327         rc = -errno;
3328
3329         return rc;
3330 }
3331
3332 static char *get_llog_event_name(__u32 cmd)
3333 {
3334         struct lcfg_type_data *data;
3335
3336         data = lcfg_cmd2data(cmd);
3337         if (data)
3338                 return data->ltd_name;
3339         return NULL;
3340 }
3341
3342 static char *get_event_filter(__u32 cmd)
3343 {
3344         char *event_name;
3345         char *filter = NULL;
3346         int len;
3347
3348         event_name = get_llog_event_name(cmd);
3349         if (event_name) {
3350                 /* 9 bytes for "event: , " */
3351                 len = 9 + strlen(event_name);
3352                 filter = malloc(len + 1);
3353                 if (!filter)
3354                         return NULL;
3355                 memset(filter, 0, len + 1);
3356                 snprintf(filter, len, "event: %s, ", event_name);
3357                 return filter;
3358         }
3359
3360         return NULL;
3361 }
3362
3363 /**
3364  * Callback to search ostname in llog
3365  * - { index: 23, event: attach, device: lustre-OST0000-osc, type: osc,
3366  *     UUID: lustre-clilov_UUID }
3367  * - { index: 24, event: setup, device: lustre-OST0000-osc,
3368  *     UUID: lustre-OST0000_UUID, node: 192.168.0.120@tcp }
3369  * - { index: 25, event: add_osc, device: lustre-clilov,
3370  *     ost: lustre-OST0000_UUID, index: 0, gen: 1 }
3371  *
3372  * \param record[in]    pointer to llog record
3373  * \param data[in]      pointer to ostname
3374  *
3375  * \retval              1 if ostname is found
3376  *                      0 if ostname is not found
3377  *                      -ENOENT if ostname is deleted
3378  */
3379 static int llog_search_ost_cb(const char *record, void *data)
3380 {
3381         char *ostname = data;
3382         char ost_filter[MAX_STRING_SIZE] = {'\0'};
3383         char *add_osc, *del_osc, *setup, *cleanup;
3384
3385         add_osc = get_event_filter(LCFG_LOV_ADD_OBD);
3386         del_osc = get_event_filter(LCFG_LOV_DEL_OBD);
3387         setup = get_event_filter(LCFG_SETUP);
3388         cleanup = get_event_filter(LCFG_CLEANUP);
3389         if (!add_osc || !del_osc || !setup || !cleanup)
3390                 return -ENOMEM;
3391
3392         if (ostname && ostname[0])
3393                 snprintf(ost_filter, sizeof(ost_filter), " %s,", ostname);
3394
3395         if (strstr(record, ost_filter)) {
3396                 if (strstr(record, add_osc) || strstr(record, setup))
3397                         return 1;
3398                 if (strstr(record, del_osc) || strstr(record, cleanup))
3399                         return -ENOENT;
3400         }
3401
3402         free(add_osc);
3403         free(del_osc);
3404         free(setup);
3405         free(cleanup);
3406
3407         return 0;
3408 }
3409
3410 /**
3411  * Search ost in llog
3412  *
3413  * \param logname[in]           pointer to config log name
3414  * \param last_index[in]        the index of the last llog record
3415  * \param ostname[in]           pointer to ost name
3416  *
3417  * \retval                      1 if ostname is found
3418  *                              0 if ostname is not found
3419  */
3420 static int llog_search_ost(char *logname, long last_index, char *ostname)
3421 {
3422         long start, end, inc = MAX_IOC_BUFLEN / 128;
3423         int rc = 0;
3424
3425         for (end = last_index; end > 1; end -= inc) {
3426                 start = end - inc > 0 ? end - inc : 1;
3427                 rc = jt_llog_print_iter(logname, start, end, llog_search_ost_cb,
3428                                         ostname, true);
3429                 if (rc)
3430                         break;
3431         }
3432
3433         return (rc == 1 ? 1 : 0);
3434 }
3435
3436 struct llog_pool_data {
3437         char lpd_fsname[LUSTRE_MAXFSNAME + 1];
3438         char lpd_poolname[LOV_MAXPOOLNAME + 1];
3439         char lpd_ostname[MAX_OBD_NAME + 1];
3440         enum lcfg_command_type lpd_cmd_type;
3441         bool lpd_pool_exists;
3442         int lpd_ost_num;
3443 };
3444
3445 /**
3446  * Called for each formatted line in the config log (within range).
3447  *
3448  * - { index: 74, event: new_pool, device: tfs-clilov, fsname: tfs, pool: tmp }
3449  * - { index: 77, event: add_pool, device: tfs-clilov, fsname: tfs, pool: tmp,
3450  *     ost: tfs-OST0000_UUID }
3451  * - { index: 224, event: remove_pool, device: tfs-clilov, fsname: tfs,
3452  *     pool: tmp, ost: tfs-OST0003_UUID }
3453  * - { index: 227, event: del_pool, device: tfs-clilov, fsname: tfs, pool: tmp }
3454  *
3455  * \param record[in]    pointer to llog record
3456  * \param data[in]      pointer to llog_pool_data
3457  *
3458  * \retval              1 if pool or OST is found
3459  *                      0 if pool or OST is not found
3460  *                      -ENOENT if pool or OST is removed
3461  */
3462 static int llog_search_pool_cb(const char *record, void *data)
3463 {
3464         struct llog_pool_data *lpd = data;
3465         char pool_filter[MAX_STRING_SIZE] = "";
3466         char *new_pool, *del_pool, *add_pool, *rem_pool;
3467         char *found = NULL;
3468         int fs_pool_len = 0, rc = 0;
3469
3470         new_pool = get_event_filter(LCFG_POOL_NEW);
3471         del_pool = get_event_filter(LCFG_POOL_DEL);
3472         add_pool = get_event_filter(LCFG_POOL_ADD);
3473         rem_pool = get_event_filter(LCFG_POOL_REM);
3474         if (!new_pool || !del_pool || !add_pool || !rem_pool) {
3475                 rc = -ENOMEM;
3476                 goto out;
3477         }
3478
3479         fs_pool_len = 16 + strlen(lpd->lpd_fsname) + strlen(lpd->lpd_poolname);
3480         snprintf(pool_filter, fs_pool_len + 1, "fsname: %s, pool: %s",
3481                  lpd->lpd_fsname, lpd->lpd_poolname);
3482
3483         /* search poolname */
3484         found = strstr(record, pool_filter);
3485         if (found &&
3486             (found[fs_pool_len] == ' ' || found[fs_pool_len] == ',')) {
3487                 if (strstr(record, new_pool)) {
3488                         lpd->lpd_pool_exists = true;
3489                         rc = 1;
3490                         goto out;
3491                 }
3492                 if (strstr(record, del_pool)) {
3493                         lpd->lpd_pool_exists = false;
3494                         rc = -ENOENT;
3495                         goto out;
3496                 }
3497
3498                 if (lpd->lpd_cmd_type == LCFG_POOL_NEW ||
3499                     lpd->lpd_cmd_type == LCFG_POOL_DEL) {
3500                         if (strstr(record, add_pool))
3501                                 lpd->lpd_ost_num++;
3502                         if (strstr(record, rem_pool))
3503                                 lpd->lpd_ost_num--;
3504                 } else if (lpd->lpd_ostname && lpd->lpd_ostname[0]) {
3505                         if (strstr(record, lpd->lpd_ostname)) {
3506                                 lpd->lpd_pool_exists = true;
3507                                 if (strstr(record, add_pool)) {
3508                                         lpd->lpd_ost_num = 1;
3509                                         rc = 1;
3510                                         goto out;
3511                                 }
3512                                 if (strstr(record, rem_pool)) {
3513                                         lpd->lpd_ost_num = 0;
3514                                         rc = -ENOENT;
3515                                         goto out;
3516                                 }
3517                         }
3518                 }
3519         }
3520 out:
3521         if (new_pool)
3522                 free(new_pool);
3523         if (del_pool)
3524                 free(del_pool);
3525         if (add_pool)
3526                 free(add_pool);
3527         if (rem_pool)
3528                 free(rem_pool);
3529
3530         return rc;
3531 }
3532
3533 /* Search pool and its ost in llog
3534  *
3535  * \param logname[in]           pointer to config log name
3536  * \param last_index[in]        the index of the last llog record
3537  * \param fsname[in]            pointer to filesystem name
3538  * \param poolname[in]          pointer pool name
3539  * \param ostname[in]           pointer to OST name(OSTnnnn-UUID)
3540  * \param cmd[in]               pool command type
3541  *
3542  * \retval                      < 0 on error
3543  *                              0 if pool is empty or OST is not found
3544  *                              1 if pool is not empty or OST is found
3545  */
3546 static int llog_search_pool(char *logname, long last_index, char *fsname,
3547                             char *poolname, char *ostname,
3548                             enum lcfg_command_type cmd)
3549 {
3550         struct llog_pool_data lpd;
3551         long start, end, inc = MAX_IOC_BUFLEN / 128;
3552         int rc = 0;
3553
3554         memset(&lpd, 0, sizeof(lpd));
3555         lpd.lpd_cmd_type = cmd;
3556         lpd.lpd_pool_exists = false;
3557         lpd.lpd_ost_num = 0;
3558         strncpy(lpd.lpd_fsname, fsname, sizeof(lpd.lpd_fsname) - 1);
3559         if (poolname && poolname[0])
3560                 strncpy(lpd.lpd_poolname, poolname,
3561                         sizeof(lpd.lpd_poolname) - 1);
3562         if (ostname && ostname[0])
3563                 strncpy(lpd.lpd_ostname, ostname, sizeof(lpd.lpd_ostname) - 1);
3564
3565         for (end = last_index; end > 1; end -= inc) {
3566                 start = end - inc > 0 ? end - inc : 1;
3567                 rc = jt_llog_print_iter(logname, start, end,
3568                                         llog_search_pool_cb, &lpd, true);
3569                 if (rc) {
3570                         if (rc == 1 && lpd.lpd_pool_exists)
3571                                 rc = lpd.lpd_ost_num ? 1 : 0;
3572                         else if (rc == -ENOENT && lpd.lpd_pool_exists &&
3573                                  !lpd.lpd_ost_num)
3574                                 rc = 0;
3575                         goto out;
3576                 }
3577         }
3578
3579         rc = -ENOENT;
3580 out:
3581         return rc;
3582 }
3583
3584 static bool combined_mgs_mds(char *fsname)
3585 {
3586         glob_t path;
3587         int rc;
3588
3589         rc = cfs_get_param_paths(&path, "mdt/%s-MDT0000", fsname);
3590         if (!rc)
3591                 cfs_free_param_data(&path);
3592
3593         if (get_mgs_device() > 0 && !rc)
3594                 return true;
3595
3596         return false;
3597 }
3598
3599 /*
3600  * if pool is NULL, search ostname in target_obd
3601  * if pool is not NULL:
3602  *  - if pool not found returns errno < 0
3603  *  - if ostname is NULL, returns 1 if pool is not empty and 0 if pool empty
3604  *  - if ostname is not NULL, returns 1 if OST is in pool and 0 if not
3605  */
3606 int lctl_search_ost(char *fsname, char *poolname, char *ostname,
3607                     enum lcfg_command_type cmd)
3608 {
3609         char logname[MAX_OBD_NAME] = {'\0'};
3610         long last_index;
3611
3612         if (fsname && fsname[0] == '\0')
3613                 fsname = NULL;
3614         if (!fsname)
3615                 return -EINVAL;
3616
3617         if (combined_mgs_mds(fsname))
3618                 return llapi_search_ost(fsname, poolname, ostname);
3619
3620         /* fetch the last_index of llog record */
3621         snprintf(logname, sizeof(logname), "%s-client", fsname);
3622         last_index = llog_last_index(logname);
3623         if (last_index < 0)
3624                 return last_index;
3625
3626         /* if pool is NULL, search ostname in target_obd */
3627         if (!poolname && ostname)
3628                 return llog_search_ost(logname, last_index, ostname);
3629
3630         return llog_search_pool(logname, last_index, fsname, poolname,
3631                                 ostname, cmd);
3632 }
3633
3634 static int check_pool_cmd(enum lcfg_command_type cmd, char *fsname,
3635                           char *poolname, char *ostname)
3636 {
3637         int rc;
3638
3639         rc = lctl_search_ost(fsname, poolname, ostname, cmd);
3640         if (rc < 0 && (cmd != LCFG_POOL_NEW)) {
3641                 fprintf(stderr, "Pool %s.%s not found\n",
3642                         fsname, poolname);
3643                 return rc;
3644         }
3645
3646         switch (cmd) {
3647         case LCFG_POOL_NEW: {
3648                 if (ostname)
3649                         return -EINVAL;
3650
3651                 if (rc >= 0) {
3652                         fprintf(stderr, "Pool %s.%s already exists\n",
3653                                 fsname, poolname);
3654                         return -EEXIST;
3655                 }
3656                 return 0;
3657         }
3658         case LCFG_POOL_DEL: {
3659                 if (ostname)
3660                         return -EINVAL;
3661
3662                 if (rc == 1) {
3663                         fprintf(stderr,
3664                                 "Pool %s.%s not empty, please remove all members\n",
3665                                 fsname, poolname);
3666                         return -ENOTEMPTY;
3667                 }
3668                 return 0;
3669         }
3670         case LCFG_POOL_ADD: {
3671                 if (rc == 1) {
3672                         fprintf(stderr, "OST %s is already in pool %s.%s\n",
3673                                 ostname, fsname, poolname);
3674                         return -EEXIST;
3675                 }
3676                 rc = lctl_search_ost(fsname, NULL, ostname, cmd);
3677                 if (rc == 0) {
3678                         fprintf(stderr, "OST %s is not part of the '%s' fs.\n",
3679                                 ostname, fsname);
3680                         return -ENOENT;
3681                 }
3682                 return 0;
3683         }
3684         case LCFG_POOL_REM: {
3685                 if (rc == 0) {
3686                         fprintf(stderr, "OST %s not found in pool %s.%s\n",
3687                                 ostname, fsname, poolname);
3688                         return -ENOENT;
3689                 }
3690                 return 0;
3691         }
3692         default:
3693                 break;
3694         } /* switch */
3695         return -EINVAL;
3696 }
3697
3698 /*
3699  * This check only verifies that the changes have been "pushed out" to
3700  * the client successfully.  This involves waiting for a config update,
3701  * and so may fail because of problems in that code or post-command
3702  * network loss. So reporting a warning is appropriate, but not a failure.
3703  */
3704 static int check_pool_cmd_result(enum lcfg_command_type cmd, char *fsname,
3705                                  char *poolname, char *ostname)
3706 {
3707         int cpt = 10;
3708         int rc = 0;
3709
3710         switch (cmd) {
3711         case LCFG_POOL_NEW: {
3712                 do {
3713                         rc = lctl_search_ost(fsname, poolname, NULL, cmd);
3714                         if (rc == -ENODEV)
3715                                 return rc;
3716                         if (rc < 0)
3717                                 sleep(1);
3718                         cpt--;
3719                 } while ((rc < 0) && (cpt > 0));
3720                 if (rc >= 0) {
3721                         fprintf(stderr, "Pool %s.%s created\n",
3722                                 fsname, poolname);
3723                         return 0;
3724                 }
3725
3726                 fprintf(stderr, "Warning, pool %s.%s not found\n", fsname,
3727                         poolname);
3728                 return -ENOENT;
3729         }
3730         case LCFG_POOL_DEL: {
3731                 do {
3732                         rc = lctl_search_ost(fsname, poolname, NULL, cmd);
3733                         if (rc == -ENODEV)
3734                                 return rc;
3735                         if (rc >= 0)
3736                                 sleep(1);
3737                         cpt--;
3738                 } while ((rc >= 0) && (cpt > 0));
3739                 if (rc < 0) {
3740                         fprintf(stderr, "Pool %s.%s destroyed\n",
3741                                 fsname, poolname);
3742                         return 0;
3743                 }
3744
3745                 fprintf(stderr, "Warning, pool %s.%s still found\n", fsname,
3746                         poolname);
3747                 return -EEXIST;
3748         }
3749         case LCFG_POOL_ADD: {
3750                 do {
3751                         rc = lctl_search_ost(fsname, poolname, ostname, cmd);
3752                         if (rc == -ENODEV)
3753                                 return rc;
3754                         if (rc != 1)
3755                                 sleep(1);
3756                         cpt--;
3757                 } while ((rc != 1) && (cpt > 0));
3758                 if (rc == 1) {
3759                         fprintf(stderr, "OST %s added to pool %s.%s\n",
3760                                 ostname, fsname, poolname);
3761                         return 0;
3762                 }
3763                 fprintf(stderr, "Warning, OST %s not found in pool %s.%s\n",
3764                         ostname, fsname, poolname);
3765                 return -ENOENT;
3766         }
3767         case LCFG_POOL_REM: {
3768                 do {
3769                         rc = lctl_search_ost(fsname, poolname, ostname, cmd);
3770                         if (rc == -ENODEV)
3771                                 return rc;
3772                         if (rc == 1)
3773                                 sleep(1);
3774                         cpt--;
3775                 } while ((rc == 1) && (cpt > 0));
3776                 if (rc != 1) {
3777                         fprintf(stderr, "OST %s removed from pool %s.%s\n",
3778                                 ostname, fsname, poolname);
3779                         return 0;
3780                 }
3781                 fprintf(stderr, "Warning, OST %s still found in pool %s.%s\n",
3782                         ostname, fsname, poolname);
3783                 return -EEXIST;
3784         }
3785         default:
3786                 break;
3787         }
3788         return -EINVAL;
3789 }
3790
3791 static int check_and_complete_ostname(char *fsname, char *ostname)
3792 {
3793         char *ptr;
3794         char real_ostname[MAX_OBD_NAME + 1];
3795         char i;
3796
3797         /* if OST name does not start with fsname, we add it */
3798         /* if not check if the fsname is the right one */
3799         ptr = strchr(ostname, '-');
3800         if (!ptr) {
3801                 sprintf(real_ostname, "%s-%s", fsname, ostname);
3802         } else if (strncmp(ostname, fsname, strlen(fsname)) != 0) {
3803                 fprintf(stderr, "%s does not start with fsname %s\n",
3804                         ostname, fsname);
3805                 return -EINVAL;
3806         } else {
3807                 if (strlen(ostname) > sizeof(real_ostname) - 1)
3808                         return -E2BIG;
3809
3810                 strncpy(real_ostname, ostname, sizeof(real_ostname));
3811         }
3812
3813         /* real_ostname is fsname-????? */
3814         ptr = real_ostname + strlen(fsname) + 1;
3815         if (strncmp(ptr, "OST", 3) != 0) {
3816                 fprintf(stderr, "%s does not start by %s-OST nor OST\n",
3817                         ostname, fsname);
3818                 return -EINVAL;
3819         }
3820         /* real_ostname is fsname-OST????? */
3821         ptr += 3;
3822         for (i = 0; i < 4; i++) {
3823                 if (!isxdigit(*ptr)) {
3824                         fprintf(stderr,
3825                                 "ost's index in %s is not an hexa number\n",
3826                                 ostname);
3827                         return -EINVAL;
3828                 }
3829                 ptr++;
3830         }
3831         /* real_ostname is fsname-OSTXXXX????? */
3832         /* if OST name does not end with _UUID, we add it */
3833         if (*ptr == '\0') {
3834                 strcat(real_ostname, "_UUID");
3835         } else if (strcmp(ptr, "_UUID") != 0) {
3836                 fprintf(stderr,
3837                         "ostname %s does not end with _UUID\n", ostname);
3838                 return -EINVAL;
3839         }
3840         /* real_ostname is fsname-OSTXXXX_UUID */
3841         strcpy(ostname, real_ostname);
3842         return 0;
3843 }
3844
3845 /* returns 0 or -errno */
3846 static int pool_cmd(enum lcfg_command_type cmd, char *cmdname,
3847                     char *fullpoolname, char *fsname, char *poolname,
3848                     char *ostname)
3849 {
3850         int rc = 0;
3851         struct obd_ioctl_data data;
3852         struct lustre_cfg_bufs bufs;
3853         struct lustre_cfg *lcfg;
3854         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
3855
3856         rc = check_pool_cmd(cmd, fsname, poolname, ostname);
3857         if (rc == -ENODEV)
3858                 fprintf(stderr,
3859                         "Can't verify pool command since there is no local MDT or client, proceeding anyhow...\n");
3860         else if (rc)
3861                 return rc;
3862
3863         lustre_cfg_bufs_reset(&bufs, NULL);
3864         lustre_cfg_bufs_set_string(&bufs, 0, cmdname);
3865         lustre_cfg_bufs_set_string(&bufs, 1, fullpoolname);
3866         if (ostname)
3867                 lustre_cfg_bufs_set_string(&bufs, 2, ostname);
3868
3869         lcfg = malloc(lustre_cfg_len(bufs.lcfg_bufcount, bufs.lcfg_buflen));
3870         if (!lcfg)
3871                 return -ENOMEM;
3872         lustre_cfg_init(lcfg, cmd, &bufs);
3873
3874         memset(&data, 0, sizeof(data));
3875         rc = data.ioc_dev = get_mgs_device();
3876         if (rc < 0)
3877                 goto out;
3878
3879         data.ioc_type = LUSTRE_CFG_TYPE;
3880         data.ioc_plen1 = lustre_cfg_len(lcfg->lcfg_bufcount,
3881                                         lcfg->lcfg_buflens);
3882         data.ioc_pbuf1 = (void *)lcfg;
3883
3884         memset(buf, 0, sizeof(rawbuf));
3885         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
3886         if (rc) {
3887                 fprintf(stderr, "error: %s: invalid ioctl\n",
3888                         jt_cmdname(cmdname));
3889                 free(lcfg);
3890                 return rc;
3891         }
3892         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_POOL, buf);
3893 out:
3894         if (rc)
3895                 rc = -errno;
3896         switch (rc) {
3897         case -ENAMETOOLONG:
3898                 fprintf(stderr,
3899                         "error: %s: either the pool or file system name is too long (max pool name len is %d and file system name is %d)\n",
3900                         jt_cmdname(cmdname), LOV_MAXPOOLNAME, LUSTRE_MAXFSNAME);
3901                 break;
3902         case -EINVAL:
3903                 fprintf(stderr,
3904                         "error: %s can contain only alphanumeric characters, underscores, and dashes besides the required '.'\n",
3905                         jt_cmdname(cmdname));
3906         default:
3907                 break;
3908         }
3909         free(lcfg);
3910         return rc;
3911 }
3912
3913 #ifdef HAVE_SERVER_SUPPORT
3914 /**
3915  * Format and send the ioctl to the MGS.
3916  *
3917  * \param       cmd             IOCTL to send
3918  * \param       ret_data        void pointer to return anything from
3919  *                              ioctl
3920  * \param       num_args        number of arguments to pack into the
3921  *                              ioctl buffer
3922  * \param       argv[]          variable number of string arguments
3923  *
3924  * \retval                      0 on success
3925  */
3926 static int nodemap_cmd(enum lcfg_command_type cmd, void *ret_data,
3927                        unsigned int ret_size, ...)
3928 {
3929         va_list                 ap;
3930         char                    *arg;
3931         int                     i = 0;
3932         struct lustre_cfg_bufs  bufs;
3933         struct obd_ioctl_data   data;
3934         struct lustre_cfg       *lcfg;
3935         char                    rawbuf[MAX_IOC_BUFLEN];
3936         char                    *buf = rawbuf;
3937         int                     rc = 0;
3938
3939         lustre_cfg_bufs_reset(&bufs, NULL);
3940
3941         va_start(ap, ret_size);
3942         arg = va_arg(ap, char *);
3943         while (arg) {
3944                 lustre_cfg_bufs_set_string(&bufs, i, arg);
3945                 i++;
3946                 arg = va_arg(ap, char *);
3947         }
3948         va_end(ap);
3949
3950         lcfg = malloc(lustre_cfg_len(bufs.lcfg_bufcount, bufs.lcfg_buflen));
3951         if (!lcfg)
3952                 return -ENOMEM;
3953         lustre_cfg_init(lcfg, cmd, &bufs);
3954
3955         memset(&data, 0, sizeof(data));
3956         rc = data.ioc_dev = get_mgs_device();
3957         if (rc < 0)
3958                 goto out;
3959
3960         data.ioc_type = LUSTRE_CFG_TYPE;
3961         data.ioc_plen1 = lustre_cfg_len(lcfg->lcfg_bufcount,
3962                                         lcfg->lcfg_buflens);
3963         data.ioc_pbuf1 = (void *)lcfg;
3964
3965         memset(buf, 0, sizeof(rawbuf));
3966         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
3967         if (rc != 0) {
3968                 fprintf(stderr,
3969                         "error: invalid ioctl: %08x errno: %d with rc=%d\n",
3970                         cmd, errno, rc);
3971                 goto out;
3972         }
3973
3974         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_NODEMAP, buf);
3975         if (rc != 0) {
3976                 fprintf(stderr,
3977                         "error: invalid ioctl: %08x errno: %d with rc=%d\n",
3978                         cmd, errno, rc);
3979                 goto out;
3980         }
3981
3982         if (ret_data) {
3983                 rc = llapi_ioctl_unpack(&data, buf, sizeof(rawbuf));
3984                 if (rc != 0)
3985                         goto out;
3986
3987                 if (ret_size > data.ioc_plen1)
3988                         ret_size = data.ioc_plen1;
3989
3990                 memcpy(ret_data, data.ioc_pbuf1, ret_size);
3991         }
3992 out:
3993         free(lcfg);
3994
3995         return rc;
3996 }
3997
3998 /**
3999  * activate nodemap functions
4000  *
4001  * \param       argc            number of args
4002  * \param       argv[]          variable string arguments
4003  *
4004  * argv[0]                      1 for activate or 0 for deactivate
4005  *
4006  * \retval                      0 on success
4007  */
4008 int jt_nodemap_activate(int argc, char **argv)
4009 {
4010         int rc;
4011
4012         rc = nodemap_cmd(LCFG_NODEMAP_ACTIVATE, NULL, 0, argv[0], argv[1],
4013                          NULL);
4014
4015         if (rc != 0) {
4016                 errno = -rc;
4017                 perror(argv[0]);
4018         }
4019
4020         return rc;
4021 }
4022
4023 /**
4024  * add a nodemap
4025  *
4026  * \param       argc            number of args
4027  * \param       argv[]          variable string arguments
4028  *
4029  * argv[0]                      nodemap name
4030  *
4031  * \retval                      0 on success
4032  */
4033 int jt_nodemap_add(int argc, char **argv)
4034 {
4035         int rc;
4036
4037         rc = llapi_nodemap_exists(argv[1]);
4038         if (rc == 0) {
4039                 fprintf(stderr, "error: %s existing nodemap name\n", argv[1]);
4040                 return 1;
4041         }
4042
4043         rc = nodemap_cmd(LCFG_NODEMAP_ADD, NULL, 0, argv[0], argv[1], NULL);
4044
4045         if (rc != 0) {
4046                 errno = -rc;
4047                 perror(argv[0]);
4048         }
4049
4050         return rc;
4051 }
4052
4053 /**
4054  * delete a nodemap
4055  *
4056  * \param       argc            number of args
4057  * \param       argv[]          variable string arguments
4058  *
4059  * argv[0]                      nodemap name
4060  *
4061  * \retval                      0 on success
4062  */
4063 int jt_nodemap_del(int argc, char **argv)
4064 {
4065         int rc;
4066
4067         rc = llapi_nodemap_exists(argv[1]);
4068         if (rc != 0) {
4069                 fprintf(stderr, "error: %s not existing nodemap name\n",
4070                         argv[1]);
4071                 return rc;
4072         }
4073         rc = nodemap_cmd(LCFG_NODEMAP_DEL, NULL, 0, argv[0], argv[1], NULL);
4074
4075         if (rc != 0) {
4076                 errno = -rc;
4077                 perror(argv[0]);
4078         }
4079
4080         return rc;
4081 }
4082
4083 /**
4084  * test a nid for nodemap membership
4085  *
4086  * \param       argc            number of args
4087  * \param       argv[]          variable string arguments
4088  *
4089  * argv[0]                      properly formatted nid
4090  *
4091  * \retval                      0 on success
4092  */
4093 int jt_nodemap_test_nid(int argc, char **argv)
4094 {
4095         char    rawbuf[MAX_IOC_BUFLEN];
4096         int     rc;
4097
4098         rc = nodemap_cmd(LCFG_NODEMAP_TEST_NID, &rawbuf, sizeof(rawbuf),
4099                          argv[0], argv[1], NULL);
4100         if (rc == 0)
4101                 printf("%s\n", (char *)rawbuf);
4102
4103         return rc;
4104 }
4105
4106 /**
4107  * test a nodemap id pair for mapping
4108  *
4109  * \param       argc            number of args
4110  * \param       argv[[]         variable string arguments
4111  *
4112  * \retval                      0 on success
4113  *
4114  * The argv array should contain the nodemap name, the id
4115  * to checking the mapping on, and the id type (UID or GID)
4116  *
4117  */
4118 int jt_nodemap_test_id(int argc, char **argv)
4119 {
4120         char    rawbuf[MAX_IOC_BUFLEN];
4121         char    *nidstr = NULL;
4122         char    *idstr = NULL;
4123         char    *typestr = NULL;
4124         int     rc = 0;
4125         int     c;
4126
4127         static struct option long_opts[] = {
4128                 { .val = 'i',   .name = "id",   .has_arg = required_argument },
4129                 { .val = 'n',   .name = "nid",  .has_arg = required_argument },
4130                 { .val = 't',   .name = "idtype",
4131                                                 .has_arg = required_argument },
4132                 { .name = NULL } };
4133
4134         while ((c = getopt_long(argc, argv, "n:t:i:",
4135                                 long_opts, NULL)) != -1) {
4136                 switch (c) {
4137                 case 'n':
4138                         nidstr = optarg;
4139                         break;
4140                 case 't':
4141                         typestr = optarg;
4142                         break;
4143                 case 'i':
4144                         idstr = optarg;
4145                         break;
4146                 }
4147         }
4148
4149         if (!nidstr || !typestr || !idstr) {
4150                 fprintf(stderr,
4151                         "usage: nodemap_test_id --nid <nid> --idtype [uid|gid] --id <id>\n");
4152                 return -1;
4153         }
4154
4155         rc = nodemap_cmd(LCFG_NODEMAP_TEST_ID, &rawbuf, sizeof(rawbuf),
4156                          argv[0], nidstr, typestr, idstr);
4157         if (rc == 0)
4158                 printf("%s\n", (char *)rawbuf);
4159
4160         return rc;
4161 }
4162
4163 /**
4164  * parse nid range
4165  *
4166  * \param       nodemap_range   --range string
4167  * \param       nid_range       nid range string, min_nid:max_nid
4168  *
4169  * \retval                      0 on success
4170  */
4171 static int parse_nid_range(char *nodemap_range, char *nid_range, int range_len)
4172 {
4173         char                    min_nid[LNET_NIDSTR_SIZE + 1];
4174         char                    max_nid[LNET_NIDSTR_SIZE + 1];
4175         struct list_head        nidlist;
4176         int                     rc = 0;
4177
4178         INIT_LIST_HEAD(&nidlist);
4179
4180         if (cfs_parse_nidlist(nodemap_range, strlen(nodemap_range),
4181                               &nidlist) <= 0) {
4182                 fprintf(stderr,
4183                         "error: nodemap_xxx_range: can't parse nid range: %s\n",
4184                         nodemap_range);
4185                 return -1;
4186         }
4187
4188         rc = cfs_nidrange_find_min_max(&nidlist, &min_nid[0], &max_nid[0],
4189                                        LNET_NIDSTR_SIZE);
4190         if (rc < 0) {
4191                 if (rc == -EINVAL)
4192                         fprintf(stderr,
4193                                 "error: nodemap_xxx_range: nid range uses currently unsupported features\n");
4194                 else if (rc == -ERANGE)
4195                         fprintf(stderr,
4196                                 "error: nodemap_xxx_range: nodemap ranges must be contiguous\n");
4197
4198                 return rc;
4199         }
4200
4201         snprintf(nid_range, range_len, "%s:%s", min_nid, max_nid);
4202
4203         return rc;
4204 }
4205
4206 /**
4207  * add an nid range to a nodemap
4208  *
4209  * \param       argc            number of args
4210  * \param       argv[]          variable string arguments
4211  *
4212  * --name                       nodemap name
4213  * --range                      properly formatted nid range
4214  *
4215  * \retval                      0 on success
4216  */
4217 int jt_nodemap_add_range(int argc, char **argv)
4218 {
4219         char                    *nodemap_name = NULL;
4220         char                    *nodemap_range = NULL;
4221         char                    nid_range[2 * LNET_NIDSTR_SIZE + 2];
4222         int                     rc = 0;
4223         int                     c;
4224
4225         static struct option long_opts[] = {
4226         { .val = 'n',   .name = "name",         .has_arg = required_argument },
4227         { .val = 'r',   .name = "range",        .has_arg = required_argument },
4228         { .name = NULL } };
4229
4230         while ((c = getopt_long(argc, argv, "n:r:",
4231                                 long_opts, NULL)) != -1) {
4232                 switch (c) {
4233                 case 'n':
4234                         nodemap_name = optarg;
4235                         break;
4236                 case 'r':
4237                         nodemap_range = optarg;
4238                         break;
4239                 }
4240         }
4241
4242         if (!nodemap_name || !nodemap_range) {
4243                 fprintf(stderr,
4244                         "usage: nodemap_add_range --name <name> --range <range>\n");
4245                 return -1;
4246         }
4247
4248         rc = parse_nid_range(nodemap_range, nid_range, sizeof(nid_range));
4249         if (rc) {
4250                 errno = -rc;
4251                 return rc;
4252         }
4253         rc = nodemap_cmd(LCFG_NODEMAP_ADD_RANGE, NULL, 0, argv[0],
4254                          nodemap_name, nid_range, NULL);
4255         if (rc != 0) {
4256                 errno = -rc;
4257                 fprintf(stderr,
4258                         "error: %s: cannot add range '%s' to nodemap '%s': rc = %d\n",
4259                         jt_cmdname(argv[0]), nodemap_range, nodemap_name, rc);
4260         }
4261
4262         return rc;
4263 }
4264
4265 /**
4266  * delete an nid range to a nodemap
4267  *
4268  * \param       argc            number of args
4269  * \param       argv[]          variable string arguments
4270  *
4271  * --name                       nodemap name
4272  * --range                      properly formatted nid range
4273  *
4274  * \retval                      0 on success
4275  */
4276 int jt_nodemap_del_range(int argc, char **argv)
4277 {
4278         char                    *nodemap_name = NULL;
4279         char                    *nodemap_range = NULL;
4280         char                    nid_range[2 * LNET_NIDSTR_SIZE + 2];
4281         int                     rc = 0;
4282         int                     c;
4283
4284         static struct option long_opts[] = {
4285         { .val = 'n',   .name = "name",         .has_arg = required_argument },
4286         { .val = 'r',   .name = "range",        .has_arg = required_argument },
4287         { .name = NULL } };
4288
4289         while ((c = getopt_long(argc, argv, "n:r:",
4290                                 long_opts, NULL)) != -1) {
4291                 switch (c) {
4292                 case 'n':
4293                         nodemap_name = optarg;
4294                         break;
4295                 case 'r':
4296                         nodemap_range = optarg;
4297                         break;
4298                 }
4299         }
4300
4301         if (!nodemap_name || !nodemap_range) {
4302                 fprintf(stderr,
4303                         "usage: nodemap_del_range --name <name> --range <range>\n");
4304                 return -1;
4305         }
4306
4307         rc = parse_nid_range(nodemap_range, nid_range, sizeof(nid_range));
4308         if (rc) {
4309                 errno = -rc;
4310                 return rc;
4311         }
4312         rc = nodemap_cmd(LCFG_NODEMAP_DEL_RANGE, NULL, 0, argv[0],
4313                          nodemap_name, nid_range, NULL);
4314         if (rc != 0) {
4315                 errno = -rc;
4316                 fprintf(stderr,
4317                         "error: %s: cannot delete range '%s' to nodemap '%s': rc = %d\n",
4318                         jt_cmdname(argv[0]), nodemap_range, nodemap_name, rc);
4319         }
4320
4321         return rc;
4322 }
4323
4324 /**
4325  * set a fileset on a nodemap
4326  *
4327  * \param       argc            number of args
4328  * \param       argv[]          variable string arguments
4329  *
4330  * --name                       nodemap name
4331  * --fileset                    fileset name
4332  *
4333  * \retval                      0 on success
4334  */
4335 int jt_nodemap_set_fileset(int argc, char **argv)
4336 {
4337         char *nodemap_name = NULL;
4338         char *fileset_name = NULL;
4339         int   rc = 0;
4340         int   c;
4341
4342         static struct option long_opts[] = {
4343         { .val = 'f',   .name = "fileset",      .has_arg = required_argument },
4344         { .val = 'n',   .name = "name",         .has_arg = required_argument },
4345         { .name = NULL } };
4346
4347         while ((c = getopt_long(argc, argv, "n:f:",
4348                                 long_opts, NULL)) != -1) {
4349                 switch (c) {
4350                 case 'n':
4351                         nodemap_name = optarg;
4352                         break;
4353                 case 'f':
4354                         fileset_name = optarg;
4355                         break;
4356                 }
4357         }
4358
4359         if (!nodemap_name || !fileset_name) {
4360                 fprintf(stderr,
4361                         "usage: nodemap_set_fileset --name <name> --fileset <fileset>\n");
4362                 return -1;
4363         }
4364
4365         rc = nodemap_cmd(LCFG_NODEMAP_SET_FILESET, NULL, 0, argv[0],
4366                          nodemap_name, fileset_name, NULL);
4367         if (rc != 0) {
4368                 errno = -rc;
4369                 fprintf(stderr,
4370                         "error: %s: cannot set fileset '%s' on nodemap '%s': rc = %d\n",
4371                         jt_cmdname(argv[0]), fileset_name, nodemap_name, rc);
4372         }
4373
4374         return rc;
4375 }
4376
4377 /**
4378  * set SELinux policy info on a nodemap
4379  *
4380  * \param       argc            number of args
4381  * \param       argv[]          variable string arguments
4382  *
4383  * --name                       nodemap name
4384  * --sepol                      SELinux policy info
4385  *
4386  * \retval                      0 on success
4387  */
4388 int jt_nodemap_set_sepol(int argc, char **argv)
4389 {
4390         char *nodemap_name = NULL;
4391         char *sepol = NULL;
4392         int   rc = 0;
4393         int   c;
4394
4395         static struct option long_options[] = {
4396                 {
4397                         .name           = "name",
4398                         .has_arg        = required_argument,
4399                         .val            = 'n',
4400                 },
4401                 {
4402                         .name           = "sepol",
4403                         .has_arg        = required_argument,
4404                         .val            = 's',
4405                 },
4406                 {
4407                         .name = NULL,
4408                 }
4409         };
4410
4411         while ((c = getopt_long(argc, argv, "n:s:",
4412                                 long_options, NULL)) != -1) {
4413                 switch (c) {
4414                 case 'n':
4415                         nodemap_name = optarg;
4416                         break;
4417                 case 's':
4418                         sepol = optarg;
4419                         break;
4420                 }
4421         }
4422
4423         if (!nodemap_name || !sepol) {
4424                 fprintf(stderr,
4425                         "usage: nodemap_set_sepol --name <name> --sepol <sepol>\n");
4426                 return -1;
4427         }
4428
4429         rc = nodemap_cmd(LCFG_NODEMAP_SET_SEPOL, NULL, 0, argv[0],
4430                          nodemap_name, sepol, NULL);
4431         if (rc != 0) {
4432                 errno = -rc;
4433                 fprintf(stderr,
4434                         "error: %s: cannot set sepol '%s' on nodemap '%s': rc = %d\n",
4435                         jt_cmdname(argv[0]), sepol, nodemap_name, rc);
4436         }
4437
4438         return rc;
4439 }
4440
4441 /**
4442  * modify a nodemap's behavior
4443  *
4444  * \param       argc            number of args
4445  * \param       argv[]          variable string arguments
4446  *
4447  * --name                       nodemap name
4448  * --property                   nodemap property to change
4449  *                              admin, trusted, squash_uid, squash_gid)
4450  * --value                      value to set property
4451  *
4452  * \retval                      0 on success
4453  */
4454 int jt_nodemap_modify(int argc, char **argv)
4455 {
4456         int                     c;
4457         int                     rc = 0;
4458         enum lcfg_command_type  cmd = 0;
4459         char                    *nodemap_name = NULL;
4460         char                    *param = NULL;
4461         char                    *value = NULL;
4462
4463         static struct option long_opts[] = {
4464         { .val = 'n',   .name = "name",         .has_arg = required_argument },
4465         { .val = 'p',   .name = "property",     .has_arg = required_argument },
4466         { .val = 'v',   .name = "value",        .has_arg = required_argument },
4467         { .name = NULL } };
4468
4469         while ((c = getopt_long(argc, argv, "n:p:v:",
4470                                 long_opts, NULL)) != -1) {
4471                 switch (c) {
4472                 case 'n':
4473                         nodemap_name = optarg;
4474                         break;
4475                 case 'p':
4476                         param = optarg;
4477                         break;
4478                 case 'v':
4479                         value = optarg;
4480                         break;
4481                 }
4482         }
4483
4484         if (!nodemap_name || !param || !value) {
4485                 fprintf(stderr,
4486                         "usage: nodemap_modify --name <nodemap_name> --property <property_name> --value <value>\n");
4487                 fprintf(stderr,
4488                         "valid properties: admin trusted map_mode squash_uid squash_gid deny_unknown audit_mode forbid_encryption\n");
4489                 return -1;
4490         }
4491
4492         if (strcmp("admin", param) == 0) {
4493                 cmd = LCFG_NODEMAP_ADMIN;
4494         } else if (strcmp("trusted", param) == 0) {
4495                 cmd = LCFG_NODEMAP_TRUSTED;
4496         } else if (strcmp("deny_unknown", param) == 0) {
4497                 cmd = LCFG_NODEMAP_DENY_UNKNOWN;
4498         } else if (strcmp("squash_uid", param) == 0) {
4499                 cmd = LCFG_NODEMAP_SQUASH_UID;
4500         } else if (strcmp("squash_gid", param) == 0) {
4501                 cmd = LCFG_NODEMAP_SQUASH_GID;
4502         } else if (strcmp("map_mode", param) == 0) {
4503                 cmd = LCFG_NODEMAP_MAP_MODE;
4504         } else if (strcmp("audit_mode", param) == 0) {
4505                 cmd = LCFG_NODEMAP_AUDIT_MODE;
4506         } else if (strcmp("forbid_encryption", param) == 0) {
4507                 cmd = LCFG_NODEMAP_FORBID_ENCRYPT;
4508         } else {
4509                 fprintf(stderr,
4510                         "error: %s: nodemap_modify invalid subcommand: %s\n",
4511                         jt_cmdname(argv[0]), param);
4512                 return -1;
4513         }
4514
4515         rc = nodemap_cmd(cmd, NULL, 0, argv[0], nodemap_name, param,
4516                          value, NULL);
4517         if (rc != 0) {
4518                 errno = -rc;
4519                 fprintf(stderr,
4520                         "error: %s: cannot modify nodemap '%s' to param '%s': value '%s': rc = %d\n",
4521                         jt_cmdname(argv[0]), nodemap_name, param, value, rc);
4522         }
4523
4524         return rc;
4525 }
4526
4527 int jt_nodemap_add_idmap(int argc, char **argv)
4528 {
4529         int                     c;
4530         enum                    lcfg_command_type cmd = 0;
4531         char                    *nodemap_name = NULL;
4532         char                    *idmap = NULL;
4533         char                    *idtype = NULL;
4534         int                     rc = 0;
4535
4536         static struct option long_opts[] = {
4537         { .val = 'i',   .name = "idtype",       .has_arg = required_argument },
4538         { .val = 'm',   .name = "idmap",        .has_arg = required_argument },
4539         { .val = 'n',   .name = "name",         .has_arg = required_argument },
4540         { .name = NULL } };
4541
4542         while ((c = getopt_long(argc, argv, "n:m:i:",
4543                                 long_opts, NULL)) != -1) {
4544                 switch (c) {
4545                 case 'n':
4546                         nodemap_name = optarg;
4547                         break;
4548                 case 'm':
4549                         idmap = optarg;
4550                         break;
4551                 case 'i':
4552                         idtype = optarg;
4553                         break;
4554                 }
4555         }
4556
4557         if (!nodemap_name || !idmap || !idtype) {
4558                 fprintf(stderr,
4559                         "usage: %s --name <name> --idtype [uid | gid] --idmap <client id>:<filesystem id>\n",
4560                         argv[0]);
4561                 return -1;
4562         }
4563
4564         if (strcmp("uid", idtype) == 0) {
4565                 cmd = LCFG_NODEMAP_ADD_UIDMAP;
4566         } else if (strcmp("gid", idtype) == 0) {
4567                 cmd = LCFG_NODEMAP_ADD_GIDMAP;
4568         } else {
4569                 fprintf(stderr,
4570                         "usage: %s --name <name> --idtype [uid | gid] --idmap <client id>:<filesystem id>\n",
4571                         argv[0]);
4572                 return -1;
4573         }
4574
4575         rc = nodemap_cmd(cmd, NULL, 0, argv[0], nodemap_name, idmap, NULL);
4576         if (rc != 0) {
4577                 errno = -rc;
4578                 fprintf(stderr,
4579                         "cannot add %smap '%s' to nodemap '%s': rc = %d\n",
4580                         idtype, idmap, nodemap_name, rc);
4581         }
4582
4583         return rc;
4584 }
4585
4586 int jt_nodemap_del_idmap(int argc, char **argv)
4587 {
4588         int                     c;
4589         enum                    lcfg_command_type cmd = 0;
4590         char                    *nodemap_name = NULL;
4591         char                    *idmap = NULL;
4592         char                    *idtype = NULL;
4593         int                     rc = 0;
4594
4595         static struct option long_opts[] = {
4596         { .val = 'i',   .name = "idtype",       .has_arg = required_argument },
4597         { .val = 'm',   .name = "idmap",        .has_arg = required_argument },
4598         { .val = 'n',   .name = "name",         .has_arg = required_argument },
4599         { .name = NULL } };
4600
4601         while ((c = getopt_long(argc, argv, "n:m:i:",
4602                                 long_opts, NULL)) != -1) {
4603                 switch (c) {
4604                 case 'n':
4605                         nodemap_name = optarg;
4606                         break;
4607                 case 'm':
4608                         idmap = optarg;
4609                         break;
4610                 case 'i':
4611                         idtype = optarg;
4612                         break;
4613                 }
4614         }
4615
4616         if (!nodemap_name || !idmap || !idtype) {
4617                 fprintf(stderr,
4618                         "usage: %s --name <name> --idtype [uid | gid] --idmap <client id>:<filesystem id>\n",
4619                         argv[0]);
4620                 return -1;
4621         }
4622
4623         if (strcmp("uid", idtype) == 0)
4624                 cmd = LCFG_NODEMAP_DEL_UIDMAP;
4625         else
4626                 cmd = LCFG_NODEMAP_DEL_GIDMAP;
4627
4628         rc = nodemap_cmd(cmd, NULL, 0, argv[0], nodemap_name, idmap, NULL);
4629         if (rc != 0) {
4630                 errno = -rc;
4631                 fprintf(stderr,
4632                         "cannot delete %smap '%s' from nodemap '%s': rc = %d\n",
4633                         idtype, idmap, nodemap_name, rc);
4634         }
4635
4636         return rc;
4637 }
4638 #else /* !HAVE_SERVER_SUPPORT */
4639 int jt_nodemap_activate(int argc, char **argv)
4640 {
4641         fprintf(stderr, "error: %s: invalid ioctl\n",
4642                 jt_cmdname(argv[0]));
4643         return -EOPNOTSUPP;
4644 }
4645
4646 int jt_nodemap_add(int argc, char **argv)
4647 {
4648         fprintf(stderr, "error: %s: invalid ioctl\n",
4649                 jt_cmdname(argv[0]));
4650         return -EOPNOTSUPP;
4651 }
4652
4653 int jt_nodemap_del(int argc, char **argv)
4654 {
4655         fprintf(stderr, "error: %s: invalid ioctl\n",
4656                 jt_cmdname(argv[0]));
4657         return -EOPNOTSUPP;
4658 }
4659
4660 int jt_nodemap_modify(int argc, char **argv)
4661 {
4662         fprintf(stderr, "error: %s: invalid ioctl\n",
4663                 jt_cmdname(argv[0]));
4664         return -EOPNOTSUPP;
4665 }
4666
4667 int jt_nodemap_add_range(int argc, char **argv)
4668 {
4669         fprintf(stderr, "error: %s: invalid ioctl\n",
4670                 jt_cmdname(argv[0]));
4671         return -EOPNOTSUPP;
4672 }
4673
4674 int jt_nodemap_test_nid(int argc, char **argv)
4675 {
4676         fprintf(stderr, "error: %s: invalid ioctl\n",
4677                 jt_cmdname(argv[0]));
4678         return -EOPNOTSUPP;
4679 }
4680
4681 int jt_nodemap_del_range(int argc, char **argv)
4682 {
4683         fprintf(stderr, "error: %s: invalid ioctl\n",
4684                 jt_cmdname(argv[0]));
4685         return -EOPNOTSUPP;
4686 }
4687
4688 int jt_nodemap_add_idmap(int argc, char **argv)
4689 {
4690         fprintf(stderr, "error: %s: invalid ioctl\n",
4691                 jt_cmdname(argv[0]));
4692         return -EOPNOTSUPP;
4693 }
4694
4695 int jt_nodemap_del_idmap(int argc, char **argv)
4696 {
4697         fprintf(stderr, "error: %s: invalid ioctl\n",
4698                 jt_cmdname(argv[0]));
4699         return -EOPNOTSUPP;
4700 }
4701
4702 int jt_nodemap_test_id(int argc, char **argv)
4703 {
4704         fprintf(stderr, "error: %s: invalid ioctl\n",
4705                 jt_cmdname(argv[0]));
4706         return -EOPNOTSUPP;
4707 }
4708
4709 int jt_nodemap_set_fileset(int argc, char **argv)
4710 {
4711         fprintf(stderr, "error: %s: invalid ioctl\n",
4712                 jt_cmdname(argv[0]));
4713         return -EOPNOTSUPP;
4714 }
4715
4716 int jt_nodemap_set_sepol(int argc, char **argv)
4717 {
4718         fprintf(stderr, "error: %s: invalid ioctl\n",
4719                 jt_cmdname(argv[0]));
4720         return -EOPNOTSUPP;
4721 }
4722
4723 int jt_nodemap_info(int argc, char **argv)
4724 {
4725         fprintf(stderr, "error: %s: invalid ioctl\n",
4726                 jt_cmdname(argv[0]));
4727         return -EOPNOTSUPP;
4728 }
4729 #endif /* HAVE_SERVER_SUPPORT */
4730
4731 /*
4732  * this function tranforms a rule [start-end/step] into an array
4733  * of matching numbers
4734  * supported forms are:
4735  * [start]                : just this number
4736  * [start-end]            : all numbers from start to end
4737  * [start-end/step]       : numbers from start to end with increment of step
4738  * on return, format contains a printf format string which can be used
4739  * to generate all the strings
4740  */
4741 static int get_array_idx(char *rule, char *format, int **array)
4742 {
4743         char *start, *end, *ptr;
4744         unsigned int lo, hi, step;
4745         int array_sz = 0;
4746         int i, array_idx;
4747         int rc;
4748
4749         start = strchr(rule, '[');
4750         end = strchr(rule, ']');
4751         if ((!start) || (!end)) {
4752                 *array = malloc(sizeof(int));
4753                 if (!*array)
4754                         return 0;
4755                 strcpy(format, rule);
4756                 array_sz = 1;
4757                 return array_sz;
4758         }
4759         *start = '\0';
4760         *end = '\0';
4761         end++;
4762         start++;
4763         /* put in format the printf format (the rule without the range) */
4764         sprintf(format, "%s%%.4x%s", rule, end);
4765
4766         array_idx = 0;
4767         array_sz = 0;
4768         *array = NULL;
4769         /* loop on , separator */
4770         do {
4771                 /* extract the 3 fields */
4772                 rc = sscanf(start, "%x-%x/%u", &lo, &hi, &step);
4773                 switch (rc) {
4774                 case 0:
4775                         goto err;
4776                 case 1: {
4777                         void *tmp;
4778
4779                         array_sz++;
4780                         tmp = realloc(*array, array_sz * sizeof(int));
4781                         if (!tmp)
4782                                 goto err;
4783                         *array = tmp;
4784                         (*array)[array_idx] = lo;
4785                         array_idx++;
4786                         break;
4787                 }
4788                 case 2: {
4789                         step = 1;
4790                         /* do not break to share code with case 3: */
4791                 }
4792                 case 3: {
4793                         void *tmp;
4794
4795                         if ((hi < lo) || (step == 0))
4796                                 goto err;
4797                         array_sz += (hi - lo) / step + 1;
4798                         tmp = realloc(*array, array_sz * sizeof(int));
4799                         if (!tmp)
4800                                 goto err;
4801                         *array = tmp;
4802                         for (i = lo; i <= hi; i += step, array_idx++)
4803                                 (*array)[array_idx] = i;
4804                         break;
4805                 }
4806                 }
4807                 ptr = strchr(start, ',');
4808                 if (ptr)
4809                         start = ptr + 1;
4810
4811         } while (ptr);
4812         return array_sz;
4813 err:
4814         if (*array) {
4815                 free(*array);
4816                 *array = NULL;
4817         }
4818         return 0;
4819 }
4820
4821 struct llog_pool_name {
4822         char lpn_name[UUID_MAX];
4823         struct list_head lpn_list;
4824 };
4825
4826 struct llog_pool_list_data {
4827         char lpld_fsname[LUSTRE_MAXFSNAME + 1];
4828         char lpld_poolname[LOV_MAXPOOLNAME + 1];
4829         bool lpld_exists;
4830         struct list_head lpld_list_head;
4831 };
4832
4833 /**
4834  * Callback to list pool information in llog
4835  * - { index: 74, event: new_pool, device: tfs-clilov, fsname: tfs, pool: tmp }
4836  * - { index: 77, event: add_pool, device: tfs-clilov, fsname: tfs, pool: tmp,
4837  *     ost: tfs-OST0000_UUID }
4838  * - { index: 224, event: remove_pool, device: tfs-clilov, fsname: tfs,
4839  *     pool: tmp, ost: tfs-OST0003_UUID }
4840  * - { index: 227, event: del_pool, device: tfs-clilov, fsname: tfs, pool: tmp }
4841  *
4842  * \param record[in]    pointer to llog record
4843  * \param data[in]      pointer to struct llog_pool_list_data
4844  *
4845  * \retval              0 on success
4846  *                      <0 on error
4847  */
4848 static int llog_poollist_cb(const char *record, void *data)
4849 {
4850         struct llog_pool_list_data *lpld = data;
4851         char pool_filter[MAX_STRING_SIZE] = "";
4852         char *new_record, *del_record, *del_pool, *found;
4853         char type[10] = "";
4854         int filter_len, rc = 0;
4855
4856         filter_len = snprintf(pool_filter, sizeof(pool_filter), " fsname: %s,",
4857                               lpld->lpld_fsname);
4858         if (lpld->lpld_poolname[0] == '\0') {
4859                 new_record = get_event_filter(LCFG_POOL_NEW);
4860                 del_record = get_event_filter(LCFG_POOL_DEL);
4861                 strncpy(type, " pool: ", sizeof(type));
4862         } else {
4863                 filter_len += snprintf(pool_filter + filter_len,
4864                                        sizeof(pool_filter) - filter_len,
4865                                        " pool: %s", lpld->lpld_poolname);
4866                 new_record = get_event_filter(LCFG_POOL_ADD);
4867                 del_record = get_event_filter(LCFG_POOL_REM);
4868                 strncpy(type, " ost: ", sizeof(type));
4869         }
4870         del_pool = get_event_filter(LCFG_POOL_DEL);
4871
4872         if (!new_record || !del_record || !del_pool) {
4873                 rc = -ENOMEM;
4874                 goto out;
4875         }
4876
4877         found = strstr(record, pool_filter);
4878         if (found &&
4879             (found[filter_len] == ' ' || found[filter_len] == ',')) {
4880                 struct llog_pool_name *tmp = NULL;
4881                 struct list_head *head = &lpld->lpld_list_head;
4882                 char *name;
4883                 int name_len, type_len = strlen(type);
4884
4885                 lpld->lpld_exists = true;
4886                 if (strstr(record, new_record)) {
4887                         name = strstr(record, type);
4888                         /* 2 bytes for " }" */
4889                         name_len = strlen(name) - type_len - 2;
4890                         if (name_len <= 0 || name_len > sizeof(tmp->lpn_name))
4891                                 return -EINVAL;
4892                         tmp = malloc(sizeof(struct llog_pool_name));
4893                         if (!tmp) {
4894                                 rc = -ENOMEM;
4895                                 goto out;
4896                         }
4897                         memset(tmp, 0, sizeof(struct llog_pool_name));
4898                         strncpy(tmp->lpn_name, name + type_len, name_len);
4899                         list_add_tail(&tmp->lpn_list, &lpld->lpld_list_head);
4900                 } else if (strstr(record, del_record)) {
4901                         name = strstr(record, type);
4902                         name_len = strlen(name) - type_len - 2;
4903                         list_for_each_entry(tmp, head, lpn_list) {
4904                                 if (strncmp(tmp->lpn_name, name + type_len,
4905                                             name_len) == 0 &&
4906                                             tmp->lpn_name[name_len] == '\0') {
4907                                         list_del(&tmp->lpn_list);
4908                                         free(tmp);
4909                                         break;
4910                                 }
4911                         }
4912                 }
4913                 /* verify if the specified pool still exists */
4914                 if (lpld->lpld_poolname[0] && strstr(record, del_pool))
4915                         lpld->lpld_exists = false;
4916         }
4917 out:
4918         if (new_record)
4919                 free(new_record);
4920         if (del_record)
4921                 free(del_record);
4922         if (del_pool)
4923                 free(del_pool);
4924
4925         return rc;
4926 }
4927
4928 /**
4929  * List pool information by config log
4930  *
4931  * \param fsname[in]    pointer to filesystem name
4932  * \param poolname[in]  pointer to pool name
4933  *
4934  * \retval              0 on success
4935  *                      < 0 on error
4936  */
4937 int llog_poollist(char *fsname, char *poolname)
4938 {
4939         char logname[MAX_OBD_NAME] = {'\0'};
4940         struct llog_pool_list_data lpld;
4941         struct llog_pool_name *tmp;
4942         struct list_head *head;
4943         int rc = 0;
4944
4945         if (fsname && fsname[0] == '\0')
4946                 fsname = NULL;
4947         if (!fsname)
4948                 return -EINVAL;
4949
4950         memset(&lpld, 0, sizeof(lpld));
4951         INIT_LIST_HEAD(&lpld.lpld_list_head);
4952         lpld.lpld_exists = false;
4953         strncpy(lpld.lpld_fsname, fsname, sizeof(lpld.lpld_fsname) - 1);
4954         if (poolname && poolname[0])
4955                 strncpy(lpld.lpld_poolname, poolname,
4956                         sizeof(lpld.lpld_poolname) - 1);
4957         snprintf(logname, sizeof(logname), "%s-client", fsname);
4958         rc = jt_llog_print_iter(logname, 0, -1, llog_poollist_cb, &lpld, false);
4959
4960         if (poolname && poolname[0])
4961                 printf("Pool: %s.%s\n", fsname, poolname);
4962         else
4963                 printf("Pools from %s:\n", fsname);
4964
4965         head = &lpld.lpld_list_head;
4966         if (poolname && poolname[0] && !lpld.lpld_exists && list_empty(head))
4967                 return -ENOENT;
4968
4969         list_for_each_entry(tmp, head, lpn_list) {
4970                 if (poolname && poolname[0])
4971                         printf("%s\n", tmp->lpn_name);
4972                 else
4973                         printf("%s.%s\n", fsname, tmp->lpn_name);
4974                 list_del(&tmp->lpn_list);
4975                 free(tmp);
4976         }
4977
4978         return rc;
4979 }
4980
4981 static bool get_pools_path(char *fsname)
4982 {
4983         glob_t path;
4984         int rc;
4985
4986         rc = cfs_get_param_paths(&path, "lov/%s-*/pools", fsname);
4987         if (!rc)
4988                 cfs_free_param_data(&path);
4989
4990         return (rc == 0);
4991 }
4992
4993 static int extract_fsname_poolname(char **argv, char *fsname,
4994                                    char *poolname)
4995 {
4996         char *cmd = argv[0], *param = argv[1];
4997         char *ptr;
4998         int rc;
4999
5000         snprintf(fsname, PATH_MAX + 1, "%s", param);
5001         ptr = strchr(fsname, '.');
5002         if (!ptr) {
5003                 if (strcmp(cmd, "pool_list") == 0) {
5004                         poolname = NULL;
5005                         goto out;
5006                 }
5007                 fprintf(stderr, ". is missing in %s\n", fsname);
5008                 rc = -EINVAL;
5009                 goto err;
5010         }
5011
5012         if ((ptr - fsname) == 0) {
5013                 fprintf(stderr, "fsname is empty\n");
5014                 rc = -EINVAL;
5015                 goto err;
5016         }
5017
5018         *ptr = '\0';
5019         ++ptr;
5020
5021         if (strlen(ptr) == 0) {
5022                 fprintf(stderr, "poolname is empty\n");
5023                 rc = -EINVAL;
5024                 goto err;
5025         }
5026
5027         strncpy(poolname, ptr, LOV_MAXPOOLNAME);
5028         poolname[LOV_MAXPOOLNAME] = '\0';
5029
5030         if (strncmp(poolname, "none", LOV_MAXPOOLNAME) == 0) {
5031                 fprintf(stderr, "poolname cannot be 'none'\n");
5032                 return -EINVAL;
5033         }
5034 out:
5035         return 0;
5036
5037 err:
5038         fprintf(stderr, "argument %s must be <fsname>.<poolname>\n", param);
5039         return rc;
5040 }
5041
5042 int jt_pool_cmd(int argc, char **argv)
5043 {
5044         enum lcfg_command_type cmd;
5045         char fsname[PATH_MAX + 1];
5046         char poolname[LOV_MAXPOOLNAME + 1];
5047         char *ostnames_buf = NULL;
5048         int i, rc;
5049         int *array = NULL, array_sz;
5050         struct {
5051                 int     rc;
5052                 char   *ostname;
5053         } *cmds = NULL;
5054
5055         switch (argc) {
5056         case 0:
5057         case 1: return CMD_HELP;
5058         case 2: {
5059                 rc = extract_fsname_poolname(argv, fsname, poolname);
5060                 if (rc)
5061                         break;
5062
5063                 if (strcmp("pool_new", argv[0]) == 0) {
5064                         cmd = LCFG_POOL_NEW;
5065                 } else if (strcmp("pool_destroy", argv[0]) == 0) {
5066                         cmd = LCFG_POOL_DEL;
5067                 } else if (strcmp("pool_list", argv[0]) == 0) {
5068                         if (get_pools_path(fsname))
5069                                 return llapi_poollist(argv[1]);
5070                         if (get_mgs_device() > 0)
5071                                 return llog_poollist(fsname, poolname);
5072                         fprintf(stderr,
5073                                 "Cannot run pool_list command since there is no local MGS/MDT or client\n");
5074                         return CMD_HELP;
5075                 } else {
5076                         return CMD_HELP;
5077                 }
5078
5079                 rc = pool_cmd(cmd, argv[0], argv[1], fsname, poolname, NULL);
5080                 if (rc)
5081                         break;
5082
5083                 check_pool_cmd_result(cmd, fsname, poolname, NULL);
5084                 break;
5085         }
5086         default: {
5087                 char format[2 * MAX_OBD_NAME];
5088
5089                 if (strcmp("pool_remove", argv[0]) == 0)
5090                         cmd = LCFG_POOL_REM;
5091                 else if (strcmp("pool_add", argv[0]) == 0)
5092                         cmd = LCFG_POOL_ADD;
5093                 else
5094                         return CMD_HELP;
5095
5096                 rc = extract_fsname_poolname(argv, fsname, poolname);
5097                 if (rc)
5098                         break;
5099
5100                 for (i = 2; i < argc; i++) {
5101                         int j;
5102
5103                         array_sz = get_array_idx(argv[i], format, &array);
5104                         if (array_sz == 0)
5105                                 return CMD_HELP;
5106
5107                         cmds = malloc(array_sz * sizeof(cmds[0]));
5108                         if (cmds) {
5109                                 ostnames_buf = malloc(array_sz *
5110                                                       (MAX_OBD_NAME + 1));
5111                         } else {
5112                                 free(array);
5113                                 rc = -ENOMEM;
5114                                 goto out;
5115                         }
5116
5117                         for (j = 0; j < array_sz; j++) {
5118                                 char ostname[MAX_OBD_NAME + 1];
5119                                 int rc2;
5120
5121                                 snprintf(ostname, MAX_OBD_NAME, format,
5122                                          array[j]);
5123                                 ostname[MAX_OBD_NAME] = '\0';
5124
5125                                 rc2 = check_and_complete_ostname(fsname,
5126                                                                 ostname);
5127                                 if (rc2) {
5128                                         free(array);
5129                                         free(cmds);
5130                                         if (ostnames_buf)
5131                                                 free(ostnames_buf);
5132                                         rc = rc ? rc : rc2;
5133                                         goto out;
5134                                 }
5135                                 if (ostnames_buf) {
5136                                         cmds[j].ostname =
5137                                         &ostnames_buf[(MAX_OBD_NAME + 1) * j];
5138                                         strcpy(cmds[j].ostname, ostname);
5139                                 } else {
5140                                         cmds[j].ostname = NULL;
5141                                 }
5142                                 cmds[j].rc = pool_cmd(cmd, argv[0], argv[1],
5143                                                       fsname, poolname,
5144                                                       ostname);
5145                                 /* Return an err if any of the add/dels fail */
5146                                 if (!rc)
5147                                         rc = cmds[j].rc;
5148                         }
5149                         for (j = 0; j < array_sz; j++) {
5150                                 if (!cmds[j].rc) {
5151                                         char ostname[MAX_OBD_NAME + 1];
5152
5153                                         if (!cmds[j].ostname) {
5154                                                 snprintf(ostname, MAX_OBD_NAME,
5155                                                          format, array[j]);
5156                                                 ostname[MAX_OBD_NAME] = '\0';
5157                                                 check_and_complete_ostname(
5158                                                         fsname, ostname);
5159                                         } else {
5160                                                 strcpy(ostname,
5161                                                        cmds[j].ostname);
5162                                         }
5163                                         check_pool_cmd_result(cmd, fsname,
5164                                                               poolname,
5165                                                               ostname);
5166                                 }
5167                         }
5168                         if (array_sz > 0)
5169                                 free(array);
5170                         if (cmds)
5171                                 free(cmds);
5172                         if (ostnames_buf)
5173                                 free(ostnames_buf);
5174                 }
5175                 /* fall through */
5176         }
5177         } /* switch */
5178
5179 out:
5180         if (rc != 0) {
5181                 errno = -rc;
5182                 perror(argv[0]);
5183         }
5184
5185         return rc;
5186 }
5187
5188 #ifdef HAVE_SERVER_SUPPORT
5189 static const char *barrier_status2name(enum barrier_status status)
5190 {
5191         switch (status) {
5192         case BS_INIT:
5193                 return "init";
5194         case BS_FREEZING_P1:
5195                 return "freezing_p1";
5196         case BS_FREEZING_P2:
5197                 return "freezing_p2";
5198         case BS_FROZEN:
5199                 return "frozen";
5200         case BS_THAWING:
5201                 return "thawing";
5202         case BS_THAWED:
5203                 return "thawed";
5204         case BS_FAILED:
5205                 return "failed";
5206         case BS_EXPIRED:
5207                 return "expired";
5208         case BS_RESCAN:
5209                 return "rescan";
5210         default:
5211                 return "unknown";
5212         }
5213 }
5214
5215 int jt_barrier_freeze(int argc, char **argv)
5216 {
5217         struct obd_ioctl_data data;
5218         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
5219         struct barrier_ctl bc;
5220         int rc;
5221
5222         if (argc < 2 || argc > 3)
5223                 return CMD_HELP;
5224
5225         memset(&data, 0, sizeof(data));
5226         rc = data.ioc_dev = get_mgs_device();
5227         if (rc < 0)
5228                 return rc;
5229
5230         memset(&bc, 0, sizeof(bc));
5231         bc.bc_version = BARRIER_VERSION_V1;
5232         bc.bc_cmd = BC_FREEZE;
5233         if (argc == 3)
5234                 bc.bc_timeout = atoi(argv[2]);
5235         if (bc.bc_timeout == 0)
5236                 bc.bc_timeout = BARRIER_TIMEOUT_DEFAULT;
5237
5238         if (strlen(argv[1]) > 8) {
5239                 fprintf(stderr,
5240                         "%s: fsname name %s is too long. It should not exceed 8.\n",
5241                         argv[0], argv[1]);
5242                 return -EINVAL;
5243         }
5244
5245         strncpy(bc.bc_name, argv[1], sizeof(bc.bc_name));
5246         data.ioc_inlbuf1 = (char *)&bc;
5247         data.ioc_inllen1 = sizeof(bc);
5248         memset(buf, 0, sizeof(rawbuf));
5249         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
5250         if (rc) {
5251                 fprintf(stderr, "Fail to pack ioctl data: rc = %d.\n", rc);
5252                 return rc;
5253         }
5254
5255         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_BARRIER, buf);
5256         if (rc < 0)
5257                 fprintf(stderr, "Fail to freeze barrier for %s: %s\n",
5258                         argv[1], strerror(errno));
5259
5260         return rc;
5261 }
5262
5263 int jt_barrier_thaw(int argc, char **argv)
5264 {
5265         struct obd_ioctl_data data;
5266         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
5267         struct barrier_ctl bc;
5268         int rc;
5269
5270         if (argc != 2)
5271                 return CMD_HELP;
5272
5273         memset(&data, 0, sizeof(data));
5274         rc = data.ioc_dev = get_mgs_device();
5275         if (rc < 0)
5276                 return rc;
5277
5278         memset(&bc, 0, sizeof(bc));
5279         bc.bc_version = BARRIER_VERSION_V1;
5280         bc.bc_cmd = BC_THAW;
5281
5282         if (strlen(argv[1]) > 8) {
5283                 fprintf(stderr,
5284                         "fsname name %s is too long. It should not exceed 8.\n",
5285                         argv[1]);
5286                 return -EINVAL;
5287         }
5288
5289         strncpy(bc.bc_name, argv[1], sizeof(bc.bc_name));
5290         data.ioc_inlbuf1 = (char *)&bc;
5291         data.ioc_inllen1 = sizeof(bc);
5292         memset(buf, 0, sizeof(rawbuf));
5293         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
5294         if (rc) {
5295                 fprintf(stderr, "Fail to pack ioctl data: rc = %d.\n", rc);
5296                 return rc;
5297         }
5298
5299         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_BARRIER, buf);
5300         if (rc < 0)
5301                 fprintf(stderr, "Fail to thaw barrier for %s: %s\n",
5302                         argv[1], strerror(errno));
5303
5304         return rc;
5305 }
5306
5307 int __jt_barrier_stat(const char *fsname, struct barrier_ctl *bc)
5308 {
5309         struct obd_ioctl_data data;
5310         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
5311         int rc;
5312
5313         memset(&data, 0, sizeof(data));
5314         rc = data.ioc_dev = get_mgs_device();
5315         if (rc < 0)
5316                 return rc;
5317
5318         memset(bc, 0, sizeof(*bc));
5319         bc->bc_version = BARRIER_VERSION_V1;
5320         bc->bc_cmd = BC_STAT;
5321         strncpy(bc->bc_name, fsname, sizeof(bc->bc_name) - 1);
5322         data.ioc_inlbuf1 = (char *)bc;
5323         data.ioc_inllen1 = sizeof(*bc);
5324         memset(buf, 0, sizeof(rawbuf));
5325         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
5326         if (rc) {
5327                 fprintf(stderr, "Fail to pack ioctl data: rc = %d.\n", rc);
5328                 return rc;
5329         }
5330
5331         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_BARRIER, buf);
5332         if (rc < 0)
5333                 fprintf(stderr, "Fail to query barrier for %s: %s\n",
5334                         fsname, strerror(errno));
5335         else
5336                 llapi_ioctl_unpack(&data, buf, sizeof(rawbuf));
5337
5338         return rc;
5339 }
5340
5341 int jt_barrier_stat(int argc, char **argv)
5342 {
5343         struct barrier_ctl bc;
5344         static struct option long_opt_barrier_stat[] = {
5345                 {
5346                         .val            = 's',
5347                         .name           = "state",
5348                         .has_arg        = no_argument,
5349                 },
5350                 {       .val            = 't',
5351                         .name           = "timeout",
5352                         .has_arg        = no_argument,
5353                 },
5354                 {
5355                         NULL
5356                 }
5357         };
5358         const char *name;
5359         int index;
5360         int opt;
5361         int rc;
5362         bool state = false;
5363         bool timeout = false;
5364
5365         while ((opt = getopt_long(argc, argv, "st", long_opt_barrier_stat,
5366                                   &index)) != EOF) {
5367                 switch (opt) {
5368                 case 's':
5369                         state = true;
5370                         break;
5371                 case 't':
5372                         timeout = true;
5373                         break;
5374                 default:
5375                         return CMD_HELP;
5376                 }
5377         }
5378
5379         if (optind >= argc)
5380                 return CMD_HELP;
5381
5382         name = argv[optind];
5383         if (strlen(name) > 8) {
5384                 fprintf(stderr,
5385                         "fsname name %s is too long. It should not exceed 8.\n",
5386                         name);
5387                 return -EINVAL;
5388         }
5389
5390         rc = __jt_barrier_stat(name, &bc);
5391         if (!rc) {
5392                 if (state && !timeout)
5393                         printf("%s\n", barrier_status2name(bc.bc_status));
5394                 else if (timeout && !state)
5395                         printf("%d\n",
5396                                (bc.bc_status == BS_FREEZING_P1 ||
5397                                 bc.bc_status == BS_FREEZING_P2 ||
5398                                 bc.bc_status == BS_FROZEN) ?
5399                                bc.bc_timeout : 0);
5400                 else
5401                         printf("state: %s\ntimeout: %d seconds\n",
5402                                barrier_status2name(bc.bc_status),
5403                                (bc.bc_status == BS_FREEZING_P1 ||
5404                                 bc.bc_status == BS_FREEZING_P2 ||
5405                                 bc.bc_status == BS_FROZEN) ?
5406                                bc.bc_timeout : 0);
5407         }
5408
5409         return rc;
5410 }
5411
5412 int jt_barrier_rescan(int argc, char **argv)
5413 {
5414         struct obd_ioctl_data data;
5415         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf;
5416         struct barrier_ctl bc;
5417         int rc;
5418
5419         if (argc < 2 || argc > 3)
5420                 return CMD_HELP;
5421
5422         memset(&data, 0, sizeof(data));
5423         rc = data.ioc_dev = get_mgs_device();
5424         if (rc < 0)
5425                 return rc;
5426
5427         memset(&bc, 0, sizeof(bc));
5428         bc.bc_version = BARRIER_VERSION_V1;
5429         bc.bc_cmd = BC_RESCAN;
5430         if (argc == 3)
5431                 bc.bc_timeout = atoi(argv[2]);
5432         if (bc.bc_timeout == 0)
5433                 bc.bc_timeout = BARRIER_TIMEOUT_DEFAULT;
5434
5435         if (strlen(argv[1]) > 8) {
5436                 fprintf(stderr,
5437                         "fsname name %s is too long. It should not exceed 8.\n",
5438                         argv[1]);
5439                 return -EINVAL;
5440         }
5441
5442         strncpy(bc.bc_name, argv[1], sizeof(bc.bc_name));
5443         data.ioc_inlbuf1 = (char *)&bc;
5444         data.ioc_inllen1 = sizeof(bc);
5445         memset(buf, 0, sizeof(rawbuf));
5446         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
5447         if (rc) {
5448                 fprintf(stderr, "Fail to pack ioctl data: rc = %d.\n", rc);
5449                 return rc;
5450         }
5451
5452         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_BARRIER, buf);
5453         if (rc < 0) {
5454                 fprintf(stderr, "Fail to rescan barrier bitmap for %s: %s\n",
5455                         argv[1], strerror(errno));
5456         } else {
5457                 llapi_ioctl_unpack(&data, buf, sizeof(rawbuf));
5458                 printf("%u of %u MDT(s) in the filesystem %s are inactive\n",
5459                        bc.bc_absence, bc.bc_total, argv[1]);
5460         }
5461
5462         return rc;
5463 }
5464 #endif /* HAVE_SERVER_SUPPORT */
5465
5466 int jt_get_obj_version(int argc, char **argv)
5467 {
5468         struct lu_fid fid;
5469         struct obd_ioctl_data data;
5470         __u64 version, id = ULLONG_MAX, group = ULLONG_MAX;
5471         char rawbuf[MAX_IOC_BUFLEN], *buf = rawbuf, *fidstr;
5472         int rc, c;
5473
5474         while ((c = getopt(argc, argv, "i:g:")) != -1) {
5475                 switch (c) {
5476                 case 'i':
5477                         id = strtoull(optarg, NULL, 0);
5478                         break;
5479                 case 'g':
5480                         group = strtoull(optarg, NULL, 0);
5481                         break;
5482                 default:
5483                         return CMD_HELP;
5484                 }
5485         }
5486
5487         argc -= optind;
5488         fidstr = *(argv + optind);
5489
5490         if (!(id != ULLONG_MAX && group != ULLONG_MAX && argc == 0) &&
5491             !(id == ULLONG_MAX && group == ULLONG_MAX && argc == 1))
5492                 return CMD_HELP;
5493
5494         memset(&data, 0, sizeof(data));
5495         data.ioc_dev = cur_device;
5496         if (argc == 1) {
5497                 rc = llapi_fid_parse(fidstr, &fid, NULL);
5498                 if (rc) {
5499                         fprintf(stderr, "%s: error parsing FID '%s': %s\n",
5500                                 jt_cmdname(argv[0]), fidstr, strerror(-rc));
5501                         return rc;
5502                 }
5503
5504                 data.ioc_inlbuf1 = (char *)&fid;
5505                 data.ioc_inllen1 = sizeof(fid);
5506         } else {
5507                 data.ioc_inlbuf3 = (char *)&id;
5508                 data.ioc_inllen3 = sizeof(id);
5509                 data.ioc_inlbuf4 = (char *)&group;
5510                 data.ioc_inllen4 = sizeof(group);
5511         }
5512         data.ioc_inlbuf2 = (char *)&version;
5513         data.ioc_inllen2 = sizeof(version);
5514
5515         memset(buf, 0, sizeof(*buf));
5516         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
5517         if (rc) {
5518                 fprintf(stderr, "error: %s: packing ioctl arguments: %s\n",
5519                         jt_cmdname(argv[0]), strerror(-rc));
5520                 return rc;
5521         }
5522
5523         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_GET_OBJ_VERSION, buf);
5524         if (rc == -1) {
5525                 fprintf(stderr, "error: %s: ioctl: %s\n",
5526                         jt_cmdname(argv[0]), strerror(errno));
5527                 return -errno;
5528         }
5529
5530         llapi_ioctl_unpack(&data, buf, sizeof(rawbuf));
5531         printf("%#jx\n", (uintmax_t)version);
5532
5533         return 0;
5534 }
5535
5536 #ifdef HAVE_SERVER_SUPPORT
5537 int jt_changelog_register(int argc, char **argv)
5538 {
5539         struct obd_ioctl_data    data = { 0 };
5540         char                     rawbuf[MAX_IOC_BUFLEN] = "";
5541         char                    *buf = rawbuf;
5542         char                    *device = lcfg_get_devname();
5543         bool                     print_name_only = false;
5544         int                      c;
5545         int                      rc;
5546
5547         if (argc > 2)
5548                 return CMD_HELP;
5549
5550         while ((c = getopt(argc, argv, "hn")) >= 0) {
5551                 switch (c) {
5552                 case 'n':
5553                         print_name_only = true;
5554                         break;
5555                 case 'h':
5556                 default:
5557                         return CMD_HELP;
5558                 }
5559         }
5560
5561         if (cur_device < 0 || !device)
5562                 return CMD_HELP;
5563
5564         data.ioc_dev = cur_device;
5565
5566         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
5567         if (rc < 0) {
5568                 fprintf(stderr, "error: %s: cannot pack ioctl: %s\n",
5569                         jt_cmdname(argv[0]), strerror(-rc));
5570                 return rc;
5571         }
5572
5573         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_CHANGELOG_REG, buf);
5574         if (rc < 0) {
5575                 rc = -errno;
5576                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
5577                         strerror(-rc));
5578                 return rc;
5579         }
5580
5581         llapi_ioctl_unpack(&data, buf, sizeof(rawbuf));
5582
5583         if (data.ioc_u32_1 == 0) {
5584                 fprintf(stderr, "received invalid userid!\n");
5585                 return -EPROTO;
5586         }
5587
5588         if (print_name_only)
5589                 printf("%s%u\n", CHANGELOG_USER_PREFIX, data.ioc_u32_1);
5590         else
5591                 printf("%s: Registered changelog userid '%s%u'\n",
5592                        device, CHANGELOG_USER_PREFIX, data.ioc_u32_1);
5593
5594         return 0;
5595 }
5596
5597 int jt_changelog_deregister(int argc, char **argv)
5598 {
5599         struct obd_ioctl_data    data = { 0 };
5600         char                     rawbuf[MAX_IOC_BUFLEN] = "";
5601         char                    *buf = rawbuf;
5602         char                    *device = lcfg_get_devname();
5603         int                      id;
5604         int                      rc;
5605
5606         if (argc != 2 || cur_device < 0 || !device)
5607                 return CMD_HELP;
5608
5609         rc = sscanf(argv[1], CHANGELOG_USER_PREFIX"%d", &id);
5610         if (rc != 1 || id <= 0) {
5611                 fprintf(stderr,
5612                         "error: %s: expected id of the form %s<num> got '%s'\n",
5613                         jt_cmdname(argv[0]), CHANGELOG_USER_PREFIX, argv[1]);
5614                 return CMD_HELP;
5615         }
5616
5617         data.ioc_dev = cur_device;
5618         data.ioc_u32_1 = id;
5619
5620         rc = llapi_ioctl_pack(&data, &buf, sizeof(rawbuf));
5621         if (rc < 0) {
5622                 fprintf(stderr, "error: %s: invalid ioctl\n",
5623                         jt_cmdname(argv[0]));
5624                 return rc;
5625         }
5626
5627         rc = l_ioctl(OBD_DEV_ID, OBD_IOC_CHANGELOG_DEREG, buf);
5628         if (rc < 0) {
5629                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
5630                         strerror(rc = errno));
5631                 return rc;
5632         }
5633
5634         llapi_ioctl_unpack(&data, buf, sizeof(rawbuf));
5635         printf("%s: Deregistered changelog user '%s%u'\n",
5636                device, CHANGELOG_USER_PREFIX, data.ioc_u32_1);
5637
5638         return 0;
5639 }
5640 #else /* !HAVE_SERVER_SUPPORT */
5641 int jt_changelog_register(int argc, char **argv)
5642 {
5643         fprintf(stderr, "error: %s: invalid ioctl\n",
5644                 jt_cmdname(argv[0]));
5645         return -EOPNOTSUPP;
5646 }
5647
5648 int jt_changelog_deregister(int argc, char **argv)
5649 {
5650         fprintf(stderr, "error: %s: invalid ioctl\n",
5651                 jt_cmdname(argv[0]));
5652         return -EOPNOTSUPP;
5653 }
5654 #endif /* HAVE_SERVER_SUPPORT */
5655
5656 int jt_pcc_add(int argc, char **argv)
5657 {
5658         struct option long_opts[] = {
5659                 { .val = 'p', .name = "param", .has_arg = required_argument },
5660                 { .name = NULL } };
5661         const char *mntpath;
5662         const char *pccpath;
5663         char *param = NULL;
5664         char cmd[PATH_MAX];
5665         int rc;
5666
5667         optind = 1;
5668         while ((rc = getopt_long(argc, argv, "p:", long_opts, NULL)) != -1) {
5669                 switch (rc) {
5670                 case 'p':
5671                         param = optarg;
5672                         break;
5673                 default:
5674                         return CMD_HELP;
5675                 }
5676         }
5677
5678         if (!param) {
5679                 fprintf(stderr, "%s: must specify the config param for PCC\n",
5680                         jt_cmdname(argv[0]));
5681                 return CMD_HELP;
5682         }
5683
5684         if (optind + 2 != argc) {
5685                 fprintf(stderr,
5686                         "%s: must specify mount path and PCC path %d:%d\n",
5687                         jt_cmdname(argv[0]), optind, argc);
5688                 return CMD_HELP;
5689         }
5690
5691         mntpath = argv[optind++];
5692         pccpath = argv[optind];
5693
5694         snprintf(cmd, PATH_MAX, "add %s %s", pccpath, param);
5695         rc = llapi_pccdev_set(mntpath, cmd);
5696         if (rc < 0)
5697                 fprintf(stderr, "%s: failed to run '%s' on %s\n",
5698                         jt_cmdname(argv[0]), cmd, mntpath);
5699
5700         return rc;
5701 }
5702
5703 int jt_pcc_del(int argc, char **argv)
5704 {
5705         const char *mntpath;
5706         const char *pccpath;
5707         char cmd[PATH_MAX];
5708         int rc;
5709
5710         optind = 1;
5711         if (argc != 3) {
5712                 fprintf(stderr, "%s: require 3 arguments\n",
5713                         jt_cmdname(argv[0]));
5714                 return CMD_HELP;
5715         }
5716
5717         mntpath = argv[optind++];
5718         pccpath = argv[optind++];
5719
5720         snprintf(cmd, PATH_MAX, "del %s", pccpath);
5721         rc = llapi_pccdev_set(mntpath, cmd);
5722         if (rc < 0)
5723                 fprintf(stderr, "%s: failed to run '%s' on %s\n",
5724                         jt_cmdname(argv[0]), cmd, mntpath);
5725
5726         return rc;
5727 }
5728
5729 int jt_pcc_clear(int argc, char **argv)
5730 {
5731         const char *mntpath;
5732         int rc;
5733
5734         optind = 1;
5735         if (argc != 2) {
5736                 fprintf(stderr, "%s: require 2 arguments\n",
5737                         jt_cmdname(argv[0]));
5738                 return CMD_HELP;
5739         }
5740
5741         mntpath = argv[optind];
5742         rc = llapi_pccdev_set(mntpath, "clear");
5743         if (rc < 0)
5744                 fprintf(stderr, "%s: failed to run 'clear' on %s\n",
5745                         jt_cmdname(argv[0]), mntpath);
5746
5747         return rc;
5748 }
5749
5750 int jt_pcc_list(int argc, char **argv)
5751 {
5752         const char *mntpath;
5753         int rc;
5754
5755         optind = 1;
5756         if (argc != 2) {
5757                 fprintf(stderr, "%s: require 2 arguments\n",
5758                         jt_cmdname(argv[0]));
5759                 return CMD_HELP;
5760         }
5761
5762         mntpath = argv[optind];
5763         rc = llapi_pccdev_get(mntpath);
5764         if (rc < 0)
5765                 fprintf(stderr, "%s: failed to run 'pcc list' on %s\n",
5766                         jt_cmdname(argv[0]), mntpath);
5767
5768         return rc;
5769 }