xref: /titanic_50/usr/src/lib/libefi/common/rdwr_efi.c (revision b599bd937c305a895426e8c412ca920ce7824850)
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 (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
25  * Copyright 2014 Toomas Soome <tsoome@me.com>
26  */
27 
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <errno.h>
31 #include <strings.h>
32 #include <unistd.h>
33 #include <uuid/uuid.h>
34 #include <libintl.h>
35 #include <sys/types.h>
36 #include <sys/dkio.h>
37 #include <sys/vtoc.h>
38 #include <sys/mhd.h>
39 #include <sys/param.h>
40 #include <sys/dktp/fdisk.h>
41 #include <sys/efi_partition.h>
42 #include <sys/byteorder.h>
43 #include <sys/ddi.h>
44 
45 static struct uuid_to_ptag {
46 	struct uuid	uuid;
47 } conversion_array[] = {
48 	{ EFI_UNUSED },
49 	{ EFI_BOOT },
50 	{ EFI_ROOT },
51 	{ EFI_SWAP },
52 	{ EFI_USR },
53 	{ EFI_BACKUP },
54 	{ 0 },			/* STAND is never used */
55 	{ EFI_VAR },
56 	{ EFI_HOME },
57 	{ EFI_ALTSCTR },
58 	{ 0 },			/* CACHE is never used */
59 	{ EFI_RESERVED },
60 	{ EFI_SYSTEM },
61 	{ EFI_LEGACY_MBR },
62 	{ EFI_SYMC_PUB },
63 	{ EFI_SYMC_CDS },
64 	{ EFI_MSFT_RESV },
65 	{ EFI_DELL_BASIC },
66 	{ EFI_DELL_RAID },
67 	{ EFI_DELL_SWAP },
68 	{ EFI_DELL_LVM },
69 	{ EFI_DELL_RESV },
70 	{ EFI_AAPL_HFS },
71 	{ EFI_AAPL_UFS },
72 	{ EFI_BIOS_BOOT },
73 	{ EFI_FREEBSD_BOOT },
74 	{ EFI_FREEBSD_SWAP },
75 	{ EFI_FREEBSD_UFS },
76 	{ EFI_FREEBSD_VINUM },
77 	{ EFI_FREEBSD_ZFS }
78 };
79 
80 /*
81  * Default vtoc information for non-SVr4 partitions
82  */
83 struct dk_map2  default_vtoc_map[NDKMAP] = {
84 	{	V_ROOT,		0	},		/* a - 0 */
85 	{	V_SWAP,		V_UNMNT	},		/* b - 1 */
86 	{	V_BACKUP,	V_UNMNT	},		/* c - 2 */
87 	{	V_UNASSIGNED,	0	},		/* d - 3 */
88 	{	V_UNASSIGNED,	0	},		/* e - 4 */
89 	{	V_UNASSIGNED,	0	},		/* f - 5 */
90 	{	V_USR,		0	},		/* g - 6 */
91 	{	V_UNASSIGNED,	0	},		/* h - 7 */
92 
93 #if defined(_SUNOS_VTOC_16)
94 
95 #if defined(i386) || defined(__amd64)
96 	{	V_BOOT,		V_UNMNT	},		/* i - 8 */
97 	{	V_ALTSCTR,	0	},		/* j - 9 */
98 
99 #else
100 #error No VTOC format defined.
101 #endif			/* defined(i386) */
102 
103 	{	V_UNASSIGNED,	0	},		/* k - 10 */
104 	{	V_UNASSIGNED,	0	},		/* l - 11 */
105 	{	V_UNASSIGNED,	0	},		/* m - 12 */
106 	{	V_UNASSIGNED,	0	},		/* n - 13 */
107 	{	V_UNASSIGNED,	0	},		/* o - 14 */
108 	{	V_UNASSIGNED,	0	},		/* p - 15 */
109 #endif			/* defined(_SUNOS_VTOC_16) */
110 };
111 
112 #ifdef DEBUG
113 int efi_debug = 1;
114 #else
115 int efi_debug = 0;
116 #endif
117 
118 extern unsigned int	efi_crc32(const unsigned char *, unsigned int);
119 static int		efi_read(int, struct dk_gpt *);
120 
121 static int
122 read_disk_info(int fd, diskaddr_t *capacity, uint_t *lbsize)
123 {
124 	struct dk_minfo		disk_info;
125 
126 	if ((ioctl(fd, DKIOCGMEDIAINFO, (caddr_t)&disk_info)) == -1)
127 		return (errno);
128 	*capacity = disk_info.dki_capacity;
129 	*lbsize = disk_info.dki_lbsize;
130 	return (0);
131 }
132 
133 /*
134  * the number of blocks the EFI label takes up (round up to nearest
135  * block)
136  */
137 #define	NBLOCKS(p, l)	(1 + ((((p) * (int)sizeof (efi_gpe_t))  + \
138 				((l) - 1)) / (l)))
139 /* number of partitions -- limited by what we can malloc */
140 #define	MAX_PARTS	((4294967295UL - sizeof (struct dk_gpt)) / \
141 			    sizeof (struct dk_part))
142 
143 int
144 efi_alloc_and_init(int fd, uint32_t nparts, struct dk_gpt **vtoc)
145 {
146 	diskaddr_t	capacity;
147 	uint_t		lbsize;
148 	uint_t		nblocks;
149 	size_t		length;
150 	struct dk_gpt	*vptr;
151 	struct uuid	uuid;
152 
153 	if (read_disk_info(fd, &capacity, &lbsize) != 0) {
154 		if (efi_debug)
155 			(void) fprintf(stderr,
156 			    "couldn't read disk information\n");
157 		return (-1);
158 	}
159 
160 	nblocks = NBLOCKS(nparts, lbsize);
161 	if ((nblocks * lbsize) < EFI_MIN_ARRAY_SIZE + lbsize) {
162 		/* 16K plus one block for the GPT */
163 		nblocks = EFI_MIN_ARRAY_SIZE / lbsize + 1;
164 	}
165 
166 	if (nparts > MAX_PARTS) {
167 		if (efi_debug) {
168 			(void) fprintf(stderr,
169 			"the maximum number of partitions supported is %lu\n",
170 			    MAX_PARTS);
171 		}
172 		return (-1);
173 	}
174 
175 	length = sizeof (struct dk_gpt) +
176 	    sizeof (struct dk_part) * (nparts - 1);
177 
178 	if ((*vtoc = calloc(length, 1)) == NULL)
179 		return (-1);
180 
181 	vptr = *vtoc;
182 
183 	vptr->efi_version = EFI_VERSION_CURRENT;
184 	vptr->efi_lbasize = lbsize;
185 	vptr->efi_nparts = nparts;
186 	/*
187 	 * add one block here for the PMBR; on disks with a 512 byte
188 	 * block size and 128 or fewer partitions, efi_first_u_lba
189 	 * should work out to "34"
190 	 */
191 	vptr->efi_first_u_lba = nblocks + 1;
192 	vptr->efi_last_lba = capacity - 1;
193 	vptr->efi_altern_lba = capacity -1;
194 	vptr->efi_last_u_lba = vptr->efi_last_lba - nblocks;
195 
196 	(void) uuid_generate((uchar_t *)&uuid);
197 	UUID_LE_CONVERT(vptr->efi_disk_uguid, uuid);
198 	return (0);
199 }
200 
201 /*
202  * Read EFI - return partition number upon success.
203  */
204 int
205 efi_alloc_and_read(int fd, struct dk_gpt **vtoc)
206 {
207 	int			rval;
208 	uint32_t		nparts;
209 	int			length;
210 
211 	/* figure out the number of entries that would fit into 16K */
212 	nparts = EFI_MIN_ARRAY_SIZE / sizeof (efi_gpe_t);
213 	length = (int) sizeof (struct dk_gpt) +
214 	    (int) sizeof (struct dk_part) * (nparts - 1);
215 	if ((*vtoc = calloc(length, 1)) == NULL)
216 		return (VT_ERROR);
217 
218 	(*vtoc)->efi_nparts = nparts;
219 	rval = efi_read(fd, *vtoc);
220 
221 	if ((rval == VT_EINVAL) && (*vtoc)->efi_nparts > nparts) {
222 		void *tmp;
223 		length = (int) sizeof (struct dk_gpt) +
224 		    (int) sizeof (struct dk_part) *
225 		    ((*vtoc)->efi_nparts - 1);
226 		nparts = (*vtoc)->efi_nparts;
227 		if ((tmp = realloc(*vtoc, length)) == NULL) {
228 			free (*vtoc);
229 			*vtoc = NULL;
230 			return (VT_ERROR);
231 		} else {
232 			*vtoc = tmp;
233 			rval = efi_read(fd, *vtoc);
234 		}
235 	}
236 
237 	if (rval < 0) {
238 		if (efi_debug) {
239 			(void) fprintf(stderr,
240 			    "read of EFI table failed, rval=%d\n", rval);
241 		}
242 		free (*vtoc);
243 		*vtoc = NULL;
244 	}
245 
246 	return (rval);
247 }
248 
249 static int
250 efi_ioctl(int fd, int cmd, dk_efi_t *dk_ioc)
251 {
252 	void *data = dk_ioc->dki_data;
253 	int error;
254 
255 	dk_ioc->dki_data_64 = (uint64_t)(uintptr_t)data;
256 	error = ioctl(fd, cmd, (void *)dk_ioc);
257 	dk_ioc->dki_data = data;
258 
259 	return (error);
260 }
261 
262 static int
263 check_label(int fd, dk_efi_t *dk_ioc)
264 {
265 	efi_gpt_t		*efi;
266 	uint_t			crc;
267 
268 	if (efi_ioctl(fd, DKIOCGETEFI, dk_ioc) == -1) {
269 		switch (errno) {
270 		case EIO:
271 			return (VT_EIO);
272 		default:
273 			return (VT_ERROR);
274 		}
275 	}
276 	efi = dk_ioc->dki_data;
277 	if (efi->efi_gpt_Signature != LE_64(EFI_SIGNATURE)) {
278 		if (efi_debug)
279 			(void) fprintf(stderr,
280 			    "Bad EFI signature: 0x%llx != 0x%llx\n",
281 			    (long long)efi->efi_gpt_Signature,
282 			    (long long)LE_64(EFI_SIGNATURE));
283 		return (VT_EINVAL);
284 	}
285 
286 	/*
287 	 * check CRC of the header; the size of the header should
288 	 * never be larger than one block
289 	 */
290 	crc = efi->efi_gpt_HeaderCRC32;
291 	efi->efi_gpt_HeaderCRC32 = 0;
292 
293 	if (((len_t)LE_32(efi->efi_gpt_HeaderSize) > dk_ioc->dki_length) ||
294 	    crc != LE_32(efi_crc32((unsigned char *)efi,
295 	    LE_32(efi->efi_gpt_HeaderSize)))) {
296 		if (efi_debug)
297 			(void) fprintf(stderr,
298 			    "Bad EFI CRC: 0x%x != 0x%x\n",
299 			    crc,
300 			    LE_32(efi_crc32((unsigned char *)efi,
301 			    sizeof (struct efi_gpt))));
302 		return (VT_EINVAL);
303 	}
304 
305 	return (0);
306 }
307 
308 static int
309 efi_read(int fd, struct dk_gpt *vtoc)
310 {
311 	int			i, j;
312 	int			label_len;
313 	int			rval = 0;
314 	int			md_flag = 0;
315 	int			vdc_flag = 0;
316 	struct dk_minfo		disk_info;
317 	dk_efi_t		dk_ioc;
318 	efi_gpt_t		*efi;
319 	efi_gpe_t		*efi_parts;
320 	struct dk_cinfo		dki_info;
321 	uint32_t		user_length;
322 	boolean_t		legacy_label = B_FALSE;
323 
324 	/*
325 	 * get the partition number for this file descriptor.
326 	 */
327 	if (ioctl(fd, DKIOCINFO, (caddr_t)&dki_info) == -1) {
328 		if (efi_debug) {
329 			(void) fprintf(stderr, "DKIOCINFO errno 0x%x\n", errno);
330 		}
331 		switch (errno) {
332 		case EIO:
333 			return (VT_EIO);
334 		case EINVAL:
335 			return (VT_EINVAL);
336 		default:
337 			return (VT_ERROR);
338 		}
339 	}
340 	if ((strncmp(dki_info.dki_cname, "pseudo", 7) == 0) &&
341 	    (strncmp(dki_info.dki_dname, "md", 3) == 0)) {
342 		md_flag++;
343 	} else if ((strncmp(dki_info.dki_cname, "vdc", 4) == 0) &&
344 	    (strncmp(dki_info.dki_dname, "vdc", 4) == 0)) {
345 		/*
346 		 * The controller and drive name "vdc" (virtual disk client)
347 		 * indicates a LDoms virtual disk.
348 		 */
349 		vdc_flag++;
350 	}
351 
352 	/* get the LBA size */
353 	if (ioctl(fd, DKIOCGMEDIAINFO, (caddr_t)&disk_info) == -1) {
354 		if (efi_debug) {
355 			(void) fprintf(stderr,
356 			    "assuming LBA 512 bytes %d\n",
357 			    errno);
358 		}
359 		disk_info.dki_lbsize = DEV_BSIZE;
360 	}
361 	if (disk_info.dki_lbsize == 0) {
362 		if (efi_debug) {
363 			(void) fprintf(stderr,
364 			    "efi_read: assuming LBA 512 bytes\n");
365 		}
366 		disk_info.dki_lbsize = DEV_BSIZE;
367 	}
368 	/*
369 	 * Read the EFI GPT to figure out how many partitions we need
370 	 * to deal with.
371 	 */
372 	dk_ioc.dki_lba = 1;
373 	if (NBLOCKS(vtoc->efi_nparts, disk_info.dki_lbsize) < 34) {
374 		label_len = EFI_MIN_ARRAY_SIZE + disk_info.dki_lbsize;
375 	} else {
376 		label_len = vtoc->efi_nparts * (int) sizeof (efi_gpe_t) +
377 		    disk_info.dki_lbsize;
378 		if (label_len % disk_info.dki_lbsize) {
379 			/* pad to physical sector size */
380 			label_len += disk_info.dki_lbsize;
381 			label_len &= ~(disk_info.dki_lbsize - 1);
382 		}
383 	}
384 
385 	if ((dk_ioc.dki_data = calloc(label_len, 1)) == NULL)
386 		return (VT_ERROR);
387 
388 	dk_ioc.dki_length = disk_info.dki_lbsize;
389 	user_length = vtoc->efi_nparts;
390 	efi = dk_ioc.dki_data;
391 	if (md_flag) {
392 		dk_ioc.dki_length = label_len;
393 		if (efi_ioctl(fd, DKIOCGETEFI, &dk_ioc) == -1) {
394 			switch (errno) {
395 			case EIO:
396 				return (VT_EIO);
397 			default:
398 				return (VT_ERROR);
399 			}
400 		}
401 	} else if ((rval = check_label(fd, &dk_ioc)) == VT_EINVAL) {
402 		/*
403 		 * No valid label here; try the alternate. Note that here
404 		 * we just read GPT header and save it into dk_ioc.data,
405 		 * Later, we will read GUID partition entry array if we
406 		 * can get valid GPT header.
407 		 */
408 
409 		/*
410 		 * This is a workaround for legacy systems. In the past, the
411 		 * last sector of SCSI disk was invisible on x86 platform. At
412 		 * that time, backup label was saved on the next to the last
413 		 * sector. It is possible for users to move a disk from previous
414 		 * solaris system to present system. Here, we attempt to search
415 		 * legacy backup EFI label first.
416 		 */
417 		dk_ioc.dki_lba = disk_info.dki_capacity - 2;
418 		dk_ioc.dki_length = disk_info.dki_lbsize;
419 		rval = check_label(fd, &dk_ioc);
420 		if (rval == VT_EINVAL) {
421 			/*
422 			 * we didn't find legacy backup EFI label, try to
423 			 * search backup EFI label in the last block.
424 			 */
425 			dk_ioc.dki_lba = disk_info.dki_capacity - 1;
426 			dk_ioc.dki_length = disk_info.dki_lbsize;
427 			rval = check_label(fd, &dk_ioc);
428 			if (rval == 0) {
429 				legacy_label = B_TRUE;
430 				if (efi_debug)
431 					(void) fprintf(stderr,
432 					    "efi_read: primary label corrupt; "
433 					    "using EFI backup label located on"
434 					    " the last block\n");
435 			}
436 		} else {
437 			if ((efi_debug) && (rval == 0))
438 				(void) fprintf(stderr, "efi_read: primary label"
439 				    " corrupt; using legacy EFI backup label "
440 				    " located on the next to last block\n");
441 		}
442 
443 		if (rval == 0) {
444 			dk_ioc.dki_lba = LE_64(efi->efi_gpt_PartitionEntryLBA);
445 			vtoc->efi_flags |= EFI_GPT_PRIMARY_CORRUPT;
446 			vtoc->efi_nparts =
447 			    LE_32(efi->efi_gpt_NumberOfPartitionEntries);
448 			/*
449 			 * Partition tables are between backup GPT header
450 			 * table and ParitionEntryLBA (the starting LBA of
451 			 * the GUID partition entries array). Now that we
452 			 * already got valid GPT header and saved it in
453 			 * dk_ioc.dki_data, we try to get GUID partition
454 			 * entry array here.
455 			 */
456 			/* LINTED */
457 			dk_ioc.dki_data = (efi_gpt_t *)((char *)dk_ioc.dki_data
458 			    + disk_info.dki_lbsize);
459 			if (legacy_label)
460 				dk_ioc.dki_length = disk_info.dki_capacity - 1 -
461 				    dk_ioc.dki_lba;
462 			else
463 				dk_ioc.dki_length = disk_info.dki_capacity - 2 -
464 				    dk_ioc.dki_lba;
465 			dk_ioc.dki_length *= disk_info.dki_lbsize;
466 			if (dk_ioc.dki_length >
467 			    ((len_t)label_len - sizeof (*dk_ioc.dki_data))) {
468 				rval = VT_EINVAL;
469 			} else {
470 				/*
471 				 * read GUID partition entry array
472 				 */
473 				rval = efi_ioctl(fd, DKIOCGETEFI, &dk_ioc);
474 			}
475 		}
476 
477 	} else if (rval == 0) {
478 
479 		dk_ioc.dki_lba = LE_64(efi->efi_gpt_PartitionEntryLBA);
480 		/* LINTED */
481 		dk_ioc.dki_data = (efi_gpt_t *)((char *)dk_ioc.dki_data
482 		    + disk_info.dki_lbsize);
483 		dk_ioc.dki_length = label_len - disk_info.dki_lbsize;
484 		rval = efi_ioctl(fd, DKIOCGETEFI, &dk_ioc);
485 
486 	} else if (vdc_flag && rval == VT_ERROR && errno == EINVAL) {
487 		/*
488 		 * When the device is a LDoms virtual disk, the DKIOCGETEFI
489 		 * ioctl can fail with EINVAL if the virtual disk backend
490 		 * is a ZFS volume serviced by a domain running an old version
491 		 * of Solaris. This is because the DKIOCGETEFI ioctl was
492 		 * initially incorrectly implemented for a ZFS volume and it
493 		 * expected the GPT and GPE to be retrieved with a single ioctl.
494 		 * So we try to read the GPT and the GPE using that old style
495 		 * ioctl.
496 		 */
497 		dk_ioc.dki_lba = 1;
498 		dk_ioc.dki_length = label_len;
499 		rval = check_label(fd, &dk_ioc);
500 	}
501 
502 	if (rval < 0) {
503 		free(efi);
504 		return (rval);
505 	}
506 
507 	/* LINTED -- always longlong aligned */
508 	efi_parts = (efi_gpe_t *)(((char *)efi) + disk_info.dki_lbsize);
509 
510 	/*
511 	 * Assemble this into a "dk_gpt" struct for easier
512 	 * digestibility by applications.
513 	 */
514 	vtoc->efi_version = LE_32(efi->efi_gpt_Revision);
515 	vtoc->efi_nparts = LE_32(efi->efi_gpt_NumberOfPartitionEntries);
516 	vtoc->efi_part_size = LE_32(efi->efi_gpt_SizeOfPartitionEntry);
517 	vtoc->efi_lbasize = disk_info.dki_lbsize;
518 	vtoc->efi_last_lba = disk_info.dki_capacity - 1;
519 	vtoc->efi_first_u_lba = LE_64(efi->efi_gpt_FirstUsableLBA);
520 	vtoc->efi_last_u_lba = LE_64(efi->efi_gpt_LastUsableLBA);
521 	vtoc->efi_altern_lba = LE_64(efi->efi_gpt_AlternateLBA);
522 	UUID_LE_CONVERT(vtoc->efi_disk_uguid, efi->efi_gpt_DiskGUID);
523 
524 	/*
525 	 * If the array the user passed in is too small, set the length
526 	 * to what it needs to be and return
527 	 */
528 	if (user_length < vtoc->efi_nparts) {
529 		return (VT_EINVAL);
530 	}
531 
532 	for (i = 0; i < vtoc->efi_nparts; i++) {
533 
534 		UUID_LE_CONVERT(vtoc->efi_parts[i].p_guid,
535 		    efi_parts[i].efi_gpe_PartitionTypeGUID);
536 
537 		for (j = 0;
538 		    j < sizeof (conversion_array)
539 		    / sizeof (struct uuid_to_ptag); j++) {
540 
541 			if (bcmp(&vtoc->efi_parts[i].p_guid,
542 			    &conversion_array[j].uuid,
543 			    sizeof (struct uuid)) == 0) {
544 				vtoc->efi_parts[i].p_tag = j;
545 				break;
546 			}
547 		}
548 		if (vtoc->efi_parts[i].p_tag == V_UNASSIGNED)
549 			continue;
550 		vtoc->efi_parts[i].p_flag =
551 		    LE_16(efi_parts[i].efi_gpe_Attributes.PartitionAttrs);
552 		vtoc->efi_parts[i].p_start =
553 		    LE_64(efi_parts[i].efi_gpe_StartingLBA);
554 		vtoc->efi_parts[i].p_size =
555 		    LE_64(efi_parts[i].efi_gpe_EndingLBA) -
556 		    vtoc->efi_parts[i].p_start + 1;
557 		for (j = 0; j < EFI_PART_NAME_LEN; j++) {
558 			vtoc->efi_parts[i].p_name[j] =
559 			    (uchar_t)LE_16(
560 			    efi_parts[i].efi_gpe_PartitionName[j]);
561 		}
562 
563 		UUID_LE_CONVERT(vtoc->efi_parts[i].p_uguid,
564 		    efi_parts[i].efi_gpe_UniquePartitionGUID);
565 	}
566 	free(efi);
567 
568 	return (dki_info.dki_partition);
569 }
570 
571 /* writes a "protective" MBR */
572 static int
573 write_pmbr(int fd, struct dk_gpt *vtoc)
574 {
575 	dk_efi_t	dk_ioc;
576 	struct mboot	mb;
577 	uchar_t		*cp;
578 	diskaddr_t	size_in_lba;
579 	uchar_t		*buf;
580 	int		len;
581 
582 	len = (vtoc->efi_lbasize == 0) ? sizeof (mb) : vtoc->efi_lbasize;
583 	buf = calloc(len, 1);
584 
585 	/*
586 	 * Preserve any boot code and disk signature if the first block is
587 	 * already an MBR.
588 	 */
589 	dk_ioc.dki_lba = 0;
590 	dk_ioc.dki_length = len;
591 	/* LINTED -- always longlong aligned */
592 	dk_ioc.dki_data = (efi_gpt_t *)buf;
593 	if (efi_ioctl(fd, DKIOCGETEFI, &dk_ioc) == -1) {
594 		(void *) memcpy(&mb, buf, sizeof (mb));
595 		bzero(&mb, sizeof (mb));
596 		mb.signature = LE_16(MBB_MAGIC);
597 	} else {
598 		(void *) memcpy(&mb, buf, sizeof (mb));
599 		if (mb.signature != LE_16(MBB_MAGIC)) {
600 			bzero(&mb, sizeof (mb));
601 			mb.signature = LE_16(MBB_MAGIC);
602 		}
603 	}
604 
605 	bzero(&mb.parts, sizeof (mb.parts));
606 	cp = (uchar_t *)&mb.parts[0];
607 	/* bootable or not */
608 	*cp++ = 0;
609 	/* beginning CHS; 0xffffff if not representable */
610 	*cp++ = 0xff;
611 	*cp++ = 0xff;
612 	*cp++ = 0xff;
613 	/* OS type */
614 	*cp++ = EFI_PMBR;
615 	/* ending CHS; 0xffffff if not representable */
616 	*cp++ = 0xff;
617 	*cp++ = 0xff;
618 	*cp++ = 0xff;
619 	/* starting LBA: 1 (little endian format) by EFI definition */
620 	*cp++ = 0x01;
621 	*cp++ = 0x00;
622 	*cp++ = 0x00;
623 	*cp++ = 0x00;
624 	/* ending LBA: last block on the disk (little endian format) */
625 	size_in_lba = vtoc->efi_last_lba;
626 	if (size_in_lba < 0xffffffff) {
627 		*cp++ = (size_in_lba & 0x000000ff);
628 		*cp++ = (size_in_lba & 0x0000ff00) >> 8;
629 		*cp++ = (size_in_lba & 0x00ff0000) >> 16;
630 		*cp++ = (size_in_lba & 0xff000000) >> 24;
631 	} else {
632 		*cp++ = 0xff;
633 		*cp++ = 0xff;
634 		*cp++ = 0xff;
635 		*cp++ = 0xff;
636 	}
637 
638 	(void *) memcpy(buf, &mb, sizeof (mb));
639 	/* LINTED -- always longlong aligned */
640 	dk_ioc.dki_data = (efi_gpt_t *)buf;
641 	dk_ioc.dki_lba = 0;
642 	dk_ioc.dki_length = len;
643 	if (efi_ioctl(fd, DKIOCSETEFI, &dk_ioc) == -1) {
644 		free(buf);
645 		switch (errno) {
646 		case EIO:
647 			return (VT_EIO);
648 		case EINVAL:
649 			return (VT_EINVAL);
650 		default:
651 			return (VT_ERROR);
652 		}
653 	}
654 	free(buf);
655 	return (0);
656 }
657 
658 /* make sure the user specified something reasonable */
659 static int
660 check_input(struct dk_gpt *vtoc)
661 {
662 	int			resv_part = -1;
663 	int			i, j;
664 	diskaddr_t		istart, jstart, isize, jsize, endsect;
665 
666 	/*
667 	 * Sanity-check the input (make sure no partitions overlap)
668 	 */
669 	for (i = 0; i < vtoc->efi_nparts; i++) {
670 		/* It can't be unassigned and have an actual size */
671 		if ((vtoc->efi_parts[i].p_tag == V_UNASSIGNED) &&
672 		    (vtoc->efi_parts[i].p_size != 0)) {
673 			if (efi_debug) {
674 				(void) fprintf(stderr,
675 "partition %d is \"unassigned\" but has a size of %llu",
676 				    i,
677 				    vtoc->efi_parts[i].p_size);
678 			}
679 			return (VT_EINVAL);
680 		}
681 		if (vtoc->efi_parts[i].p_tag == V_UNASSIGNED) {
682 			if (uuid_is_null((uchar_t *)&vtoc->efi_parts[i].p_guid))
683 				continue;
684 			/* we have encountered an unknown uuid */
685 			vtoc->efi_parts[i].p_tag = 0xff;
686 		}
687 		if (vtoc->efi_parts[i].p_tag == V_RESERVED) {
688 			if (resv_part != -1) {
689 				if (efi_debug) {
690 					(void) fprintf(stderr,
691 "found duplicate reserved partition at %d\n",
692 					    i);
693 				}
694 				return (VT_EINVAL);
695 			}
696 			resv_part = i;
697 		}
698 		if ((vtoc->efi_parts[i].p_start < vtoc->efi_first_u_lba) ||
699 		    (vtoc->efi_parts[i].p_start > vtoc->efi_last_u_lba)) {
700 			if (efi_debug) {
701 				(void) fprintf(stderr,
702 				    "Partition %d starts at %llu.  ",
703 				    i,
704 				    vtoc->efi_parts[i].p_start);
705 				(void) fprintf(stderr,
706 				    "It must be between %llu and %llu.\n",
707 				    vtoc->efi_first_u_lba,
708 				    vtoc->efi_last_u_lba);
709 			}
710 			return (VT_EINVAL);
711 		}
712 		if ((vtoc->efi_parts[i].p_start +
713 		    vtoc->efi_parts[i].p_size <
714 		    vtoc->efi_first_u_lba) ||
715 		    (vtoc->efi_parts[i].p_start +
716 		    vtoc->efi_parts[i].p_size >
717 		    vtoc->efi_last_u_lba + 1)) {
718 			if (efi_debug) {
719 				(void) fprintf(stderr,
720 				    "Partition %d ends at %llu.  ",
721 				    i,
722 				    vtoc->efi_parts[i].p_start +
723 				    vtoc->efi_parts[i].p_size);
724 				(void) fprintf(stderr,
725 				    "It must be between %llu and %llu.\n",
726 				    vtoc->efi_first_u_lba,
727 				    vtoc->efi_last_u_lba);
728 			}
729 			return (VT_EINVAL);
730 		}
731 
732 		for (j = 0; j < vtoc->efi_nparts; j++) {
733 			isize = vtoc->efi_parts[i].p_size;
734 			jsize = vtoc->efi_parts[j].p_size;
735 			istart = vtoc->efi_parts[i].p_start;
736 			jstart = vtoc->efi_parts[j].p_start;
737 			if ((i != j) && (isize != 0) && (jsize != 0)) {
738 				endsect = jstart + jsize -1;
739 				if ((jstart <= istart) &&
740 				    (istart <= endsect)) {
741 					if (efi_debug) {
742 						(void) fprintf(stderr,
743 "Partition %d overlaps partition %d.",
744 						    i, j);
745 					}
746 					return (VT_EINVAL);
747 				}
748 			}
749 		}
750 	}
751 	/* just a warning for now */
752 	if ((resv_part == -1) && efi_debug) {
753 		(void) fprintf(stderr,
754 		    "no reserved partition found\n");
755 	}
756 	return (0);
757 }
758 
759 /*
760  * add all the unallocated space to the current label
761  */
762 int
763 efi_use_whole_disk(int fd)
764 {
765 	struct dk_gpt		*efi_label;
766 	int			rval;
767 	int			i;
768 	uint_t			phy_last_slice = 0;
769 	diskaddr_t		pl_start = 0;
770 	diskaddr_t		pl_size;
771 
772 	rval = efi_alloc_and_read(fd, &efi_label);
773 	if (rval < 0) {
774 		return (rval);
775 	}
776 
777 	/* find the last physically non-zero partition */
778 	for (i = 0; i < efi_label->efi_nparts - 2; i ++) {
779 		if (pl_start < efi_label->efi_parts[i].p_start) {
780 			pl_start = efi_label->efi_parts[i].p_start;
781 			phy_last_slice = i;
782 		}
783 	}
784 	pl_size = efi_label->efi_parts[phy_last_slice].p_size;
785 
786 	/*
787 	 * If alter_lba is 1, we are using the backup label.
788 	 * Since we can locate the backup label by disk capacity,
789 	 * there must be no unallocated space.
790 	 */
791 	if ((efi_label->efi_altern_lba == 1) || (efi_label->efi_altern_lba
792 	    >= efi_label->efi_last_lba)) {
793 		if (efi_debug) {
794 			(void) fprintf(stderr,
795 			    "efi_use_whole_disk: requested space not found\n");
796 		}
797 		efi_free(efi_label);
798 		return (VT_ENOSPC);
799 	}
800 
801 	/*
802 	 * If there is space between the last physically non-zero partition
803 	 * and the reserved partition, just add the unallocated space to this
804 	 * area. Otherwise, the unallocated space is added to the last
805 	 * physically non-zero partition.
806 	 */
807 	if (pl_start + pl_size - 1 == efi_label->efi_last_u_lba -
808 	    EFI_MIN_RESV_SIZE) {
809 		efi_label->efi_parts[phy_last_slice].p_size +=
810 		    efi_label->efi_last_lba - efi_label->efi_altern_lba;
811 	}
812 
813 	/*
814 	 * Move the reserved partition. There is currently no data in
815 	 * here except fabricated devids (which get generated via
816 	 * efi_write()). So there is no need to copy data.
817 	 */
818 	efi_label->efi_parts[efi_label->efi_nparts - 1].p_start +=
819 	    efi_label->efi_last_lba - efi_label->efi_altern_lba;
820 	efi_label->efi_last_u_lba += efi_label->efi_last_lba
821 	    - efi_label->efi_altern_lba;
822 
823 	rval = efi_write(fd, efi_label);
824 	if (rval < 0) {
825 		if (efi_debug) {
826 			(void) fprintf(stderr,
827 			    "efi_use_whole_disk:fail to write label, rval=%d\n",
828 			    rval);
829 		}
830 		efi_free(efi_label);
831 		return (rval);
832 	}
833 
834 	efi_free(efi_label);
835 	return (0);
836 }
837 
838 
839 /*
840  * write EFI label and backup label
841  */
842 int
843 efi_write(int fd, struct dk_gpt *vtoc)
844 {
845 	dk_efi_t		dk_ioc;
846 	efi_gpt_t		*efi;
847 	efi_gpe_t		*efi_parts;
848 	int			i, j;
849 	struct dk_cinfo		dki_info;
850 	int			md_flag = 0;
851 	int			nblocks;
852 	diskaddr_t		lba_backup_gpt_hdr;
853 
854 	if (ioctl(fd, DKIOCINFO, (caddr_t)&dki_info) == -1) {
855 		if (efi_debug)
856 			(void) fprintf(stderr, "DKIOCINFO errno 0x%x\n", errno);
857 		switch (errno) {
858 		case EIO:
859 			return (VT_EIO);
860 		case EINVAL:
861 			return (VT_EINVAL);
862 		default:
863 			return (VT_ERROR);
864 		}
865 	}
866 
867 	/* check if we are dealing wih a metadevice */
868 	if ((strncmp(dki_info.dki_cname, "pseudo", 7) == 0) &&
869 	    (strncmp(dki_info.dki_dname, "md", 3) == 0)) {
870 		md_flag = 1;
871 	}
872 
873 	if (check_input(vtoc)) {
874 		/*
875 		 * not valid; if it's a metadevice just pass it down
876 		 * because SVM will do its own checking
877 		 */
878 		if (md_flag == 0) {
879 			return (VT_EINVAL);
880 		}
881 	}
882 
883 	dk_ioc.dki_lba = 1;
884 	if (NBLOCKS(vtoc->efi_nparts, vtoc->efi_lbasize) < 34) {
885 		dk_ioc.dki_length = EFI_MIN_ARRAY_SIZE + vtoc->efi_lbasize;
886 	} else {
887 		dk_ioc.dki_length = NBLOCKS(vtoc->efi_nparts,
888 		    vtoc->efi_lbasize) *
889 		    vtoc->efi_lbasize;
890 	}
891 
892 	/*
893 	 * the number of blocks occupied by GUID partition entry array
894 	 */
895 	nblocks = dk_ioc.dki_length / vtoc->efi_lbasize - 1;
896 
897 	/*
898 	 * Backup GPT header is located on the block after GUID
899 	 * partition entry array. Here, we calculate the address
900 	 * for backup GPT header.
901 	 */
902 	lba_backup_gpt_hdr = vtoc->efi_last_u_lba + 1 + nblocks;
903 	if ((dk_ioc.dki_data = calloc(dk_ioc.dki_length, 1)) == NULL)
904 		return (VT_ERROR);
905 
906 	efi = dk_ioc.dki_data;
907 
908 	/* stuff user's input into EFI struct */
909 	efi->efi_gpt_Signature = LE_64(EFI_SIGNATURE);
910 	efi->efi_gpt_Revision = LE_32(vtoc->efi_version); /* 0x02000100 */
911 	efi->efi_gpt_HeaderSize = LE_32(sizeof (struct efi_gpt));
912 	efi->efi_gpt_Reserved1 = 0;
913 	efi->efi_gpt_MyLBA = LE_64(1ULL);
914 	efi->efi_gpt_AlternateLBA = LE_64(lba_backup_gpt_hdr);
915 	efi->efi_gpt_FirstUsableLBA = LE_64(vtoc->efi_first_u_lba);
916 	efi->efi_gpt_LastUsableLBA = LE_64(vtoc->efi_last_u_lba);
917 	efi->efi_gpt_PartitionEntryLBA = LE_64(2ULL);
918 	efi->efi_gpt_NumberOfPartitionEntries = LE_32(vtoc->efi_nparts);
919 	efi->efi_gpt_SizeOfPartitionEntry = LE_32(sizeof (struct efi_gpe));
920 	UUID_LE_CONVERT(efi->efi_gpt_DiskGUID, vtoc->efi_disk_uguid);
921 
922 	/* LINTED -- always longlong aligned */
923 	efi_parts = (efi_gpe_t *)((char *)dk_ioc.dki_data + vtoc->efi_lbasize);
924 
925 	for (i = 0; i < vtoc->efi_nparts; i++) {
926 		for (j = 0;
927 		    j < sizeof (conversion_array) /
928 		    sizeof (struct uuid_to_ptag); j++) {
929 
930 			if (vtoc->efi_parts[i].p_tag == j) {
931 				UUID_LE_CONVERT(
932 				    efi_parts[i].efi_gpe_PartitionTypeGUID,
933 				    conversion_array[j].uuid);
934 				break;
935 			}
936 		}
937 
938 		if (j == sizeof (conversion_array) /
939 		    sizeof (struct uuid_to_ptag)) {
940 			/*
941 			 * If we didn't have a matching uuid match, bail here.
942 			 * Don't write a label with unknown uuid.
943 			 */
944 			if (efi_debug) {
945 				(void) fprintf(stderr,
946 				    "Unknown uuid for p_tag %d\n",
947 				    vtoc->efi_parts[i].p_tag);
948 			}
949 			return (VT_EINVAL);
950 		}
951 
952 		efi_parts[i].efi_gpe_StartingLBA =
953 		    LE_64(vtoc->efi_parts[i].p_start);
954 		efi_parts[i].efi_gpe_EndingLBA =
955 		    LE_64(vtoc->efi_parts[i].p_start +
956 		    vtoc->efi_parts[i].p_size - 1);
957 		efi_parts[i].efi_gpe_Attributes.PartitionAttrs =
958 		    LE_16(vtoc->efi_parts[i].p_flag);
959 		for (j = 0; j < EFI_PART_NAME_LEN; j++) {
960 			efi_parts[i].efi_gpe_PartitionName[j] =
961 			    LE_16((ushort_t)vtoc->efi_parts[i].p_name[j]);
962 		}
963 		if ((vtoc->efi_parts[i].p_tag != V_UNASSIGNED) &&
964 		    uuid_is_null((uchar_t *)&vtoc->efi_parts[i].p_uguid)) {
965 			(void) uuid_generate((uchar_t *)
966 			    &vtoc->efi_parts[i].p_uguid);
967 		}
968 		bcopy(&vtoc->efi_parts[i].p_uguid,
969 		    &efi_parts[i].efi_gpe_UniquePartitionGUID,
970 		    sizeof (uuid_t));
971 	}
972 	efi->efi_gpt_PartitionEntryArrayCRC32 =
973 	    LE_32(efi_crc32((unsigned char *)efi_parts,
974 	    vtoc->efi_nparts * (int)sizeof (struct efi_gpe)));
975 	efi->efi_gpt_HeaderCRC32 =
976 	    LE_32(efi_crc32((unsigned char *)efi, sizeof (struct efi_gpt)));
977 
978 	if (efi_ioctl(fd, DKIOCSETEFI, &dk_ioc) == -1) {
979 		free(dk_ioc.dki_data);
980 		switch (errno) {
981 		case EIO:
982 			return (VT_EIO);
983 		case EINVAL:
984 			return (VT_EINVAL);
985 		default:
986 			return (VT_ERROR);
987 		}
988 	}
989 	/* if it's a metadevice we're done */
990 	if (md_flag) {
991 		free(dk_ioc.dki_data);
992 		return (0);
993 	}
994 
995 	/* write backup partition array */
996 	dk_ioc.dki_lba = vtoc->efi_last_u_lba + 1;
997 	dk_ioc.dki_length -= vtoc->efi_lbasize;
998 	/* LINTED */
999 	dk_ioc.dki_data = (efi_gpt_t *)((char *)dk_ioc.dki_data +
1000 	    vtoc->efi_lbasize);
1001 
1002 	if (efi_ioctl(fd, DKIOCSETEFI, &dk_ioc) == -1) {
1003 		/*
1004 		 * we wrote the primary label okay, so don't fail
1005 		 */
1006 		if (efi_debug) {
1007 			(void) fprintf(stderr,
1008 			    "write of backup partitions to block %llu "
1009 			    "failed, errno %d\n",
1010 			    vtoc->efi_last_u_lba + 1,
1011 			    errno);
1012 		}
1013 	}
1014 	/*
1015 	 * now swap MyLBA and AlternateLBA fields and write backup
1016 	 * partition table header
1017 	 */
1018 	dk_ioc.dki_lba = lba_backup_gpt_hdr;
1019 	dk_ioc.dki_length = vtoc->efi_lbasize;
1020 	/* LINTED */
1021 	dk_ioc.dki_data = (efi_gpt_t *)((char *)dk_ioc.dki_data -
1022 	    vtoc->efi_lbasize);
1023 	efi->efi_gpt_AlternateLBA = LE_64(1ULL);
1024 	efi->efi_gpt_MyLBA = LE_64(lba_backup_gpt_hdr);
1025 	efi->efi_gpt_PartitionEntryLBA = LE_64(vtoc->efi_last_u_lba + 1);
1026 	efi->efi_gpt_HeaderCRC32 = 0;
1027 	efi->efi_gpt_HeaderCRC32 =
1028 	    LE_32(efi_crc32((unsigned char *)dk_ioc.dki_data,
1029 	    sizeof (struct efi_gpt)));
1030 
1031 	if (efi_ioctl(fd, DKIOCSETEFI, &dk_ioc) == -1) {
1032 		if (efi_debug) {
1033 			(void) fprintf(stderr,
1034 			    "write of backup header to block %llu failed, "
1035 			    "errno %d\n",
1036 			    lba_backup_gpt_hdr,
1037 			    errno);
1038 		}
1039 	}
1040 	/* write the PMBR */
1041 	(void) write_pmbr(fd, vtoc);
1042 	free(dk_ioc.dki_data);
1043 	return (0);
1044 }
1045 
1046 void
1047 efi_free(struct dk_gpt *ptr)
1048 {
1049 	free(ptr);
1050 }
1051 
1052 /*
1053  * Input: File descriptor
1054  * Output: 1 if disk has an EFI label, or > 2TB with no VTOC or legacy MBR.
1055  * Otherwise 0.
1056  */
1057 int
1058 efi_type(int fd)
1059 {
1060 	struct vtoc vtoc;
1061 	struct extvtoc extvtoc;
1062 
1063 	if (ioctl(fd, DKIOCGEXTVTOC, &extvtoc) == -1) {
1064 		if (errno == ENOTSUP)
1065 			return (1);
1066 		else if (errno == ENOTTY) {
1067 			if (ioctl(fd, DKIOCGVTOC, &vtoc) == -1)
1068 				if (errno == ENOTSUP)
1069 					return (1);
1070 		}
1071 	}
1072 	return (0);
1073 }
1074 
1075 void
1076 efi_err_check(struct dk_gpt *vtoc)
1077 {
1078 	int			resv_part = -1;
1079 	int			i, j;
1080 	diskaddr_t		istart, jstart, isize, jsize, endsect;
1081 	int			overlap = 0;
1082 
1083 	/*
1084 	 * make sure no partitions overlap
1085 	 */
1086 	for (i = 0; i < vtoc->efi_nparts; i++) {
1087 		/* It can't be unassigned and have an actual size */
1088 		if ((vtoc->efi_parts[i].p_tag == V_UNASSIGNED) &&
1089 		    (vtoc->efi_parts[i].p_size != 0)) {
1090 			(void) fprintf(stderr,
1091 			    "partition %d is \"unassigned\" but has a size "
1092 			    "of %llu\n", i, vtoc->efi_parts[i].p_size);
1093 		}
1094 		if (vtoc->efi_parts[i].p_tag == V_UNASSIGNED) {
1095 			continue;
1096 		}
1097 		if (vtoc->efi_parts[i].p_tag == V_RESERVED) {
1098 			if (resv_part != -1) {
1099 				(void) fprintf(stderr,
1100 				    "found duplicate reserved partition at "
1101 				    "%d\n", i);
1102 			}
1103 			resv_part = i;
1104 			if (vtoc->efi_parts[i].p_size != EFI_MIN_RESV_SIZE)
1105 				(void) fprintf(stderr,
1106 				    "Warning: reserved partition size must "
1107 				    "be %d sectors\n", EFI_MIN_RESV_SIZE);
1108 		}
1109 		if ((vtoc->efi_parts[i].p_start < vtoc->efi_first_u_lba) ||
1110 		    (vtoc->efi_parts[i].p_start > vtoc->efi_last_u_lba)) {
1111 			(void) fprintf(stderr,
1112 			    "Partition %d starts at %llu\n",
1113 			    i,
1114 			    vtoc->efi_parts[i].p_start);
1115 			(void) fprintf(stderr,
1116 			    "It must be between %llu and %llu.\n",
1117 			    vtoc->efi_first_u_lba,
1118 			    vtoc->efi_last_u_lba);
1119 		}
1120 		if ((vtoc->efi_parts[i].p_start +
1121 		    vtoc->efi_parts[i].p_size <
1122 		    vtoc->efi_first_u_lba) ||
1123 		    (vtoc->efi_parts[i].p_start +
1124 		    vtoc->efi_parts[i].p_size >
1125 		    vtoc->efi_last_u_lba + 1)) {
1126 			(void) fprintf(stderr,
1127 			    "Partition %d ends at %llu\n",
1128 			    i,
1129 			    vtoc->efi_parts[i].p_start +
1130 			    vtoc->efi_parts[i].p_size);
1131 			(void) fprintf(stderr,
1132 			    "It must be between %llu and %llu.\n",
1133 			    vtoc->efi_first_u_lba,
1134 			    vtoc->efi_last_u_lba);
1135 		}
1136 
1137 		for (j = 0; j < vtoc->efi_nparts; j++) {
1138 			isize = vtoc->efi_parts[i].p_size;
1139 			jsize = vtoc->efi_parts[j].p_size;
1140 			istart = vtoc->efi_parts[i].p_start;
1141 			jstart = vtoc->efi_parts[j].p_start;
1142 			if ((i != j) && (isize != 0) && (jsize != 0)) {
1143 				endsect = jstart + jsize -1;
1144 				if ((jstart <= istart) &&
1145 				    (istart <= endsect)) {
1146 					if (!overlap) {
1147 					(void) fprintf(stderr,
1148 					    "label error: EFI Labels do not "
1149 					    "support overlapping partitions\n");
1150 					}
1151 					(void) fprintf(stderr,
1152 					    "Partition %d overlaps partition "
1153 					    "%d.\n", i, j);
1154 					overlap = 1;
1155 				}
1156 			}
1157 		}
1158 	}
1159 	/* make sure there is a reserved partition */
1160 	if (resv_part == -1) {
1161 		(void) fprintf(stderr,
1162 		    "no reserved partition found\n");
1163 	}
1164 }
1165 
1166 /*
1167  * We need to get information necessary to construct a *new* efi
1168  * label type
1169  */
1170 int
1171 efi_auto_sense(int fd, struct dk_gpt **vtoc)
1172 {
1173 
1174 	int	i;
1175 
1176 	/*
1177 	 * Now build the default partition table
1178 	 */
1179 	if (efi_alloc_and_init(fd, EFI_NUMPAR, vtoc) != 0) {
1180 		if (efi_debug) {
1181 			(void) fprintf(stderr, "efi_alloc_and_init failed.\n");
1182 		}
1183 		return (-1);
1184 	}
1185 
1186 	for (i = 0; i < min((*vtoc)->efi_nparts, V_NUMPAR); i++) {
1187 		(*vtoc)->efi_parts[i].p_tag = default_vtoc_map[i].p_tag;
1188 		(*vtoc)->efi_parts[i].p_flag = default_vtoc_map[i].p_flag;
1189 		(*vtoc)->efi_parts[i].p_start = 0;
1190 		(*vtoc)->efi_parts[i].p_size = 0;
1191 	}
1192 	/*
1193 	 * Make constants first
1194 	 * and variable partitions later
1195 	 */
1196 
1197 	/* root partition - s0 128 MB */
1198 	(*vtoc)->efi_parts[0].p_start = 34;
1199 	(*vtoc)->efi_parts[0].p_size = 262144;
1200 
1201 	/* partition - s1  128 MB */
1202 	(*vtoc)->efi_parts[1].p_start = 262178;
1203 	(*vtoc)->efi_parts[1].p_size = 262144;
1204 
1205 	/* partition -s2 is NOT the Backup disk */
1206 	(*vtoc)->efi_parts[2].p_tag = V_UNASSIGNED;
1207 
1208 	/* partition -s6 /usr partition - HOG */
1209 	(*vtoc)->efi_parts[6].p_start = 524322;
1210 	(*vtoc)->efi_parts[6].p_size = (*vtoc)->efi_last_u_lba - 524322
1211 	    - (1024 * 16);
1212 
1213 	/* efi reserved partition - s9 16K */
1214 	(*vtoc)->efi_parts[8].p_start = (*vtoc)->efi_last_u_lba - (1024 * 16);
1215 	(*vtoc)->efi_parts[8].p_size = (1024 * 16);
1216 	(*vtoc)->efi_parts[8].p_tag = V_RESERVED;
1217 	return (0);
1218 }
1219