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 <portals/ptlctl.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         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 101
 102         if (argc != 2 && argc != 3 && argc != 4)
 103                 return CMD_HELP;
 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         lcfg = lustre_cfg_new(LCFG_ATTACH, &bufs);
 118         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 119         lustre_cfg_free(lcfg);
 120         if (rc < 0) {
 121                 fprintf(stderr, "error: %s: LCFG_ATTACH %s\n",
 122                         jt_cmdname(argv[0]), strerror(rc = errno));
 123         } else if (argc == 3) {
 124                 char name[1024];
 125
 126                 lcfg_set_devname(argv[2]);
 127                 if (strlen(argv[2]) > 128) {
 128                         printf("Name too long to set environment\n");
 129                         return -EINVAL;
 130                 }
 131                 snprintf(name, 512, "LUSTRE_DEV_%s", argv[2]);
 132                 rc = setenv(name, argv[1], 1);
 133                 if (rc) {
 134                         printf("error setting env variable %s\n", name);
 135                 }
 136         } else {
 137                 lcfg_set_devname(argv[2]);
 138         }
 139
 140         return rc;
 141 }
 142
 143 int jt_lcfg_setup(int argc, char **argv)
 144 {
 145         struct lustre_cfg_bufs bufs;
 146         struct lustre_cfg *lcfg;
 147         int rc, i;
 148
 149         if (lcfg_devname == NULL) {
 150                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 151                         "device name for config commands.\n",
 152                         jt_cmdname(argv[0]));
 153                 return -EINVAL;
 154         }
 155
 156         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 157
 158         if (argc > 7)
 159                 return CMD_HELP;
 160
 161         for (i = 1; i < argc; i++) {
 162                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
 163         }
 164
 165         lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
 166         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 167         lustre_cfg_free(lcfg);
 168         if (rc < 0)
 169                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 170                         strerror(rc = errno));
 171
 172         return rc;
 173 }
 174
 175 int jt_obd_detach(int argc, char **argv)
 176 {
 177         struct lustre_cfg_bufs bufs;
 178         struct lustre_cfg *lcfg;
 179         int rc;
 180
 181         if (lcfg_devname == NULL) {
 182                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 183                         "device name for config commands.\n",
 184                         jt_cmdname(argv[0]));
 185                 return -EINVAL;
 186         }
 187         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 188
 189         if (argc != 1)
 190                 return CMD_HELP;
 191
 192         lcfg = lustre_cfg_new(LCFG_DETACH, &bufs);
 193         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 194         lustre_cfg_free(lcfg);
 195
 196         if (rc < 0)
 197                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 198                         strerror(rc = errno));
 199         return rc;
 200 }
 201
 202 int jt_obd_cleanup(int argc, char **argv)
 203 {
 204         struct lustre_cfg_bufs bufs;
 205         struct lustre_cfg *lcfg;
 206         char force = 'F';
 207         char failover = 'A';
 208         char flags[3];
 209         int flag_cnt = 0, n;
 210         int rc;
 211
 212
 213
 214         if (lcfg_devname == NULL) {
 215                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 216                         "device name for config commands.\n",
 217                         jt_cmdname(argv[0]));
 218                 return -EINVAL;
 219         }
 220
 221         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 222
 223         if (argc < 1 || argc > 3)
 224                 return CMD_HELP;
 225
 226         /* we are protected from overflowing our buffer by the argc
 227          * check above
 228          */
 229         for (n = 1; n < argc; n++) {
 230                 if (strcmp(argv[n], "force") == 0) {
 231                         flags[flag_cnt++] = force;
 232                 } else if (strcmp(argv[n], "failover") == 0) {
 233                         flags[flag_cnt++] = failover;
 234                 } else {
 235                         fprintf(stderr, "unknown option: %s", argv[n]);
 236                         return CMD_HELP;
 237                 }
 238         }
 239
 240         if (flag_cnt) {
 241                 lustre_cfg_bufs_set_string(&bufs, 1, flags);
 242         }
 243
 244         lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs);
 245         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 246         lustre_cfg_free(lcfg);
 247         if (rc < 0)
 248                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 249                         strerror(rc = errno));
 250
 251         return rc;
 252 }
 253
 254 static
 255 int do_add_uuid(char * func, char *uuid, ptl_nid_t nid, int nal)
 256 {
 257         char tmp[64];
 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         lcfg->lcfg_nal = nal;
 269
 270         rc = lcfg_ioctl(func, OBD_DEV_ID, lcfg);
 271         lustre_cfg_free(lcfg);
 272         if (rc) {
 273                 fprintf(stderr, "IOC_PORTAL_ADD_UUID failed: %s\n",
 274                         strerror(errno));
 275                 return -1;
 276         }
 277
 278         printf ("Added uuid %s: %s\n", uuid, ptl_nid2str (tmp, nid));
 279         return 0;
 280
 281 }
 282
 283 int jt_lcfg_add_uuid(int argc, char **argv)
 284 {
 285         ptl_nid_t nid = 0;
 286         int nal;
 287
 288         if (argc != 4) {
 289                 return CMD_HELP;
 290         }
 291
 292         if (ptl_parse_nid (&nid, argv[2]) != 0) {
 293                 fprintf (stderr, "Can't parse NID %s\n", argv[2]);
 294                         return (-1);
 295         }
 296
 297         nal = ptl_name2nal(argv[3]);
 298
 299         if (nal <= 0) {
 300                 fprintf (stderr, "Can't parse NAL %s\n", argv[3]);
 301                 return -1;
 302         }
 303
 304         return do_add_uuid(argv[0], argv[1], nid, nal);
 305 }
 306
 307 int obd_add_uuid(char *uuid, ptl_nid_t nid, int nal)
 308 {
 309         return do_add_uuid("obd_add_uuid", uuid, nid, nal);
 310 }
 311
 312 int jt_lcfg_del_uuid(int argc, char **argv)
 313 {
 314         int rc;
 315         struct lustre_cfg_bufs bufs;
 316         struct lustre_cfg *lcfg;
 317
 318         if (argc != 2) {
 319                 fprintf(stderr, "usage: %s <uuid>\n", argv[0]);
 320                 return 0;
 321         }
 322
 323         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 324         if (strcmp (argv[1], "_all_"))
 325                 lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 326
 327         lcfg = lustre_cfg_new(LCFG_DEL_UUID, &bufs);
 328         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 329         lustre_cfg_free(lcfg);
 330         if (rc) {
 331                 fprintf(stderr, "IOC_PORTAL_DEL_UUID failed: %s\n",
 332                         strerror(errno));
 333                 return -1;
 334         }
 335         return 0;
 336 }
 337
 338 int jt_lcfg_lov_setup(int argc, char **argv)
 339 {
 340         struct lustre_cfg_bufs bufs;
 341         struct lustre_cfg *lcfg;
 342         struct lov_desc desc;
 343         int rc;
 344         char *end;
 345
 346         /* argv: lov_setup <LOV uuid> <stripe count> <stripe size>
 347          *                 <stripe offset> <pattern>
 348          */
 349         if (argc != 6)
 350                 return CMD_HELP;
 351
 352         if (strlen(argv[1]) > sizeof(desc.ld_uuid) - 1) {
 353                 fprintf(stderr,
 354                         "error: %s: LOV uuid '%s' longer than "LPSZ" chars\n",
 355                         jt_cmdname(argv[0]), argv[1], sizeof(desc.ld_uuid) - 1);
 356                 return -EINVAL;
 357         }
 358
 359         memset(&desc, 0, sizeof(desc));
 360         obd_str2uuid(&desc.ld_uuid, argv[1]);
 361         desc.ld_default_stripe_count = strtoul(argv[2], &end, 0);
 362         if (*end) {
 363                 fprintf(stderr, "error: %s: bad default stripe count '%s'\n",
 364                         jt_cmdname(argv[0]), argv[2]);
 365                 return CMD_HELP;
 366         }
 367
 368         desc.ld_default_stripe_size = strtoull(argv[3], &end, 0);
 369         if (*end) {
 370                 fprintf(stderr, "error: %s: bad default stripe size '%s'\n",
 371                         jt_cmdname(argv[0]), argv[3]);
 372                 return CMD_HELP;
 373         }
 374         if (desc.ld_default_stripe_size < 4096) {
 375                 fprintf(stderr,
 376                         "error: %s: default stripe size "LPU64" too small\n",
 377                         jt_cmdname(argv[0]), desc.ld_default_stripe_size);
 378                 return -EINVAL;
 379         } else if ((long)desc.ld_default_stripe_size <
 380                    desc.ld_default_stripe_size) {
 381                 fprintf(stderr,
 382                         "error: %s: default stripe size "LPU64" too large\n",
 383                         jt_cmdname(argv[0]), desc.ld_default_stripe_size);
 384                 return -EINVAL;
 385         }
 386
 387         desc.ld_default_stripe_offset = strtoull(argv[4], &end, 0);
 388         if (*end) {
 389                 fprintf(stderr, "error: %s: bad default stripe offset '%s'\n",
 390                         jt_cmdname(argv[0]), argv[4]);
 391                 return CMD_HELP;
 392         }
 393
 394         desc.ld_pattern = strtoul(argv[5], &end, 0);
 395         if (*end) {
 396                 fprintf(stderr, "error: %s: bad stripe pattern '%s'\n",
 397                         jt_cmdname(argv[0]), argv[5]);
 398                 return CMD_HELP;
 399         }
 400
 401         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 402         lustre_cfg_bufs_set(&bufs, 1, &desc, sizeof(desc));
 403
 404         lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
 405         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 406         lustre_cfg_free(lcfg);
 407         if (rc)
 408                 fprintf(stderr, "error: %s: ioctl error: %s\n",
 409                         jt_cmdname(argv[0]), strerror(rc = errno));
 410         return rc;
 411 }
 412
 413 int jt_lcfg_lov_modify_tgts(int argc, char **argv)
 414 {
 415         struct lustre_cfg_bufs bufs;
 416         struct lustre_cfg *lcfg;
 417         char *end;
 418         int cmd = 0;
 419         int index;
 420         int gen;
 421         int rc;
 422
 423         /* argv: lov_modify_tgts <op> <LOV name> <OBD uuid> <index> <gen> */
 424         if (argc != 6)
 425                 return CMD_HELP;
 426
 427         if (!strncmp(argv[1], "add", 4)) {
 428                 cmd = LCFG_LOV_ADD_OBD;
 429         } else if (!strncmp(argv[1], "del", 4)) {
 430                 cmd = LCFG_LOV_DEL_OBD;
 431         } else {
 432                 fprintf(stderr, "error: %s: bad operation '%s'\n",
 433                         jt_cmdname(argv[0]), argv[1]);
 434                 return CMD_HELP;
 435         }
 436
 437         lustre_cfg_bufs_reset(&bufs, argv[2]);
 438
 439
 440         if (((index = strlen(argv[3]) + 1)) > sizeof(struct obd_uuid)) {
 441                 fprintf(stderr,
 442                         "error: %s: OBD uuid '%s' longer than "LPSZ" chars\n",
 443                         jt_cmdname(argv[0]), argv[3],
 444                         sizeof(struct obd_uuid) - 1);
 445                 return -EINVAL;
 446         }
 447         lustre_cfg_bufs_set(&bufs, 1, argv[3], index);
 448
 449         index = strtoul(argv[4], &end, 0);
 450         if (*end) {
 451                 fprintf(stderr, "error: %s: bad OBD index '%s'\n",
 452                         jt_cmdname(argv[0]), argv[4]);
 453                 return CMD_HELP;
 454         }
 455         lustre_cfg_bufs_set(&bufs, 2, argv[4], strlen(argv[4]));
 456
 457         gen = strtoul(argv[5], &end, 0);
 458         if (*end) {
 459                 fprintf(stderr, "error: %s: bad OBD generation '%s'\n",
 460                         jt_cmdname(argv[0]), argv[5]);
 461                 return CMD_HELP;
 462         }
 463         lustre_cfg_bufs_set(&bufs, 3, argv[5], strlen(argv[5]));
 464
 465         lcfg = lustre_cfg_new(cmd, &bufs);
 466         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 467         lustre_cfg_free(lcfg);
 468         if (rc)
 469                 fprintf(stderr, "error: %s: ioctl error: %s\n",
 470                         jt_cmdname(argv[0]), strerror(rc = errno));
 471         return rc;
 472 }
 473
 474 int jt_lcfg_lmv_setup(int argc, char **argv)
 475 {
 476         struct lustre_cfg_bufs bufs;
 477         struct lustre_cfg *lcfg;
 478         struct lmv_desc desc;
 479         int rc;
 480
 481         /* argv: lmv_setup <lmv_uuid> */
 482
 483         if (argc != 2)
 484                 return CMD_HELP;
 485
 486         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 487
 488         if (strlen(argv[1]) > (sizeof(desc.ld_uuid) - 1)) {
 489                 fprintf(stderr,
 490                         "error: %s: LMV uuid '%s' longer than "LPSZ" chars\n",
 491                         jt_cmdname(argv[0]), argv[1], sizeof(desc.ld_uuid) - 1);
 492                 return -EINVAL;
 493         }
 494
 495         memset(&desc, 0, sizeof(desc));
 496         obd_str2uuid(&desc.ld_uuid, argv[1]);
 497
 498         lustre_cfg_bufs_set(&bufs, 1, &desc, sizeof(desc));
 499         lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
 500         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 501         if (rc)
 502                 fprintf(stderr, "error: %s: ioctl error: %s\n",
 503                         jt_cmdname(argv[0]), strerror(rc = errno));
 504
 505         lustre_cfg_free(lcfg);
 506         return rc;
 507 }
 508
 509 int jt_lcfg_lmv_modify_tgts(int argc, char **argv)
 510 {
 511         struct lustre_cfg_bufs bufs;
 512         struct lustre_cfg *lcfg;
 513         int mdc_uuid_len, rc;
 514
 515         /* NOTE: EXTREME care must be taken to always add MDCs in the same
 516          *       order, or have only additions at the end of the list.
 517          */
 518
 519         /* argv: lmv_modify_tgts add <LMV name> <MDC uuid> */
 520         if (argc != 4)
 521                 return CMD_HELP;
 522
 523         if (strncmp(argv[1], "add", 4) != 0) {
 524                 fprintf(stderr, "error: %s: bad operation '%s'\n",
 525                         jt_cmdname(argv[0]), argv[1]);
 526                 return CMD_HELP;
 527         }
 528
 529         lustre_cfg_bufs_reset(&bufs, argv[2]);
 530
 531         if (((mdc_uuid_len = strlen(argv[3]) + 1)) > sizeof(struct obd_uuid)) {
 532                 fprintf(stderr,
 533                         "error: %s: MDC uuid '%s' longer than "LPSZ" chars\n",
 534                         jt_cmdname(argv[0]), argv[3],
 535                         sizeof(struct obd_uuid) - 1);
 536                 return -EINVAL;
 537         }
 538
 539         lustre_cfg_bufs_set(&bufs, 1, argv[3], mdc_uuid_len);
 540
 541         lcfg = lustre_cfg_new(LCFG_LMV_ADD_MDC, &bufs);
 542         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 543         lustre_cfg_free(lcfg);
 544         if (rc)
 545                 fprintf(stderr, "error: %s: ioctl error: %s\n",
 546                         jt_cmdname(argv[0]), strerror(rc = errno));
 547         return rc;
 548 }
 549
 550 int jt_lcfg_mount_option(int argc, char **argv)
 551 {
 552         int rc;
 553         struct lustre_cfg_bufs bufs;
 554         struct lustre_cfg *lcfg;
 555         int i;
 556
 557         if (argc < 3 || argc > 5)
 558                 return CMD_HELP;
 559
 560         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 561
 562         for (i = 1; i < argc; i++)
 563                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
 564
 565         lcfg = lustre_cfg_new(LCFG_MOUNTOPT, &bufs);
 566         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 567         lustre_cfg_free(lcfg);
 568         if (rc < 0) {
 569                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 570                         strerror(rc = errno));
 571         }
 572         return rc;
 573 }
 574
 575 int jt_lcfg_del_mount_option(int argc, char **argv)
 576 {
 577         int rc;
 578         struct lustre_cfg_bufs bufs;
 579         struct lustre_cfg *lcfg;
 580
 581         if (argc != 2)
 582                 return CMD_HELP;
 583
 584         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 585
 586         /* profile name */
 587         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 588
 589         lcfg = lustre_cfg_new(LCFG_DEL_MOUNTOPT, &bufs);
 590         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 591         lustre_cfg_free(lcfg);
 592         if (rc < 0) {
 593                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 594                         strerror(rc = errno));
 595         }
 596         return rc;
 597 }
 598
 599 int jt_lcfg_set_timeout(int argc, char **argv)
 600 {
 601         int rc;
 602         struct lustre_cfg_bufs bufs;
 603         struct lustre_cfg *lcfg;
 604
 605         if (argc != 2)
 606                 return CMD_HELP;
 607
 608         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 609         lcfg = lustre_cfg_new(LCFG_SET_TIMEOUT, &bufs);
 610         lcfg->lcfg_num = atoi(argv[1]);
 611
 612         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 613         lustre_cfg_free(lcfg);
 614         if (rc < 0) {
 615                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 616                         strerror(rc = errno));
 617         }
 618         return rc;
 619 }
 620
 621
 622 int jt_lcfg_set_lustre_upcall(int argc, char **argv)
 623 {
 624         int rc;
 625         struct lustre_cfg_bufs bufs;
 626         struct lustre_cfg *lcfg;
 627
 628         if (argc != 2)
 629                 return CMD_HELP;
 630
 631         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 632
 633         /* profile name */
 634         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 635
 636         lcfg = lustre_cfg_new(LCFG_SET_UPCALL, &bufs);
 637         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 638         lustre_cfg_free(lcfg);
 639         if (rc < 0) {
 640                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 641                         strerror(rc = errno));
 642         }
 643         return rc;
 644 }
 645
 646 int jt_lcfg_add_conn(int argc, char **argv)
 647 {
 648         struct lustre_cfg_bufs bufs;
 649         struct lustre_cfg *lcfg;
 650         int priority;
 651         int rc;
 652
 653         if (argc == 2)
 654                 priority = 0;
 655         else if (argc == 3)
 656                 priority = 1;
 657         else
 658                 return CMD_HELP;
 659
 660         if (lcfg_devname == NULL) {
 661                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 662                         "device name for config commands.\n",
 663                         jt_cmdname(argv[0]));
 664                 return -EINVAL;
 665         }
 666
 667         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 668
 669         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 670
 671         lcfg = lustre_cfg_new(LCFG_ADD_CONN, &bufs);
 672         lcfg->lcfg_num = priority;
 673
 674         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 675         lustre_cfg_free (lcfg);
 676         if (rc < 0) {
 677                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 678                         strerror(rc = errno));
 679         }
 680         return rc;
 681 }
 682
 683 int jt_lcfg_del_conn(int argc, char **argv)
 684 {
 685         struct lustre_cfg_bufs bufs;
 686         struct lustre_cfg *lcfg;
 687         int rc;
 688
 689         if (argc != 2)
 690                 return CMD_HELP;
 691
 692         if (lcfg_devname == NULL) {
 693                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 694                         "device name for config commands.\n",
 695                         jt_cmdname(argv[0]));
 696                 return -EINVAL;
 697         }
 698
 699         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 700
 701         /* connection uuid */
 702         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 703
 704         lcfg = lustre_cfg_new(LCFG_DEL_CONN, &bufs);
 705
 706         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 707         lustre_cfg_free(lcfg);
 708         if (rc < 0) {
 709                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 710                         strerror(rc = errno));
 711         }
 712
 713         return rc;
 714 }
 715
 716 int jt_lcfg_set_security(int argc, char **argv)
 717 {
 718         struct lustre_cfg_bufs bufs;
 719         struct lustre_cfg *lcfg;
 720         int rc;
 721
 722         if (argc != 3)
 723                 return CMD_HELP;
 724
 725         if (lcfg_devname == NULL) {
 726                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 727                         "device name for config commands.\n",
 728                         jt_cmdname(argv[0]));
 729                 return -EINVAL;
 730         }
 731
 732         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 733
 734         /* currently only used to set on mds */
 735         if (strcmp(argv[1], "mds_sec") &&
 736             strcmp(argv[1], "oss_sec") &&
 737             strcmp(argv[1], "deny_sec")) {
 738                 fprintf(stderr, "%s: invalid security key %s\n",
 739                         jt_cmdname(argv[0]), argv[1]);
 740                 return -EINVAL;
 741         }
 742         if (strcmp(argv[2], "null") &&
 743             strcmp(argv[2], "krb5i") &&
 744             strcmp(argv[2], "krb5p")) {
 745                 fprintf(stderr, "%s: invalid security value %s\n",
 746                         jt_cmdname(argv[0]), argv[2]);
 747                 return -EINVAL;
 748         }
 749
 750         /* connection uuid */
 751         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 752         lustre_cfg_bufs_set_string(&bufs, 2, argv[2]);
 753         lcfg = lustre_cfg_new(LCFG_SET_SECURITY, &bufs);
 754
 755         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 756         lustre_cfg_free(lcfg);
 757         if (rc < 0) {
 758                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 759                         strerror(rc = errno));
 760         }
 761
 762         return rc;
 763 }
 764
 765