?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / avs / dsw / iiadm.c
blobdd49e10e4e918a8ee9f2da8738eec48d2ae737f0
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 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #include <sys/time.h>
28 #include <errno.h>
29 #include <signal.h>
30 #include <stdio.h>
31 #include <string.h>
32 #include <fcntl.h>
33 #include <stdlib.h>
34 #include <unistd.h>
35 #include <values.h>
36 #include <locale.h>
37 #include <langinfo.h>
38 #include <sys/mman.h>
39 #include <sys/stat.h>
40 #include <sys/wait.h>
41 #include <strings.h>
42 #include <stdarg.h>
43 #include <ctype.h>
44 #include <math.h>
45 #include <sys/param.h>
46 #include <sys/mnttab.h>
47 #include <nsctl.h>
48 #include <netdb.h>
49 #include <search.h>
50
51 #include <sys/nsctl/cfg.h>
52 #include <sys/nsctl/nsc_hash.h>
53
54 #include <sys/unistat/spcs_s.h>
55 #include <sys/unistat/spcs_s_u.h>
56 #include <sys/unistat/spcs_errors.h>
57 #include <sys/nsctl/dsw.h>
58 #include <sys/nsctl/dsw_dev.h> /* for bit map header format */
59
60 #include <sys/nskernd.h>
61
62 typedef struct mstcount_s {
63 int count;
64 } mstcount_t;
65 typedef struct shdvol_s {
66 char master[ DSW_NAMELEN ];
67 } shdvol_t;
68 typedef struct grptag_s {
69 char ctag[ DSW_NAMELEN ];
70 } grptag_t;
71 hash_node_t **volhash = NULL;
72
73 #define DSW_TEXT_DOMAIN "II"
74
75 #include <dlfcn.h>
76 #define RDC_LIB "/usr/lib/librdc.so.1"
77 static int (*self_check)(char *);
78
79 /*
80 * Support for the special cluster tag "local" to be used with -C in a
81 * cluster for local volumes.
82 */
83 #define II_LOCAL_TAG "local"
84
85 #define II_NOT_CLUSTER 1
86 #define II_CLUSTER 2
87 #define II_CLUSTER_LCL 3
88
89 static char *cfg_cluster_tag = NULL;
90 static CFGFILE *cfg = NULL;
91
92 void sigterm(int sig);
93
94 #define SD_BIT_CLR(bmap, bit) (bmap &= ~(1 << bit))
95 #define SD_BIT_ISSET(bmap, bit) ((bmap & (1 << bit)) != 0)
96
97 #define MAX_LINE_SIZE 256 /* maximum characters per line in config file */
98 #define MAX_GROUPS 1024 /* maximum number of groups to support */
99 #define MAX_CLUSTERS 1024 /* maximum number of resource groups */
100
101 unsigned long bm_size; /* size in bytes of bitmap */
102 unsigned long bm_actual; /* original number of bits in bitmap */
103 int debug = 0;
104
105 int dsw_fd;
106
107 #define LD_II 0x00000001
108 #define LD_DSVOLS 0x00000002
109 #define LD_SVOLS 0x00000004
110 #define LD_SHADOWS 0x00000008
111
112 static int reload_vols = 0;
113 static int config_locked = 0;
114 static int last_lock;
115
116 /*
117 * names for do_copy() flags.
118 */
119
120 enum copy_update {Copy = 0, Update};
121 enum copy_direction {ToShadow = 0, ToMaster};
122 enum copy_wait {WaitForStart = 0, WaitForEnd};
123
124 char *cmdnam;
125
126 unsigned char *allocate_bitmap(char *);
127 void usage(char *);
128 void enable(char *, char *, char *, char *);
129 int disable(char *);
130 void bitmap_op(char *, int, int, int, int);
131 void print_status(dsw_config_t *, int);
132 int abort_copy(char *);
133 int reset(char *);
134 int overflow(char *);
135 void iiversion(void);
136 int wait_for_copy(char *);
137 int export(char *);
138 void list_volumes(void);
139 void dsw_error(char *, spcs_s_info_t *);
140 void InitEnv();
141 static void check_dg_is_local(char *dgname);
142 static int check_resource_group(char *volume);
143 static int check_diskgroup(char *path, char *result);
144 static int check_cluster();
145 static void unload_ii_vols();
146 static void load_ii_vols(CFGFILE *);
147 static int perform_autosv();
148 static int is_exported(char *);
149 static void conform_name(char **);
150 static void do_attach(dsw_config_t *);
151 static int ii_lock(CFGFILE *, int);
152 static void verify_groupname(char *grp, int testDash);
153
154 void dsw_list_clusters(char *);
155 void dsw_enable(int, char **);
156 void dsw_disable(int, char **);
157 void dsw_copy_to_shadow(int, char **);
158 void dsw_update_shadow(int, char **);
159 void dsw_copy_to_master(int, char **);
160 void dsw_update_master(int, char **);
161 void dsw_abort_copy(int, char **);
162 void dsw_display_status(int, char **);
163 void dsw_display_bitmap(int, char **);
164 void dsw_reset(int, char **);
165 void dsw_overflow(int, char **);
166 void dsw_version(int, char **);
167 void dsw_wait(int, char **);
168 void dsw_list_volumes(int, char **);
169 void dsw_list_group_volumes();
170 void dsw_export(int, char **);
171 void dsw_import(int, char **);
172 void dsw_join(int, char **);
173 void dsw_attach(int, char **);
174 void dsw_detach(int, char **);
175 void dsw_params(int, char **);
176 void dsw_olist(int, char **);
177 void dsw_ostat(int, char **);
178 void dsw_move_2_group(int, char **);
179 void dsw_list_groups();
180 void check_iishadow(char *);
181
182 extern char *optarg;
183 extern int optind, opterr, optopt;
184
185 int Aflg;
186 int Cflg;
187 int CLflg;
188 int Dflg;
189 int Eflg;
190 int Iflg;
191 int Jflg;
192 int Lflg;
193 int Oflg;
194 int Pflg;
195 int Qflg;
196 int Rflg;
197 int aflg;
198 int bflg;
199 int cflg;
200 int dflg;
201 int eflg;
202 int fflg;
203 int gflg;
204 int gLflg;
205 int hflg;
206 int iflg;
207 int lflg;
208 int mflg;
209 int nflg;
210 int pflg;
211 int uflg;
212 int vflg;
213 int wflg;
214
215 int errflg;
216 #ifdef DEBUG
217 const char single_opts[] =
218 "a:b:c:d:e:f:g:hilmnpu:vw:A:C:D:E:I:J:LO:PQ:R:";
219 #else
220 /* no b or f flags */
221 const char single_opts[] = "a:c:d:e:g:hilmnpu:vw:A:C:D:E:I:J:LO:PQ:R:";
222 #endif
223 const char group_opts[] = "ac:de:ilmnpu:wA:C:DELPR";
224 const char *opt_list = single_opts;
225
226 char buf[CFG_MAX_BUF];
227 char key[CFG_MAX_KEY];
228 char last_overflow[DSW_NAMELEN];
229 int setnumber;
230 char *group_name;
231 char **group_volumes;
232 enum copy_direction direction;
233 char *param_delay, *param_unit;
234 char *overflow_file;
235
236 #ifdef lint
237 int
238 iiadm_lintmain(int argc, char *argv[])
239 #else
240 int
241 main(int argc, char *argv[])
242 #endif
243 {
244 int c;
245 int actions = 0;
246 int ac;
247 char *av[1024];
248
249 InitEnv();
250
251 (void) memset(av, 0, sizeof (av));
252 cmdnam = argv[0];
253 while ((c = getopt(argc, argv, opt_list)) != EOF)
254 switch (c) {
255 case 'c':
256 cflg++;
257 actions++;
258 if (strcmp(optarg, "m") == 0) {
259 av[0] = "copy_to_master";
260 direction = ToMaster;
261 } else if (strcmp(optarg, "s") == 0) {
262 av[0] = "copy_to_shadow";
263 direction = ToShadow;
264 } else {
265 errflg ++;
266 usage(gettext(
267 "must specify m or s with -c"));
268 }
269 ac = 2;
270 break;
271 case 'd':
272 dflg++;
273 actions++;
274 av[0] = "disable";
275 av[1] = optarg;
276 ac = 2;
277 break;
278 case 'e':
279 eflg++;
280 actions++;
281 av[0] = "enable";
282 if (strcmp(optarg, "ind") == 0)
283 av[4] = "independent";
284 else if (strcmp(optarg, "dep") == 0)
285 av[4] = "dependent";
286 else {
287 errflg ++;
288 usage(gettext(
289 "must specify ind or dep with -e"));
290 }
291 ac = 1;
292 break;
293 case 'g':
294 gflg++;
295 opt_list = group_opts;
296 group_name = optarg;
297 if (group_name && *group_name == '-') {
298 gLflg = (strcmp("-L", group_name) == 0);
299 if (gLflg)
300 actions++;
301 }
302 verify_groupname(group_name, !gLflg);
303 break;
304 case 'h':
305 hflg++;
306 actions++;
307 break;
308 case 'u':
309 uflg++;
310 actions++;
311 if (strcmp(optarg, "m") == 0) {
312 av[0] = "update_master";
313 direction = ToMaster;
314 } else if (strcmp(optarg, "s") == 0) {
315 av[0] = "update_shadow";
316 direction = ToShadow;
317 } else {
318 errflg ++;
319 usage(gettext(
320 "must specify m or s with -u"));
321 }
322 ac = 2;
323 break;
324 case 'i':
325 iflg++;
326 actions++;
327 av[0] = "display_status";
328 break;
329 case 'l':
330 lflg++;
331 actions++;
332 av[0] = "list_config";
333 ac = 1;
334 break;
335 case 'm':
336 mflg++;
337 actions++;
338 av[0] = "move_to_group";
339 ac = 1;
340 break;
341 case 'n':
342 nflg++;
343 break;
344 case 'p':
345 pflg++;
346 break;
347 case 'b':
348 bflg++;
349 actions++;
350 av[0] = "display_bitmap";
351 av[1] = optarg;
352 ac = 2;
353 break;
354 case 'a':
355 aflg++;
356 actions++;
357 av[0] = "abort_copy";
358 av[1] = optarg;
359 ac = 2;
360 break;
361 case 'v':
362 vflg++;
363 actions++;
364 av[1] = "version";
365 ac = 1;
366 break;
367 case 'w':
368 wflg++;
369 actions++;
370 av[0] = "wait";
371 av[1] = optarg;
372 ac = 2;
373 break;
374 case 'A':
375 Aflg++;
376 actions++;
377 av[0] = "attach";
378 av[1] = optarg;
379 ac = 2;
380 break;
381 case 'C':
382 Cflg++;
383 cfg_cluster_tag = optarg;
384 if (cfg_cluster_tag && *cfg_cluster_tag == '-') {
385 CLflg = (strcmp("-L", cfg_cluster_tag) == 0);
386 if (CLflg)
387 actions++;
388 }
389 break;
390 case 'D':
391 Dflg++;
392 actions++;
393 av[0] = "detach";
394 av[1] = optarg;
395 ac = 2;
396 break;
397 case 'O':
398 Oflg++;
399 actions++;
400 av[0] = "overflow";
401 av[1] = optarg;
402 ac = 2;
403 break;
404 case 'R':
405 Rflg++;
406 actions++;
407 av[0] = "reset";
408 av[1] = optarg;
409 ac = 2;
410 break;
411 case 'E':
412 Eflg++;
413 actions++;
414 av[0] = "export";
415 av[1] = optarg;
416 ac = 2;
417 break;
418 case 'I':
419 Iflg++;
420 actions++;
421 av[0] = "import";
422 av[1] = optarg;
423 ac = 2;
424 break;
425 case 'J':
426 Jflg++;
427 actions++;
428 av[0] = "join";
429 av[1] = optarg;
430 ac = 2;
431 break;
432 case 'P':
433 Pflg++;
434 actions++;
435 av[0] = "parameter";
436 ac = 1;
437 break;
438 case 'L':
439 Lflg++;
440 actions++;
441 /* If -g group -L, force error */
442 if (group_name) actions++;
443 av[0] = "LIST";
444 ac = 1;
445 break;
446 case 'Q':
447 Qflg++;
448 actions++;
449 av[0] = "query";
450 av[1] = optarg;
451 ac = 2;
452 break;
453 case '?':
454 errflg++;
455 break;
456 }
457 if (hflg) {
458 usage(NULL);
459 exit(0);
460 }
461
462 if (errflg)
463 usage(gettext("unrecognized argument"));
464 switch (actions) {
465 case 0:
466 if (argc > 1)
467 usage(gettext("must specify an action flag"));
468
469 /* default behavior is to list configuration */
470 lflg++; av[0] = "list_config"; ac = 1;
471 break;
472 case 1:
473 break;
474 default:
475 usage(gettext("too many action flags"));
476 break;
477 }
478
479 if (gflg && (Iflg || Jflg || Oflg || Qflg))
480 usage(gettext("can't use a group with this option"));
481 if (!gflg && (mflg))
482 usage(gettext("must use a group with this option"));
483
484 /*
485 * Open configuration file.
486 */
487 if ((cfg = cfg_open(NULL)) == NULL) {
488 perror("unable to access configuration");
489 exit(2);
490 }
491
492 /*
493 * Set write locking (CFG_WRLOCK) for:
494 * iiadm -e (enable)
495 * iiadm -d (disable)
496 * iiadm -A (attach overflow)
497 * iiadm -D (detach overflow)
498 * iiadm -g grp -m volume (move volume into group)
499 * iiadm -E (export shadow [needs to update dsvol section])
500 * iiadm -I (import shadow [ditto])
501 * iiadm -J (join shadow [ditto])
502 * read locking (CFG_RDLOCK) for all other commands
503 */
504 last_lock = (eflg || dflg || mflg || Aflg || Dflg || Eflg || Iflg ||
505 Jflg)? CFG_WRLOCK : CFG_RDLOCK;
506 if (!cfg_lock(cfg, last_lock)) {
507 perror("unable to lock configuration");
508 exit(2);
509 }
510 config_locked = 1;
511
512 /*
513 * If we are in a cluster, set or derive a valid disk group
514 */
515 switch (check_cluster()) {
516 case II_CLUSTER:
517 /*
518 * If in a Sun Cluster, can't Import an II shadow
519 * Must be done as -C local
520 */
521 if (Iflg)
522 dsw_error(gettext(
523 "-I (import) only allowed as -C local"), NULL);
524 /*FALLTHRU*/
525 case II_CLUSTER_LCL:
526 /*
527 * If a cluster tag was specified or derived, set it
528 */
529 if (CLflg) {
530 dsw_list_clusters(argv[optind]);
531 cfg_close(cfg);
532 exit(0);
533 } else {
534 cfg_resource(cfg, cfg_cluster_tag);
535 }
536 break;
537 case II_NOT_CLUSTER:
538 if (cfg_cluster_tag != NULL)
539 dsw_error(gettext(
540 "-C is valid only in a Sun Cluster"), NULL);
541 break;
542 default:
543 dsw_error(gettext(
544 "Unexpected return from check_cluster()"), NULL);
545 }
546
547 /* preload the ii config */
548 load_ii_vols(cfg);
549 reload_vols |= LD_II;
550
551 if (eflg) {
552 if (argc - optind != 3)
553 usage(gettext("must specify 3 volumes with -e"));
554 av[1] = argv[optind++];
555 av[2] = argv[optind++];
556 av[3] = argv[optind++];
557 ac = 5;
558 dsw_enable(ac, av);
559 } else if (dflg) {
560 dsw_disable(ac, av);
561 } else if (uflg) {
562 if (argv[optind] == NULL && group_name == NULL)
563 usage(gettext("must specify volume with -u"));
564 for (c = 1; argv[optind] != NULL; optind++)
565 av[c++] = argv[optind];
566 av[c] = NULL;
567
568 if (direction == ToMaster)
569 dsw_update_master(ac, av);
570 else
571 dsw_update_shadow(ac, av);
572 } else if (iflg) {
573 if (argv[optind]) {
574 av[1] = argv[optind];
575 ac = 2;
576 } else
577 ac = 1;
578 dsw_display_status(ac, av);
579 } else if (bflg) {
580 dsw_display_bitmap(ac, av);
581 } else if (cflg) {
582 if (argv[optind] == NULL && group_name == NULL)
583 usage(gettext("must specify volume with -c"));
584 for (c = 1; argv[optind] != NULL; optind++)
585 av[c++] = argv[optind];
586 av[c] = NULL;
587
588 if (direction == ToMaster)
589 dsw_copy_to_master(ac, av);
590 else
591 dsw_copy_to_shadow(ac, av);
592 } else if (aflg) {
593 dsw_abort_copy(ac, av);
594 } else if (Eflg) {
595 dsw_export(ac, av);
596 } else if (Iflg) {
597 if (argc - optind != 1)
598 usage(gettext("must specify 2 volumes with -I"));
599 av[2] = argv[optind++];
600 ac = 3;
601 dsw_import(ac, av);
602 } else if (Aflg) {
603 if (group_name) {
604 if (argc - optind != 0)
605 usage(gettext("must specify overflow volume " \
606 "when using groups with -A"));
607 ac = 2;
608 } else {
609 if (argc - optind != 1)
610 usage(gettext("specify 2 volumes with -A"));
611 ac = 3;
612 av[2] = argv[optind++];
613 }
614 dsw_attach(ac, av);
615 } else if (Dflg) {
616 dsw_detach(ac, av);
617 } else if (Jflg) {
618 if (argc - optind != 1)
619 usage(gettext("must specify 2 volumes with -J"));
620 av[2] = argv[optind++];
621 ac = 3;
622 dsw_join(ac, av);
623 } else if (Pflg) {
624 if (argc - optind == ((group_name) ? 0 : 1)) {
625 av[1] = argv[optind++];
626 ac = (group_name) ? 0 : 2;
627 } else if (argc - optind == ((group_name) ? 2 : 3)) {
628 av[1] = argv[optind++];
629 av[2] = argv[optind++];
630 av[3] = argv[optind++];
631 ac = (group_name) ? 2 : 4;
632 } else
633 usage(gettext(
634 "must specify delay, unit and shadow with -P"));
635 dsw_params(ac, av);
636 } else if (Oflg) {
637 dsw_overflow(ac, av);
638 } else if (Rflg) {
639 dsw_reset(ac, av);
640 } else if (vflg) {
641 dsw_version(ac, av);
642 } else if (wflg) {
643 dsw_wait(ac, av);
644 } else if (lflg) {
645 if ((gflg) && (!group_name))
646 dsw_list_group_volumes();
647 else
648 dsw_list_volumes(ac, av);
649 } else if (Lflg) {
650 dsw_olist(ac, av);
651 } else if (gLflg) {
652 dsw_list_groups();
653 } else if (Qflg) {
654 dsw_ostat(ac, av);
655 } else if (mflg) {
656 if (argc - optind < 1)
657 usage(gettext("must specify one or more volumes"));
658 for (c = 1; argv[optind] != NULL; optind++)
659 av[c++] = argv[optind];
660 av[c] = NULL;
661 dsw_move_2_group(ac, av);
662 }
663 if (cfg)
664 cfg_close(cfg);
665
666 exit(0);
667 return (0);
668 }
669
670 static int
671 ii_lock(CFGFILE *cfg, int locktype)
672 {
673 last_lock = locktype;
674 return (cfg_lock(cfg, locktype));
675 }
676
677 static int
678 do_ioctl(int fd, int cmd, void *arg)
679 {
680 int unlocked = 0;
681 int rc;
682 int save_errno;
683
684 if (config_locked) {
685 switch (cmd) {
686 case DSWIOC_ENABLE:
687 case DSWIOC_RESUME:
688 case DSWIOC_SUSPEND:
689 case DSWIOC_COPY:
690 case DSWIOC_BITMAP:
691 case DSWIOC_DISABLE:
692 case DSWIOC_SHUTDOWN:
693 case DSWIOC_ABORT:
694 case DSWIOC_RESET:
695 case DSWIOC_OFFLINE:
696 case DSWIOC_WAIT:
697 case DSWIOC_ACOPY:
698 case DSWIOC_EXPORT:
699 case DSWIOC_IMPORT:
700 case DSWIOC_JOIN:
701 case DSWIOC_COPYP:
702 case DSWIOC_OATTACH:
703 case DSWIOC_ODETACH:
704 case DSWIOC_SBITSSET:
705 case DSWIOC_CBITSSET:
706 case DSWIOC_SEGMENT:
707 case DSWIOC_MOVEGRP:
708 case DSWIOC_CHANGETAG:
709 cfg_unlock(cfg);
710 unlocked = 1;
711 break;
712
713 case DSWIOC_STAT:
714 case DSWIOC_VERSION:
715 case DSWIOC_LIST:
716 case DSWIOC_OCREAT:
717 case DSWIOC_OLIST:
718 case DSWIOC_OSTAT:
719 case DSWIOC_OSTAT2:
720 case DSWIOC_LISTLEN:
721 case DSWIOC_OLISTLEN:
722 case DSWIOC_CLIST:
723 case DSWIOC_GLIST:
724 break;
725
726 default:
727 (void) fprintf(stderr,
728 "cfg locking needs to be set for %08x\n", cmd);
729 exit(1);
730 break;
731 }
732 }
733 if (unlocked) {
734 /* unload vol hashes */
735 if (reload_vols & LD_II)
736 unload_ii_vols();
737 if (reload_vols & LD_SHADOWS)
738 cfg_unload_shadows();
739 if (reload_vols & LD_DSVOLS)
740 cfg_unload_dsvols();
741 if (reload_vols & LD_SVOLS)
742 cfg_unload_svols();
743 }
744 rc = ioctl(fd, cmd, arg);
745 save_errno = errno;
746 if (config_locked && unlocked) {
747 (void) cfg_lock(cfg, last_lock);
748 }
749 if (unlocked) {
750 /* reload vol hashes */
751 if (reload_vols & LD_SVOLS)
752 (void) cfg_load_svols(cfg);
753 if (reload_vols & LD_DSVOLS)
754 (void) cfg_load_dsvols(cfg);
755 if (reload_vols & LD_SHADOWS)
756 (void) cfg_load_shadows(cfg);
757 if (reload_vols & LD_II)
758 load_ii_vols(cfg);
759 }
760
761 errno = save_errno;
762 return (rc);
763 }
764
765 static int
766 get_dsw_config(int setno, dsw_config_t *parms)
767 {
768 char buf[CFG_MAX_BUF];
769 char key[CFG_MAX_KEY];
770
771 bzero(parms, sizeof (dsw_config_t));
772 (void) snprintf(key, sizeof (key), "ii.set%d.master", setno);
773 if (cfg_get_cstring(cfg, key, parms->master_vol, DSW_NAMELEN) < 0)
774 return (-1);
775
776 (void) snprintf(key, sizeof (key), "ii.set%d.shadow", setno);
777 (void) cfg_get_cstring(cfg, key, parms->shadow_vol, DSW_NAMELEN);
778
779 (void) snprintf(key, sizeof (key), "ii.set%d.bitmap", setno);
780 (void) cfg_get_cstring(cfg, key, parms->bitmap_vol, DSW_NAMELEN);
781
782 (void) snprintf(key, sizeof (key), "ii.set%d.mode", setno);
783 (void) cfg_get_cstring(cfg, key, buf, sizeof (buf));
784 if (strcmp(buf, "I") == 0)
785 parms->flag |= DSW_GOLDEN;
786
787 (void) snprintf(key, sizeof (key), "ii.set%d.overflow", setno);
788 (void) cfg_get_cstring(cfg, key, last_overflow, DSW_NAMELEN);
789
790 (void) snprintf(key, sizeof (key), "ii.set%d.group", setno);
791 (void) cfg_get_cstring(cfg, key, parms->group_name, DSW_NAMELEN);
792
793 (void) snprintf(key, sizeof (key), "ii.set%d.cnode", setno);
794 (void) cfg_get_cstring(cfg, key, parms->cluster_tag, DSW_NAMELEN);
795 return (0);
796 }
797
798 static int
799 find_next_cf_line(char *volume, int next)
800 {
801 dsw_config_t cf_line;
802
803 for (setnumber = next; get_dsw_config(setnumber, &cf_line) == 0;
804 setnumber++) {
805 if (strncmp(volume, cf_line.master_vol, DSW_NAMELEN) == 0 ||
806 strncmp(volume, cf_line.shadow_vol, DSW_NAMELEN) == 0 ||
807 strncmp(volume, cf_line.bitmap_vol, DSW_NAMELEN) == 0)
808 return (1);
809 }
810 return (0);
811 }
812 int
813 find_any_cf_line(char *volume)
814 {
815 return (find_next_cf_line(volume, 1));
816 }
817
818 static int
819 find_next_shadow_line(char *volume, int next)
820 {
821 dsw_config_t cf_line;
822
823 for (setnumber = next; get_dsw_config(setnumber, &cf_line) == 0;
824 setnumber++) {
825 if (strncmp(volume, cf_line.shadow_vol, DSW_NAMELEN) == 0)
826 return (1);
827 }
828 return (0);
829 }
830 int
831 find_shadow_line(char *volume)
832 {
833 return (find_next_shadow_line(volume, 1));
834 }
835
836 /*
837 * this function is designed to be called once, subsequent calls won't
838 * free memory allocated by earlier invocations.
839 */
840 char *
841 get_overflow_list()
842 {
843 dsw_aioctl_t *acopy_args;
844 int rc, num;
845
846 num = do_ioctl(dsw_fd, DSWIOC_OLISTLEN, NULL);
847 if (num < 0)
848 dsw_error(gettext("Can't get overflow list length"), NULL);
849
850 acopy_args = malloc(sizeof (dsw_aioctl_t) + num * DSW_NAMELEN);
851 if (acopy_args == NULL)
852 dsw_error(gettext("Can't get memory for list enquiry"), NULL);
853
854 acopy_args->count = num;
855 acopy_args->flags = 0;
856 acopy_args->status = spcs_s_ucreate();
857
858 rc = do_ioctl(dsw_fd, DSWIOC_OLIST, acopy_args);
859 if (rc == -1)
860 dsw_error(gettext("Overflow list access failure"),
861 &acopy_args->status);
862 else
863 acopy_args->shadow_vol[DSW_NAMELEN*acopy_args->count] = NULL;
864
865 return (acopy_args->shadow_vol);
866 }
867
868 /*
869 * this function is designed to be called once, subsequent calls won't
870 * free memory allocated by earlier invocations.
871 */
872
873 int
874 find_group_members(char *group)
875 {
876 int nmembers = 0;
877 int vector_len = 0;
878
879 group_volumes = NULL;
880 for (setnumber = 1; /*CSTYLED*/; setnumber++) {
881 (void) snprintf(key, sizeof (key), "ii.set%d.group", setnumber);
882 if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0)
883 break;
884
885 if (strcmp(group, buf))
886 continue;
887
888 (void) snprintf(key, sizeof (key), "ii.set%d.shadow",
889 setnumber);
890 if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0)
891 break;
892
893 if (nmembers >= vector_len) {
894 vector_len += 10;
895 group_volumes = realloc(group_volumes, (1+vector_len) *
896 sizeof (char *));
897 }
898 group_volumes[nmembers] = strdup(buf);
899 nmembers++;
900 }
901 if (group_volumes)
902 group_volumes[nmembers] = NULL; /* terminate list */
903 return (nmembers);
904 }
905
906 static int
907 find_next_matching_cf_line(
908 char *volume, dsw_config_t *conf, dsw_ioctl_t *io, int next)
909 {
910 dsw_config_t config;
911
912 if (!find_next_cf_line(volume, next)) {
913 return (0);
914 }
915
916 if (conf == NULL)
917 conf = &config;
918 (void) get_dsw_config(setnumber, conf);
919 if (io) {
920 (void) strlcpy(io->shadow_vol, conf->shadow_vol, DSW_NAMELEN);
921 }
922 return (1);
923 }
924
925 int
926 find_matching_cf_line(char *volume, dsw_config_t *conf, dsw_ioctl_t *io)
927 {
928 return (find_next_matching_cf_line(volume, conf, io, 1));
929 }
930
931 int
932 find_shadow_config(char *volume, dsw_config_t *conf, dsw_ioctl_t *io)
933 {
934 dsw_config_t *c, cf;
935
936 if (io) {
937 bzero(io, sizeof (dsw_ioctl_t));
938 }
939 c = conf ? conf : &cf;
940 setnumber = 1;
941 /* perform action for each line of the stored config file */
942 for ((void) snprintf(key, sizeof (key), "ii.set%d.shadow", setnumber);
943 cfg_get_cstring(cfg, key, c->shadow_vol, DSW_NAMELEN) >= 0;
944 (void) snprintf(key, sizeof (key), "ii.set%d.shadow",
945 ++setnumber)) {
946 if (strncmp(volume, c->shadow_vol, DSW_NAMELEN) == 0) {
947 (void) get_dsw_config(setnumber, c);
948
949 if (check_resource_group(c->bitmap_vol)) {
950 setnumber = 0;
951 continue;
952 }
953
954 switch (check_cluster()) {
955 case II_CLUSTER:
956 if ((cfg_cluster_tag) &&
957 (strcmp(cfg_cluster_tag, c->cluster_tag)))
958 continue;
959 break;
960 case II_CLUSTER_LCL:
961 if (strlen(c->cluster_tag))
962 continue;
963 break;
964 }
965
966 if (io) {
967 (void) strlcpy(io->shadow_vol, c->shadow_vol,
968 DSW_NAMELEN);
969 }
970 return (1);
971 }
972 }
973 return (0);
974 }
975
976 void
977 add_cfg_entry(dsw_config_t *parms)
978 {
979 /* insert the well-known fields first */
980 (void) snprintf(buf, sizeof (buf), "%s %s %s %s",
981 parms->master_vol, parms->shadow_vol, parms->bitmap_vol,
982 (parms->flag & DSW_GOLDEN) ? "I" : "D");
983
984 if (cfg_put_cstring(cfg, "ii", buf, strlen(buf)) >= 0) {
985 /* if we have a group name, add it */
986 if (group_name) {
987 if (find_any_cf_line(parms->shadow_vol)) {
988 (void) sprintf(buf, "ii.set%d.group",
989 setnumber);
990 if (cfg_put_cstring(cfg, buf,
991 group_name, strlen(group_name)) < 0)
992 perror("cfg_put_cstring");
993 }
994 else
995 perror("cfg_location");
996 }
997
998 /* commit the record */
999 (void) cfg_commit(cfg);
1000 }
1001 else
1002 perror("cfg_put_string");
1003 }
1004
1005 void
1006 remove_iiset(int setno, char *shadow, int shd_exp)
1007 {
1008 mstcount_t *mdata;
1009 shdvol_t *sdata;
1010 char sn[CFG_MAX_BUF];
1011
1012 if (perform_autosv()) {
1013 if (volhash) {
1014 unload_ii_vols();
1015 }
1016 load_ii_vols(cfg);
1017 if (cfg_load_dsvols(cfg) < 0 || cfg_load_svols(cfg) < 0) {
1018 dsw_error(gettext("Unable to parse config file"), NULL);
1019 }
1020
1021 sdata = (shdvol_t *)nsc_lookup(volhash, shadow);
1022 if (sdata) {
1023 /*
1024 * Handle the normal cases of disabling a set that is
1025 * not an imported shadow volume
1026 */
1027 if (strcmp(sdata->master, II_IMPORTED_SHADOW)) {
1028 /*
1029 * Handle multiple-shadows of single master
1030 */
1031 mdata = (mstcount_t *)
1032 nsc_lookup(volhash, sdata->master);
1033 if ((mdata) && (mdata->count == 1)) {
1034 if (cfg_vol_disable(cfg, sdata->master,
1035 cfg_cluster_tag, "ii") < 0)
1036 dsw_error(gettext(
1037 "SV disable of master "
1038 "failed"),
1039 NULL);
1040 }
1041 }
1042
1043 /*
1044 * Handle disk group name of different shadow
1045 */
1046 if (shd_exp) {
1047 /*
1048 * If shadow is exported, then do nothing
1049 */
1050 /*EMPTY*/;
1051 } else if (cfg_cluster_tag &&
1052 strcmp(cfg_cluster_tag, "") &&
1053 cfg_dgname(shadow, sn, sizeof (sn)) &&
1054 strlen(sn) &&
1055 strcmp(sn, cfg_cluster_tag)) {
1056 /* reload disk group volumes */
1057 cfg_resource(cfg, sn);
1058 cfg_unload_dsvols();
1059 cfg_unload_svols();
1060 (void) cfg_load_dsvols(cfg);
1061 (void) cfg_load_svols(cfg);
1062 if (cfg_vol_disable(cfg, shadow, sn,
1063 "ii") < 0) {
1064 dsw_error(gettext(
1065 "SV disable of shadow "
1066 "failed"),
1067 NULL);
1068 }
1069 cfg_resource(cfg, cfg_cluster_tag);
1070 } else {
1071 if (cfg_vol_disable(cfg, shadow,
1072 cfg_cluster_tag, "ii") < 0)
1073 dsw_error(gettext(
1074 "SV disable of shadow failed"),
1075 NULL);
1076 }
1077 }
1078 cfg_unload_svols();
1079 cfg_unload_dsvols();
1080 unload_ii_vols();
1081 reload_vols &= ~(LD_SVOLS | LD_DSVOLS | LD_II);
1082 }
1083
1084 (void) sprintf(key, "ii.set%d", setno);
1085 if (cfg_put_cstring(cfg, key, NULL, 0) < 0) {
1086 perror("cfg_put_cstring");
1087 }
1088 (void) cfg_commit(cfg);
1089 }
1090
1091 /*
1092 * determine if we are running in a Sun Cluster Environment
1093 */
1094 int
1095 check_cluster()
1096 {
1097 static int is_cluster = -1;
1098 int rc;
1099 #ifdef DEBUG
1100 char *cdebug = getenv("II_SET_CLUSTER");
1101 #endif
1102
1103 /*
1104 * If this routine was previously called, just return results
1105 */
1106 if (is_cluster != -1)
1107 return (is_cluster);
1108
1109 /*
1110 * See if Sun Cluster was installed on this node
1111 */
1112 #ifdef DEBUG
1113 if (cdebug) rc = atoi(cdebug);
1114 else
1115 #endif
1116 rc = cfg_iscluster();
1117 if (rc > 0) {
1118 /*
1119 * Determine if user specified -C local
1120 */
1121 if ((cfg_cluster_tag == NULL) ||
1122 (strcmp(cfg_cluster_tag, II_LOCAL_TAG))) {
1123 /*
1124 * We're in a Sun Cluster, and no "-C local"
1125 */
1126 is_cluster = II_CLUSTER;
1127 } else {
1128 /*
1129 * We're in a Sun Cluster, but "-C local" was specified
1130 */
1131 is_cluster = II_CLUSTER_LCL;
1132 cfg_cluster_tag = "";
1133 }
1134 return (is_cluster);
1135 } else if (rc == 0) {
1136 /*
1137 * Not in a Sun Cluster
1138 */
1139 is_cluster = II_NOT_CLUSTER;
1140 return (is_cluster);
1141 } else {
1142 dsw_error(gettext("unable to ascertain environment"), NULL);
1143 /*NOTREACHED*/
1144 }
1145
1146 /* gcc */
1147 return (is_cluster);
1148 }
1149
1150 /*
1151 * Determine if we need to set a cfg_resource based on this volume
1152 */
1153 static int
1154 check_resource_group(char *volume)
1155 {
1156 char diskgroup[CFG_MAX_BUF];
1157
1158 /*
1159 * If we are in a cluster, attempt to derive a new resource group
1160 */
1161
1162 #ifdef DEBUG
1163 if (getenv("II_SET_CLUSTER") || (check_cluster() == II_CLUSTER)) {
1164 #else
1165 if (check_cluster() == II_CLUSTER) {
1166 #endif
1167 if (check_diskgroup(volume, diskgroup)) {
1168 if (cfg_cluster_tag == NULL) {
1169 cfg_cluster_tag = strdup(diskgroup);
1170 if (cfg_cluster_tag == NULL)
1171 dsw_error(gettext(
1172 "Memory allocation failure"), NULL);
1173 cfg_resource(cfg, cfg_cluster_tag);
1174 return (1);
1175 } else {
1176 /*
1177 * Check dgname and cluster tag from -C are
1178 * the same.
1179 */
1180 if (strcmp(diskgroup, cfg_cluster_tag) != 0) {
1181 char error_buffer[128];
1182 (void) snprintf(error_buffer,
1183 sizeof (error_buffer),
1184 gettext("-C (%s) does not match "
1185 "disk group name (%s) for %s"),
1186 cfg_cluster_tag, diskgroup, volume);
1187 spcs_log("ii", NULL, error_buffer);
1188 dsw_error(error_buffer, NULL);
1189 }
1190 }
1191 } else if (cfg_cluster_tag == NULL)
1192 dsw_error(gettext(
1193 "Point-in-Time Copy volumes, that are not "
1194 "in a device group which has been "
1195 "registered with SunCluster, "
1196 "require usage of \"-C\""), NULL);
1197 }
1198 return (0);
1199 }
1200
1201 static void
1202 check_dg_is_local(char *dgname)
1203 {
1204 char error_buffer[128];
1205 char *othernode;
1206 int rc;
1207
1208 /*
1209 * check where this disk service is mastered
1210 */
1211 rc = cfg_dgname_islocal(dgname, &othernode);
1212 if (rc < 0) {
1213 (void) snprintf(error_buffer, sizeof (error_buffer),
1214 gettext("Unable to find disk service:%s"), dgname);
1215 dsw_error(error_buffer, NULL);
1216 } else if (rc == 0) {
1217 (void) snprintf(error_buffer, sizeof (error_buffer),
1218 gettext("disk service, %s, is active on node \"%s\"\n"
1219 "Please re-issue the command on that node"), dgname,
1220 othernode);
1221 dsw_error(error_buffer, NULL);
1222 }
1223 }
1224
1225 /*
1226 * Carry out cluster based checks for a specified volume, or just
1227 * global options.
1228 */
1229 static int
1230 check_diskgroup(char *path, char *result)
1231 {
1232 char dgname[CFG_MAX_BUF];
1233 char error_buffer[128];
1234
1235 #ifdef DEBUG
1236 char *override = getenv("II_CLUSTER_TAG");
1237 if (override) {
1238 (void) strcpy(result, override);
1239 return (1);
1240 }
1241 #endif
1242 /*
1243 * Check on path name, a returned NULL dgname is valid
1244 */
1245 if (cfg_dgname(path, dgname, sizeof (dgname)) == NULL) {
1246 (void) snprintf(error_buffer, sizeof (error_buffer), gettext(
1247 "unable to determine disk group name for %s"), path);
1248 dsw_error(error_buffer, NULL);
1249 }
1250 if (strcmp(dgname, "") == 0)
1251 return (0);
1252
1253 /*
1254 * See if disk group is local to this node
1255 */
1256 check_dg_is_local(dgname);
1257
1258 /*
1259 * Copy dgname into result
1260 */
1261 (void) strcpy(result, dgname);
1262 return (1);
1263 }
1264
1265 /*
1266 * sigterm (): traps specified signal , usually termination one
1267 */
1268 void
1269 sigterm(int sig)
1270 {
1271 spcs_log("ii", NULL, gettext("%s received signal %d"), cmdnam, sig);
1272 exit(1);
1273 }
1274
1275 /*
1276 * sigchild; reap child and collect status.
1277 */
1278
1279 volatile pid_t dead_child;
1280 int dead_stat;
1281
1282 /*ARGSUSED*/
1283 void
1284 sigchild(int sig)
1285 {
1286 dead_child = wait(&dead_stat);
1287 }
1288
1289 /*
1290 * InitEnv(): initializes environment
1291 */
1292 void
1293 InitEnv()
1294 {
1295 (void) setlocale(LC_ALL, "");
1296 (void) textdomain(DSW_TEXT_DOMAIN);
1297
1298 #ifndef DEBUG
1299 (void) sigset(SIGHUP, sigterm);
1300 (void) sigset(SIGINT, sigterm);
1301 (void) sigset(SIGQUIT, sigterm);
1302 (void) sigset(SIGILL, sigterm);
1303 (void) sigset(SIGEMT, sigterm);
1304 (void) sigset(SIGABRT, sigterm);
1305 (void) sigset(SIGFPE, sigterm);
1306 (void) sigset(SIGBUS, sigterm);
1307 (void) sigset(SIGSEGV, sigterm);
1308 (void) sigset(SIGTERM, sigterm);
1309 (void) sigset(SIGPWR, sigterm);
1310 (void) sigset(SIGSTOP, sigterm);
1311 (void) sigset(SIGTSTP, sigterm);
1312 #endif
1313
1314 dsw_fd = open(DSWDEV, O_RDONLY);
1315 if (dsw_fd < 0) {
1316 perror(DSWDEV);
1317 exit(1);
1318 }
1319
1320 (void) setsid();
1321 }
1322
1323 /*
1324 * print an error message, followed by decoded errno then exit.
1325 */
1326 void
1327 dsw_error(char *str, spcs_s_info_t *status)
1328 {
1329 char *sp;
1330
1331 (void) fprintf(stderr, "%s: %s:\n", cmdnam, str);
1332 if (status == NULL) {
1333 /* deflect ESRCH */
1334 if (ESRCH == errno) {
1335 sp = "Set/volume not found";
1336 } else {
1337 sp = strerror(errno);
1338 }
1339 (void) fprintf(stderr, "%s\n", sp ? sp : "");
1340 } else {
1341 spcs_s_report(*status, stderr);
1342 spcs_s_ufree(status);
1343 }
1344 if (cfg)
1345 cfg_close(cfg);
1346 exit(2);
1347 }
1348
1349
1350 #undef size
1351
1352 void
1353 free_bitmap(unsigned char *bitmap)
1354 {
1355 free(bitmap);
1356 }
1357
1358
1359 int
1360 get_bitmap(master_volume, shd_bitmap, copy_bitmap, size)
1361 char *master_volume;
1362 unsigned char *shd_bitmap;
1363 unsigned char *copy_bitmap;
1364 unsigned long size;
1365 {
1366 dsw_bitmap_t parms;
1367
1368 (void) strlcpy(parms.shadow_vol, master_volume, DSW_NAMELEN);
1369 parms.shd_bitmap = shd_bitmap;
1370 parms.shd_size = size;
1371 parms.copy_bitmap = copy_bitmap;
1372 parms.copy_size = size;
1373
1374 return (do_ioctl(dsw_fd, DSWIOC_BITMAP, &parms));
1375 }
1376
1377 unsigned char *
1378 allocate_bitmap(char *shadow_volume)
1379 {
1380 unsigned char *shd_bitmap;
1381 unsigned char *copy_bitmap;
1382 unsigned char *p;
1383 unsigned char *q;
1384 int i;
1385 dsw_stat_t args;
1386 int stat_flags;
1387
1388 (void) strlcpy(args.shadow_vol, shadow_volume, DSW_NAMELEN);
1389
1390 args.status = spcs_s_ucreate();
1391 if (do_ioctl(dsw_fd, DSWIOC_STAT, &args) == -1)
1392 dsw_error(gettext("Stat failed"), &args.status);
1393
1394 stat_flags = args.stat;
1395 if (stat_flags & DSW_BMPOFFLINE)
1396 return (NULL);
1397
1398 bm_size = args.size;
1399 bm_size = (bm_size + DSW_SIZE-1) / DSW_SIZE;
1400 bm_actual = bm_size;
1401 bm_size = (bm_size + DSW_BITS-1) / DSW_BITS;
1402 spcs_s_ufree(&args.status);
1403
1404 p = shd_bitmap = (unsigned char *) malloc(bm_size);
1405 if (!shd_bitmap) {
1406 perror(gettext("malloc bitmap"));
1407 return (NULL);
1408 }
1409
1410 q = copy_bitmap = (unsigned char *) malloc(bm_size);
1411 if (!copy_bitmap) {
1412 perror(gettext("malloc bitmap"));
1413 free(shd_bitmap);
1414 return (NULL);
1415 }
1416
1417 (void) memset(shd_bitmap, 0, bm_size);
1418 (void) memset(copy_bitmap, 0, bm_size);
1419
1420 if (get_bitmap(shadow_volume, shd_bitmap, copy_bitmap, bm_size) < 0) {
1421 free(copy_bitmap);
1422 free(shd_bitmap);
1423 return (NULL);
1424 }
1425
1426 /*
1427 * "or" the copy and shadow bitmaps together to return a composite
1428 * bitmap that contains the total set of differences between the
1429 * volumes.
1430 */
1431 for (i = bm_size; i-- > 0; /*CSTYLED*/)
1432 *p++ |= *q++;
1433
1434 free(copy_bitmap);
1435
1436 return (shd_bitmap);
1437 }
1438
1439 /*
1440 * print usage message and exit.
1441 */
1442 void
1443 usage(char *why)
1444 {
1445 if (why) {
1446 (void) fprintf(stderr, "%s: %s\n", cmdnam, why);
1447
1448 (void) fprintf(stderr, "%s\n",
1449 gettext("\nBrief summary:"));
1450 (void) fprintf(stderr, "%s\n",
1451 gettext("\t-e {ind|dep} master_vol shadow_vol "
1452 "bitmap_vol"));
1453 (void) fprintf(stderr, "%s\n",
1454 gettext("\t-[cu {s|m}] volume_set"));
1455 (void) fprintf(stderr, "%s\n",
1456 gettext("\t-i all"));
1457 (void) fprintf(stderr, "%s\n",
1458 gettext("\t-[adDEilPRw] volume_set"));
1459 (void) fprintf(stderr, "%s\n",
1460 gettext("\t-g group_name [options]"));
1461 (void) fprintf(stderr, "%s\n",
1462 gettext("\t-C cluster_tag [options]"));
1463 (void) fprintf(stderr, "%s\n",
1464 gettext("\t-[hilLv]"));
1465 (void) fprintf(stderr, "%s\n",
1466 gettext("\t-[IJ] volume_set bitmap"));
1467 (void) fprintf(stderr, "%s\n",
1468 gettext("\t-A overflow_vol volume_set"));
1469 (void) fprintf(stderr, "%s\n",
1470 gettext("\t-[OQ] overflow_vol"));
1471 (void) fprintf(stderr, "%s\n",
1472 gettext("\t-P {delay} {units} volume_set"));
1473
1474 /* assume we came here due to a user mistake */
1475 exit(1);
1476 /* NOTREACHED */
1477 } else {
1478
1479 (void) fprintf(stdout, "%s\n",
1480 gettext("Point-in-Time Copy Administrator CLI options"));
1481 (void) fprintf(stdout, "%s\n",
1482 gettext("Usage summary:"));
1483 (void) fprintf(stdout, "%s\n",
1484 gettext("\t-e ind m s b\tenable independent master shadow "
1485 "bitmap"));
1486 (void) fprintf(stdout, "%s\n",
1487 gettext("\t-e dep m s b\tenable dependent master shadow "
1488 "bitmap"));
1489 if (check_cluster() == II_CLUSTER)
1490 (void) fprintf(stdout, "%s\n",
1491 gettext("\t-ne ind m s b\tenable exportable master "
1492 "shadow bitmap"));
1493 (void) fprintf(stdout, "%s\n",
1494 gettext("\t-d v\t\tdisable volume"));
1495 (void) fprintf(stdout, "%s\n",
1496 gettext("\t-u s v\t\tupdate shadow volume"));
1497 (void) fprintf(stdout, "%s\n",
1498 gettext("\t-u m v\t\tupdate master volume"));
1499 (void) fprintf(stdout, "%s\n",
1500 gettext("\t-c s v\t\tcopy to shadow volume"));
1501 (void) fprintf(stdout, "%s\n",
1502 gettext("\t-c m v\t\tcopy to master volume"));
1503 (void) fprintf(stdout, "%s\n",
1504 gettext("\t-a v\t\tabort copy volume"));
1505 (void) fprintf(stdout, "%s\n",
1506 gettext("\t-w v\t\twait volume"));
1507 (void) fprintf(stdout, "%s\n",
1508 gettext("\t-i v\t\tdisplay volume status"));
1509 (void) fprintf(stdout, "%s\n",
1510 gettext("\t-i all\t\tdisplay all volume status"));
1511 (void) fprintf(stdout, "%s\n",
1512 gettext("\t-l\t\tlist all volumes"));
1513 (void) fprintf(stdout, "%s\n",
1514 gettext("\t-R v\t\treset volume"));
1515 (void) fprintf(stdout, "%s\n",
1516 gettext("\t-A o v\t\tattach overflow to volume"));
1517 (void) fprintf(stdout, "%s\n",
1518 gettext("\t-D v\t\tdetach overflow from volume"));
1519 (void) fprintf(stdout, "%s\n",
1520 gettext("\t-L\t\tlist all overflow volumes"));
1521 (void) fprintf(stdout, "%s\n",
1522 gettext("\t-O o\t\tinitialize overflow"));
1523 (void) fprintf(stdout, "%s\n",
1524 gettext("\t-Q o\t\tquery status of overflow"));
1525 (void) fprintf(stdout, "%s\n",
1526 gettext("\t-E v\t\texport shadow volume"));
1527 (void) fprintf(stdout, "%s\n",
1528 gettext("\t-I v b\t\timport volume bitmap"));
1529 (void) fprintf(stdout, "%s\n",
1530 gettext("\t-J v b\t\tjoin volume bitmap"));
1531 (void) fprintf(stdout, "%s\n",
1532 gettext("\t-P d u v\tset copy delay/units for volume"));
1533 (void) fprintf(stdout, "%s\n",
1534 gettext("\t-P v\t\tget copy delay/units for volume"));
1535 (void) fprintf(stdout, "%s\n",
1536 gettext("\t-C tag\t\tcluster resource tag"));
1537 #ifdef DEBUG
1538 (void) fprintf(stdout, "%s\n",
1539 gettext("\t-b v\t\tdisplay bitmap volume"));
1540 (void) fprintf(stdout, "%s\n",
1541 gettext("\t-f f\t\tuse private configuration file"));
1542 #endif
1543 (void) fprintf(stdout, "%s\n",
1544 gettext("\t-v\t\tprint software versions"));
1545 (void) fprintf(stdout, "%s\n",
1546 gettext("\t-n\t\tperform action without question"));
1547 (void) fprintf(stdout, "%s\n",
1548 gettext("\t-p [-c|-u] {m|s}"
1549 "enable PID locking on copy or update"));
1550 (void) fprintf(stdout, "%s\n",
1551 gettext("\t-p -w v\t\tdisable PID locking"));
1552 (void) fprintf(stdout, "%s\n",
1553 gettext("\t-h\t\tiiadm usage summary"));
1554 (void) fprintf(stdout, "%s\n",
1555 gettext("\nUsage summary for options that support "
1556 "grouping (-g g):"));
1557 (void) fprintf(stdout, "%s\n",
1558 gettext("\t-g g -e ind m s b group enable independent "
1559 "master shadow bitmap"));
1560 (void) fprintf(stdout, "%s\n",
1561 gettext("\t-g g -e dep m s b group enable dependent "
1562 "master shadow bitmap"));
1563 (void) fprintf(stdout, "%s\n",
1564 gettext("\t-g g -d\t\tdisable group"));
1565 (void) fprintf(stdout, "%s\n",
1566 gettext("\t-g g -u s\tupdate shadow for all volumes in "
1567 "group"));
1568 (void) fprintf(stdout, "%s\n",
1569 gettext("\t-g g -u m\tupdate master for all volumes in "
1570 "group"));
1571 (void) fprintf(stdout, "%s\n",
1572 gettext("\t-g g -c s\tcopy to shadow for all volumes in "
1573 "group"));
1574 (void) fprintf(stdout, "%s\n",
1575 gettext("\t-g g -c m\tcopy to master for all volumes in "
1576 "group"));
1577 (void) fprintf(stdout, "%s\n",
1578 gettext("\t-g g -a\t\tabort copy for all volumes in "
1579 "group"));
1580 (void) fprintf(stdout, "%s\n",
1581 gettext("\t-g g -w\t\twait for all volumes in group"));
1582 (void) fprintf(stdout, "%s\n",
1583 gettext("\t-g g -i\t\tdisplay status of all volumes in "
1584 "group"));
1585 (void) fprintf(stdout, "%s\n",
1586 gettext("\t-g g -l\t\tlist all volumes in group"));
1587 (void) fprintf(stdout, "%s\n",
1588 gettext("\t-g -L\t\tlist all groups"));
1589 (void) fprintf(stdout, "%s\n",
1590 gettext("\t-g g -m v v\tmove one or more volumes into "
1591 "group"));
1592 (void) fprintf(stdout, "%s\n",
1593 gettext("\t-g \"\" -m v\tremove volume from group"));
1594 (void) fprintf(stdout, "%s\n",
1595 gettext("\t-g g -R\t\treset all volumes in group"));
1596 (void) fprintf(stdout, "%s\n",
1597 gettext("\t-g g -A o\tattach overflow to all volumes in "
1598 "group"));
1599 (void) fprintf(stdout, "%s\n",
1600 gettext("\t-g g -D\t\tdetach overflow from all volumes in "
1601 "group"));
1602 (void) fprintf(stdout, "%s\n",
1603 gettext("\t-g g -E\t\texport shadow volume for all "
1604 "volumes in group"));
1605 (void) fprintf(stdout, "%s\n",
1606 gettext("\t-g g -P d u\tset copy delay/units for all "
1607 "volumes in group"));
1608 (void) fprintf(stdout, "%s\n",
1609 gettext("\t-g g -P\t\tget copy delay/units for all "
1610 "volumes in group"));
1611 (void) fprintf(stdout, "%s\n",
1612 gettext("\nLegend summary:"));
1613 (void) fprintf(stdout, "%s\n",
1614 gettext("\tind\t\tindependent volume set"));
1615 (void) fprintf(stdout, "%s\n",
1616 gettext("\tdep\t\tdependent volume set"));
1617 (void) fprintf(stdout, "%s\n",
1618 gettext("\tall\t\tall configured volumes"));
1619 (void) fprintf(stdout, "%s\n",
1620 gettext("\tm\t\tmaster volume"));
1621 (void) fprintf(stdout, "%s\n",
1622 gettext("\ts\t\tshadow volume"));
1623 (void) fprintf(stdout, "%s\n",
1624 gettext("\tv\t\tshadow volume (reference name)"));
1625 (void) fprintf(stdout, "%s\n",
1626 gettext("\to\t\toverflow volume"));
1627 (void) fprintf(stdout, "%s\n",
1628 gettext("\tb\t\tbitmap volume"));
1629 #ifdef DEBUG
1630 (void) fprintf(stdout, "%s\n",
1631 gettext("\tf\t\tconfiguration file name"));
1632 #endif
1633 (void) fprintf(stdout, "%s\n",
1634 gettext("\td\t\tdelay tick interval"));
1635 (void) fprintf(stdout, "%s\n",
1636 gettext("\tu\t\tunit size"));
1637 (void) fprintf(stdout, "%s\n",
1638 gettext("\tg\t\tgroup name"));
1639
1640 /* assume we came here because user request help text */
1641 exit(0);
1642 /* NOTREACHED */
1643 }
1644
1645 }
1646
1647 static char yeschr[MAX_LINE_SIZE + 2];
1648 static char nochr[MAX_LINE_SIZE + 2];
1649
1650 static int
1651 yes(void)
1652 {
1653 int i, b;
1654 char ans[MAX_LINE_SIZE + 1];
1655
1656 for (i = 0; /*CSTYLED*/; i++) {
1657 b = getchar();
1658 if (b == '\n' || b == '\0' || b == EOF) {
1659 if (i < MAX_LINE_SIZE)
1660 ans[i] = 0;
1661 break;
1662 }
1663 if (i < MAX_LINE_SIZE)
1664 ans[i] = b;
1665 }
1666 if (i >= MAX_LINE_SIZE) {
1667 i = MAX_LINE_SIZE;
1668 ans[MAX_LINE_SIZE] = 0;
1669 }
1670 if ((i == 0) || (strncmp(yeschr, ans, i))) {
1671 if (strncmp(nochr, ans, i) == 0)
1672 return (0);
1673 else if (strncmp(yeschr, ans, i) == 0)
1674 return (1);
1675 else {
1676 (void) fprintf(stderr, "%s %s/%s\n",
1677 gettext("You have to respond with"),
1678 yeschr, nochr);
1679 return (2);
1680 }
1681 }
1682 return (1);
1683 }
1684
1685 static int
1686 convert_int(char *str)
1687 {
1688 int result, rc;
1689 char *buf;
1690
1691 buf = (char *)calloc(strlen(str) + 256, sizeof (char));
1692 rc = sscanf(str, "%d%s", &result, buf);
1693
1694 if (rc != 1) {
1695 (void) sprintf(buf, gettext("'%s' is not a valid number"), str);
1696 /* dsw_error calls exit which frees 'buf' */
1697 errno = EINVAL;
1698 dsw_error(buf, NULL);
1699 }
1700 free(buf);
1701
1702 return (result);
1703 }
1704
1705 void
1706 check_action(char *will_happen)
1707 {
1708 int answer;
1709
1710 if (nflg || !isatty(fileno(stdin)))
1711 return;
1712 (void) strncpy(yeschr, nl_langinfo(YESSTR), MAX_LINE_SIZE + 1);
1713 (void) strncpy(nochr, nl_langinfo(NOSTR), MAX_LINE_SIZE + 1);
1714
1715 /*CONSTCOND*/
1716 while (1) {
1717 (void) printf("%s %s/%s ", will_happen, yeschr, nochr);
1718 answer = yes();
1719 if (answer == 1 || answer == 0)
1720 break;
1721 }
1722 if (answer == 1)
1723 return;
1724 exit(1);
1725 }
1726
1727 enum child_event {Status, CopyStart};
1728
1729 /*
1730 * Wait for child process to get to some state, where some state may be:
1731 *
1732 * Status Set up the shadow enough so that it responds
1733 * to status requests.
1734 * CopyStart Start copy/update operations.
1735 */
1736
1737 int
1738 child_wait(pid_t child, enum child_event event, char *volume)
1739 {
1740 dsw_stat_t args;
1741 int rc;
1742
1743 (void) strlcpy(args.shadow_vol, volume, DSW_NAMELEN);
1744
1745 for (; dead_child != child; (void) sleep(1)) {
1746
1747 /* poll shadow group with a status ioctl() */
1748 args.status = spcs_s_ucreate();
1749 errno = 0;
1750 rc = do_ioctl(dsw_fd, DSWIOC_STAT, &args);
1751
1752 spcs_s_ufree(&args.status);
1753
1754 if (event == Status) {
1755 /* keep polling while we fail with DSW_ENOTFOUND */
1756 if (rc != -1 || errno != DSW_ENOTFOUND)
1757 return (0);
1758 } else {
1759 /* event == CopyStart */
1760 if (rc == -1) {
1761 return (1); /* something wrong */
1762 }
1763 if (args.stat & DSW_COPYINGP)
1764 return (0); /* copying underway */
1765 }
1766 }
1767 /* child died */
1768 if (WIFEXITED(dead_stat))
1769 return (WEXITSTATUS(dead_stat));
1770 else
1771 return (1);
1772 }
1773
1774 int
1775 mounted(char *t)
1776 {
1777 int rdsk;
1778 int i;
1779 FILE *mntfp;
1780 struct mnttab mntref;
1781 struct mnttab mntent;
1782 char target[DSW_NAMELEN];
1783 char *s;
1784
1785 rdsk = i = 0;
1786 for (s = target; i < DSW_NAMELEN && (*s = *t++); i++) {
1787 if (*s == 'r' && rdsk == 0)
1788 rdsk = 1;
1789 else
1790 s++;
1791 }
1792 *s = '\0';
1793
1794 mntref.mnt_special = target;
1795 mntref.mnt_mountp = NULL;
1796 mntref.mnt_fstype = NULL;
1797 mntref.mnt_mntopts = NULL;
1798 mntref.mnt_time = NULL;
1799
1800 if ((mntfp = fopen("/etc/mnttab", "r")) == NULL) {
1801 dsw_error(gettext("Can not check volume against mount table"),
1802 NULL);
1803 }
1804 if (getmntany(mntfp, &mntent, &mntref) != -1) {
1805 /* found something before EOF */
1806 (void) fclose(mntfp);
1807 return (1);
1808 }
1809 (void) fclose(mntfp);
1810 return (0);
1811 }
1812
1813 void
1814 enable(char *master_volume, char *shadow_volume,
1815 char *bitmap_volume, char *copy_type)
1816 {
1817 dsw_config_t parms;
1818 dsw_ioctl_t temp;
1819 char *p;
1820 int rc;
1821 pid_t child;
1822 spcs_s_info_t *sp_info;
1823 struct stat mstat, sstat, bstat;
1824 char mst_dg[DSW_NAMELEN] = {0};
1825 char shd_dg[DSW_NAMELEN] = {0};
1826 char bmp_dg[DSW_NAMELEN] = {0};
1827 int mvol_enabled;
1828 char *altname;
1829 grptag_t *gdata;
1830
1831 bzero(&parms, sizeof (dsw_config_t));
1832
1833 if (strcmp(copy_type, "independent") == 0 ||
1834 strcmp(copy_type, gettext("independent")) == 0)
1835 parms.flag = DSW_GOLDEN;
1836 else if (strcmp(copy_type, "dependent") == 0 ||
1837 strcmp(copy_type, gettext("dependent")) == 0)
1838 parms.flag = 0;
1839 else
1840 dsw_error(gettext("don't understand shadow type"), NULL);
1841
1842 /* validate volume names */
1843 if (perform_autosv()) {
1844 if (cfg_load_svols(cfg) < 0 || cfg_load_dsvols(cfg) < 0 ||
1845 cfg_load_shadows(cfg) < 0) {
1846 dsw_error(gettext("Unable to parse config file"), NULL);
1847 }
1848 load_ii_vols(cfg);
1849 reload_vols = LD_SVOLS | LD_DSVOLS | LD_SHADOWS | LD_II;
1850
1851 /* see if it's been used before under a different name */
1852 conform_name(&master_volume);
1853 conform_name(&shadow_volume);
1854 rc = cfg_get_canonical_name(cfg, bitmap_volume, &altname);
1855 if (rc < 0) {
1856 dsw_error(gettext("Unable to parse config file"), NULL);
1857 }
1858 if (rc) {
1859 errno = EBUSY;
1860 dsw_error(gettext("Bitmap in use"), NULL);
1861 }
1862 }
1863
1864 /*
1865 * If not local, determine disk group names for volumes in II set
1866 */
1867 switch (check_cluster()) {
1868 case II_CLUSTER:
1869 /*
1870 * Check if none or all volumes are in a disk group
1871 */
1872 rc = 0;
1873 if (check_diskgroup(master_volume, mst_dg)) rc++;
1874 if (check_diskgroup(shadow_volume, shd_dg)) rc++;
1875 if (check_diskgroup(bitmap_volume, bmp_dg)) rc++;
1876 if ((rc != 0) && (rc != 3))
1877 dsw_error(gettext(
1878 "Not all Point-in-Time Copy volumes are "
1879 "in a disk group"), NULL);
1880
1881 /*
1882 * If volumes are not in a disk group, but are in a
1883 * cluster, then "-C <tag>", must be set
1884 */
1885 if (rc == 0 && cfg_cluster_tag == NULL)
1886 dsw_error(gettext(
1887 "Point-in-Time Copy volumes, that are not "
1888 "in a device group which has been "
1889 "registered with SunCluster, "
1890 "require usage of \"-C\""), NULL);
1891
1892 /*
1893 * the same disk group
1894 * If -n, plus mst_dg==bmp_dg, then allow E/I/J in SunCluster
1895 */
1896 if ((strcmp(mst_dg, bmp_dg)) ||
1897 (strcmp(mst_dg, shd_dg) && (!nflg)))
1898 dsw_error(gettext(
1899 "Volumes are not in same disk group"), NULL);
1900
1901 /*
1902 * Can never enable the same shadow twice, regardless of
1903 * exportable shadow device group movement
1904 */
1905 if (find_shadow_line(shadow_volume))
1906 dsw_error(gettext(
1907 "Shadow volume is already configured"), NULL);
1908
1909 /*
1910 * Groups cannot span multiple clusters
1911 */
1912 if (group_name && perform_autosv()) {
1913 gdata = (grptag_t *)nsc_lookup(volhash, group_name);
1914 if (gdata &&
1915 strncmp(gdata->ctag, mst_dg, DSW_NAMELEN) != 0) {
1916 errno = EINVAL;
1917 dsw_error(gettext("Group contains sets not "
1918 "in the same cluster resource"), NULL);
1919 }
1920 }
1921
1922 /*
1923 * Check cluster tag and bitmap disk group
1924 * set latter if different
1925 */
1926 if (check_resource_group(bitmap_volume)) {
1927 /*
1928 * Unload and reload in the event cluster tag has
1929 * changed
1930 */
1931 if (perform_autosv()) {
1932 unload_ii_vols();
1933 cfg_unload_shadows();
1934 cfg_unload_dsvols();
1935 cfg_unload_svols();
1936 if (cfg_load_svols(cfg) < 0 ||
1937 cfg_load_dsvols(cfg) < 0 ||
1938 cfg_load_shadows(cfg) < 0) {
1939 dsw_error(gettext(
1940 "Unable to parse config "
1941 "file"), NULL);
1942 }
1943 load_ii_vols(cfg);
1944 }
1945 }
1946 /*
1947 * Copy cluster name into config
1948 */
1949 (void) strncpy(parms.cluster_tag, cfg_cluster_tag, DSW_NAMELEN);
1950 break;
1951
1952 case II_CLUSTER_LCL:
1953 /* ensure that the -C local won't interfere with the set */
1954 if (group_name && perform_autosv()) {
1955 gdata = (grptag_t *)nsc_lookup(volhash, group_name);
1956 if (gdata) {
1957 if (strlen(gdata->ctag) != 0) {
1958 errno = EINVAL;
1959 dsw_error(gettext("Unable to put set "
1960 "into -C local and specified "
1961 "group"), NULL);
1962 }
1963 }
1964 }
1965 break;
1966 }
1967
1968 /*
1969 * If we've got a group name, add it into the config
1970 */
1971 if (group_name) {
1972 (void) strncpy(parms.group_name, group_name, DSW_NAMELEN);
1973 }
1974
1975 /*
1976 * Determine accessability of volumes
1977 */
1978 if (stat(master_volume, &mstat) != 0)
1979 dsw_error(gettext(
1980 "Unable to access master volume"), NULL);
1981 if (!S_ISCHR(mstat.st_mode))
1982 dsw_error(gettext(
1983 "Master volume is not a character device"), NULL);
1984 /* check the shadow_vol hasn't be used as SNDR secondary vol */
1985 check_iishadow(shadow_volume);
1986 if (stat(shadow_volume, &sstat) != 0)
1987 dsw_error(gettext(
1988 "Unable to access shadow volume"), NULL);
1989 if (!S_ISCHR(sstat.st_mode))
1990 dsw_error(gettext(
1991 "Shadow volume is not a character device"), NULL);
1992 if (mounted(shadow_volume)) {
1993 errno = EBUSY;
1994 dsw_error(gettext(
1995 "Shadow volume is mounted, unmount it first"), NULL);
1996 }
1997 if (mstat.st_rdev == sstat.st_rdev) {
1998 errno = EINVAL;
1999 dsw_error(gettext(
2000 "Master and shadow are the same device"), NULL);
2001 }
2002 if (stat(bitmap_volume, &bstat) != 0) {
2003 dsw_error(gettext("Unable to access bitmap"), NULL);
2004 }
2005 if (!S_ISCHR(bstat.st_mode))
2006 dsw_error(gettext(
2007 "Bitmap volume is not a character device"), NULL);
2008 if (S_ISCHR(bstat.st_mode)) {
2009 if (mstat.st_rdev == bstat.st_rdev) {
2010 errno = EINVAL;
2011 dsw_error(gettext(
2012 "Master and bitmap are the same device"), NULL);
2013 } else if (sstat.st_rdev == bstat.st_rdev) {
2014 errno = EINVAL;
2015 dsw_error(gettext(
2016 "Shadow and bitmap are the same device"), NULL);
2017 }
2018 }
2019
2020 (void) strncpy(parms.master_vol, master_volume, DSW_NAMELEN);
2021 (void) strncpy(parms.shadow_vol, shadow_volume, DSW_NAMELEN);
2022 (void) strncpy(parms.bitmap_vol, bitmap_volume, DSW_NAMELEN);
2023 errno = 0;
2024 parms.status = spcs_s_ucreate();
2025
2026 /*
2027 * Check that none of the member volumes forms part of another
2028 * InstantImage group.
2029 *
2030 * -- this check has been removed; it is done in the kernel instead
2031 * -- PJW
2032 */
2033
2034 /*
2035 * Check against overflow volumes
2036 */
2037 for (p = get_overflow_list(); *p != NULL; p += DSW_NAMELEN) {
2038 if (strncmp(master_volume, p, DSW_NAMELEN) == 0)
2039 dsw_error(gettext(
2040 "Master volume is already an overflow volume"),
2041 NULL);
2042 else if (strncmp(shadow_volume, p, DSW_NAMELEN) == 0)
2043 dsw_error(gettext(
2044 "Shadow volume is already an overflow volume"),
2045 NULL);
2046 else if (strncmp(bitmap_volume, p, DSW_NAMELEN) == 0)
2047 dsw_error(gettext(
2048 "Bitmap volume is already an overflow volume"),
2049 NULL);
2050 }
2051
2052 /*
2053 * Make sure that the shadow volume is not already configured
2054 */
2055 if (find_shadow_config(shadow_volume, NULL, &temp))
2056 dsw_error(gettext(
2057 "Shadow volume is already configured"), NULL);
2058 if (perform_autosv()) {
2059 /*
2060 * parse the dsvol entries to see if we need to place
2061 * the master or shadow under SV control
2062 */
2063 if (nsc_lookup(volhash, master_volume) == NULL) {
2064 if (cfg_vol_enable(cfg, master_volume, cfg_cluster_tag,
2065 "ii") < 0) {
2066 dsw_error(
2067 gettext("Cannot enable master volume"),
2068 NULL);
2069 }
2070 mvol_enabled = 1;
2071 } else {
2072 mvol_enabled = 0;
2073 }
2074 if (nsc_lookup(volhash, shadow_volume) == NULL) {
2075 if (nflg) {
2076 cfg_resource(cfg, shd_dg);
2077 rc = cfg_vol_enable(cfg, shadow_volume,
2078 shd_dg, "ii");
2079 cfg_resource(cfg, cfg_cluster_tag);
2080 } else {
2081 rc = cfg_vol_enable(cfg, shadow_volume,
2082 cfg_cluster_tag, "ii");
2083 }
2084 if (rc < 0) {
2085 if (mvol_enabled) {
2086 if (cfg_vol_disable(cfg,
2087 master_volume, cfg_cluster_tag,
2088 "ii") < 0)
2089 dsw_error(gettext(
2090 "SV disable of master "
2091 "failed"),
2092 NULL);
2093 }
2094 dsw_error(
2095 gettext("Cannot enable shadow volume"),
2096 NULL);
2097 }
2098 }
2099 unload_ii_vols();
2100 cfg_unload_shadows();
2101 cfg_unload_dsvols();
2102 cfg_unload_svols();
2103 reload_vols = 0;
2104 }
2105
2106 add_cfg_entry(&parms);
2107 cfg_unlock(cfg);
2108 config_locked = 0;
2109
2110 (void) sigset(SIGCHLD, sigchild);
2111 switch (child = fork()) {
2112
2113 case (pid_t)-1:
2114 dsw_error(gettext("Unable to fork"), NULL);
2115 break;
2116
2117 case 0:
2118 rc = do_ioctl(dsw_fd, DSWIOC_ENABLE, &parms);
2119 if (rc == -1 && errno != DSW_EABORTED && errno != DSW_EIO) {
2120 /*
2121 * Failed to enable shadow group, log problem and remove
2122 * the shadow group from the config file.
2123 */
2124 spcs_log("ii", &parms.status,
2125 gettext("Enable failed %s %s %s (%s)"),
2126 master_volume, shadow_volume, bitmap_volume,
2127 parms.flag & DSW_GOLDEN ?
2128 "independent" : "dependent");
2129
2130 if (!ii_lock(cfg, CFG_WRLOCK) ||
2131 !find_shadow_config(shadow_volume, NULL, &temp)) {
2132 dsw_error(gettext(
2133 "Enable failed, can't tidy up cfg"),
2134 &parms.status);
2135 }
2136 config_locked = 1;
2137 remove_iiset(setnumber, shadow_volume, 0);
2138 dsw_error(gettext("Enable failed"), &parms.status);
2139 }
2140
2141 if (rc == -1)
2142 sp_info = &parms.status;
2143 else
2144 sp_info = NULL;
2145 spcs_log("ii", sp_info, gettext("Enabled %s %s %s (%s)"),
2146 master_volume, shadow_volume, bitmap_volume,
2147 parms.flag & DSW_GOLDEN ? "independent" : "dependent");
2148 spcs_s_ufree(&parms.status);
2149 break;
2150
2151 default:
2152 exit(child_wait(child, Status, shadow_volume));
2153 break;
2154 }
2155 }
2156
2157 int
2158 reset(char *volume)
2159 {
2160 dsw_ioctl_t args;
2161 dsw_config_t parms;
2162 int rc;
2163 int wait_loc;
2164 pid_t child = (pid_t)0;
2165 enum copy_wait wait_action;
2166 spcs_s_info_t *stat;
2167 dsw_stat_t prev_stat;
2168 int stat_flags;
2169 static int unlocked = 0;
2170 int do_enable = 0;
2171 char key[CFG_MAX_KEY];
2172 char optval[CFG_MAX_BUF];
2173 unsigned int flags;
2174
2175 wait_action = WaitForStart;
2176
2177 if (unlocked && !ii_lock(cfg, CFG_RDLOCK)) {
2178 dsw_error(gettext("Unable to set locking on the configuration"),
2179 NULL);
2180 }
2181 config_locked = 1;
2182 if (!find_shadow_config(volume, &parms, &args))
2183 dsw_error(gettext("Volume is not in a Point-in-Time Copy "
2184 "group"), NULL);
2185
2186 cfg_unlock(cfg);
2187 config_locked = 0;
2188 unlocked = 1;
2189
2190 spcs_log("ii", NULL, gettext("Start reset %s"), volume);
2191 (void) strlcpy(prev_stat.shadow_vol, volume, DSW_NAMELEN);
2192 prev_stat.status = spcs_s_ucreate();
2193 if (do_ioctl(dsw_fd, DSWIOC_STAT, &prev_stat) == -1) {
2194 /* set is suspended, so we do the enable processing instead */
2195 do_enable = 1;
2196
2197 /* first check to see whether the set was offline */
2198 (void) snprintf(key, CFG_MAX_KEY, "ii.set%d.options",
2199 setnumber);
2200 if (!ii_lock(cfg, CFG_RDLOCK)) {
2201 dsw_error(gettext("Unable to set locking on the "
2202 "configuration"), NULL);
2203 }
2204 config_locked = 1;
2205 unlocked = 0;
2206 if (cfg_get_single_option(cfg, CFG_SEC_CONF, key,
2207 NSKERN_II_BMP_OPTION, optval, CFG_MAX_BUF) < 0) {
2208 dsw_error(gettext("unable to read config file"), NULL);
2209 }
2210 cfg_unlock(cfg);
2211 config_locked = 0;
2212 unlocked = 1;
2213 (void) sscanf(optval, "%x", &flags);
2214 if ((flags & DSW_OFFLINE) == 0) {
2215 /* set wasn't offline - don't reset */
2216 dsw_error(gettext("Set not offline, will not reset"),
2217 NULL);
2218 }
2219 parms.status = spcs_s_ucreate();
2220 stat = &parms.status;
2221 stat_flags = DSW_BMPOFFLINE;
2222 } else {
2223 args.status = spcs_s_ucreate();
2224 stat = &args.status;
2225 stat_flags = prev_stat.stat;
2226 }
2227 spcs_s_ufree(&prev_stat.status);
2228
2229 if (wait_action == WaitForStart)
2230 (void) sigset(SIGCHLD, sigchild);
2231
2232 switch (child = fork()) {
2233
2234 case (pid_t)-1:
2235 dsw_error(gettext("Unable to fork"), NULL);
2236 break;
2237
2238 case 0:
2239 if (do_enable) {
2240 rc = do_ioctl(dsw_fd, DSWIOC_ENABLE, &parms);
2241 } else {
2242 rc = do_ioctl(dsw_fd, DSWIOC_RESET, &args);
2243 }
2244 if (rc == -1 && errno != DSW_EABORTED && errno != DSW_EIO) {
2245 spcs_log("ii", stat, gettext("Fail reset %s"), volume);
2246 dsw_error(gettext("Reset shadow failed"), stat);
2247 }
2248 /* last_overflow is set during find_shadow_config */
2249 if (strlen(last_overflow) > 0 &&
2250 (stat_flags & (DSW_SHDOFFLINE | DSW_BMPOFFLINE)) != 0) {
2251 /* reattach it */
2252 (void) strncpy(parms.bitmap_vol, last_overflow,
2253 DSW_NAMELEN);
2254 do_attach(&parms);
2255 }
2256 spcs_log("ii", stat, gettext("Finish reset %s"), volume);
2257 spcs_s_ufree(stat);
2258
2259 exit(0);
2260 break;
2261 default:
2262 if (wait_action == WaitForStart) {
2263 rc = child_wait(child, CopyStart, args.shadow_vol);
2264 } else { /* wait_action == WaitForEnd */
2265 wait_loc = 0;
2266 (void) wait(&wait_loc);
2267 if (WIFEXITED(wait_loc) && (WEXITSTATUS(wait_loc) == 0))
2268 rc = 0;
2269 else
2270 rc = -1;
2271 }
2272 break;
2273 }
2274 /* if successful, remove flags entry from options field */
2275 if (rc >= 0) {
2276 if (!ii_lock(cfg, CFG_WRLOCK)) {
2277 dsw_error(gettext("Unable to set locking on the "
2278 "configuration"), NULL);
2279 }
2280 config_locked = 1;
2281 if (!find_shadow_config(volume, &parms, &args)) {
2282 dsw_error(gettext("Volume is not in a Point-in-Time "
2283 "Copy group"), NULL);
2284 }
2285 (void) snprintf(key, CFG_MAX_KEY, "ii.set%d.options",
2286 setnumber);
2287 if (cfg_del_option(cfg, CFG_SEC_CONF, key, NSKERN_II_BMP_OPTION)
2288 < 0) {
2289 dsw_error(gettext("Update of config failed"), NULL);
2290 }
2291 (void) cfg_commit(cfg);
2292 cfg_unlock(cfg);
2293 config_locked = 0;
2294 }
2295
2296 return (rc);
2297 }
2298
2299 int
2300 overflow(char *volume)
2301 {
2302 dsw_ioctl_t args;
2303 int rc;
2304 spcs_s_info_t *stat;
2305
2306 check_action(gettext("Initialize this overflow volume?"));
2307 if (find_matching_cf_line(volume, NULL, &args))
2308 dsw_error(gettext("Volume is part of a Point-in-Time Copy "
2309 "group"), NULL);
2310 args.status = spcs_s_ucreate();
2311 (void) strncpy(args.shadow_vol, volume, DSW_NAMELEN);
2312 rc = do_ioctl(dsw_fd, DSWIOC_OCREAT, &args);
2313 if (rc == -1) {
2314 spcs_log("ii", &args.status,
2315 gettext("Create overflow failed %s"), volume);
2316 dsw_error(gettext("Create overflow failed"), &args.status);
2317 }
2318 if (rc == -1)
2319 stat = &args.status;
2320 else
2321 stat = NULL;
2322 spcs_log("ii", stat, gettext("Create overflow succeeded %s"), volume);
2323 spcs_s_ufree(&args.status);
2324
2325 return (0);
2326 }
2327
2328 void
2329 bitmap_op(char *master_volume, int print_bitmap, int bitmap_percent, int used,
2330 int is_compact)
2331 {
2332 unsigned char *bitmap;
2333 char *name;
2334 int i, x, y;
2335 unsigned j;
2336 unsigned long n;
2337 unsigned long percent;
2338
2339 bitmap = allocate_bitmap(master_volume);
2340 if (bitmap == NULL)
2341 return;
2342
2343 if (bitmap_percent) {
2344 /* count the number of bits set in bitmap */
2345 for (i = n = 0; i < bm_size; i++)
2346 for (j = (unsigned)bitmap[i]; j; j &= j -1)
2347 n++;
2348 if (is_compact)
2349 (void) printf(gettext("Chunks in map: %d used: %d\n"),
2350 used, n);
2351 if (bm_actual < 100) {
2352 percent = 0;
2353 } else {
2354 percent = (n * 100) / bm_actual;
2355 }
2356 (void) printf(gettext("Percent of bitmap set: %u\n"), percent);
2357 percent = percent/100;
2358 /* distinguish between 0.0000% and 0.n% of bitmap set */
2359 if (percent < 1)
2360 (void) printf("\t(%s)\n", n > 0 ?
2361 gettext("bitmap dirty") : gettext("bitmap clean"));
2362 }
2363
2364 if (print_bitmap) {
2365 name = strrchr(master_volume, '/');
2366 if (name++ == NULL)
2367 name = master_volume;
2368 i = bm_size * 8;
2369 x = (int)ceil(sqrt((double)i));
2370 x += (8 - (x % 8)); /* round up to nearest multiple of 8 */
2371 y = i / x;
2372 if (y * x < i)
2373 y++;
2374 (void) printf("#define bm%s_width %d\n#define bm%s_height %d\n",
2375 name, x, name, y);
2376 (void) printf("#define bm%s_x_hot 0\n#define bm%s_y_hot 0\n",
2377 name, name);
2378 (void) printf("static char bm%s_bits[] = {\n", name);
2379 for (i = 0; i < bm_size; i++) {
2380 if (i % 12 == 0)
2381 (void) printf("\n");
2382 (void) printf("0x%02x, ", bitmap[i]);
2383 }
2384 y = x * y;
2385 for (; i < y; i++) {
2386 if (i % 12 == 0)
2387 (void) printf("\n");
2388 (void) printf("0x00, ");
2389 }
2390 (void) printf("\n};\n");
2391 }
2392
2393 free_bitmap(bitmap);
2394 }
2395
2396 static int
2397 validate_group_names(char **vol_list, char *group)
2398 {
2399 ENTRY item, *found;
2400 int i, rc, count;
2401 dsw_aioctl_t *group_list;
2402 char *ptr;
2403
2404 if (group == NULL || *group == NULL) {
2405 /* no group set, just count volume list */
2406 for (i = 0; *vol_list++ != NULL; i++)
2407 ;
2408 return (i);
2409 }
2410
2411 if ((count = do_ioctl(dsw_fd, DSWIOC_LISTLEN, NULL)) < 0)
2412 dsw_error("DSWIOC_LISTLEN", NULL);
2413
2414 group_list = malloc(sizeof (dsw_aioctl_t) + count * DSW_NAMELEN);
2415 if (group_list == NULL)
2416 dsw_error(gettext("Failed to allocate memory"), NULL);
2417
2418 bzero(group_list, sizeof (dsw_aioctl_t) + count * DSW_NAMELEN);
2419 group_list->count = count;
2420 group_list->flags = 0;
2421 group_list->status = spcs_s_ucreate();
2422 (void) strncpy(group_list->shadow_vol, group, DSW_NAMELEN);
2423
2424 rc = do_ioctl(dsw_fd, DSWIOC_GLIST, group_list);
2425 if (rc < 0)
2426 dsw_error(gettext("Group list access failure"),
2427 &group_list->status);
2428
2429 group_list->shadow_vol[DSW_NAMELEN * group_list->count] = '\0';
2430
2431 /* create hash and enter all volumes into it */
2432 if (hcreate(group_list->count) == 0)
2433 dsw_error(gettext("Failed to allocate memory"), NULL);
2434 ptr = group_list->shadow_vol;
2435 count = group_list->count;
2436 i = 0;
2437 while (i < count) {
2438 ptr[ DSW_NAMELEN - 1 ] = '\0';
2439 item.key = ptr;
2440 item.data = (void *) 0;
2441 (void) hsearch(item, ENTER);
2442 ++i;
2443 ptr += DSW_NAMELEN;
2444 }
2445
2446 /* now compare the volume list with the hash */
2447 for (i = 0; vol_list[ i ]; i++) {
2448 item.key = vol_list[ i ];
2449 found = hsearch(item, FIND);
2450 if (!found)
2451 dsw_error(gettext("Group config does not match kernel"),
2452 NULL);
2453 if (found->data != (void *) 0)
2454 dsw_error(gettext("Duplicate volume specified"), NULL);
2455 found->data = (void *) 1;
2456 }
2457 if (i != count)
2458 dsw_error(gettext("Group config does not match kernel"), NULL);
2459
2460 /* everything checks out */
2461 free(group_list);
2462 hdestroy();
2463
2464 return (count);
2465 }
2466
2467 int
2468 do_acopy(char **vol_list, enum copy_update update_mode,
2469 enum copy_direction direction)
2470 {
2471 dsw_aioctl_t *acopy_args;
2472 dsw_ioctl_t copy_args;
2473 dsw_config_t parms;
2474 dsw_stat_t stat_s;
2475 int i;
2476 int rc;
2477 int n_vols;
2478 char *t;
2479 char buf[1024];
2480 char *sp;
2481 char *ppid;
2482
2483 n_vols = validate_group_names(vol_list, group_name);
2484
2485 acopy_args = calloc(sizeof (dsw_aioctl_t) + n_vols * DSW_NAMELEN, 1);
2486 if (acopy_args == NULL)
2487 dsw_error(gettext("Too many volumes given for update"), NULL);
2488
2489 acopy_args->count = n_vols;
2490
2491 acopy_args->flags = 0;
2492
2493 if (update_mode == Update)
2494 acopy_args->flags |= CV_BMP_ONLY;
2495 if (direction == ToMaster)
2496 acopy_args->flags |= CV_SHD2MST;
2497 if (pflg) {
2498 acopy_args->flags |= CV_LOCK_PID;
2499 #ifdef DEBUG
2500 ppid = getenv("IIADM_PPID");
2501 if (ppid) {
2502 acopy_args->pid = atoi(ppid);
2503 (void) fprintf(stderr, "(using %s for ppid)\n", ppid);
2504 } else {
2505 acopy_args->pid = getppid();
2506 }
2507 #else
2508 acopy_args->pid = getppid();
2509 #endif
2510 }
2511
2512 for (i = 0; i < n_vols; i++) {
2513 if (!find_shadow_config(vol_list[i], &parms, &copy_args))
2514 dsw_error(gettext("Volume is not in a Point-in-Time "
2515 "group"), NULL);
2516 if (direction == ToMaster) {
2517 t = parms.master_vol;
2518 } else {
2519 t = parms.shadow_vol;
2520 }
2521
2522 if (mounted(t)) {
2523 errno = EBUSY;
2524 dsw_error(gettext("Target of copy/update is mounted, "
2525 "unmount it first"), NULL);
2526 }
2527
2528 (void) strlcpy(stat_s.shadow_vol, parms.shadow_vol,
2529 DSW_NAMELEN);
2530 stat_s.status = spcs_s_ucreate();
2531 rc = do_ioctl(dsw_fd, DSWIOC_STAT, &stat_s);
2532 spcs_s_ufree(&stat_s.status);
2533 if (rc == -1) {
2534 (void) sprintf(buf,
2535 gettext("Shadow group %s is suspended"),
2536 vol_list[i]);
2537 dsw_error(buf, NULL);
2538 }
2539
2540 if (stat_s.stat & DSW_COPYINGP) {
2541 (void) fprintf(stderr, "%s: %s\n", cmdnam,
2542 gettext("Copy already in progress"));
2543 exit(1);
2544 }
2545 }
2546 acopy_args->status = spcs_s_ucreate();
2547 for (i = 0; i < n_vols; i++) {
2548 spcs_log("ii", NULL, gettext("Atomic %s %s %s"),
2549 update_mode == Update ? gettext("update") : gettext("copy"),
2550 vol_list[i],
2551 direction == ToMaster ? gettext("from shadow") :
2552 gettext("to shadow"));
2553 }
2554 if (group_name == NULL || *group_name == NULL) {
2555 sp = acopy_args->shadow_vol;
2556 for (i = 0; i < n_vols; i++, sp += DSW_NAMELEN)
2557 (void) strncpy(sp, vol_list[i], DSW_NAMELEN);
2558 } else {
2559 (void) strncpy(acopy_args->shadow_vol, group_name, DSW_NAMELEN);
2560 acopy_args->flags |= CV_IS_GROUP;
2561 }
2562 rc = do_ioctl(dsw_fd, DSWIOC_ACOPY, acopy_args);
2563 if (rc == -1) {
2564 i = acopy_args->count;
2565 if (i < 0 || i >= n_vols) {
2566 spcs_log("ii", NULL, gettext("Atomic update failed"));
2567 (void) sprintf(buf, gettext("Update failed"));
2568 } else {
2569 spcs_log("ii", NULL,
2570 gettext("Atomic update of %s failed"),
2571 vol_list[acopy_args->count]);
2572 (void) sprintf(buf, gettext("Update of %s failed"),
2573 vol_list[acopy_args->count]);
2574 }
2575 dsw_error(buf, &(acopy_args->status));
2576 }
2577 return (rc);
2578 }
2579
2580 int
2581 do_copy(char **vol_list, enum copy_update update_mode,
2582 enum copy_direction direction, enum copy_wait wait_action)
2583 {
2584 dsw_ioctl_t copy_args;
2585 dsw_config_t parms;
2586 dsw_stat_t stat_s;
2587 int rc;
2588 int wait_loc;
2589 char *t;
2590 char *volume;
2591 pid_t child = (pid_t)0;
2592 char *ppid;
2593
2594 if (vol_list[0] && vol_list[1])
2595 return (do_acopy(vol_list, update_mode, direction));
2596
2597 volume = vol_list[0];
2598 if (!find_shadow_config(volume, &parms, &copy_args))
2599 dsw_error(gettext("Volume is not in a Point-in-Time Copy "
2600 "group"), NULL);
2601
2602 cfg_unlock(cfg);
2603 config_locked = 0;
2604 copy_args.flags = 0;
2605
2606 if (update_mode == Update)
2607 copy_args.flags |= CV_BMP_ONLY;
2608 if (direction == ToMaster) {
2609 copy_args.flags |= CV_SHD2MST;
2610 t = parms.master_vol;
2611 } else {
2612 t = parms.shadow_vol;
2613 }
2614 if (pflg) {
2615 copy_args.flags |= CV_LOCK_PID;
2616 #ifdef DEBUG
2617 ppid = getenv("IIADM_PPID");
2618 if (ppid) {
2619 copy_args.pid = atoi(ppid);
2620 (void) fprintf(stderr, "(using %s for ppid)\n", ppid);
2621 } else {
2622 copy_args.pid = getppid();
2623 }
2624 #else
2625 copy_args.pid = getppid();
2626 #endif
2627 }
2628
2629 if (mounted(t)) {
2630 errno = EBUSY;
2631 dsw_error(gettext("Target of copy/update is mounted, "
2632 "unmount it first"), NULL);
2633 }
2634
2635 (void) strlcpy(stat_s.shadow_vol, copy_args.shadow_vol, DSW_NAMELEN);
2636 stat_s.status = spcs_s_ucreate();
2637 rc = do_ioctl(dsw_fd, DSWIOC_STAT, &stat_s);
2638 spcs_s_ufree(&stat_s.status);
2639 if (rc == -1)
2640 dsw_error(gettext("Shadow group suspended"), NULL);
2641
2642 if (stat_s.stat & DSW_COPYINGP) {
2643 (void) fprintf(stderr, "%s: %s\n", cmdnam,
2644 gettext("Copy already in progress"));
2645 exit(1);
2646 }
2647
2648 copy_args.status = spcs_s_ucreate();
2649 spcs_log("ii", NULL, gettext("Start %s %s %s"),
2650 update_mode == Update ? gettext("update") : gettext("copy"),
2651 volume,
2652 direction == ToMaster ? gettext("from shadow") :
2653 gettext("to shadow"));
2654
2655 if (wait_action == WaitForStart)
2656 (void) sigset(SIGCHLD, sigchild);
2657 switch (child = fork()) {
2658
2659 case (pid_t)-1:
2660 dsw_error(gettext("Unable to fork"),
2661 NULL);
2662 break;
2663
2664 case 0:
2665 rc = do_ioctl(dsw_fd, DSWIOC_COPY, &copy_args);
2666 if (rc == -1) {
2667 spcs_log("ii", &copy_args.status,
2668 gettext("Fail %s %s %s"),
2669 update_mode == Update ?
2670 gettext("update") : gettext("copy"),
2671 volume,
2672 direction == ToMaster ?
2673 gettext("from shadow") : gettext("to shadow"));
2674 dsw_error(gettext("Copy failed"), &copy_args.status);
2675 }
2676 spcs_s_ufree(&copy_args.status);
2677 spcs_log("ii", NULL, gettext("Finish %s %s %s"),
2678 update_mode == Update ? gettext("update") : gettext("copy"),
2679 volume,
2680 direction == ToMaster ? gettext("from shadow") :
2681 gettext("to shadow"));
2682
2683 exit(0);
2684 break;
2685 default:
2686 if (wait_action == WaitForStart) {
2687 rc = child_wait(child, CopyStart, copy_args.shadow_vol);
2688 } else { /* wait_action == WaitForEnd */
2689 wait_loc = 0;
2690 (void) wait(&wait_loc);
2691 if (WIFEXITED(wait_loc) && (WEXITSTATUS(wait_loc) == 0))
2692 rc = 0;
2693 else
2694 rc = 1;
2695 }
2696 break;
2697 }
2698 return (rc);
2699 }
2700
2701 void
2702 print_status(dsw_config_t *conf, int in_config)
2703 {
2704 dsw_stat_t args;
2705 int stat_flags;
2706 static int need_sep = 0;
2707 time_t tmp_time;
2708
2709 if (need_sep++ > 0)
2710 (void) printf("--------------------------------------"
2711 "----------------------------------------\n");
2712 (void) strlcpy(args.shadow_vol, conf->shadow_vol, DSW_NAMELEN);
2713 if (in_config) {
2714 (void) printf("%s: %s\n",
2715 conf->master_vol, gettext("(master volume)"));
2716 (void) printf("%s: %s\n",
2717 conf->shadow_vol, gettext("(shadow volume)"));
2718 (void) printf("%s: %s\n",
2719 conf->bitmap_vol, gettext("(bitmap volume)"));
2720 }
2721
2722 /*
2723 * Do special checking on the status of this volume in a Sun Cluster
2724 */
2725 if (check_cluster() == II_CLUSTER) {
2726 char dgname[CFG_MAX_BUF], *other_node;
2727
2728 if (cfg_dgname(conf->bitmap_vol, dgname, sizeof (dgname))) {
2729 if (strlen(dgname)) {
2730 int rc = cfg_dgname_islocal(dgname,
2731 &other_node);
2732
2733 if (rc < 0) {
2734 (void) printf(gettext(
2735 "Suspended on this node, "
2736 "not active elsewhere\n"));
2737 return;
2738 } else if (rc == 0) {
2739 (void) printf(gettext(
2740 "Suspended on this node, "
2741 "active on %s\n"), other_node);
2742 return;
2743 }
2744 }
2745 }
2746 }
2747
2748 args.status = spcs_s_ucreate();
2749 if (do_ioctl(dsw_fd, DSWIOC_STAT, &args) == -1) {
2750
2751 /* Handle Not found or not in config */
2752 if (errno != DSW_ENOTFOUND || !in_config)
2753 dsw_error(gettext("Stat failed"), &args.status);
2754
2755 /* Just suspend */
2756 (void) printf(gettext("Suspended.\n"));
2757 return;
2758 }
2759
2760 if (args.overflow_vol[0] != '\0')
2761 (void) printf("%s: %s\n", args.overflow_vol,
2762 gettext("(overflow volume)"));
2763
2764 if (conf->group_name[0] != '\0')
2765 (void) printf(gettext("Group name: %s\n"),
2766 conf->group_name);
2767
2768 if (conf->cluster_tag[0] != '\0')
2769 (void) printf(gettext("Cluster tag: %s\n"),
2770 conf->cluster_tag);
2771
2772 stat_flags = args.stat;
2773 spcs_s_ufree(&args.status);
2774 if (stat_flags & DSW_GOLDEN)
2775 (void) printf(gettext("Independent copy"));
2776 else
2777 (void) printf(gettext("Dependent copy"));
2778
2779 if (stat_flags & DSW_TREEMAP)
2780 (void) printf(gettext(", compacted shadow space"));
2781
2782 if (stat_flags & DSW_COPYINGP)
2783 (void) printf(gettext(", copy in progress"));
2784 else if (stat_flags & DSW_COPYING)
2785 (void) printf(gettext(", copy not active"));
2786
2787 if (stat_flags & DSW_COPYINGM)
2788 (void) printf(gettext(", copying master to shadow"));
2789
2790 if (stat_flags & DSW_COPYINGS)
2791 (void) printf(gettext(", copying shadow to master"));
2792
2793 if (stat_flags & DSW_COPYINGX)
2794 (void) printf(gettext(", abort of copy requested"));
2795
2796 if (stat_flags & DSW_MSTOFFLINE)
2797 (void) printf(gettext(", master volume offline"));
2798
2799 if (stat_flags & DSW_SHDOFFLINE)
2800 (void) printf(gettext(", shadow volume offline"));
2801
2802 if (stat_flags & DSW_BMPOFFLINE)
2803 (void) printf(gettext(", bitmap volume offline"));
2804
2805 if (stat_flags & DSW_OVROFFLINE)
2806 (void) printf(gettext(", overflow volume offline"));
2807
2808 if (stat_flags & DSW_SHDEXPORT)
2809 (void) printf(gettext(", shadow volume exported"));
2810
2811 if (stat_flags & DSW_SHDIMPORT)
2812 (void) printf(gettext(", shadow volume imported"));
2813
2814 if (stat_flags & DSW_OVERFLOW)
2815 (void) printf(gettext(", out of space"));
2816
2817 if (stat_flags & DSW_VOVERFLOW)
2818 (void) printf(gettext(", spilled into overflow volume"));
2819 (void) printf("\n");
2820
2821 tmp_time = args.mtime;
2822 if (tmp_time != 0)
2823 (void) printf("%s %s", gettext("Latest modified time:"),
2824 ctime(&tmp_time));
2825 else
2826 (void) printf("%s\n", gettext("Latest modified time: unknown"));
2827
2828 (void) printf("%s %8llu\n", gettext("Volume size:"), args.size);
2829 if (args.shdsize != 0) {
2830 (void) printf("%s %lld %s %lld\n",
2831 gettext("Shadow chunks total:"), args.shdsize,
2832 gettext("Shadow chunks used:"), args.shdused);
2833 }
2834 bitmap_op(args.shadow_vol, 0, 1, 0, 0);
2835 }
2836
2837 int
2838 abort_copy(char *volume)
2839 {
2840 dsw_ioctl_t args;
2841
2842 if (!find_shadow_config(volume, NULL, &args))
2843 dsw_error(gettext("Volume is not in a Point-in-Time Copy "
2844 "group"), NULL);
2845 args.status = spcs_s_ucreate();
2846 if (do_ioctl(dsw_fd, DSWIOC_ABORT, &args) == -1)
2847 dsw_error(gettext("Abort failed"), &args.status);
2848 spcs_log("ii", NULL, gettext("Abort %s"), args.shadow_vol);
2849 spcs_s_ufree(&args.status);
2850 return (0);
2851 }
2852
2853 void
2854 iiversion()
2855 {
2856 dsw_version_t args;
2857
2858 args.status = spcs_s_ucreate();
2859 if (do_ioctl(dsw_fd, DSWIOC_VERSION, &args) == -1)
2860 dsw_error(gettext("Version failed"), &args.status);
2861 spcs_s_ufree(&args.status);
2862 #ifdef DEBUG
2863 (void) printf(gettext("Point in Time Copy version %d.%d.%d.%d\n"),
2864 args.major, args.minor, args.micro, args.baseline);
2865 #else
2866 if (args.micro) {
2867 (void) printf(gettext("Point in Time Copy version %d.%d.%d\n"),
2868 args.major, args.minor, args.micro);
2869 } else {
2870 (void) printf(gettext("Point in Time Copy version %d.%d\n"),
2871 args.major, args.minor);
2872 }
2873 #endif
2874 }
2875
2876 void
2877 list_volumes()
2878 {
2879 dsw_list_t args;
2880 int i, set, found;
2881 dsw_config_t *lp;
2882 ENTRY item, *ip;
2883 dsw_config_t parms;
2884
2885 if ((i = do_ioctl(dsw_fd, DSWIOC_LISTLEN, &args)) == -1)
2886 dsw_error("DSWIOC_LISTLEN", NULL);
2887
2888 args.status = spcs_s_ucreate();
2889 args.list_used = 0;
2890 args.list_size = i + 4;
2891 lp = args.list = (dsw_config_t *)
2892 malloc(args.list_size * sizeof (dsw_config_t));
2893
2894 if (args.list == NULL)
2895 dsw_error(gettext("Failed to allocate memory"), NULL);
2896 if (do_ioctl(dsw_fd, DSWIOC_LIST, &args) == -1)
2897 dsw_error(gettext("List failed"), &args.status);
2898 spcs_s_ufree(&args.status);
2899
2900 /* make a hashtable */
2901 if (args.list_used > 0) {
2902 if (hcreate(args.list_used) == 0) {
2903 dsw_error(gettext("Failed to allocate memory"), NULL);
2904 /*NOTREACHED*/
2905 }
2906 }
2907
2908 /* populate the hashtable */
2909 for (i = 0; i < args.list_used; i++, lp++) {
2910 item.key = lp->shadow_vol;
2911 item.data = (char *)lp;
2912 if (hsearch(item, ENTER) == NULL) {
2913 dsw_error(gettext("Failed to allocate memory"), NULL);
2914 /*NOTREACHED*/
2915 }
2916 }
2917
2918 /* perform action for each line of the stored config file */
2919 for (set = 1; get_dsw_config(set, &parms) == 0; set++) {
2920
2921 /* Are there any II sets configured on this node? */
2922 if (args.list_used > 0) {
2923 item.key = parms.shadow_vol;
2924
2925 /* Is this volume configured on this node? */
2926 if (ip = hsearch(item, FIND)) {
2927
2928 /* Handle Imported Shadows */
2929 /* LINTED alignment of cast ok */
2930 lp = (dsw_config_t *)ip->data;
2931 if (strcmp(parms.master_vol,
2932 II_IMPORTED_SHADOW))
2933 found = !(lp->flag & DSW_SHDIMPORT);
2934 else
2935 found = (lp->flag & DSW_SHDIMPORT);
2936 }
2937 else
2938 found = FALSE;
2939 }
2940 else
2941 found = FALSE;
2942
2943 if ((cfg_cluster_tag) &&
2944 strcmp(cfg_cluster_tag, parms.cluster_tag))
2945 continue;
2946
2947 if ((group_name) && strcmp(group_name, parms.group_name))
2948 continue;
2949
2950 (void) printf("%s %.*s %.*s %.*s%s\n",
2951 (parms.flag & DSW_GOLDEN) ? "ind" : "dep",
2952 DSW_NAMELEN, parms.master_vol,
2953 DSW_NAMELEN, parms.shadow_vol,
2954 DSW_NAMELEN, parms.bitmap_vol,
2955 found ? "" : gettext(" (suspended)"));
2956 }
2957 hdestroy();
2958 free(args.list);
2959 }
2960
2961 int
2962 wait_for_copy(char *volume)
2963 {
2964 dsw_ioctl_t parms;
2965 int rc;
2966 static int unlocked = 0;
2967 char *ppid;
2968
2969 if (unlocked && !ii_lock(cfg, CFG_RDLOCK)) {
2970 dsw_error(gettext("Unable to set locking on the configuration"),
2971 NULL);
2972 }
2973 config_locked = 1;
2974 if (!find_shadow_config(volume, NULL, &parms))
2975 dsw_error(gettext("Volume is not in a Point-in-Time Copy "
2976 "group"), NULL);
2977 cfg_unlock(cfg);
2978 config_locked = 0;
2979 unlocked = 1;
2980
2981 parms.status = spcs_s_ucreate();
2982 if (pflg) {
2983 #ifdef DEBUG
2984 ppid = getenv("IIADM_PPID");
2985 if (ppid) {
2986 parms.pid = atoi(ppid);
2987 (void) fprintf(stderr, "(using %s for ppid)\n", ppid);
2988 } else {
2989 parms.pid = (nflg) ? -1 : getppid();
2990 }
2991 #else
2992 parms.pid = (nflg) ? -1 : getppid();
2993 #endif
2994 parms.flags |= CV_LOCK_PID;
2995 }
2996
2997 rc = do_ioctl(dsw_fd, DSWIOC_WAIT, &parms);
2998 if (rc == -1)
2999 dsw_error(gettext("Wait failed"), &parms.status);
3000 spcs_s_ufree(&parms.status);
3001 return (0);
3002 }
3003
3004 int
3005 export(char *volume)
3006 {
3007 dsw_ioctl_t parms;
3008 dsw_config_t conf;
3009 char *old_ctag, dgname[DSW_NAMELEN];
3010 int rc;
3011
3012 if (!find_shadow_config(volume, &conf, &parms))
3013 dsw_error(gettext("Volume is not in a Point-in-Time Copy "
3014 "group"), NULL);
3015 if (mounted(volume))
3016 dsw_error(gettext("Can't export a mounted volume"), NULL);
3017
3018 /* If this is an exportable shadow in the cluster, change ctag */
3019 if (strlen(conf.cluster_tag) &&
3020 (cfg_dgname(volume, dgname, sizeof (dgname)))) {
3021 old_ctag = cfg_cluster_tag;
3022 cfg_resource(cfg, cfg_cluster_tag = strdup(dgname));
3023 } else old_ctag = NULL;
3024
3025 if (cfg_load_dsvols(cfg) < 0 || cfg_load_shadows(cfg) < 0) {
3026 dsw_error(gettext("Unable to parse config file"), NULL);
3027 }
3028 reload_vols = LD_DSVOLS | LD_SHADOWS;
3029 conform_name(&volume);
3030
3031 spcs_log("ii", NULL, gettext("Export %s"), volume);
3032 parms.status = spcs_s_ucreate();
3033 rc = do_ioctl(dsw_fd, DSWIOC_EXPORT, &parms);
3034 if (rc == -1)
3035 dsw_error(gettext("Export failed"), &parms.status);
3036 if (perform_autosv()) {
3037 if (cfg_vol_disable(cfg, volume, cfg_cluster_tag, "ii") < 0) {
3038 dsw_error(gettext("SV-disable failed"), NULL);
3039 }
3040 (void) cfg_commit(cfg);
3041 }
3042
3043 /* restore old cluster tag, if changed */
3044 if (old_ctag != NULL)
3045 cfg_resource(cfg, cfg_cluster_tag = old_ctag);
3046
3047 spcs_s_ufree(&parms.status);
3048 return (0);
3049 }
3050
3051 int
3052 detach(char *volume)
3053 {
3054 dsw_ioctl_t parms;
3055 int rc;
3056
3057 if (!find_shadow_config(volume, NULL, &parms))
3058 dsw_error(gettext("Volume is not in a Point-in-Time Copy "
3059 "group"), NULL);
3060 parms.status = spcs_s_ucreate();
3061 rc = do_ioctl(dsw_fd, DSWIOC_ODETACH, &parms);
3062 if (rc == 0) {
3063 /* remove overflow from cfg line */
3064 (void) sprintf(key, "ii.set%d.overflow", setnumber);
3065 if (cfg_put_cstring(cfg, key, "-", 1) < 0) {
3066 perror("cfg_put_cstring");
3067 }
3068 (void) cfg_commit(cfg);
3069 } else {
3070 spcs_log("ii", NULL, gettext("Detach of overflow %s failed"),
3071 parms.shadow_vol);
3072 dsw_error(gettext("Failed to detach overflow volume"),
3073 &parms.status);
3074 }
3075 return (rc);
3076 }
3077
3078 static void
3079 can_disable(char *vol)
3080 {
3081 dsw_stat_t args;
3082
3083 if (mounted(vol)) {
3084 (void) strlcpy(args.shadow_vol, vol, DSW_NAMELEN);
3085 args.status = spcs_s_ucreate();
3086 if (do_ioctl(dsw_fd, DSWIOC_STAT, &args) != -1 &&
3087 (args.stat & DSW_GOLDEN) == 0) {
3088 errno = EBUSY;
3089 dsw_error(gettext("Shadow Volume is currently mounted "
3090 "and dependent on the master volume"), NULL);
3091 }
3092 spcs_s_ufree(&args.status);
3093 }
3094 }
3095
3096 static void
3097 clean_up_after_failed_disable(dsw_ioctl_t *parms)
3098 {
3099 char **p;
3100 dsw_stat_t args;
3101
3102 for (p = group_volumes; *p; p++) {
3103 (void) strlcpy(args.shadow_vol, *p, DSW_NAMELEN);
3104 args.status = spcs_s_ucreate();
3105 if (do_ioctl(dsw_fd, DSWIOC_STAT, &args) == -1) {
3106 /* set was successfully disabled */
3107 if (find_shadow_config(*p, NULL, NULL))
3108 remove_iiset(setnumber, *p, 0);
3109 }
3110 spcs_s_ufree(&args.status);
3111 }
3112
3113 dsw_error(gettext("Some sets in the group failed to disable"),
3114 &parms->status);
3115 }
3116
3117 int
3118 dsw_group_or_single_disable(int argc, char *argv[])
3119 {
3120 int rc = 0;
3121 char **p;
3122 dsw_ioctl_t parms;
3123 int flags = 0;
3124 dsw_config_t conf;
3125 int shd_exported = 0;
3126
3127 if (argc != 2)
3128 usage(gettext("Incorrect number of arguments"));
3129
3130 if (group_name) {
3131 if (find_group_members(group_name) < 1)
3132 dsw_error(gettext("Group does not exist or "
3133 "has no members"), NULL);
3134 for (p = group_volumes; *p; p++) {
3135 can_disable(*p);
3136 }
3137
3138 (void) strncpy(parms.shadow_vol, group_name, DSW_NAMELEN);
3139 if (*group_name)
3140 flags = CV_IS_GROUP;
3141 } else {
3142 if (!find_shadow_config(argv[1], &conf, &parms)) {
3143 dsw_error(gettext("Volume is not in a Point-in-Time "
3144 "Copy group"), NULL);
3145 }
3146
3147 can_disable(argv[1]);
3148 flags = 0;
3149 }
3150
3151 if (group_name && !*group_name) {
3152 /* user typed iiadm -g "" -d */
3153 for (p = group_volumes; *p; p++) {
3154 parms.status = spcs_s_ucreate();
3155 parms.flags = flags;
3156 (void) strncpy(parms.shadow_vol, *p, DSW_NAMELEN);
3157 rc = do_ioctl(dsw_fd, DSWIOC_DISABLE, &parms);
3158 if (rc == -1 && errno != DSW_ENOTFOUND)
3159 dsw_error(gettext("Disable failed"),
3160 &parms.status);
3161 if (!find_shadow_config(*p, NULL, NULL))
3162 dsw_error(gettext("Volume is not in a Point-in"
3163 "-Time Copy group"), &parms.status);
3164 remove_iiset(setnumber, *p, 0);
3165 spcs_s_ufree(&parms.status);
3166 spcs_log("ii", NULL, gettext("Disabled %s"),
3167 parms.shadow_vol);
3168 }
3169 } else {
3170 if (is_exported(conf.shadow_vol)) {
3171 shd_exported = 1;
3172 }
3173 if ((strcmp(conf.master_vol, II_IMPORTED_SHADOW) == 0) &&
3174 is_exported(conf.shadow_vol)) {
3175 dsw_error(gettext(
3176 "Imported shadow not disabled"), NULL);
3177 }
3178
3179 parms.status = spcs_s_ucreate();
3180 parms.flags = flags;
3181 rc = do_ioctl(dsw_fd, DSWIOC_DISABLE, &parms);
3182 if (rc == -1 && errno != DSW_ENOTFOUND) {
3183 if (errno == DSW_EDISABLE) {
3184 /*
3185 * one or more sets within the group
3186 * couldn't disable
3187 */
3188 clean_up_after_failed_disable(&parms);
3189 } else {
3190 dsw_error(gettext("Disable failed"),
3191 &parms.status);
3192 }
3193 }
3194 spcs_log("ii", NULL, gettext("Disabled %s"), parms.shadow_vol);
3195 }
3196
3197
3198 if (group_name && *group_name) {
3199 for (p = group_volumes; *p; p++) {
3200 if (!find_shadow_config(*p, NULL, NULL)) {
3201 /* argh! */
3202 (void) fprintf(stderr,
3203 gettext("Volume '%s' is not "
3204 "in a Point-in-Time Copy group"), *p);
3205 } else {
3206 remove_iiset(setnumber, *p, 0);
3207 }
3208 }
3209 } else if (!group_name) {
3210 if (!find_shadow_config(argv[1], NULL, NULL)) {
3211 /* argh! */
3212 dsw_error(gettext("Volume is not in a Point-in-Time "
3213 "Copy group"), NULL);
3214 }
3215
3216 remove_iiset(setnumber, argv[1], shd_exported);
3217 }
3218
3219 return (0);
3220 }
3221
3222 int
3223 dsw_group_or_single_op(int argc, char *argv[], int (*op)(char *))
3224 {
3225 int rc = 0;
3226
3227 if (argc != 2)
3228 usage(gettext("Incorrect number of arguments"));
3229
3230 if (group_name) {
3231 if (find_group_members(group_name) < 1)
3232 dsw_error(gettext("Group does not exist or "
3233 "has no members"), NULL);
3234 for (; *group_volumes; group_volumes++)
3235 rc |= (*op)(*group_volumes);
3236 } else {
3237 rc = (*op)(argv[1]);
3238 }
3239 return (rc);
3240 }
3241
3242 void
3243 dsw_list_clusters(char *cluster)
3244 {
3245 dsw_aioctl_t *acopy_args;
3246 int rc, i, count;
3247 char *ptr;
3248
3249 if ((count = do_ioctl(dsw_fd, DSWIOC_LISTLEN, NULL)) < 0)
3250 dsw_error("DSWIOC_LISTLEN", NULL);
3251
3252 acopy_args = malloc(sizeof (dsw_aioctl_t) + count * DSW_NAMELEN);
3253 if (acopy_args == NULL)
3254 dsw_error(gettext("Can't get memory for list enquiry"), NULL);
3255
3256 bzero(acopy_args, sizeof (dsw_aioctl_t) + count * DSW_NAMELEN);
3257 acopy_args->count = count;
3258 acopy_args->flags = 0;
3259 acopy_args->status = spcs_s_ucreate();
3260 if (cluster)
3261 (void) strncpy(acopy_args->shadow_vol, cluster, DSW_NAMELEN);
3262
3263 rc = do_ioctl(dsw_fd, DSWIOC_CLIST, acopy_args);
3264 if (rc == -1)
3265 dsw_error(gettext("Cluster list access failure"),
3266 &acopy_args->status);
3267
3268 acopy_args->shadow_vol[DSW_NAMELEN*acopy_args->count] = NULL;
3269
3270 if (cluster) {
3271 (void) printf(gettext("Sets in cluster resource group %s:\n"),
3272 cluster);
3273 } else {
3274 (void) printf(
3275 gettext("Currently configured resource groups\n"));
3276 }
3277 for (i = 0, ptr = acopy_args->shadow_vol; *ptr &&
3278 i < acopy_args->count; i++, ptr += DSW_NAMELEN) {
3279 (void) printf(" %-64.64s\n", ptr);
3280 }
3281 }
3282
3283 void
3284 dsw_enable(int argc, char *argv[])
3285 {
3286 if (argc != 5)
3287 usage(gettext("Incorrect number of arguments"));
3288
3289 enable(argv[1], argv[2], argv[3], argv[4]);
3290 exit(0);
3291 }
3292
3293
3294 void
3295 dsw_disable(int argc, char *argv[])
3296 {
3297 (void) dsw_group_or_single_disable(argc, argv);
3298 exit(0);
3299 }
3300
3301
3302 void
3303 dsw_copy_to_shadow(int argc, char *argv[])
3304 {
3305 char **volume_list;
3306
3307 if (argc != 2)
3308 usage(gettext("Incorrect number of arguments"));
3309 if (group_name == NULL)
3310 volume_list = ++argv;
3311 else {
3312 if (find_group_members(group_name) < 1)
3313 dsw_error(gettext("Group does not exist or "
3314 "has no members"), NULL);
3315 volume_list = group_volumes;
3316 }
3317
3318 exit(do_copy(volume_list, Copy, ToShadow, WaitForStart));
3319 }
3320
3321
3322 void
3323 dsw_update_shadow(int argc, char *argv[])
3324 {
3325 char **volume_list;
3326
3327 if (argc != 2)
3328 usage(gettext("Incorrect number of arguments"));
3329 if (group_name == NULL)
3330 volume_list = ++argv;
3331 else {
3332 if (find_group_members(group_name) < 1)
3333 dsw_error(gettext("Group does not exist or "
3334 "has no members"), NULL);
3335 volume_list = group_volumes;
3336 }
3337
3338 exit(do_copy(volume_list, Update, ToShadow, WaitForStart));
3339 }
3340
3341
3342 void
3343 dsw_copy_to_master(int argc, char *argv[])
3344 {
3345 char **volume_list;
3346
3347 if (argc != 2)
3348 usage(gettext("Incorrect number of arguments"));
3349 if (group_name == NULL) {
3350 volume_list = ++argv;
3351 check_action(gettext("Overwrite master with shadow volume?"));
3352 } else {
3353 check_action(gettext("Overwrite every"
3354 " master in this group with its shadow volume?"));
3355 if (find_group_members(group_name) < 1)
3356 dsw_error(gettext("Group does not exist or "
3357 "has no members"), NULL);
3358 volume_list = group_volumes;
3359 }
3360
3361 exit(do_copy(volume_list, Copy, ToMaster, WaitForStart));
3362 }
3363
3364
3365 void
3366 dsw_update_master(int argc, char *argv[])
3367 {
3368 char **volume_list;
3369
3370 if (argc != 2)
3371 usage(gettext("Incorrect number of arguments"));
3372 if (group_name == NULL) {
3373 volume_list = ++argv;
3374 check_action(gettext("Overwrite master with shadow volume?"));
3375 } else {
3376 check_action(gettext("Overwrite every"
3377 " master in this group with its shadow volume?"));
3378 if (find_group_members(group_name) < 1)
3379 dsw_error(gettext("Group does not exist or "
3380 "has no members"), NULL);
3381 volume_list = group_volumes;
3382 }
3383
3384 exit(do_copy(volume_list, Update, ToMaster, WaitForStart));
3385 }
3386
3387
3388 void
3389 dsw_abort_copy(int argc, char *argv[])
3390 {
3391 exit(dsw_group_or_single_op(argc, argv, abort_copy));
3392 }
3393
3394
3395 void
3396 dsw_display_status(int argc, char *argv[])
3397 {
3398 dsw_config_t parms;
3399 int in_config;
3400
3401 if (argc != 2 && argc != 1)
3402 usage(gettext("Incorrect number of arguments"));
3403
3404 /* "iiadm -i" and "iiadm -i all" are equivalent */
3405 if (argc == 2 && strcmp("all", argv[1]) != 0) {
3406 in_config = find_shadow_config(argv[1], &parms, NULL);
3407 if (!in_config) {
3408 (void) printf(gettext(
3409 "Volume is not in configuration file\n"), NULL);
3410 (void) fflush(stdout);
3411 (void) strlcpy(parms.shadow_vol, argv[1], DSW_NAMELEN);
3412 }
3413 print_status(&parms, in_config);
3414 } else if (group_name) {
3415 if (find_group_members(group_name) < 1)
3416 dsw_error(gettext("Group does not exist or "
3417 "has no members"), NULL);
3418 for (; *group_volumes; group_volumes++) {
3419 in_config = find_shadow_config(*group_volumes,
3420 &parms, NULL);
3421 if (in_config)
3422 print_status(&parms, in_config);
3423 }
3424 } else {
3425 /* perform action for each line of the stored config file */
3426 for (setnumber = 1;
3427 !get_dsw_config(setnumber, &parms); setnumber++) {
3428 switch (check_cluster()) {
3429 case II_CLUSTER:
3430 if ((cfg_cluster_tag) &&
3431 (strcmp(cfg_cluster_tag,
3432 parms.cluster_tag)))
3433 continue;
3434 break;
3435 case II_CLUSTER_LCL:
3436 if (strlen(parms.cluster_tag))
3437 continue;
3438 break;
3439 }
3440 print_status(&parms, 1);
3441 }
3442 }
3443 exit(0);
3444 }
3445
3446 void
3447 dsw_display_bitmap(int argc, char *argv[])
3448 {
3449 dsw_config_t parms;
3450 int in_config;
3451
3452 if (argc != 2)
3453 usage(gettext("Incorrect number of arguments"));
3454
3455 in_config = find_shadow_config(argv[1], &parms, NULL);
3456 if (!in_config) {
3457 (void) printf(gettext(
3458 "Volume is not in configuration file\n"), NULL);
3459 (void) fflush(stdout);
3460 (void) strlcpy(parms.master_vol, argv[1], DSW_NAMELEN);
3461 }
3462
3463 bitmap_op(parms.shadow_vol, 1, 0, 0, 0);
3464 exit(0);
3465 }
3466
3467
3468 /*ARGSUSED*/
3469 void
3470 dsw_version(int argc, char *argv[])
3471 {
3472 iiversion();
3473 exit(0);
3474 }
3475
3476 void
3477 dsw_reset(int argc, char *argv[])
3478 {
3479 exit(dsw_group_or_single_op(argc, argv, reset));
3480 }
3481
3482 void
3483 dsw_overflow(int argc, char *argv[])
3484 {
3485 if (argc != 2)
3486 usage(gettext("Incorrect number of arguments"));
3487
3488 exit(overflow(argv[1]));
3489 }
3490
3491 void
3492 dsw_wait(int argc, char *argv[])
3493 {
3494 exit(dsw_group_or_single_op(argc, argv, wait_for_copy));
3495 }
3496
3497 /*ARGSUSED*/
3498 void
3499 dsw_list_volumes(int argc, char *argv[])
3500 {
3501 if (argc != 1)
3502 usage(gettext("Incorrect number of arguments"));
3503
3504 list_volumes();
3505 exit(0);
3506 }
3507
3508 void
3509 dsw_export(int argc, char *argv[])
3510 {
3511 if (argc != 2)
3512 usage(gettext("Incorrect number of arguments"));
3513
3514 exit(dsw_group_or_single_op(argc, argv, export));
3515 }
3516
3517 void
3518 dsw_detach(int argc, char *argv[])
3519 {
3520 (void) dsw_group_or_single_op(argc, argv, detach);
3521 exit(0);
3522 }
3523
3524 void
3525 import(char *shadow_volume, char *bitmap_volume)
3526 {
3527 dsw_config_t parms = {0};
3528 int rc = 0;
3529 char shd_dg[DSW_NAMELEN];
3530 char bmp_dg[DSW_NAMELEN];
3531
3532 /*
3533 * If importing a shadow volume and the shadow volume is already
3534 * configured, we only support this if we are in a Sun Cluster
3535 * and the current user specified a cluster tag of -C local
3536 */
3537 if (find_shadow_config(shadow_volume, &parms, NULL)) {
3538 dsw_error(gettext("Can't import volume on same node"), NULL);
3539 }
3540
3541 switch (check_cluster()) {
3542 case II_CLUSTER:
3543 case II_CLUSTER_LCL:
3544 (void) check_resource_group(shadow_volume);
3545 if (cfg_cluster_tag) { /* check all volumes are in same dg */
3546 if (cfg_dgname(shadow_volume, shd_dg, DSW_NAMELEN)
3547 == NULL)
3548 dsw_error(gettext("Shadow volume not in a"
3549 " disk group"), NULL);
3550 if (cfg_dgname(bitmap_volume, bmp_dg, DSW_NAMELEN)
3551 == NULL)
3552 dsw_error(gettext("Bitmap volume not in a"
3553 " disk group"), NULL);
3554 if (strcmp(bmp_dg, shd_dg) != 0)
3555 dsw_error(gettext("Bitmap volume not in"
3556 " same disk group as shadow set members"),
3557 NULL);
3558 }
3559 break;
3560 case II_NOT_CLUSTER:
3561 /* do nothing */
3562 break;
3563 default:
3564 dsw_error(gettext(
3565 "Unexpected return from check_cluster()"), NULL);
3566 }
3567
3568 /* Local configuration volumes */
3569 if (cfg_load_dsvols(cfg) < 0 || cfg_load_shadows(cfg) < 0) {
3570 dsw_error(gettext("Unable to parse config file"), NULL);
3571 }
3572
3573 reload_vols = LD_DSVOLS | LD_SHADOWS;
3574 conform_name(&shadow_volume);
3575 (void) strcpy(parms.master_vol, II_IMPORTED_SHADOW);
3576 (void) strlcpy(parms.shadow_vol, shadow_volume, DSW_NAMELEN);
3577 (void) strlcpy(parms.bitmap_vol, bitmap_volume, DSW_NAMELEN);
3578 parms.flag = DSW_GOLDEN;
3579
3580 spcs_log("ii", NULL, gettext("Import %s %s"),
3581 parms.shadow_vol, parms.bitmap_vol);
3582 parms.status = spcs_s_ucreate();
3583 rc = do_ioctl(dsw_fd, DSWIOC_IMPORT, &parms);
3584 if (rc == -1) {
3585 spcs_log("ii", NULL, gettext("Import failed %s %s"),
3586 parms.shadow_vol, parms.bitmap_vol);
3587 dsw_error(gettext("Import failed"), &parms.status);
3588 }
3589 if (perform_autosv()) {
3590 if (cfg_vol_enable(cfg, shadow_volume, cfg_cluster_tag, "ii")
3591 < 0) {
3592 dsw_error(gettext("SV-enable failed"), NULL);
3593 }
3594 /* cfg_commit is called by add_cfg_entry below */
3595 }
3596 spcs_s_ufree(&parms.status);
3597 add_cfg_entry(&parms);
3598 }
3599
3600 void
3601 dsw_import(int argc, char *argv[])
3602 {
3603 if (argc != 3)
3604 usage(gettext("Incorrect number of arguments"));
3605 import(argv[1], argv[2]);
3606
3607 exit(0);
3608 }
3609
3610 void
3611 join(char *shadow_volume, char *bitmap_file)
3612 {
3613 dsw_ioctl_t shd;
3614 dsw_config_t conf;
3615 dsw_bitmap_t parms;
3616 int rc = 0;
3617 int size;
3618 FILE *bmpfp;
3619 uchar_t *shd_bitmap = 0;
3620 ii_header_t header;
3621 char dgname[DSW_NAMELEN];
3622
3623 if (!find_shadow_config(shadow_volume, &conf, &shd))
3624 dsw_error(gettext("Volume is not in a Point-in-Time Copy "
3625 "group"), NULL);
3626
3627 /* If this is an exportable shadow in the cluster, change ctag */
3628 if (strlen(conf.cluster_tag) &&
3629 (cfg_dgname(shadow_volume, dgname, sizeof (dgname))))
3630 cfg_resource(cfg, cfg_cluster_tag = strdup(dgname));
3631
3632 if (cfg_load_dsvols(cfg) < 0 || cfg_load_shadows(cfg) < 0) {
3633 dsw_error(gettext("Unable to parse config file"), NULL);
3634 }
3635 reload_vols = LD_DSVOLS | LD_SHADOWS;
3636 conform_name(&shadow_volume);
3637
3638 if ((bmpfp = fopen(bitmap_file, "r")) == NULL) {
3639 perror(bitmap_file);
3640 (void) fprintf(stderr,
3641 gettext("Can't open imported bitmap volume\n"));
3642 exit(1);
3643 }
3644
3645 if (fread(&header, sizeof (header), 1, bmpfp) != 1) {
3646 (void) fprintf(stderr,
3647 gettext("Can't read imported bitmap volume\n"));
3648 exit(1);
3649 }
3650
3651 /* See if this is a bitmap header */
3652 switch (header.ii_magic) {
3653 case DSW_DIRTY: /* A copy of a enable bitmap volume */
3654 case DSW_CLEAN:
3655 check_action(gettext("Use the never imported bitmap?"));
3656 break;
3657 case DSW_INVALID: /* A valid diskable secondary bitmap */
3658 break;
3659 default:
3660 (void) fprintf(stderr,
3661 gettext("Secondary bitmap is not a valid bitmap volume\n"));
3662 exit(1);
3663 }
3664
3665 size = FBA_SIZE(header.ii_copyfba - header.ii_shdfba);
3666 if ((shd_bitmap = malloc(size)) == NULL) {
3667 perror("malloc");
3668 exit(1);
3669 }
3670
3671 if (fseek(bmpfp, FBA_SIZE(header.ii_shdfba), SEEK_SET)) {
3672 perror("fseek");
3673 exit(1);
3674 }
3675
3676 if (fread(shd_bitmap, 1, size, bmpfp) != size) {
3677 (void) fprintf(stderr,
3678 gettext("Can't read imported bitmap volume\n"));
3679 exit(1);
3680 }
3681
3682 (void) fclose(bmpfp);
3683
3684 (void) strlcpy(parms.shadow_vol, shadow_volume, DSW_NAMELEN);
3685 parms.shd_bitmap = shd_bitmap;
3686 parms.shd_size = size;
3687 parms.copy_bitmap = NULL;
3688 parms.copy_size = 0;
3689
3690 spcs_log("ii", NULL, gettext("Join %s %s"),
3691 parms.shadow_vol, bitmap_file);
3692 parms.status = spcs_s_ucreate();
3693 rc = do_ioctl(dsw_fd, DSWIOC_JOIN, &parms);
3694 if (rc == -1) {
3695 spcs_log("ii", NULL, gettext("Join failed %s %s"),
3696 parms.shadow_vol, bitmap_file);
3697 dsw_error(gettext("Join failed"), &parms.status);
3698 }
3699 if (perform_autosv()) {
3700 rc = cfg_vol_enable(cfg, shadow_volume, cfg_cluster_tag, "ii");
3701 if (rc < 0) {
3702 dsw_error(gettext("SV-enable failed"), NULL);
3703 }
3704 (void) cfg_commit(cfg);
3705 }
3706 spcs_s_ufree(&parms.status);
3707 }
3708
3709 int
3710 params(char *shadow_volume)
3711 {
3712 char *delay = param_delay;
3713 char *unit = param_unit;
3714 dsw_copyp_t parms;
3715 int rc = 0;
3716 int get = 0;
3717 int new_delay;
3718 int new_unit;
3719
3720 (void) strlcpy(parms.shadow_vol, shadow_volume, DSW_NAMELEN);
3721 if (delay == NULL || unit == NULL) {
3722 get = 1;
3723 parms.copy_delay = -1;
3724 parms.copy_unit = -1;
3725 } else {
3726 new_delay = parms.copy_delay = convert_int(delay);
3727 new_unit = parms.copy_unit = convert_int(unit);
3728 }
3729
3730 parms.status = spcs_s_ucreate();
3731 rc = do_ioctl(dsw_fd, DSWIOC_COPYP, &parms);
3732 if (rc == -1) {
3733 (void) fprintf(stderr,
3734 gettext("Parameter ranges are delay(%d - %d), "
3735 "units(%d - %d)\n"), MIN_THROTTLE_DELAY, MAX_THROTTLE_DELAY,
3736 MIN_THROTTLE_UNIT, MAX_THROTTLE_UNIT);
3737 dsw_error(gettext("Set Copy Parameters failed"), &parms.status);
3738 }
3739 if (!get)
3740 spcs_log("ii", NULL, gettext("Changed copy parameters %s from "
3741 "%d %d to %d %d"), parms.shadow_vol, parms.copy_delay,
3742 parms.copy_unit, new_delay, new_unit);
3743 else
3744 (void) printf(gettext("volume: %s\ncopy delay: %d\ncopy unit:"
3745 " %d\n"), parms.shadow_vol, parms.copy_delay,
3746 parms.copy_unit);
3747 spcs_s_ufree(&parms.status);
3748 return (0);
3749 }
3750
3751 static void
3752 do_attach(dsw_config_t *parms)
3753 {
3754 dsw_config_t io;
3755 int rc;
3756 int check = 0;
3757
3758 spcs_log("ii", NULL, gettext("Attach %s %s"),
3759 parms->shadow_vol, parms->bitmap_vol);
3760 parms->status = spcs_s_ucreate();
3761 rc = do_ioctl(dsw_fd, DSWIOC_OATTACH, parms);
3762 if (rc == -1) {
3763 check = 1;
3764 /* if overflow() fails, it calls dsw_error to exit */
3765 (void) overflow(parms->bitmap_vol);
3766 }
3767 spcs_s_ufree(&parms->status);
3768 if (check == 1) {
3769 if (!find_shadow_config(parms->shadow_vol, &io, NULL))
3770 dsw_error(
3771 gettext("Volume is not in a Point-in-Time Copy "
3772 "group"), NULL);
3773 (void) strlcpy(io.bitmap_vol, parms->bitmap_vol, DSW_NAMELEN);
3774 io.status = spcs_s_ucreate();
3775 if (do_ioctl(dsw_fd, DSWIOC_OATTACH, &io) == -1) {
3776 spcs_log("ii", NULL, gettext("Attach failed %s %s"),
3777 io.shadow_vol, parms->bitmap_vol);
3778 dsw_error(gettext("Attach failed"), &io.status);
3779 }
3780 spcs_s_ufree(&io.status);
3781 }
3782 }
3783
3784 int
3785 attach(char *shadow_volume)
3786 {
3787 dsw_config_t parms;
3788 dsw_stat_t args;
3789 char shd_dg[DSW_NAMELEN];
3790 char ovr_dg[DSW_NAMELEN];
3791
3792 switch (check_cluster()) {
3793 case II_CLUSTER:
3794 case II_CLUSTER_LCL:
3795 (void) check_resource_group(shadow_volume);
3796 if (cfg_cluster_tag) { /* check all volumes are in same dg */
3797 if (cfg_dgname(shadow_volume, shd_dg, DSW_NAMELEN)
3798 == NULL)
3799 dsw_error(gettext("Shadow volume not in a"
3800 " disk group"), NULL);
3801 if (cfg_dgname(overflow_file, ovr_dg, DSW_NAMELEN)
3802 == NULL)
3803 dsw_error(gettext("Overflow volume not in a"
3804 " disk group"), NULL);
3805 if (strcmp(ovr_dg, shd_dg) != 0)
3806 dsw_error(gettext("Overflow volume not in"
3807 " same disk group as shadow set members"),
3808 NULL);
3809 }
3810 break;
3811 case II_NOT_CLUSTER:
3812 /* do nothing */
3813 break;
3814 default:
3815 dsw_error(gettext(
3816 "Unexpected return from check_cluster()"), NULL);
3817 }
3818
3819 /* assure that the overflow_file is not an II volume */
3820 if (find_any_cf_line(overflow_file))
3821 dsw_error(gettext(
3822 "Overflow volume is already in a Point-in-Time Copy "
3823 "group"), NULL);
3824
3825 /* use find_shadow_config() to find setnumber */
3826 if (!find_shadow_config(shadow_volume, &parms, NULL))
3827 dsw_error(gettext("Volume is not in a Point-in-Time Copy "
3828 "group"), NULL);
3829
3830 /* can only attach an overflow volume to dependent, compact shadow */
3831 (void) strlcpy(args.shadow_vol, shadow_volume, DSW_NAMELEN);
3832
3833 args.status = spcs_s_ucreate();
3834 if ((do_ioctl(dsw_fd, DSWIOC_STAT, &args) == -1) ||
3835 !(args.stat & DSW_TREEMAP))
3836 dsw_error(gettext("Not a compact dependent shadow"), NULL);
3837
3838 /* bitmap_vol is overloaded */
3839 (void) strlcpy(parms.bitmap_vol, overflow_file, DSW_NAMELEN);
3840
3841 do_attach(&parms);
3842
3843 /* add overflow to cfg line */
3844 (void) sprintf(key, "ii.set%d.overflow", setnumber);
3845 if (cfg_put_cstring(cfg, key, overflow_file,
3846 strlen(overflow_file)) < 0) {
3847 perror("cfg_put_cstring");
3848 }
3849 (void) cfg_commit(cfg);
3850 return (0);
3851 }
3852
3853 void
3854 dsw_join(int argc, char *argv[])
3855 {
3856 if (argc != 3)
3857 usage(gettext("Incorrect number of arguments"));
3858
3859 join(argv[1], argv[2]);
3860 exit(0);
3861 }
3862
3863 void
3864 dsw_params(int argc, char *argv[])
3865 {
3866 if (argc != 4 && argc != 2 && argc != 0)
3867 usage(gettext("Incorrect number of arguments"));
3868
3869 if ((argc == 4) || (argc == 2)) {
3870 param_delay = argv[1];
3871 param_unit = argv[2];
3872 if (argc == 4) {
3873 argv[1] = argv[3];
3874 argv[2] = NULL;
3875 }
3876 }
3877 exit(dsw_group_or_single_op(2, argv, params));
3878 }
3879
3880 /*ARGSUSED*/
3881 void
3882 dsw_attach(int argc, char *argv[])
3883 {
3884 overflow_file = argv[1];
3885 argv[1] = argv[2];
3886 (void) dsw_group_or_single_op(2, argv, attach);
3887 exit(0);
3888 }
3889
3890 /*ARGSUSED*/
3891 void
3892 dsw_olist(int argc, char *argv[])
3893 {
3894 char *sp, *overflow_list, **vol;
3895 int count, i;
3896 ENTRY item, *found;
3897 char key[ CFG_MAX_KEY ], buf[ CFG_MAX_BUF ];
3898
3899 overflow_list = get_overflow_list();
3900
3901 /* count entries */
3902 count = 0;
3903 for (sp = overflow_list; *sp; sp += DSW_NAMELEN) {
3904 ++count;
3905 }
3906
3907 /* create hash (adding room for suspended overflow volumes) */
3908 if (hcreate(count + 1024) == 0) {
3909 dsw_error(gettext("Out of memory creating lookup table"), NULL);
3910 /*NOTREACHED*/
3911 }
3912
3913 if (count > 0) {
3914 /* create memory to store copy of list */
3915 vol = (char **)calloc(count, sizeof (char *));
3916 if (!vol) {
3917 dsw_error(
3918 gettext("Out of memory creating lookup table"),
3919 NULL);
3920 /*NOTREACHED*/
3921 }
3922
3923 /* fill hash */
3924 for (i = 0, sp = overflow_list; *sp; sp += DSW_NAMELEN, i++) {
3925
3926 /* make copy of string */
3927 vol[ i ] = (char *)malloc(DSW_NAMELEN + 1);
3928 (void) strlcpy(vol[ i ], sp, DSW_NAMELEN);
3929
3930 item.key = vol[ i ];
3931 item.data = (char *)0;
3932 (void) hsearch(item, ENTER);
3933 }
3934 }
3935
3936 /* loop through config file entries */
3937 i = 0;
3938 cfg_rewind(cfg, CFG_SEC_CONF);
3939
3940 /*CONSTCOND*/
3941 while (1) {
3942 ++i;
3943 (void) snprintf(key, CFG_MAX_KEY, "ii.set%d.overflow", i);
3944 if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0) {
3945 break;
3946 }
3947
3948 /* has this set got an overflow volume? */
3949 if (!*buf) {
3950 continue;
3951 }
3952
3953 /* look up overflow in hash */
3954 item.key = buf;
3955 if (count > 0 && (found = hsearch(item, FIND)) != NULL) {
3956 if (0 == (int)found->data) {
3957 (void) printf("%s\n", buf);
3958 found->data = (char *)1;
3959 (void) hsearch(*found, ENTER);
3960 }
3961 } else {
3962 /* must be part of a suspended set */
3963 (void) printf("%s (attached to suspended set)\n", buf);
3964 item.key = buf;
3965 item.data = (char *)1;
3966 (void) hsearch(item, ENTER);
3967 }
3968 }
3969
3970 exit(0);
3971 }
3972
3973 void
3974 dsw_ostat(int argc, char *argv[])
3975 {
3976 dsw_ostat_t args;
3977 int stat_flags;
3978
3979 if (argc != 2)
3980 usage(gettext("Incorrect number of arguments"));
3981
3982 (void) strlcpy(args.overflow_vol, argv[1], DSW_NAMELEN);
3983
3984 args.status = spcs_s_ucreate();
3985 if (do_ioctl(dsw_fd, DSWIOC_OSTAT2, &args) == -1)
3986 dsw_error(gettext("Stat failed"), &args.status);
3987 spcs_s_ufree(&args.status);
3988
3989 if ((args.hversion >= 1) && (args.hmagic == II_OMAGIC)) {
3990 stat_flags = args.flags;
3991 if (stat_flags & IIO_CNTR_INVLD)
3992 (void) printf(gettext("Clean shutdown of volume "
3993 "sets associated with overflow volume "
3994 "did not occur.\n"
3995 "Overflow counters will be inconsistent "
3996 "until new point-in-time(s) are taken.\n"));
3997 }
3998 (void) printf(gettext("Total number of attached shadows: %d\n"),
3999 args.drefcnt);
4000 (void) printf(gettext("Number of currently attached shadows: %d\n"),
4001 args.crefcnt);
4002 (void) printf(gettext("Total number of chunks: %lld\n"), args.nchunks);
4003 (void) printf(gettext("Number of chunks ever allocated: %lld\n"),
4004 args.used);
4005 (void) printf(gettext("Number of used chunks: %lld\n"),
4006 (args.nchunks - args.unused));
4007 (void) printf(gettext("Number of unused chunks: %lld\n"), args.unused);
4008 exit(0);
4009 }
4010
4011 /*ARGSUSED*/
4012 void
4013 dsw_move_2_group(int argc, char *argv[])
4014 {
4015 dsw_config_t parms;
4016 dsw_movegrp_t movegrp;
4017 grptag_t *gdata;
4018 int waserr = 0;
4019
4020 /* handle move to NULL group, or group of all spaces or tabs */
4021 (void) strncpy(movegrp.new_group, group_name, DSW_NAMELEN);
4022 if ((strlen(group_name) == 0) || (strcspn(group_name, " \t") == 0)) {
4023 group_name = "-";
4024 bzero(movegrp.new_group, DSW_NAMELEN);
4025 gdata = NULL;
4026 } else {
4027 /* get the ctag for this group (if any) */
4028 gdata = (grptag_t *)nsc_lookup(volhash, group_name);
4029 }
4030
4031 movegrp.status = spcs_s_ucreate();
4032
4033 for (++argv; *argv; argv++) {
4034 if (!find_shadow_config(*argv, &parms, NULL))
4035 dsw_error(gettext("Volume is not in a Point-in-Time "
4036 "Copy group"), NULL);
4037
4038 /* ensure the ctag matches the group */
4039 if (gdata && *gdata->ctag) {
4040 if (strncmp(parms.cluster_tag, gdata->ctag,
4041 DSW_NAMELEN) != 0) {
4042 (void) fprintf(stderr, "%s: %s %s %s\n", cmdnam,
4043 gettext("unable to move set"), *argv,
4044 gettext("into new group - cluster "
4045 "resource mismatch"));
4046 waserr = 1;
4047 continue;
4048 }
4049 }
4050
4051 /* move the set in the kernel */
4052 (void) strncpy(movegrp.shadow_vol, parms.shadow_vol,
4053 DSW_NAMELEN);
4054 if (do_ioctl(dsw_fd, DSWIOC_MOVEGRP, &movegrp) < 0)
4055 dsw_error(gettext("Failed to move group in kernel"),
4056 NULL);
4057
4058 /* now update the config */
4059 (void) sprintf(key, "ii.set%d.group", setnumber);
4060 if (cfg_put_cstring(cfg, key, group_name,
4061 strlen(group_name)) < 0) {
4062 perror("cfg_put_cstring");
4063 }
4064 (void) cfg_commit(cfg);
4065 }
4066 spcs_s_ufree(&movegrp.status);
4067 cfg_close(cfg);
4068 exit(waserr);
4069 }
4070
4071 void
4072 dsw_list_groups()
4073 {
4074 FILE *pfp;
4075
4076 if ((pfp = popen("/usr/bin/sort -u", "w")) == NULL) {
4077 dsw_error(gettext("Can't open sort program"), NULL);
4078 }
4079
4080 (void) fflush(stdout);
4081 for (setnumber = 1; /*CSTYLED*/; setnumber++) {
4082 (void) snprintf(key, sizeof (key), "ii.set%d.group", setnumber);
4083 if (cfg_get_cstring(cfg, key, buf, sizeof (buf)) < 0)
4084 break;
4085
4086 /* skip if shadow set is not in any group */
4087 if (strcmp(buf, "") == 0)
4088 continue;
4089 (void) fprintf(pfp, "%s\n", buf);
4090 }
4091 (void) pclose(pfp);
4092 }
4093
4094 void
4095 dsw_list_group_volumes()
4096 {
4097 FILE *pfp;
4098
4099 if (find_group_members(group_name) < 1)
4100 dsw_error(gettext("Group does not exist or has no members"),
4101 NULL);
4102
4103 if ((pfp = popen("/usr/bin/sort -u", "w")) == NULL) {
4104 dsw_error(gettext("Can't open sort program"), NULL);
4105 }
4106
4107 (void) fflush(stdout);
4108 for (; *group_volumes; group_volumes++)
4109 (void) fprintf(pfp, "%s\n", *group_volumes);
4110 (void) pclose(pfp);
4111 }
4112
4113 static void
4114 load_ii_vols(CFGFILE *cfg)
4115 {
4116 int set, entries;
4117 char *mst, *shd, *buf, **entry;
4118 char *ctag, *group;
4119 mstcount_t *mdata;
4120 shdvol_t *sdata;
4121 grptag_t *gdata;
4122 static int whinged = 0;
4123
4124 if (volhash) {
4125 return;
4126 }
4127
4128 volhash = nsc_create_hash();
4129 cfg_rewind(cfg, CFG_SEC_CONF);
4130 entries = cfg_get_section(cfg, &entry, "ii");
4131 for (set = 1; set <= entries; set++) {
4132 buf = entry[set - 1];
4133
4134 /* grab master volume name */
4135 mst = strtok(buf, " ");
4136 if (!mst) {
4137 free(buf);
4138 break;
4139 }
4140
4141 /* grab shadow, group & cnode fields */
4142 shd = strtok(NULL, " ");
4143 (void) strtok(NULL, " "); /* bitmap */
4144 (void) strtok(NULL, " "); /* mode */
4145 (void) strtok(NULL, " "); /* overflow */
4146 ctag = strtok(NULL, " "); /* cnode */
4147 (void) strtok(NULL, " "); /* options */
4148 group = strtok(NULL, " "); /* group */
4149
4150 /* Fix optional tags */
4151 if (ctag)
4152 ctag += strspn(ctag, "-");
4153 if (group)
4154 group += strspn(group, "-");
4155
4156 /* If cluster tags don't match, skip record */
4157 if ((cfg_cluster_tag && strcmp(ctag, cfg_cluster_tag)) ||
4158 (!cfg_cluster_tag && strlen(ctag))) {
4159 free(buf);
4160 continue;
4161 }
4162
4163 /* master volume, may be duplicates */
4164 mdata = (mstcount_t *)nsc_lookup(volhash, mst);
4165 if (mdata) {
4166 ++mdata->count;
4167 } else {
4168 mdata = (mstcount_t *)malloc(sizeof (mstcount_t));
4169 mdata->count = 1;
4170 (void) nsc_insert_node(volhash, mdata, mst);
4171 }
4172
4173 /* grab shadow volume name */
4174 sdata = (shdvol_t *)malloc(sizeof (shdvol_t));
4175 (void) strncpy(sdata->master, mst, DSW_NAMELEN);
4176 (void) nsc_insert_node(volhash, sdata, shd);
4177
4178 /* No need to continue if no groups or ctags */
4179 if (!group || !*group || !ctag || !*ctag) {
4180 free(buf);
4181 continue;
4182 }
4183
4184 gdata = (grptag_t *)nsc_lookup(volhash, group);
4185 if (gdata) {
4186 /* group already exists - check ctag */
4187 if (*ctag &&
4188 (strncmp(ctag, gdata->ctag, DSW_NAMELEN) != 0)) {
4189 if (!whinged) {
4190 (void) printf(gettext(
4191 "Warning: multiple "
4192 "cluster resource groups "
4193 "defined within a single "
4194 "I/O group\n"));
4195 whinged = 1;
4196 }
4197 }
4198 } else {
4199 gdata = (grptag_t *)malloc(sizeof (grptag_t));
4200 (void) strncpy(gdata->ctag, ctag, DSW_NAMELEN);
4201 (void) nsc_insert_node(volhash, gdata, group);
4202 }
4203
4204 free(buf);
4205 }
4206
4207 /* free up any leftovers */
4208 while (set < entries)
4209 free(entry[set++]);
4210 if (entries)
4211 free(entry);
4212 }
4213
4214 static void
4215 unload_ii_vols()
4216 {
4217 nsc_remove_all(volhash, free);
4218 volhash = 0;
4219 }
4220
4221 static int
4222 perform_autosv()
4223 {
4224 static int result;
4225 static int calculated = 0;
4226 int rc;
4227
4228 #ifdef DEBUG
4229 if (getenv("II_SET_CLUSTER"))
4230 return (1);
4231 #endif
4232
4233 if (calculated) {
4234 return (result);
4235 }
4236
4237 /*
4238 * we only perform auto-sv if we're in a sun cluster or if
4239 * we're on a standalone system. I.e. we don't do auto-sv on Harry
4240 */
4241 rc = check_cluster();
4242
4243 if (II_NOT_CLUSTER == rc) {
4244 result = 1;
4245 } else {
4246 result = cfg_issuncluster();
4247 }
4248
4249 calculated = 1;
4250 return (result);
4251 }
4252
4253 /*
4254 * Returns true if set has had the shadow volume exported.
4255 * Returns false if shadow volume is not exported, or set is suspended.
4256 */
4257 static int
4258 is_exported(char *set)
4259 {
4260 dsw_stat_t args;
4261 int rc;
4262
4263 (void) strlcpy(args.shadow_vol, set, DSW_NAMELEN);
4264 args.status = spcs_s_ucreate();
4265
4266 rc = do_ioctl(dsw_fd, DSWIOC_STAT, &args);
4267 spcs_s_ufree(&args.status);
4268
4269 if (-1 == rc) {
4270 /* set must be suspended, or being disabled */
4271 return (0);
4272 }
4273
4274 return ((args.stat & DSW_SHDEXPORT) == DSW_SHDEXPORT);
4275 }
4276
4277 static void
4278 conform_name(char **path)
4279 {
4280 char *cfgname;
4281 int rc = cfg_get_canonical_name(cfg, *path, &cfgname);
4282
4283 if (rc < 0) {
4284 dsw_error(gettext("Unable to parse config file"), NULL);
4285 }
4286 if (rc) {
4287 (void) printf(" '%s'\n%s\n '%s'\n", *path,
4288 gettext("is currently configured as"), cfgname);
4289 check_action(gettext("Perform operation with indicated volume"
4290 " name?"));
4291 *path = cfgname;
4292 /*
4293 * NOTE: *path ought to be deallocated ('free(*path)') after
4294 * we're done with it, but since this routine is called just
4295 * before we exit, it doesn't really matter
4296 */
4297 }
4298 }
4299
4300 /*
4301 * verify_groupname(char *, int);
4302 *
4303 * Check the group name for the following rules:
4304 * 1. The name does not start with a '-'
4305 * 2. The name does not contain any space characters as defined by
4306 * isspace(3C).
4307 * If either of these rules are broken, error immediately. The check for a
4308 * leading dash can be skipped if the 'testDash' argument is false. This is to
4309 * allow for the '-g -L' functionality.
4310 *
4311 */
4312 static void
4313 verify_groupname(char *grp, int testDash)
4314 {
4315 int i;
4316
4317 if (testDash && grp[0] == '-') {
4318 errno = EINVAL;
4319 dsw_error(gettext("group name cannot start with a '-'"), NULL);
4320 }
4321
4322 for (i = 0; grp[i] != '\0'; i++) {
4323 if (isspace(grp[i])) {
4324 errno = EINVAL;
4325 dsw_error(gettext("group name cannot contain a space"),
4326 NULL);
4327 }
4328 }
4329 }
4330
4331 void
4332 check_iishadow(char *shadow_vol) {
4333 int i;
4334 int entries;
4335 char **entry;
4336 char *shost;
4337 char *svol;
4338 char *buf;
4339 void *librdc;
4340
4341 /*
4342 * See if librdc is around
4343 * If not, we can just return
4344 */
4345 if (librdc = dlopen(RDC_LIB, RTLD_LAZY | RTLD_GLOBAL))
4346 self_check = (int (*)(char *)) dlsym(librdc, "self_check");
4347 else {
4348 return;
4349 }
4350
4351 entry = NULL;
4352 entries = cfg_get_section(cfg, &entry, "sndr");
4353 for (i = 0; i < entries; i++) {
4354 buf = entry[i];
4355
4356 (void) strtok(buf, " "); /* phost */
4357 (void) strtok(NULL, " "); /* primary */
4358 (void) strtok(NULL, " "); /* pbitmap */
4359 shost = strtok(NULL, " "); /* shost */
4360 svol = strtok(NULL, " "); /* secondary */
4361
4362 if (self_check(shost) && (strcmp(shadow_vol, svol) == 0)) {
4363 free(buf);
4364 if (entries)
4365 free(entry);
4366 errno = EINVAL;
4367 dsw_error(gettext(
4368 "shadow volume is in use as SNDR secondary volume"),
4369 NULL);
4370 }
4371 free(buf);
4372 }
4373
4374 (void) dlclose(librdc);
4375 if (entries)
4376 free(entry);
4377 }
unleashed repo fork