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 lcfg;
  97         int rc;
  98
  99         LCFG_INIT(lcfg, LCFG_ATTACH, lcfg_devname);
 100
 101         if (argc != 2 && argc != 3 && argc != 4)
 102                 return CMD_HELP;
 103
 104         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
 105         lcfg.lcfg_inlbuf1 = argv[1];
 106         if (argc >= 3) {
 107                 lcfg.lcfg_dev_namelen = strlen(argv[2]) + 1;
 108                 lcfg.lcfg_dev_name = argv[2];
 109         } else {
 110                 fprintf(stderr, "error: %s: LCFG_ATTACH requires a name\n",
 111                         jt_cmdname(argv[0]));
 112                 return -EINVAL;
 113         }
 114
 115         if (argc == 4) {
 116                 lcfg.lcfg_inllen2 = strlen(argv[3]) + 1;
 117                 lcfg.lcfg_inlbuf2 = argv[3];
 118         }
 119
 120         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &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 lcfg;
 147         int rc;
 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         LCFG_INIT(lcfg, LCFG_SETUP, lcfg_devname);
 157
 158         if (argc > 7)
 159                 return CMD_HELP;
 160
 161         if (argc > 1) {
 162                 lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
 163                 lcfg.lcfg_inlbuf1 = argv[1];
 164         }
 165         if (argc > 2) {
 166                 lcfg.lcfg_inllen2 = strlen(argv[2]) + 1;
 167                 lcfg.lcfg_inlbuf2 = argv[2];
 168         }
 169         if (argc > 3) {
 170                 lcfg.lcfg_inllen3 = strlen(argv[3]) + 1;
 171                 lcfg.lcfg_inlbuf3 = argv[3];
 172         }
 173         if (argc > 4) {
 174                 lcfg.lcfg_inllen4 = strlen(argv[4]) + 1;
 175                 lcfg.lcfg_inlbuf4 = argv[4];
 176         }
 177         if (argc > 5) {
 178                 lcfg.lcfg_inllen5 = strlen(argv[5]) + 1;
 179                 lcfg.lcfg_inlbuf5 = argv[5];
 180         }
 181         if (argc > 6) {
 182                 lcfg.lcfg_inllen6 = strlen(argv[6]) + 1;
 183                 lcfg.lcfg_inlbuf6 = argv[6];
 184         }
 185         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 186         if (rc < 0)
 187                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 188                         strerror(rc = errno));
 189
 190         return rc;
 191 }
 192
 193 int jt_obd_detach(int argc, char **argv)
 194 {
 195         struct lustre_cfg lcfg;
 196         int rc;
 197
 198         if (lcfg_devname == NULL) {
 199                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 200                         "device name for config commands.\n",
 201                         jt_cmdname(argv[0]));
 202                 return -EINVAL;
 203         }
 204
 205         LCFG_INIT(lcfg, LCFG_DETACH, lcfg_devname);
 206
 207         if (argc != 1)
 208                 return CMD_HELP;
 209
 210         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 211         if (rc < 0)
 212                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 213                         strerror(rc = errno));
 214
 215         return rc;
 216 }
 217
 218 int jt_obd_cleanup(int argc, char **argv)
 219 {
 220         struct lustre_cfg lcfg;
 221         char force = 'F';
 222         char failover = 'A';
 223         char flags[3];
 224         int flag_cnt = 0, n;
 225         int rc;
 226
 227         if (lcfg_devname == NULL) {
 228                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 229                         "device name for config commands.\n",
 230                         jt_cmdname(argv[0]));
 231                 return -EINVAL;
 232         }
 233
 234         LCFG_INIT(lcfg, LCFG_CLEANUP, lcfg_devname);
 235
 236         if (argc < 1 || argc > 3)
 237                 return CMD_HELP;
 238
 239         for (n = 1; n < argc; n++)
 240                 if (strcmp(argv[n], "force") == 0) {
 241                         flags[flag_cnt++] = force;
 242                 } else if (strcmp(argv[n], "failover") == 0) {
 243                         flags[flag_cnt++] = failover;
 244                 } else {
 245                         fprintf(stderr, "unknown option: %s", argv[n]);
 246                         return CMD_HELP;
 247                 }
 248
 249         lcfg.lcfg_inllen1 = flag_cnt;
 250         if (flag_cnt)
 251                 lcfg.lcfg_inlbuf1 = flags;
 252
 253         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 254         if (rc < 0)
 255                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 256                         strerror(rc = errno));
 257
 258         return rc;
 259 }
 260
 261 static
 262 int do_add_uuid(char * func, char *uuid, ptl_nid_t nid, int nal)
 263 {
 264         char tmp[64];
 265         int rc;
 266         struct lustre_cfg lcfg;
 267
 268         LCFG_INIT(lcfg, LCFG_ADD_UUID, lcfg_devname);
 269         lcfg.lcfg_nid = nid;
 270         lcfg.lcfg_inllen1 = strlen(uuid) + 1;
 271         lcfg.lcfg_inlbuf1 = uuid;
 272         lcfg.lcfg_nal = nal;
 273
 274         rc = lcfg_ioctl(func, OBD_DEV_ID, &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, ptl_nid2str (tmp, nid));
 282         return 0;
 283 }
 284
 285 int jt_lcfg_add_uuid(int argc, char **argv)
 286 {
 287         ptl_nid_t nid = 0;
 288         int nal;
 289
 290         if (argc != 4) {
 291                 return CMD_HELP;
 292         }
 293
 294         if (ptl_parse_nid (&nid, argv[2]) != 0) {
 295                 fprintf (stderr, "Can't parse NID %s\n", argv[2]);
 296                         return (-1);
 297         }
 298
 299         nal = ptl_name2nal(argv[3]);
 300
 301         if (nal <= 0) {
 302                 fprintf (stderr, "Can't parse NAL %s\n", argv[3]);
 303                 return -1;
 304         }
 305
 306         return do_add_uuid(argv[0], argv[1], nid, nal);
 307 }
 308
 309 int obd_add_uuid(char *uuid, ptl_nid_t nid, int nal)
 310 {
 311         return do_add_uuid("obd_add_uuid", uuid, nid, nal);
 312 }
 313
 314 int jt_lcfg_del_uuid(int argc, char **argv)
 315 {
 316         int rc;
 317         struct lustre_cfg lcfg;
 318
 319         if (argc != 2) {
 320                 fprintf(stderr, "usage: %s <uuid>\n", argv[0]);
 321                 return 0;
 322         }
 323
 324         LCFG_INIT(lcfg, LCFG_DEL_UUID, lcfg_devname);
 325
 326         if (strcmp (argv[1], "_all_"))
 327         {
 328                 lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
 329                 lcfg.lcfg_inlbuf1 = argv[1];
 330         }
 331
 332         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 333         if (rc) {
 334                 fprintf(stderr, "IOC_PORTAL_DEL_UUID failed: %s\n",
 335                         strerror(errno));
 336                 return -1;
 337         }
 338         return 0;
 339 }
 340
 341 int jt_lcfg_lov_setup(int argc, char **argv)
 342 {
 343         struct lustre_cfg lcfg;
 344         struct lov_desc desc;
 345         int rc;
 346         char *end;
 347
 348         /* argv: lov_setup <LOV uuid> <stripe count> <stripe size>
 349          *                 <stripe offset> <pattern> [ <max tgt index> ]
 350          */
 351         if (argc <= 6)
 352                 return CMD_HELP;
 353
 354         if (strlen(argv[1]) > sizeof(desc.ld_uuid) - 1) {
 355                 fprintf(stderr,
 356                         "error: %s: LOV uuid '%s' longer than "LPSZ" chars\n",
 357                         jt_cmdname(argv[0]), argv[1], sizeof(desc.ld_uuid) - 1);
 358                 return -EINVAL;
 359         }
 360
 361         memset(&desc, 0, sizeof(desc));
 362         obd_str2uuid(&desc.ld_uuid, argv[1]);
 363         desc.ld_default_stripe_count = strtoul(argv[2], &end, 0);
 364         if (*end) {
 365                 fprintf(stderr, "error: %s: bad default stripe count '%s'\n",
 366                         jt_cmdname(argv[0]), argv[2]);
 367                 return CMD_HELP;
 368         }
 369
 370         desc.ld_default_stripe_size = strtoull(argv[3], &end, 0);
 371         if (*end) {
 372                 fprintf(stderr, "error: %s: bad default stripe size '%s'\n",
 373                         jt_cmdname(argv[0]), argv[3]);
 374                 return CMD_HELP;
 375         }
 376         if (desc.ld_default_stripe_size < 4096) {
 377                 fprintf(stderr,
 378                         "error: %s: default stripe size "LPU64" too small\n",
 379                         jt_cmdname(argv[0]), desc.ld_default_stripe_size);
 380                 return -EINVAL;
 381         } else if ((long)desc.ld_default_stripe_size <
 382                    desc.ld_default_stripe_size) {
 383                 fprintf(stderr,
 384                         "error: %s: default stripe size "LPU64" too large\n",
 385                         jt_cmdname(argv[0]), desc.ld_default_stripe_size);
 386                 return -EINVAL;
 387         }
 388         desc.ld_default_stripe_offset = strtoull(argv[4], &end, 0);
 389         if (*end) {
 390                 fprintf(stderr, "error: %s: bad default stripe offset '%s'\n",
 391                         jt_cmdname(argv[0]), argv[4]);
 392                 return CMD_HELP;
 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         if (argc > 7) {
 402                 desc.ld_tgt_count = argc - 6;
 403                 if (desc.ld_default_stripe_count > desc.ld_tgt_count) {
 404                         fprintf(stderr,
 405                                 "error: %s: default stripe count %u > "
 406                                 "OST count %u\n", jt_cmdname(argv[0]),
 407                                 desc.ld_default_stripe_count,
 408                                 desc.ld_tgt_count);
 409                         return -EINVAL;
 410                 }
 411         }
 412
 413         LCFG_INIT(lcfg, LCFG_SETUP, lcfg_devname);
 414
 415         lcfg.lcfg_inllen1 = sizeof(desc);
 416         lcfg.lcfg_inlbuf1 = (char *)&desc;
 417
 418         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 419         if (rc)
 420                 fprintf(stderr, "error: %s: ioctl error: %s\n",
 421                         jt_cmdname(argv[0]), strerror(rc = errno));
 422         return rc;
 423 }
 424
 425 int jt_lcfg_lmv_setup(int argc, char **argv)
 426 {
 427         struct lustre_cfg lcfg;
 428         struct lmv_desc desc;
 429         struct obd_uuid *uuidarray, *ptr;
 430         int rc, i;
 431
 432         LCFG_INIT(lcfg, LCFG_SETUP, lcfg_devname);
 433
 434         if (argc <= 2)
 435                 return CMD_HELP;
 436
 437         if (strlen(argv[1]) > sizeof(desc.ld_uuid) - 1) {
 438                 fprintf(stderr,
 439                         "error: %s: LMV uuid '%s' longer than "LPSZ" chars\n",
 440                         jt_cmdname(argv[0]), argv[1], sizeof(desc.ld_uuid) - 1);
 441                 return -EINVAL;
 442         }
 443
 444         memset(&desc, 0, sizeof(desc));
 445         obd_str2uuid(&desc.ld_uuid, argv[1]);
 446         desc.ld_tgt_count = argc - 2;
 447         printf("LMV: %d uuids:\n", desc.ld_tgt_count);
 448
 449         /* NOTE: it is possible to overwrite the default striping parameters,
 450          *       but EXTREME care must be taken when saving the OST UUID list.
 451          *       It must be EXACTLY the same, or have only additions at the
 452          *       end of the list, or only overwrite individual OST entries
 453          *       that are restored from backups of the previous OST.
 454          */
 455         uuidarray = calloc(desc.ld_tgt_count, sizeof(*uuidarray));
 456         if (!uuidarray) {
 457                 fprintf(stderr, "error: %s: no memory for %d UUIDs\n",
 458                         jt_cmdname(argv[0]), desc.ld_tgt_count);
 459                 rc = -ENOMEM;
 460                 goto out;
 461         }
 462         for (i = 2, ptr = uuidarray; i < argc; i++, ptr++) {
 463                 if (strlen(argv[i]) >= sizeof(*ptr)) {
 464                         fprintf(stderr, "error: %s: arg %d (%s) too long\n",
 465                                 jt_cmdname(argv[0]), i, argv[i]);
 466                         rc = -EINVAL;
 467                         goto out;
 468                 }
 469                 printf("  %s\n", argv[i]);
 470                 strcpy((char *)ptr, argv[i]);
 471         }
 472
 473         lcfg.lcfg_inllen1 = sizeof(desc);
 474         lcfg.lcfg_inlbuf1 = (char *)&desc;
 475         lcfg.lcfg_inllen2 = desc.ld_tgt_count * sizeof(*uuidarray);
 476         lcfg.lcfg_inlbuf2 = (char *)uuidarray;
 477
 478         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 479         if (rc)
 480                 fprintf(stderr, "error: %s: ioctl error: %s\n",
 481                         jt_cmdname(argv[0]), strerror(rc = errno));
 482 out:
 483         free(uuidarray);
 484         return rc;
 485 }
 486
 487 int jt_lcfg_lov_modify_tgts(int argc, char **argv)
 488 {
 489         struct lustre_cfg lcfg;
 490         char *end;
 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                 LCFG_INIT(lcfg, LCFG_LOV_ADD_OBD, argv[2]);
 501         } else if (!strncmp(argv[1], "del", 4)) {
 502                 LCFG_INIT(lcfg, LCFG_LOV_DEL_OBD, argv[2]);
 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         lcfg.lcfg_inlbuf1 = argv[3];
 510         lcfg.lcfg_inllen1 = strlen(lcfg.lcfg_inlbuf1) + 1;
 511         if (lcfg.lcfg_inllen1 > sizeof(struct obd_uuid)) {
 512                 fprintf(stderr,
 513                         "error: %s: OBD uuid '%s' longer than "LPSZ" chars\n",
 514                         jt_cmdname(argv[0]), argv[3],
 515                         sizeof(struct obd_uuid) - 1);
 516                 return -EINVAL;
 517         }
 518
 519         index = strtoul(argv[4], &end, 0);
 520         if (*end) {
 521                 fprintf(stderr, "error: %s: bad OBD index '%s'\n",
 522                         jt_cmdname(argv[0]), argv[4]);
 523                 return CMD_HELP;
 524         }
 525         lcfg.lcfg_inlbuf2 = argv[4];
 526         lcfg.lcfg_inllen2 = strlen(lcfg.lcfg_inlbuf2);
 527
 528         gen = strtoul(argv[5], &end, 0);
 529         if (*end) {
 530                 fprintf(stderr, "error: %s: bad OBD generation '%s'\n",
 531                         jt_cmdname(argv[0]), argv[5]);
 532                 return CMD_HELP;
 533         }
 534         lcfg.lcfg_inlbuf3 = argv[5];
 535         lcfg.lcfg_inllen3 = strlen(lcfg.lcfg_inlbuf3);
 536
 537         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 538         if (rc)
 539                 fprintf(stderr, "error: %s: ioctl error: %s\n",
 540                         jt_cmdname(argv[0]), strerror(rc = errno));
 541
 542         return rc;
 543 }
 544
 545 int jt_lcfg_mount_option(int argc, char **argv)
 546 {
 547         int rc;
 548         struct lustre_cfg lcfg;
 549
 550         LCFG_INIT(lcfg, LCFG_MOUNTOPT, lcfg_devname);
 551
 552         if (argc < 3 || argc > 4)
 553                 return CMD_HELP;
 554
 555         /* profile name */
 556         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
 557         lcfg.lcfg_inlbuf1 = argv[1];
 558         /* osc name */
 559         lcfg.lcfg_inllen2 = strlen(argv[2]) + 1;
 560         lcfg.lcfg_inlbuf2 = argv[2];
 561         if (argc == 4) {
 562                 /* mdc name */
 563                 lcfg.lcfg_inllen3 = strlen(argv[3]) + 1;
 564                 lcfg.lcfg_inlbuf3 = argv[3];
 565         }
 566         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 567         if (rc < 0) {
 568                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 569                         strerror(rc = errno));
 570         }
 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 lcfg;
 579
 580         LCFG_INIT(lcfg, LCFG_DEL_MOUNTOPT, lcfg_devname);
 581
 582         if (argc != 2)
 583                 return CMD_HELP;
 584
 585         /* profile name */
 586         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
 587         lcfg.lcfg_inlbuf1 = argv[1];
 588
 589         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 590         if (rc < 0) {
 591                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 592                         strerror(rc = errno));
 593         }
 594
 595         return rc;
 596 }
 597
 598 int jt_lcfg_set_timeout(int argc, char **argv)
 599 {
 600         int rc;
 601         struct lustre_cfg lcfg;
 602
 603         LCFG_INIT(lcfg, LCFG_SET_TIMEOUT, lcfg_devname);
 604
 605         if (argc != 2)
 606                 return CMD_HELP;
 607
 608         lcfg.lcfg_num = atoi(argv[1]);
 609
 610         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 611         if (rc < 0) {
 612                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 613                         strerror(rc = errno));
 614         }
 615
 616         return rc;
 617 }
 618
 619
 620 int jt_lcfg_set_lustre_upcall(int argc, char **argv)
 621 {
 622         int rc;
 623         struct lustre_cfg lcfg;
 624
 625         LCFG_INIT(lcfg, LCFG_SET_UPCALL, lcfg_devname);
 626
 627         if (argc != 2)
 628                 return CMD_HELP;
 629
 630         /* profile name */
 631         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
 632         lcfg.lcfg_inlbuf1 = argv[1];
 633
 634         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 635         if (rc < 0) {
 636                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 637                         strerror(rc = errno));
 638         }
 639
 640         return rc;
 641 }
 642 int jt_lcfg_add_conn(int argc, char **argv)
 643 {
 644         struct lustre_cfg lcfg;
 645         int priority;
 646         int rc;
 647
 648         if (argc == 2)
 649                 priority = 0;
 650         else if (argc == 3)
 651                 priority = 1;
 652         else
 653                 return CMD_HELP;
 654
 655         if (lcfg_devname == NULL) {
 656                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 657                         "device name for config commands.\n",
 658                         jt_cmdname(argv[0]));
 659                return -EINVAL;
 660         }
 661
 662         LCFG_INIT(lcfg, LCFG_ADD_CONN, lcfg_devname);
 663
 664         /* connection uuid */
 665         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
 666         lcfg.lcfg_inlbuf1 = argv[1];
 667         lcfg.lcfg_inllen2 = sizeof(int);
 668         lcfg.lcfg_inlbuf2 = (char*) &priority;
 669
 670         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 671         if (rc < 0) {
 672                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 673                         strerror(rc = errno));
 674         }
 675
 676         return rc;
 677 }
 678
 679 int jt_lcfg_del_conn(int argc, char **argv)
 680 {
 681         struct lustre_cfg lcfg;
 682         int rc;
 683
 684         if (argc != 2)
 685                 return CMD_HELP;
 686
 687         if (lcfg_devname == NULL) {
 688                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 689                         "device name for config commands.\n",
 690                         jt_cmdname(argv[0]));
 691                return -EINVAL;
 692         }
 693
 694         LCFG_INIT(lcfg, LCFG_DEL_CONN, lcfg_devname);
 695
 696         /* connection uuid */
 697         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
 698         lcfg.lcfg_inlbuf1 = argv[1];
 699
 700         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 701         if (rc < 0) {
 702                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 703                         strerror(rc = errno));
 704         }
 705
 706         return rc;
 707 }
 708
 709 int jt_lcfg_set_security(int argc, char **argv)
 710 {
 711         struct lustre_cfg lcfg;
 712         int rc;
 713
 714         if (argc != 3)
 715                 return CMD_HELP;
 716
 717         if (lcfg_devname == NULL) {
 718                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 719                         "device name for config commands.\n",
 720                         jt_cmdname(argv[0]));
 721                return -EINVAL;
 722         }
 723
 724         LCFG_INIT(lcfg, LCFG_SET_SECURITY, lcfg_devname);
 725
 726         /* currently only used to set on mds */
 727         if (strcmp(argv[1], "mds_mds_sec") && strcmp(argv[1], "mds_ost_sec")) {
 728                 fprintf(stderr, "%s: invalid security key %s\n",
 729                         jt_cmdname(argv[0]), argv[1]);
 730                 return -EINVAL;
 731         }
 732         if (strcmp(argv[2], "null") && strcmp(argv[2], "krb5")) {
 733                 fprintf(stderr, "%s: invalid security value %s\n",
 734                         jt_cmdname(argv[0]), argv[2]);
 735                 return -EINVAL;
 736         }
 737
 738         /* connection uuid */
 739         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
 740         lcfg.lcfg_inlbuf1 = argv[1];
 741         lcfg.lcfg_inllen2 = strlen(argv[2]) + 1;
 742         lcfg.lcfg_inlbuf2 = argv[2];
 743
 744         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 745         if (rc < 0) {
 746                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 747                         strerror(rc = errno));
 748         }
 749
 750         return rc;
 751 }