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
 341
 342
 343 int jt_lcfg_del_mount_option(int argc, char **argv)
 344 {
 345         int rc;
 346         struct lustre_cfg_bufs bufs;
 347         struct lustre_cfg *lcfg;
 348
 349         if (argc != 2)
 350                 return CMD_HELP;
 351
 352         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 353
 354         /* profile name */
 355         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 356
 357         lcfg = lustre_cfg_new(LCFG_DEL_MOUNTOPT, &bufs);
 358         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 359         lustre_cfg_free(lcfg);
 360         if (rc < 0) {
 361                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 362                         strerror(rc = errno));
 363         }
 364         return rc;
 365 }
 366
 367 int jt_lcfg_set_timeout(int argc, char **argv)
 368 {
 369         fprintf(stderr, "%s has been deprecated. Use conf_param instead.\n"
 370                 "e.g. conf_param lustre-MDT0000 obd_timeout=50\n",
 371                 jt_cmdname(argv[0]));
 372         return CMD_HELP;
 373 }
 374
 375 int jt_lcfg_add_conn(int argc, char **argv)
 376 {
 377         struct lustre_cfg_bufs bufs;
 378         struct lustre_cfg *lcfg;
 379         int priority;
 380         int rc;
 381
 382         if (argc == 2)
 383                 priority = 0;
 384         else if (argc == 3)
 385                 priority = 1;
 386         else
 387                 return CMD_HELP;
 388
 389         if (lcfg_devname == NULL) {
 390                 fprintf(stderr, "%s: please use 'device name' to set the "
 391                         "device name for config commands.\n",
 392                         jt_cmdname(argv[0]));
 393                 return -EINVAL;
 394         }
 395
 396         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 397
 398         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 399
 400         lcfg = lustre_cfg_new(LCFG_ADD_CONN, &bufs);
 401         lcfg->lcfg_num = priority;
 402
 403         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 404         lustre_cfg_free (lcfg);
 405         if (rc < 0) {
 406                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 407                         strerror(rc = errno));
 408         }
 409
 410         return rc;
 411 }
 412
 413 int jt_lcfg_del_conn(int argc, char **argv)
 414 {
 415         struct lustre_cfg_bufs bufs;
 416         struct lustre_cfg *lcfg;
 417         int rc;
 418
 419         if (argc != 2)
 420                 return CMD_HELP;
 421
 422         if (lcfg_devname == NULL) {
 423                 fprintf(stderr, "%s: please use 'device name' to set the "
 424                         "device name for config commands.\n",
 425                         jt_cmdname(argv[0]));
 426                 return -EINVAL;
 427         }
 428
 429         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
 430
 431         /* connection uuid */
 432         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
 433
 434         lcfg = lustre_cfg_new(LCFG_DEL_MOUNTOPT, &bufs);
 435
 436         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 437         lustre_cfg_free(lcfg);
 438         if (rc < 0) {
 439                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 440                         strerror(rc = errno));
 441         }
 442
 443         return rc;
 444 }
 445
 446 /* Param set locally, directly on target */
 447 int jt_lcfg_param(int argc, char **argv)
 448 {
 449         int i, rc;
 450         struct lustre_cfg_bufs bufs;
 451         struct lustre_cfg *lcfg;
 452
 453         if (argc >= LUSTRE_CFG_MAX_BUFCOUNT)
 454                 return CMD_HELP;
 455
 456         lustre_cfg_bufs_reset(&bufs, NULL);
 457
 458         for (i = 1; i < argc; i++) {
 459                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
 460         }
 461
 462         lcfg = lustre_cfg_new(LCFG_PARAM, &bufs);
 463
 464         rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
 465         lustre_cfg_free(lcfg);
 466         if (rc < 0) {
 467                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 468                         strerror(rc = errno));
 469         }
 470         return rc;
 471 }
 472
 473 /* Param set in config log on MGS */
 474 /* conf_param key1=value1 [key2=value2...] */
 475 int jt_lcfg_mgsparam(int argc, char **argv)
 476 {
 477         int i, rc;
 478         struct lustre_cfg_bufs bufs;
 479         struct lustre_cfg *lcfg;
 480
 481         if ((argc >= LUSTRE_CFG_MAX_BUFCOUNT) || (argc <= 1))
 482                 return CMD_HELP;
 483
 484         lustre_cfg_bufs_reset(&bufs, NULL);
 485
 486         for (i = 1; i < argc; i++) {
 487                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
 488         }
 489
 490         /* We could put other opcodes here. */
 491         lcfg = lustre_cfg_new(LCFG_PARAM, &bufs);
 492
 493         rc = lcfg_mgs_ioctl(argv[0], OBD_DEV_ID, lcfg);
 494         lustre_cfg_free(lcfg);
 495         if (rc < 0) {
 496                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
 497                         strerror(rc = errno));
 498         }
 499
 500         return rc;
 501 }
 502
 503 /* Display the path in the same format as sysctl
 504  * For eg. obdfilter.lustre-OST0000.stats */
 505 static char *display_name(char *filename)
 506 {
 507         char *tmp;
 508
 509         filename += strlen("/proc/");
 510         if (strncmp(filename, "fs/", strlen("fs/")) == 0)
 511                 filename += strlen("fs/");
 512         else
 513                 filename += strlen("sys/");
 514
 515         if (strncmp(filename, "lustre/", strlen("lustre/")) == 0)
 516                 filename += strlen("lustre/");
 517
 518         /* replace '/' with '.' to match conf_param and sysctl */
 519         tmp = filename;
 520         while ((tmp = strchr(tmp, '/')) != NULL)
 521                 *tmp = '.';
 522
 523         return filename;
 524 }
 525
 526 /* Find a character in a length limited string */
 527 static char *strnchr(const char *p, char c, size_t n)
 528 {
 529        if (!p)
 530                return (0);
 531
 532        while (n-- > 0) {
 533                if (*p == c)
 534                        return ((char *)p);
 535                p++;
 536        }
 537        return (0);
 538 }
 539
 540 int jt_lcfg_getparam(int argc, char **argv)
 541 {
 542         int fp;
 543         int rc = 0, i, show_path = 0, only_path = 0;
 544         char pattern[PATH_MAX];
 545         char *path, *tmp, *buf;
 546         glob_t glob_info;
 547
 548         if (argc == 3 && (strcmp(argv[1], "-n") == 0 ||
 549                           strcmp(argv[1], "-N") == 0)) {
 550                 path = argv[2];
 551                 if (strcmp(argv[1], "-N") == 0) {
 552                         only_path = 1;
 553                         show_path = 1;
 554                 }
 555         } else if (argc == 2) {
 556                 show_path = 1;
 557                 path = argv[1];
 558         } else {
 559                 return CMD_HELP;
 560         }
 561
 562         /* If the input is in form Eg. obdfilter.*.stats */
 563         if (strchr(path, '.')) {
 564                 tmp = path;
 565                 while (*tmp != '\0') {
 566                         if (*tmp == '.')
 567                                 *tmp = '/';
 568                         tmp ++;
 569                 }
 570         }
 571
 572         /* If the entire path is specified as input */
 573         fp = open(path, O_RDONLY);
 574         if (fp < 0)
 575                 snprintf(pattern, PATH_MAX, "/proc/{fs,sys}/{lnet,lustre}/%s",
 576                          path);
 577         else {
 578                 strcpy(pattern, path);
 579                 close(fp);
 580         }
 581
 582         rc = glob(pattern, GLOB_BRACE, NULL, &glob_info);
 583         if (rc) {
 584                 fprintf(stderr, "error : glob %s: %s \n", pattern,strerror(rc));
 585                 return rc;
 586         }
 587
 588         buf = malloc(CFS_PAGE_SIZE);
 589         for (i = 0; i  < glob_info.gl_pathc; i++) {
 590                 char *valuename = NULL;
 591
 592                 memset(buf, 0, CFS_PAGE_SIZE);
 593                 if (show_path) {
 594                         char *filename;
 595                         filename = strdup(glob_info.gl_pathv[i]);
 596                         valuename = display_name(filename);
 597                         if (valuename && only_path) {
 598                                 printf("%s\n", valuename);
 599                                 continue;
 600                         }
 601                 }
 602
 603                 /* Write the contents of file to stdout */
 604                 fp = open(glob_info.gl_pathv[i], O_RDONLY);
 605                 if (fp < 0) {
 606                         fprintf(stderr, "error: %s: opening('%s') failed: %s\n",
 607                                 jt_cmdname(argv[0]), glob_info.gl_pathv[i],
 608                                 strerror(errno));
 609                         continue;
 610                 }
 611
 612                 do {
 613                         rc = read(fp, buf, CFS_PAGE_SIZE);
 614                         if (rc == 0)
 615                                 break;
 616                         if (rc < 0) {
 617                                 fprintf(stderr, "error: %s: read('%s') "
 618                                         "failed: %s\n", jt_cmdname(argv[0]),
 619                                         glob_info.gl_pathv[i], strerror(errno));
 620                                 break;
 621                         }
 622                         /* Print the output in the format path=value if the
 623                          * value contains no new line character or cab be
 624                          * occupied in a line, else print value on new line */
 625                         if (valuename && show_path) {
 626                                 int longbuf = strnchr(buf, rc - 1, '\n') != NULL
 627                                               || rc > 60;
 628                                 printf("%s=%s", valuename, longbuf ? "\n" : buf);
 629                                 valuename = NULL;
 630                                 if (!longbuf)
 631                                         continue;
 632                                 fflush(stdout);
 633                         }
 634                         rc = write(fileno(stdout), buf, rc);
 635                         if (rc < 0) {
 636                                 fprintf(stderr, "error: %s: write to stdout "
 637                                         "failed: %s\n", jt_cmdname(argv[0]),
 638                                         strerror(errno));
 639                                 break;
 640                         }
 641                 } while (1);
 642                 close(fp);
 643         }
 644
 645         globfree(&glob_info);
 646         free(buf);
 647         return rc;
 648 }
 649
 650
 651 int jt_lcfg_setparam(int argc, char **argv)
 652 {
 653         int rc = 0, i;
 654         int fp, show_path = 0;
 655         char pattern[PATH_MAX];
 656         char *path, *value, *tmp;
 657         glob_t glob_info;
 658
 659         path = argv[1];
 660         if (argc == 4 && (strcmp(argv[1], "-n") == 0)) {
 661                 /* Format: lctl set_param -n param value */
 662                 path = argv[2];
 663                 value = argv[3];
 664         } else if (argc == 3) {
 665                 if (strcmp(argv[1], "-n") != 0) {
 666                         /* Format: lctl set_param param value */
 667                         show_path = 1;
 668                         value = argv[2];
 669                 } else if ((value = strchr(argv[2], '=')) != NULL) {
 670                         /* Format: lctl set_param -n param=value */
 671                         path = argv[2];
 672                         *value = '\0';
 673                         value ++;
 674                 } else {
 675                         fprintf(stderr, "error: %s Incorrect arguments."
 676                                         "See Usage\n",
 677                                 jt_cmdname(argv[0]));
 678                         return CMD_HELP;
 679                 }
 680         } else if (argc == 2 && ((value = strchr(argv[1], '=')) != NULL)) {
 681                 /* Format: lctl set_param param=value */
 682                 show_path = 1;
 683                 *value = '\0';
 684                 value++;
 685         } else {
 686                 fprintf(stderr, "error: %s Incorrect arguments. See Usage\n",
 687                         jt_cmdname(argv[0]));
 688                 return CMD_HELP;
 689         }
 690
 691         /* If the input is in form Eg. obdfilter.*.stats */
 692         if (strchr(path, '.')) {
 693                 tmp = path;
 694                 while (*tmp != '\0') {
 695                         if (*tmp == '.')
 696                                 *tmp = '/';
 697                         tmp ++;
 698                 }
 699         }
 700
 701         fp = open(path, O_RDONLY);
 702         if (fp < 0)
 703                 snprintf(pattern, PATH_MAX, "/proc/{fs,sys}/{lnet,lustre}/%s",
 704                          path);
 705         else {
 706                 strcpy(pattern, path);
 707                 close(fp);
 708         }
 709
 710         rc = glob(pattern, GLOB_BRACE, NULL, &glob_info);
 711         if (rc) {
 712                 fprintf(stderr, "error : glob %s: %s \n", pattern,strerror(rc));
 713                 return rc;
 714         }
 715         for (i = 0; i  < glob_info.gl_pathc; i++) {
 716                 if (show_path) {
 717                         char *valuename, *filename;
 718                         filename = strdup(glob_info.gl_pathv[i]);
 719                         valuename = display_name(filename);
 720                         printf("%s=%s\n", valuename, value);
 721                 }
 722                 /* Write the new value to the file */
 723                 fp = open(glob_info.gl_pathv[i], O_WRONLY);
 724                 if (fp == -1) {
 725                         fprintf(stderr, "error: %s: %s opening %s\n",
 726                                 jt_cmdname(argv[0]), strerror(rc = errno),
 727                                 glob_info.gl_pathv[i]);
 728                         break;
 729                 } else {
 730                         rc = write(fp, value, strlen(value));
 731                         if (rc < 0)
 732                                 fprintf(stderr,
 733                                         "error writing to file %s (%s)\n",
 734                                         glob_info.gl_pathv[i], strerror(errno));
 735                         else
 736                                 rc = 0;
 737                         close(fp);
 738                 }
 739         }
 740
 741         globfree(&glob_info);
 742         return rc;
 743 }