Whamcloud - gitweb
LU-8551 test: Use mds1 rather than mds to operate on MDT0000
[fs/lustre-release.git] / lustre / utils / lustre_cfg.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
19  *
20  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
21  * CA 95054 USA or visit www.sun.com if you need additional information or
22  * have any questions.
23  *
24  * GPL HEADER END
25  */
26 /*
27  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
28  * Use is subject to license terms.
29  *
30  * Copyright (c) 2011, 2015, Intel Corporation.
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 <errno.h>
45 #include <fcntl.h>
46 #include <limits.h>
47 #include <stdbool.h>
48 #include <stdlib.h>
49 #include <string.h>
50 #include <sys/ioctl.h>
51 #include <sys/stat.h>
52 #include <unistd.h>
53 #include <stdio.h>
54 #include <stdarg.h>
55 #include <ctype.h>
56
57 #include <libcfs/util/string.h>
58 #include <libcfs/util/param.h>
59 #include <libcfs/util/parser.h>
60 #include <lnet/nidstr.h>
61 #include <lustre_cfg.h>
62 #include <lustre_ioctl.h>
63 #include <lustre/lustre_idl.h>
64 #include <lustre_ver.h>
65
66 #include <sys/un.h>
67 #include <time.h>
68 #include <sys/time.h>
69 #include <errno.h>
70 #include <string.h>
71
72 #include "obdctl.h"
73 #include <lnet/lnetctl.h>
74 #include <stdio.h>
75
76 static char * lcfg_devname;
77
78 int lcfg_set_devname(char *name)
79 {
80         char *ptr;
81         int digit = 1;
82
83         if (name) {
84                 if (lcfg_devname)
85                         free(lcfg_devname);
86                 /* quietly strip the unnecessary '$' */
87                 if (*name == '$' || *name == '%')
88                         name++;
89
90                 ptr = name;
91                 while (*ptr != '\0') {
92                         if (!isdigit(*ptr)) {
93                             digit = 0;
94                             break;
95                         }
96                         ptr++;
97                 }
98
99                 if (digit) {
100                         /* We can't translate from dev # to name */
101                         lcfg_devname = NULL;
102                 } else {
103                         lcfg_devname = strdup(name);
104                 }
105         } else {
106                 lcfg_devname = NULL;
107         }
108         return 0;
109 }
110
111 char * lcfg_get_devname(void)
112 {
113         return lcfg_devname;
114 }
115
116 int jt_lcfg_device(int argc, char **argv)
117 {
118         return jt_obd_device(argc, argv);
119 }
120
121 int jt_lcfg_attach(int argc, char **argv)
122 {
123         struct lustre_cfg_bufs bufs;
124         struct lustre_cfg *lcfg;
125         int rc;
126
127         if (argc != 4)
128                 return CMD_HELP;
129
130         lustre_cfg_bufs_reset(&bufs, NULL);
131
132         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
133         lustre_cfg_bufs_set_string(&bufs, 0, argv[2]);
134         lustre_cfg_bufs_set_string(&bufs, 2, argv[3]);
135
136         lcfg = lustre_cfg_new(LCFG_ATTACH, &bufs);
137         if (lcfg == NULL) {
138                 rc = -ENOMEM;
139         } else {
140                 rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
141                 lustre_cfg_free(lcfg);
142         }
143         if (rc < 0) {
144                 fprintf(stderr, "error: %s: LCFG_ATTACH %s\n",
145                         jt_cmdname(argv[0]), strerror(rc = errno));
146         } else {
147                 lcfg_set_devname(argv[2]);
148         }
149
150         return rc;
151 }
152
153 int jt_lcfg_setup(int argc, char **argv)
154 {
155         struct lustre_cfg_bufs bufs;
156         struct lustre_cfg *lcfg;
157         int i;
158         int rc;
159
160         if (lcfg_devname == NULL) {
161                 fprintf(stderr, "%s: please use 'device name' to set the "
162                         "device name for config commands.\n",
163                         jt_cmdname(argv[0]));
164                 return -EINVAL;
165         }
166
167         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
168
169         if (argc > 6)
170                 return CMD_HELP;
171
172         for (i = 1; i < argc; i++) {
173                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
174         }
175
176         lcfg = lustre_cfg_new(LCFG_SETUP, &bufs);
177         if (lcfg == NULL) {
178                 rc = -ENOMEM;
179         } else {
180                 rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
181                 lustre_cfg_free(lcfg);
182         }
183         if (rc < 0)
184                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
185                         strerror(rc = errno));
186
187         return rc;
188 }
189
190 int jt_obd_detach(int argc, char **argv)
191 {
192         struct lustre_cfg_bufs bufs;
193         struct lustre_cfg *lcfg;
194         int rc;
195
196         if (lcfg_devname == NULL) {
197                 fprintf(stderr, "%s: please use 'device name' to set the "
198                         "device name for config commands.\n",
199                         jt_cmdname(argv[0]));
200                 return -EINVAL;
201         }
202
203         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
204
205         if (argc != 1)
206                 return CMD_HELP;
207
208         lcfg = lustre_cfg_new(LCFG_DETACH, &bufs);
209         if (lcfg == NULL) {
210                 rc = -ENOMEM;
211         } else {
212                 rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
213                 lustre_cfg_free(lcfg);
214         }
215         if (rc < 0)
216                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
217                         strerror(rc = errno));
218
219         return rc;
220 }
221
222 int jt_obd_cleanup(int argc, char **argv)
223 {
224         struct lustre_cfg_bufs bufs;
225         struct lustre_cfg *lcfg;
226         char force = 'F';
227         char failover = 'A';
228         char flags[3] = { 0 };
229         int flag_cnt = 0, n;
230         int rc;
231
232         if (lcfg_devname == NULL) {
233                 fprintf(stderr, "%s: please use 'device name' to set the "
234                         "device name for config commands.\n",
235                         jt_cmdname(argv[0]));
236                 return -EINVAL;
237         }
238
239         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
240
241         if (argc < 1 || argc > 3)
242                 return CMD_HELP;
243
244         /* we are protected from overflowing our buffer by the argc
245          * check above
246          */
247         for (n = 1; n < argc; n++) {
248                 if (strcmp(argv[n], "force") == 0) {
249                         flags[flag_cnt++] = force;
250                 } else if (strcmp(argv[n], "failover") == 0) {
251                         flags[flag_cnt++] = failover;
252                 } else {
253                         fprintf(stderr, "unknown option: %s\n", argv[n]);
254                         return CMD_HELP;
255                 }
256         }
257
258         if (flag_cnt) {
259                 lustre_cfg_bufs_set_string(&bufs, 1, flags);
260         }
261
262         lcfg = lustre_cfg_new(LCFG_CLEANUP, &bufs);
263         if (lcfg == NULL) {
264                 rc = -ENOMEM;
265         } else {
266                 rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
267                 lustre_cfg_free(lcfg);
268         }
269         if (rc < 0)
270                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
271                         strerror(rc = errno));
272
273         return rc;
274 }
275
276 static
277 int do_add_uuid(char * func, char *uuid, lnet_nid_t nid)
278 {
279         int rc;
280         struct lustre_cfg_bufs bufs;
281         struct lustre_cfg *lcfg;
282
283         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
284         if (uuid != NULL)
285                 lustre_cfg_bufs_set_string(&bufs, 1, uuid);
286
287         lcfg = lustre_cfg_new(LCFG_ADD_UUID, &bufs);
288         if (lcfg == NULL) {
289                 rc = -ENOMEM;
290         } else {
291                 lcfg->lcfg_nid = nid;
292
293                 rc = lcfg_ioctl(func, OBD_DEV_ID, lcfg);
294                 lustre_cfg_free(lcfg);
295         }
296         if (rc) {
297                 fprintf(stderr, "IOC_PORTAL_ADD_UUID failed: %s\n",
298                         strerror(errno));
299                 return -1;
300         }
301
302         if (uuid != NULL)
303                 printf("Added uuid %s: %s\n", uuid, libcfs_nid2str(nid));
304
305         return 0;
306 }
307
308 int jt_lcfg_add_uuid(int argc, char **argv)
309 {
310         lnet_nid_t nid;
311
312         if (argc != 3) {
313                 return CMD_HELP;
314         }
315
316         nid = libcfs_str2nid(argv[2]);
317         if (nid == LNET_NID_ANY) {
318                 fprintf (stderr, "Can't parse NID %s\n", argv[2]);
319                 return (-1);
320         }
321
322         return do_add_uuid(argv[0], argv[1], nid);
323 }
324
325 int jt_lcfg_del_uuid(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                 fprintf(stderr, "usage: %s <uuid>\n", argv[0]);
333                 return 0;
334         }
335
336         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
337         if (strcmp (argv[1], "_all_"))
338                 lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
339
340         lcfg = lustre_cfg_new(LCFG_DEL_UUID, &bufs);
341         if (lcfg == NULL) {
342                 rc = -ENOMEM;
343         } else {
344                 rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
345                 lustre_cfg_free(lcfg);
346         }
347         if (rc) {
348                 fprintf(stderr, "IOC_PORTAL_DEL_UUID failed: %s\n",
349                         strerror(errno));
350                 return -1;
351         }
352         return 0;
353 }
354
355 int jt_lcfg_del_mount_option(int argc, char **argv)
356 {
357         int rc;
358         struct lustre_cfg_bufs bufs;
359         struct lustre_cfg *lcfg;
360
361         if (argc != 2)
362                 return CMD_HELP;
363
364         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
365
366         /* profile name */
367         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
368
369         lcfg = lustre_cfg_new(LCFG_DEL_MOUNTOPT, &bufs);
370         if (lcfg == NULL) {
371                 rc = -ENOMEM;
372         } else {
373                 rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
374                 lustre_cfg_free(lcfg);
375         }
376         if (rc < 0) {
377                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
378                         strerror(rc = errno));
379         }
380         return rc;
381 }
382
383 int jt_lcfg_set_timeout(int argc, char **argv)
384 {
385         int rc;
386         struct lustre_cfg_bufs bufs;
387         struct lustre_cfg *lcfg;
388
389         fprintf(stderr, "%s has been deprecated. Use conf_param instead.\n"
390                 "e.g. conf_param lustre-MDT0000 obd_timeout=50\n",
391                 jt_cmdname(argv[0]));
392         return CMD_HELP;
393
394
395         if (argc != 2)
396                 return CMD_HELP;
397
398         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
399         lcfg = lustre_cfg_new(LCFG_SET_TIMEOUT, &bufs);
400         if (lcfg == NULL) {
401                 rc = -ENOMEM;
402         } else {
403                 lcfg->lcfg_num = atoi(argv[1]);
404
405                 rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
406                 lustre_cfg_free(lcfg);
407         }
408         if (rc < 0) {
409                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
410                         strerror(rc = errno));
411         }
412         return rc;
413 }
414
415 int jt_lcfg_add_conn(int argc, char **argv)
416 {
417         struct lustre_cfg_bufs bufs;
418         struct lustre_cfg *lcfg;
419         int priority;
420         int rc;
421
422         if (argc == 2)
423                 priority = 0;
424         else if (argc == 3)
425                 priority = 1;
426         else
427                 return CMD_HELP;
428
429         if (lcfg_devname == NULL) {
430                 fprintf(stderr, "%s: please use 'device name' to set the "
431                         "device name for config commands.\n",
432                         jt_cmdname(argv[0]));
433                 return -EINVAL;
434         }
435
436         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
437
438         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
439
440         lcfg = lustre_cfg_new(LCFG_ADD_CONN, &bufs);
441         if (lcfg == NULL) {
442                 rc = -ENOMEM;
443         } else {
444                 lcfg->lcfg_num = priority;
445
446                 rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
447                 lustre_cfg_free(lcfg);
448         }
449         if (rc < 0) {
450                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
451                         strerror(rc = errno));
452         }
453
454         return rc;
455 }
456
457 int jt_lcfg_del_conn(int argc, char **argv)
458 {
459         struct lustre_cfg_bufs bufs;
460         struct lustre_cfg *lcfg;
461         int rc;
462
463         if (argc != 2)
464                 return CMD_HELP;
465
466         if (lcfg_devname == NULL) {
467                 fprintf(stderr, "%s: please use 'device name' to set the "
468                         "device name for config commands.\n",
469                         jt_cmdname(argv[0]));
470                 return -EINVAL;
471         }
472
473         lustre_cfg_bufs_reset(&bufs, lcfg_devname);
474
475         /* connection uuid */
476         lustre_cfg_bufs_set_string(&bufs, 1, argv[1]);
477
478         lcfg = lustre_cfg_new(LCFG_DEL_MOUNTOPT, &bufs);
479         if (lcfg == NULL) {
480                 rc = -ENOMEM;
481         } else {
482                 rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
483                 lustre_cfg_free(lcfg);
484         }
485         if (rc < 0) {
486                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
487                         strerror(rc = errno));
488         }
489
490         return rc;
491 }
492
493 /* Param set locally, directly on target */
494 int jt_lcfg_param(int argc, char **argv)
495 {
496         int i, rc;
497         struct lustre_cfg_bufs bufs;
498         struct lustre_cfg *lcfg;
499
500         if (argc >= LUSTRE_CFG_MAX_BUFCOUNT)
501                 return CMD_HELP;
502
503         lustre_cfg_bufs_reset(&bufs, NULL);
504
505         for (i = 1; i < argc; i++) {
506                 lustre_cfg_bufs_set_string(&bufs, i, argv[i]);
507         }
508
509         lcfg = lustre_cfg_new(LCFG_PARAM, &bufs);
510         if (lcfg == NULL) {
511                 rc = -ENOMEM;
512         } else {
513                 rc = lcfg_ioctl(argv[0], OBD_DEV_ID, lcfg);
514                 lustre_cfg_free(lcfg);
515         }
516         if (rc < 0) {
517                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
518                         strerror(rc = errno));
519         }
520         return rc;
521 }
522
523 struct param_opts {
524         unsigned int po_only_path:1;
525         unsigned int po_show_path:1;
526         unsigned int po_show_type:1;
527         unsigned int po_recursive:1;
528         unsigned int po_params2:1;
529         unsigned int po_delete:1;
530         unsigned int po_only_dir:1;
531 };
532
533 /* Param set to single log file, used by all clients and servers.
534  * This should be loaded after the individual config logs.
535  * Called from set param with -P option.
536  */
537 static int jt_lcfg_mgsparam2(int argc, char **argv, struct param_opts *popt)
538 {
539         int     rc, i;
540         int     first_param;
541         struct  lustre_cfg_bufs bufs;
542         struct  lustre_cfg *lcfg;
543         char    *buf = NULL;
544         int     len;
545
546         first_param = optind;
547         if (first_param < 0 || first_param >= argc)
548                 return CMD_HELP;
549
550         for (i = first_param, rc = 0; i < argc; i++) {
551                 lustre_cfg_bufs_reset(&bufs, NULL);
552                 /* This same command would be executed on all nodes, many
553                  * of which should fail (silently) because they don't have
554                  * that proc file existing locally. There would be no
555                  * preprocessing on the MGS to try to figure out which
556                  * parameter files to add this to, there would be nodes
557                  * processing on the cluster nodes to try to figure out
558                  * if they are the intended targets. They will blindly
559                  * try to set the parameter, and ENOTFOUND means it wasn't
560                  * for them.
561                  * Target name "general" means call on all targets. It is
562                  * left here in case some filtering will be added in
563                  * future.
564                  */
565                 lustre_cfg_bufs_set_string(&bufs, 0, "general");
566
567                 len = strlen(argv[i]);
568
569                 /* put an '=' on the end in case it doesn't have one */
570                 if (popt->po_delete && argv[i][len - 1] != '=') {
571                         buf = malloc(len + 1);
572                         if (buf == NULL) {
573                                 rc = -ENOMEM;
574                                 break;
575                         }
576                         sprintf(buf, "%s=", argv[i]);
577                 } else {
578                         buf = argv[i];
579                 }
580                 lustre_cfg_bufs_set_string(&bufs, 1, buf);
581
582                 lcfg = lustre_cfg_new(LCFG_SET_PARAM, &bufs);
583                 if (lcfg == NULL) {
584                         fprintf(stderr, "error: allocating lcfg for %s: %s\n",
585                                 jt_cmdname(argv[0]), strerror(-ENOMEM));
586                         if (rc == 0)
587                                 rc = -ENOMEM;
588                 } else {
589                         int rc2 = lcfg_mgs_ioctl(argv[0], OBD_DEV_ID, lcfg);
590                         if (rc2 != 0) {
591                                 fprintf(stderr, "error: executing %s: %s\n",
592                                         jt_cmdname(argv[0]), strerror(errno));
593                                 if (rc == 0)
594                                         rc = rc2;
595                         }
596                         lustre_cfg_free(lcfg);
597                 }
598                 if (buf != argv[i])
599                         free(buf);
600         }
601
602         return rc;
603 }
604
605 /* Param set in config log on MGS */
606 /* conf_param key=value */
607 /* Note we can actually send mgc conf_params from clients, but currently
608  * that's only done for default file striping (see ll_send_mgc_param),
609  * and not here. */
610 /* After removal of a parameter (-d) Lustre will use the default
611  * AT NEXT REBOOT, not immediately. */
612 int jt_lcfg_mgsparam(int argc, char **argv)
613 {
614         int rc;
615         int del = 0;
616         struct lustre_cfg_bufs bufs;
617         struct lustre_cfg *lcfg;
618         char *buf = NULL;
619
620         /* mgs_setparam processes only lctl buf #1 */
621         if ((argc > 3) || (argc <= 1))
622                 return CMD_HELP;
623
624         while ((rc = getopt(argc, argv, "d")) != -1) {
625                 switch (rc) {
626                         case 'd':
627                                 del = 1;
628                                 break;
629                         default:
630                                 return CMD_HELP;
631                 }
632         }
633
634         lustre_cfg_bufs_reset(&bufs, NULL);
635         if (del) {
636                 char *ptr;
637
638                 /* for delete, make it "<param>=\0" */
639                 buf = malloc(strlen(argv[optind]) + 2);
640                 if (buf == NULL) {
641                         rc = -ENOMEM;
642                         goto out;
643                 }
644                 /* put an '=' on the end in case it doesn't have one */
645                 sprintf(buf, "%s=", argv[optind]);
646                 /* then truncate after the first '=' */
647                 ptr = strchr(buf, '=');
648                 *(++ptr) = '\0';
649                 lustre_cfg_bufs_set_string(&bufs, 1, buf);
650         } else {
651                 lustre_cfg_bufs_set_string(&bufs, 1, argv[optind]);
652         }
653
654         /* We could put other opcodes here. */
655         lcfg = lustre_cfg_new(LCFG_PARAM, &bufs);
656         if (lcfg == NULL) {
657                 rc = -ENOMEM;
658         } else {
659                 rc = lcfg_mgs_ioctl(argv[0], OBD_DEV_ID, lcfg);
660                 if (rc < 0)
661                         rc = -errno;
662                 lustre_cfg_free(lcfg);
663         }
664         if (buf)
665                 free(buf);
666 out:
667         if (rc < 0) {
668                 fprintf(stderr, "error: %s: %s\n", jt_cmdname(argv[0]),
669                         strerror(-rc));
670         }
671
672         return rc;
673 }
674
675 /**
676  * Display a parameter path in the same format as sysctl.
677  * E.g. obdfilter.lustre-OST0000.stats
678  *
679  * \param[in] filename  file name of the parameter
680  * \param[in] st        parameter file stats
681  * \param[in] popt      set/get param options
682  *
683  * \retval allocated pointer containing modified filename
684  */
685 static char *
686 display_name(const char *filename, struct stat *st, struct param_opts *popt)
687 {
688         size_t suffix_len = 0;
689         char *suffix = NULL;
690         char *param_name;
691         char *tmp;
692
693         if (popt->po_show_type) {
694                 if (S_ISDIR(st->st_mode))
695                         suffix = "/";
696                 else if (S_ISLNK(st->st_mode))
697                         suffix = "@";
698                 else if (st->st_mode & S_IWUSR)
699                         suffix = "=";
700         }
701
702         /* Take the original filename string and chop off the glob addition */
703         tmp = strstr(filename, "/lustre/");
704         if (tmp == NULL) {
705                 tmp = strstr(filename, "/lnet/");
706                 if (tmp != NULL)
707                         tmp += strlen("/lnet/");
708         } else {
709                 tmp += strlen("/lustre/");
710         }
711
712         /* Allocate return string */
713         param_name = strdup(tmp);
714         if (param_name == NULL)
715                 return NULL;
716
717         /* replace '/' with '.' to match conf_param and sysctl */
718         for (tmp = strchr(param_name, '/'); tmp != NULL; tmp = strchr(tmp, '/'))
719                 *tmp = '.';
720
721         /* Append the indicator to entries if needed. */
722         if (popt->po_show_type && suffix != NULL) {
723                 suffix_len = strlen(suffix);
724
725                 tmp = realloc(param_name, suffix_len + strlen(param_name) + 1);
726                 if (tmp != NULL) {
727                         param_name = tmp;
728                         strncat(param_name, suffix, suffix_len);
729                 }
730         }
731
732         return param_name;
733 }
734
735 /* Find a character in a length limited string */
736 /* BEWARE - kernel definition of strnchr has args in different order! */
737 static char *strnchr(const char *p, char c, size_t n)
738 {
739        if (!p)
740                return (0);
741
742        while (n-- > 0) {
743                if (*p == c)
744                        return ((char *)p);
745                p++;
746        }
747        return (0);
748 }
749
750 /**
751  * Turns a lctl parameter string into a procfs/sysfs subdirectory path pattern.
752  *
753  * \param[in] popt              Used to control parameter usage. For this
754  *                              function it is used to see if the path has
755  *                              a added suffix.
756  * \param[in,out] path          lctl parameter string that is turned into
757  *                              the subdirectory path pattern that is used
758  *                              to search the procfs/sysfs tree.
759  *
760  * \retval -errno on error.
761  */
762 static int
763 clean_path(struct param_opts *popt, char *path)
764 {
765         char *nidstr = NULL;
766         char *tmp;
767
768         if (popt == NULL || path == NULL || strlen(path) == 0)
769                 return -EINVAL;
770
771         /* If path contains a suffix we need to remove it */
772         if (popt->po_show_type) {
773                 size_t path_end = strlen(path) - 1;
774
775                 tmp = path + path_end;
776                 switch (*tmp) {
777                 case '@':
778                 case '=':
779                 case '/':
780                         *tmp = '\0';
781                 default:
782                         break;
783                 }
784         }
785
786         /* get rid of '\', glob doesn't like it */
787         tmp = strrchr(path, '\\');
788         if (tmp != NULL) {
789                 char *tail = path + strlen(path);
790
791                 while (tmp != path) {
792                         if (*tmp == '\\') {
793                                 memmove(tmp, tmp + 1, tail - tmp);
794                                 --tail;
795                         }
796                         --tmp;
797                 }
798         }
799
800         /* Does this path contain a NID string ? */
801         tmp = strchr(path, '@');
802         if (tmp != NULL) {
803                 char *find_nid = strdup(path);
804                 lnet_nid_t nid;
805
806                 if (find_nid == NULL)
807                         return -ENOMEM;
808
809                 /* First we need to chop off rest after nid string.
810                  * Since find_nid is a clone of path it better have
811                  * '@' */
812                 tmp = strchr(find_nid, '@');
813                 tmp = strchr(tmp, '.');
814                 if (tmp != NULL)
815                         *tmp = '\0';
816
817                 /* Now chop off the front. */
818                 for (tmp = strchr(find_nid, '.'); tmp != NULL;
819                      tmp = strchr(tmp, '.')) {
820                         /* Remove MGC to make it NID format */
821                         if (!strncmp(++tmp, "MGC", 3))
822                                 tmp += 3;
823
824                         nid = libcfs_str2nid(tmp);
825                         if (nid != LNET_NID_ANY) {
826                                 nidstr = libcfs_nid2str(nid);
827                                 if (nidstr == NULL)
828                                         return -EINVAL;
829                                 break;
830                         }
831                 }
832                 free(find_nid);
833         }
834
835         /* replace param '.' with '/' */
836         for (tmp = strchr(path, '.'); tmp != NULL; tmp = strchr(tmp, '.')) {
837                 *tmp++ = '/';
838
839                 /* Remove MGC to make it NID format */
840                 if (!strncmp(tmp, "MGC", 3))
841                         tmp += 3;
842
843                 /* There exist cases where some of the subdirectories of the
844                  * the parameter tree has embedded in its name a NID string.
845                  * This means that it is possible that these subdirectories
846                  * could have actual '.' in its name. If this is the case we
847                  * don't want to blindly replace the '.' with '/'. */
848                 if (nidstr != NULL) {
849                         char *match = strstr(tmp, nidstr);
850
851                         if (tmp == match)
852                                 tmp += strlen(nidstr);
853                 }
854         }
855
856         return 0;
857 }
858
859 /**
860  * The application lctl can perform three operations for lustre
861  * tunables. This enum defines those three operations which are
862  *
863  * 1) LIST_PARAM        - list available tunables
864  * 2) GET_PARAM         - report the current setting of a tunable
865  * 3) SET_PARAM         - set the tunable to a new value
866  */
867 enum parameter_operation {
868         LIST_PARAM,
869         GET_PARAM,
870         SET_PARAM,
871 };
872
873 char *parameter_opname[] = {
874         [LIST_PARAM] = "list_param",
875         [GET_PARAM] = "get_param",
876         [SET_PARAM] = "set_param",
877 };
878
879 /**
880  * Read the value of parameter
881  *
882  * \param[in]   path            full path to the parameter
883  * \param[in]   param_name      lctl parameter format of the
884  *                              parameter path
885  * \param[in]   popt            set/get param options
886  *
887  * \retval 0 on success.
888  * \retval -errno on error.
889  */
890 static int
891 read_param(const char *path, const char *param_name, struct param_opts *popt)
892 {
893         bool display_path = popt->po_show_path;
894         long page_size = sysconf(_SC_PAGESIZE);
895         int rc = 0;
896         char *buf;
897         int fd;
898
899         /* Read the contents of file to stdout */
900         fd = open(path, O_RDONLY);
901         if (fd < 0) {
902                 rc = -errno;
903                 fprintf(stderr,
904                         "error: get_param: opening '%s': %s\n",
905                         path, strerror(errno));
906                 return rc;
907         }
908
909         buf = calloc(1, page_size);
910         if (buf == NULL) {
911                 fprintf(stderr,
912                         "error: get_param: allocating '%s' buffer: %s\n",
913                         path, strerror(errno));
914                 close(fd);
915                 return -ENOMEM;
916         }
917
918         while (1) {
919                 ssize_t count = read(fd, buf, page_size);
920
921                 if (count == 0)
922                         break;
923                 if (count < 0) {
924                         rc = -errno;
925                         if (errno != EIO) {
926                                 fprintf(stderr, "error: get_param: "
927                                         "reading '%s': %s\n",
928                                         param_name, strerror(errno));
929                         }
930                         break;
931                 }
932
933                 /* Print the output in the format path=value if the value does
934                  * not contain a new line character and the output can fit in
935                  * a single line, else print value on new line */
936                 if (display_path) {
937                         bool longbuf;
938
939                         longbuf = strnchr(buf, count - 1, '\n') != NULL ||
940                                           count + strlen(param_name) >= 80;
941                         printf("%s=%s", param_name, longbuf ? "\n" : buf);
942
943                         /* Make sure it doesn't print again while looping */
944                         display_path = false;
945
946                         if (!longbuf)
947                                 continue;
948                 }
949
950                 if (fwrite(buf, 1, count, stdout) != count) {
951                         rc = -errno;
952                         fprintf(stderr,
953                                 "error: get_param: write to stdout: %s\n",
954                                 strerror(errno));
955                         break;
956                 }
957         }
958         close(fd);
959         free(buf);
960
961         return rc;
962 }
963
964 /**
965  * Set a parameter to a specified value
966  *
967  * \param[in] path              full path to the parameter
968  * \param[in] param_name        lctl parameter format of the parameter path
969  * \param[in] popt              set/get param options
970  * \param[in] value             value to set the parameter to
971  *
972  * \retval number of bytes written on success.
973  * \retval -errno on error.
974  */
975 static int
976 write_param(const char *path, const char *param_name, struct param_opts *popt,
977             const char *value)
978 {
979         int fd, rc = 0;
980         ssize_t count;
981
982         if (value == NULL)
983                 return -EINVAL;
984
985         /* Write the new value to the file */
986         fd = open(path, O_WRONLY);
987         if (fd < 0) {
988                 rc = -errno;
989                 fprintf(stderr, "error: set_param: opening '%s': %s\n",
990                         path, strerror(errno));
991                 return rc;
992         }
993
994         count = write(fd, value, strlen(value));
995         if (count < 0) {
996                 rc = -errno;
997                 if (errno != EIO) {
998                         fprintf(stderr, "error: set_param: setting %s=%s: %s\n",
999                                 path, value, strerror(errno));
1000                 }
1001         } else if (count < strlen(value)) { /* Truncate case */
1002                 rc = -EINVAL;
1003                 fprintf(stderr, "error: set_param: setting %s=%s: "
1004                         "wrote only %zd\n", path, value, count);
1005         } else if (popt->po_show_path) {
1006                 printf("%s=%s\n", param_name, value);
1007         }
1008         close(fd);
1009
1010         return rc;
1011 }
1012
1013 /**
1014  * Perform a read, write or just a listing of a parameter
1015  *
1016  * \param[in] popt              list,set,get parameter options
1017  * \param[in] pattern           search filter for the path of the parameter
1018  * \param[in] value             value to set the parameter if write operation
1019  * \param[in] mode              what operation to perform with the parameter
1020  *
1021  * \retval number of bytes written on success.
1022  * \retval -errno on error and prints error message.
1023  */
1024 static int
1025 param_display(struct param_opts *popt, char *pattern, char *value,
1026               enum parameter_operation mode)
1027 {
1028         int dir_count = 0;
1029         char **dir_cache;
1030         glob_t paths;
1031         char *opname = parameter_opname[mode];
1032         int rc, i;
1033
1034         rc = cfs_get_param_paths(&paths, "%s", pattern);
1035         if (rc != 0) {
1036                 rc = -errno;
1037                 if (!popt->po_recursive) {
1038                         fprintf(stderr, "error: %s: param_path '%s': %s\n",
1039                                 opname, pattern, strerror(errno));
1040                 }
1041                 return rc;
1042         }
1043
1044         dir_cache = calloc(paths.gl_pathc, sizeof(char *));
1045         if (dir_cache == NULL) {
1046                 rc = -ENOMEM;
1047                 fprintf(stderr,
1048                         "error: %s: allocating '%s' dir_cache[%zd]: %s\n",
1049                         opname, pattern, paths.gl_pathc, strerror(-rc));
1050                 goto out_param;
1051         }
1052
1053         for (i = 0; i < paths.gl_pathc; i++) {
1054                 char *param_name = NULL, *tmp;
1055                 char pathname[PATH_MAX];
1056                 struct stat st;
1057                 int rc2;
1058
1059                 if (stat(paths.gl_pathv[i], &st) == -1) {
1060                         fprintf(stderr, "error: %s: stat '%s': %s\n",
1061                                 opname, paths.gl_pathv[i], strerror(errno));
1062                         if (rc == 0)
1063                                 rc = -errno;
1064                         continue;
1065                 }
1066
1067                 if (popt->po_only_dir && !S_ISDIR(st.st_mode))
1068                         continue;
1069
1070                 param_name = display_name(paths.gl_pathv[i], &st, popt);
1071                 if (param_name == NULL) {
1072                         fprintf(stderr,
1073                                 "error: %s: generating name for '%s': %s\n",
1074                                 opname, paths.gl_pathv[i], strerror(ENOMEM));
1075                         if (rc == 0)
1076                                 rc = -ENOMEM;
1077                         continue;
1078                 }
1079
1080                 /**
1081                  * For the upstream client the parameter files locations
1082                  * are split between under both /sys/kernel/debug/lustre
1083                  * and /sys/fs/lustre. The parameter files containing
1084                  * small amounts of data, less than a page in size, are
1085                  * located under /sys/fs/lustre and in the case of large
1086                  * parameter data files, think stats for example, are
1087                  * located in the debugfs tree. Since the files are split
1088                  * across two trees the directories are often duplicated
1089                  * which means these directories are listed twice which
1090                  * leads to duplicate output to the user. To avoid scanning
1091                  * a directory twice we have to cache any directory and
1092                  * check if a search has been requested twice.
1093                  */
1094                 if (S_ISDIR(st.st_mode)) {
1095                         int j;
1096
1097                         for (j = 0; j < dir_count; j++) {
1098                                 if (!strcmp(dir_cache[j], param_name))
1099                                         break;
1100                         }
1101                         if (j != dir_count) {
1102                                 free(param_name);
1103                                 param_name = NULL;
1104                                 continue;
1105                         }
1106                         dir_cache[dir_count++] = strdup(param_name);
1107                 }
1108
1109                 switch (mode) {
1110                 case GET_PARAM:
1111                         /* Read the contents of file to stdout */
1112                         if (S_ISREG(st.st_mode))
1113                                 read_param(paths.gl_pathv[i], param_name, popt);
1114                         break;
1115                 case SET_PARAM:
1116                         if (S_ISREG(st.st_mode)) {
1117                                 rc2 = write_param(paths.gl_pathv[i],
1118                                                   param_name, popt, value);
1119                                 if (rc2 < 0 && rc == 0)
1120                                         rc = rc2;
1121                         }
1122                         break;
1123                 case LIST_PARAM:
1124                         if (popt->po_show_path)
1125                                 printf("%s\n", param_name);
1126                         break;
1127                 }
1128
1129                 /* Only directories are searched recursively if
1130                  * requested by the user */
1131                 if (!S_ISDIR(st.st_mode) || !popt->po_recursive) {
1132                         free(param_name);
1133                         param_name = NULL;
1134                         continue;
1135                 }
1136
1137                 /* Turn param_name into file path format */
1138                 rc2 = clean_path(popt, param_name);
1139                 if (rc2 < 0) {
1140                         fprintf(stderr, "error: %s: cleaning '%s': %s\n",
1141                                 opname, param_name, strerror(-rc2));
1142                         free(param_name);
1143                         param_name = NULL;
1144                         if (rc == 0)
1145                                 rc = rc2;
1146                         continue;
1147                 }
1148
1149                 /* Use param_name to grab subdirectory tree from full path */
1150                 tmp = strstr(paths.gl_pathv[i], param_name);
1151
1152                 /* cleanup paramname now that we are done with it */
1153                 free(param_name);
1154                 param_name = NULL;
1155
1156                 /* Shouldn't happen but just in case */
1157                 if (tmp == NULL) {
1158                         if (rc == 0)
1159                                 rc = -EINVAL;
1160                         continue;
1161                 }
1162
1163                 rc2 = snprintf(pathname, sizeof(pathname), "%s/*", tmp);
1164                 if (rc2 < 0) {
1165                         /* snprintf() should never an error, and if it does
1166                          * there isn't much point trying to use fprintf() */
1167                         continue;
1168                 }
1169                 if (rc2 >= sizeof(pathname)) {
1170                         fprintf(stderr, "error: %s: overflow processing '%s'\n",
1171                                 opname, pathname);
1172                         if (rc == 0)
1173                                 rc = -EINVAL;
1174                         continue;
1175                 }
1176
1177                 rc2 = param_display(popt, pathname, value, mode);
1178                 if (rc2 != 0 && rc2 != -ENOENT) {
1179                         /* errors will be printed by param_display() */
1180                         if (rc == 0)
1181                                 rc = rc2;
1182                         continue;
1183                 }
1184         }
1185
1186         for (i = 0; i < dir_count; i++)
1187                 free(dir_cache[i]);
1188         free(dir_cache);
1189 out_param:
1190         cfs_free_param_data(&paths);
1191         return rc;
1192 }
1193
1194 static int listparam_cmdline(int argc, char **argv, struct param_opts *popt)
1195 {
1196         int ch;
1197
1198         popt->po_show_path = 1;
1199         popt->po_only_path = 1;
1200
1201         while ((ch = getopt(argc, argv, "FRD")) != -1) {
1202                 switch (ch) {
1203                 case 'F':
1204                         popt->po_show_type = 1;
1205                         break;
1206                 case 'R':
1207                         popt->po_recursive = 1;
1208                         break;
1209                 case 'D':
1210                         popt->po_only_dir = 1;
1211                         break;
1212                 default:
1213                         return -1;
1214                 }
1215         }
1216
1217         return optind;
1218 }
1219
1220 int jt_lcfg_listparam(int argc, char **argv)
1221 {
1222         int rc = 0, index, i;
1223         struct param_opts popt;
1224         char *path;
1225
1226         memset(&popt, 0, sizeof(popt));
1227         index = listparam_cmdline(argc, argv, &popt);
1228         if (index < 0 || index >= argc)
1229                 return CMD_HELP;
1230
1231         for (i = index; i < argc; i++) {
1232                 int rc2;
1233
1234                 path = argv[i];
1235
1236                 rc2 = clean_path(&popt, path);
1237                 if (rc2 < 0) {
1238                         fprintf(stderr, "error: %s: cleaning '%s': %s\n",
1239                                 jt_cmdname(argv[0]), path, strerror(-rc2));
1240                         if (rc == 0)
1241                                 rc = rc2;
1242                         continue;
1243                 }
1244
1245                 rc2 = param_display(&popt, path, NULL, LIST_PARAM);
1246                 if (rc2 < 0) {
1247                         fprintf(stderr, "error: %s: listing '%s': %s\n",
1248                                 jt_cmdname(argv[0]), path, strerror(-rc2));
1249                         if (rc == 0)
1250                                 rc = rc2;
1251                         continue;
1252                 }
1253         }
1254
1255         return rc;
1256 }
1257
1258 static int getparam_cmdline(int argc, char **argv, struct param_opts *popt)
1259 {
1260         int ch;
1261
1262         popt->po_show_path = 1;
1263
1264         while ((ch = getopt(argc, argv, "FnNR")) != -1) {
1265                 switch (ch) {
1266                 case 'F':
1267                         popt->po_show_type = 1;
1268                         break;
1269                 case 'n':
1270                         popt->po_show_path = 0;
1271                         break;
1272                 case 'N':
1273                         popt->po_only_path = 1;
1274                         break;
1275                 case 'R':
1276                         popt->po_recursive = 1;
1277                         break;
1278                 default:
1279                         return -1;
1280                 }
1281         }
1282
1283         return optind;
1284 }
1285
1286 int jt_lcfg_getparam(int argc, char **argv)
1287 {
1288         int rc = 0, index, i;
1289         struct param_opts popt;
1290         char *path;
1291
1292         memset(&popt, 0, sizeof(popt));
1293         index = getparam_cmdline(argc, argv, &popt);
1294         if (index < 0 || index >= argc)
1295                 return CMD_HELP;
1296
1297         for (i = index; i < argc; i++) {
1298                 int rc2;
1299
1300                 path = argv[i];
1301
1302                 rc2 = clean_path(&popt, path);
1303                 if (rc2 < 0) {
1304                         fprintf(stderr, "error: %s: cleaning '%s': %s\n",
1305                                 jt_cmdname(argv[0]), path, strerror(-rc2));
1306                         if (rc == 0)
1307                                 rc = rc2;
1308                         continue;
1309                 }
1310
1311                 rc2 = param_display(&popt, path, NULL,
1312                                    popt.po_only_path ? LIST_PARAM : GET_PARAM);
1313                 if (rc2 < 0) {
1314                         if (rc == 0)
1315                                 rc = rc2;
1316                         continue;
1317                 }
1318         }
1319
1320         return rc;
1321 }
1322
1323 /**
1324  * Output information about nodemaps.
1325  * \param       argc            number of args
1326  * \param       argv[]          variable string arguments
1327  *
1328  * [list|nodemap_name|all]      \a list will list all nodemaps (default).
1329  *                              Specifying a \a nodemap_name will
1330  *                              display info about that specific nodemap.
1331  *                              \a all will display info for all nodemaps.
1332  * \retval                      0 on success
1333  */
1334 int jt_nodemap_info(int argc, char **argv)
1335 {
1336         const char              usage_str[] = "usage: nodemap_info "
1337                                               "[list|nodemap_name|all]\n";
1338         struct param_opts       popt;
1339         int                     rc = 0;
1340
1341         memset(&popt, 0, sizeof(popt));
1342         popt.po_show_path = 1;
1343
1344         if (argc > 2) {
1345                 fprintf(stderr, usage_str);
1346                 return -1;
1347         }
1348
1349         if (argc == 1 || strcmp("list", argv[1]) == 0) {
1350                 popt.po_only_path = 1;
1351                 popt.po_only_dir = 1;
1352                 rc = param_display(&popt, "nodemap/*", NULL, LIST_PARAM);
1353         } else if (strcmp("all", argv[1]) == 0) {
1354                 rc = param_display(&popt, "nodemap/*/*", NULL, LIST_PARAM);
1355         } else {
1356                 char    pattern[PATH_MAX];
1357
1358                 snprintf(pattern, sizeof(pattern), "nodemap/%s/*", argv[1]);
1359                 rc = param_display(&popt, pattern, NULL, LIST_PARAM);
1360                 if (rc == -ESRCH)
1361                         fprintf(stderr, "error: nodemap_info: cannot find "
1362                                         "nodemap %s\n", argv[1]);
1363         }
1364         return rc;
1365 }
1366
1367 static int setparam_cmdline(int argc, char **argv, struct param_opts *popt)
1368 {
1369         int ch;
1370
1371         popt->po_show_path = 1;
1372         popt->po_only_path = 0;
1373         popt->po_show_type = 0;
1374         popt->po_recursive = 0;
1375         popt->po_params2 = 0;
1376         popt->po_delete = 0;
1377
1378         while ((ch = getopt(argc, argv, "nPd")) != -1) {
1379                 switch (ch) {
1380                 case 'n':
1381                         popt->po_show_path = 0;
1382                         break;
1383                 case 'P':
1384                         popt->po_params2 = 1;
1385                         break;
1386                 case 'd':
1387                         popt->po_delete = 1;
1388                         break;
1389                 default:
1390                         return -1;
1391                 }
1392         }
1393         return optind;
1394 }
1395
1396 int jt_lcfg_setparam(int argc, char **argv)
1397 {
1398         int rc = 0, index, i;
1399         struct param_opts popt;
1400         char *path = NULL, *value = NULL;
1401
1402         memset(&popt, 0, sizeof(popt));
1403         index = setparam_cmdline(argc, argv, &popt);
1404         if (index < 0 || index >= argc)
1405                 return CMD_HELP;
1406
1407         if (popt.po_params2)
1408                 /* We can't delete parameters that were
1409                  * set with old conf_param interface */
1410                 return jt_lcfg_mgsparam2(argc, argv, &popt);
1411
1412         for (i = index; i < argc; i++) {
1413                 int rc2;
1414                 path = NULL;
1415
1416                 value = strchr(argv[i], '=');
1417                 if (value != NULL) {
1418                         /* format: set_param a=b */
1419                         *value = '\0';
1420                         value++;
1421                         path = argv[i];
1422                         if (*value == '\0') {
1423                                 fprintf(stderr,
1424                                         "error: %s: setting %s: no value\n",
1425                                         jt_cmdname(argv[0]), path);
1426                                 if (rc == 0)
1427                                         rc = -EINVAL;
1428                                 continue;
1429                         }
1430                 } else {
1431                         /* format: set_param a b */
1432                         path = argv[i];
1433                         i++;
1434                         if (i >= argc) {
1435                                 fprintf(stderr,
1436                                         "error: %s: setting %s: no value\n",
1437                                         jt_cmdname(argv[0]), path);
1438                                 if (rc == 0)
1439                                         rc = -EINVAL;
1440                                 break;
1441                         } else {
1442                                 value = argv[i];
1443                         }
1444                 }
1445
1446                 rc2 = clean_path(&popt, path);
1447                 if (rc2 < 0) {
1448                         fprintf(stderr, "error: %s: cleaning %s: %s\n",
1449                                 jt_cmdname(argv[0]), path, strerror(-rc2));
1450                         if (rc == 0)
1451                                 rc = rc2;
1452                         continue;
1453                 }
1454
1455                 rc2 = param_display(&popt, path, value, SET_PARAM);
1456                 if (rc == 0)
1457                         rc = rc2;
1458         }
1459
1460         return rc;
1461 }