lustre/utils/obd.c

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