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> [ <max tgt index> ]
 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         desc.ld_default_stripe_offset = strtoull(argv[4], &end, 0);
 387         if (*end) {
 388                 fprintf(stderr, "error: %s: bad default stripe offset '%s'\n",
 389                         jt_cmdname(argv[0]), argv[4]);
 390                 return CMD_HELP;
 391         }
 392         desc.ld_pattern = strtoul(argv[5], &end, 0);
 393         if (*end) {
 394                 fprintf(stderr, "error: %s: bad stripe pattern '%s'\n",
 395                         jt_cmdname(argv[0]), argv[5]);
 396                 return CMD_HELP;
 397         }
 398
 399         if (argc > 7) {
 400                 desc.ld_tgt_count = argc - 6;
 401                 if (desc.ld_default_stripe_count > desc.ld_tgt_count) {
 402                         fprintf(stderr,
 403                                 "error: %s: default stripe count %u > "
 404                                 "OST count %u\n", jt_cmdname(argv[0]),
 405                                 desc.ld_default_stripe_count,
 406                                 desc.ld_tgt_count);
 407                         return -EINVAL;
 408                 }
 409         }
 410
 411         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 412         lustre_cfg_bufs_set(&bufs, 1, &desc, sizeof(desc));
 413
 414         lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
 415         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 416         lustre_cfg_free(lcfg);
 417         if (rc)
 418                 fprintf(stderr, "error: %s: ioctl error: %s\n",
 419                         jt_cmdname(argv[0]), strerror(rc = errno));
 420         return rc;
 421 }
 422
 423 int jt_lcfg_lmv_setup(int argc, char **argv)
 424 {
 425         struct lustre_cfg_bufs bufs;
 426         struct lustre_cfg *lcfg;
 427         struct lmv_desc desc;
 428         struct obd_uuid *uuidarray, *ptr;
 429         int rc, i;
 430
 431         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 432         if (argc <= 2)
 433                 return CMD_HELP;
 434
 435         if (strlen(argv[1]) > sizeof(desc.ld_uuid) - 1) {
 436                 fprintf(stderr,
 437                         "error: %s: LMV uuid '%s' longer than "LPSZ" chars\n",
 438                         jt_cmdname(argv[0]), argv[1], sizeof(desc.ld_uuid) - 1);
 439                 return -EINVAL;
 440         }
 441
 442         memset(&desc, 0, sizeof(desc));
 443         obd_str2uuid(&desc.ld_uuid, argv[1]);
 444         desc.ld_tgt_count = argc - 2;
 445         printf("LMV: %d uuids:\n", desc.ld_tgt_count);
 446
 447         /* NOTE: it is possible to overwrite the default striping parameters,
 448          *       but EXTREME care must be taken when saving the OST UUID list.
 449          *       It must be EXACTLY the same, or have only additions at the
 450          *       end of the list, or only overwrite individual OST entries
 451          *       that are restored from backups of the previous OST.
 452          */
 453         uuidarray = calloc(desc.ld_tgt_count, sizeof(*uuidarray));
 454         if (!uuidarray) {
 455                 fprintf(stderr, "error: %s: no memory for %d UUIDs\n",
 456                         jt_cmdname(argv[0]), desc.ld_tgt_count);
 457                 rc = -ENOMEM;
 458                 goto out;
 459         }
 460         for (i = 2, ptr = uuidarray; i < argc; i++, ptr++) {
 461                 if (strlen(argv[i]) >= sizeof(*ptr)) {
 462                         fprintf(stderr, "error: %s: arg %d (%s) too long\n",
 463                                 jt_cmdname(argv[0]), i, argv[i]);
 464                         rc = -EINVAL;
 465                         goto out;
 466                 }
 467                 printf("  %s\n", argv[i]);
 468                 strcpy((char *)ptr, argv[i]);
 469         }
 470
 471         lustre_cfg_bufs_set(&bufs, 1, &desc, sizeof(desc));
 472         lustre_cfg_bufs_set(&bufs, 2, (char*)uuidarray,
 473                             desc.ld_tgt_count * sizeof(*uuidarray));
 474         lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
 475         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 476         lustre_cfg_free(lcfg);
 477
 478         if (rc)
 479                 fprintf(stderr, "error: %s: ioctl error: %s\n",
 480                         jt_cmdname(argv[0]), strerror(rc = errno));
 481 out:
 482         free(uuidarray);
 483         return rc;
 484 }
 485 int jt_lcfg_lov_modify_tgts(int argc, char **argv)
 486 {
 487         struct lustre_cfg_bufs bufs;
 488         struct lustre_cfg *lcfg;
 489         char *end;
 490         int cmd = 0;
 491         int index;
 492         int gen;
 493         int rc;
 494
 495         /* argv: lov_modify_tgts <op> <LOV name> <OBD uuid> <index> <gen> */
 496         if (argc != 6)
 497                 return CMD_HELP;
 498
 499         if (!strncmp(argv[1], "add", 4)) {
 500                 cmd = LCFG_LOV_ADD_OBD;
 501         } else if (!strncmp(argv[1], "del", 4)) {
 502                 cmd = LCFG_LOV_DEL_OBD;
 503         } else {
 504                 fprintf(stderr, "error: %s: bad operation '%s'\n",
 505                         jt_cmdname(argv[0]), argv[1]);
 506                 return CMD_HELP;
 507         }
 508
 509         lustre_cfg_bufs_reset(&bufs, argv[2]);
 510
 511
 512         if (((index = strlen(argv[3]) + 1)) > sizeof(struct obd_uuid)) {
 513                 fprintf(stderr,
 514                         "error: %s: OBD uuid '%s' longer than "LPSZ" chars\n",
 515                         jt_cmdname(argv[0]), argv[3],
 516                         sizeof(struct obd_uuid) - 1);
 517                 return -EINVAL;
 518         }
 519         lustre_cfg_bufs_set(&bufs, 1, argv[3], index);
 520
 521         index = strtoul(argv[4], &end, 0);
 522         if (*end) {
 523                 fprintf(stderr, "error: %s: bad OBD index '%s'\n",
 524                         jt_cmdname(argv[0]), argv[4]);
 525                 return CMD_HELP;
 526         }
 527         lustre_cfg_bufs_set(&bufs, 2, argv[4], strlen(argv[4]));
 528
 529         gen = strtoul(argv[5], &end, 0);
 530         if (*end) {
 531                 fprintf(stderr, "error: %s: bad OBD generation '%s'\n",
 532                         jt_cmdname(argv[0]), argv[5]);
 533                 return CMD_HELP;
 534         }
 535         lustre_cfg_bufs_set(&bufs, 3, argv[5], strlen(argv[5]));
 536
 537         lcfg = lustre_cfg_new(cmd, &bufs);
 538         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 539         lustre_cfg_free(lcfg);
 540         if (rc)
 541                 fprintf(stderr, "error: %s: ioctl error: %s\n",
 542                         jt_cmdname(argv[0]), strerror(rc = errno));
 543         return rc;
 544 }
 545
 546 int jt_lcfg_mount_option(int argc, char **argv)
 547 {
 548         int rc;
 549         struct lustre_cfg_bufs bufs;
 550         struct lustre_cfg *lcfg;
 551         int i;
 552
 553         if (argc < 3 || argc > 4)
 554                 return CMD_HELP;
 555
 556         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 557
 558         for (i = 1; i < argc; i++)
 559                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
 560
 561         lcfg = lustre_cfg_new(LCFG_MOUNTOPT, &bufs);
 562         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 563         lustre_cfg_free(lcfg);
 564         if (rc < 0) {
 565                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 566                         strerror(rc = errno));
 567         }
 568         return rc;
 569 }
 570
 571 int jt_lcfg_del_mount_option(int argc, char **argv)
 572 {
 573         int rc;
 574         struct lustre_cfg_bufs bufs;
 575         struct lustre_cfg *lcfg;
 576
 577         if (argc != 2)
 578                 return CMD_HELP;
 579
 580         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 581
 582         /* profile name */
 583         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 584
 585         lcfg = lustre_cfg_new(LCFG_DEL_MOUNTOPT, &bufs);
 586         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 587         lustre_cfg_free(lcfg);
 588         if (rc < 0) {
 589                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 590                         strerror(rc = errno));
 591         }
 592         return rc;
 593 }
 594
 595 int jt_lcfg_set_timeout(int argc, char **argv)
 596 {
 597         int rc;
 598         struct lustre_cfg_bufs bufs;
 599         struct lustre_cfg *lcfg;
 600
 601         if (argc != 2)
 602                 return CMD_HELP;
 603
 604         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 605         lcfg = lustre_cfg_new(LCFG_SET_TIMEOUT, &bufs);
 606         lcfg->lcfg_num = atoi(argv[1]);
 607
 608         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 609         lustre_cfg_free(lcfg);
 610         if (rc < 0) {
 611                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 612                         strerror(rc = errno));
 613         }
 614         return rc;
 615 }
 616
 617
 618 int jt_lcfg_set_lustre_upcall(int argc, char **argv)
 619 {
 620         int rc;
 621         struct lustre_cfg_bufs bufs;
 622         struct lustre_cfg *lcfg;
 623
 624         if (argc != 2)
 625                 return CMD_HELP;
 626
 627         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 628
 629         /* profile name */
 630         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 631
 632         lcfg = lustre_cfg_new(LCFG_SET_UPCALL, &bufs);
 633         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 634         lustre_cfg_free(lcfg);
 635         if (rc < 0) {
 636                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 637                         strerror(rc = errno));
 638         }
 639         return rc;
 640 }
 641
 642 int jt_lcfg_add_conn(int argc, char **argv)
 643 {
 644         struct lustre_cfg_bufs bufs;
 645         struct lustre_cfg *lcfg;
 646         int priority;
 647         int rc;
 648
 649         if (argc == 2)
 650                 priority = 0;
 651         else if (argc == 3)
 652                 priority = 1;
 653         else
 654                 return CMD_HELP;
 655
 656         if (lcfg_devname == NULL) {
 657                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 658                         "device name for config commands.\n",
 659                         jt_cmdname(argv[0]));
 660                 return -EINVAL;
 661         }
 662
 663         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 664
 665         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 666
 667         lcfg = lustre_cfg_new(LCFG_ADD_CONN, &bufs);
 668         lcfg->lcfg_num = priority;
 669
 670         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 671         lustre_cfg_free (lcfg);
 672         if (rc < 0) {
 673                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 674                         strerror(rc = errno));
 675         }
 676         return rc;
 677 }
 678
 679 int jt_lcfg_del_conn(int argc, char **argv)
 680 {
 681         struct lustre_cfg_bufs bufs;
 682         struct lustre_cfg *lcfg;
 683         int rc;
 684
 685         if (argc != 2)
 686                 return CMD_HELP;
 687
 688         if (lcfg_devname == NULL) {
 689                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 690                         "device name for config commands.\n",
 691                         jt_cmdname(argv[0]));
 692                 return -EINVAL;
 693         }
 694
 695         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 696
 697         /* connection uuid */
 698         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 699
 700         lcfg = lustre_cfg_new(LCFG_DEL_CONN, &bufs);
 701
 702         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 703         lustre_cfg_free(lcfg);
 704         if (rc < 0) {
 705                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 706                         strerror(rc = errno));
 707         }
 708
 709         return rc;
 710 }
 711
 712 int jt_lcfg_set_security(int argc, char **argv)
 713 {
 714         struct lustre_cfg_bufs bufs;
 715         struct lustre_cfg *lcfg;
 716         int rc;
 717
 718         if (argc != 3)
 719                 return CMD_HELP;
 720
 721         if (lcfg_devname == NULL) {
 722                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 723                         "device name for config commands.\n",
 724                         jt_cmdname(argv[0]));
 725                return -EINVAL;
 726         }
 727
 728         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 729
 730         /* currently only used to set on mds */
 731         if (strcmp(argv[1], "mds_mds_sec") && strcmp(argv[1], "mds_ost_sec")) {
 732                 fprintf(stderr, "%s: invalid security key %s\n",
 733                         jt_cmdname(argv[0]), argv[1]);
 734                 return -EINVAL;
 735         }
 736         if (strcmp(argv[2], "null") && strcmp(argv[2], "krb5")) {
 737                 fprintf(stderr, "%s: invalid security value %s\n",
 738                         jt_cmdname(argv[0]), argv[2]);
 739                 return -EINVAL;
 740         }
 741
 742         /* connection uuid */
 743         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 744         lustre_cfg_bufs_set_string(&bufs, 2, argv[2]);
 745         lcfg = lustre_cfg_new(LCFG_SET_SECURITY, &bufs);
 746
 747         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 748         lustre_cfg_free(lcfg);
 749         if (rc < 0) {
 750                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 751                         strerror(rc = errno));
 752         }
 753
 754         return rc;
 755 }