lustre/utils/lustre_cfg.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (C) 2002 Cluster File Systems, Inc.
   5  *   Author: Peter J. Braam <braam@clusterfs.com>
   6  *   Author: Phil Schwan <phil@clusterfs.com>
   7  *   Author: Andreas Dilger <adilger@clusterfs.com>
   8  *   Author: Robert Read <rread@clusterfs.com>
   9  *
  10  *   This file is part of Lustre, http://www.lustre.org.
  11  *
  12  *   Lustre is free software; you can redistribute it and/or
  13  *   modify it under the terms of version 2 of the GNU General Public
  14  *   License as published by the Free Software Foundation.
  15  *
  16  *   Lustre is distributed in the hope that it will be useful,
  17  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *   GNU General Public License for more details.
  20  *
  21  *   You should have received a copy of the GNU General Public License
  22  *   along with Lustre; if not, write to the Free Software
  23  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24  *
  25  */
  26
  27
  28 #include <stdlib.h>
  29 #include <sys/ioctl.h>
  30 #include <stdio.h>
  31 #include <stdarg.h>
  32
  33 #ifndef __KERNEL__
  34 #include <liblustre.h>
  35 #endif
  36 #include <linux/lustre_lib.h>
  37 #include <linux/lustre_cfg.h>
  38 #include <linux/lustre_idl.h>
  39 #include <linux/lustre_dlm.h>
  40 #include <linux/obd.h>          /* for struct lov_stripe_md */
  41 #include <linux/lustre_build_version.h>
  42
  43 #include <unistd.h>
  44 #include <sys/un.h>
  45 #include <time.h>
  46 #include <sys/time.h>
  47 #include <errno.h>
  48 #include <string.h>
  49
  50
  51 #include "obdctl.h"
  52 #include <lnet/lnetctl.h>
  53 #include "parser.h"
  54 #include <stdio.h>
  55
  56 static char * lcfg_devname;
  57
  58 void lcfg_set_devname(char *name)
  59 {
  60         if (lcfg_devname)
  61                 free(lcfg_devname);
  62         lcfg_devname = strdup(name);
  63 }
  64
  65
  66 int jt_lcfg_device(int argc, char **argv)
  67 {
  68         char *name;
  69
  70         if (argc == 1) {
  71                 printf("current device is %s\n", lcfg_devname? : "not set");
  72                 return 0;
  73         } else if (argc != 2) {
  74                 return CMD_HELP;
  75         }
  76
  77         name = argv[1];
  78
  79         /* quietly strip the unnecessary '$' */
  80         if (*name == '$')
  81                 name++;
  82
  83         lcfg_set_devname(name);
  84
  85         return 0;
  86 }
  87
  88 /* NOOP */
  89 int jt_lcfg_newdev(int argc, char **argv)
  90 {
  91         return 0;
  92 }
  93
  94 int jt_lcfg_attach(int argc, char **argv)
  95 {
  96         struct lustre_cfg_bufs bufs;
  97         struct lustre_cfg *lcfg;
  98         int rc;
  99
 100         if (argc != 2 && argc != 3 && argc != 4)
 101                 return CMD_HELP;
 102
 103         lustre_cfg_bufs_reset(&bufs, NULL);
 104
 105         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 106         if (argc >= 3) {
 107                 lustre_cfg_bufs_set_string(&bufs, 0, argv[2]);
 108         } else {
 109                 fprintf(stderr, "error: %s: LCFG_ATTACH requires a name\n",
 110                         jt_cmdname(argv[0]));
 111                 return -EINVAL;
 112         }
 113
 114         if (argc == 4) {
 115                 lustre_cfg_bufs_set_string(&bufs, 2, argv[3]);
 116         }
 117
 118         lcfg = lustre_cfg_new(LCFG_ATTACH, &bufs);
 119         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 120         lustre_cfg_free(lcfg);
 121         if (rc < 0) {
 122                 fprintf(stderr, "error: %s: LCFG_ATTACH %s\n",
 123                         jt_cmdname(argv[0]), strerror(rc = errno));
 124         } else if (argc == 3) {
 125                 char name[1024];
 126
 127                 lcfg_set_devname(argv[2]);
 128                 if (strlen(argv[2]) > 128) {
 129                         printf("Name too long to set environment\n");
 130                         return -EINVAL;
 131                 }
 132                 snprintf(name, 512, "LUSTRE_DEV_%s", argv[2]);
 133                 rc = setenv(name, argv[1], 1);
 134                 if (rc) {
 135                         printf("error setting env variable %s\n", name);
 136                 }
 137         } else {
 138                 lcfg_set_devname(argv[2]);
 139         }
 140
 141         return rc;
 142 }
 143
 144 int jt_lcfg_setup(int argc, char **argv)
 145 {
 146         struct lustre_cfg_bufs bufs;
 147         struct lustre_cfg *lcfg;
 148         int i;
 149         int rc;
 150
 151         if (lcfg_devname == NULL) {
 152                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 153                         "device name for config commands.\n",
 154                         jt_cmdname(argv[0]));
 155                 return -EINVAL;
 156         }
 157
 158         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 159
 160         if (argc > 5)
 161                 return CMD_HELP;
 162
 163         for (i = 1; i < argc; i++) {
 164                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
 165         }
 166
 167         lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
 168         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 169         lustre_cfg_free(lcfg);
 170         if (rc < 0)
 171                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 172                         strerror(rc = errno));
 173
 174         return rc;
 175 }
 176
 177 int jt_obd_detach(int argc, char **argv)
 178 {
 179         struct lustre_cfg_bufs bufs;
 180         struct lustre_cfg *lcfg;
 181         int rc;
 182
 183         if (lcfg_devname == NULL) {
 184                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 185                         "device name for config commands.\n",
 186                         jt_cmdname(argv[0]));
 187                 return -EINVAL;
 188         }
 189
 190         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 191
 192         if (argc != 1)
 193                 return CMD_HELP;
 194
 195         lcfg = lustre_cfg_new(LCFG_DETACH, &bufs);
 196         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 197         lustre_cfg_free(lcfg);
 198         if (rc < 0)
 199                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 200                         strerror(rc = errno));
 201
 202         return rc;
 203 }
 204
 205 int jt_obd_cleanup(int argc, char **argv)
 206 {
 207         struct lustre_cfg_bufs bufs;
 208         struct lustre_cfg *lcfg;
 209         char force = 'F';
 210         char failover = 'A';
 211         char flags[3] = { 0 };
 212         int flag_cnt = 0, n;
 213         int rc;
 214
 215         if (lcfg_devname == NULL) {
 216                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 217                         "device name for config commands.\n",
 218                         jt_cmdname(argv[0]));
 219                 return -EINVAL;
 220         }
 221
 222         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 223
 224         if (argc < 1 || argc > 3)
 225                 return CMD_HELP;
 226
 227         /* we are protected from overflowing our buffer by the argc
 228          * check above
 229          */
 230         for (n = 1; n < argc; n++) {
 231                 if (strcmp(argv[n], "force") == 0) {
 232                         flags[flag_cnt++] = force;
 233                 } else if (strcmp(argv[n], "failover") == 0) {
 234                         flags[flag_cnt++] = failover;
 235                 } else {
 236                         fprintf(stderr, "unknown option: %s", argv[n]);
 237                         return CMD_HELP;
 238                 }
 239         }
 240
 241         if (flag_cnt) {
 242                 lustre_cfg_bufs_set_string(&bufs, 1, flags);
 243         }
 244
 245         lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs);
 246         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 247         lustre_cfg_free(lcfg);
 248         if (rc < 0)
 249                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 250                         strerror(rc = errno));
 251
 252         return rc;
 253 }
 254
 255 static
 256 int do_add_uuid(char * func, char *uuid, lnet_nid_t nid)
 257 {
 258         int rc;
 259         struct lustre_cfg_bufs bufs;
 260         struct lustre_cfg *lcfg;
 261
 262         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 263         if (uuid)
 264                 lustre_cfg_bufs_set_string(&bufs, 1, uuid);
 265
 266         lcfg = lustre_cfg_new(LCFG_ADD_UUID, &bufs);
 267         lcfg->lcfg_nid = nid;
 268
 269 #if 0
 270         fprintf(stderr, "adding\tnid: %d\tuuid: %s\n",
 271                lcfg->lcfg_nid, uuid);
 272 #endif
 273         rc = lcfg_ioctl(func, OBD_DEV_ID, lcfg);
 274         lustre_cfg_free(lcfg);
 275         if (rc) {
 276                 fprintf(stderr, "IOC_PORTAL_ADD_UUID failed: %s\n",
 277                         strerror(errno));
 278                 return -1;
 279         }
 280
 281         printf ("Added uuid %s: %s\n", uuid, libcfs_nid2str(nid));
 282         return 0;
 283 }
 284
 285 int jt_lcfg_add_uuid(int argc, char **argv)
 286 {
 287         lnet_nid_t nid;
 288
 289         if (argc != 3) {
 290                 return CMD_HELP;
 291         }
 292
 293         nid = libcfs_str2nid(argv[2]);
 294         if (nid == LNET_NID_ANY) {
 295                 fprintf (stderr, "Can't parse NID %s\n", argv[2]);
 296                 return (-1);
 297         }
 298
 299         return do_add_uuid(argv[0], argv[1], nid);
 300 }
 301
 302 int obd_add_uuid(char *uuid, lnet_nid_t nid)
 303 {
 304         return do_add_uuid("obd_add_uuid", uuid, nid);
 305 }
 306
 307 int jt_lcfg_del_uuid(int argc, char **argv)
 308 {
 309         int rc;
 310         struct lustre_cfg_bufs bufs;
 311         struct lustre_cfg *lcfg;
 312
 313         if (argc != 2) {
 314                 fprintf(stderr, "usage: %s <uuid>\n", argv[0]);
 315                 return 0;
 316         }
 317
 318         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 319         if (strcmp (argv[1], "_all_"))
 320                 lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 321
 322         lcfg = lustre_cfg_new(LCFG_DEL_UUID, &bufs);
 323         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 324         lustre_cfg_free(lcfg);
 325         if (rc) {
 326                 fprintf(stderr, "IOC_PORTAL_DEL_UUID failed: %s\n",
 327                         strerror(errno));
 328                 return -1;
 329         }
 330         return 0;
 331 }
 332
 333 int jt_lcfg_lov_setup(int argc, char **argv)
 334 {
 335         struct lustre_cfg_bufs bufs;
 336         struct lustre_cfg *lcfg;
 337         struct lov_desc desc;
 338         int rc;
 339         char *end;
 340
 341          /* argv: lov_setup <LOV uuid> <stripe count> <stripe size>
 342           *                 <stripe offset> <pattern> [ <max tgt index> ]
 343           */
 344         if (argc < 6 || argc > 7)
 345                 return CMD_HELP;
 346
 347         if (strlen(argv[1]) > sizeof(desc.ld_uuid) - 1) {
 348                 fprintf(stderr,
 349                         "error: %s: LOV uuid '%s' longer than "LPSZ" chars\n",
 350                         jt_cmdname(argv[0]), argv[1], sizeof(desc.ld_uuid) - 1);
 351                 return -EINVAL;
 352         }
 353
 354         memset(&desc, 0, sizeof(desc));
 355         obd_str2uuid(&desc.ld_uuid, argv[1]);
 356         desc.ld_tgt_count = 0;
 357         desc.ld_magic = LOV_DESC_MAGIC;
 358         desc.ld_default_stripe_count = strtoul(argv[2], &end, 0);
 359         if (*end) {
 360                 fprintf(stderr, "error: %s: bad default stripe count '%s'\n",
 361                         jt_cmdname(argv[0]), argv[2]);
 362                 return CMD_HELP;
 363         }
 364
 365         desc.ld_default_stripe_size = strtoull(argv[3], &end, 0);
 366         if (*end) {
 367                 fprintf(stderr, "error: %s: bad default stripe size '%s'\n",
 368                         jt_cmdname(argv[0]), argv[3]);
 369                 return CMD_HELP;
 370         }
 371         if (desc.ld_default_stripe_size < 4096) {
 372                 fprintf(stderr,
 373                         "error: %s: default stripe size "LPU64" smaller than "
 374                         "minimum %u\n",
 375                         jt_cmdname(argv[0]), desc.ld_default_stripe_size,
 376                         LOV_MIN_STRIPE_SIZE);
 377                 return -EINVAL;
 378         } else if ((long)desc.ld_default_stripe_size <
 379                    desc.ld_default_stripe_size) {
 380                 fprintf(stderr,
 381                         "error: %s: default stripe size "LPU64" too large\n",
 382                         jt_cmdname(argv[0]), desc.ld_default_stripe_size);
 383                 return -EINVAL;
 384         }
 385         desc.ld_default_stripe_offset = strtoull(argv[4], &end, 0);
 386         if (*end) {
 387                 fprintf(stderr, "error: %s: bad default stripe offset '%s'\n",
 388                         jt_cmdname(argv[0]), argv[4]);
 389                 return CMD_HELP;
 390         }
 391         desc.ld_pattern = strtoul(argv[5], &end, 0);
 392         if (*end) {
 393                 fprintf(stderr, "error: %s: bad stripe pattern '%s'\n",
 394                         jt_cmdname(argv[0]), argv[5]);
 395                 return CMD_HELP;
 396         }
 397
 398         if (argc == 7) {
 399                 desc.ld_tgt_count = strtoul(argv[6], &end, 0);
 400                 if (*end) {
 401                         fprintf(stderr, "error: %s: bad target count '%s'\n",
 402                                 jt_cmdname(argv[0]), argv[6]);
 403                         return CMD_HELP;
 404                 }
 405                 if (desc.ld_default_stripe_count > desc.ld_tgt_count) {
 406                         fprintf(stderr,
 407                                 "error: %s: default stripe count %u > "
 408                                 "OST count %u\n", jt_cmdname(argv[0]),
 409                                 desc.ld_default_stripe_count,
 410                                 desc.ld_tgt_count);
 411                         return -EINVAL;
 412                 }
 413         }
 414
 415         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 416         lustre_cfg_bufs_set(&bufs, 1, &desc, sizeof(desc));
 417
 418         lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
 419         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 420         lustre_cfg_free(lcfg);
 421         if (rc)
 422                 fprintf(stderr, "error: %s: ioctl error: %s\n",
 423                         jt_cmdname(argv[0]), strerror(rc = errno));
 424         return rc;
 425 }
 426
 427 int jt_lcfg_lov_modify_tgts(int argc, char **argv)
 428 {
 429         struct lustre_cfg_bufs bufs;
 430         struct lustre_cfg *lcfg;
 431         char *end;
 432         int cmd = 0;
 433         int index;
 434         int gen;
 435         int rc;
 436
 437         /* argv: lov_modify_tgts <op> <LOV name> <OBD uuid> <index> <gen> */
 438         if (argc != 6)
 439                 return CMD_HELP;
 440
 441         if (!strncmp(argv[1], "add", 4)) {
 442                 cmd = LCFG_LOV_ADD_OBD;
 443         } else if (!strncmp(argv[1], "del", 4)) {
 444                 cmd = LCFG_LOV_DEL_OBD;
 445         } else {
 446                 fprintf(stderr, "error: %s: bad operation '%s'\n",
 447                         jt_cmdname(argv[0]), argv[1]);
 448                 return CMD_HELP;
 449         }
 450
 451         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 452
 453         if (((index = strlen(argv[3]) + 1)) > sizeof(struct obd_uuid)) {
 454                 fprintf(stderr,
 455                         "error: %s: OBD uuid '%s' longer than "LPSZ" chars\n",
 456                         jt_cmdname(argv[0]), argv[3],
 457                         sizeof(struct obd_uuid) - 1);
 458                 return -EINVAL;
 459         }
 460         lustre_cfg_bufs_set(&bufs, 1, argv[3], index);
 461
 462         index = strtoul(argv[4], &end, 0);
 463         if (*end) {
 464                 fprintf(stderr, "error: %s: bad OBD index '%s'\n",
 465                         jt_cmdname(argv[0]), argv[4]);
 466                 return CMD_HELP;
 467         }
 468         lustre_cfg_bufs_set(&bufs, 2, argv[4], strlen(argv[4]));
 469
 470         gen = strtoul(argv[5], &end, 0);
 471         if (*end) {
 472                 fprintf(stderr, "error: %s: bad OBD generation '%s'\n",
 473                         jt_cmdname(argv[0]), argv[5]);
 474                 return CMD_HELP;
 475         }
 476         lustre_cfg_bufs_set(&bufs, 3, argv[5], strlen(argv[5]));
 477
 478         lcfg = lustre_cfg_new(cmd, &bufs);
 479         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 480         lustre_cfg_free(lcfg);
 481         if (rc)
 482                 fprintf(stderr, "error: %s: ioctl error: %s\n",
 483                         jt_cmdname(argv[0]), strerror(rc = errno));
 484
 485         return rc;
 486 }
 487
 488
 489
 490 int jt_lcfg_mount_option(int argc, char **argv)
 491 {
 492         int rc;
 493         struct lustre_cfg_bufs bufs;
 494         struct lustre_cfg *lcfg;
 495         int i;
 496
 497         if (argc < 3 || argc > 4)
 498                 return CMD_HELP;
 499
 500         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 501
 502         for (i = 1; i < argc; i++)
 503                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
 504
 505         lcfg = lustre_cfg_new(LCFG_MOUNTOPT, &bufs);
 506         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 507         lustre_cfg_free(lcfg);
 508         if (rc < 0) {
 509                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 510                         strerror(rc = errno));
 511         }
 512         return rc;
 513 }
 514
 515 int jt_lcfg_del_mount_option(int argc, char **argv)
 516 {
 517         int rc;
 518         struct lustre_cfg_bufs bufs;
 519         struct lustre_cfg *lcfg;
 520
 521         if (argc != 2)
 522                 return CMD_HELP;
 523
 524         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 525
 526         /* profile name */
 527         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 528
 529         lcfg = lustre_cfg_new(LCFG_DEL_MOUNTOPT, &bufs);
 530         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 531         lustre_cfg_free(lcfg);
 532         if (rc < 0) {
 533                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 534                         strerror(rc = errno));
 535         }
 536         return rc;
 537 }
 538
 539 int jt_lcfg_set_timeout(int argc, char **argv)
 540 {
 541         int rc;
 542         struct lustre_cfg_bufs bufs;
 543         struct lustre_cfg *lcfg;
 544
 545         if (argc != 2)
 546                 return CMD_HELP;
 547
 548         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 549         lcfg = lustre_cfg_new(LCFG_SET_TIMEOUT, &bufs);
 550         lcfg->lcfg_num = atoi(argv[1]);
 551
 552         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 553         lustre_cfg_free(lcfg);
 554         if (rc < 0) {
 555                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 556                         strerror(rc = errno));
 557         }
 558         return rc;
 559 }
 560
 561
 562 int jt_lcfg_set_lustre_upcall(int argc, char **argv)
 563 {
 564         int rc;
 565         struct lustre_cfg_bufs bufs;
 566         struct lustre_cfg *lcfg;
 567
 568         if (argc != 2)
 569                 return CMD_HELP;
 570
 571         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 572
 573         /* profile name */
 574         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 575
 576         lcfg = lustre_cfg_new(LCFG_SET_UPCALL, &bufs);
 577         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 578         lustre_cfg_free(lcfg);
 579         if (rc < 0) {
 580                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 581                         strerror(rc = errno));
 582         }
 583         return rc;
 584 }
 585
 586 int jt_lcfg_add_conn(int argc, char **argv)
 587 {
 588         struct lustre_cfg_bufs bufs;
 589         struct lustre_cfg *lcfg;
 590         int priority;
 591         int rc;
 592
 593         if (argc == 2)
 594                 priority = 0;
 595         else if (argc == 3)
 596                 priority = 1;
 597         else
 598                 return CMD_HELP;
 599
 600         if (lcfg_devname == NULL) {
 601                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 602                         "device name for config commands.\n",
 603                         jt_cmdname(argv[0]));
 604                 return -EINVAL;
 605         }
 606
 607         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 608
 609         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 610
 611         lcfg = lustre_cfg_new(LCFG_ADD_CONN, &bufs);
 612         lcfg->lcfg_num = priority;
 613
 614         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 615         lustre_cfg_free (lcfg);
 616         if (rc < 0) {
 617                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 618                         strerror(rc = errno));
 619         }
 620
 621         return rc;
 622 }
 623
 624 int jt_lcfg_del_conn(int argc, char **argv)
 625 {
 626         struct lustre_cfg_bufs bufs;
 627         struct lustre_cfg *lcfg;
 628         int rc;
 629
 630         if (argc != 2)
 631                 return CMD_HELP;
 632
 633         if (lcfg_devname == NULL) {
 634                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 635                         "device name for config commands.\n",
 636                         jt_cmdname(argv[0]));
 637                 return -EINVAL;
 638         }
 639
 640         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 641
 642         /* connection uuid */
 643         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 644
 645         lcfg = lustre_cfg_new(LCFG_DEL_MOUNTOPT, &bufs);
 646
 647         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 648         lustre_cfg_free(lcfg);
 649         if (rc < 0) {
 650                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 651                         strerror(rc = errno));
 652         }
 653
 654         return rc;
 655 }