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 #include <stdlib.h>
  28 #include <sys/ioctl.h>
  29 #include <stdio.h>
  30 #include <stdarg.h>
  31 #include <ctype.h>
  32
  33 #ifndef __KERNEL__
  34 #include <liblustre.h>
  35 #endif
  36 #include <lustre_lib.h>
  37 #include <lustre_cfg.h>
  38 #include <lustre/lustre_idl.h>
  39 #include <lustre_dlm.h>
  40 #include <obd.h>          /* for struct lov_stripe_md */
  41 #include <obd_lov.h>
  42 #include <lustre/lustre_build_version.h>
  43
  44 #include <unistd.h>
  45 #include <sys/un.h>
  46 #include <time.h>
  47 #include <sys/time.h>
  48 #include <errno.h>
  49 #include <string.h>
  50
  51
  52 #include "obdctl.h"
  53 #include <lnet/lnetctl.h>
  54 #include "parser.h"
  55 #include <stdio.h>
  56
  57 static char * lcfg_devname;
  58
  59 int lcfg_set_devname(char *name)
  60 {
  61         if (name) {
  62                 if (lcfg_devname)
  63                         free(lcfg_devname);
  64                 /* quietly strip the unnecessary '$' */
  65                 if (*name == '$' || *name == '%')
  66                         name++;
  67                 if (isdigit(*name)) {
  68                         /* We can't translate from dev # to name */
  69                         lcfg_devname = NULL;
  70                 } else {
  71                         lcfg_devname = strdup(name);
  72                 }
  73         } else {
  74                 lcfg_devname = NULL;
  75         }
  76         return 0;
  77 }
  78
  79 char * lcfg_get_devname(void)
  80 {
  81         return lcfg_devname;
  82 }
  83
  84 int jt_lcfg_device(int argc, char **argv)
  85 {
  86         return jt_obd_device(argc, argv);
  87 }
  88
  89 int jt_lcfg_attach(int argc, char **argv)
  90 {
  91         struct lustre_cfg_bufs bufs;
  92         struct lustre_cfg *lcfg;
  93         int rc;
  94
  95         if (argc != 4)
  96                 return CMD_HELP;
  97
  98         lustre_cfg_bufs_reset(&bufs, NULL);
  99
 100         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 101         lustre_cfg_bufs_set_string(&bufs, 0, argv[2]);
 102         lustre_cfg_bufs_set_string(&bufs, 2, argv[3]);
 103
 104         lcfg = lustre_cfg_new(LCFG_ATTACH, &bufs);
 105         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 106         lustre_cfg_free(lcfg);
 107         if (rc < 0) {
 108                 fprintf(stderr, "error: %s: LCFG_ATTACH %s\n",
 109                         jt_cmdname(argv[0]), strerror(rc = errno));
 110         } else if (argc == 3) {
 111                 char name[1024];
 112
 113                 lcfg_set_devname(argv[2]);
 114                 if (strlen(argv[2]) > 128) {
 115                         printf("Name too long to set environment\n");
 116                         return -EINVAL;
 117                 }
 118                 snprintf(name, 512, "LUSTRE_DEV_%s", argv[2]);
 119                 rc = setenv(name, argv[1], 1);
 120                 if (rc) {
 121                         printf("error setting env variable %s\n", name);
 122                 }
 123         } else {
 124                 lcfg_set_devname(argv[2]);
 125         }
 126
 127         return rc;
 128 }
 129
 130 int jt_lcfg_setup(int argc, char **argv)
 131 {
 132         struct lustre_cfg_bufs bufs;
 133         struct lustre_cfg *lcfg;
 134         int i;
 135         int rc;
 136
 137         if (lcfg_devname == NULL) {
 138                 fprintf(stderr, "%s: please use 'device name' to set the "
 139                         "device name for config commands.\n",
 140                         jt_cmdname(argv[0]));
 141                 return -EINVAL;
 142         }
 143
 144         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 145
 146         if (argc > 6)
 147                 return CMD_HELP;
 148
 149         for (i = 1; i < argc; i++) {
 150                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
 151         }
 152
 153         lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
 154         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 155         lustre_cfg_free(lcfg);
 156         if (rc < 0)
 157                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 158                         strerror(rc = errno));
 159
 160         return rc;
 161 }
 162
 163 int jt_obd_detach(int argc, char **argv)
 164 {
 165         struct lustre_cfg_bufs bufs;
 166         struct lustre_cfg *lcfg;
 167         int rc;
 168
 169         if (lcfg_devname == NULL) {
 170                 fprintf(stderr, "%s: please use 'device name' to set the "
 171                         "device name for config commands.\n",
 172                         jt_cmdname(argv[0]));
 173                 return -EINVAL;
 174         }
 175
 176         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 177
 178         if (argc != 1)
 179                 return CMD_HELP;
 180
 181         lcfg = lustre_cfg_new(LCFG_DETACH, &bufs);
 182         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 183         lustre_cfg_free(lcfg);
 184         if (rc < 0)
 185                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 186                         strerror(rc = errno));
 187
 188         return rc;
 189 }
 190
 191 int jt_obd_cleanup(int argc, char **argv)
 192 {
 193         struct lustre_cfg_bufs bufs;
 194         struct lustre_cfg *lcfg;
 195         char force = 'F';
 196         char failover = 'A';
 197         char flags[3] = { 0 };
 198         int flag_cnt = 0, n;
 199         int rc;
 200
 201         if (lcfg_devname == NULL) {
 202                 fprintf(stderr, "%s: please use 'device name' to set the "
 203                         "device name for config commands.\n",
 204                         jt_cmdname(argv[0]));
 205                 return -EINVAL;
 206         }
 207
 208         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 209
 210         if (argc < 1 || argc > 3)
 211                 return CMD_HELP;
 212
 213         /* we are protected from overflowing our buffer by the argc
 214          * check above
 215          */
 216         for (n = 1; n < argc; n++) {
 217                 if (strcmp(argv[n], "force") == 0) {
 218                         flags[flag_cnt++] = force;
 219                 } else if (strcmp(argv[n], "failover") == 0) {
 220                         flags[flag_cnt++] = failover;
 221                 } else {
 222                         fprintf(stderr, "unknown option: %s", argv[n]);
 223                         return CMD_HELP;
 224                 }
 225         }
 226
 227         if (flag_cnt) {
 228                 lustre_cfg_bufs_set_string(&bufs, 1, flags);
 229         }
 230
 231         lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs);
 232         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 233         lustre_cfg_free(lcfg);
 234         if (rc < 0)
 235                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 236                         strerror(rc = errno));
 237
 238         return rc;
 239 }
 240
 241 static
 242 int do_add_uuid(char * func, char *uuid, lnet_nid_t nid)
 243 {
 244         int rc;
 245         struct lustre_cfg_bufs bufs;
 246         struct lustre_cfg *lcfg;
 247
 248         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 249         if (uuid)
 250                 lustre_cfg_bufs_set_string(&bufs, 1, uuid);
 251
 252         lcfg = lustre_cfg_new(LCFG_ADD_UUID, &bufs);
 253         lcfg->lcfg_nid = nid;
 254         /* Poison NAL -- pre 1.4.6 will LASSERT on 0 NAL, this way it
 255            doesn't work without crashing (bz 10130) */
 256         lcfg->lcfg_nal = 0x5a;
 257
 258 #if 0
 259         fprintf(stderr, "adding\tnid: %d\tuuid: %s\n",
 260                lcfg->lcfg_nid, uuid);
 261 #endif
 262         rc = lcfg_ioctl(func, OBD_DEV_ID, lcfg);
 263         lustre_cfg_free(lcfg);
 264         if (rc) {
 265                 fprintf(stderr, "IOC_PORTAL_ADD_UUID failed: %s\n",
 266                         strerror(errno));
 267                 return -1;
 268         }
 269
 270         printf ("Added uuid %s: %s\n", uuid, libcfs_nid2str(nid));
 271         return 0;
 272 }
 273
 274 int jt_lcfg_add_uuid(int argc, char **argv)
 275 {
 276         lnet_nid_t nid;
 277
 278         if (argc != 3) {
 279                 return CMD_HELP;
 280         }
 281
 282         nid = libcfs_str2nid(argv[2]);
 283         if (nid == LNET_NID_ANY) {
 284                 fprintf (stderr, "Can't parse NID %s\n", argv[2]);
 285                 return (-1);
 286         }
 287
 288         return do_add_uuid(argv[0], argv[1], nid);
 289 }
 290
 291 int obd_add_uuid(char *uuid, lnet_nid_t nid)
 292 {
 293         return do_add_uuid("obd_add_uuid", uuid, nid);
 294 }
 295
 296 int jt_lcfg_del_uuid(int argc, char **argv)
 297 {
 298         int rc;
 299         struct lustre_cfg_bufs bufs;
 300         struct lustre_cfg *lcfg;
 301
 302         if (argc != 2) {
 303                 fprintf(stderr, "usage: %s <uuid>\n", argv[0]);
 304                 return 0;
 305         }
 306
 307         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 308         if (strcmp (argv[1], "_all_"))
 309                 lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 310
 311         lcfg = lustre_cfg_new(LCFG_DEL_UUID, &bufs);
 312         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 313         lustre_cfg_free(lcfg);
 314         if (rc) {
 315                 fprintf(stderr, "IOC_PORTAL_DEL_UUID failed: %s\n",
 316                         strerror(errno));
 317                 return -1;
 318         }
 319         return 0;
 320 }
 321
 322
 323
 324
 325 int jt_lcfg_del_mount_option(int argc, char **argv)
 326 {
 327         int rc;
 328         struct lustre_cfg_bufs bufs;
 329         struct lustre_cfg *lcfg;
 330
 331         if (argc != 2)
 332                 return CMD_HELP;
 333
 334         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 335
 336         /* profile name */
 337         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 338
 339         lcfg = lustre_cfg_new(LCFG_DEL_MOUNTOPT, &bufs);
 340         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 341         lustre_cfg_free(lcfg);
 342         if (rc < 0) {
 343                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 344                         strerror(rc = errno));
 345         }
 346         return rc;
 347 }
 348
 349 int jt_lcfg_set_timeout(int argc, char **argv)
 350 {
 351         int rc;
 352         struct lustre_cfg_bufs bufs;
 353         struct lustre_cfg *lcfg;
 354
 355         fprintf(stderr, "%s has been deprecated. Use conf_param instead.\n"
 356                 "e.g. conf_param lustre-MDT0000 obd_timeout=50\n",
 357                 jt_cmdname(argv[0]));
 358         return CMD_HELP;
 359
 360
 361         if (argc != 2)
 362                 return CMD_HELP;
 363
 364         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 365         lcfg = lustre_cfg_new(LCFG_SET_TIMEOUT, &bufs);
 366         lcfg->lcfg_num = atoi(argv[1]);
 367
 368         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 369         //rc = lcfg_mgs_ioctl(argv[0], OBD_DEV_ID, lcfg);
 370
 371         lustre_cfg_free(lcfg);
 372         if (rc < 0) {
 373                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 374                         strerror(rc = errno));
 375         }
 376         return rc;
 377 }
 378
 379
 380
 381 int jt_lcfg_add_conn(int argc, char **argv)
 382 {
 383         struct lustre_cfg_bufs bufs;
 384         struct lustre_cfg *lcfg;
 385         int priority;
 386         int rc;
 387
 388         if (argc == 2)
 389                 priority = 0;
 390         else if (argc == 3)
 391                 priority = 1;
 392         else
 393                 return CMD_HELP;
 394
 395         if (lcfg_devname == NULL) {
 396                 fprintf(stderr, "%s: please use 'device name' to set the "
 397                         "device name for config commands.\n",
 398                         jt_cmdname(argv[0]));
 399                 return -EINVAL;
 400         }
 401
 402         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 403
 404         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 405
 406         lcfg = lustre_cfg_new(LCFG_ADD_CONN, &bufs);
 407         lcfg->lcfg_num = priority;
 408
 409         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 410         lustre_cfg_free (lcfg);
 411         if (rc < 0) {
 412                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 413                         strerror(rc = errno));
 414         }
 415
 416         return rc;
 417 }
 418
 419 int jt_lcfg_del_conn(int argc, char **argv)
 420 {
 421         struct lustre_cfg_bufs bufs;
 422         struct lustre_cfg *lcfg;
 423         int rc;
 424
 425         if (argc != 2)
 426                 return CMD_HELP;
 427
 428         if (lcfg_devname == NULL) {
 429                 fprintf(stderr, "%s: please use 'device name' to set the "
 430                         "device name for config commands.\n",
 431                         jt_cmdname(argv[0]));
 432                 return -EINVAL;
 433         }
 434
 435         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 436
 437         /* connection uuid */
 438         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 439
 440         lcfg = lustre_cfg_new(LCFG_DEL_MOUNTOPT, &bufs);
 441
 442         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 443         lustre_cfg_free(lcfg);
 444         if (rc < 0) {
 445                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 446                         strerror(rc = errno));
 447         }
 448
 449         return rc;
 450 }
 451
 452 /* Param set locally, directly on target */
 453 int jt_lcfg_param(int argc, char **argv)
 454 {
 455         int i, rc;
 456         struct lustre_cfg_bufs bufs;
 457         struct lustre_cfg *lcfg;
 458
 459         if (argc >= LUSTRE_CFG_MAX_BUFCOUNT)
 460                 return CMD_HELP;
 461
 462         lustre_cfg_bufs_reset(&bufs, NULL);
 463
 464         for (i = 1; i < argc; i++) {
 465                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
 466         }
 467
 468         lcfg = lustre_cfg_new(LCFG_PARAM, &bufs);
 469
 470         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 471         lustre_cfg_free(lcfg);
 472         if (rc < 0) {
 473                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 474                         strerror(rc = errno));
 475         }
 476         return rc;
 477 }
 478
 479 /* Param set in config log on MGS */
 480 /* conf_param key1=value1 [key2=value2...] */
 481 int jt_lcfg_mgsparam(int argc, char **argv)
 482 {
 483         int i, rc;
 484         struct lustre_cfg_bufs bufs;
 485         struct lustre_cfg *lcfg;
 486
 487         if ((argc >= LUSTRE_CFG_MAX_BUFCOUNT) || (argc <= 1))
 488                 return CMD_HELP;
 489
 490         lustre_cfg_bufs_reset(&bufs, NULL);
 491         for (i = 1; i < argc; i++) {
 492                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
 493         }
 494
 495         /* We could put other opcodes here. */
 496         lcfg = lustre_cfg_new(LCFG_PARAM, &bufs);
 497
 498         rc = lcfg_mgs_ioctl(argv[0], OBD_DEV_ID, lcfg);
 499         lustre_cfg_free(lcfg);
 500         if (rc < 0) {
 501                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 502                         strerror(rc = errno));
 503         }
 504
 505         return rc;
 506 }
 507
 508