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 > 5)
 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
 178         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 179         if (rc < 0)
 180                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 181                         strerror(rc = errno));
 182
 183         return rc;
 184 }
 185
 186 int jt_obd_detach(int argc, char **argv)
 187 {
 188         struct lustre_cfg lcfg;
 189         int rc;
 190
 191         if (lcfg_devname == NULL) {
 192                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 193                         "device name for config commands.\n",
 194                         jt_cmdname(argv[0]));
 195                 return -EINVAL;
 196         }
 197
 198         LCFG_INIT(lcfg, LCFG_DETACH, lcfg_devname);
 199
 200         if (argc != 1)
 201                 return CMD_HELP;
 202
 203         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 204         if (rc < 0)
 205                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 206                         strerror(rc = errno));
 207
 208         return rc;
 209 }
 210
 211 int jt_obd_cleanup(int argc, char **argv)
 212 {
 213         struct lustre_cfg lcfg;
 214         char force = 'F';
 215         char failover = 'A';
 216         char flags[3];
 217         int flag_cnt = 0, n;
 218         int rc;
 219
 220         if (lcfg_devname == NULL) {
 221                 fprintf(stderr, "%s: please use 'cfg_device name' to set the "
 222                         "device name for config commands.\n",
 223                         jt_cmdname(argv[0]));
 224                 return -EINVAL;
 225         }
 226
 227         LCFG_INIT(lcfg, LCFG_CLEANUP, lcfg_devname);
 228
 229         if (argc < 1 || argc > 3)
 230                 return CMD_HELP;
 231
 232         for (n = 1; n < argc; n++)
 233                 if (strcmp(argv[n], "force") == 0) {
 234                         flags[flag_cnt++] = force;
 235                 } else if (strcmp(argv[n], "failover") == 0) {
 236                         flags[flag_cnt++] = failover;
 237                 } else {
 238                         fprintf(stderr, "unknown option: %s", argv[n]);
 239                         return CMD_HELP;
 240                 }
 241
 242         lcfg.lcfg_inllen1 = flag_cnt;
 243         if (flag_cnt)
 244                 lcfg.lcfg_inlbuf1 = flags;
 245
 246         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &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 lcfg;
 260
 261         LCFG_INIT(lcfg, LCFG_ADD_UUID, lcfg_devname);
 262         lcfg.lcfg_nid = nid;
 263         lcfg.lcfg_inllen1 = strlen(uuid) + 1;
 264         lcfg.lcfg_inlbuf1 = uuid;
 265         lcfg.lcfg_nal = nal;
 266
 267         rc = lcfg_ioctl(func, OBD_DEV_ID, &lcfg);
 268         if (rc) {
 269                 fprintf(stderr, "IOC_PORTAL_ADD_UUID failed: %s\n",
 270                         strerror(errno));
 271                 return -1;
 272         }
 273
 274         printf ("Added uuid %s: %s\n", uuid, ptl_nid2str (tmp, nid));
 275         return 0;
 276 }
 277
 278 int jt_lcfg_add_uuid(int argc, char **argv)
 279 {
 280         ptl_nid_t nid = 0;
 281         int nal;
 282
 283         if (argc != 4) {
 284                 return CMD_HELP;
 285         }
 286
 287         if (ptl_parse_nid (&nid, argv[2]) != 0) {
 288                 fprintf (stderr, "Can't parse NID %s\n", argv[2]);
 289                         return (-1);
 290         }
 291
 292         nal = ptl_name2nal(argv[3]);
 293
 294         if (nal <= 0) {
 295                 fprintf (stderr, "Can't parse NAL %s\n", argv[3]);
 296                 return -1;
 297         }
 298
 299         return do_add_uuid(argv[0], argv[1], nid, nal);
 300 }
 301
 302 int obd_add_uuid(char *uuid, ptl_nid_t nid, int nal)
 303 {
 304         return do_add_uuid("obd_add_uuid", uuid, nid, nal);
 305 }
 306
 307 int jt_lcfg_del_uuid(int argc, char **argv)
 308 {
 309         int rc;
 310         struct lustre_cfg lcfg;
 311
 312         if (argc != 2) {
 313                 fprintf(stderr, "usage: %s <uuid>\n", argv[0]);
 314                 return 0;
 315         }
 316
 317         LCFG_INIT(lcfg, LCFG_DEL_UUID, lcfg_devname);
 318
 319         if (strcmp (argv[1], "_all_"))
 320         {
 321                 lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
 322                 lcfg.lcfg_inlbuf1 = argv[1];
 323         }
 324
 325         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 326         if (rc) {
 327                 fprintf(stderr, "IOC_PORTAL_DEL_UUID failed: %s\n",
 328                         strerror(errno));
 329                 return -1;
 330         }
 331         return 0;
 332 }
 333
 334 int jt_lcfg_lov_setup(int argc, char **argv)
 335 {
 336         struct lustre_cfg lcfg;
 337         struct lov_desc desc;
 338         struct obd_uuid *uuidarray, *ptr;
 339         int rc, i;
 340         char *end;
 341
 342         LCFG_INIT(lcfg, LCFG_SETUP, lcfg_devname);
 343
 344         if (argc <= 6)
 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 = argc - 6;
 357         desc.ld_default_stripe_count = strtoul(argv[2], &end, 0);
 358         if (*end) {
 359                 fprintf(stderr, "error: %s: bad default stripe count '%s'\n",
 360                         jt_cmdname(argv[0]), argv[2]);
 361                 return CMD_HELP;
 362         }
 363         if (desc.ld_default_stripe_count > desc.ld_tgt_count) {
 364                 fprintf(stderr,
 365                         "error: %s: default stripe count %u > OST count %u\n",
 366                         jt_cmdname(argv[0]), desc.ld_default_stripe_count,
 367                         desc.ld_tgt_count);
 368                 return -EINVAL;
 369         }
 370
 371         desc.ld_default_stripe_size = strtoull(argv[3], &end, 0);
 372         if (*end) {
 373                 fprintf(stderr, "error: %s: bad default stripe size '%s'\n",
 374                         jt_cmdname(argv[0]), argv[3]);
 375                 return CMD_HELP;
 376         }
 377         if (desc.ld_default_stripe_size < 4096) {
 378                 fprintf(stderr,
 379                         "error: %s: default stripe size "LPU64" too small\n",
 380                         jt_cmdname(argv[0]), desc.ld_default_stripe_size);
 381                 return -EINVAL;
 382         } else if ((long)desc.ld_default_stripe_size <
 383                    desc.ld_default_stripe_size) {
 384                 fprintf(stderr,
 385                         "error: %s: default stripe size "LPU64" too large\n",
 386                         jt_cmdname(argv[0]), desc.ld_default_stripe_size);
 387                 return -EINVAL;
 388         }
 389         desc.ld_default_stripe_offset = strtoull(argv[4], &end, 0);
 390         if (*end) {
 391                 fprintf(stderr, "error: %s: bad default stripe offset '%s'\n",
 392                         jt_cmdname(argv[0]), argv[4]);
 393                 return CMD_HELP;
 394         }
 395         desc.ld_pattern = strtoul(argv[5], &end, 0);
 396         if (*end) {
 397                 fprintf(stderr, "error: %s: bad stripe pattern '%s'\n",
 398                         jt_cmdname(argv[0]), argv[5]);
 399                 return CMD_HELP;
 400         }
 401
 402         /* NOTE: it is possible to overwrite the default striping parameters,
 403          *       but EXTREME care must be taken when saving the OST UUID list.
 404          *       It must be EXACTLY the same, or have only additions at the
 405          *       end of the list, or only overwrite individual OST entries
 406          *       that are restored from backups of the previous OST.
 407          */
 408         uuidarray = calloc(desc.ld_tgt_count, sizeof(*uuidarray));
 409         if (!uuidarray) {
 410                 fprintf(stderr, "error: %s: no memory for %d UUIDs\n",
 411                         jt_cmdname(argv[0]), desc.ld_tgt_count);
 412                 rc = -ENOMEM;
 413                 goto out;
 414         }
 415         for (i = 6, ptr = uuidarray; i < argc; i++, ptr++) {
 416                 if (strlen(argv[i]) >= sizeof(*ptr)) {
 417                         fprintf(stderr, "error: %s: arg %d (%s) too long\n",
 418                                 jt_cmdname(argv[0]), i, argv[i]);
 419                         rc = -EINVAL;
 420                         goto out;
 421                 }
 422                 strcpy((char *)ptr, argv[i]);
 423         }
 424
 425         lcfg.lcfg_inllen1 = sizeof(desc);
 426         lcfg.lcfg_inlbuf1 = (char *)&desc;
 427         lcfg.lcfg_inllen2 = desc.ld_tgt_count * sizeof(*uuidarray);
 428         lcfg.lcfg_inlbuf2 = (char *)uuidarray;
 429
 430         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 431         if (rc)
 432                 fprintf(stderr, "error: %s: ioctl error: %s\n",
 433                         jt_cmdname(argv[0]), strerror(rc = errno));
 434 out:
 435         free(uuidarray);
 436         return rc;
 437 }
 438
 439 int jt_lcfg_mount_option(int argc, char **argv)
 440 {
 441         int rc;
 442         struct lustre_cfg lcfg;
 443
 444         LCFG_INIT(lcfg, LCFG_MOUNTOPT, lcfg_devname);
 445
 446         if (argc < 3 || argc > 4)
 447                 return CMD_HELP;
 448
 449         /* profile name */
 450         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
 451         lcfg.lcfg_inlbuf1 = argv[1];
 452         /* osc name */
 453         lcfg.lcfg_inllen2 = strlen(argv[2]) + 1;
 454         lcfg.lcfg_inlbuf2 = argv[2];
 455         if (argc == 4) {
 456                 /* mdc name */
 457                 lcfg.lcfg_inllen3 = strlen(argv[3]) + 1;
 458                 lcfg.lcfg_inlbuf3 = argv[3];
 459         }
 460         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 461         if (rc < 0) {
 462                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 463                         strerror(rc = errno));
 464         }
 465
 466         return rc;
 467 }
 468
 469 int jt_lcfg_del_mount_option(int argc, char **argv)
 470 {
 471         int rc;
 472         struct lustre_cfg lcfg;
 473
 474         LCFG_INIT(lcfg, LCFG_DEL_MOUNTOPT, lcfg_devname);
 475
 476         if (argc != 2)
 477                 return CMD_HELP;
 478
 479         /* profile name */
 480         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
 481         lcfg.lcfg_inlbuf1 = argv[1];
 482
 483         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 484         if (rc < 0) {
 485                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 486                         strerror(rc = errno));
 487         }
 488
 489         return rc;
 490 }
 491
 492 int jt_lcfg_set_timeout(int argc, char **argv)
 493 {
 494         int rc;
 495         struct lustre_cfg lcfg;
 496
 497         LCFG_INIT(lcfg, LCFG_SET_TIMEOUT, lcfg_devname);
 498
 499         if (argc != 2)
 500                 return CMD_HELP;
 501
 502         lcfg.lcfg_num = atoi(argv[1]);
 503
 504         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 505         if (rc < 0) {
 506                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 507                         strerror(rc = errno));
 508         }
 509
 510         return rc;
 511 }
 512
 513
 514 int jt_lcfg_set_lustre_upcall(int argc, char **argv)
 515 {
 516         int rc;
 517         struct lustre_cfg lcfg;
 518
 519         LCFG_INIT(lcfg, LCFG_SET_UPCALL, lcfg_devname);
 520
 521         if (argc != 2)
 522                 return CMD_HELP;
 523
 524         /* profile name */
 525         lcfg.lcfg_inllen1 = strlen(argv[1]) + 1;
 526         lcfg.lcfg_inlbuf1 = argv[1];
 527
 528         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, &lcfg);
 529         if (rc < 0) {
 530                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 531                         strerror(rc = errno));
 532         }
 533
 534         return rc;
 535 }
 536