1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <sys/stat.h>
28 #include <sys/mkdev.h>
29 #include <sys/param.h>
30 #include <sys/wait.h>
31 #include <fcntl.h>
32 #include <stdarg.h>
33 #include <stdlib.h>
34 #include <strings.h>
35 #include <errno.h>
36 #include <stdio.h>
37 #include <locale.h>
38 #include <unistd.h>
39 #include <search.h>
40 #include <libgen.h>
41 #include <nsctl.h>
42
43 #include <sys/unistat/spcs_s.h>
44 #include <sys/unistat/spcs_s_u.h>
45 #include <sys/unistat/spcs_errors.h>
46
47 #include <sys/nsctl/sv.h>
48 #include <sys/nsctl/sv_impl.h>
49
50 #include <sys/nsctl/cfg.h>
51 #include <sys/nsctl/nsc_hash.h>
52
53 #include "../sv/svadm.h"
54
55
56 static int sv_max_devices;
57
58
59 /*
60 * support for the special cluster tag "local" to be used with -C in a
61 * cluster for local volumes.
62 */
63
64 #define SV_LOCAL_TAG "local"
65
66 static int sv_islocal;
67
68 /*
69 * libcfg access.
70 */
71
72 static CFGFILE *cfg; /* libcfg file pointer */
73 static int cfg_changed; /* set to 1 if we need to commit changes */
74
75 static char *cfg_cluster_tag; /* local cluster tag */
76
77 static char *implicit_tag; /* implicit cluster tag */
78
79
80 /*
81 * Print width for print_sv() output.
82 */
83
84 #define STATWIDTH (SV_MAXPATH / 2)
85
86 /*
87 * Pathnames.
88 */
89
90 static const caddr_t sv_rpath = SV_DEVICE;
91
92 /*
93 * Functions.
94 */
95
96 static int read_config_file(const caddr_t, sv_name_t []);
97 static int enable_dev(sv_name_t *);
98 static int disable_dev(const caddr_t);
99 static void error(spcs_s_info_t *, caddr_t, ...);
100 static void create_cfg_hash();
101 static int find_in_hash(char *path);
102 static void destroy_hashtable();
103 static void remove_from_cfgfile(char *path, int setnumber);
104
105 static caddr_t program;
106
107 static void
108 sv_cfg_open(CFGLOCK mode)
109 {
110 if (cfg != NULL)
111 return;
112
113 cfg = cfg_open(NULL);
114 if (cfg == NULL) {
115 error(NULL, gettext("unable to access the configuration"));
116 /* NOTREACHED */
117 }
118
119 if (cfg_cluster_tag && *cfg_cluster_tag) {
120 cfg_resource(cfg, cfg_cluster_tag);
121 } else {
122 cfg_resource(cfg, NULL);
123 }
124 if (!cfg_lock(cfg, mode)) {
125 error(NULL, gettext("unable to lock the configuration"));
126 /* NOTREACHED */
127 }
128 }
129
130
131 static void
132 sv_cfg_close(void)
133 {
134 if (cfg == NULL)
135 return;
136
137 if (cfg_changed) {
138 (void) cfg_commit(cfg);
139 cfg_changed = 0;
140 }
141
142 cfg_close(cfg);
143 cfg = NULL;
144 }
145
146
147
148 static void
149 usage(void)
150 {
151 (void) fprintf(stderr, gettext("usage:\n"));
152
153 (void) fprintf(stderr, gettext(
154 "\t%s -h help\n"), program);
155
156 (void) fprintf(stderr, gettext(
157 "\t%s [-C tag] display status\n"),
158 program);
159
160 (void) fprintf(stderr, gettext(
161 "\t%s [-C tag] -i display "
162 "extended status\n"), program);
163
164 (void) fprintf(stderr, gettext(
165 "\t%s [-C tag] -v display "
166 "version number\n"), program);
167
168 (void) fprintf(stderr, gettext(
169 "\t%s [-C tag] -e { -f file | volume } enable\n"), program);
170
171 (void) fprintf(stderr, gettext(
172 "\t%s [-C tag] -d { -f file | volume } disable\n"), program);
173
174 (void) fprintf(stderr, gettext(
175 "\t%s [-C tag] -r { -f file | volume } reconfigure\n"), program);
176
177 sv_cfg_close();
178 }
179
180 static void
181 message(caddr_t prefix, spcs_s_info_t *status, caddr_t string, va_list ap)
182 {
183 (void) fprintf(stderr, "%s: %s: ", program, prefix);
184 (void) vfprintf(stderr, string, ap);
185 (void) fprintf(stderr, "\n");
186
187 if (status) {
188 spcs_s_report(*status, stderr);
189 spcs_s_ufree(status);
190 }
191 }
192
193
194 static void
195 error(spcs_s_info_t *status, caddr_t string, ...)
196 {
197 va_list ap;
198 va_start(ap, string);
199
200 message(gettext("error"), status, string, ap);
201
202 va_end(ap);
203
204 sv_cfg_close();
205 exit(1);
206 }
207
208
209 static void
210 warn(spcs_s_info_t *status, caddr_t string, ...)
211 {
212 va_list ap;
213 va_start(ap, string);
214
215 message(gettext("warning"), status, string, ap);
216
217 va_end(ap);
218 }
219
220
221 static void
222 sv_get_maxdevs(void)
223 {
224 sv_name_t svn[1];
225 sv_list_t svl;
226 int fd;
227
228 if (sv_max_devices > 0)
229 return;
230
231 fd = open(sv_rpath, O_RDONLY);
232 if (fd < 0)
233 error(NULL, gettext("unable to open %s: %s"),
234 sv_rpath, strerror(errno));
235
236 bzero(&svl, sizeof (svl));
237 bzero(&svn[0], sizeof (svn));
238
239 svl.svl_names = &svn[0];
240 svl.svl_error = spcs_s_ucreate();
241
242 if (ioctl(fd, SVIOC_LIST, &svl) < 0) {
243 (void) close(fd);
244 error(&svl.svl_error, gettext("unable to get max devs"));
245 }
246
247 spcs_s_ufree(&svl.svl_error);
248 sv_max_devices = svl.svl_maxdevs;
249
250 (void) close(fd);
251 }
252
253
254 static sv_name_t *
255 sv_alloc_svnames(void)
256 {
257 sv_name_t *svn = NULL;
258
259 sv_get_maxdevs();
260
261 svn = calloc(sv_max_devices, sizeof (*svn));
262 if (svn == NULL) {
263 error(NULL, "unable to allocate %ld bytes of memory",
264 sv_max_devices * sizeof (*svn));
265 }
266
267 return (svn);
268 }
269
270
271 static void
272 sv_check_dgislocal(char *dgname)
273 {
274 char *othernode;
275 int rc;
276
277 /*
278 * check where this disk service is mastered
279 */
280
281 rc = cfg_dgname_islocal(dgname, &othernode);
282 if (rc < 0) {
283 error(NULL, gettext("unable to find "
284 "disk service, %s: %s"), dgname, strerror(errno));
285 }
286
287 if (rc == 0) {
288 error(NULL, gettext("disk service, %s, is "
289 "active on node \"%s\"\nPlease re-issue "
290 "the command on that node"), dgname, othernode);
291 }
292 }
293
294
295 /*
296 * Carry out cluster based checks for a specified volume, or just
297 * global options.
298 */
299 static void
300 sv_check_cluster(char *path)
301 {
302 char dgname[CFG_MAX_BUF];
303 static int sv_iscluster = -1; /* set to 1 if running in a cluster */
304
305 /*
306 * Find out if we are running in a cluster
307 */
308 if (sv_iscluster == -1) {
309 if ((sv_iscluster = cfg_iscluster()) < 0) {
310 error(NULL, gettext("unable to ascertain environment"));
311 }
312 }
313
314 if (!sv_iscluster && cfg_cluster_tag != NULL) {
315 error(NULL, gettext("-C is not valid when not in a cluster"));
316 }
317
318 if (!sv_iscluster || sv_islocal || path == NULL) {
319 return;
320 }
321
322
323 /*
324 * Cluster-only checks on pathname
325 */
326 if (cfg_dgname(path, dgname, sizeof (dgname)) == NULL) {
327 error(NULL, gettext("unable to determine "
328 "disk group name for %s"), path);
329 return;
330 }
331
332 if (cfg_cluster_tag != NULL) {
333 /*
334 * Do dgislocal check now in case path did not contain
335 * a dgname.
336 *
337 * E.g. adding a /dev/did/ device to a disk service.
338 */
339
340 sv_check_dgislocal(cfg_cluster_tag);
341 }
342
343 if (strcmp(dgname, "") == 0)
344 return; /* NULL dgname is valid */
345
346 if (cfg_cluster_tag == NULL) {
347 /*
348 * Implicitly set the cluster tag to dgname
349 */
350
351 sv_check_dgislocal(dgname);
352
353 if (implicit_tag) {
354 free(implicit_tag);
355 implicit_tag = NULL;
356 }
357
358 implicit_tag = strdup(dgname);
359 if (implicit_tag == NULL) {
360 error(NULL,
361 gettext("unable to allocate memory "
362 "for cluster tag"));
363 }
364 } else {
365 /*
366 * Check dgname and cluster tag from -C are the same.
367 */
368
369 if (strcmp(dgname, cfg_cluster_tag) != 0) {
370 error(NULL,
371 gettext("-C (%s) does not match disk group "
372 "name (%s) for %s"), cfg_cluster_tag,
373 dgname, path);
374 }
375
376 /*
377 * sv_check_dgislocal(cfg_cluster_tag) was called above.
378 */
379 }
380 }
381
382
383 static void
384 print_version(void)
385 {
386 sv_version_t svv;
387 int fd;
388
389 bzero(&svv, sizeof (svv));
390 svv.svv_error = spcs_s_ucreate();
391
392 fd = open(sv_rpath, O_RDONLY);
393 if (fd < 0) {
394 warn(NULL, gettext("unable to open %s: %s"),
395 sv_rpath, strerror(errno));
396 return;
397 }
398
399 if (ioctl(fd, SVIOC_VERSION, &svv) != 0) {
400 error(&svv.svv_error,
401 gettext("unable to read the version number"));
402 /* NOTREACHED */
403 }
404
405 spcs_s_ufree(&svv.svv_error);
406 #ifdef DEBUG
407 (void) printf(gettext("Storage Volume version %d.%d.%d.%d\n"),
408 svv.svv_major_rev, svv.svv_minor_rev,
409 svv.svv_micro_rev, svv.svv_baseline_rev);
410 #else
411 if (svv.svv_micro_rev) {
412 (void) printf(gettext("Storage Volume version %d.%d.%d\n"),
413 svv.svv_major_rev, svv.svv_minor_rev, svv.svv_micro_rev);
414 } else {
415 (void) printf(gettext("Storage Volume version %d.%d\n"),
416 svv.svv_major_rev, svv.svv_minor_rev);
417 }
418 #endif
419
420 (void) close(fd);
421 }
422
423 int
424 main(int argc, char *argv[])
425 {
426 extern int optind;
427 extern char *optarg;
428 char *conf_file = NULL;
429 int enable, disable, compare, print, version;
430 int opt, Cflag, fflag, iflag;
431 int rc;
432
433 (void) setlocale(LC_ALL, "");
434 (void) textdomain("svadm");
435
436 program = strdup(basename(argv[0]));
437
438 Cflag = fflag = iflag = 0;
439 compare = enable = disable = version = 0;
440
441 print = 1;
442
443 while ((opt = getopt(argc, argv, "C:def:hirv")) != EOF) {
444 switch (opt) {
445
446 case 'C':
447 if (Cflag) {
448 warn(NULL,
449 gettext("-C specified multiple times"));
450 usage();
451 exit(2);
452 /* NOTREACHED */
453 }
454
455 Cflag++;
456 cfg_cluster_tag = optarg;
457 break;
458
459 case 'e':
460 print = 0;
461 enable++;
462 break;
463
464 case 'd':
465 print = 0;
466 disable++;
467 break;
468
469 case 'f':
470 fflag++;
471 conf_file = optarg;
472 break;
473
474 case 'i':
475 iflag++;
476 break;
477
478 case 'r':
479 /* Compare running system with sv.cf */
480 print = 0;
481 compare++;
482 break;
483
484 case 'v':
485 print = 0;
486 version++;
487 break;
488
489 case 'h':
490 usage();
491 exit(0);
492
493 default:
494 usage();
495 exit(2);
496 /* NOTREACHED */
497 }
498 }
499
500
501 /*
502 * Usage checks
503 */
504
505 if ((enable + disable + compare) > 1) {
506 warn(NULL, gettext("-d, -e and -r are mutually exclusive"));
507 usage();
508 exit(2);
509 }
510
511 if (fflag && (print || version)) {
512 warn(NULL, gettext("-f is only valid with -d, -e or -r"));
513 usage();
514 exit(2);
515 }
516
517 if (fflag && optind != argc) {
518 usage();
519 exit(2);
520 }
521
522 if (print || version) {
523 /* check for no more args */
524
525 if (optind != argc) {
526 usage();
527 exit(2);
528 }
529 } else {
530 /* check for inline args */
531
532 if (!fflag && (argc - optind) != 1) {
533 usage();
534 exit(2);
535 }
536 }
537
538 if (!print && iflag) {
539 usage();
540 exit(2);
541 }
542
543
544 /*
545 * Check for the special cluster tag and convert into the
546 * internal representation.
547 */
548
549 if (cfg_cluster_tag != NULL &&
550 strcmp(cfg_cluster_tag, SV_LOCAL_TAG) == 0) {
551 cfg_cluster_tag = "-";
552 sv_islocal = 1;
553 }
554
555
556 /*
557 * Process commands
558 */
559
560 if (optind != argc) {
561 /* deal with inline volume argument */
562
563 rc = 0;
564 if (enable)
565 rc = enable_one_sv(argv[optind]);
566 else if (disable)
567 rc = disable_one_sv(argv[optind]);
568 else /* if (compare) */
569 compare_one_sv(argv[optind]);
570
571 if (rc != 0)
572 return (1);
573
574 return (0);
575 }
576
577 rc = 0;
578 if (enable)
579 rc = enable_sv(conf_file);
580 else if (disable)
581 rc = disable_sv(conf_file);
582 else if (compare)
583 compare_sv(conf_file);
584 else if (print)
585 print_sv(iflag);
586 else /* if (version) */
587 print_version();
588
589 if (rc != 0)
590 return (1);
591
592 return (0);
593 }
594
595
596
597 /* LINT - not static as fwcadm uses it */
598 static int
599 enable_sv(char *conf_file)
600 {
601 int index;
602 sv_name_t *svn;
603 int cnt;
604 int rc, ret;
605
606 svn = sv_alloc_svnames();
607
608 index = read_config_file(conf_file, svn);
609
610 rc = ret = 0;
611
612 for (cnt = 0; cnt < index; cnt++) {
613
614 /*
615 * Check for more data.
616 */
617 if (svn[cnt].svn_path[0] == '\0') {
618 /*
619 * This was set when reading sv.conf. After the last
620 * line svn_path was set to \0, so we are finished.
621 * We shouldn't get here, but put this in just in
622 * case.
623 */
624 break;
625 }
626 rc = enable_dev(&svn[cnt]);
627 if (rc && !ret)
628 ret = rc;
629 }
630
631 sv_cfg_close();
632
633 return (ret);
634 }
635
636
637 /* LINT - not static as fwcadm uses it */
638 static int
639 enable_one_sv(caddr_t path)
640 {
641 sv_name_t svn;
642 int rc;
643
644 sv_get_maxdevs();
645
646 bzero(&svn, sizeof (svn));
647 (void) strncpy(svn.svn_path, path, sizeof (svn.svn_path));
648 svn.svn_mode = (NSC_DEVICE | NSC_CACHE);
649
650 /* force NULL termination */
651 svn.svn_path[sizeof (svn.svn_path) - 1] = '\0';
652
653 rc = enable_dev(&svn);
654 sv_cfg_close();
655
656 return (rc);
657 }
658
659
660 static int
661 enable_dev(sv_name_t *svn)
662 {
663 char buf[CFG_MAX_BUF];
664 struct stat stb;
665 sv_conf_t svc;
666 int fd;
667 int sev;
668 int rc;
669 char *lcltag;
670 char *altname;
671
672 sv_check_cluster(svn->svn_path);
673 sv_cfg_open(CFG_WRLOCK);
674
675 bzero(&svc, sizeof (svc));
676
677 if (stat(svn->svn_path, &stb) != 0) {
678 warn(NULL, gettext("unable to access %s: %s"),
679 svn->svn_path, strerror(errno));
680 return (1);
681 }
682
683 if (!S_ISCHR(stb.st_mode)) {
684 warn(NULL, gettext("%s is not a character device - ignored"),
685 svn->svn_path);
686 return (1);
687 }
688
689 svc.svc_major = major(stb.st_rdev);
690 svc.svc_minor = minor(stb.st_rdev);
691 (void) strncpy(svc.svc_path, svn->svn_path, sizeof (svc.svc_path));
692
693 fd = open(sv_rpath, O_RDONLY);
694 if (fd < 0) {
695 warn(NULL, gettext("unable to open %s: %s"),
696 svn->svn_path, strerror(errno));
697 return (1);
698 }
699
700 svc.svc_flag = svn->svn_mode;
701 svc.svc_error = spcs_s_ucreate();
702
703 /* first, check for duplicates */
704 rc = cfg_get_canonical_name(cfg, svn->svn_path, &altname);
705 if (rc < 0) {
706 spcs_log("sv", NULL, gettext("Unable to parse config file"));
707 warn(NULL, gettext("Unable to parse config file"));
708 (void) close(fd);
709 return (1);
710 }
711 if (rc) {
712 error(NULL, gettext("'%s' has already been configured as "
713 "'%s'. Re-enter command with the latter name."),
714 svn->svn_path, altname);
715 }
716
717 /* secondly, try to insert it into the dsvol config */
718 if (implicit_tag && *implicit_tag) {
719 lcltag = implicit_tag;
720 } else if (cfg_cluster_tag && *cfg_cluster_tag) {
721 lcltag = cfg_cluster_tag;
722 } else {
723 lcltag = "-";
724 }
725 rc = cfg_add_user(cfg, svn->svn_path, lcltag, "sv");
726 if (CFG_USER_ERR == rc) {
727 spcs_log("sv", NULL,
728 gettext("%s: unable to put %s into dsvol cfg"),
729 program, svn->svn_path);
730 warn(NULL, gettext("unable to put %s into dsvol cfg"),
731 svn->svn_path);
732 (void) close(fd);
733 return (1);
734 }
735 cfg_changed = 1;
736
737 if (CFG_USER_OK == rc) {
738 /* success */
739 (void) close(fd);
740 return (0);
741 }
742
743 if (ioctl(fd, SVIOC_ENABLE, &svc) < 0) {
744 if ((CFG_USER_REPEAT == rc) && (SV_EENABLED == errno)) {
745 /* it's ok -- we were just double-checking */
746 (void) close(fd);
747 return (0);
748 }
749
750 spcs_log("sv", &svc.svc_error,
751 gettext("%s: unable to enable %s"),
752 program, svn->svn_path);
753
754 warn(&svc.svc_error, gettext("unable to enable %s"),
755 svn->svn_path);
756
757 /* remove it from dsvol, if we're the ones who put it in */
758 if (CFG_USER_FIRST == rc) {
759 (void) cfg_rem_user(cfg, svn->svn_path, lcltag, "sv");
760 }
761 (void) close(fd);
762 return (1);
763 }
764
765 spcs_log("sv", NULL, gettext("%s: enabled %s"),
766 program, svn->svn_path);
767
768 if (implicit_tag != NULL) {
769 #ifdef DEBUG
770 if (cfg_cluster_tag != NULL) {
771 error(NULL,
772 gettext("enable_dev: -C %s AND implicit_tag %s!"),
773 cfg_cluster_tag, implicit_tag);
774 }
775 #endif
776
777 (void) snprintf(buf, sizeof (buf), "%s - %s",
778 svc.svc_path, implicit_tag);
779 } else {
780 (void) strcpy(buf, svc.svc_path);
781 }
782
783 rc = 0;
784 if (cfg_put_cstring(cfg, "sv", buf, sizeof (buf)) < 0) {
785 warn(NULL,
786 gettext("unable to add %s to configuration storage: %s"),
787 svc.svc_path, cfg_error(&sev));
788 rc = 1;
789 }
790
791 cfg_changed = 1;
792 spcs_s_ufree(&svc.svc_error);
793 (void) close(fd);
794
795 return (rc);
796 }
797
798
799 /*
800 * This routine parses the config file passed in via conf_file and
801 * stores the data in the svn array. The return value is the number
802 * of entries read from conf_file. If an error occurs the error()
803 * routine is called (which exits the program).
804 */
805 static int
806 read_config_file(const caddr_t conf_file, sv_name_t svn[])
807 {
808 char line[1024], rdev[1024], junk[1024];
809 struct stat stb;
810 int lineno;
811 int cnt, i;
812 int index = 0; /* Current location in svn array */
813 sv_name_t *cur_svn; /* Pointer to svn[index] */
814 FILE *fp;
815
816 if (access(conf_file, R_OK) != 0 ||
817 stat(conf_file, &stb) != 0 ||
818 !S_ISREG(stb.st_mode)) {
819 error(NULL, gettext("cannot read config file %s"), conf_file);
820 }
821
822 if ((fp = fopen(conf_file, "r")) == NULL) {
823 error(NULL, gettext("unable to open config file %s: %s"),
824 conf_file, strerror(errno));
825 }
826
827 lineno = 0;
828
829 while (fgets(line, sizeof (line), fp) != NULL) {
830 lineno++;
831
832 i = strlen(line);
833
834 if (i < 1)
835 continue;
836
837 if (line[i-1] == '\n')
838 line[i-1] = '\0';
839 else if (i == (sizeof (line) - 1)) {
840 warn(NULL, gettext(
841 "line %d: line too long -- should be less than %d characters"),
842 lineno, (sizeof (line) - 1));
843 warn(NULL, gettext("line %d: ignored"), lineno);
844 }
845
846 /*
847 * check for comment line.
848 */
849 if (line[0] == '#')
850 continue;
851
852 cnt = sscanf(line, "%s %s", rdev, junk);
853
854 if (cnt != 1 && cnt != 2) {
855 if (cnt > 0) {
856 warn(NULL, gettext("line %d: invalid format"),
857 lineno);
858 warn(NULL, gettext("line %d: ignored"), lineno);
859 }
860 continue;
861 }
862
863 rdev[sizeof (rdev) - 1] = '\0';
864
865 cur_svn = &svn[index]; /* For easier reading below */
866
867 if (strlen(rdev) >= sizeof (cur_svn->svn_path)) {
868 warn(NULL, gettext(
869 "line %d: raw device name (%s) longer than %d characters"),
870 lineno, rdev,
871 (sizeof (cur_svn->svn_path) - 1));
872 warn(NULL, gettext("line %d: ignored"), lineno);
873 continue;
874 }
875
876 (void) strcpy(cur_svn->svn_path, rdev);
877 cur_svn->svn_mode = (NSC_DEVICE | NSC_CACHE);
878
879 index++;
880 }
881
882 /* Set the last path to NULL */
883 svn[index].svn_path[0] = '\0';
884
885 (void) fclose(fp);
886
887 return (index);
888 }
889
890
891 /*
892 * Disable the device from the kernel configuration.
893 *
894 * RETURN:
895 * 0 on success
896 * non-zero on failure.
897 *
898 * Failures are reported to the user.
899 */
900 static int
901 disable_dev(const caddr_t path)
902 {
903 struct stat stb;
904 sv_conf_t svc;
905 int fd;
906
907 sv_check_cluster(path);
908
909 if (stat(path, &stb) < 0) {
910 svc.svc_major = (major_t)-1;
911 svc.svc_minor = (minor_t)-1;
912 } else {
913 svc.svc_major = major(stb.st_rdev);
914 svc.svc_minor = minor(stb.st_rdev);
915 }
916
917 if ((fd = open(sv_rpath, O_RDONLY)) < 0) {
918 warn(NULL, gettext("unable to open %s: %s"),
919 sv_rpath, strerror(errno));
920 return (-1);
921 }
922
923 (void) strcpy(svc.svc_path, path);
924 svc.svc_error = spcs_s_ucreate();
925
926 /*
927 * Issue the ioctl to attempt to disable this device. Note that all
928 * the libdscfg details are handled elsewhere.
929 */
930 if (ioctl(fd, SVIOC_DISABLE, &svc) < 0) {
931 if (errno != SV_EDISABLED) {
932 spcs_log("sv", &svc.svc_error,
933 gettext("%s: unable to disable %s"),
934 program, path);
935
936 warn(&svc.svc_error,
937 gettext("unable to disable %s"), path);
938 (void) close(fd);
939 return (-1);
940 }
941 }
942
943 spcs_log("sv", NULL, gettext("%s: disabled %s"), program, path);
944
945 spcs_s_ufree(&svc.svc_error);
946 (void) close(fd);
947
948 return (0);
949 }
950
951
952 static void
953 print_cluster_tag(const int setnumber)
954 {
955 char buf[CFG_MAX_BUF];
956 char key[CFG_MAX_KEY];
957
958 bzero(buf, sizeof (buf));
959 (void) snprintf(key, sizeof (key), "sv.set%d.cnode", setnumber);
960
961 (void) cfg_get_cstring(cfg, key, buf, sizeof (buf));
962
963 if (*buf != '\0') {
964 if (strcmp(buf, "-") == 0) {
965 (void) printf(" [%s]", gettext("local to node"));
966 } else {
967 (void) printf(" [%s: %s]", gettext("cluster"), buf);
968 }
969 }
970 }
971
972
973 /* LINT - not static as fwcadm uses it */
974 static void
975 print_sv(int verbose)
976 {
977 sv_name_t *svn, *svn_system; /* Devices in system */
978 sv_list_t svl_system;
979 int fd, i;
980 int setnumber;
981
982 sv_check_cluster(NULL);
983 sv_cfg_open(CFG_RDLOCK);
984
985 svn_system = sv_alloc_svnames();
986
987 if ((fd = open(sv_rpath, O_RDONLY)) < 0) {
988 (void) printf(gettext("unable to open %s: %s"),
989 sv_rpath, strerror(errno));
990 return;
991 }
992
993 /* Grab the system list from the driver */
994 svl_system.svl_count = sv_max_devices;
995 svl_system.svl_names = &svn_system[0];
996 svl_system.svl_error = spcs_s_ucreate();
997
998 if (ioctl(fd, SVIOC_LIST, &svl_system) < 0) {
999 error(&svl_system.svl_error, gettext("unable to get list"));
1000 }
1001
1002 spcs_s_ufree(&svl_system.svl_error);
1003 (void) close(fd);
1004
1005 /*
1006 * We build a hashmap out of the entries from the config file to make
1007 * searching faster. We end up taking a performance hit when the # of
1008 * volumes is small, but for larger configurations it's a
1009 * HUGE improvement.
1010 */
1011
1012 /* build the hashtable */
1013 cfg_rewind(cfg, CFG_SEC_CONF);
1014 create_cfg_hash();
1015
1016 /*
1017 * For each volume found from the kernel, print out
1018 * info about it from the kernel.
1019 */
1020 for (i = 0; i < svl_system.svl_count; i++) {
1021 if (*svn_system[i].svn_path == '\0') {
1022 break;
1023 }
1024
1025 svn = &svn_system[i];
1026 if (svn->svn_mode == 0) {
1027 #ifdef DEBUG
1028 (void) printf(gettext("%s [kernel guard]\n"),
1029 svn->svn_path);
1030 #endif
1031 continue;
1032 }
1033 /* get sv entry from the hashtable */
1034 if ((setnumber = find_in_hash(svn->svn_path)) != -1) {
1035 (void) printf("%-*s", STATWIDTH, svn->svn_path);
1036
1037 if (verbose) {
1038 print_cluster_tag(setnumber);
1039 }
1040
1041 (void) printf("\n");
1042
1043 } else {
1044 /*
1045 * We didn't find the entry in the hashtable. Let
1046 * the user know that the persistent storage is
1047 * inconsistent with the kernel configuration.
1048 */
1049 if (cfg_cluster_tag == NULL)
1050 warn(NULL, gettext(
1051 "%s is configured, but not in the "
1052 "config storage"), svn->svn_path);
1053 }
1054 }
1055
1056 /* free up the hashtable */
1057 destroy_hashtable();
1058
1059 sv_cfg_close();
1060 }
1061
1062
1063 /* LINT - not static as fwcadm uses it */
1064 static int
1065 disable_sv(char *conf_file)
1066 {
1067 sv_name_t *svn, *svn_system; /* Devices in system */
1068 sv_list_t svl_system;
1069 int fd, i, setnumber;
1070 int rc, ret;
1071
1072 svn_system = sv_alloc_svnames();
1073
1074 rc = ret = 0;
1075
1076 if (conf_file == NULL) {
1077 if ((fd = open(sv_rpath, O_RDONLY)) < 0) {
1078 (void) printf(gettext("unable to open %s: %s"),
1079 sv_rpath, strerror(errno));
1080 return (1);
1081 }
1082
1083 /* Grab the system list from the driver */
1084 svl_system.svl_count = sv_max_devices;
1085 svl_system.svl_names = &svn_system[0];
1086 svl_system.svl_error = spcs_s_ucreate();
1087
1088 if (ioctl(fd, SVIOC_LIST, &svl_system) < 0) {
1089 error(&(svl_system.svl_error),
1090 gettext("unable to get list"));
1091 }
1092
1093 spcs_s_ufree(&(svl_system.svl_error));
1094 (void) close(fd);
1095 } else {
1096 svl_system.svl_count = read_config_file(conf_file, svn_system);
1097 }
1098
1099
1100 for (i = 0; i < svl_system.svl_count; i++) {
1101 if (*svn_system[i].svn_path == '\0')
1102 break;
1103
1104 svn = &svn_system[i];
1105
1106 sv_check_cluster(svn->svn_path);
1107 sv_cfg_open(CFG_WRLOCK);
1108 create_cfg_hash();
1109 rc = 0;
1110 if ((setnumber = find_in_hash(svn->svn_path)) != -1) {
1111 if ((rc = disable_dev(svn->svn_path)) != -1) {
1112 remove_from_cfgfile(svn->svn_path, setnumber);
1113 } else if (errno == SV_ENODEV) {
1114 remove_from_cfgfile(svn->svn_path, setnumber);
1115 }
1116 } else {
1117 /* warn the user that we didn't find it in cfg file */
1118 warn(NULL, gettext(
1119 "%s was not found in the config storage"),
1120 svn->svn_path);
1121 /* try to disable anyway */
1122 (void) disable_dev(svn->svn_path);
1123 rc = 1;
1124 }
1125
1126 sv_cfg_close();
1127 destroy_hashtable();
1128
1129 if (rc && !ret)
1130 ret = rc;
1131 }
1132
1133 return (ret);
1134 }
1135
1136
1137 /* LINT - not static as fwcadm uses it */
1138 static int
1139 disable_one_sv(char *path)
1140 {
1141 int setnumber;
1142 int rc;
1143
1144 sv_get_maxdevs();
1145 sv_check_cluster(path);
1146 sv_cfg_open(CFG_WRLOCK);
1147
1148 create_cfg_hash();
1149 if ((setnumber = find_in_hash(path)) != -1) {
1150 /* remove from kernel */
1151 if ((rc = disable_dev(path)) == 0) {
1152 /* remove the cfgline */
1153 remove_from_cfgfile(path, setnumber);
1154 } else if (errno == SV_ENODEV) {
1155 remove_from_cfgfile(path, setnumber);
1156 }
1157 } else {
1158 /* warn the user that we didn't find it in cfg file */
1159 warn(NULL,
1160 gettext("%s was not found in the config storage"), path);
1161 /* still attempt to remove */
1162 (void) disable_dev(path);
1163 rc = 1;
1164 }
1165 destroy_hashtable();
1166
1167 sv_cfg_close();
1168 return (rc);
1169 }
1170
1171
1172 static void
1173 compare_tag(char *path)
1174 {
1175 char buf[CFG_MAX_BUF], vol[CFG_MAX_BUF], cnode[CFG_MAX_BUF];
1176 char key[CFG_MAX_KEY];
1177 int found, setnumber, i;
1178 char *tag;
1179
1180 sv_check_cluster(path);
1181 cfg_resource(cfg, (char *)NULL); /* reset */
1182 cfg_rewind(cfg, CFG_SEC_CONF);
1183
1184 #ifdef DEBUG
1185 if (cfg_cluster_tag != NULL && implicit_tag != NULL) {
1186 error(NULL, gettext("compare_tag: -C %s AND implicit_tag %s!"),
1187 cfg_cluster_tag, implicit_tag);
1188 }
1189 #endif
1190
1191 if (cfg_cluster_tag != NULL)
1192 tag = cfg_cluster_tag;
1193 else if (implicit_tag != NULL)
1194 tag = implicit_tag;
1195 else
1196 tag = "-";
1197
1198 found = 0;
1199 for (i = 0; i < sv_max_devices; i++) {
1200 setnumber = i + 1;
1201 (void) snprintf(key, sizeof (key), "sv.set%d", setnumber);
1202 if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0) {
1203 break;
1204 }
1205
1206 if (sscanf(buf, "%s - %s", vol, cnode) != 2) {
1207 continue;
1208 }
1209
1210 if (strcmp(path, vol) == 0) {
1211 found = 1;
1212 break;
1213 }
1214 }
1215
1216 if (!found) {
1217 warn(NULL, gettext("unable to find %s in the configuration"),
1218 path);
1219 return;
1220 }
1221
1222 /* have name match, compare cnode to new tag */
1223
1224 if (strcmp(tag, cnode) == 0) {
1225 /* cluster tags match */
1226 return;
1227 }
1228
1229 /* need to change the cluster tag */
1230
1231 (void) snprintf(key, sizeof (key), "sv.set%d.cnode", setnumber);
1232 if (cfg_put_cstring(cfg, key, tag, strlen(tag)) < 0) {
1233 warn(NULL,
1234 gettext("unable to change cluster tag for %s"), path);
1235 return;
1236 }
1237
1238 cfg_changed = 1;
1239
1240 /* change "-" tags to "" for display purposes */
1241
1242 if (strcmp(tag, "-") == 0)
1243 tag = "";
1244
1245 if (strcmp(cnode, "-") == 0)
1246 (void) strcpy(cnode, "");
1247
1248 (void) printf(
1249 gettext("%s: changed cluster tag for %s from \"%s\" to \"%s\"\n"),
1250 program, path, cnode, tag);
1251
1252 spcs_log("sv", NULL,
1253 gettext("%s: changed cluster tag for %s from \"%s\" to \"%s\""),
1254 program, path, cnode, tag);
1255 }
1256
1257
1258 /* LINT - not static as fwcadm uses it */
1259 static void
1260 compare_sv(char *conf_file)
1261 {
1262 sv_name_t *svn_config; /* Devices in config file */
1263 sv_name_t *svn_system; /* Devices in system */
1264 sv_name_t *enable; /* Devices that need enabled */
1265 sv_list_t svl_system;
1266 int config_cnt;
1267 int sys_cnt = 0;
1268 int setnumber, i, j;
1269 int index = 0; /* Index in enable[] */
1270 int found;
1271 int fd0;
1272
1273 svn_config = sv_alloc_svnames();
1274 svn_system = sv_alloc_svnames();
1275 enable = sv_alloc_svnames();
1276
1277 bzero(svn_system, sizeof (svn_system));
1278 bzero(&svl_system, sizeof (svl_system));
1279 bzero(enable, sizeof (enable));
1280
1281 /*
1282 * Read the configuration file
1283 * The return value is the number of entries
1284 */
1285 config_cnt = read_config_file(conf_file, svn_config);
1286
1287 if ((fd0 = open(sv_rpath, O_RDONLY)) < 0)
1288 error(NULL, gettext("unable to open %s: %s"),
1289 sv_rpath, strerror(errno));
1290
1291 /* Grab the system list from the driver */
1292 svl_system.svl_count = sv_max_devices;
1293 svl_system.svl_names = &svn_system[0];
1294 svl_system.svl_error = spcs_s_ucreate();
1295
1296 if (ioctl(fd0, SVIOC_LIST, &svl_system) < 0) {
1297 error(&svl_system.svl_error, gettext("unable to get list"));
1298 }
1299
1300 spcs_s_ufree(&svl_system.svl_error);
1301 (void) close(fd0);
1302
1303 /*
1304 * Count the number of devices in the system.
1305 * The last entry in the array has '\0' for a path name.
1306 */
1307 for (j = 0; j < sv_max_devices; j++) {
1308 if (svn_system[j].svn_path[0] != '\0') {
1309 sys_cnt++;
1310 } else {
1311 break;
1312 }
1313 }
1314 /*
1315 * Compare the configuration array with the system array.
1316 * Mark any differences and disable conflicting devices.
1317 */
1318 for (i = 0; i < config_cnt; i++) {
1319 found = 0;
1320 for (j = 0; j < sys_cnt; j++) {
1321 if (svn_system[j].svn_path[0] == '\0' ||
1322 svn_system[j].svn_mode == 0)
1323 continue;
1324
1325 /* Check to see if path matches */
1326 if (strcmp(svn_system[j].svn_path,
1327 svn_config[i].svn_path) == 0) {
1328 /* Found a match */
1329 svn_system[j].svn_path[0] = '\0';
1330 found++;
1331 break;
1332 }
1333 }
1334
1335 if (!found) {
1336 /* Minor number not in system = > enable device */
1337 enable[index].svn_mode = svn_config[i].svn_mode;
1338 (void) strcpy(enable[index].svn_path,
1339 svn_config[i].svn_path);
1340 index++;
1341 }
1342 }
1343
1344 /* Disable any devices that weren't in the config file */
1345 for (j = 0; j < sys_cnt; j++) {
1346 sv_check_cluster(NULL);
1347 sv_cfg_open(CFG_WRLOCK);
1348 create_cfg_hash();
1349 if (svn_system[j].svn_path[0] != '\0' &&
1350 svn_system[j].svn_mode != 0) {
1351 (void) printf(gettext("%s: disabling sv: %s\n"),
1352 program, svn_system[j].svn_path);
1353 if (disable_dev(svn_system[j].svn_path) == 0) {
1354 setnumber =
1355 find_in_hash(svn_system[j].svn_path);
1356 if (setnumber != -1) {
1357 /* the volume was found in cfg store */
1358 remove_from_cfgfile(
1359 svn_system[j].svn_path, setnumber);
1360 }
1361 }
1362 }
1363 sv_cfg_close();
1364 destroy_hashtable();
1365 }
1366
1367 while (index) {
1368 /*
1369 * Config file doesn't match system => enable the devices
1370 * in enable[]
1371 */
1372 index--;
1373 (void) printf(gettext("%s: enabling new sv: %s\n"),
1374 program, enable[index].svn_path);
1375 (void) enable_dev(&enable[index]);
1376 }
1377
1378 /*
1379 * Search for entries where the cluster tag has changed.
1380 */
1381 sv_check_cluster(NULL);
1382 sv_cfg_open(CFG_WRLOCK);
1383
1384 for (i = 0; i < sv_max_devices; i++) {
1385 if (svn_config[i].svn_path[0] == '\0')
1386 break;
1387
1388 compare_tag(svn_config[i].svn_path);
1389 }
1390
1391 sv_cfg_close();
1392 }
1393
1394
1395 /*
1396 * We assume that the volume is already enabled and we can only
1397 * be changing the cluster tag. Anything else is an error.
1398 */
1399 /* LINT - not static as fwcadm uses it */
1400 static void
1401 compare_one_sv(char *path)
1402 {
1403 sv_get_maxdevs();
1404 sv_check_cluster(NULL);
1405 sv_cfg_open(CFG_WRLOCK);
1406
1407 compare_tag(path);
1408
1409 sv_cfg_close();
1410 }
1411
1412 /*
1413 * Read all sets from the libdscfg configuration file, and store everything in
1414 * the hashfile.
1415 *
1416 * We assume that the config file has been opened & rewound for us. We store
1417 * the volume name as the key, and the setnumber where we found it as the data.
1418 *
1419 * The caller can pass in a pointer to the maximum number of volumes, or
1420 * a pointer to NULL, specifying we want 'all' the volumes. The table is
1421 * searched using find_in_hash.
1422 */
1423 static void
1424 create_cfg_hash()
1425 {
1426 char key[CFG_MAX_KEY], buf[CFG_MAX_BUF];
1427 char vol[CFG_MAX_BUF], cnode[CFG_MAX_BUF];
1428 int setnumber;
1429 ENTRY item;
1430
1431 if (hcreate((size_t)sv_max_devices) == 0)
1432 error(NULL, gettext("unable to create hash table"));
1433
1434 for (setnumber = 1; /* CSTYLED */; setnumber++) {
1435 (void) snprintf(key, sizeof (key), "sv.set%d", setnumber);
1436 if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0)
1437 break;
1438
1439 if (sscanf(buf, "%s - %s", vol, cnode) != 2) {
1440 continue;
1441 }
1442
1443 item.key = strdup(vol);
1444 item.data = (void *)setnumber;
1445 if (hsearch(item, ENTER) == NULL) {
1446 error(NULL,
1447 gettext("unable to add entry to hash table"));
1448 }
1449 }
1450 }
1451
1452 /*
1453 * Function to search the hash for a specific volume. If it is found,
1454 * we return the set number. If it isn't found, we return -1
1455 */
1456 static int
1457 find_in_hash(char *path)
1458 {
1459 ENTRY *found_entry, item;
1460 int retval = -1;
1461
1462 item.key = path;
1463
1464 if ((found_entry = hsearch(item, FIND)) != NULL) {
1465 retval = (int)found_entry->data;
1466 }
1467
1468 return (retval);
1469 }
1470
1471 /*
1472 * Just a wrapper to destory the hashtable. At some point in the future we
1473 * might want to do something more.... For instance, verify that the cfg
1474 * database and the kernel configuration match (?) Just an idea.
1475 */
1476 static void
1477 destroy_hashtable()
1478 {
1479 hdestroy();
1480 }
1481
1482 /*
1483 * This function will remove a particular set from the config file.
1484 *
1485 * We make a whole host of assumptions:
1486 * o the hashfile is up to date;
1487 * o The config file has been opened with a WRLOCK for us.
1488 */
1489 static void
1490 remove_from_cfgfile(char *path, int setnumber)
1491 {
1492 char key[CFG_MAX_KEY];
1493 int sev;
1494 char *lcltag;
1495
1496 /* attempt to remove the volume from config storage */
1497 (void) snprintf(key, sizeof (key), "sv.set%d", setnumber);
1498 if (cfg_put_cstring(cfg, key, NULL, 0) < 0) {
1499 warn(NULL, gettext("unable to remove %s from "
1500 "config storage: %s"), path, cfg_error(&sev));
1501 } else {
1502 if (implicit_tag && *implicit_tag) {
1503 lcltag = implicit_tag;
1504 } else if (cfg_cluster_tag && *cfg_cluster_tag) {
1505 lcltag = cfg_cluster_tag;
1506 } else {
1507 lcltag = "-";
1508 }
1509 if (cfg_rem_user(cfg, path, lcltag, "sv") != CFG_USER_LAST) {
1510 warn(NULL, gettext("unable to remove %s from dsvol"),
1511 path);
1512 }
1513 cfg_changed = 1;
1514 }
1515 }