xref: /illumos-gate/usr/src/cmd/format/menu_fdisk.c (revision fd6d41c5025e9fb45a115fc82d86e9983d1e9fd6)
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) 1993, 2010, Oracle and/or its affiliates. All rights reserved.
23  * Copyright 2016 Toomas Soome <tsoome@me.com>
24  */
25 
26 /*
27  * This file contains functions that implement the fdisk menu commands.
28  */
29 #include "global.h"
30 #include <errno.h>
31 #include <sys/time.h>
32 #include <sys/resource.h>
33 #include <sys/wait.h>
34 #include <signal.h>
35 #include <string.h>
36 #include <fcntl.h>
37 #include <stdlib.h>
38 #include <sys/dktp/fdisk.h>
39 #include <sys/stat.h>
40 #include <sys/dklabel.h>
41 #ifdef i386
42 #include <libfdisk.h>
43 #endif
44 
45 #include "main.h"
46 #include "analyze.h"
47 #include "menu.h"
48 #include "menu_command.h"
49 #include "menu_defect.h"
50 #include "menu_partition.h"
51 #include "menu_fdisk.h"
52 #include "param.h"
53 #include "misc.h"
54 #include "label.h"
55 #include "startup.h"
56 #include "partition.h"
57 #include "prompts.h"
58 #include "checkdev.h"
59 #include "io.h"
60 #include "ctlr_scsi.h"
61 #include "auto_sense.h"
62 
63 extern	struct menu_item menu_fdisk[];
64 
65 /*
66  * Byte swapping macros for accessing struct ipart
67  *	to resolve little endian on Sparc.
68  */
69 #if defined(sparc)
70 #define	les(val)	((((val)&0xFF)<<8)|(((val)>>8)&0xFF))
71 #define	lel(val)	(((unsigned)(les((val)&0x0000FFFF))<<16) | \
72 			(les((unsigned)((val)&0xffff0000)>>16)))
73 
74 #elif	defined(i386)
75 
76 #define	les(val)	(val)
77 #define	lel(val)	(val)
78 
79 #else	/* defined(sparc) */
80 
81 #error	No Platform defined
82 
83 #endif	/* defined(sparc) */
84 
85 
86 /* Function prototypes */
87 #ifdef	__STDC__
88 
89 #if	defined(sparc)
90 
91 static int getbyte(uchar_t **);
92 static int getlong(uchar_t **);
93 
94 #endif	/* defined(sparc) */
95 
96 static int get_solaris_part(int fd, struct ipart *ipart);
97 
98 #else	/* __STDC__ */
99 
100 #if	defined(sparc)
101 
102 static int getbyte();
103 static int getlong();
104 
105 #endif	/* defined(sparc) */
106 
107 static int get_solaris_part();
108 
109 #endif	/* __STDC__ */
110 
111 #ifdef i386
112 int extpart_init(ext_part_t **epp);
113 #endif
114 /*
115  * Handling the alignment problem of struct ipart.
116  */
117 static void
118 fill_ipart(char *bootptr, struct ipart *partp)
119 {
120 #if defined(sparc)
121 	/*
122 	 * Sparc platform:
123 	 *
124 	 * Packing short/word for struct ipart to resolve
125 	 *	little endian on Sparc since it is not
126 	 *	properly aligned on Sparc.
127 	 */
128 	partp->bootid = getbyte((uchar_t **)&bootptr);
129 	partp->beghead = getbyte((uchar_t **)&bootptr);
130 	partp->begsect = getbyte((uchar_t **)&bootptr);
131 	partp->begcyl = getbyte((uchar_t **)&bootptr);
132 	partp->systid = getbyte((uchar_t **)&bootptr);
133 	partp->endhead = getbyte((uchar_t **)&bootptr);
134 	partp->endsect = getbyte((uchar_t **)&bootptr);
135 	partp->endcyl = getbyte((uchar_t **)&bootptr);
136 	partp->relsect = getlong((uchar_t **)&bootptr);
137 	partp->numsect = getlong((uchar_t **)&bootptr);
138 #elif defined(i386)
139 	/*
140 	 * i386 platform:
141 	 *
142 	 * The fdisk table does not begin on a 4-byte boundary within
143 	 * the master boot record; so, we need to recopy its contents
144 	 * to another data structure to avoid an alignment exception.
145 	 */
146 	(void) bcopy(bootptr, partp, sizeof (struct ipart));
147 #else
148 #error  No Platform defined
149 #endif /* defined(sparc) */
150 }
151 
152 /*
153  * Get a correct byte/short/word routines for Sparc platform.
154  */
155 #if defined(sparc)
156 static int
157 getbyte(uchar_t **bp)
158 {
159 	int	b;
160 
161 	b = **bp;
162 	*bp = *bp + 1;
163 	return (b);
164 }
165 
166 #ifdef DEADCODE
167 static int
168 getshort(uchar_t **bp)
169 {
170 	int	b;
171 
172 	b = ((**bp) << 8) | *(*bp + 1);
173 	*bp += 2;
174 	return (b);
175 }
176 #endif /* DEADCODE */
177 
178 static int
179 getlong(uchar_t **bp)
180 {
181 	int	b, bh, bl;
182 
183 	bh = ((**bp) << 8) | *(*bp + 1);
184 	*bp += 2;
185 	bl = ((**bp) << 8) | *(*bp + 1);
186 	*bp += 2;
187 
188 	b = (bh << 16) | bl;
189 	return (b);
190 }
191 #endif /* defined(sparc) */
192 
193 #ifdef i386
194 /*
195  * Convert emcpowerN[a-p,p0,p1,p2,p3,p4] to emcpowerNp0 path,
196  * this is specific for emc powerpath driver.
197  */
198 static void
199 get_emcpower_pname(char *name, char *devname)
200 {
201 	char	*emcp = "emcpower";
202 	char	*npt = NULL;
203 	char	np[MAXNAMELEN];
204 	int	i = strlen(emcp);
205 
206 	(void) strcpy(np, devname);
207 	npt = strstr(np, emcp);
208 	while ((i < strlen(npt)) && (isdigit(npt[i])))
209 		i++;
210 	npt[i] = '\0';
211 	(void) snprintf(name, MAXNAMELEN, "/dev/rdsk/%sp0", npt);
212 }
213 #endif
214 
215 /*
216  * Convert cn[tn]dn to cn[tn]dns2 path
217  */
218 static void
219 get_sname(char *name)
220 {
221 	char		buf[MAXPATHLEN];
222 	char		*devp = "/dev/dsk";
223 	char		*rdevp = "/dev/rdsk";
224 	char		np[MAXNAMELEN];
225 	char		*npt;
226 
227 #ifdef i386
228 	if (emcpower_name(cur_disk->disk_name)) {
229 		get_emcpower_pname(name, cur_disk->disk_name);
230 		return;
231 	}
232 #endif
233 
234 	/*
235 	 * If it is a full path /dev/[r]dsk/cn[tn]dn, use this path
236 	 */
237 	(void) strcpy(np, cur_disk->disk_name);
238 	if (strncmp(rdevp, cur_disk->disk_name, strlen(rdevp)) == 0 ||
239 	    strncmp(devp, cur_disk->disk_name, strlen(devp)) == 0) {
240 		/*
241 		 * Skip if the path is already included with sN
242 		 */
243 		if (strchr(np, 's') == strrchr(np, 's')) {
244 			npt = strrchr(np, 'p');
245 			/* If pN is found, do not include it */
246 			if (npt != NULL) {
247 				*npt = '\0';
248 			}
249 			(void) snprintf(buf, sizeof (buf), "%ss2", np);
250 		} else {
251 			(void) snprintf(buf, sizeof (buf), "%s", np);
252 		}
253 	} else {
254 		(void) snprintf(buf, sizeof (buf), "/dev/rdsk/%ss2", np);
255 	}
256 	(void) strcpy(name, buf);
257 }
258 
259 /*
260  * Convert cn[tn]dnsn to cn[tn]dnp0 path
261  */
262 static void
263 get_pname(char *name)
264 {
265 	char		buf[MAXPATHLEN];
266 	char		*devp = "/dev/dsk";
267 	char		*rdevp = "/dev/rdsk";
268 	char		np[MAXNAMELEN];
269 	char		*npt;
270 
271 	/*
272 	 * If it is a full path /dev/[r]dsk/cn[tn]dnsn, use this path
273 	 */
274 	if (cur_disk == NULL) {
275 		(void) strcpy(np, x86_devname);
276 	} else {
277 		(void) strcpy(np, cur_disk->disk_name);
278 	}
279 
280 #ifdef i386
281 	if (emcpower_name(np)) {
282 		get_emcpower_pname(name, np);
283 		return;
284 	}
285 #endif
286 
287 	if (strncmp(rdevp, np, strlen(rdevp)) == 0 ||
288 	    strncmp(devp, np, strlen(devp)) == 0) {
289 		/*
290 		 * Skip if the path is already included with pN
291 		 */
292 		if (strchr(np, 'p') == NULL) {
293 			npt = strrchr(np, 's');
294 			/* If sN is found, do not include it */
295 			if (isdigit(*++npt)) {
296 				*--npt = '\0';
297 			}
298 			(void) snprintf(buf, sizeof (buf), "%sp0", np);
299 		} else {
300 			(void) snprintf(buf, sizeof (buf), "%s", np);
301 		}
302 	} else {
303 		(void) snprintf(buf, sizeof (buf), "/dev/rdsk/%sp0", np);
304 	}
305 	(void) strcpy(name, buf);
306 }
307 
308 /*
309  * Open file descriptor for current disk (cur_file)
310  *	with "p0" path or cur_disk->disk_path
311  */
312 void
313 open_cur_file(int mode)
314 {
315 	char	*dkpath;
316 	char	pbuf[MAXPATHLEN];
317 
318 	switch (mode) {
319 		case FD_USE_P0_PATH:
320 			(void) get_pname(&pbuf[0]);
321 			dkpath = pbuf;
322 			break;
323 		case FD_USE_CUR_DISK_PATH:
324 			if (cur_disk->fdisk_part.systid == SUNIXOS ||
325 			    cur_disk->fdisk_part.systid == SUNIXOS2) {
326 				(void) get_sname(&pbuf[0]);
327 				dkpath = pbuf;
328 			} else {
329 				dkpath = cur_disk->disk_path;
330 			}
331 			break;
332 		default:
333 			err_print("Error: Invalid mode option for opening "
334 			    "cur_file\n");
335 			fullabort();
336 	}
337 
338 	/* Close previous cur_file */
339 	(void) close(cur_file);
340 	/* Open cur_file with the required path dkpath */
341 	if ((cur_file = open_disk(dkpath, O_RDWR | O_NDELAY)) < 0) {
342 		err_print(
343 		    "Error: can't open selected disk '%s'.\n", dkpath);
344 		fullabort();
345 	}
346 }
347 
348 
349 /*
350  * This routine implements the 'fdisk' command.  It simply runs
351  * the fdisk command on the current disk.
352  * Use of this is restricted to interactive mode only.
353  */
354 int
355 c_fdisk()
356 {
357 
358 	char		buf[MAXPATHLEN];
359 	char		pbuf[MAXPATHLEN];
360 	struct stat	statbuf;
361 
362 	/*
363 	 * We must be in interactive mode to use the fdisk command
364 	 */
365 	if (option_f != (char *)NULL || isatty(0) != 1 || isatty(1) != 1) {
366 		err_print("Fdisk command is for interactive use only!\n");
367 		return (-1);
368 	}
369 
370 	/*
371 	 * There must be a current disk type and a current disk
372 	 */
373 	if (cur_dtype == NULL) {
374 		err_print("Current Disk Type is not set.\n");
375 		return (-1);
376 	}
377 
378 	/*
379 	 * Before running the fdisk command, get file status of
380 	 *	/dev/rdsk/cn[tn]dnp0 path to see if this disk
381 	 *	supports fixed disk partition table.
382 	 */
383 	(void) get_pname(&pbuf[0]);
384 	if (stat(pbuf, (struct stat *)&statbuf) == -1 ||
385 	    !S_ISCHR(statbuf.st_mode)) {
386 		err_print(
387 		"Disk does not support fixed disk partition table\n");
388 		return (0);
389 	}
390 
391 	/*
392 	 * Run the fdisk program.
393 	 */
394 	(void) snprintf(buf, sizeof (buf), "fdisk %s\n", pbuf);
395 	(void) system(buf);
396 
397 	/*
398 	 * Open cur_file with "p0" path for accessing the fdisk table
399 	 */
400 	(void) open_cur_file(FD_USE_P0_PATH);
401 
402 	/*
403 	 * Get solaris partition information in the fdisk partition table
404 	 */
405 	if (get_solaris_part(cur_file, &cur_disk->fdisk_part) == -1) {
406 		err_print("No fdisk solaris partition found\n");
407 		cur_disk->fdisk_part.numsect = 0;  /* No Solaris */
408 	}
409 
410 	/*
411 	 * Restore cur_file with cur_disk->disk_path
412 	 */
413 	(void) open_cur_file(FD_USE_CUR_DISK_PATH);
414 
415 	return (0);
416 }
417 
418 /*
419  * Read MBR on the disk
420  * if the Solaris partition has changed,
421  *	reread the vtoc
422  */
423 #ifdef DEADCODE
424 static void
425 update_cur_parts()
426 {
427 
428 	int i;
429 	register struct partition_info *parts;
430 
431 	for (i = 0; i < NDKMAP; i++) {
432 #if defined(_SUNOS_VTOC_16)
433 		if (cur_parts->vtoc.v_part[i].p_tag &&
434 		    cur_parts->vtoc.v_part[i].p_tag != V_ALTSCTR) {
435 			cur_parts->vtoc.v_part[i].p_start = 0;
436 			cur_parts->vtoc.v_part[i].p_size = 0;
437 
438 #endif
439 			cur_parts->pinfo_map[i].dkl_nblk = 0;
440 			cur_parts->pinfo_map[i].dkl_cylno = 0;
441 			cur_parts->vtoc.v_part[i].p_tag =
442 			    default_vtoc_map[i].p_tag;
443 			cur_parts->vtoc.v_part[i].p_flag =
444 			    default_vtoc_map[i].p_flag;
445 #if defined(_SUNOS_VTOC_16)
446 		}
447 #endif
448 	}
449 	cur_parts->pinfo_map[C_PARTITION].dkl_nblk = ncyl * spc();
450 
451 #if defined(_SUNOS_VTOC_16)
452 	/*
453 	 * Adjust for the boot partitions
454 	 */
455 	cur_parts->pinfo_map[I_PARTITION].dkl_nblk = spc();
456 	cur_parts->pinfo_map[I_PARTITION].dkl_cylno = 0;
457 	cur_parts->vtoc.v_part[C_PARTITION].p_start =
458 	    cur_parts->pinfo_map[C_PARTITION].dkl_cylno * nhead * nsect;
459 	cur_parts->vtoc.v_part[C_PARTITION].p_size =
460 	    cur_parts->pinfo_map[C_PARTITION].dkl_nblk;
461 
462 	cur_parts->vtoc.v_part[I_PARTITION].p_start =
463 	    cur_parts->pinfo_map[I_PARTITION].dkl_cylno;
464 	cur_parts->vtoc.v_part[I_PARTITION].p_size =
465 	    cur_parts->pinfo_map[I_PARTITION].dkl_nblk;
466 
467 #endif	/* defined(_SUNOS_VTOC_16) */
468 	parts = cur_dtype->dtype_plist;
469 	cur_dtype->dtype_ncyl = ncyl;
470 	cur_dtype->dtype_plist = cur_parts;
471 	parts->pinfo_name = cur_parts->pinfo_name;
472 	cur_disk->disk_parts = cur_parts;
473 	cur_ctype->ctype_dlist = cur_dtype;
474 
475 }
476 #endif /* DEADCODE */
477 
478 static int
479 get_solaris_part(int fd, struct ipart *ipart)
480 {
481 	int		i;
482 	struct ipart	ip;
483 	int		status;
484 	char		*mbr;
485 	char		*bootptr;
486 	struct dk_label	update_label;
487 	ushort_t	found = 0;
488 #ifdef i386
489 	uint32_t	relsec, numsec;
490 	int		pno, rval, ext_part_found = 0;
491 	ext_part_t	*epp;
492 #endif
493 
494 	(void) lseek(fd, 0, 0);
495 
496 	/*
497 	 * We may get mbr of different size, but the first 512 bytes
498 	 * are valid information.
499 	 */
500 	mbr = malloc(cur_blksz);
501 	if (mbr == NULL) {
502 		err_print("No memory available.\n");
503 		return (-1);
504 	}
505 	status = read(fd, mbr, cur_blksz);
506 
507 	if (status != cur_blksz) {
508 		err_print("Bad read of fdisk partition. Status = %x\n", status);
509 		err_print("Cannot read fdisk partition information.\n");
510 		free(mbr);
511 		return (-1);
512 	}
513 
514 	(void) memcpy(&boot_sec, mbr, sizeof (struct mboot));
515 	free(mbr);
516 
517 #ifdef i386
518 	(void) extpart_init(&epp);
519 #endif
520 	for (i = 0; i < FD_NUMPART; i++) {
521 		int	ipc;
522 
523 		ipc = i * sizeof (struct ipart);
524 
525 		/* Handling the alignment problem of struct ipart */
526 		bootptr = &boot_sec.parts[ipc];
527 		(void) fill_ipart(bootptr, &ip);
528 
529 #ifdef i386
530 		if (fdisk_is_dos_extended(ip.systid) && (ext_part_found == 0)) {
531 			/* We support only one extended partition per disk */
532 			ext_part_found = 1;
533 			rval = fdisk_get_solaris_part(epp, &pno, &relsec,
534 			    &numsec);
535 			if (rval == FDISK_SUCCESS) {
536 				/*
537 				 * Found a solaris partition inside the
538 				 * extended partition. Update the statistics.
539 				 */
540 				if (nhead != 0 && nsect != 0) {
541 					pcyl = numsec / (nhead * nsect);
542 					xstart = relsec / (nhead * nsect);
543 					ncyl = pcyl - acyl;
544 				}
545 				solaris_offset = relsec;
546 				found = 2;
547 				ip.bootid = 0;
548 				ip.beghead = ip.begsect = ip.begcyl = 0xff;
549 				ip.endhead = ip.endsect = ip.endcyl = 0xff;
550 				ip.systid = SUNIXOS2;
551 				ip.relsect = relsec;
552 				ip.numsect = numsec;
553 				ipart->bootid = ip.bootid;
554 				status = bcmp(&ip, ipart,
555 				    sizeof (struct ipart));
556 				bcopy(&ip, ipart, sizeof (struct ipart));
557 			}
558 			continue;
559 		}
560 #endif
561 
562 		/*
563 		 * we are interested in Solaris and EFI partition types
564 		 */
565 #ifdef i386
566 		if ((ip.systid == SUNIXOS &&
567 		    (fdisk_is_linux_swap(epp, lel(ip.relsect), NULL) != 0)) ||
568 		    ip.systid == SUNIXOS2 ||
569 		    ip.systid == EFI_PMBR) {
570 #else
571 		if (ip.systid == SUNIXOS ||
572 		    ip.systid == SUNIXOS2 ||
573 		    ip.systid == EFI_PMBR) {
574 #endif
575 			/*
576 			 * if the disk has an EFI label, nhead and nsect may
577 			 * be zero.  This test protects us from FPE's, and
578 			 * format still seems to work fine
579 			 */
580 			if (nhead != 0 && nsect != 0) {
581 				pcyl = lel(ip.numsect) / (nhead * nsect);
582 				xstart = lel(ip.relsect) / (nhead * nsect);
583 				ncyl = pcyl - acyl;
584 			}
585 #ifdef DEBUG
586 			else {
587 				err_print("Critical geometry values are zero:\n"
588 				    "\tnhead = %d; nsect = %d\n", nhead, nsect);
589 			}
590 #endif /* DEBUG */
591 
592 			solaris_offset = (uint_t)lel(ip.relsect);
593 			found = 1;
594 			break;
595 		}
596 	}
597 
598 #ifdef i386
599 	libfdisk_fini(&epp);
600 #endif
601 
602 	if (!found) {
603 		err_print("Solaris fdisk partition not found\n");
604 		return (-1);
605 	} else if (found == 1) {
606 		/*
607 		 * Found a primary solaris partition.
608 		 * compare the previous and current Solaris partition
609 		 * but don't use bootid in determination of Solaris partition
610 		 * changes
611 		 */
612 		ipart->bootid = ip.bootid;
613 		status = bcmp(&ip, ipart, sizeof (struct ipart));
614 
615 		bcopy(&ip, ipart, sizeof (struct ipart));
616 	}
617 
618 	/* if the disk partitioning has changed - get the VTOC */
619 	if (status) {
620 		struct extvtoc exvtoc;
621 		struct vtoc vtoc;
622 
623 		status = ioctl(fd, DKIOCGEXTVTOC, &exvtoc);
624 		if (status == -1) {
625 			i = errno;
626 			/* Try the old ioctl DKIOCGVTOC */
627 			status = ioctl(fd, DKIOCGVTOC, &vtoc);
628 			if (status == -1) {
629 				err_print("Bad ioctl DKIOCGEXTVTOC.\n");
630 				err_print("errno=%d %s\n", i, strerror(i));
631 				err_print("Cannot read vtoc information.\n");
632 				return (-1);
633 			}
634 		}
635 
636 		status = read_label(fd, &update_label);
637 		if (status == -1) {
638 			err_print("Cannot read label information.\n");
639 			return (-1);
640 		}
641 
642 		/* copy vtoc information */
643 		cur_parts->vtoc = update_label.dkl_vtoc;
644 
645 #if defined(_SUNOS_VTOC_16)
646 		/*
647 		 * this is to update the slice table on x86
648 		 * we don't care about VTOC8 here
649 		 */
650 		for (i = 0; i < NDKMAP; i ++) {
651 			cur_parts->pinfo_map[i].dkl_cylno =
652 			    update_label.dkl_vtoc.v_part[i].p_start /
653 			    ((int)(update_label.dkl_nhead *
654 			    update_label.dkl_nsect));
655 			cur_parts->pinfo_map[i].dkl_nblk =
656 			    update_label.dkl_vtoc.v_part[i].p_size;
657 		}
658 #endif /* defined(_SUNOS_VTOC_16) */
659 
660 		cur_dtype->dtype_ncyl = update_label.dkl_ncyl;
661 		cur_dtype->dtype_pcyl = update_label.dkl_pcyl;
662 		cur_dtype->dtype_acyl = update_label.dkl_acyl;
663 		cur_dtype->dtype_nhead = update_label.dkl_nhead;
664 		cur_dtype->dtype_nsect = update_label.dkl_nsect;
665 		ncyl = cur_dtype->dtype_ncyl;
666 		acyl = cur_dtype->dtype_acyl;
667 		pcyl = cur_dtype->dtype_pcyl;
668 		nsect = cur_dtype->dtype_nsect;
669 		nhead = cur_dtype->dtype_nhead;
670 	}
671 	return (0);
672 }
673 
674 
675 int
676 copy_solaris_part(struct ipart *ipart)
677 {
678 
679 	int		status, i, fd;
680 	struct mboot	mboot;
681 	char		*mbr;
682 	struct ipart	ip;
683 	char		buf[MAXPATHLEN];
684 	char		*bootptr;
685 	struct stat	statbuf;
686 #ifdef i386
687 	uint32_t	relsec, numsec;
688 	int		pno, rval, ext_part_found = 0;
689 	ext_part_t	*epp;
690 #endif
691 
692 	(void) get_pname(&buf[0]);
693 	if (stat(buf, &statbuf) == -1 ||
694 	    !S_ISCHR(statbuf.st_mode) ||
695 	    ((cur_label == L_TYPE_EFI) &&
696 	    (cur_disk->disk_flags & DSK_LABEL_DIRTY))) {
697 		/*
698 		 * Make sure to reset solaris_offset to zero if it is
699 		 *	previously set by a selected disk that
700 		 *	supports the fdisk table.
701 		 */
702 		solaris_offset = 0;
703 		/*
704 		 * Return if this disk does not support fdisk table or
705 		 * if it uses an EFI label but has not yet been labelled.
706 		 * If the EFI label has not been written then the open
707 		 * on the partition will fail.
708 		 */
709 		return (0);
710 	}
711 
712 	if ((fd = open(buf, O_RDONLY)) < 0) {
713 		/*
714 		 * Labeled device support in lofi provides p0 partition on
715 		 * both x86 and sparc. However, sparc does not implement fdisk
716 		 * partitioning. This workaround will allow format
717 		 * to ignore fdisk errors in case of lofi devices.
718 		 */
719 		if (strcmp(cur_disk->disk_dkinfo.dki_cname, "lofi") == 0) {
720 			solaris_offset = 0;
721 			return (0);
722 		}
723 		err_print("Error: can't open disk '%s'.\n", buf);
724 		return (-1);
725 	}
726 
727 	/*
728 	 * We may get mbr of different size, but the first 512 bytes
729 	 * are valid information.
730 	 */
731 	mbr = malloc(cur_blksz);
732 	if (mbr == NULL) {
733 		err_print("No memory available.\n");
734 		return (-1);
735 	}
736 	status = read(fd, mbr, cur_blksz);
737 
738 	if (status != cur_blksz) {
739 		err_print("Bad read of fdisk partition.\n");
740 		(void) close(fd);
741 		free(mbr);
742 		return (-1);
743 	}
744 
745 	(void) memcpy(&mboot, mbr, sizeof (struct mboot));
746 
747 #ifdef i386
748 	(void) extpart_init(&epp);
749 #endif
750 	for (i = 0; i < FD_NUMPART; i++) {
751 		int	ipc;
752 
753 		ipc = i * sizeof (struct ipart);
754 
755 		/* Handling the alignment problem of struct ipart */
756 		bootptr = &mboot.parts[ipc];
757 		(void) fill_ipart(bootptr, &ip);
758 
759 #ifdef i386
760 		if (fdisk_is_dos_extended(ip.systid) && (ext_part_found == 0)) {
761 			/* We support only one extended partition per disk */
762 			ext_part_found = 1;
763 			rval = fdisk_get_solaris_part(epp, &pno, &relsec,
764 			    &numsec);
765 			if (rval == FDISK_SUCCESS) {
766 				/*
767 				 * Found a solaris partition inside the
768 				 * extended partition. Update the statistics.
769 				 */
770 				if (nhead != 0 && nsect != 0) {
771 					pcyl = numsec / (nhead * nsect);
772 					ncyl = pcyl - acyl;
773 				}
774 				solaris_offset = relsec;
775 				ip.bootid = 0;
776 				ip.beghead = ip.begsect = ip.begcyl = 0xff;
777 				ip.endhead = ip.endsect = ip.endcyl = 0xff;
778 				ip.systid = SUNIXOS2;
779 				ip.relsect = relsec;
780 				ip.numsect = numsec;
781 				bcopy(&ip, ipart, sizeof (struct ipart));
782 			}
783 			continue;
784 		}
785 #endif
786 
787 
788 #ifdef i386
789 		if ((ip.systid == SUNIXOS &&
790 		    (fdisk_is_linux_swap(epp, lel(ip.relsect), NULL) != 0)) ||
791 		    ip.systid == SUNIXOS2 ||
792 		    ip.systid == EFI_PMBR) {
793 #else
794 		if (ip.systid == SUNIXOS ||
795 		    ip.systid == SUNIXOS2 ||
796 		    ip.systid == EFI_PMBR) {
797 #endif
798 			solaris_offset = lel(ip.relsect);
799 			bcopy(&ip, ipart, sizeof (struct ipart));
800 
801 			/*
802 			 * if the disk has an EFI label, we typically won't
803 			 * have values for nhead and nsect.  format seems to
804 			 * work without them, and we need to protect ourselves
805 			 * from FPE's
806 			 */
807 			if (nhead != 0 && nsect != 0) {
808 				pcyl = lel(ip.numsect) / (nhead * nsect);
809 				ncyl = pcyl - acyl;
810 			}
811 #ifdef DEBUG
812 			else {
813 				err_print("Critical geometry values are zero:\n"
814 				    "\tnhead = %d; nsect = %d\n", nhead, nsect);
815 			}
816 #endif /* DEBUG */
817 
818 			break;
819 		}
820 	}
821 #ifdef i386
822 	libfdisk_fini(&epp);
823 #endif
824 
825 	(void) close(fd);
826 	free(mbr);
827 	return (0);
828 }
829 
830 #if defined(_FIRMWARE_NEEDS_FDISK)
831 int
832 auto_solaris_part(struct dk_label *label)
833 {
834 
835 	int		status, i, fd;
836 	struct mboot	mboot;
837 	char		*mbr;
838 	struct ipart	ip;
839 	char		*bootptr;
840 	char		pbuf[MAXPATHLEN];
841 #ifdef i386
842 	uint32_t	relsec, numsec;
843 	int		pno, rval, ext_part_found = 0;
844 	ext_part_t	*epp;
845 #endif
846 
847 	(void) get_pname(&pbuf[0]);
848 	if ((fd = open_disk(pbuf, O_RDONLY)) < 0) {
849 		err_print("Error: can't open selected disk '%s'.\n", pbuf);
850 		return (-1);
851 	}
852 
853 	/*
854 	 * We may get mbr of different size, but the first 512 bytes
855 	 * are valid information.
856 	 */
857 	mbr = malloc(cur_blksz);
858 	if (mbr == NULL) {
859 		err_print("No memory available.\n");
860 		return (-1);
861 	}
862 	status = read(fd, mbr, cur_blksz);
863 
864 	if (status != cur_blksz) {
865 		err_print("Bad read of fdisk partition.\n");
866 		free(mbr);
867 		return (-1);
868 	}
869 
870 	(void) memcpy(&mboot, mbr, sizeof (struct mboot));
871 
872 #ifdef i386
873 	(void) extpart_init(&epp);
874 #endif
875 	for (i = 0; i < FD_NUMPART; i++) {
876 		int	ipc;
877 
878 		ipc = i * sizeof (struct ipart);
879 
880 		/* Handling the alignment problem of struct ipart */
881 		bootptr = &mboot.parts[ipc];
882 		(void) fill_ipart(bootptr, &ip);
883 
884 #ifdef i386
885 		if (fdisk_is_dos_extended(ip.systid) && (ext_part_found == 0)) {
886 			/* We support only one extended partition per disk */
887 			ext_part_found = 1;
888 			rval = fdisk_get_solaris_part(epp, &pno, &relsec,
889 			    &numsec);
890 			if (rval == FDISK_SUCCESS) {
891 				/*
892 				 * Found a solaris partition inside the
893 				 * extended partition. Update the statistics.
894 				 */
895 				if ((label->dkl_nhead != 0) &&
896 				    (label->dkl_nsect != 0)) {
897 					label->dkl_pcyl =
898 					    numsec / (label->dkl_nhead *
899 					    label->dkl_nsect);
900 					label->dkl_ncyl = label->dkl_pcyl -
901 					    label->dkl_acyl;
902 				}
903 				solaris_offset = relsec;
904 			}
905 			continue;
906 		}
907 #endif
908 
909 		/*
910 		 * if the disk has an EFI label, the nhead and nsect fields
911 		 * the label may be zero.  This protects us from FPE's, and
912 		 * format still seems to work happily
913 		 */
914 
915 
916 #ifdef i386
917 		if ((ip.systid == SUNIXOS &&
918 		    (fdisk_is_linux_swap(epp, lel(ip.relsect), NULL) != 0)) ||
919 		    ip.systid == SUNIXOS2 ||
920 		    ip.systid == EFI_PMBR) {
921 #else
922 		if (ip.systid == SUNIXOS ||
923 		    ip.systid == SUNIXOS2 ||
924 		    ip.systid == EFI_PMBR) {
925 #endif
926 			if ((label->dkl_nhead != 0) &&
927 			    (label->dkl_nsect != 0)) {
928 				label->dkl_pcyl = lel(ip.numsect) /
929 				    (label->dkl_nhead * label->dkl_nsect);
930 				label->dkl_ncyl = label->dkl_pcyl -
931 				    label->dkl_acyl;
932 			}
933 #ifdef DEBUG
934 			else {
935 				err_print("Critical label fields aren't "
936 				    "non-zero:\n"
937 				    "\tlabel->dkl_nhead = %d; "
938 				    "label->dkl_nsect = "
939 				    "%d\n", label->dkl_nhead,
940 				    label->dkl_nsect);
941 			}
942 #endif /* DEBUG */
943 
944 		solaris_offset = lel(ip.relsect);
945 		break;
946 		}
947 	}
948 
949 #ifdef i386
950 	libfdisk_fini(&epp);
951 #endif
952 	(void) close(fd);
953 	free(mbr);
954 	return (0);
955 }
956 #endif	/* defined(_FIRMWARE_NEEDS_FDISK) */
957 
958 
959 int
960 good_fdisk()
961 {
962 	char		buf[MAXPATHLEN];
963 	struct stat	statbuf;
964 
965 	(void) get_pname(&buf[0]);
966 	if (stat(buf, &statbuf) == -1 ||
967 	    !S_ISCHR(statbuf.st_mode) ||
968 	    cur_label == L_TYPE_EFI) {
969 		/*
970 		 * Return if this disk does not support fdisk table or
971 		 * if the disk is labeled with EFI.
972 		 */
973 		return (1);
974 	}
975 
976 	if (lel(cur_disk->fdisk_part.numsect) > 0) {
977 		return (1);
978 	} else {
979 		/*
980 		 * Labeled device support in lofi provides p0 partition on
981 		 * both x86 and sparc. However, sparc does not implement fdisk
982 		 * partitioning. This workaround will allow format
983 		 * to ignore fdisk errors in case of lofi devices.
984 		 */
985 		if (strcmp(cur_disk->disk_dkinfo.dki_cname, "lofi") == 0) {
986 			return (1);
987 		}
988 		err_print("WARNING - ");
989 		err_print("This disk may be in use by an application "
990 		    "that has\n\t  modified the fdisk table. Ensure "
991 		    "that this disk is\n\t  not currently in use "
992 		    "before proceeding to use fdisk.\n");
993 		return (0);
994 	}
995 }
996 
997 #ifdef i386
998 int
999 extpart_init(ext_part_t **epp)
1000 {
1001 	int		rval, lf_op_flag = 0;
1002 	char		p0_path[MAXPATHLEN];
1003 
1004 	get_pname(&p0_path[0]);
1005 	lf_op_flag |= FDISK_READ_DISK;
1006 	if ((rval = libfdisk_init(epp, p0_path, NULL, lf_op_flag)) !=
1007 	    FDISK_SUCCESS) {
1008 		switch (rval) {
1009 			/*
1010 			 * FDISK_EBADLOGDRIVE, FDISK_ENOLOGDRIVE
1011 			 * and FDISK_EBADMAGIC can be considered
1012 			 * as soft errors and hence we do not exit.
1013 			 */
1014 			case FDISK_EBADLOGDRIVE:
1015 				break;
1016 			case FDISK_ENOLOGDRIVE:
1017 				break;
1018 			case FDISK_EBADMAGIC:
1019 				break;
1020 			case FDISK_ENOVGEOM:
1021 				err_print("Could not get virtual geometry for"
1022 				    " this device\n");
1023 				fullabort();
1024 				break;
1025 			case FDISK_ENOPGEOM:
1026 				err_print("Could not get physical geometry for"
1027 				    " this device\n");
1028 				fullabort();
1029 				break;
1030 			case FDISK_ENOLGEOM:
1031 				err_print("Could not get label geometry for "
1032 				    " this device\n");
1033 				fullabort();
1034 				break;
1035 			default:
1036 				err_print("Failed to initialise libfdisk.\n");
1037 				fullabort();
1038 				break;
1039 		}
1040 	}
1041 	return (0);
1042 }
1043 #endif
1044