xref: /titanic_50/usr/src/cmd/boot/installgrub/installgrub.c (revision 3d729aecc03ea6ebb9bd5d56b8dccd24f57daa41)
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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
23  * Copyright 2012 Milan Jurik. All rights reserved.
24  * Copyright 2015 Nexenta Systems, Inc. All rights reserved.
25  */
26 
27 #include <stdio.h>
28 #include <stdlib.h>
29 #include <libgen.h>
30 #include <malloc.h>
31 #include <string.h>
32 #include <fcntl.h>
33 #include <unistd.h>
34 #include <strings.h>
35 #include <libintl.h>
36 #include <locale.h>
37 #include <errno.h>
38 #include <libfdisk.h>
39 #include <stdarg.h>
40 #include <assert.h>
41 
42 #include <sys/mount.h>
43 #include <sys/mnttab.h>
44 #include <sys/dktp/fdisk.h>
45 #include <sys/dkio.h>
46 #include <sys/vtoc.h>
47 #include <sys/types.h>
48 #include <sys/stat.h>
49 #include <sys/multiboot.h>
50 #include <sys/sysmacros.h>
51 #include <sys/efi_partition.h>
52 
53 #include <libnvpair.h>
54 #include <libfstyp.h>
55 
56 #include "message.h"
57 #include "installgrub.h"
58 #include "./../common/bblk_einfo.h"
59 #include "./../common/boot_utils.h"
60 #include "./../common/mboot_extra.h"
61 #include "getresponse.h"
62 
63 #ifndef	TEXT_DOMAIN
64 #define	TEXT_DOMAIN	"SUNW_OST_OSCMD"
65 #endif
66 
67 /*
68  * Variables to track installgrub desired mode of operation.
69  * 'nowrite' and 'boot_debug' come from boot_common.h.
70  */
71 static boolean_t write_mbr = B_FALSE;
72 static boolean_t force_mbr = B_FALSE;
73 static boolean_t force_update = B_FALSE;
74 static boolean_t do_getinfo = B_FALSE;
75 static boolean_t do_version = B_FALSE;
76 static boolean_t do_mirror_bblk = B_FALSE;
77 static boolean_t strip = B_FALSE;
78 static boolean_t verbose_dump = B_FALSE;
79 
80 /* Installing the bootblock is the default operation. */
81 static boolean_t do_install = B_TRUE;
82 
83 /* Versioning string, if present. */
84 static char *update_str;
85 
86 /*
87  * Temporary buffer to store the first 32K of data looking for a multiboot
88  * signature.
89  */
90 char	mboot_scan[MBOOT_SCAN_SIZE];
91 
92 /* Function prototypes. */
93 static void check_options(char *);
94 static int handle_install(char *, char **);
95 static int handle_mirror(char *, char **);
96 static int handle_getinfo(char *, char **);
97 static int commit_to_disk(ig_data_t *, char *);
98 static int init_device(ig_device_t *, char *path);
99 static void cleanup_device(ig_device_t *);
100 static void cleanup_stage2(ig_stage2_t *);
101 static int get_start_sector(ig_device_t *);
102 static int get_disk_fd(ig_device_t *device);
103 static int get_raw_partition_fd(ig_device_t *);
104 static char *get_raw_partition_path(ig_device_t *);
105 static boolean_t gather_stage2_from_dev(ig_data_t *);
106 static int propagate_bootblock(ig_data_t *, ig_data_t *, char *);
107 static int find_x86_bootpar(struct mboot *, int *, uint32_t *);
108 static int copy_stage2_to_pcfs(ig_data_t *);
109 static int write_stage2(ig_data_t *);
110 static int write_stage1(ig_data_t *);
111 static void usage(char *);
112 static int read_stage1_from_file(char *, ig_data_t *);
113 static int read_stage2_from_file(char *, ig_data_t *);
114 static int read_stage1_from_disk(int, char *);
115 static int read_stage2_from_disk(int, ig_stage2_t *, int);
116 static int prepare_stage1(ig_data_t *);
117 static int prepare_stage2(ig_data_t *, char *);
118 static void prepare_fake_multiboot(ig_stage2_t *);
119 static void add_stage2_einfo(ig_stage2_t *, char *updt_str);
120 static boolean_t is_update_necessary(ig_data_t *, char *);
121 
122 extern int read_stage2_blocklist(int, unsigned int *);
123 
124 int
125 main(int argc, char *argv[])
126 {
127 	int	opt;
128 	int	params = 3;
129 	int	ret;
130 	char	**handle_args;
131 	char	*progname;
132 
133 	(void) setlocale(LC_ALL, "");
134 	(void) textdomain(TEXT_DOMAIN);
135 	if (init_yes() < 0) {
136 		(void) fprintf(stderr, gettext(ERR_MSG_INIT_YES),
137 		    strerror(errno));
138 		exit(BC_ERROR);
139 	}
140 
141 	/*
142 	 * retro-compatibility: installing the bootblock is the default
143 	 * and there is no switch for it.
144 	 */
145 	do_install = B_TRUE;
146 
147 	while ((opt = getopt(argc, argv, "dVMFfmneiu:")) != EOF) {
148 		switch (opt) {
149 		case 'm':
150 			write_mbr = B_TRUE;
151 			break;
152 		case 'n':
153 			nowrite = B_TRUE;
154 			break;
155 		case 'f':
156 			force_mbr = B_TRUE;
157 			break;
158 		case 'i':
159 			do_getinfo = B_TRUE;
160 			do_install = B_FALSE;
161 			params = 1;
162 			break;
163 		case 'V':
164 			verbose_dump = B_TRUE;
165 			break;
166 		case 'd':
167 			boot_debug = B_TRUE;
168 			break;
169 		case 'F':
170 			force_update = B_TRUE;
171 			break;
172 		case 'e':
173 			strip = B_TRUE;
174 			break;
175 		case 'M':
176 			do_mirror_bblk = B_TRUE;
177 			do_install = B_FALSE;
178 			params = 2;
179 			break;
180 		case 'u':
181 			do_version = B_TRUE;
182 
183 			update_str = malloc(strlen(optarg) + 1);
184 			if (update_str == NULL) {
185 				(void) fprintf(stderr, gettext("Unable to "
186 				    "allocate memory\n"));
187 				exit(BC_ERROR);
188 			}
189 			(void) strlcpy(update_str, optarg, strlen(optarg) + 1);
190 			break;
191 		default:
192 			/* fall through to process non-optional args */
193 			break;
194 		}
195 	}
196 
197 	/* check arguments */
198 	if (argc != optind + params) {
199 		usage(argv[0]);
200 		exit(BC_ERROR);
201 	}
202 
203 	/*
204 	 * clean up options (and bail out if an unrecoverable combination is
205 	 * requested.
206 	 */
207 	progname = argv[0];
208 	check_options(progname);
209 	handle_args = argv + optind;
210 
211 	if (nowrite)
212 		(void) fprintf(stdout, DRY_RUN);
213 
214 	if (do_getinfo) {
215 		ret = handle_getinfo(progname, handle_args);
216 	} else if (do_mirror_bblk) {
217 		ret = handle_mirror(progname, handle_args);
218 	} else {
219 		ret = handle_install(progname, handle_args);
220 	}
221 	return (ret);
222 }
223 
224 #define	MEANINGLESS_OPT	gettext("%s specified but meaningless, ignoring\n")
225 static void
226 check_options(char *progname)
227 {
228 	if (do_getinfo && do_mirror_bblk) {
229 		(void) fprintf(stderr, gettext("Only one of -M and -i can be "
230 		    "specified at the same time\n"));
231 		usage(progname);
232 		exit(BC_ERROR);
233 	}
234 
235 	if (do_mirror_bblk) {
236 		/*
237 		 * -u and -F may actually reflect a user intent that is not
238 		 * correct with this command (mirror can be interpreted
239 		 * "similar" to install. Emit a message and continue.
240 		 * -e and -V have no meaning, be quiet here and only report the
241 		 * incongruence if a debug output is requested.
242 		 */
243 		if (do_version) {
244 			(void) fprintf(stderr, MEANINGLESS_OPT, "-u");
245 			do_version = B_FALSE;
246 		}
247 		if (force_update) {
248 			(void) fprintf(stderr, MEANINGLESS_OPT, "-F");
249 			force_update = B_FALSE;
250 		}
251 		if (strip || verbose_dump) {
252 			BOOT_DEBUG(MEANINGLESS_OPT, "-e|-V");
253 			strip = B_FALSE;
254 			verbose_dump = B_FALSE;
255 		}
256 	}
257 
258 	if (do_getinfo) {
259 		if (write_mbr || force_mbr || do_version || force_update) {
260 			BOOT_DEBUG(MEANINGLESS_OPT, "-m|-f|-u|-F");
261 			write_mbr = force_mbr = do_version = B_FALSE;
262 			force_update = B_FALSE;
263 		}
264 	}
265 }
266 
267 /*
268  * Install a new stage1/stage2 pair on the specified device. handle_install()
269  * expects argv to contain 3 parameters (the path to stage1, the path to stage2,
270  * the target device).
271  *
272  * Returns:	BC_SUCCESS - if the installation is successful
273  *		BC_ERROR   - if the installation failed
274  *		BC_NOUPDT  - if no installation was performed because the GRUB
275  *		             version currently installed is more recent than the
276  *			     supplied one.
277  *
278  */
279 static int
280 handle_install(char *progname, char **argv)
281 {
282 	ig_data_t	install_data;
283 	char		*stage1_path = NULL;
284 	char		*stage2_path = NULL;
285 	char		*device_path = NULL;
286 	int		ret = BC_ERROR;
287 
288 	stage1_path = strdup(argv[0]);
289 	stage2_path = strdup(argv[1]);
290 	device_path = strdup(argv[2]);
291 
292 	bzero(&install_data, sizeof (ig_data_t));
293 
294 	if (!stage1_path || !stage2_path || !device_path) {
295 		(void) fprintf(stderr, gettext("Missing parameter"));
296 		usage(progname);
297 		goto out;
298 	}
299 
300 	BOOT_DEBUG("stage1 path: %s, stage2 path: %s, device: %s\n",
301 	    stage1_path, stage2_path, device_path);
302 
303 	if (init_device(&install_data.device, device_path) != BC_SUCCESS) {
304 		(void) fprintf(stderr, gettext("Unable to gather device "
305 		    "information for %s\n"), device_path);
306 		goto out;
307 	}
308 
309 	/* read in stage1 and stage2. */
310 	if (read_stage1_from_file(stage1_path, &install_data) != BC_SUCCESS) {
311 		(void) fprintf(stderr, gettext("Error opening %s\n"),
312 		    stage1_path);
313 		goto out_dev;
314 	}
315 
316 	if (read_stage2_from_file(stage2_path, &install_data) != BC_SUCCESS) {
317 		(void) fprintf(stderr, gettext("Error opening %s\n"),
318 		    stage2_path);
319 		goto out_dev;
320 	}
321 
322 	/* We do not support versioning on PCFS. */
323 	if (is_bootpar(install_data.device.type) && do_version)
324 		do_version = B_FALSE;
325 
326 	/*
327 	 * is_update_necessary() will take care of checking if versioning and/or
328 	 * forcing the update have been specified. It will also emit a warning
329 	 * if a non-versioned update is attempted over a versioned bootblock.
330 	 */
331 	if (!is_update_necessary(&install_data, update_str)) {
332 		(void) fprintf(stderr, gettext("GRUB version installed "
333 		    "on %s is more recent or identical\n"
334 		    "Use -F to override or install without the -u option\n"),
335 		    device_path);
336 		ret = BC_NOUPDT;
337 		goto out_dev;
338 	}
339 	/*
340 	 * We get here if:
341 	 * - the installed GRUB version is older than the one about to be
342 	 *   installed.
343 	 * - no versioning string has been passed through the command line.
344 	 * - a forced update is requested (-F).
345 	 */
346 	BOOT_DEBUG("Ready to commit to disk\n");
347 	ret = commit_to_disk(&install_data, update_str);
348 
349 out_dev:
350 	cleanup_device(&install_data.device);
351 out:
352 	free(stage1_path);
353 	free(stage2_path);
354 	free(device_path);
355 	return (ret);
356 }
357 
358 /*
359  * Retrieves from a device the extended information (einfo) associated to the
360  * installed stage2.
361  * Expects one parameter, the device path, in the form: /dev/rdsk/c?[t?]d?s0.
362  * Returns:
363  *        - BC_SUCCESS (and prints out einfo contents depending on 'flags')
364  *	  - BC_ERROR (on error)
365  *        - BC_NOEINFO (no extended information available)
366  */
367 static int
368 handle_getinfo(char *progname, char **argv)
369 {
370 	ig_data_t	data;
371 	ig_stage2_t	*stage2 = &data.stage2;
372 	ig_device_t	*device = &data.device;
373 	bblk_einfo_t	*einfo;
374 	uint8_t		flags = 0;
375 	uint32_t	size;
376 	char		*device_path;
377 	int		retval = BC_ERROR;
378 	int		ret;
379 
380 	device_path = strdup(argv[0]);
381 	if (!device_path) {
382 		(void) fprintf(stderr, gettext("Missing parameter"));
383 		usage(progname);
384 		goto out;
385 	}
386 
387 	bzero(&data, sizeof (ig_data_t));
388 	BOOT_DEBUG("device path: %s\n", device_path);
389 
390 	if (init_device(device, device_path) != BC_SUCCESS) {
391 		(void) fprintf(stderr, gettext("Unable to gather device "
392 		    "information for %s\n"), device_path);
393 		goto out_dev;
394 	}
395 
396 	if (is_bootpar(device->type)) {
397 		(void) fprintf(stderr, gettext("Versioning not supported on "
398 		    "PCFS\n"));
399 		goto out_dev;
400 	}
401 
402 	ret = read_stage2_from_disk(device->part_fd, stage2, device->type);
403 	if (ret == BC_ERROR) {
404 		(void) fprintf(stderr, gettext("Error reading stage2 from "
405 		    "%s\n"), device_path);
406 		goto out_dev;
407 	}
408 
409 	if (ret == BC_NOEXTRA) {
410 		(void) fprintf(stdout, gettext("No multiboot header found on "
411 		    "%s, unable to locate extra information area\n"),
412 		    device_path);
413 		retval = BC_NOEINFO;
414 		goto out_dev;
415 	}
416 
417 	einfo = find_einfo(stage2->extra, stage2->extra_size);
418 	if (einfo == NULL) {
419 		retval = BC_NOEINFO;
420 		(void) fprintf(stderr, gettext("No extended information "
421 		    "found\n"));
422 		goto out_dev;
423 	}
424 
425 	/* Print the extended information. */
426 	if (strip)
427 		flags |= EINFO_EASY_PARSE;
428 	if (verbose_dump)
429 		flags |= EINFO_PRINT_HEADER;
430 
431 	size = stage2->buf_size - P2ROUNDUP(stage2->file_size, 8);
432 	print_einfo(flags, einfo, size);
433 	retval = BC_SUCCESS;
434 
435 out_dev:
436 	cleanup_device(&data.device);
437 out:
438 	free(device_path);
439 	return (retval);
440 }
441 
442 /*
443  * Attempt to mirror (propagate) the current stage2 over the attaching disk.
444  *
445  * Returns:
446  *	- BC_SUCCESS (a successful propagation happened)
447  *	- BC_ERROR (an error occurred)
448  *	- BC_NOEXTRA (it is not possible to dump the current bootblock since
449  *			there is no multiboot information)
450  */
451 static int
452 handle_mirror(char *progname, char **argv)
453 {
454 	ig_data_t	curr_data;
455 	ig_data_t	attach_data;
456 	ig_device_t	*curr_device = &curr_data.device;
457 	ig_device_t	*attach_device = &attach_data.device;
458 	ig_stage2_t	*stage2_curr = &curr_data.stage2;
459 	ig_stage2_t	*stage2_attach = &attach_data.stage2;
460 	bblk_einfo_t	*einfo_curr = NULL;
461 	char		*curr_device_path;
462 	char		*attach_device_path;
463 	char		*updt_str = NULL;
464 	int		retval = BC_ERROR;
465 	int		ret;
466 
467 	curr_device_path = strdup(argv[0]);
468 	attach_device_path = strdup(argv[1]);
469 
470 	if (!curr_device_path || !attach_device_path) {
471 		(void) fprintf(stderr, gettext("Missing parameter"));
472 		usage(progname);
473 		goto out;
474 	}
475 	BOOT_DEBUG("Current device path is: %s, attaching device path is: "
476 	    " %s\n", curr_device_path, attach_device_path);
477 
478 	bzero(&curr_data, sizeof (ig_data_t));
479 	bzero(&attach_data, sizeof (ig_data_t));
480 
481 	if (init_device(curr_device, curr_device_path) != BC_SUCCESS) {
482 		(void) fprintf(stderr, gettext("Unable to gather device "
483 		    "information for %s (current device)\n"), curr_device_path);
484 		goto out_currdev;
485 	}
486 
487 	if (init_device(attach_device, attach_device_path) != BC_SUCCESS) {
488 		(void) fprintf(stderr, gettext("Unable to gather device "
489 		    "information for %s (attaching device)\n"),
490 		    attach_device_path);
491 		goto out_devs;
492 	}
493 
494 	if (is_bootpar(curr_device->type) || is_bootpar(attach_device->type)) {
495 		(void) fprintf(stderr, gettext("boot block mirroring is not "
496 		    "supported on PCFS\n"));
497 		goto out_devs;
498 	}
499 
500 	ret = read_stage2_from_disk(curr_device->part_fd, stage2_curr,
501 	    curr_device->type);
502 	if (ret == BC_ERROR) {
503 		BOOT_DEBUG("Error reading first stage2 blocks from %s\n",
504 		    curr_device->path);
505 		retval = BC_ERROR;
506 		goto out_devs;
507 	}
508 
509 	if (ret == BC_NOEXTRA) {
510 		BOOT_DEBUG("No multiboot header found on %s, unable to grab "
511 		    "stage2\n", curr_device->path);
512 		retval = BC_NOEXTRA;
513 		goto out_devs;
514 	}
515 
516 	einfo_curr = find_einfo(stage2_curr->extra, stage2_curr->extra_size);
517 	if (einfo_curr != NULL)
518 		updt_str = einfo_get_string(einfo_curr);
519 
520 	write_mbr = B_TRUE;
521 	force_mbr = B_TRUE;
522 	retval = propagate_bootblock(&curr_data, &attach_data, updt_str);
523 	cleanup_stage2(stage2_curr);
524 	cleanup_stage2(stage2_attach);
525 
526 out_devs:
527 	cleanup_device(attach_device);
528 out_currdev:
529 	cleanup_device(curr_device);
530 out:
531 	free(curr_device_path);
532 	free(attach_device_path);
533 	return (retval);
534 }
535 
536 static int
537 commit_to_disk(ig_data_t *install, char *updt_str)
538 {
539 	assert(install != NULL);
540 	/*
541 	 * vanilla stage1 and stage2 need to be updated at runtime.
542 	 * Update stage2 before stage1 because stage1 needs to know the first
543 	 * sector stage2 will be written to.
544 	 */
545 	if (prepare_stage2(install, updt_str) != BC_SUCCESS) {
546 		(void) fprintf(stderr, gettext("Error building stage2\n"));
547 		return (BC_ERROR);
548 	}
549 	if (prepare_stage1(install) != BC_SUCCESS) {
550 		(void) fprintf(stderr, gettext("Error building stage1\n"));
551 		return (BC_ERROR);
552 	}
553 
554 	/* Write stage2 out to disk. */
555 	if (write_stage2(install) != BC_SUCCESS) {
556 		(void) fprintf(stderr, gettext("Error writing stage2 to "
557 		    "disk\n"));
558 		return (BC_ERROR);
559 	}
560 
561 	/* Write stage1 to disk and, if requested, to the MBR. */
562 	if (write_stage1(install) != BC_SUCCESS) {
563 		(void) fprintf(stderr, gettext("Error writing stage1 to "
564 		    "disk\n"));
565 		return (BC_ERROR);
566 	}
567 
568 	return (BC_SUCCESS);
569 }
570 
571 /*
572  * Propagate the bootblock on the source disk to the destination disk and
573  * version it with 'updt_str' in the process. Since we cannot trust any data
574  * on the attaching disk, we do not perform any specific check on a potential
575  * target extended information structure and we just blindly update.
576  */
577 static int
578 propagate_bootblock(ig_data_t *source, ig_data_t *target, char *updt_str)
579 {
580 	ig_device_t	*src_device = &source->device;
581 	ig_device_t	*dest_device = &target->device;
582 	ig_stage2_t	*src_stage2 = &source->stage2;
583 	ig_stage2_t	*dest_stage2 = &target->stage2;
584 	uint32_t	buf_size;
585 	int		retval;
586 
587 	assert(source != NULL);
588 	assert(target != NULL);
589 
590 	/* read in stage1 from the source disk. */
591 	if (read_stage1_from_disk(src_device->part_fd, target->stage1_buf)
592 	    != BC_SUCCESS)
593 		return (BC_ERROR);
594 
595 	/* Prepare target stage2 for commit_to_disk. */
596 	cleanup_stage2(dest_stage2);
597 
598 	if (updt_str != NULL)
599 		do_version = B_TRUE;
600 	else
601 		do_version = B_FALSE;
602 
603 	buf_size = src_stage2->file_size + SECTOR_SIZE;
604 
605 	dest_stage2->buf_size = P2ROUNDUP(buf_size, SECTOR_SIZE);
606 	dest_stage2->buf = malloc(dest_stage2->buf_size);
607 	if (dest_stage2->buf == NULL) {
608 		perror(gettext("Memory allocation failed"));
609 		return (BC_ERROR);
610 	}
611 	dest_stage2->file = dest_stage2->buf;
612 	dest_stage2->file_size = src_stage2->file_size;
613 	memcpy(dest_stage2->file, src_stage2->file, dest_stage2->file_size);
614 	dest_stage2->extra = dest_stage2->buf +
615 	    P2ROUNDUP(dest_stage2->file_size, 8);
616 
617 	/* If we get down here we do have a mboot structure. */
618 	assert(src_stage2->mboot);
619 
620 	dest_stage2->mboot_off = src_stage2->mboot_off;
621 	dest_stage2->mboot = (multiboot_header_t *)(dest_stage2->buf +
622 	    dest_stage2->mboot_off);
623 
624 	(void) fprintf(stdout, gettext("Propagating %s stage1/stage2 to %s\n"),
625 	    src_device->path, dest_device->path);
626 	retval = commit_to_disk(target, updt_str);
627 
628 	return (retval);
629 }
630 
631 /*
632  * open the device and fill the various members of ig_device_t.
633  */
634 static int
635 init_device(ig_device_t *device, char *path)
636 {
637 	struct dk_gpt *vtoc;
638 	fstyp_handle_t fhdl;
639 	const char *fident;
640 
641 	bzero(device, sizeof (*device));
642 	device->part_fd = -1;
643 	device->disk_fd = -1;
644 	device->path_p0 = NULL;
645 
646 	device->path = strdup(path);
647 	if (device->path == NULL) {
648 		perror(gettext("Memory allocation failed"));
649 		return (BC_ERROR);
650 	}
651 
652 	if (strstr(device->path, "diskette")) {
653 		(void) fprintf(stderr, gettext("installing GRUB to a floppy "
654 		    "disk is no longer supported\n"));
655 		return (BC_ERROR);
656 	}
657 
658 	/* Detect if the target device is a pcfs partition. */
659 	if (strstr(device->path, "p0:boot"))
660 		device->type = IG_DEV_X86BOOTPAR;
661 
662 	if (get_disk_fd(device) != BC_SUCCESS)
663 		return (BC_ERROR);
664 
665 	/* read in the device boot sector. */
666 	if (read(device->disk_fd, device->boot_sector, SECTOR_SIZE)
667 	    != SECTOR_SIZE) {
668 		(void) fprintf(stderr, gettext("Error reading boot sector\n"));
669 		perror("read");
670 		return (BC_ERROR);
671 	}
672 
673 	if (efi_alloc_and_read(device->disk_fd, &vtoc) > 0) {
674 		device->type = IG_DEV_EFI;
675 		efi_free(vtoc);
676 	}
677 
678 	if (get_raw_partition_fd(device) != BC_SUCCESS)
679 		return (BC_ERROR);
680 
681 	if (is_efi(device->type)) {
682 		if (fstyp_init(device->part_fd, 0, NULL, &fhdl) != 0)
683 			return (BC_ERROR);
684 
685 		if (fstyp_ident(fhdl, "zfs", &fident) != 0) {
686 			fstyp_fini(fhdl);
687 			(void) fprintf(stderr, gettext("Booting of EFI labeled "
688 			    "disks is only supported with ZFS\n"));
689 			return (BC_ERROR);
690 		}
691 		fstyp_fini(fhdl);
692 	}
693 
694 	if (get_start_sector(device) != BC_SUCCESS)
695 		return (BC_ERROR);
696 
697 	return (BC_SUCCESS);
698 }
699 
700 static void
701 cleanup_device(ig_device_t *device)
702 {
703 	if (device->path)
704 		free(device->path);
705 	if (device->path_p0)
706 		free(device->path_p0);
707 
708 	if (device->part_fd != -1)
709 		(void) close(device->part_fd);
710 	if (device->disk_fd != -1)
711 		(void) close(device->disk_fd);
712 
713 	bzero(device, sizeof (ig_device_t));
714 	device->part_fd = -1;
715 	device->disk_fd = -1;
716 }
717 
718 static void
719 cleanup_stage2(ig_stage2_t *stage2)
720 {
721 	if (stage2->buf)
722 		free(stage2->buf);
723 	bzero(stage2, sizeof (ig_stage2_t));
724 }
725 
726 static int
727 get_start_sector(ig_device_t *device)
728 {
729 	uint32_t		secnum = 0, numsec = 0;
730 	int			i, pno, rval, log_part = 0;
731 	struct mboot		*mboot;
732 	struct ipart		*part;
733 	ext_part_t		*epp;
734 	struct part_info	dkpi;
735 	struct extpart_info	edkpi;
736 
737 	if (is_efi(device->type)) {
738 		struct dk_gpt *vtoc;
739 
740 		if (efi_alloc_and_read(device->disk_fd, &vtoc) <= 0)
741 			return (BC_ERROR);
742 
743 		device->start_sector = vtoc->efi_parts[device->slice].p_start;
744 		/* GPT doesn't use traditional slice letters */
745 		device->slice = 0xff;
746 		device->partition = 0;
747 
748 		efi_free(vtoc);
749 		goto found_part;
750 	}
751 
752 	mboot = (struct mboot *)device->boot_sector;
753 
754 	if (is_bootpar(device->type)) {
755 		if (find_x86_bootpar(mboot, &pno, &secnum) != BC_SUCCESS) {
756 			(void) fprintf(stderr, NOBOOTPAR);
757 			return (BC_ERROR);
758 		} else {
759 			device->start_sector = secnum;
760 			device->partition = pno;
761 			goto found_part;
762 		}
763 	}
764 
765 	/*
766 	 * Search for Solaris fdisk partition
767 	 * Get the solaris partition information from the device
768 	 * and compare the offset of S2 with offset of solaris partition
769 	 * from fdisk partition table.
770 	 */
771 	if (ioctl(device->part_fd, DKIOCEXTPARTINFO, &edkpi) < 0) {
772 		if (ioctl(device->part_fd, DKIOCPARTINFO, &dkpi) < 0) {
773 			(void) fprintf(stderr, PART_FAIL);
774 			return (BC_ERROR);
775 		} else {
776 			edkpi.p_start = dkpi.p_start;
777 		}
778 	}
779 
780 	for (i = 0; i < FD_NUMPART; i++) {
781 		part = (struct ipart *)mboot->parts + i;
782 
783 		if (part->relsect == 0) {
784 			(void) fprintf(stderr, BAD_PART, i);
785 			return (BC_ERROR);
786 		}
787 
788 		if (edkpi.p_start >= part->relsect &&
789 		    edkpi.p_start < (part->relsect + part->numsect)) {
790 			/* Found the partition */
791 			break;
792 		}
793 	}
794 
795 	if (i == FD_NUMPART) {
796 		/* No solaris fdisk partitions (primary or logical) */
797 		(void) fprintf(stderr, NOSOLPAR);
798 		return (BC_ERROR);
799 	}
800 
801 	/*
802 	 * We have found a Solaris fdisk partition (primary or extended)
803 	 * Handle the simple case first: Solaris in a primary partition
804 	 */
805 	if (!fdisk_is_dos_extended(part->systid)) {
806 		device->start_sector = part->relsect;
807 		device->partition = i;
808 		goto found_part;
809 	}
810 
811 	/*
812 	 * Solaris in a logical partition. Find that partition in the
813 	 * extended part.
814 	 */
815 	if ((rval = libfdisk_init(&epp, device->path_p0, NULL, FDISK_READ_DISK))
816 	    != FDISK_SUCCESS) {
817 		switch (rval) {
818 			/*
819 			 * The first 3 cases are not an error per-se, just that
820 			 * there is no Solaris logical partition
821 			 */
822 			case FDISK_EBADLOGDRIVE:
823 			case FDISK_ENOLOGDRIVE:
824 			case FDISK_EBADMAGIC:
825 				(void) fprintf(stderr, NOSOLPAR);
826 				return (BC_ERROR);
827 			case FDISK_ENOVGEOM:
828 				(void) fprintf(stderr, NO_VIRT_GEOM);
829 				return (BC_ERROR);
830 			case FDISK_ENOPGEOM:
831 				(void) fprintf(stderr, NO_PHYS_GEOM);
832 				return (BC_ERROR);
833 			case FDISK_ENOLGEOM:
834 				(void) fprintf(stderr, NO_LABEL_GEOM);
835 				return (BC_ERROR);
836 			default:
837 				(void) fprintf(stderr, LIBFDISK_INIT_FAIL);
838 				return (BC_ERROR);
839 		}
840 	}
841 
842 	rval = fdisk_get_solaris_part(epp, &pno, &secnum, &numsec);
843 	libfdisk_fini(&epp);
844 	if (rval != FDISK_SUCCESS) {
845 		/* No solaris logical partition */
846 		(void) fprintf(stderr, NOSOLPAR);
847 		return (BC_ERROR);
848 	}
849 
850 	device->start_sector = secnum;
851 	device->partition = pno - 1;
852 	log_part = 1;
853 
854 found_part:
855 	/* get confirmation for -m */
856 	if (write_mbr && !force_mbr) {
857 		(void) fprintf(stdout, MBOOT_PROMPT);
858 		if (!yes()) {
859 			write_mbr = 0;
860 			(void) fprintf(stdout, MBOOT_NOT_UPDATED);
861 			return (BC_ERROR);
862 		}
863 	}
864 
865 	/*
866 	 * Currently if Solaris is in an extended partition we need to
867 	 * write GRUB to the MBR. Check for this.
868 	 */
869 	if (log_part && !write_mbr) {
870 		(void) fprintf(stdout, gettext("Installing Solaris on an "
871 		    "extended partition... forcing MBR update\n"));
872 		write_mbr = 1;
873 	}
874 
875 	/*
876 	 * warn, if Solaris in primary partition and GRUB not in MBR and
877 	 * partition is not active
878 	 */
879 	if (!log_part && part->bootid != 128 && !write_mbr) {
880 		(void) fprintf(stdout, SOLPAR_INACTIVE, device->partition + 1);
881 	}
882 
883 	return (BC_SUCCESS);
884 }
885 
886 static int
887 get_disk_fd(ig_device_t *device)
888 {
889 	int	i;
890 	char	save[2];
891 	char	*end = NULL;
892 
893 	assert(device != NULL);
894 	assert(device->path != NULL);
895 
896 	if (is_bootpar(device->type)) {
897 		end = strstr(device->path, "p0:boot");
898 		/* tested at the start of init_device() */
899 		assert(end != NULL);
900 		/* chop off :boot */
901 		save[0] = end[2];
902 		end[2] = '\0';
903 	} else {
904 		i = strlen(device->path);
905 		save[0] = device->path[i - 2];
906 		save[1] = device->path[i - 1];
907 		device->path[i - 2] = 'p';
908 		device->path[i - 1] = '0';
909 	}
910 
911 	if (nowrite)
912 		device->disk_fd = open(device->path, O_RDONLY);
913 	else
914 		device->disk_fd = open(device->path, O_RDWR);
915 
916 	device->path_p0 = strdup(device->path);
917 	if (device->path_p0 == NULL) {
918 		perror("strdup");
919 		return (BC_ERROR);
920 	}
921 
922 	if (is_bootpar(device->type)) {
923 		end[2] = save[0];
924 	} else {
925 		device->path[i - 2] = save[0];
926 		device->path[i - 1] = save[1];
927 	}
928 
929 	if (device->disk_fd == -1) {
930 		perror("open");
931 		return (BC_ERROR);
932 	}
933 
934 	return (BC_SUCCESS);
935 }
936 
937 static void
938 prepare_fake_multiboot(ig_stage2_t *stage2)
939 {
940 	multiboot_header_t	*mboot;
941 
942 	assert(stage2 != NULL);
943 	assert(stage2->mboot != NULL);
944 	assert(stage2->buf != NULL);
945 
946 	mboot = stage2->mboot;
947 
948 	/*
949 	 * Currently we expect find_multiboot() to have located a multiboot
950 	 * header with the AOUT kludge flag set.
951 	 */
952 	assert(mboot->flags & BB_MBOOT_AOUT_FLAG);
953 
954 	/* Insert the information necessary to locate stage2. */
955 	mboot->header_addr = stage2->mboot_off;
956 	mboot->load_addr = 0;
957 	mboot->load_end_addr = stage2->file_size;
958 }
959 
960 static void
961 add_stage2_einfo(ig_stage2_t *stage2, char *updt_str)
962 {
963 	bblk_hs_t	hs;
964 	uint32_t	avail_space;
965 
966 	assert(stage2 != NULL);
967 
968 	/* Fill bootblock hashing source information. */
969 	hs.src_buf = (unsigned char *)stage2->file;
970 	hs.src_size = stage2->file_size;
971 	/* How much space for the extended information structure? */
972 	avail_space = stage2->buf_size - P2ROUNDUP(stage2->file_size, 8);
973 	add_einfo(stage2->extra, updt_str, &hs, avail_space);
974 }
975 
976 
977 static int
978 write_stage2(ig_data_t *install)
979 {
980 	ig_device_t		*device = &install->device;
981 	ig_stage2_t		*stage2 = &install->stage2;
982 	off_t			offset;
983 
984 	assert(install != NULL);
985 
986 	if (is_bootpar(device->type)) {
987 		/*
988 		 * stage2 is already on the filesystem, we only need to update
989 		 * the first two blocks (that we have modified during
990 		 * prepare_stage2())
991 		 */
992 		if (write_out(device->part_fd, stage2->file, SECTOR_SIZE,
993 		    stage2->pcfs_first_sectors[0] * SECTOR_SIZE)
994 		    != BC_SUCCESS ||
995 		    write_out(device->part_fd, stage2->file + SECTOR_SIZE,
996 		    SECTOR_SIZE, stage2->pcfs_first_sectors[1] * SECTOR_SIZE)
997 		    != BC_SUCCESS) {
998 			(void) fprintf(stderr, WRITE_FAIL_STAGE2);
999 			return (BC_ERROR);
1000 		}
1001 		(void) fprintf(stdout, WRITE_STAGE2_PCFS);
1002 		return (BC_SUCCESS);
1003 	}
1004 
1005 	/*
1006 	 * For disk, write stage2 starting at STAGE2_BLKOFF sector.
1007 	 * Note that we use stage2->buf rather than stage2->file, because we
1008 	 * may have extended information after the latter.
1009 	 *
1010 	 * If we're writing to an EFI-labeled disk where stage2 lives in the
1011 	 * 3.5MB boot loader gap following the ZFS vdev labels, make sure the
1012 	 * size of the buffer doesn't exceed the size of the gap.
1013 	 */
1014 	if (is_efi(device->type) && stage2->buf_size > STAGE2_MAXSIZE) {
1015 		(void) fprintf(stderr, WRITE_FAIL_STAGE2);
1016 		return (BC_ERROR);
1017 	}
1018 
1019 	offset = STAGE2_BLKOFF(device->type) * SECTOR_SIZE;
1020 
1021 	if (write_out(device->part_fd, stage2->buf, stage2->buf_size,
1022 	    offset) != BC_SUCCESS) {
1023 		perror("write");
1024 		return (BC_ERROR);
1025 	}
1026 
1027 	/* Simulate the "old" installgrub output. */
1028 	(void) fprintf(stdout, WRITE_STAGE2_DISK, device->partition,
1029 	    (stage2->buf_size / SECTOR_SIZE) + 1, STAGE2_BLKOFF(device->type),
1030 	    stage2->first_sector);
1031 
1032 	return (BC_SUCCESS);
1033 }
1034 
1035 static int
1036 write_stage1(ig_data_t *install)
1037 {
1038 	ig_device_t	*device = &install->device;
1039 
1040 	assert(install != NULL);
1041 
1042 	if (write_out(device->part_fd, install->stage1_buf,
1043 	    sizeof (install->stage1_buf), 0) != BC_SUCCESS) {
1044 		(void) fprintf(stdout, WRITE_FAIL_PBOOT);
1045 		perror("write");
1046 		return (BC_ERROR);
1047 	}
1048 
1049 	/* Simulate "old" installgrub output. */
1050 	(void) fprintf(stdout, WRITE_PBOOT, device->partition,
1051 	    device->start_sector);
1052 
1053 	if (write_mbr) {
1054 		if (write_out(device->disk_fd, install->stage1_buf,
1055 		    sizeof (install->stage1_buf), 0) != BC_SUCCESS) {
1056 			(void) fprintf(stdout, WRITE_FAIL_BOOTSEC);
1057 			perror("write");
1058 			return (BC_ERROR);
1059 		}
1060 		/* Simulate "old" installgrub output. */
1061 		(void) fprintf(stdout, WRITE_MBOOT);
1062 	}
1063 
1064 	return (BC_SUCCESS);
1065 }
1066 
1067 #define	USAGE_STRING	"%s [-m|-f|-n|-F|-u verstr] stage1 stage2 device\n"    \
1068 			"%s -M [-n] device1 device2\n"			       \
1069 			"%s [-V|-e] -i device\n"			       \
1070 
1071 #define	CANON_USAGE_STR	gettext(USAGE_STRING)
1072 
1073 static void
1074 usage(char *progname)
1075 {
1076 	(void) fprintf(stdout, CANON_USAGE_STR, progname, progname, progname);
1077 }
1078 
1079 
1080 static int
1081 read_stage1_from_file(char *path, ig_data_t *dest)
1082 {
1083 	int	fd;
1084 
1085 	assert(dest);
1086 
1087 	/* read the stage1 file from filesystem */
1088 	fd = open(path, O_RDONLY);
1089 	if (fd == -1 ||
1090 	    read(fd, dest->stage1_buf, SECTOR_SIZE) != SECTOR_SIZE) {
1091 		(void) fprintf(stderr, READ_FAIL_STAGE1, path);
1092 		return (BC_ERROR);
1093 	}
1094 	(void) close(fd);
1095 	return (BC_SUCCESS);
1096 }
1097 
1098 static int
1099 read_stage2_from_file(char *path, ig_data_t *dest)
1100 {
1101 	int		fd;
1102 	struct stat	sb;
1103 	ig_stage2_t	*stage2 = &dest->stage2;
1104 	ig_device_t	*device = &dest->device;
1105 	uint32_t	buf_size;
1106 
1107 	assert(dest);
1108 	assert(stage2->buf == NULL);
1109 
1110 	fd = open(path, O_RDONLY);
1111 	if (fstat(fd, &sb) == -1) {
1112 		perror("fstat");
1113 		goto out;
1114 	}
1115 
1116 	stage2->file_size = sb.st_size;
1117 
1118 	if (!is_bootpar(device->type)) {
1119 		/*
1120 		 * buffer size needs to account for stage2 plus the extra
1121 		 * versioning information at the end of it. We reserve one
1122 		 * extra sector (plus we round up to the next sector boundary).
1123 		 */
1124 		buf_size = stage2->file_size + SECTOR_SIZE;
1125 	} else {
1126 		/* In the PCFS case we only need to read in stage2. */
1127 		buf_size = stage2->file_size;
1128 	}
1129 
1130 	stage2->buf_size = P2ROUNDUP(buf_size, SECTOR_SIZE);
1131 
1132 	BOOT_DEBUG("stage2 buffer size = %d (%d sectors)\n", stage2->buf_size,
1133 	    stage2->buf_size / SECTOR_SIZE);
1134 
1135 	stage2->buf = malloc(stage2->buf_size);
1136 	if (stage2->buf == NULL) {
1137 		perror(gettext("Memory allocation failed"));
1138 		goto out_fd;
1139 	}
1140 
1141 	stage2->file = stage2->buf;
1142 
1143 	/*
1144 	 * Extra information (e.g. the versioning structure) is placed at the
1145 	 * end of stage2, aligned on a 8-byte boundary.
1146 	 */
1147 	if (!(is_bootpar(device->type)))
1148 		stage2->extra = stage2->file + P2ROUNDUP(stage2->file_size, 8);
1149 
1150 	if (lseek(fd, 0, SEEK_SET) == -1) {
1151 		perror("lseek");
1152 		goto out_alloc;
1153 	}
1154 
1155 	if (read(fd, stage2->file, stage2->file_size) < 0) {
1156 		perror(gettext("unable to read stage2"));
1157 		goto out_alloc;
1158 	}
1159 
1160 	(void) close(fd);
1161 	return (BC_SUCCESS);
1162 
1163 out_alloc:
1164 	free(stage2->buf);
1165 	stage2->buf = NULL;
1166 out_fd:
1167 	(void) close(fd);
1168 out:
1169 	return (BC_ERROR);
1170 }
1171 
1172 static int
1173 prepare_stage1(ig_data_t *install)
1174 {
1175 	ig_device_t	*device = &install->device;
1176 
1177 	assert(install != NULL);
1178 
1179 	/* If PCFS add the BIOS Parameter Block. */
1180 	if (is_bootpar(device->type)) {
1181 		char	bpb_sect[SECTOR_SIZE];
1182 
1183 		if (pread(device->part_fd, bpb_sect, SECTOR_SIZE, 0)
1184 		    != SECTOR_SIZE) {
1185 			(void) fprintf(stderr, READ_FAIL_BPB);
1186 			return (BC_ERROR);
1187 		}
1188 		bcopy(bpb_sect + STAGE1_BPB_OFFSET,
1189 		    install->stage1_buf + STAGE1_BPB_OFFSET, STAGE1_BPB_SIZE);
1190 	}
1191 
1192 	/* copy MBR to stage1 in case of overwriting MBR sector. */
1193 	bcopy(device->boot_sector + BOOTSZ, install->stage1_buf + BOOTSZ,
1194 	    SECTOR_SIZE - BOOTSZ);
1195 	/* modify default stage1 file generated by GRUB. */
1196 	*((unsigned char *)(install->stage1_buf + STAGE1_FORCE_LBA)) = 1;
1197 	*((ulong_t *)(install->stage1_buf + STAGE1_STAGE2_SECTOR))
1198 	    = install->stage2.first_sector;
1199 	*((ushort_t *)(install->stage1_buf + STAGE1_STAGE2_ADDRESS))
1200 	    = STAGE2_MEMADDR;
1201 	*((ushort_t *)(install->stage1_buf + STAGE1_STAGE2_SEGMENT))
1202 	    = STAGE2_MEMADDR >> 4;
1203 
1204 	return (BC_SUCCESS);
1205 }
1206 
1207 /*
1208  * Grab stage1 from the specified device file descriptor.
1209  */
1210 static int
1211 read_stage1_from_disk(int dev_fd, char *stage1_buf)
1212 {
1213 	assert(stage1_buf != NULL);
1214 
1215 	if (read_in(dev_fd, stage1_buf, SECTOR_SIZE, 0) != BC_SUCCESS) {
1216 		perror(gettext("Unable to read stage1 from disk"));
1217 		return (BC_ERROR);
1218 	}
1219 	return (BC_SUCCESS);
1220 }
1221 
1222 static int
1223 read_stage2_from_disk(int dev_fd, ig_stage2_t *stage2, int type)
1224 {
1225 	uint32_t		size;
1226 	uint32_t		buf_size;
1227 	uint32_t		mboot_off;
1228 	multiboot_header_t	*mboot;
1229 
1230 	assert(stage2 != NULL);
1231 	assert(dev_fd != -1);
1232 
1233 	if (read_in(dev_fd, mboot_scan, sizeof (mboot_scan),
1234 	    STAGE2_BLKOFF(type) * SECTOR_SIZE) != BC_SUCCESS) {
1235 		perror(gettext("Error reading stage2 sectors"));
1236 		return (BC_ERROR);
1237 	}
1238 
1239 	/* No multiboot means no chance of knowing stage2 size */
1240 	if (find_multiboot(mboot_scan, sizeof (mboot_scan), &mboot_off)
1241 	    != BC_SUCCESS) {
1242 		BOOT_DEBUG("Unable to find multiboot header\n");
1243 		return (BC_NOEXTRA);
1244 	}
1245 	mboot = (multiboot_header_t *)(mboot_scan + mboot_off);
1246 
1247 	/*
1248 	 * Unfilled mboot values mean an older version of installgrub installed
1249 	 * the stage2. Again we have no chance of knowing stage2 size.
1250 	 */
1251 	if (mboot->load_end_addr == 0 ||
1252 	    mboot->load_end_addr < mboot->load_addr)
1253 		return (BC_NOEXTRA);
1254 
1255 	/*
1256 	 * Currently, the amount of space reserved for extra information
1257 	 * is "fixed". We may have to scan for the terminating extra payload
1258 	 * in the future.
1259 	 */
1260 	size = mboot->load_end_addr - mboot->load_addr;
1261 	buf_size = P2ROUNDUP(size + SECTOR_SIZE, SECTOR_SIZE);
1262 
1263 	stage2->buf = malloc(buf_size);
1264 	if (stage2->buf == NULL) {
1265 		perror(gettext("Memory allocation failed"));
1266 		return (BC_ERROR);
1267 	}
1268 	stage2->buf_size = buf_size;
1269 
1270 	if (read_in(dev_fd, stage2->buf, buf_size, STAGE2_BLKOFF(type) *
1271 	    SECTOR_SIZE) != BC_SUCCESS) {
1272 		perror("read");
1273 		free(stage2->buf);
1274 		return (BC_ERROR);
1275 	}
1276 
1277 	/* Update pointers. */
1278 	stage2->file = stage2->buf;
1279 	stage2->file_size = size;
1280 	stage2->mboot_off = mboot_off;
1281 	stage2->mboot = (multiboot_header_t *)(stage2->buf + stage2->mboot_off);
1282 	stage2->extra = stage2->buf + P2ROUNDUP(stage2->file_size, 8);
1283 	stage2->extra_size = stage2->buf_size - P2ROUNDUP(stage2->file_size, 8);
1284 
1285 	return (BC_SUCCESS);
1286 }
1287 
1288 static boolean_t
1289 is_update_necessary(ig_data_t *data, char *updt_str)
1290 {
1291 	bblk_einfo_t	*einfo;
1292 	bblk_hs_t	stage2_hs;
1293 	ig_stage2_t	stage2_disk;
1294 	ig_stage2_t	*stage2_file = &data->stage2;
1295 	ig_device_t	*device = &data->device;
1296 	int		dev_fd = device->part_fd;
1297 
1298 	assert(data != NULL);
1299 	assert(device->part_fd != -1);
1300 
1301 	bzero(&stage2_disk, sizeof (ig_stage2_t));
1302 
1303 	/* Gather stage2 (if present) from the target device. */
1304 	if (read_stage2_from_disk(dev_fd, &stage2_disk, device->type)
1305 	    != BC_SUCCESS) {
1306 		BOOT_DEBUG("Unable to read stage2 from %s\n", device->path);
1307 		BOOT_DEBUG("No multiboot wrapped stage2 on %s\n", device->path);
1308 		return (B_TRUE);
1309 	}
1310 
1311 	/*
1312 	 * Look for the extended information structure in the extra payload
1313 	 * area.
1314 	 */
1315 	einfo = find_einfo(stage2_disk.extra, stage2_disk.extra_size);
1316 	if (einfo == NULL) {
1317 		BOOT_DEBUG("No extended information available\n");
1318 		return (B_TRUE);
1319 	}
1320 
1321 	if (!do_version || updt_str == NULL) {
1322 		(void) fprintf(stdout, "WARNING: target device %s has a "
1323 		    "versioned stage2 that is going to be overwritten by a non "
1324 		    "versioned one\n", device->path);
1325 		return (B_TRUE);
1326 	}
1327 
1328 	if (force_update) {
1329 		BOOT_DEBUG("Forcing update of %s bootblock\n", device->path);
1330 		return (B_TRUE);
1331 	}
1332 
1333 	/* Compare the two extended information structures. */
1334 	stage2_hs.src_buf = (unsigned char *)stage2_file->file;
1335 	stage2_hs.src_size = stage2_file->file_size;
1336 
1337 	return (einfo_should_update(einfo, &stage2_hs, updt_str));
1338 }
1339 
1340 
1341 #define	START_BLOCK(pos)	(*(ulong_t *)(pos))
1342 #define	NUM_BLOCK(pos)		(*(ushort_t *)((pos) + 4))
1343 #define	START_SEG(pos)		(*(ushort_t *)((pos) + 6))
1344 
1345 static int
1346 prepare_stage2(ig_data_t *install, char *updt_str)
1347 {
1348 	ig_device_t	*device = &install->device;
1349 	ig_stage2_t	*stage2 = &install->stage2;
1350 	uint32_t	mboot_off = 0;
1351 
1352 	assert(install != NULL);
1353 	assert(stage2->file != NULL);
1354 
1355 	/* New stage2 files come with an embedded stage2. */
1356 	if (find_multiboot(stage2->file, stage2->file_size, &mboot_off)
1357 	    != BC_SUCCESS) {
1358 		BOOT_DEBUG("WARNING: no multiboot structure found in stage2, "
1359 		    "are you using an old GRUB stage2?\n");
1360 		if (do_version == B_TRUE) {
1361 			(void) fprintf(stderr, gettext("Versioning requested "
1362 			    "but stage2 does not support it.. skipping.\n"));
1363 			do_version = B_FALSE;
1364 		}
1365 	} else {
1366 		/* Keep track of where the multiboot header is. */
1367 		stage2->mboot_off = mboot_off;
1368 		stage2->mboot = (multiboot_header_t *)(stage2->file +
1369 		    mboot_off);
1370 		if (do_version) {
1371 			/*
1372 			 * Adding stage2 information needs to happen before
1373 			 * we modify the copy of stage2 we have in memory, so
1374 			 * that the hashing reflects the one of the file.
1375 			 * An error here is not fatal.
1376 			 */
1377 			add_stage2_einfo(stage2, updt_str);
1378 		}
1379 		/*
1380 		 * Fill multiboot information. We add them even without
1381 		 * versioning to support as much as possible mirroring.
1382 		 */
1383 		prepare_fake_multiboot(stage2);
1384 	}
1385 
1386 	if (is_bootpar(device->type)) {
1387 		uint32_t	blocklist[SECTOR_SIZE / sizeof (uint32_t)];
1388 		uint32_t	install_addr = STAGE2_MEMADDR + SECTOR_SIZE;
1389 		int		i = 0;
1390 		uchar_t		*pos;
1391 
1392 		bzero(blocklist, sizeof (blocklist));
1393 		if (read_stage2_blocklist(device->part_fd, blocklist) != 0) {
1394 			(void) fprintf(stderr, gettext("Error reading pcfs "
1395 			    "stage2 blocklist\n"));
1396 			return (BC_ERROR);
1397 		}
1398 
1399 		pos = (uchar_t *)stage2->file + STAGE2_BLOCKLIST;
1400 		stage2->first_sector = device->start_sector + blocklist[0];
1401 		stage2->pcfs_first_sectors[0] = blocklist[0];
1402 		BOOT_DEBUG("stage2 first sector: %d\n", stage2->first_sector);
1403 
1404 
1405 		if (blocklist[1] > 1) {
1406 			blocklist[0]++;
1407 			blocklist[1]--;
1408 		} else {
1409 			i += 2;
1410 		}
1411 
1412 		stage2->pcfs_first_sectors[1] = blocklist[i];
1413 
1414 		while (blocklist[i]) {
1415 			if (START_BLOCK(pos - 8) != 0 &&
1416 			    START_BLOCK(pos - 8) != blocklist[i + 2]) {
1417 				(void) fprintf(stderr, PCFS_FRAGMENTED);
1418 				return (BC_ERROR);
1419 			}
1420 			START_BLOCK(pos) = blocklist[i] + device->start_sector;
1421 			START_SEG(pos) = (ushort_t)(install_addr >> 4);
1422 			NUM_BLOCK(pos) = blocklist[i + 1];
1423 			install_addr += blocklist[i + 1] * SECTOR_SIZE;
1424 			pos -= 8;
1425 			i += 2;
1426 		}
1427 	} else {
1428 		/* Solaris VTOC */
1429 		stage2->first_sector = device->start_sector +
1430 		    STAGE2_BLKOFF(device->type);
1431 		BOOT_DEBUG("stage2 first sector: %d\n", stage2->first_sector);
1432 		/*
1433 		 * In a solaris partition, stage2 is written to contiguous
1434 		 * blocks. So we update the starting block only.
1435 		 */
1436 		*((ulong_t *)(stage2->file + STAGE2_BLOCKLIST)) =
1437 		    stage2->first_sector + 1;
1438 	}
1439 
1440 	/* force lba and set disk partition */
1441 	*((unsigned char *) (stage2->file + STAGE2_FORCE_LBA)) = 1;
1442 	*((long *)(stage2->file + STAGE2_INSTALLPART))
1443 	    = (device->partition << 16) | (device->slice << 8) | 0xff;
1444 
1445 	return (BC_SUCCESS);
1446 }
1447 
1448 static int
1449 find_x86_bootpar(struct mboot *mboot, int *part_num, uint32_t *start_sect)
1450 {
1451 	int	i;
1452 
1453 	for (i = 0; i < FD_NUMPART; i++) {
1454 		struct ipart	*part;
1455 
1456 		part = (struct ipart *)mboot->parts + i;
1457 		if (part->systid == 0xbe) {
1458 			if (start_sect)
1459 				*start_sect = part->relsect;
1460 			if (part_num)
1461 				*part_num = i;
1462 			/* solaris boot part */
1463 			return (BC_SUCCESS);
1464 		}
1465 	}
1466 	return (BC_ERROR);
1467 }
1468 
1469 static char *
1470 get_raw_partition_path(ig_device_t *device)
1471 {
1472 	char	*raw;
1473 	int	len;
1474 
1475 	if (is_bootpar(device->type)) {
1476 		int		part;
1477 		struct mboot	*mboot;
1478 
1479 		mboot = (struct mboot *)device->boot_sector;
1480 		if (find_x86_bootpar(mboot, &part, NULL) != BC_SUCCESS) {
1481 			(void) fprintf(stderr, BOOTPAR_NOTFOUND,
1482 			    device->path_p0);
1483 			return (NULL);
1484 		}
1485 
1486 		raw = strdup(device->path_p0);
1487 		if (raw == NULL) {
1488 			perror(gettext("Memory allocation failed"));
1489 			return (NULL);
1490 		}
1491 
1492 		raw[strlen(raw) - 2] = '1' + part;
1493 		return (raw);
1494 	}
1495 
1496 	/* For disk, remember slice and return whole fdisk partition  */
1497 	raw = strdup(device->path);
1498 	if (raw == NULL) {
1499 		perror(gettext("Memory allocation failed"));
1500 		return (NULL);
1501 	}
1502 
1503 	len = strlen(raw);
1504 	if (!is_efi(device->type) &&
1505 	    (raw[len - 2] != 's' || raw[len - 1] == '2')) {
1506 		(void) fprintf(stderr, NOT_ROOT_SLICE);
1507 		free(raw);
1508 		return (NULL);
1509 	}
1510 	device->slice = atoi(&raw[len - 1]);
1511 
1512 	if (!is_efi(device->type)) {
1513 		raw[len - 2] = 's';
1514 		raw[len - 1] = '2';
1515 	}
1516 
1517 	return (raw);
1518 }
1519 
1520 static int
1521 get_raw_partition_fd(ig_device_t *device)
1522 {
1523 	struct stat	stat = {0};
1524 	char		*raw;
1525 
1526 	raw = get_raw_partition_path(device);
1527 	if (raw == NULL)
1528 		return (BC_ERROR);
1529 
1530 	if (nowrite)
1531 		device->part_fd = open(raw, O_RDONLY);
1532 	else
1533 		device->part_fd = open(raw, O_RDWR);
1534 
1535 	if (device->part_fd < 0 || fstat(device->part_fd, &stat) != 0) {
1536 		(void) fprintf(stderr, OPEN_FAIL, raw);
1537 		free(raw);
1538 		return (BC_ERROR);
1539 	}
1540 
1541 	if (S_ISCHR(stat.st_mode) == 0) {
1542 		(void) fprintf(stderr, NOT_RAW_DEVICE, raw);
1543 		(void) close(device->part_fd);
1544 		device->part_fd = -1;
1545 		free(raw);
1546 		return (BC_ERROR);
1547 	}
1548 
1549 	free(raw);
1550 	return (BC_SUCCESS);
1551 }
1552 
1553 #define	TMP_MNTPT	"/tmp/installgrub_pcfs"
1554 static int
1555 copy_stage2_to_pcfs(ig_data_t *install)
1556 {
1557 	FILE		*mntfp;
1558 	int		pcfs_fp;
1559 	int		status = BC_ERROR;
1560 	char		buf[SECTOR_SIZE];
1561 	char		*cp;
1562 	struct mnttab	mp = {0}, mpref = {0};
1563 	ig_device_t	*device = &install->device;
1564 	ig_stage2_t	*stage2 = &install->stage2;
1565 
1566 	/* convert raw to block device name by removing the first 'r' */
1567 	(void) strncpy(buf, device->path, sizeof (buf));
1568 	buf[sizeof (buf) - 1] = 0;
1569 	cp = strchr(buf, 'r');
1570 	if (cp == NULL) {
1571 		(void) fprintf(stderr, CONVERT_FAIL, device->path);
1572 		return (BC_ERROR);
1573 	}
1574 	do {
1575 		*cp = *(cp + 1);
1576 	} while (*(++cp));
1577 
1578 	/* get the mount point, if any */
1579 	mntfp = fopen("/etc/mnttab", "r");
1580 	if (mntfp == NULL) {
1581 		(void) fprintf(stderr, OPEN_FAIL_FILE, "/etc/mnttab");
1582 		return (BC_ERROR);
1583 	}
1584 
1585 	mpref.mnt_special = buf;
1586 	if (getmntany(mntfp, &mp, &mpref) != 0) {
1587 		char cmd[128];
1588 
1589 		/* not mounted, try remount */
1590 		(void) mkdir(TMP_MNTPT, S_IRWXU);
1591 		(void) snprintf(cmd, sizeof (cmd), "mount -F pcfs %s %s",
1592 		    buf, TMP_MNTPT);
1593 		(void) system(cmd);
1594 		rewind(mntfp);
1595 		bzero(&mp, sizeof (mp));
1596 		if (getmntany(mntfp, &mp, &mpref) != 0) {
1597 			(void) fprintf(stderr, MOUNT_FAIL, buf);
1598 			return (BC_ERROR);
1599 		}
1600 	}
1601 
1602 	(void) snprintf(buf, sizeof (buf),
1603 	    "%s/boot", mp.mnt_mountp);
1604 	(void) mkdir(buf, S_IRWXU);
1605 	(void) strcat(buf, "/grub");
1606 	(void) mkdir(buf, S_IRWXU);
1607 
1608 	(void) strcat(buf, "/stage2");
1609 	pcfs_fp = open(buf, O_WRONLY | O_CREAT, S_IRWXU);
1610 	if (pcfs_fp == -1) {
1611 		(void) fprintf(stderr, OPEN_FAIL_FILE, buf);
1612 		perror("open:");
1613 		goto out;
1614 	}
1615 
1616 	/* write stage2 to the pcfs mounted filesystem. */
1617 	if (write(pcfs_fp, stage2->file, stage2->file_size)
1618 	    != stage2->file_size) {
1619 		perror(gettext("Error writing stage2"));
1620 		goto out;
1621 	}
1622 
1623 	status = BC_SUCCESS;
1624 out_fd:
1625 	(void) close(pcfs_fp);
1626 out:
1627 	(void) umount(TMP_MNTPT);
1628 	(void) rmdir(TMP_MNTPT);
1629 	return (status);
1630 }
1631