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