xref: /titanic_41/usr/src/cmd/avs/rdc/sndrboot.c (revision 570de38f63910201fdd77246630b7aa8f9dc5661)
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 /*
23  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 
28 #include <sys/types.h>
29 #include <sys/wait.h>
30 #include <stdio.h>
31 #include <sys/mnttab.h>
32 #include <errno.h>
33 #include <limits.h>
34 #include <fcntl.h>
35 #include <strings.h>
36 #include <stdlib.h>
37 #include <unistd.h>
38 
39 #include <locale.h>
40 #include <langinfo.h>
41 #include <libintl.h>
42 #include <stdarg.h>
43 #include <netdb.h>
44 #include <ctype.h>
45 #include <sys/utsname.h>
46 
47 #include <sys/nsctl/rdc_io.h>
48 #include <sys/nsctl/rdc_ioctl.h>
49 #include <sys/nsctl/rdc_prot.h>
50 
51 #include <sys/nsctl/cfg.h>
52 #include <sys/nsctl/cfg_cluster.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 
58 #include "rdcadm.h"
59 
60 /*
61  * Special re-use of sndrboot to fix SNDR set IDs during post-patch processing
62  */
63 #define	RDC_CMD_FIXSETIDS	0xFEEDFACE
64 
65 /*
66  * config file user level Dual copy pair structure
67  */
68 typedef struct _sd_dual_pair {
69 	char fhost[MAX_RDC_HOST_SIZE];	/* Hostname for primary device */
70 	char fnetaddr[RDC_MAXADDR];	/* Host netaddr for primary device */
71 	char ffile[NSC_MAXPATH];	/* Primary device */
72 	char fbitmap[NSC_MAXPATH];	/* Primary bitmap device */
73 	char thost[MAX_RDC_HOST_SIZE];	/* Hostname for secondary device */
74 	char tnetaddr[RDC_MAXADDR];	/* Host netaddr for secondary device */
75 	char tfile[NSC_MAXPATH];	/* Secondary device */
76 	char tbitmap[NSC_MAXPATH];	/* Secondary bitmap device */
77 	char directfile[NSC_MAXPATH];	/* Local FCAL direct IO volume */
78 	char diskqueue[NSC_MAXPATH];	/* Disk Queue volume */
79 	char group[NSC_MAXPATH];	/* Group name */
80 	char lhost[MAX_RDC_HOST_SIZE];  /* Logical hostname for cluster */
81 	int  doasync;			/* Device is in sync/async mode */
82 	int  setid;			/* unique setid of this set */
83 } _sd_dual_pair_t;
84 
85 #include <sys/socket.h>
86 #include <netinet/in.h>
87 #include <arpa/inet.h>
88 #include <netinet/tcp.h>
89 #include <rpc/rpc_com.h>
90 #include <rpc/rpc.h>
91 
92 #include <sys/nsctl/librdc.h>
93 
94 char *ctag = NULL;
95 
96 int parseopts(int, char **, int *);
97 static int rdc_operation(char *, char *, char *, char *, char *, char *, int,
98     char *, char *, char *, int, char *, int setid);
99 static int read_libcfg(int);
100 static void usage(void);
101 
102 extern char *basename(char *);
103 
104 int rdc_maxsets;
105 static _sd_dual_pair_t *pair_list;
106 char *program;
107 
108 struct netbuf svaddr;
109 struct netbuf *svp;
110 struct netconfig nconf;
111 struct netconfig *conf;
112 struct knetconfig knconf;
113 static int clustered = 0;
114 static int proto_test = 0;
115 
116 #ifdef lint
117 int
sndrboot_lintmain(int argc,char * argv[])118 sndrboot_lintmain(int argc, char *argv[])
119 #else
120 int
121 main(int argc, char *argv[])
122 #endif
123 {
124 	char fromhost[MAX_RDC_HOST_SIZE];
125 	char tohost[MAX_RDC_HOST_SIZE];
126 	char fromfile[NSC_MAXPATH];
127 	char tofile[NSC_MAXPATH];
128 	char frombitmap[NSC_MAXPATH];
129 	char tobitmap[NSC_MAXPATH];
130 	char directfile[NSC_MAXPATH];
131 	char diskqueue[NSC_MAXPATH];
132 	char group[NSC_MAXPATH];
133 	char lhost[MAX_RDC_HOST_SIZE];
134 	int pairs;
135 	int pid;
136 	int flag = 0;
137 	int doasync;
138 	int rc;
139 	char *required;
140 	int setid;
141 
142 	(void) setlocale(LC_ALL, "");
143 	(void) textdomain("rdc");
144 
145 	program = basename(argv[0]);
146 
147 	rc = rdc_check_release(&required);
148 	if (rc < 0) {
149 		rdc_err(NULL,
150 		    gettext("unable to determine the current "
151 		    "Solaris release: %s\n"), strerror(errno));
152 	} else if (rc == FALSE) {
153 		rdc_err(NULL,
154 		    gettext("incorrect Solaris release (requires %s)\n"),
155 		    required);
156 	}
157 
158 	rdc_maxsets = rdc_get_maxsets();
159 	if (rdc_maxsets == -1) {
160 		spcs_log("sndr", NULL,
161 		    gettext("%s unable to get maxsets value from kernel"),
162 		    program);
163 
164 		rdc_err(NULL,
165 		    gettext("unable to get maxsets value from kernel"));
166 	}
167 
168 	pair_list = calloc(rdc_maxsets, sizeof (*pair_list));
169 	if (pair_list == NULL) {
170 		rdc_err(NULL,
171 		    gettext(
172 			"unable to allocate pair_list"
173 			" array for %d sets"),
174 			rdc_maxsets);
175 	}
176 
177 	if (parseopts(argc, argv, &flag))
178 		return (1);
179 	pairs = read_libcfg(flag);
180 
181 	if (flag == RDC_CMD_FIXSETIDS) {
182 		if (pairs) {
183 			spcs_log("sndr", NULL, gettext("Fixed %d Remote Mirror"
184 				    " set IDs"), pairs);
185 #ifdef DEBUG
186 			rdc_warn(NULL, gettext("Fixed %d Remote Mirror set "
187 				    "IDs"), pairs);
188 #endif
189 		}
190 		return (0);
191 	}
192 
193 	if (pairs == 0) {
194 #ifdef DEBUG
195 		rdc_err(NULL,
196 		    gettext("Config contains no dual copy sets"));
197 #else
198 		return (0);
199 #endif
200 	}
201 
202 	while (pairs--) {
203 		pid = fork();
204 		if (pid == -1) {		/* error forking */
205 			perror("fork");
206 			continue;
207 		}
208 
209 		if (pid > 0)		/* this is parent process */
210 			continue;
211 
212 /*
213  * At this point, this is the child process.  Do the operation
214  */
215 
216 		(void) strncpy(fromfile,
217 		    pair_list[pairs].ffile, NSC_MAXPATH);
218 		(void) strncpy(tofile,
219 		    pair_list[pairs].tfile, NSC_MAXPATH);
220 		(void) strncpy(frombitmap,
221 		    pair_list[pairs].fbitmap, NSC_MAXPATH);
222 		(void) strncpy(fromhost,
223 		    pair_list[pairs].fhost, MAX_RDC_HOST_SIZE);
224 		(void) strncpy(tohost,
225 		    pair_list[pairs].thost, MAX_RDC_HOST_SIZE);
226 		(void) strncpy(tobitmap,
227 		    pair_list[pairs].tbitmap, NSC_MAXPATH);
228 		(void) strncpy(directfile,
229 		    pair_list[pairs].directfile, NSC_MAXPATH);
230 		(void) strncpy(diskqueue,
231 		    pair_list[pairs].diskqueue, NSC_MAXPATH);
232 		(void) strncpy(group,
233 		    pair_list[pairs].group, NSC_MAXPATH);
234 		(void) strncpy(lhost,
235 		    pair_list[pairs].lhost, MAX_RDC_HOST_SIZE);
236 
237 		doasync = pair_list[pairs].doasync;
238 		setid = pair_list[pairs].setid;
239 		if (rdc_operation(fromhost, fromfile, frombitmap,
240 		    tohost, tofile, tobitmap, flag, directfile, group,
241 		    diskqueue, doasync, lhost, setid)
242 		    < 0) {
243 			exit(255);
244 		}
245 
246 		exit(0);
247 	}
248 
249 	while ((wait((int *)0) > 0))
250 		;
251 	return (0);
252 }
253 
254 static int
rdc_operation(fromhost,fromfile,frombitmap,tohost,tofile,tobitmap,flag,directfile,group,diskqueue,doasync,lhost,setid)255 rdc_operation(fromhost, fromfile, frombitmap, tohost, tofile,
256     tobitmap, flag, directfile, group, diskqueue, doasync,
257     lhost, setid)
258 char *fromhost, *fromfile, *frombitmap;
259 char *tohost, *tofile, *tobitmap;
260 int flag, doasync;
261 char *directfile;
262 char *group, *diskqueue;
263 int setid;
264 char *lhost;
265 {
266 	const int getaddr = (flag == RDC_CMD_RESUME);
267 	const int rpcbind = !getaddr;
268 	rdc_config_t parms;
269 	int ret;
270 	spcs_s_info_t ustatus;
271 	struct hostent *hp;
272 	char fromname[MAXHOSTNAMELEN], toname[MAXHOSTNAMELEN];
273 	struct t_info tinfo;
274 	int i;
275 
276 	conf = &nconf;
277 	bzero(&fromname, MAXHOSTNAMELEN);
278 	bzero(&toname, MAXHOSTNAMELEN);
279 
280 	hp = gethost_byname(fromhost);
281 	if (hp == NULL) {
282 		spcs_log("sndr", NULL,
283 		    gettext("%s gethost_byname failed for %s"),
284 		    program, fromhost);
285 	}
286 	if (strcmp(hp->h_name, fromhost) == 0)
287 		(void) strncpy(fromname, hp->h_name, MAXHOSTNAMELEN);
288 	else {
289 	for (i = 0; hp->h_aliases[i] != NULL; i++) {
290 		if (strcmp(hp->h_aliases[i], fromhost) == 0)
291 			(void) strncpy(fromname, hp->h_aliases[i],
292 			    MAXHOSTNAMELEN);
293 		}
294 	}
295 	if (fromname[0] == '\0') {
296 		spcs_log("sndr", NULL,
297 		    gettext("%s host %s is not local"),
298 		    program, fromhost);
299 		rdc_err(NULL, gettext("Host %s is not local"),
300 		    fromhost);
301 	}
302 	hp = gethost_byname(tohost);
303 	if (hp == NULL) {
304 		spcs_log("sndr", NULL,
305 		    gettext("%s gethost_byname failed for %s"),
306 		    program, tohost);
307 	}
308 	if (strcmp(hp->h_name, tohost) == 0)
309 		(void) strncpy(toname, hp->h_name, MAXHOSTNAMELEN);
310 	else {
311 	for (i = 0; hp->h_aliases[i] != NULL; i++) {
312 		if (strcmp(hp->h_aliases[i], tohost) == 0)
313 			(void) strncpy(toname, hp->h_aliases[i],
314 			    MAXHOSTNAMELEN);
315 		}
316 	}
317 	if (toname[0] == '\0') {
318 		spcs_log("sndr", NULL,
319 		    gettext("%s host %s is not local"),
320 		    program, tohost);
321 		rdc_err(NULL, gettext("Host %s is not local"),
322 		    tohost);
323 	}
324 
325 	if (self_check(fromname) && self_check(toname)) {
326 		spcs_log("sndr", NULL,
327 		    gettext("%s Both %s and %s are local"),
328 		    program, fromhost, tohost);
329 		rdc_err(NULL, gettext("Both %s and %s are local"),
330 		    fromhost, tohost);
331 	}
332 
333 	/*
334 	 * Now build up the address for each host including port and transport
335 	 */
336 	if (getaddr) {
337 		svp = get_addr(toname, RDC_PROGRAM, RDC_VERS_MIN,
338 			&conf, proto_test?NC_UDP: NULL, "rdc", &tinfo, rpcbind);
339 
340 		if (svp == NULL) {
341 #ifdef DEBUG
342 			(void) printf("get_addr failed for Ver 4 %s\n", toname);
343 #endif
344 			spcs_log("sndr", NULL,
345 			    gettext("%s get_addr failed for Ver 4"),
346 			    program);
347 			return (-1);
348 		}
349 		svaddr = *svp;
350 	} else {
351 		bzero(&svaddr, sizeof (svaddr));
352 	}
353 
354 	parms.rdc_set->secondary.addr.len = svaddr.len;
355 	parms.rdc_set->secondary.addr.maxlen = svaddr.maxlen;
356 	parms.rdc_set->secondary.addr.buf = (void *)svaddr.buf;
357 
358 #ifdef DEBUG_ADDR
359 	(void) fprintf(stderr,
360 		"secondary buf %x len %d\n", svaddr.buf, svaddr.len);
361 
362 	for (i = 0; i < svaddr.len; i++)
363 		(void) printf("%u ", svaddr.buf[i]);
364 	(void) printf("\n");
365 #endif
366 
367 	if (getaddr) {
368 		svp = get_addr(fromname, RDC_PROGRAM, RDC_VERS_MIN,
369 			&conf, proto_test?NC_UDP: NULL, "rdc", &tinfo, rpcbind);
370 		if (svp == NULL) {
371 #ifdef DEBUG
372 			(void) printf("get_addr failed for Ver 4 %s\n",
373 			    fromname);
374 #endif
375 			return (-1);
376 		}
377 		svaddr = *svp;
378 	} else {
379 		;
380 		/*EMPTY*/
381 	}
382 	parms.rdc_set->primary.addr.len = svaddr.len;
383 	parms.rdc_set->primary.addr.maxlen = svaddr.maxlen;
384 	parms.rdc_set->primary.addr.buf =
385 				(void *)svaddr.buf;
386 
387 #ifdef DEBUG_ADDR
388 	(void) fprintf(stderr, "primary buf %x len %d\n",
389 	    svaddr.buf, svaddr.len);
390 	for (i = 0; i < svaddr.len; i++)
391 		(void) printf("%u ", svaddr.buf[i]);
392 	(void) printf("\n");
393 #endif
394 
395 	if (getaddr) {
396 		(void) convert_nconf_to_knconf(conf, &knconf);
397 #ifdef DEBUG_ADDR
398 		(void) printf("knconf %x %s %s %x\n", knconf.knc_semantics,
399 		    knconf.knc_protofmly, knconf.knc_proto, knconf.knc_rdev);
400 #endif
401 		parms.rdc_set->netconfig = &knconf;
402 	} else {
403 		parms.rdc_set->netconfig = NULL;
404 	}
405 	if (!clustered && !self_check(fromname) && !self_check(toname)) {
406 		spcs_log("sndr", NULL,
407 		    gettext("%s Neither %s nor %s is local"),
408 		    program, fromhost, tohost);
409 		rdc_err(NULL, gettext("Neither %s nor %s is local"),
410 		    fromhost, tohost);
411 	}
412 	(void) strncpy(parms.rdc_set->primary.intf, fromhost,
413 	    MAX_RDC_HOST_SIZE);
414 	(void) strncpy(parms.rdc_set->primary.file, fromfile, NSC_MAXPATH);
415 	(void) strncpy(parms.rdc_set->primary.bitmap, frombitmap, NSC_MAXPATH);
416 
417 	(void) strncpy(parms.rdc_set->secondary.intf, tohost,
418 	    MAX_RDC_HOST_SIZE);
419 	(void) strncpy(parms.rdc_set->secondary.file, tofile, NSC_MAXPATH);
420 	(void) strncpy(parms.rdc_set->secondary.bitmap, tobitmap, NSC_MAXPATH);
421 
422 	(void) strncpy(parms.rdc_set->group_name, group, NSC_MAXPATH);
423 	(void) strncpy(parms.rdc_set->disk_queue, diskqueue, NSC_MAXPATH);
424 
425 	parms.rdc_set->maxqfbas = maxqfbas;
426 	parms.rdc_set->maxqitems = maxqitems;
427 	parms.rdc_set->autosync = autosync;
428 	parms.rdc_set->asyncthr = asyncthr;
429 	parms.rdc_set->setid = setid;
430 
431 	/* gethostid(3c) is defined to return a 32bit value */
432 	parms.rdc_set->syshostid = (int32_t)gethostid();
433 
434 	parms.command = 0;
435 	parms.options = 0;
436 	parms.command = flag;
437 
438 	if (flag == RDC_CMD_RESUME) {
439 		if (doasync)
440 			parms.options |= RDC_OPT_ASYNC;
441 		else
442 			parms.options |= RDC_OPT_SYNC;
443 	}
444 	if (clustered) {
445 		if (!ctag)
446 			goto noconfig;
447 		if (strcmp(ctag, "-") == 0)
448 			goto noconfig;
449 
450 #ifdef DEBUG
451 		(void) fprintf(stderr, "logical hostname: %s\n", lhost);
452 #endif
453 
454 		if (strcmp(lhost, fromname) == 0) {
455 			parms.options |= RDC_OPT_PRIMARY;
456 			(void) strncpy(parms.rdc_set->direct_file, directfile,
457 			    NSC_MAXPATH);
458 
459 		} else {
460 			parms.options |= RDC_OPT_SECONDARY;
461 			parms.rdc_set->direct_file[0] = 0; /* no fcal direct */
462 		}
463 	} else {
464 noconfig:
465 		/*
466 		 * If not clustered, don't resume sndr sets with lhost
467 		 */
468 		if ((flag == RDC_CMD_RESUME) && lhost && strlen(lhost))
469 			return (0);
470 
471 		if (self_check(fromname)) {
472 			parms.options |= RDC_OPT_PRIMARY;
473 			(void) strncpy(parms.rdc_set->direct_file, directfile,
474 			    NSC_MAXPATH);
475 		} else {
476 			parms.options |= RDC_OPT_SECONDARY;
477 			parms.rdc_set->direct_file[0] = 0; /* no fcal direct */
478 		}
479 	}
480 
481 	ustatus = spcs_s_ucreate();
482 
483 	errno = 0;
484 	ret = RDC_IOCTL(RDC_CONFIG, &parms, NULL, 0, 0, 0, ustatus);
485 	if (ret != SPCS_S_OK) {
486 
487 		/* Surpress error messages for suspend on cluster elements */
488 		if ((flag == RDC_CMD_SUSPEND) && (errno == RDC_EALREADY) &&
489 			!clustered && lhost && strlen(lhost)) {
490 			spcs_s_ufree(&ustatus);
491 			return (0);
492 		}
493 
494 		(void) fprintf(stderr,
495 			gettext("Remote Mirror: %s %s %s %s %s %s\n"),
496 			fromhost, fromfile,
497 			frombitmap, tohost, tofile, tobitmap);
498 
499 		if (errno == RDC_EEINVAL) {
500 			spcs_log("sndr", NULL,
501 			    gettext("%s %s %s %s %s %s %s %s\n%s"),
502 			    program, rdc_decode_flag(flag, parms.options),
503 			    fromhost, fromfile, frombitmap,
504 			    tohost, tofile, tobitmap,
505 			    gettext("invalid command option"));
506 			rdc_err(&ustatus,
507 			    gettext("Remote Mirror: invalid command option "
508 				    "'%s'"), rdc_decode_flag(flag,
509 				    parms.options));
510 		} else {
511 			spcs_log("sndr", &ustatus,
512 			    gettext("%s %s %s %s %s %s %s %s"),
513 			    program, rdc_decode_flag(flag, parms.options),
514 			    fromhost, fromfile, frombitmap,
515 			    tohost, tofile, tobitmap);
516 			rdc_err(&ustatus, 0);
517 		}
518 	}
519 
520 	spcs_log("sndr", NULL,
521 	    gettext("%s %s %s %s %s %s %s %s\nSuccessful"),
522 	    program, rdc_decode_flag(flag, parms.options),
523 	    fromhost, fromfile, frombitmap, tohost, tofile, tobitmap);
524 
525 	spcs_s_ufree(&ustatus);
526 	return (0);
527 }
528 /*
529  * assign setid's to any existing
530  * sets without setids, making sure of course NOT to re-use a setid
531  */
532 int
update_setids(CFGFILE * cfg,int * no_id,int highest)533 update_setids(CFGFILE *cfg, int *no_id, int highest)
534 {
535 	int setid;
536 	char buf[CFG_MAX_BUF];
537 	char key[CFG_MAX_KEY];
538 	char *ctag;
539 
540 	/* If in a Sun Cluster, SetIDs need to have a ctag */
541 	if ((ctag = cfg_get_resource(cfg)) != NULL) {
542 		ctag = strdup(ctag);
543 		cfg_resource(cfg, "setid-ctag");
544 	}
545 
546 	/*
547 	 * Paranoia. IF there are any sets with setids, we don't
548 	 * want to re-use their number.
549 	 */
550 	if (highest > get_new_cfg_setid(cfg)) {
551 		bzero(&buf, sizeof (buf));
552 		(void) sprintf(buf, "%d", highest);
553 		if (cfg_put_cstring(cfg, "setid.set1.value", buf,
554 		    sizeof (buf)) < 0)
555 			rdc_warn(NULL, gettext("sndrboot: Unable to store "
556 			    "new setid"));
557 	}
558 
559 	for (setid = 0; no_id[setid]; setid++) {
560 		bzero(&buf, sizeof (buf));
561 		bzero(&key, sizeof (key));
562 		(void) sprintf(buf, "%d", get_new_cfg_setid(cfg));
563 		(void) sprintf(key, "sndr.set%d.options", no_id[setid]);
564 		if (cfg_put_options(cfg, CFG_SEC_CONF, key, "setid", buf) < 0)
565 			rdc_warn(NULL, gettext("sndrboot: Unable to store "
566 			    "unique setid"));
567 
568 		pair_list[no_id[setid] - 1].setid = atoi(buf);
569 	}
570 
571 	/* Restore old ctag if in a Sun Cluster */
572 	if (ctag) {
573 		cfg_resource(cfg, ctag);
574 		free(ctag);
575 	}
576 
577 	if (cfg_commit(cfg) < 0)
578 		rdc_err(NULL, gettext("sndrboot: Failed to commit setids"));
579 
580 	return (setid);
581 }
582 
583 /*
584  * this is called when the option lghn is no available in libdscfg
585  * that should only happen on an upgrade.
586  * cfg write lock must be held across this function
587  */
588 char *
get_lghn(CFGFILE * cfg,char * ctag,int setnum,int flag)589 get_lghn(CFGFILE *cfg, char *ctag, int setnum, int flag)
590 {
591 	FILE *pipe;
592 	char rsgrp[SCCONF_MAXSTRINGLEN];
593 	char cmd[SCCONF_MAXSTRINGLEN];
594 	static char lhostname[MAX_RDC_HOST_SIZE];
595 	char key[CFG_MAX_KEY];
596 	int rc;
597 
598 	if (ctag == NULL)
599 		goto fail;
600 
601 	bzero(&lhostname, sizeof (lhostname));
602 
603 	(void) sprintf(rsgrp, "%s-stor-rg", ctag);
604 /* BEGIN CSTYLED */
605 	rc = snprintf(cmd, SCCONF_MAXSTRINGLEN,
606 	    "/usr/cluster/bin/scrgadm -pvv | fgrep HostnameList \
607 | fgrep %s | fgrep value | awk -F: '{ print $4 }'", rsgrp);
608 /* END CSTYLED */
609 
610 	if (rc < 0) {
611 		rdc_err(NULL, gettext("Error getting scrgadm output"));
612 	}
613 
614 	pipe = popen(cmd, "r");
615 
616 	if (pipe == NULL) {
617 		rdc_err(NULL, gettext("Error opening pipe"));
618 	}
619 	rc = fscanf(pipe, "%s", lhostname);
620 	(void) pclose(pipe);
621 
622 	if (rc != 1) {
623 		rdc_err(NULL, gettext("Unable to get logical host"));
624 	}
625 
626 	/* not really failing, but suspend does not have the config lock */
627 	if (flag == RDC_CMD_SUSPEND)
628 		goto fail;
629 
630 	bzero(&key, sizeof (key));
631 	(void) snprintf(key, sizeof (key), "sndr.set%d.options", setnum);
632 	if (cfg_put_options(cfg, CFG_SEC_CONF, key, "lghn", lhostname) < 0)
633 		rdc_warn(NULL, gettext("sndrboot: Unable to store logical "
634 		    "host name in configuration database"));
635 
636 	if (cfg_commit(cfg) < 0)
637 		rdc_err(NULL,
638 		    gettext("sndrboot: Failed to commit logical host name"));
639 
640 fail:
641 	return (lhostname);
642 
643 }
644 
645 /*
646  * read_libcfg()
647  *
648  * DESCRIPTION: Read the relevant config info via libcfg
649  *
650  * Outputs:
651  *	int i			Number of pairs of devices
652  *
653  * Side Effects: The 0 to i-1 entries in the pair_list are filled.
654  *
655  */
656 static int
read_libcfg(int flag)657 read_libcfg(int flag)
658 {
659 	char fromhost[MAX_RDC_HOST_SIZE];
660 	char fromfile[NSC_MAXPATH];
661 	char frombitmap[NSC_MAXPATH];
662 	char tohost[MAX_RDC_HOST_SIZE];
663 	char tofile[NSC_MAXPATH];
664 	char tobitmap[NSC_MAXPATH];
665 	char directfile[NSC_MAXPATH];
666 	char diskqueue[NSC_MAXPATH];
667 	char group[NSC_MAXPATH];
668 	char lhost[MAX_RDC_HOST_SIZE];
669 	char sync[16];
670 	char setid[64];
671 	int doasync;
672 	CFGFILE *cfg;
673 	int i, j = 0;
674 	int rc;
675 	char buf[CFG_MAX_BUF];
676 	char key[CFG_MAX_KEY];
677 	char dummy[NSC_MAXPATH];
678 	int setnumber;
679 	int numsets;
680 	int highest = 0;
681 	char lghn[5];
682 	int *no_id;
683 
684 
685 	if ((cfg = cfg_open("")) == NULL)
686 		rdc_err(NULL, gettext("Error opening config"));
687 
688 	/*
689 	 * If RDC_CMD_FIXSETIDS, we were called during post-patch install
690 	 * Acquire a write-lock on the cfg_lock(), so the code can attempt
691 	 * to fix setIDs
692 	 */
693 	if (flag == RDC_CMD_FIXSETIDS) {
694 		if (!cfg_lock(cfg, CFG_WRLOCK))
695 			rdc_err(NULL, gettext("Error write locking config"));
696 		cfg_resource(cfg, NULL);
697 	} else {
698 		if (!cfg_lock(cfg, CFG_RDLOCK))
699 			rdc_err(NULL, gettext("Error locking config"));
700 		cfg_resource(cfg, ctag);
701 	}
702 
703 	if ((numsets = cfg_get_num_entries(cfg, "sndr")) < 0)
704 		rdc_err(NULL, gettext("Unable to get set info from config"));
705 
706 	no_id = (int *)calloc(numsets + 1, sizeof (int));
707 	if (!no_id)
708 		rdc_err(NULL, gettext("No memory"));
709 
710 
711 	(void) snprintf(lghn, sizeof (lghn), "lghn");
712 
713 	for (i = 0; i < rdc_maxsets; i++) {
714 		setnumber = i + 1;
715 
716 		bzero(buf, CFG_MAX_BUF);
717 		(void) snprintf(key, sizeof (key), "sndr.set%d", setnumber);
718 		if (cfg_get_cstring(cfg, key, buf, CFG_MAX_BUF) < 0)
719 			break;
720 
721 		rc = sscanf(buf, "%s %s %s %s %s %s %s %s %s %s %s %s",
722 		    fromhost, fromfile, frombitmap, tohost, tofile, tobitmap,
723 			directfile, sync, group, dummy, dummy, diskqueue);
724 		if (rc != 12)
725 			rdc_err(NULL, gettext("cfg input error (%d)"), rc);
726 
727 		if (strcmp(directfile, "ip") == 0)
728 			(void) strcpy(directfile, "");
729 
730 		if (strcmp(group, "-") == 0)
731 			(void) strcpy(group, "");
732 
733 		if (strcmp(diskqueue, "-") == 0)
734 			(void) strcpy(diskqueue, "");
735 
736 		(void) snprintf(key, sizeof (key),
737 			"sndr.set%d.options", setnumber);
738 
739 		if (cfg_get_single_option(cfg, CFG_SEC_CONF, key,
740 			lghn, lhost, MAX_RDC_HOST_SIZE) < 0)
741 			(void) strcpy(lhost,
742 			    get_lghn(cfg, ctag, setnumber, flag));
743 
744 		if (strcmp(sync, "sync") == 0)
745 			doasync = 0;
746 		else if (strcmp(sync, "async") == 0)
747 			doasync = 1;
748 		else {
749 			cfg_close(cfg);
750 			rdc_err(NULL,
751 			    gettext("Set %s:%s neither sync nor async"),
752 			    tohost, tofile);
753 		}
754 
755 		(void) strncpy(pair_list[i].fhost, fromhost,
756 		    MAX_RDC_HOST_SIZE);
757 		(void) strncpy(pair_list[i].ffile, fromfile, NSC_MAXPATH);
758 		(void) strncpy(pair_list[i].fbitmap, frombitmap, NSC_MAXPATH);
759 		(void) strncpy(pair_list[i].thost, tohost, MAX_RDC_HOST_SIZE);
760 		(void) strncpy(pair_list[i].tfile, tofile, NSC_MAXPATH);
761 		(void) strncpy(pair_list[i].tbitmap, tobitmap, NSC_MAXPATH);
762 		(void) strncpy(pair_list[i].directfile, directfile,
763 		    NSC_MAXPATH);
764 		(void) strncpy(pair_list[i].diskqueue, diskqueue,
765 		    NSC_MAXPATH);
766 		(void) strncpy(pair_list[i].group, group, NSC_MAXPATH);
767 		(void) strncpy(pair_list[i].lhost, lhost, MAX_RDC_HOST_SIZE);
768 		pair_list[i].doasync = doasync;
769 
770 		if (cfg_get_single_option(cfg, CFG_SEC_CONF, key, "setid",
771 		    setid, sizeof (setid)) < 0) {
772 			no_id[j++] = setnumber;
773 		}
774 		pair_list[i].setid = atoi(setid);
775 
776 		if (pair_list[i].setid > highest)
777 			highest = pair_list[i].setid;
778 
779 		if (gethost_netaddrs(fromhost, tohost,
780 		    (char *)pair_list[i].fnetaddr,
781 		    (char *)pair_list[i].tnetaddr) < 0) {
782 			cfg_close(cfg);
783 			spcs_log("sndr", NULL,
784 			    gettext("%s unable to determine IP addresses "
785 			    "for hosts %s %s"), program, fromhost, tohost);
786 			rdc_err(NULL, gettext("unable to determine IP "
787 			    "addresses for hosts %s, %s"), fromhost, tohost);
788 		}
789 	}
790 	/*
791 	 * fix any lost set ids if possible, also deal with upgrade
792 	 */
793 	if (j > 0 && flag == RDC_CMD_FIXSETIDS) {
794 		(void) update_setids(cfg, no_id, highest);
795 		i = j;	/* Set number of fixups */
796 	}
797 	free(no_id);
798 	cfg_close(cfg);
799 	return (i);
800 }
801 
802 
803 int
parseopts(argc,argv,flag)804 parseopts(argc, argv, flag)
805 int argc;
806 char **argv;
807 int *flag;
808 {
809 	int  errflag = 0;
810 	char c;
811 	char inval = 0;
812 #ifdef DEBUG
813 	while ((c = getopt(argc, argv, "C:Urs")) != -1) {
814 #else
815 	while ((c = getopt(argc, argv, "C:rs")) != -1) {
816 #endif
817 		switch (c) {
818 		case 'C':
819 			clustered = TRUE;
820 			ctag = optarg;
821 			break;
822 #ifdef DEBUG
823 		case 'U':
824 			proto_test = 1;
825 			break;
826 #endif
827 		case 'r':
828 			if (*flag)
829 				inval = 1;
830 			*flag = RDC_CMD_RESUME;
831 			break;
832 		case 's':
833 			if (*flag)
834 				inval = 1;
835 			*flag = RDC_CMD_SUSPEND;
836 			break;
837 		case '?':
838 			errflag++;
839 		}
840 	}
841 
842 	/*
843 	 * Special fix to address no SetIds in AVS 3.1 to 3.2 install + patch
844 	 * Adjust set IDs, if someone invokes the following invalid command
845 	 *
846 	 *	/use/sbin/sndrboot -C post-patch-setids -r -s
847 	 *
848 	 * Command will be called in post-install of the patch containing fix
849 	 *
850 	 */
851 	if (clustered && (strcmp(ctag, "post-patch-setids") == 0) &&
852 	    *flag && inval) {
853 		*flag = RDC_CMD_FIXSETIDS;
854 		return (0);
855 	}
856 
857 	if (inval) {
858 		rdc_warn(NULL, gettext("Invalid argument combination"));
859 		errflag = 1;
860 	}
861 
862 	if (!*flag || errflag) {
863 		usage();
864 		return (-1);
865 	}
866 
867 	return (0);
868 }
869 
870 static void
usage()871 usage()
872 {
873 	(void) fprintf(stderr, gettext("usage:\n"));
874 	(void) fprintf(stderr,
875 		gettext("\t%s -r [-C tag]\t\t"
876 			"resume\n"), program);
877 
878 	(void) fprintf(stderr,
879 		gettext("\t%s -s [-C tag]\t\t"
880 			"suspend\n"), program);
881 }
882