xref: /titanic_41/usr/src/cmd/avs/dsw/iiboot.c (revision f3312ec0e8acbd249df97358fb8c3ca92f4e089c) 
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/wait.h>
28 #include <stdio.h>
29 #include <sys/param.h>
30 #include <errno.h>
31 #include <limits.h>
32 #include <fcntl.h>
33 #include <strings.h>
34 #include <stdlib.h>
35 #include <unistd.h>
36 #include <signal.h>
37 
38 #include <locale.h>
39 #include <langinfo.h>
40 #include <libintl.h>
41 #include <stdarg.h>
42 #include <ctype.h>
43 
44 #include <sys/nsctl/cfg.h>
45 
46 #include <sys/unistat/spcs_s.h>
47 #include <sys/unistat/spcs_s_u.h>
48 #include <sys/unistat/spcs_errors.h>
49 
50 #include <sys/nsctl/dsw.h>
51 #include <sys/nskernd.h>
52 
53 #define	MAX_PROCESSES 64
54 
55 int parseopts(int, char **, int *);
56 int read_resume_cfg();
57 int read_suspend_cfg();
58 void iiboot_usage(void);
59 extern char *basename(char *);
60 
61 dsw_config_t *resume_list = 0;
62 dsw_ioctl_t *suspend_list = 0;
63 int	n_structs;
64 char *program;
65 char *cfg_cluster_tag = NULL;
66 
67 volatile int fork_cnt;
68 volatile int fork_rc;
69 
70 static void
71 iiboot_msg(char *prefix, spcs_s_info_t *status, char *string, va_list ap)
72 {
73 	if (status) {
74 		(void) fprintf(stderr, "II: %s\n", prefix);
75 		spcs_s_report(*status, stderr);
76 		spcs_s_ufree(status);
77 	} else {
78 		(void) fprintf(stderr, "%s: %s: ", program, prefix);
79 	}
80 
81 	if (string && *string != '\0') {
82 		(void) vfprintf(stderr, string, ap);
83 	}
84 
85 	(void) fprintf(stderr, "\n");
86 }
87 
88 static void
89 iiboot_err(spcs_s_info_t *status, char *string, ...)
90 {
91 	va_list ap;
92 	va_start(ap, string);
93 
94 	iiboot_msg(gettext("Error"), status, string, ap);
95 
96 	va_end(ap);
97 	exit(1);
98 }
99 
100 static void
101 iiboot_warn(spcs_s_info_t *status, char *string, ...)
102 {
103 	va_list ap;
104 	va_start(ap, string);
105 
106 	iiboot_msg(gettext("warning"), status, string, ap);
107 
108 	va_end(ap);
109 }
110 
111 /* ARGSUSED */
112 static void
113 sigchld(int sig)
114 {
115 	int wait_loc = 0;
116 
117 	(void) wait(&wait_loc);
118 	if (WIFEXITED(wait_loc) && (WEXITSTATUS(wait_loc) == 0)) {
119 		;
120 		/*EMPTY*/
121 	} else {
122 		fork_rc = WEXITSTATUS(wait_loc);
123 	}
124 
125 	if (fork_cnt > 0)
126 		--fork_cnt;
127 }
128 
129 
130 int
131 #ifdef lint
132 iiboot_lintmain(int argc, char *argv[])
133 #else
134 main(int argc, char *argv[])
135 #endif
136 {
137 	int pairs;
138 	pid_t pid = 0;
139 	int flag = 0;
140 	int i, j;
141 	int rc;
142 	int	ioctl_fd;
143 	void *ioarg;
144 	dsw_ioctl_t *ii_iop, ii_suspend;
145 	dsw_list_t args = {0};
146 	dsw_config_t *ii_cfgp, *lp = NULL;
147 	spcs_s_info_t ustatus;
148 	int max_processes = MAX_PROCESSES;
149 
150 	(void) setlocale(LC_ALL, "");
151 	(void) textdomain("ii");
152 
153 	program = strdup(basename(argv[0]));
154 
155 	if ((ioctl_fd = open(DSWDEV, O_RDWR, 0)) == -1) {
156 		spcs_log("ii", NULL, "iiboot open %s failed, errno %d",
157 			DSWDEV, errno);
158 		iiboot_err(NULL,
159 		    gettext("Failed to open Point-in-Time Copy control "
160 			    "device"));
161 	}
162 
163 	if (parseopts(argc, argv, &flag))
164 		return (1);
165 
166 	if (flag == DSWIOC_RESUME)
167 		pairs = read_resume_cfg();
168 	else
169 		pairs = -1;
170 
171 	if (pairs == 0) {
172 #ifdef DEBUG
173 		iiboot_err(NULL,
174 		    gettext("Config contains no Point-in-Time Copy sets"));
175 #endif
176 		return (0);
177 	}
178 
179 	if (cfg_cluster_tag == NULL && flag != DSWIOC_RESUME) {
180 		if (ioctl(ioctl_fd, DSWIOC_SHUTDOWN, 0) < 0) {
181 			spcs_log("ii", &ustatus, "iiboot shutdown failed");
182 			iiboot_err(NULL, gettext("SHUTDOWN ioctl error"));
183 		}
184 		return (0);
185 	} else if (cfg_cluster_tag != NULL && flag == DSWIOC_SUSPEND) {
186 		bzero(&ii_suspend, sizeof (dsw_ioctl_t));
187 		ii_suspend.status = spcs_s_ucreate();
188 		ii_suspend.flags = CV_IS_CLUSTER;
189 		(void) strncpy(ii_suspend.shadow_vol, cfg_cluster_tag,
190 		    DSW_NAMELEN);
191 		rc = ioctl(ioctl_fd, flag, &ii_suspend);
192 		if ((rc) && (errno != DSW_ECNOTFOUND)) {
193 			spcs_log("ii", &ii_suspend.status,
194 			    "iiboot resume cluster %s failed", cfg_cluster_tag);
195 			iiboot_err(&ii_suspend.status, gettext("ioctl error"));
196 			spcs_s_ufree(&ii_suspend.status);
197 			return (-1);
198 		}
199 		spcs_s_ufree(&ii_suspend.status);
200 		return (0);
201 
202 	} else if ((cfg_cluster_tag != NULL) && (flag == DSWIOC_RESUME)) {
203 		/*
204 		 * If we are running in a Sun Cluster, this is a resume
205 		 * operation, get a list of all shadow volumes, where the
206 		 * shadow volumes match the shadows of the sets being resumed
207 		 */
208 		rc = ioctl(ioctl_fd, DSWIOC_LISTLEN, &args);
209 		if (rc == -1) {
210 			spcs_log("ii", NULL,
211 				"iiboot get LIST failed, errno %d", errno);
212 			iiboot_err(NULL,
213 				gettext("Failed to get LIST of Point-in-Time "
214 				    "sets"));
215 			return (-1);
216 		}
217 
218 		args.status = spcs_s_ucreate();
219 		args.list_used = 0;
220 		args.list_size = rc + 4;
221 		lp = args.list = (dsw_config_t *)
222 		    malloc(args.list_size * sizeof (dsw_config_t));
223 		if (args.list == NULL) {
224 			iiboot_err(NULL,
225 				gettext("Failed to allocate memory"));
226 		}
227 		if (ioctl(ioctl_fd, DSWIOC_LIST, &args)  == -1) {
228 			spcs_log("ii", &args.status, "Failed to get LIST");
229 			iiboot_err(&args.status, gettext("ioctl error"));
230 		}
231 		spcs_s_ufree(&args.status);
232 
233 		/* Remove all elements that are not in the resume list */
234 		for (j = args.list_used; j; j--) {
235 			for (i = 0; i < pairs; i++) {
236 				if (strcmp(lp->shadow_vol,
237 				    resume_list[i].shadow_vol) == 0) {
238 					if (strlen(lp->cluster_tag) == 0) {
239 						lp++;
240 						break;
241 					}
242 				}
243 			}
244 			if (i != pairs)
245 				continue;
246 			(void) memmove(lp, lp + 1, j * sizeof (dsw_config_t));
247 			args.list_used--;
248 		}
249 	}
250 
251 	(void) sigset(SIGCHLD, sigchld);
252 	fork_cnt = fork_rc = 0;
253 	for (i = 0; i < pairs; i++) {
254 		ustatus = spcs_s_ucreate();
255 		if (flag == DSWIOC_RESUME) {
256 			ioarg = (void *) (ii_cfgp = (resume_list + i));
257 			ii_cfgp->status = ustatus;
258 			pid = fork();
259 		} else {
260 			ioarg = (void *) (ii_iop = (suspend_list + i));
261 			ii_iop->status = ustatus;
262 		}
263 		while (pid == -1) {		/* error forking */
264 			perror("fork");
265 
266 			/* back off on the max processes and try again */
267 			--max_processes;
268 			if (fork_cnt > 0) {
269 				(void) pause();
270 			}
271 			pid = fork();
272 		}
273 
274 		if (pid > 0) {		/* this is parent process */
275 			++fork_cnt;
276 			while (fork_cnt > MAX_PROCESSES) {
277 				(void) pause();
278 			}
279 			continue;
280 		}
281 
282 		rc = ioctl(ioctl_fd, flag, ioarg);
283 		if (rc == SPCS_S_ERROR) {
284 			if (flag == DSWIOC_RESUME)
285 				spcs_log("ii", &ustatus,
286 					"iiboot resume %s failed",
287 					ii_cfgp->shadow_vol);
288 			else
289 				spcs_log("ii", &ustatus,
290 					"iiboot suspend %s failed",
291 					ii_iop->shadow_vol);
292 			iiboot_err(&ustatus, gettext("ioctl error"));
293 		}
294 		/* Resuming child */
295 		spcs_s_ufree(&ustatus);
296 		if (flag == DSWIOC_RESUME)
297 			exit(0);
298 	}
299 
300 	/*
301 	 * Allow all processes to finish up before exiting
302 	 * Set rc for success
303 	 */
304 	while (fork_cnt > 0) {
305 		(void) alarm(60);	/* wake up in 60 secs just in case */
306 		(void) pause();
307 	}
308 	(void) alarm(0);
309 
310 	/* Disable duplicate shadows that were part of the implicit join */
311 	if ((j = args.list_used) != 0) {
312 		int setno;
313 		char key[CFG_MAX_KEY], buf[CFG_MAX_BUF], sn[CFG_MAX_BUF];
314 		CFGFILE *cfg;
315 		char *mst, *shd, *ctag;
316 		pid_t pid = fork();
317 
318 		if (pid == -1) {
319 			iiboot_err(NULL, gettext("Failed to fork"));
320 			return (errno);
321 		} else if (pid > 0) {
322 			return (0);	/* Parent, OK exit */
323 		}
324 
325 		for (j = args.list_used, lp = args.list; j; j--, lp++) {
326 		    setno = 0;
327 		    while (++setno) {
328 
329 			/*
330 			 * Open the configuration database
331 			 */
332 			if (!(cfg = cfg_open(""))) {
333 			    iiboot_err(NULL, gettext("Failed to open dscfg"));
334 			    return (-1);
335 			}
336 
337 			/* Sooner or later, this lock will be free */
338 			while (!cfg_lock(cfg, CFG_WRLOCK))
339 				(void) sleep(2);
340 
341 			(void) snprintf(key, CFG_MAX_KEY, "ii.set%d", setno);
342 			if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0) {
343 				cfg_close(cfg);
344 				break;
345 			}
346 
347 			/* For imported shadows, master must be special tag */
348 			mst = strtok(buf, " ");		/* master */
349 			shd = strtok(NULL, " ");	/* shadow */
350 			(void) strtok(NULL, " ");	/* bitmap */
351 			(void) strtok(NULL, " ");	/* mode */
352 			(void) strtok(NULL, " ");	/* overflow */
353 			ctag = strtok(NULL, " ");	/* cnode */
354 
355 			/*
356 			 * For this record to be processed, the shadow volume
357 			 * name must match and the cluster tag must be blank
358 			 */
359 			if (strcmp(lp->shadow_vol, shd) || strcmp(ctag, "-")) {
360 				cfg_close(cfg);
361 				continue;
362 			}
363 
364 			/* Derrive local cluster tag */
365 			if (cfg_l_dgname(lp->shadow_vol, sn, sizeof (sn)))
366 				ctag = sn;
367 			else
368 				iiboot_err(NULL, gettext(
369 					"Failed to device group for shadow %s"),
370 					lp->shadow_vol);
371 
372 			/* disable master volume if not imported */
373 			if (strcmp(mst, II_IMPORTED_SHADOW))
374 			    if (cfg_vol_disable(cfg, mst, cfg_cluster_tag,
375 				"ii") < 0)
376 				iiboot_err(NULL, gettext(
377 				    "SV disable of master failed"));
378 
379 			/*
380 			 * Delete the Imported Shadow set
381 			 */
382 			if (cfg_put_cstring(cfg, key, NULL, 0) < 0) {
383 				iiboot_err(NULL, gettext(
384 					"Failed to delete Imported shadow %s"),
385 					lp->shadow_vol);
386 			}
387 
388 			/*
389 			 * SV disable shadow volume
390 			 */
391 			if (cfg_vol_disable(cfg, shd, NULL, "ii") < 0)
392 				iiboot_err(NULL, gettext(
393 					"SV disable of shadow failed"));
394 
395 			/*
396 			 * Commit the delete
397 			 */
398 			(void) cfg_commit(cfg);
399 			cfg_close(cfg);
400 
401 			/*
402 			 * Open the configuration database
403 			 */
404 			if (!(cfg = cfg_open(""))) {
405 			    iiboot_err(NULL, gettext("Failed to open dscfg"));
406 			    return (-1);
407 			}
408 
409 			/* Sooner or later, this lock will be free */
410 			while (!cfg_lock(cfg, CFG_WRLOCK))
411 				(void) sleep(2);
412 
413 			/* Set cluster tag for Shadow volume */
414 			(void) cfg_vol_enable(cfg, shd, ctag, "ii");
415 
416 
417 			/*
418 			 * Commit the delete
419 			 */
420 			(void) cfg_commit(cfg);
421 			cfg_close(cfg);
422 		    }
423 		}
424 	}
425 	return (fork_rc);
426 }
427 
428 static int
429 set_is_offline(char *cflags)
430 {
431 	unsigned int flags;
432 	int conv;
433 
434 	if (!cflags || !*cflags)
435 		return (0);
436 
437 	/* convert flags to an int */
438 	conv = sscanf(cflags, "%x", &flags);
439 	return ((conv == 1) && ((flags & DSW_OFFLINE) != 0));
440 }
441 
442 /*
443  * read_resume_cfg()
444  *
445  * DESCRIPTION: Read the relevant config info via libcfg
446  *
447  * Outputs:
448  *	int i			Number of Point-in-Time Copy sets
449  *
450  * Side Effects: The 0 to i-1 entries in the resume_list are filled.
451  *
452  */
453 
454 int
455 read_resume_cfg()
456 {
457 	CFGFILE *cfg;
458 	int i;
459 	char *buf, **entry, *mst, *shd, *bmp, *ctag, *opt, *ptr;
460 	int valid_sets;
461 	dsw_config_t *p;
462 	static int offset = sizeof (NSKERN_II_BMP_OPTION);
463 
464 	spcs_log("ii", NULL, "iiboot resume cluster tag %s",
465 			cfg_cluster_tag ? cfg_cluster_tag : "<none>");
466 	if ((cfg = cfg_open("")) == NULL) {
467 		spcs_log("ii", NULL, "iiboot cfg_open failed, errno %d",
468 			errno);
469 		iiboot_err(NULL, gettext("Error opening config"));
470 	}
471 
472 	cfg_resource(cfg, cfg_cluster_tag);
473 	if (!cfg_lock(cfg, CFG_RDLOCK)) {
474 		spcs_log("ii", NULL, "iiboot CFG_RDLOCK failed, errno %d",
475 			errno);
476 		iiboot_err(NULL, gettext("Error locking config"));
477 	}
478 
479 	/* Determine number of set, if zero return 0 */
480 	if ((n_structs = cfg_get_section(cfg, &entry, "ii")) == 0)
481 		return (0);
482 
483 	resume_list = calloc(n_structs, sizeof (*resume_list));
484 	if (resume_list == NULL) {
485 		spcs_log("ii", NULL, "iiboot resume realloc failed, errno %d",
486 		    errno);
487 		iiboot_err(NULL, gettext("Resume realloc failed"));
488 	}
489 
490 	valid_sets = 0;
491 	p = resume_list;
492 	for (i = 0; i < n_structs; i++) {
493 		buf = entry[i];
494 		mst = strtok(buf, " ");
495 		shd = strtok(NULL, " ");
496 		bmp = strtok(NULL, " ");
497 		(void) strtok(NULL, " ");	/* mode */
498 		(void) strtok(NULL, " ");	/* overflow */
499 		ctag = strtok(NULL, " ");	/* ctag */
500 		if (ctag)
501 			ctag += strspn(ctag, "-");
502 		opt = strtok(NULL, " ");
503 
504 		if (!mst || !shd || !bmp)
505 			break;
506 
507 		/* If cluster tags don't match, skip record */
508 		if ((cfg_cluster_tag && strcmp(ctag, cfg_cluster_tag)) ||
509 		    (!cfg_cluster_tag && strlen(ctag))) {
510 			free(buf);
511 			continue;
512 		}
513 
514 		ptr = strstr(opt, NSKERN_II_BMP_OPTION "=");
515 		if (ptr && set_is_offline(ptr + offset)) {
516 			free(buf);
517 			continue;
518 		}
519 
520 		(void) strncpy(p->master_vol, mst, DSW_NAMELEN);
521 		(void) strncpy(p->shadow_vol, shd, DSW_NAMELEN);
522 		(void) strncpy(p->bitmap_vol, bmp, DSW_NAMELEN);
523 		if (ctag)
524 			(void) strncpy(p->cluster_tag, ctag, DSW_NAMELEN);
525 		free(buf);
526 		++p;
527 		++valid_sets;
528 	}
529 
530 	while (i < n_structs)
531 		free(entry[i++]);
532 	if (entry)
533 		free(entry);
534 
535 	cfg_close(cfg);
536 	return (valid_sets);
537 }
538 
539 /*
540  * read_suspend_cfg()
541  *
542  * DESCRIPTION: Read the relevant config info via libcfg
543  *
544  * Outputs:
545  *	int i			Number of Point-in-Time Copy sets
546  *
547  * Side Effects: The 0 to i-1 entries in the suspend_list are filled.
548  *
549  */
550 
551 int
552 read_suspend_cfg()
553 {
554 	int rc;
555 	CFGFILE *cfg;
556 	int i;
557 	char buf[CFG_MAX_BUF];
558 	char key[CFG_MAX_KEY];
559 	int setnumber;
560 	dsw_ioctl_t *p;
561 
562 	spcs_log("ii", NULL, "iiboot suspend cluster tag %s",
563 			cfg_cluster_tag ? cfg_cluster_tag : "<none>");
564 
565 	if (cfg_cluster_tag == NULL) {
566 		return (1);
567 	}
568 
569 	if ((cfg = cfg_open("")) == NULL) {
570 		spcs_log("ii", NULL, "iiboot cfg_open failed, errno %d",
571 			errno);
572 		iiboot_err(NULL, gettext("Error opening config"));
573 	}
574 
575 	cfg_resource(cfg, cfg_cluster_tag);
576 	if (!cfg_lock(cfg, CFG_RDLOCK)) {
577 		spcs_log("ii", NULL, "iiboot CFG_RDLOCK failed, errno %d",
578 			errno);
579 		iiboot_err(NULL, gettext("Error locking config"));
580 	}
581 
582 
583 	/*CSTYLED*/
584 	for (i = 0; ; i++) {
585 		setnumber = i + 1;
586 
587 		bzero(buf, CFG_MAX_BUF);
588 		(void) snprintf(key, sizeof (key), "ii.set%d", setnumber);
589 		rc = cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF);
590 		if (rc < 0)
591 			break;
592 		if (n_structs < setnumber) {
593 			n_structs += 2;
594 			suspend_list = realloc(suspend_list,
595 					sizeof (*suspend_list) * n_structs);
596 			if (suspend_list == NULL) {
597 			    spcs_log("ii", NULL,
598 			    "iiboot suspend realloc failed, errno %d",
599 			    errno);
600 			    iiboot_err(NULL, gettext("Suspend realloc failed"));
601 			}
602 		}
603 		p = suspend_list + i;
604 
605 		(void) snprintf(key, sizeof (key), "ii.set%d.shadow",
606 		    setnumber);
607 		(void) cfg_get_cstring(cfg, key, p->shadow_vol, DSW_NAMELEN);
608 
609 	}
610 
611 	cfg_close(cfg);
612 	return (i);
613 }
614 
615 
616 int
617 parseopts(argc, argv, flag)
618 int argc;
619 char **argv;
620 int *flag;
621 {
622 	int  errflag = 0;
623 	int  Cflag = 0;
624 	char c;
625 	char inval = 0;
626 
627 	while ((c = getopt(argc, argv, "hrsC:")) != -1) {
628 		switch (c) {
629 		case 'C':
630 			if (Cflag) {
631 				iiboot_warn(NULL,
632 				    gettext("-C specified multiple times"));
633 				iiboot_usage();
634 				return (-1);
635 			}
636 
637 			Cflag++;
638 			cfg_cluster_tag = (optarg[0] == '-') ? NULL : optarg;
639 			break;
640 
641 		case 'h':
642 			iiboot_usage();
643 			exit(0);
644 			/* NOTREACHED */
645 
646 		case 'r':
647 			if (*flag)
648 				inval = 1;
649 			*flag = DSWIOC_RESUME;
650 			break;
651 		case 's':
652 			if (*flag)
653 				inval = 1;
654 			*flag = DSWIOC_SUSPEND;
655 			break;
656 		case '?':
657 			errflag++;
658 		}
659 	}
660 
661 	if (inval) {
662 		iiboot_warn(NULL, gettext("Invalid argument combination"));
663 		errflag = 1;
664 	}
665 
666 	if (!*flag || errflag) {
667 		iiboot_usage();
668 		return (-1);
669 	}
670 
671 	return (0);
672 }
673 
674 void
675 iiboot_usage()
676 {
677 	(void) fprintf(stderr, gettext("usage:\n"));
678 	(void) fprintf(stderr,
679 		gettext("\t%s -r [-C tag]\t\tresume\n"), program);
680 	(void) fprintf(stderr,
681 		gettext("\t%s -s [-C tag]\t\tsuspend\n"), program);
682 	(void) fprintf(stderr, gettext("\t%s -h\t\t\tthis help message\n"),
683 	    program);
684 }
685