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  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright  2008 Sun Microsystems, Inc. All rights reserved
  30  * Use is subject to license terms.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * lustre/utils/lustre_cfg.c
  37  *
  38  * Author: Peter J. Braam <braam@clusterfs.com>
  39  * Author: Phil Schwan <phil@clusterfs.com>
  40  * Author: Andreas Dilger <adilger@clusterfs.com>
  41  * Author: Robert Read <rread@clusterfs.com>
  42  */
  43
  44 #include <stdlib.h>
  45 #include <sys/ioctl.h>
  46 #include <stdio.h>
  47 #include <stdarg.h>
  48 #include <ctype.h>
  49 #include <glob.h>
  50
  51 #ifndef __KERNEL__
  52 #include <liblustre.h>
  53 #endif
  54 #include <lustre_lib.h>
  55 #include <lustre_cfg.h>
  56 #include <lustre/lustre_idl.h>
  57 #include <lustre_dlm.h>
  58 #include <obd.h>          /* for struct lov_stripe_md */
  59 #include <obd_lov.h>
  60 #include <lustre/lustre_build_version.h>
  61
  62 #include <unistd.h>
  63 #include <sys/un.h>
  64 #include <time.h>
  65 #include <sys/time.h>
  66 #include <errno.h>
  67 #include <string.h>
  68
  69
  70 #include "obdctl.h"
  71 #include <lnet/lnetctl.h>
  72 #include "parser.h"
  73 #include <stdio.h>
  74
  75 static char * lcfg_devname;
  76
  77 int lcfg_set_devname(char *name)
  78 {
  79         if (name) {
  80                 if (lcfg_devname)
  81                         free(lcfg_devname);
  82                 /* quietly strip the unnecessary '$' */
  83                 if (*name == '$' || *name == '%')
  84                         name++;
  85                 if (isdigit(*name)) {
  86                         /* We can't translate from dev # to name */
  87                         lcfg_devname = NULL;
  88                 } else {
  89                         lcfg_devname = strdup(name);
  90                 }
  91         } else {
  92                 lcfg_devname = NULL;
  93         }
  94         return 0;
  95 }
  96
  97 char * lcfg_get_devname(void)
  98 {
  99         return lcfg_devname;
 100 }
 101
 102 int jt_lcfg_device(int argc, char **argv)
 103 {
 104         return jt_obd_device(argc, argv);
 105 }
 106
 107 int jt_lcfg_attach(int argc, char **argv)
 108 {
 109         struct lustre_cfg_bufs bufs;
 110         struct lustre_cfg *lcfg;
 111         int rc;
 112
 113         if (argc != 4)
 114                 return CMD_HELP;
 115
 116         lustre_cfg_bufs_reset(&bufs, NULL);
 117
 118         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 119         lustre_cfg_bufs_set_string(&bufs, 0, argv[2]);
 120         lustre_cfg_bufs_set_string(&bufs, 2, argv[3]);
 121
 122         lcfg = lustre_cfg_new(LCFG_ATTACH, &bufs);
 123         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 124         lustre_cfg_free(lcfg);
 125         if (rc < 0) {
 126                 fprintf(stderr, "error: %s: LCFG_ATTACH %s\n",
 127                         jt_cmdname(argv[0]), strerror(rc = errno));
 128         } else if (argc == 3) {
 129                 char name[1024];
 130
 131                 lcfg_set_devname(argv[2]);
 132                 if (strlen(argv[2]) > 128) {
 133                         printf("Name too long to set environment\n");
 134                         return -EINVAL;
 135                 }
 136                 snprintf(name, 512, "LUSTRE_DEV_%s", argv[2]);
 137                 rc = setenv(name, argv[1], 1);
 138                 if (rc) {
 139                         printf("error setting env variable %s\n", name);
 140                 }
 141         } else {
 142                 lcfg_set_devname(argv[2]);
 143         }
 144
 145         return rc;
 146 }
 147
 148 int jt_lcfg_setup(int argc, char **argv)
 149 {
 150         struct lustre_cfg_bufs bufs;
 151         struct lustre_cfg *lcfg;
 152         int i;
 153         int rc;
 154
 155         if (lcfg_devname == NULL) {
 156                 fprintf(stderr, "%s: please use 'device name' to set the "
 157                         "device name for config commands.\n",
 158                         jt_cmdname(argv[0]));
 159                 return -EINVAL;
 160         }
 161
 162         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 163
 164         if (argc > 6)
 165                 return CMD_HELP;
 166
 167         for (i = 1; i < argc; i++) {
 168                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
 169         }
 170
 171         lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
 172         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 173         lustre_cfg_free(lcfg);
 174         if (rc < 0)
 175                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 176                         strerror(rc = errno));
 177
 178         return rc;
 179 }
 180
 181 int jt_obd_detach(int argc, char **argv)
 182 {
 183         struct lustre_cfg_bufs bufs;
 184         struct lustre_cfg *lcfg;
 185         int rc;
 186
 187         if (lcfg_devname == NULL) {
 188                 fprintf(stderr, "%s: please use 'device name' to set the "
 189                         "device name for config commands.\n",
 190                         jt_cmdname(argv[0]));
 191                 return -EINVAL;
 192         }
 193
 194         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 195
 196         if (argc != 1)
 197                 return CMD_HELP;
 198
 199         lcfg = lustre_cfg_new(LCFG_DETACH, &bufs);
 200         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 201         lustre_cfg_free(lcfg);
 202         if (rc < 0)
 203                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 204                         strerror(rc = errno));
 205
 206         return rc;
 207 }
 208
 209 int jt_obd_cleanup(int argc, char **argv)
 210 {
 211         struct lustre_cfg_bufs bufs;
 212         struct lustre_cfg *lcfg;
 213         char force = 'F';
 214         char failover = 'A';
 215         char flags[3] = { 0 };
 216         int flag_cnt = 0, n;
 217         int rc;
 218
 219         if (lcfg_devname == NULL) {
 220                 fprintf(stderr, "%s: please use 'device name' to set the "
 221                         "device name for config commands.\n",
 222                         jt_cmdname(argv[0]));
 223                 return -EINVAL;
 224         }
 225
 226         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 227
 228         if (argc < 1 || argc > 3)
 229                 return CMD_HELP;
 230
 231         /* we are protected from overflowing our buffer by the argc
 232          * check above
 233          */
 234         for (n = 1; n < argc; n++) {
 235                 if (strcmp(argv[n], "force") == 0) {
 236                         flags[flag_cnt++] = force;
 237                 } else if (strcmp(argv[n], "failover") == 0) {
 238                         flags[flag_cnt++] = failover;
 239                 } else {
 240                         fprintf(stderr, "unknown option: %s", argv[n]);
 241                         return CMD_HELP;
 242                 }
 243         }
 244
 245         if (flag_cnt) {
 246                 lustre_cfg_bufs_set_string(&bufs, 1, flags);
 247         }
 248
 249         lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs);
 250         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 251         lustre_cfg_free(lcfg);
 252         if (rc < 0)
 253                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 254                         strerror(rc = errno));
 255
 256         return rc;
 257 }
 258
 259 static
 260 int do_add_uuid(char * func, char *uuid, lnet_nid_t nid)
 261 {
 262         int rc;
 263         struct lustre_cfg_bufs bufs;
 264         struct lustre_cfg *lcfg;
 265
 266         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 267         if (uuid)
 268                 lustre_cfg_bufs_set_string(&bufs, 1, uuid);
 269
 270         lcfg = lustre_cfg_new(LCFG_ADD_UUID, &bufs);
 271         lcfg->lcfg_nid = nid;
 272         /* Poison NAL -- pre 1.4.6 will LASSERT on 0 NAL, this way it
 273            doesn't work without crashing (bz 10130) */
 274         lcfg->lcfg_nal = 0x5a;
 275
 276 #if 0
 277         fprintf(stderr, "adding\tnid: %d\tuuid: %s\n",
 278                lcfg->lcfg_nid, uuid);
 279 #endif
 280         rc = lcfg_ioctl(func, OBD_DEV_ID, lcfg);
 281         lustre_cfg_free(lcfg);
 282         if (rc) {
 283                 fprintf(stderr, "IOC_PORTAL_ADD_UUID failed: %s\n",
 284                         strerror(errno));
 285                 return -1;
 286         }
 287
 288         printf ("Added uuid %s: %s\n", uuid, libcfs_nid2str(nid));
 289         return 0;
 290 }
 291
 292 int jt_lcfg_add_uuid(int argc, char **argv)
 293 {
 294         lnet_nid_t nid;
 295
 296         if (argc != 3) {
 297                 return CMD_HELP;
 298         }
 299
 300         nid = libcfs_str2nid(argv[2]);
 301         if (nid == LNET_NID_ANY) {
 302                 fprintf (stderr, "Can't parse NID %s\n", argv[2]);
 303                 return (-1);
 304         }
 305
 306         return do_add_uuid(argv[0], argv[1], nid);
 307 }
 308
 309 int obd_add_uuid(char *uuid, lnet_nid_t nid)
 310 {
 311         return do_add_uuid("obd_add_uuid", uuid, nid);
 312 }
 313
 314 int jt_lcfg_del_uuid(int argc, char **argv)
 315 {
 316         int rc;
 317         struct lustre_cfg_bufs bufs;
 318         struct lustre_cfg *lcfg;
 319
 320         if (argc != 2) {
 321                 fprintf(stderr, "usage: %s <uuid>\n", argv[0]);
 322                 return 0;
 323         }
 324
 325         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 326         if (strcmp (argv[1], "_all_"))
 327                 lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 328
 329         lcfg = lustre_cfg_new(LCFG_DEL_UUID, &bufs);
 330         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 331         lustre_cfg_free(lcfg);
 332         if (rc) {
 333                 fprintf(stderr, "IOC_PORTAL_DEL_UUID failed: %s\n",
 334                         strerror(errno));
 335                 return -1;
 336         }
 337         return 0;
 338 }
 339
 340 int jt_lcfg_del_mount_option(int argc, char **argv)
 341 {
 342         int rc;
 343         struct lustre_cfg_bufs bufs;
 344         struct lustre_cfg *lcfg;
 345
 346         if (argc != 2)
 347                 return CMD_HELP;
 348
 349         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 350
 351         /* profile name */
 352         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 353
 354         lcfg = lustre_cfg_new(LCFG_DEL_MOUNTOPT, &bufs);
 355         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 356         lustre_cfg_free(lcfg);
 357         if (rc < 0) {
 358                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 359                         strerror(rc = errno));
 360         }
 361         return rc;
 362 }
 363
 364 int jt_lcfg_set_timeout(int argc, char **argv)
 365 {
 366         fprintf(stderr, "%s has been deprecated. Use conf_param instead.\n"
 367                 "e.g. conf_param lustre-MDT0000 obd_timeout=50\n",
 368                 jt_cmdname(argv[0]));
 369         return CMD_HELP;
 370 }
 371
 372 int jt_lcfg_add_conn(int argc, char **argv)
 373 {
 374         struct lustre_cfg_bufs bufs;
 375         struct lustre_cfg *lcfg;
 376         int priority;
 377         int rc;
 378
 379         if (argc == 2)
 380                 priority = 0;
 381         else if (argc == 3)
 382                 priority = 1;
 383         else
 384                 return CMD_HELP;
 385
 386         if (lcfg_devname == NULL) {
 387                 fprintf(stderr, "%s: please use 'device name' to set the "
 388                         "device name for config commands.\n",
 389                         jt_cmdname(argv[0]));
 390                 return -EINVAL;
 391         }
 392
 393         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 394
 395         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 396
 397         lcfg = lustre_cfg_new(LCFG_ADD_CONN, &bufs);
 398         lcfg->lcfg_num = priority;
 399
 400         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 401         lustre_cfg_free (lcfg);
 402         if (rc < 0) {
 403                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 404                         strerror(rc = errno));
 405         }
 406
 407         return rc;
 408 }
 409
 410 int jt_lcfg_del_conn(int argc, char **argv)
 411 {
 412         struct lustre_cfg_bufs bufs;
 413         struct lustre_cfg *lcfg;
 414         int rc;
 415
 416         if (argc != 2)
 417                 return CMD_HELP;
 418
 419         if (lcfg_devname == NULL) {
 420                 fprintf(stderr, "%s: please use 'device name' to set the "
 421                         "device name for config commands.\n",
 422                         jt_cmdname(argv[0]));
 423                 return -EINVAL;
 424         }
 425
 426         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 427
 428         /* connection uuid */
 429         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 430
 431         lcfg = lustre_cfg_new(LCFG_DEL_MOUNTOPT, &bufs);
 432
 433         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 434         lustre_cfg_free(lcfg);
 435         if (rc < 0) {
 436                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 437                         strerror(rc = errno));
 438         }
 439
 440         return rc;
 441 }
 442
 443 /* Param set locally, directly on target */
 444 int jt_lcfg_param(int argc, char **argv)
 445 {
 446         int i, rc;
 447         struct lustre_cfg_bufs bufs;
 448         struct lustre_cfg *lcfg;
 449
 450         if (argc >= LUSTRE_CFG_MAX_BUFCOUNT)
 451                 return CMD_HELP;
 452
 453         lustre_cfg_bufs_reset(&bufs, NULL);
 454
 455         for (i = 1; i < argc; i++) {
 456                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
 457         }
 458
 459         lcfg = lustre_cfg_new(LCFG_PARAM, &bufs);
 460
 461         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 462         lustre_cfg_free(lcfg);
 463         if (rc < 0) {
 464                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 465                         strerror(rc = errno));
 466         }
 467         return rc;
 468 }
 469
 470 /* Param set in config log on MGS */
 471 /* conf_param key1=value1 [key2=value2...] */
 472 int jt_lcfg_mgsparam(int argc, char **argv)
 473 {
 474         int i, rc;
 475         struct lustre_cfg_bufs bufs;
 476         struct lustre_cfg *lcfg;
 477
 478         if ((argc >= LUSTRE_CFG_MAX_BUFCOUNT) || (argc <= 1))
 479                 return CMD_HELP;
 480
 481         lustre_cfg_bufs_reset(&bufs, NULL);
 482
 483         for (i = 1; i < argc; i++) {
 484                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
 485         }
 486
 487         /* We could put other opcodes here. */
 488         lcfg = lustre_cfg_new(LCFG_PARAM, &bufs);
 489
 490         rc = lcfg_mgs_ioctl(argv[0], OBD_DEV_ID, lcfg);
 491         lustre_cfg_free(lcfg);
 492         if (rc < 0) {
 493                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 494                         strerror(rc = errno));
 495         }
 496
 497         return rc;
 498 }
 499
 500 /* Display the path in the same format as sysctl
 501  * For eg. obdfilter.lustre-OST0000.stats */
 502 static char *display_name(char *filename)
 503 {
 504         char *tmp;
 505
 506         filename += strlen("/proc/");
 507         if (strncmp(filename, "fs/", strlen("fs/")) == 0)
 508                 filename += strlen("fs/");
 509         else
 510                 filename += strlen("sys/");
 511
 512         if (strncmp(filename, "lustre/", strlen("lustre/")) == 0)
 513                 filename += strlen("lustre/");
 514
 515         /* replace '/' with '.' to match conf_param and sysctl */
 516         tmp = filename;
 517         while ((tmp = strchr(tmp, '/')) != NULL)
 518                 *tmp = '.';
 519
 520         return filename;
 521 }
 522
 523 /* Find a character in a length limited string */
 524 static char *strnchr(const char *p, char c, size_t n)
 525 {
 526        if (!p)
 527                return (0);
 528
 529        while (n-- > 0) {
 530                if (*p == c)
 531                        return ((char *)p);
 532                p++;
 533        }
 534        return (0);
 535 }
 536
 537 static char *globerrstr(int glob_rc)
 538 {
 539         switch(glob_rc) {
 540         case GLOB_NOSPACE:
 541                 return "Out of memory";
 542         case GLOB_ABORTED:
 543                 return "Read error";
 544         case GLOB_NOMATCH:
 545                 return "Found no match";
 546         }
 547         return "Unknow error";
 548 }
 549
 550 static void clean_path(char *path)
 551 {
 552         char *tmp;
 553
 554         /* If the input is in form Eg. obdfilter.*.stats */
 555         if (strchr(path, '.')) {
 556                 tmp = path;
 557                 while (*tmp != '\0') {
 558                         if ((*tmp == '.') &&
 559                             (tmp != path) && (*(tmp - 1) != '\\'))
 560                                 *tmp = '/';
 561                         tmp ++;
 562                 }
 563         }
 564         /* get rid of '\', glob doesn't like it */
 565         if ((tmp = strrchr(path, '\\')) != NULL) {
 566                 char *tail = path + strlen(path);
 567                 while (tmp != path) {
 568                         if (*tmp == '\\') {
 569                                 memmove(tmp, tmp + 1, tail - tmp);
 570                                 --tail;
 571                         }
 572                         --tmp;
 573                 }
 574         }
 575 }
 576
 577 int jt_lcfg_getparam(int argc, char **argv)
 578 {
 579         int fp;
 580         int rc = 0, i, show_path = 0, only_path = 0;
 581         char pattern[PATH_MAX];
 582         char *path, *buf;
 583         glob_t glob_info;
 584
 585         if (argc == 3 && (strcmp(argv[1], "-n") == 0 ||
 586                           strcmp(argv[1], "-N") == 0)) {
 587                 path = argv[2];
 588                 if (strcmp(argv[1], "-N") == 0) {
 589                         only_path = 1;
 590                         show_path = 1;
 591                 }
 592         } else if (argc == 2) {
 593                 show_path = 1;
 594                 path = argv[1];
 595         } else {
 596                 return CMD_HELP;
 597         }
 598
 599         clean_path(path);
 600
 601         /* If the entire path is specified as input */
 602         fp = open(path, O_RDONLY);
 603         if (fp < 0)
 604                 snprintf(pattern, PATH_MAX, "/proc/{fs,sys}/{lnet,lustre}/%s",
 605                          path);
 606         else {
 607                 strcpy(pattern, path);
 608                 close(fp);
 609         }
 610
 611         rc = glob(pattern, GLOB_BRACE, NULL, &glob_info);
 612         if (rc) {
 613                 fprintf(stderr, "error : glob %s: %s \n", pattern,
 614                         globerrstr(rc));
 615                 return rc;
 616         }
 617
 618         buf = malloc(CFS_PAGE_SIZE);
 619         for (i = 0; i  < glob_info.gl_pathc; i++) {
 620                 char *valuename = NULL;
 621
 622                 memset(buf, 0, CFS_PAGE_SIZE);
 623                 if (show_path) {
 624                         char *filename;
 625                         filename = strdup(glob_info.gl_pathv[i]);
 626                         valuename = display_name(filename);
 627                         if (valuename && only_path) {
 628                                 printf("%s\n", valuename);
 629                                 continue;
 630                         }
 631                 }
 632
 633                 /* Write the contents of file to stdout */
 634                 fp = open(glob_info.gl_pathv[i], O_RDONLY);
 635                 if (fp < 0) {
 636                         fprintf(stderr, "error: %s: opening('%s') failed: %s\n",
 637                                 jt_cmdname(argv[0]), glob_info.gl_pathv[i],
 638                                 strerror(errno));
 639                         continue;
 640                 }
 641
 642                 do {
 643                         rc = read(fp, buf, CFS_PAGE_SIZE);
 644                         if (rc == 0)
 645                                 break;
 646                         if (rc < 0) {
 647                                 fprintf(stderr, "error: %s: read('%s') "
 648                                         "failed: %s\n", jt_cmdname(argv[0]),
 649                                         glob_info.gl_pathv[i], strerror(errno));
 650                                 break;
 651                         }
 652                         /* Print the output in the format path=value if the
 653                          * value contains no new line character or cab be
 654                          * occupied in a line, else print value on new line */
 655                         if (valuename && show_path) {
 656                                 int longbuf = strnchr(buf, rc - 1, '\n') != NULL
 657                                               || rc > 60;
 658                                 printf("%s=%s", valuename, longbuf ? "\n" : buf);
 659                                 valuename = NULL;
 660                                 if (!longbuf)
 661                                         continue;
 662                                 fflush(stdout);
 663                         }
 664                         rc = write(fileno(stdout), buf, rc);
 665                         if (rc < 0) {
 666                                 fprintf(stderr, "error: %s: write to stdout "
 667                                         "failed: %s\n", jt_cmdname(argv[0]),
 668                                         strerror(errno));
 669                                 break;
 670                         }
 671                 } while (1);
 672                 close(fp);
 673         }
 674
 675         globfree(&glob_info);
 676         free(buf);
 677         return rc;
 678 }
 679
 680 int jt_lcfg_setparam(int argc, char **argv)
 681 {
 682         int rc = 0, i;
 683         int fp, show_path = 0;
 684         char pattern[PATH_MAX];
 685         char *path, *value;
 686         glob_t glob_info;
 687
 688         path = argv[1];
 689         if (argc == 4 && (strcmp(argv[1], "-n") == 0)) {
 690                 /* Format: lctl set_param -n param value */
 691                 path = argv[2];
 692                 value = argv[3];
 693         } else if (argc == 3) {
 694                 if (strcmp(argv[1], "-n") != 0) {
 695                         /* Format: lctl set_param param value */
 696                         show_path = 1;
 697                         value = argv[2];
 698                 } else if ((value = strchr(argv[2], '=')) != NULL) {
 699                         /* Format: lctl set_param -n param=value */
 700                         path = argv[2];
 701                         *value = '\0';
 702                         value ++;
 703                 } else {
 704                         fprintf(stderr, "error: %s Incorrect arguments."
 705                                         "See Usage\n",
 706                                 jt_cmdname(argv[0]));
 707                         return CMD_HELP;
 708                 }
 709         } else if (argc == 2 && ((value = strchr(argv[1], '=')) != NULL)) {
 710                 /* Format: lctl set_param param=value */
 711                 show_path = 1;
 712                 *value = '\0';
 713                 value++;
 714         } else {
 715                 fprintf(stderr, "error: %s Incorrect arguments. See Usage\n",
 716                         jt_cmdname(argv[0]));
 717                 return CMD_HELP;
 718         }
 719
 720         clean_path(path);
 721
 722         fp = open(path, O_RDONLY);
 723         if (fp < 0)
 724                 snprintf(pattern, PATH_MAX, "/proc/{fs,sys}/{lnet,lustre}/%s",
 725                          path);
 726         else {
 727                 strcpy(pattern, path);
 728                 close(fp);
 729         }
 730
 731         rc = glob(pattern, GLOB_BRACE, NULL, &glob_info);
 732         if (rc) {
 733                 fprintf(stderr, "error : glob %s: %s \n", pattern,
 734                         globerrstr(rc));
 735                 return rc;
 736         }
 737         for (i = 0; i  < glob_info.gl_pathc; i++) {
 738                 if (show_path) {
 739                         char *valuename, *filename;
 740                         filename = strdup(glob_info.gl_pathv[i]);
 741                         valuename = display_name(filename);
 742                         printf("%s=%s\n", valuename, value);
 743                 }
 744                 /* Write the new value to the file */
 745                 fp = open(glob_info.gl_pathv[i], O_WRONLY);
 746                 if (fp == -1) {
 747                         fprintf(stderr, "error: %s: %s opening %s\n",
 748                                 jt_cmdname(argv[0]), strerror(rc = errno),
 749                                 glob_info.gl_pathv[i]);
 750                         break;
 751                 } else {
 752                         rc = write(fp, value, strlen(value));
 753                         if (rc < 0)
 754                                 fprintf(stderr,
 755                                         "error writing to file %s (%s)\n",
 756                                         glob_info.gl_pathv[i], strerror(errno));
 757                         else
 758                                 rc = 0;
 759                         close(fp);
 760                 }
 761         }
 762
 763         globfree(&glob_info);
 764         return rc;
 765 }