Chameleon

Chameleon Svn Source Tree

Root/branches/zenith432/i386/libsaio/disk.c

1/*␊
2 * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved.␊
3 *␊
4 * @APPLE_LICENSE_HEADER_START@␊
5 * ␊
6 * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights␊
7 * Reserved. This file contains Original Code and/or Modifications of␊
8 * Original Code as defined in and that are subject to the Apple Public␊
9 * Source License Version 2.0 (the "License"). You may not use this file␊
10 * except in compliance with the License. Please obtain a copy of the␊
11 * License at http://www.apple.com/publicsource and read it before using␊
12 * this file.␊
13 * ␊
14 * The Original Code and all software distributed under the License are␊
15 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER␊
16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,␊
17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,␊
18 * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the␊
19 * License for the specific language governing rights and limitations␊
20 * under the License.␊
21 * ␊
22 * @APPLE_LICENSE_HEADER_END@␊
23 *␊
24 *␊
25 * Mach Operating System␊
26 * Copyright (c) 1990 Carnegie-Mellon University␊
27 * Copyright (c) 1989 Carnegie-Mellon University␊
28 * All rights reserved. The CMU software License Agreement specifies␊
29 * the terms and conditions for use and redistribution.␊
30 *␊
31 *␊
32 * INTEL CORPORATION PROPRIETARY INFORMATION␊
33 *␊
34 * This software is supplied under the terms of a license agreement or ␊
35 * nondisclosure agreement with Intel Corporation and may not be copied ␊
36 * nor disclosed except in accordance with the terms of that agreement.␊
37 *␊
38 * Copyright 1988, 1989 Intel Corporation␊
39 *␊
40 *␊
41 * Copyright 1993 NeXT Computer, Inc.␊
42 * All rights reserved.␊
43 *␊
44 *␊
45 * Copyright 2007 VMware Inc.␊
46 * "Preboot" ramdisk support added by David Elliott␊
47 * GPT support added by David Elliott. Based on IOGUIDPartitionScheme.cpp.␊
48 */␊
49␊
50//Azi: style the rest later...␊
51␊
52// Allow UFS_SUPPORT to be overridden with preprocessor option.␊
53#ifndef UFS_SUPPORT␊
54// zef: Disabled UFS support␊
55#define UFS_SUPPORT 0␊
56#endif␊
57␊
58#if UFS_SUPPORT␊
59#include "ufs.h"␊
60#endif␊
61#include <limits.h>␊
62#include <IOKit/storage/IOApplePartitionScheme.h>␊
63#include <IOKit/storage/IOGUIDPartitionScheme.h>␊
64#include "libsaio.h"␊
65#include "boot.h"␊
66#include "bootstruct.h"␊
67#include "memory.h"␊
68#include "fdisk.h"␊
69#include "hfs.h"␊
70#include "ntfs.h"␊
71#include "exfat.h"␊
72#include "msdos.h"␊
73#include "ext2fs.h"␊
74#include "befs.h"␊
75#include "freebsd.h"␊
76#include "openbsd.h"␊
77#include "xml.h"␊
78#include "disk.h"␊
79// For EFI_GUID␊
80#include "efi.h"␊
81#include "efi_tables.h"␊
82␊
83typedef struct gpt_hdr gpt_hdr;␊
84typedef struct gpt_ent gpt_ent;␊
85␊
86#define PROBEFS_SIZE BPS * 4 /* buffer size for filesystem probe */␊
87#define CD_BPS 2048 /* CD-ROM block size */␊
88#define N_CACHE_SECS (BIOS_LEN / BPS) /* Must be a multiple of 4 for CD-ROMs */␊
89#define UFS_FRONT_PORCH 0␊
90#define kAPMSector 2 /* Sector number of Apple partition map */␊
91#define kAPMCDSector 8 /* Translated sector of Apple partition map on a CD */␊
92#define ECC_CORRECTED_ERR 0x11␊
93␊
94/*␊
95 * IORound and IOTrunc convenience functions, in the spirit␊
96 * of vm's round_page() and trunc_page().␊
97 */␊
98#define IORound(value,multiple) \␊
99 ((((value) + (multiple) - 1) / (multiple)) * (multiple))␊
100␊
101#define IOTrunc(value,multiple) \␊
102 (((value) / (multiple)) * (multiple));␊
103␊
104//==========================================================================␊
105// Maps (E)BIOS return codes to message strings.␊
106␊
107struct NamedValue {␊
108␉unsigned char value;␊
109␉const char *name;␊
110};␊
111␊
112/*␊
113 * Map a disk drive to bootable volumes contained within.␊
114 */␊
115struct DiskBVMap {␊
116 int biosdev;␉␉// BIOS device number (unique)␊
117 BVRef bvr;␉␉// chain of boot volumes on the disk␊
118 int bvrcnt;␉␉// number of boot volumes␊
119 struct DiskBVMap *next;␉␉// linkage to next mapping␊
120};␊
121␊
122/*␊
123 * trackbuf points to the start of the track cache. Biosread()␊
124 * will store the sectors read from disk to this memory area.␊
125 *␊
126 * biosbuf points to a sector within the track cache, and is␊
127 * updated by Biosread().␊
128 */␊
129static char * const trackbuf = (char *) ptov(BIOS_ADDR);␊
130static char * biosbuf;␊
131␊
132static struct DiskBVMap *gDiskBVMap = NULL;␊
133static struct disk_blk0 *gBootSector = NULL;␊
134␊
135// Function pointers to be filled in if ramdisks are available:␊
136int (*p_ramdiskReadBytes)( int biosdev, unsigned int blkno,␊
137 unsigned int byteoff,␊
138 unsigned int byteCount, void * buffer ) = NULL;␊
139int (*p_get_ramdisk_info)(int biosdev, struct driveInfo *dip) = NULL;␊
140␊
141static bool getOSVersion(BVRef bvr, char *str);␊
142static bool cache_valid = false;␊
143␊
144static const struct NamedValue bios_errors[] =␊
145{␊
146␉{ 0x10, "Media error" },␊
147␉{ 0x11, "Corrected ECC error" },␊
148␉{ 0x20, "Controller or device error" },␊
149␉{ 0x40, "Seek failed" },␊
150␉{ 0x80, "Device timeout" },␊
151␉{ 0xAA, "Drive not ready" },␊
152␉{ 0x00, NULL }␊
153};␊
154␊
155static const struct NamedValue fdiskTypes[] =␊
156{␊
157␉{ FDISK_DOS12,␉␉"DOS_FAT_12" }, // 0x01␊
158␉{ FDISK_DOS16S,␉␉"DOS_FAT_16_S" }, // 0x04␊
159␉{ FDISK_DOS16B,␉␉"DOS_FAT_16" }, // 0x06␊
160␉{ FDISK_NTFS,␉␉"Windows NTFS" }, // 0x07␊
161␉{ FDISK_SMALLFAT32,␉"DOS_FAT_32" }, // 0x0B␊
162␉{ FDISK_FAT32,␉␉"Windows FAT_32" }, // 0x0C␊
163␉{ FDISK_DOS16SLBA,␉"Windows FAT_16" }, // 0x0E␊
164␉{ FDISK_WIN_LDM, "Windows_LDM" }, // 0x42␊
165␉{ FDISK_LINUX_SWAP, "Linux_Swap" }, // 0x82␊
166␉{ FDISK_LINUX,␉␉"Linux" }, // 0x83␊
167␉{ FDISK_LINUX_LVM, "Linux_LVM" }, // 0x8E␊
168␉{ FDISK_FREEBSD,␉"FreeBSD" }, // 0xA5␊
169␉{ FDISK_OPENBSD,␉"OpenBSD" }, // 0xA6␊
170␉{ FDISK_NEXTNAME, "Apple_Rhapsody_UFS" }, // 0xA7␊
171␉{ FDISK_UFS,␉␉"Apple UFS" }, // 0xA8␊
172␉{ FDISK_NETBSD, "NetBSD" }, // 0xA9␊
173␉{ FDISK_BOOTER,␉␉"Apple_Boot" }, // 0xAB␊
174␉{ FDISK_ENCRYPTED, "Apple_Encrypted" }, // 0xAE␊
175␉{ FDISK_HFS,␉␉"Apple HFS" }, // 0xAF␊
176␉{ 0xCD,␉␉␉"CD-ROM" }, // 0xCD␊
177␉{ FDISK_BEFS, "Haiku" }, // 0xEB␊
178␉{ FDISK_LINUX_RAID, "Linux_RAID" }, // 0xFD␊
179␉{ 0x00,␉␉␉NULL } /* must be last */␊
180};␊
181␊
182//==============================================================================␊
183␊
184extern void spinActivityIndicator(int sectors);␊
185␊
186//==========================================================================␊
187␊
188static int getDriveInfo( int biosdev, struct driveInfo *dip )␊
189{␊
190␉static struct driveInfo cached_di;␊
191␉int cc;␊
192␊
193␉// Real BIOS devices are 8-bit, so anything above that is for internal use.␊
194␉// Don't cache ramdisk drive info since it doesn't require several BIOS␊
195␉// calls and is thus not worth it.␊
196␉if (biosdev >= 0x100)␊
197␉{␊
198␉␉if (p_get_ramdisk_info != NULL)␊
199␉␉{␊
200␉␉␉cc = (*p_get_ramdisk_info)(biosdev, dip);␊
201␉␉}␊
202␉␉else␊
203␉␉{␊
204␉␉␉cc = -1;␊
205␉␉}␊
206␉␉if (cc < 0)␊
207␉␉{␊
208␉␉␉dip->valid = 0;␊
209␉␉␉return -1;␊
210␉␉}␊
211␉␉else␊
212␉␉{␊
213␉␉␉return 0;␊
214␉␉}␊
215␉}␊
216␊
217␉if (!cached_di.valid || biosdev != cached_di.biosdev)␊
218␉{␊
219␉␉cc = get_drive_info(biosdev, &cached_di);␊
220␊
221␉␉if (cc < 0)␊
222␉␉{␊
223␉␉␉cached_di.valid = 0;␊
224␉␉␉DEBUG_DISK(("get_drive_info returned error\n"));␊
225␉␉␉return (-1); // BIOS call error␊
226␉␉}␊
227␉}␊
228␊
229␉bcopy(&cached_di, dip, sizeof(cached_di));␊
230␊
231␉return 0;␊
232}␊
233␊
234//==========================================================================␊
235␊
236static const char *getNameForValue( const struct NamedValue *nameTable,␊
237 unsigned char value )␊
238{␊
239␉const struct NamedValue *np;␊
240␊
241␉for ( np = nameTable; np->value; np++)␊
242␉{␊
243␉␉if (np->value == value)␊
244␉␉{␊
245␉␉␉return np->name;␊
246␉␉}␊
247␉}␊
248␊
249␉return NULL;␊
250}␊
251␊
252//==============================================================================␊
253␊
254static const char * bios_error(int errnum)␊
255{␊
256␉static char errorstr[] = "Error 0x00";␊
257␉const char * errname;␊
258␊
259␉errname = getNameForValue(bios_errors, errnum);␊
260␊
261␉if (errname)␊
262␉{␊
263␉␉return errname;␊
264␉}␊
265␊
266␉snprintf(errorstr, sizeof(errorstr), "Error 0x%02x", errnum);␊
267␉return errorstr; // No string, print error code only␊
268}␊
269␊
270//==========================================================================␊
271// Use BIOS INT13 calls to read the sector specified. This function will␊
272// also perform read-ahead to cache a few subsequent sector to the sector␊
273// cache.␊
274// ␊
275// Return:␊
276// 0 on success, or an error code from INT13/F2 or INT13/F42 BIOS call.␊
277␊
278static int Biosread( int biosdev, unsigned long long secno )␊
279{␊
280␉static int xbiosdev, xcyl, xhead;␊
281␉static unsigned int xsec, xnsecs;␊
282␉struct driveInfo di;␊
283␊
284␉int rc = -1;␊
285␉int cyl, head, sec;␊
286␉int tries = 0;␊
287␉int bps, divisor;␊
288␊
289␉if (getDriveInfo(biosdev, &di) < 0)␊
290␉{␊
291␉␉return -1;␊
292␉}␊
293␊
294␉if (di.no_emulation)␊
295␉{␊
296␉␉bps = 2048; /* Always assume 2K block size since the BIOS may lie about the geometry */␊
297␉}␊
298␉else␊
299␉{␊
300␉␉bps = di.di.params.phys_nbps;␊
301␊
302␉␉if (bps == 0)␊
303␉␉{␊
304␉␉␉return -1;␊
305␉␉}␊
306␉}␊
307␊
308␉divisor = bps / BPS;␊
309␊
310␉DEBUG_DISK(("Biosread dev %x sec %d bps %d\n", biosdev, secno, bps));␊
311␊
312␉// To read the disk sectors, use EBIOS if we can. Otherwise,␊
313␉// revert to the standard BIOS calls.␊
314␊
315␉if ((biosdev >= kBIOSDevTypeHardDrive) && (di.uses_ebios & EBIOS_FIXED_DISK_ACCESS))␊
316␉{␊
317␉␉if (cache_valid && (biosdev == xbiosdev) && (secno >= xsec) && ((unsigned int)secno < (xsec + xnsecs)))␊
318␉␉{␊
319␉␉␉biosbuf = trackbuf + (BPS * (secno - xsec));␊
320␉␉␉return 0;␊
321␉␉}␊
322␊
323␉␉xnsecs = N_CACHE_SECS;␊
324␉␉xsec = (secno / divisor) * divisor;␊
325␉␉cache_valid = false;␊
326␊
327␉␉while ((rc = ebiosread(biosdev, secno / divisor, xnsecs / divisor)) && (++tries < 5))␊
328␉␉{␊
329␉␉␉if (rc == ECC_CORRECTED_ERR)␊
330␉␉␉{␊
331␉␉␉␉rc = 0; /* Ignore corrected ECC errors */␊
332␉␉␉␉break;␊
333␉␉␉}␊
334␊
335␉␉␉error(" EBIOS read error: %s\n", bios_error(rc), rc);␊
336␉␉␉error(" Block 0x%x Sectors %d\n", secno, xnsecs);␊
337␉␉␉sleep(1);␊
338␉␉}␊
339␉}␊
340␊
341␉else␊
342␉{␊
343␉␉/* spc = spt * heads */␊
344␉␉int spc = (di.di.params.phys_spt * di.di.params.phys_heads);␊
345␉␉cyl = secno / spc;␊
346␉␉head = (secno % spc) / di.di.params.phys_spt;␊
347␉␉sec = secno % di.di.params.phys_spt;␊
348␊
349␉␉if (cache_valid && (biosdev == xbiosdev) && (cyl == xcyl) &&␊
350␉␉␉(head == xhead) && ((unsigned int)sec >= xsec) && ((unsigned int)sec < (xsec + xnsecs)))␊
351␊
352␉␉{␊
353␉␉␉// this sector is in trackbuf cache␊
354␉␉␉biosbuf = trackbuf + (BPS * (sec - xsec));␊
355␉␉␉return 0;␊
356␉␉}␊
357␊
358␉␉// Cache up to a track worth of sectors, but do not cross a track boundary.␊
359␊
360␉␉xcyl = cyl;␊
361␉␉xhead = head;␊
362␉␉xsec = sec;␊
363␉␉xnsecs = ((unsigned int)(sec + N_CACHE_SECS) > di.di.params.phys_spt) ? (di.di.params.phys_spt - sec) : N_CACHE_SECS;␊
364␊
365␉␉cache_valid = false;␊
366␊
367␉␉while ((rc = biosread(biosdev, cyl, head, sec, xnsecs)) && (++tries < 5))␊
368␉␉{␊
369␉␉␉if (rc == ECC_CORRECTED_ERR)␊
370␉␉␉{␊
371␉␉␉␉rc = 0; /* Ignore corrected ECC errors */␊
372␉␉␉␉break;␊
373␉␉␉}␊
374␉␉␉error(" BIOS read error: %s\n", bios_error(rc), rc);␊
375␉␉␉error(" Block %d, Cyl %d Head %d Sector %d\n", secno, cyl, head, sec);␊
376␉␉␉sleep(1);␊
377␉␉}␊
378␉}␊
379␊
380␉// If the BIOS reported success, mark the sector cache as valid.␊
381␊
382␉if (rc == 0)␊
383␉{␊
384␉␉cache_valid = true;␊
385␉}␊
386␊
387␉biosbuf = trackbuf + (secno % divisor) * BPS;␊
388␉xbiosdev = biosdev;␊
389␊
390␉spinActivityIndicator(xnsecs);␊
391␊
392␉return rc;␊
393}␊
394␊
395//==============================================================================␊
396␊
397int testBiosread(int biosdev, unsigned long long secno)␊
398{␊
399␉return Biosread(biosdev, secno);␊
400}␊
401␊
402//==============================================================================␊
403␊
404static int readBytes(int biosdev, unsigned long long blkno, unsigned int byteoff, unsigned int byteCount, void * buffer)␊
405{␊
406␉// ramdisks require completely different code for reading.␊
407␉if(p_ramdiskReadBytes != NULL && biosdev >= 0x100)␊
408␉{␊
409␉␉return (*p_ramdiskReadBytes)(biosdev, blkno, byteoff, byteCount, buffer);␊
410␉}␊
411␊
412␉char * cbuf = (char *) buffer;␊
413␉int error;␊
414␉int copy_len;␊
415␊
416␉DEBUG_DISK(("%s: dev %X block %X [%d] -> 0x%X...", __FUNCTION__, biosdev, blkno, byteCount, (unsigned)cbuf));␊
417␊
418␉for (; byteCount; cbuf += copy_len, blkno++)␊
419␉{␊
420␉␉error = Biosread(biosdev, blkno);␊
421␊
422␉␉if (error)␊
423␉␉{␊
424␉␉␉DEBUG_DISK(("error\n"));␊
425␊
426␉␉␉return (-1);␊
427␉␉}␊
428␊
429␉␉copy_len = ((byteCount + byteoff) > BPS) ? (BPS - byteoff) : byteCount;␊
430␉␉bcopy( biosbuf + byteoff, cbuf, copy_len );␊
431␉␉byteCount -= copy_len;␊
432␉␉byteoff = 0;␊
433␉}␊
434␊
435␉DEBUG_DISK(("done\n"));␊
436␊
437␉return 0; ␊
438}␊
439␊
440//==============================================================================␊
441␊
442static int isExtendedFDiskPartition( const struct fdisk_part *part )␊
443{␊
444␉static unsigned char extParts[] =␊
445␉{␊
446␉␉0x05, /* Extended */␊
447␉␉0x0f, /* Win95 extended */␊
448␉␉0x85, /* Linux extended */␊
449␉};␊
450␊
451␉unsigned int i;␊
452␊
453␉for (i = 0; i < sizeof(extParts)/sizeof(extParts[0]); i++)␊
454␉{␊
455␉␉if (extParts[i] == part->systid)␊
456␉␉{␊
457␉␉␉return 1;␊
458␉␉}␊
459␉}␊
460␉return 0;␊
461}␊
462␊
463//==============================================================================␊
464␊
465static int getNextFDiskPartition( int biosdev, int *partno, const struct fdisk_part **outPart )␊
466{␊
467␉static int sBiosdev = -1;␊
468␉static int sNextPartNo;␊
469␉static unsigned int sFirstBase;␊
470␉static unsigned int sExtBase;␊
471␉static unsigned int sExtDepth;␊
472␉static struct fdisk_part *sExtPart;␊
473␉struct fdisk_part *part;␊
474␊
475␉if ( sBiosdev != biosdev || *partno < 0 )␊
476␉{␊
477␉␉// Fetch MBR.␊
478␉␉if ( readBootSector( biosdev, DISK_BLK0, 0 ) )␊
479␉␉{␊
480␉␉␉return 0;␊
481␉␉}␊
482␊
483␉␉sBiosdev = biosdev;␊
484␉␉sNextPartNo = 0;␊
485␉␉sFirstBase = 0;␊
486␉␉sExtBase = 0;␊
487␉␉sExtDepth = 0;␊
488␉␉sExtPart = NULL;␊
489␉}␊
490␊
491␉while (1)␊
492␉{␊
493␉␉part = NULL;␊
494␊
495␉␉if ( sNextPartNo < FDISK_NPART )␊
496␉␉{␊
497␉␉␉part = (struct fdisk_part *) gBootSector->parts[sNextPartNo];␊
498␉␉}␊
499␉␉else if ( sExtPart )␊
500␉␉{␊
501␉␉␉unsigned int blkno = sExtPart->relsect + sFirstBase;␊
502␊
503␉␉␉// Save the block offset of the first extended partition.␊
504␊
505␉␉␉if (sExtDepth == 0)␊
506␉␉␉{␊
507␉␉␉␉sFirstBase = blkno;␊
508␉␉␉}␊
509␉␉␉sExtBase = blkno;␊
510␊
511␉␉␉// Load extended partition table.␊
512␊
513␉␉␉if ( readBootSector( biosdev, blkno, 0 ) == 0 )␊
514␉␉␉{␊
515␉␉␉␉sNextPartNo = 0;␊
516␉␉␉␉sExtDepth++;␊
517␉␉␉␉sExtPart = NULL;␊
518␉␉␉␉continue;␊
519␉␉␉}␊
520␉␉␉// Fall through to part == NULL␊
521␉␉}␊
522␊
523␉␉if ( part == NULL ) break; // Reached end of partition chain.␊
524␊
525␉␉// Advance to next partition number.␊
526␊
527␉␉sNextPartNo++;␊
528␊
529␉␉if ( isExtendedFDiskPartition(part) )␊
530␉␉{␊
531␉␉␉sExtPart = part;␊
532␉␉␉continue;␊
533␉␉}␊
534␊
535␉␉// Skip empty slots.␊
536␊
537␉␉if ( part->systid == 0x00 )␊
538␉␉{␊
539␉␉␉continue;␊
540␉␉}␊
541␊
542␉␉// Change relative offset to an absolute offset.␊
543␉␉part->relsect += sExtBase;␊
544␊
545␉␉*outPart = part;␊
546␉␉*partno = sExtDepth ? (int)(sExtDepth + FDISK_NPART) : sNextPartNo;␊
547␊
548␉␉break;␊
549␉}␊
550␊
551␉return (part != NULL);␊
552}␊
553␊
554//==============================================================================␊
555␊
556/*␊
557 * Trying to figure out the filsystem type of a given partition.␊
558 * X = fdisk partition type␊
559 * 0 = Unknown/Unused␊
560 * -1 = error␊
561 */␊
562static int probeFileSystem(int biosdev, unsigned int blkoff)␊
563{␊
564␉// detected filesystem type;␊
565␉int result = -1;␊
566␉int fatbits = 0;␊
567␊
568␉// Allocating buffer for 4 sectors.␊
569␉const void *probeBuffer = malloc(PROBEFS_SIZE);␊
570␉if (probeBuffer == NULL)␊
571␉{␊
572␉␉goto exit;␊
573␉}␊
574␊
575␉// Reading first 4 sectors of current partition␊
576␉int error = readBytes(biosdev, blkoff, 0, PROBEFS_SIZE, (void *)probeBuffer);␊
577␊
578␉if (error)␊
579␉{␊
580␉␉goto exit;␊
581␉}␊
582␊
583␉if (HFSProbe(probeBuffer))␊
584␉{␊
585␉␉result = FDISK_HFS;␊
586␉}␊
587␉else if (EX2Probe(probeBuffer))␊
588␉{␊
589␉␉result = FDISK_LINUX;␊
590␉}␊
591␉else if (FreeBSDProbe(probeBuffer))␊
592␉{␊
593␉␉result = FDISK_FREEBSD;␊
594␉}␊
595␉else if (OpenBSDProbe(probeBuffer))␊
596␉{␊
597␉␉result = FDISK_OPENBSD;␊
598␉}␊
599␉else if (BeFSProbe(probeBuffer))␊
600␉{␊
601␉␉result = FDISK_BEFS;␊
602␉}␊
603␉else if (NTFSProbe(probeBuffer))␊
604␉{␊
605␉␉result = FDISK_NTFS;␊
606␉}␊
607␊
608␉else if (EXFATProbe(probeBuffer))␊
609␉{␊
610␉␉result = FDISK_PSEUDO_EXFAT;␊
611␉}␊
612␊
613␉else if ((fatbits = MSDOSProbe(probeBuffer)))␊
614␉{␊
615␉␉switch (fatbits)␊
616␉␉{␊
617␉␉␉case 12:␊
618␉␉␉␉result = FDISK_DOS12;␊
619␉␉␉␉break;␊
620␊
621␉␉␉case 16:␊
622␉␉␉␉result = FDISK_DOS16B;␊
623␉␉␉␉break;␊
624␊
625␉␉␉case 32:␊
626␉␉␉default:␊
627␉␉␉␉result = FDISK_FAT32;␊
628␉␉␉␉break;␊
629␉␉}␊
630␉}␊
631␉else␊
632␉{␊
633␉␉// Couldn't detect filesystem type␊
634␉␉result = 0;␊
635␉}␊
636␊
637exit:␊
638␉if (probeBuffer)␊
639␉{␊
640␉␉free((void *)probeBuffer);␊
641␉}␊
642␊
643␉return result;␊
644}␊
645␊
646//==============================================================================␊
647␊
648static BVRef newFDiskBVRef( int biosdev,␊
649 int partno,␊
650 unsigned int blkoff,␊
651 const struct fdisk_part *part,␊
652 FSInit initFunc,␊
653 FSLoadFile loadFunc,␊
654 FSReadFile readFunc,␊
655 FSGetDirEntry getdirFunc,␊
656 FSGetFileBlock getBlockFunc,␊
657 FSGetUUID getUUIDFunc,␊
658 BVGetDescription getDescriptionFunc,␊
659 BVFree bvFreeFunc,␊
660 int probe, int type, unsigned int bvrFlags )␊
661{␊
662␉BVRef bvr = (BVRef)malloc(sizeof(*bvr));␊
663␉if ( bvr )␊
664␉{␊
665␉␉bzero(bvr, sizeof(*bvr));␊
666␊
667␉␉bvr->biosdev = biosdev;␊
668␉␉bvr->part_no = partno;␊
669␉␉bvr->part_boff = blkoff;␊
670␉␉bvr->part_type = part->systid;␊
671␉␉bvr->fs_loadfile = loadFunc;␊
672␉␉bvr->fs_readfile = readFunc;␊
673␉␉bvr->fs_getdirentry = getdirFunc;␊
674␉␉bvr->fs_getfileblock= getBlockFunc;␊
675␉␉bvr->fs_getuuid = getUUIDFunc;␊
676␉␉bvr->description = getDescriptionFunc;␊
677␉␉bvr->type = type;␊
678␉␉bvr->bv_free = bvFreeFunc;␊
679␊
680␉␉if ((part->bootid & FDISK_ACTIVE) && (part->systid == FDISK_HFS))␊
681␉␉{␊
682␉␉␉bvr->flags |= kBVFlagPrimary;␊
683␉␉}␊
684␊
685␉␉// Probe the filesystem.␊
686␊
687␉␉if ( initFunc )␊
688␉␉{␊
689␉␉␉bvr->flags |= kBVFlagNativeBoot;␊
690␊
691␉␉␉if ( probe && initFunc( bvr ) != 0 )␊
692␉␉␉{␊
693␉␉␉␉// filesystem probe failed.␊
694␊
695␉␉␉␉DEBUG_DISK(("%s: failed probe on dev %X part %d\n", __FUNCTION__, biosdev, partno));␊
696␊
697␉␉␉␉(*bvr->bv_free)(bvr);␊
698␉␉␉␉bvr = NULL;␊
699␉␉␉}␊
700␊
701␉␉␉if ( bvr && readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 )␊
702␉␉␉{␊
703␉␉␉␉bvr->flags |= kBVFlagBootable;␊
704␉␉␉}␊
705␉␉}␊
706␉␉else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 )␊
707␉␉{␊
708␉␉␉/*␊
709␉␉␉ * This is an ugly place to check for exfat/FDisk, but it reads␊
710␉␉␉ * the partition boot sector only once.␊
711␉␉␉ */␊
712␉␉␉if (bvr->part_type == FDISK_NTFS && EXFATProbe((void const *)0x7e00))␊
713␉␉␉{␊
714␉␉␉␉bvr->flags |= kBVFlagNativeBoot | kBVFlagBootable;␊
715␉␉␉␉bvr->fs_loadfile = EXFATLoadFile;␊
716␉␉␉␉bvr->fs_readfile = EXFATReadFile;␊
717␉␉␉␉bvr->fs_getdirentry = EXFATGetDirEntry;␊
718␉␉␉␉bvr->fs_getfileblock= EXFATGetFileBlock;␊
719␉␉␉␉bvr->fs_getuuid = EXFATGetUUID;␊
720␉␉␉␉bvr->description = EXFATGetDescription;␊
721␉␉␉␉bvr->bv_free = EXFATFree;␊
722␉␉␉}␊
723␉␉␉else␊
724␉␉␉{␊
725␉␉␉␉bvr->flags |= kBVFlagForeignBoot;␊
726␉␉␉}␊
727␉␉}␊
728␉␉else␊
729␉␉{␊
730␉␉␉(*bvr->bv_free)(bvr);␊
731␉␉␉bvr = NULL;␊
732␉␉}␊
733␉}␊
734␊
735␉if ( bvr )␊
736␉{␊
737␉␉bvr->flags |= bvrFlags;␊
738␉}␊
739␊
740␉return bvr;␊
741}␊
742␊
743//==============================================================================␊
744␊
745static␊
746BVRef newAPMBVRef( int biosdev, int partno, unsigned int blkoff,␊
747 const DPME * part,␊
748 FSInit initFunc, FSLoadFile loadFunc,␊
749 FSReadFile readFunc,␊
750 FSGetDirEntry getdirFunc,␊
751 FSGetFileBlock getBlockFunc,␊
752 FSGetUUID getUUIDFunc,␊
753 BVGetDescription getDescriptionFunc,␊
754 BVFree bvFreeFunc,␊
755 int probe, int type, unsigned int bvrFlags )␊
756{␊
757␉BVRef bvr = (BVRef)malloc(sizeof(*bvr));␊
758␉if ( bvr )␊
759␉{␊
760␉␉bzero(bvr, sizeof(*bvr));␊
761␊
762␉␉bvr->biosdev = biosdev;␊
763␉␉bvr->part_no = partno;␊
764␉␉bvr->part_boff = blkoff;␊
765␉␉bvr->fs_loadfile = loadFunc;␊
766␉␉bvr->fs_readfile = readFunc;␊
767␉␉bvr->fs_getdirentry = getdirFunc;␊
768␉␉bvr->fs_getfileblock= getBlockFunc;␊
769␉␉bvr->fs_getuuid = getUUIDFunc;␊
770␉␉bvr->description = getDescriptionFunc;␊
771␉␉bvr->type = type;␊
772␉␉bvr->bv_free = bvFreeFunc;␊
773␉␉strlcpy(bvr->name, part->dpme_name, DPISTRLEN);␊
774␉␉strlcpy(bvr->type_name, part->dpme_type, DPISTRLEN);␊
775␊
776␉␉/*␊
777␉␉if ( part->bootid & FDISK_ACTIVE )␊
778␉␉{␊
779␉␉␉bvr->flags |= kBVFlagPrimary;␊
780␉␉}␊
781␉␉*/␊
782␊
783␉␉// Probe the filesystem.␊
784␊
785␉␉if ( initFunc )␊
786␉␉{␊
787␉␉␉bvr->flags |= kBVFlagNativeBoot | kBVFlagBootable | kBVFlagSystemVolume;␊
788␊
789␉␉␉if ( probe && initFunc( bvr ) != 0 )␊
790␉␉␉{␊
791␉␉␉␉// filesystem probe failed.␊
792␊
793␉␉␉␉DEBUG_DISK(("%s: failed probe on dev %X part %d\n", __FUNCTION__, biosdev, partno));␊
794␊
795␉␉␉␉(*bvr->bv_free)(bvr);␊
796␉␉␉␉bvr = NULL;␊
797␉␉␉}␊
798␉␉}␊
799␉␉/*␊
800␉␉else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 )␊
801␉␉{␊
802␉␉␉bvr->flags |= kBVFlagForeignBoot;␊
803␉␉}␊
804␉␉*/␊
805␉␉else␊
806␉␉{␊
807␉␉␉(*bvr->bv_free)(bvr);␊
808␉␉␉bvr = NULL;␊
809␉␉}␊
810␉}␊
811␊
812␉if ( bvr )␊
813␉{␊
814␉␉bvr->flags |= bvrFlags;␊
815␉}␊
816␊
817␉return bvr;␊
818}␊
819␊
820//==============================================================================␊
821␊
822// GUID's in LE form:␊
823// HFS+ partition - 48465300-0000-11AA-AA11-00306543ECAC␊
824EFI_GUID const GPT_HFS_GUID␉␉= { 0x48465300, 0x0000, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xAF00 "Apple HFS/HFS+"␊
825␊
826// turbo - Apple Boot Partition - 426F6F74-0000-11AA-AA11-00306543ECAC␊
827EFI_GUID const GPT_BOOT_GUID␉␉= { 0x426F6F74, 0x0000, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xAB00 "Apple boot"␊
828␊
829// turbo - or an EFI System Partition - C12A7328-F81F-11D2-BA4B-00A0C93EC93B␊
830EFI_GUID const GPT_EFISYS_GUID␉␉= { 0xC12A7328, 0xF81F, 0x11D2, { 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B } }; // 0xEF00 "EFI System"␊
831␊
832// zef - Basic Data Partition - EBD0A0A2-B9E5-4433-87C0-68B6B72699C7 for foreign OS support␊
833EFI_GUID const GPT_BASICDATA_GUID␉= { 0xEBD0A0A2, 0xB9E5, 0x4433, { 0x87, 0xC0, 0x68, 0xB6, 0xB7, 0x26, 0x99, 0xC7 } }; // 0x0100 "Microsoft basic data"␊
834␊
835// Microsoft Reserved Partition - E3C9E316-0B5C-4DB8-817DF92DF00215AE␊
836EFI_GUID const GPT_BASICDATA2_GUID␉= { 0xE3C9E316, 0x0B5C, 0x4DB8, { 0x81, 0x7D, 0xF9, 0x2D, 0xF0, 0x02, 0x15, 0xAE } }; // 0x0C01 "Microsoft reserved"␊
837␊
838// Apple OSX␊
839//EFI_GUID const GPT_UFS_GUID␉␉= { 0x55465300, 0x0000, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xA800 "Apple UFS"␊
840//EFI_GUID const GPT_RAID_GUID␉␉= { 0x52414944, 0x0000, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xAF01 "Apple RAID"␊
841//EFI_GUID const GPT_RAID_OFFLINE_GUID␉= { 0x52414944, 0x5f4f, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xAF02 "Apple RAID offline"␊
842//EFI_GUID const GPT_LABEL_GUID␉␉= { 0x4C616265, 0x6C00, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xAF03 "Apple label"␊
843//EFI_GUID const GPT_APPLETV_GUID␉= { 0x5265636F, 0x7665, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xAF04 "Apple TV recovery"␊
844//EFI_GUID const GPT_CORESTORAGE_GUID␉= { 0x53746F72, 0x6167, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xAF05 "Apple Core storage"␊
845// same as Apple ZFS␊
846//EFI_GUID const GPT_ZFS_GUID␉␉= { 0x6A898CC3, 0x1DD2, 0x11B2, { 0x99, 0xA6, 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }; // 0xBF01 "Solaris /usr & Apple ZFS␊
847␊
848static BVRef newGPTBVRef( int biosdev,␊
849 int partno,␊
850 unsigned int blkoff,␊
851 const gpt_ent *part,␊
852 FSInit initFunc,␊
853 FSLoadFile loadFunc,␊
854 FSReadFile readFunc,␊
855 FSGetDirEntry getdirFunc,␊
856 FSGetFileBlock getBlockFunc,␊
857 FSGetUUID getUUIDFunc,␊
858 BVGetDescription getDescriptionFunc,␊
859 BVFree bvFreeFunc,␊
860 int probe,␊
861 int type,␊
862 unsigned int bvrFlags )␊
863{␊
864␉BVRef bvr = (BVRef)malloc(sizeof(*bvr));␊
865␉if ( bvr )␊
866␉{␊
867␉␉bzero(bvr, sizeof(*bvr));␊
868␊
869␉␉bvr->biosdev = biosdev;␊
870␉␉bvr->part_no = partno;␊
871␉␉bvr->part_boff = blkoff;␊
872␉␉bvr->fs_loadfile = loadFunc;␊
873␉␉bvr->fs_readfile = readFunc;␊
874␉␉bvr->fs_getdirentry = getdirFunc;␊
875␉␉bvr->fs_getfileblock = getBlockFunc;␊
876␉␉bvr->fs_getuuid = getUUIDFunc;␊
877␉␉bvr->description = getDescriptionFunc;␊
878␉␉bvr->type = type;␊
879␉␉bvr->bv_free = bvFreeFunc;␊
880␉␉// FIXME: UCS-2 -> UTF-8 the name␊
881␉␉strlcpy(bvr->name, "----", DPISTRLEN);␊
882␉␉if ( (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)part->ent_type) == 0) || (efi_guid_compare(&GPT_HFS_GUID, (EFI_GUID const*)part->ent_type) == 0) )␊
883␉␉{␊
884␉␉␉strlcpy(bvr->type_name, "GPT HFS+", DPISTRLEN);␊
885␉␉}␊
886␉␉else␊
887␉␉{␊
888␉␉␉strlcpy(bvr->type_name, "GPT Unknown", DPISTRLEN);␊
889␉␉}␊
890␊
891␉␉/*␊
892␉␉if ( part->bootid & FDISK_ACTIVE )␊
893␉␉{␊
894␉␉␉bvr->flags |= kBVFlagPrimary;␊
895␉␉}␊
896␉␉*/␊
897␊
898␉␉// Probe the filesystem.␊
899␊
900␉␉if ( initFunc )␊
901␉␉{␊
902␉␉␉bvr->flags |= kBVFlagNativeBoot;␊
903␊
904␉␉␉if ( probe && initFunc( bvr ) != 0 )␊
905␉␉␉{␊
906␉␉␉␉// filesystem probe failed.␊
907␊
908␉␉␉␉DEBUG_DISK(("%s: failed probe on dev %x part %d\n", __FUNCTION__, biosdev, partno));␊
909␊
910␉␉␉␉(*bvr->bv_free)(bvr);␊
911␉␉␉␉bvr = NULL;␊
912␉␉␉}␊
913␉␉␉else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 )␊
914␉␉␉{␊
915␉␉␉␉bvr->flags |= kBVFlagBootable;␊
916␉␉␉}␊
917␉␉}␊
918␉␉else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 )␊
919␉␉{␊
920␉␉␉bvr->flags |= kBVFlagForeignBoot;␊
921␉␉}␊
922␉␉else␊
923␉␉{␊
924␉␉␉(*bvr->bv_free)(bvr);␊
925␉␉␉bvr = NULL;␊
926␉␉}␊
927␉}␊
928␊
929␉if ( bvr )␊
930␉{␊
931␉␉bvr->flags |= bvrFlags;␊
932␉}␊
933␊
934␉return bvr;␊
935}␊
936␊
937//==============================================================================␊
938␊
939/* A note on partition numbers:␊
940 * IOKit makes the primary partitions numbers 1-4, and then␊
941 * extended partitions are numbered consecutively 5 and up.␊
942 * So, for example, if you have two primary partitions and␊
943 * one extended partition they will be numbered 1, 2, 5.␊
944 */␊
945␊
946static BVRef diskScanFDiskBootVolumes( int biosdev, int *countPtr )␊
947{␊
948 const struct fdisk_part␉*part;␊
949 struct DiskBVMap␉␉*map;␊
950 int␉␉␉␉partno = -1;␊
951 BVRef␉␉␉bvr;␊
952#if UFS_SUPPORT␊
953 BVRef␉␉␉booterUFS = NULL;␊
954#endif␊
955 int␉␉␉␉spc;␊
956 struct driveInfo␉␉di;␊
957 boot_drive_info_t␉␉*dp;␊
958␊
959␉/* Initialize disk info */␊
960␊
961␉if (getDriveInfo(biosdev, &di) != 0)␊
962␉{␊
963␉␉return NULL;␊
964␉}␊
965␊
966␉dp = &di.di;␊
967␉spc = (dp->params.phys_spt * dp->params.phys_heads);␊
968␊
969␉if (spc == 0)␊
970␉{␊
971␉␉/* This is probably a CD-ROM; punt on the geometry. */␊
972␉␉spc = 1;␊
973␉}␊
974␊
975␉do␊
976␉{␊
977␉// Create a new mapping.␊
978␊
979␉map = (struct DiskBVMap *) malloc(sizeof(*map));␊
980␊
981␉if ( !map )␊
982␉{␊
983␉␉return NULL;␊
984␉}␊
985␊
986␉if ( map )␊
987 {␊
988␉␉map->biosdev = biosdev;␊
989␉␉map->bvr = NULL;␊
990␉␉map->bvrcnt = 0;␊
991␉␉map->next = gDiskBVMap;␊
992␉␉gDiskBVMap = map;␊
993␊
994␉␉// Create a record for each partition found on the disk.␊
995␊
996␉␉while ( getNextFDiskPartition( biosdev, &partno, &part ) )␊
997␉␉{␊
998␉␉␉DEBUG_DISK(("%s: part %d [%X]\n", __FUNCTION__, partno, part->systid));␊
999␉␉␉bvr = 0;␊
1000␊
1001␉␉␉switch ( part->systid )␊
1002␉␉␉{␊
1003#if UFS_SUPPORT␊
1004␉␉␉␉case FDISK_UFS:␊
1005␉␉␉␉␉bvr = newFDiskBVRef(␊
1006␉␉␉␉␉␉biosdev, partno,␊
1007␉␉␉␉␉␉part->relsect + UFS_FRONT_PORCH/BPS,␊
1008␉␉␉␉␉␉part,␊
1009␉␉␉␉␉␉UFSInitPartition,␊
1010␉␉␉␉␉␉UFSLoadFile,␊
1011␉␉␉␉␉␉UFSReadFile,␊
1012␉␉␉␉␉␉UFSGetDirEntry,␊
1013␉␉␉␉␉␉UFSGetFileBlock,␊
1014␉␉␉␉␉␉UFSGetUUID,␊
1015␉␉␉␉␉␉UFSGetDescription,␊
1016␉␉␉␉␉␉UFSFree,␊
1017␉␉␉␉␉␉0,␊
1018␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1019␉␉␉␉␉break;␊
1020#endif␊
1021␊
1022␉␉␉␉case FDISK_HFS:␊
1023␉␉␉␉␉bvr = newFDiskBVRef(␊
1024␉␉␉␉␉␉biosdev, partno,␊
1025␉␉␉␉␉␉part->relsect,␊
1026␉␉␉␉␉␉part,␊
1027␉␉␉␉␉␉HFSInitPartition,␊
1028␉␉␉␉␉␉HFSLoadFile,␊
1029␉␉␉␉␉␉HFSReadFile,␊
1030␉␉␉␉␉␉HFSGetDirEntry,␊
1031␉␉␉␉␉␉HFSGetFileBlock,␊
1032␉␉␉␉␉␉HFSGetUUID,␊
1033␉␉␉␉␉␉HFSGetDescription,␊
1034␉␉␉␉␉␉HFSFree,␊
1035␉␉␉␉␉␉0,␊
1036␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1037␉␉␉␉␉break;␊
1038␊
1039␉␉␉␉// turbo - we want the booter type scanned also␊
1040␉␉␉␉case FDISK_BOOTER:␊
1041␉␉␉␉␉if (part->bootid & FDISK_ACTIVE)␊
1042␉␉␉␉␉{␊
1043␉␉␉␉␉␉gBIOSBootVolume = newFDiskBVRef(␊
1044␉␉␉␉␉␉␉biosdev, partno,␊
1045␉␉␉␉␉␉␉part->relsect,␊
1046␉␉␉␉␉␉␉part,␊
1047␉␉␉␉␉␉␉HFSInitPartition,␊
1048␉␉␉␉␉␉␉HFSLoadFile,␊
1049␉␉␉␉␉␉␉HFSReadFile,␊
1050␉␉␉␉␉␉␉HFSGetDirEntry,␊
1051␉␉␉␉␉␉␉HFSGetFileBlock,␊
1052␉␉␉␉␉␉␉HFSGetUUID,␊
1053␉␉␉␉␉␉␉HFSGetDescription,␊
1054␉␉␉␉␉␉␉HFSFree,␊
1055␉␉␉␉␉␉␉0,␊
1056␉␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1057␉␉␉␉␉}␊
1058␉␉␉␉␉break;␊
1059␊
1060#if UFS_SUPPORT␊
1061␉␉␉␉case FDISK_BOOTER:␊
1062␉␉␉␉␉booterUFS = newFDiskBVRef(␊
1063␉␉␉␉␉␉biosdev, partno,␊
1064␉␉␉␉␉␉((part->relsect + spc - 1) / spc) * spc,␊
1065␉␉␉␉␉␉part,␊
1066␉␉␉␉␉␉UFSInitPartition,␊
1067␉␉␉␉␉␉UFSLoadFile,␊
1068␉␉␉␉␉␉UFSReadFile,␊
1069␉␉␉␉␉␉UFSGetDirEntry,␊
1070␉␉␉␉␉␉UFSGetFileBlock,␊
1071␉␉␉␉␉␉UFSGetUUID,␊
1072␉␉␉␉␉␉UFSGetDescription,␊
1073␉␉␉␉␉␉UFSFree,␊
1074␉␉␉␉␉␉0,␊
1075␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1076␉␉␉␉␉break;␊
1077#endif␊
1078␊
1079␉␉␉␉case FDISK_FAT32:␊
1080␉␉␉␉case FDISK_DOS12:␊
1081␉␉␉␉case FDISK_DOS16S:␊
1082␉␉␉␉case FDISK_DOS16B:␊
1083␉␉␉␉case FDISK_SMALLFAT32:␊
1084␉␉␉␉case FDISK_DOS16SLBA:␊
1085␉␉␉␉␉bvr = newFDiskBVRef(␊
1086␉␉␉␉␉␉biosdev, partno,␊
1087␉␉␉␉␉␉part->relsect,␊
1088␉␉␉␉␉␉part,␊
1089␉␉␉␉␉␉MSDOSInitPartition,␊
1090␉␉␉␉␉␉MSDOSLoadFile,␊
1091␉␉␉␉␉␉MSDOSReadFile,␊
1092␉␉␉␉␉␉MSDOSGetDirEntry,␊
1093␉␉␉␉␉␉MSDOSGetFileBlock,␊
1094␉␉␉␉␉␉MSDOSGetUUID,␊
1095␉␉␉␉␉␉MSDOSGetDescription,␊
1096␉␉␉␉␉␉MSDOSFree,␊
1097␉␉␉␉␉␉0,␊
1098␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1099␉␉␉␉␉break;␊
1100␊
1101␉␉␉␉case FDISK_NTFS:␊
1102␉␉␉␉␉bvr = newFDiskBVRef(␊
1103␉␉␉␉␉␉biosdev, partno,␊
1104␉␉␉␉␉␉part->relsect,␊
1105␉␉␉␉␉␉part,␊
1106␉␉␉␉␉␉0, 0, 0, 0, 0,␊
1107␉␉␉␉␉␉NTFSGetUUID,␊
1108␉␉␉␉␉␉NTFSGetDescription,␊
1109␉␉␉␉␉␉(BVFree)free,␊
1110␉␉␉␉␉␉0,␊
1111␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1112␉␉␉␉␉break;␊
1113␊
1114␉␉␉␉case FDISK_LINUX:␊
1115␉␉␉␉␉bvr = newFDiskBVRef(␊
1116␉␉␉␉␉␉biosdev, partno,␊
1117␉␉␉␉␉␉part->relsect,␊
1118␉␉␉␉␉␉part,␊
1119␉␉␉␉␉␉0, 0, 0, 0, 0,␊
1120␉␉␉␉␉␉EX2GetUUID,␊
1121␉␉␉␉␉␉EX2GetDescription,␊
1122␉␉␉␉␉␉(BVFree)free,␊
1123␉␉␉␉␉␉0,␊
1124␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1125␉␉␉␉␉break;␊
1126␊
1127␉␉␉␉case FDISK_BEFS:␊
1128␉␉␉␉␉bvr = newFDiskBVRef(␊
1129␉␉␉␉␉␉biosdev, partno,␊
1130␉␉␉␉␉␉part->relsect,␊
1131␉␉␉␉␉␉part,␊
1132␉␉␉␉␉␉0, 0, 0, 0, 0, 0,␊
1133␉␉␉␉␉␉BeFSGetDescription,␊
1134␉␉␉␉␉␉(BVFree)free,␊
1135␉␉␉␉␉␉0,␊
1136␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1137␉␉␉␉␉break;␊
1138␊
1139␉␉␉␉case FDISK_FREEBSD:␊
1140␉␉␉␉␉bvr = newFDiskBVRef(␊
1141␉␉␉␉␉␉biosdev, partno,␊
1142␉␉␉␉␉␉part->relsect,␊
1143␉␉␉␉␉␉part,␊
1144␉␉␉␉␉␉0, 0, 0, 0, 0, 0,␊
1145␉␉␉␉␉␉FreeBSDGetDescription,␊
1146␉␉␉␉␉␉(BVFree)free,␊
1147␉␉␉␉␉␉0,␊
1148␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1149␉␉␉␉␉break;␊
1150␊
1151␉␉␉␉case FDISK_OPENBSD:␊
1152␉␉␉␉␉bvr = newFDiskBVRef(␊
1153␉␉␉␉␉␉biosdev, partno,␊
1154␉␉␉␉␉␉part->relsect,␊
1155␉␉␉␉␉␉part,␊
1156␉␉␉␉␉␉0, 0, 0, 0, 0, 0,␊
1157␉␉␉␉␉␉OpenBSDGetDescription,␊
1158␉␉␉␉␉␉(BVFree)free,␊
1159␉␉␉␉␉␉0,␊
1160␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1161␉␉␉␉␉break;␊
1162␊
1163␉␉␉␉default:␊
1164␉␉␉␉␉bvr = newFDiskBVRef(␊
1165␉␉␉␉␉␉biosdev, partno,␊
1166␉␉␉␉␉␉part->relsect,␊
1167␉␉␉␉␉␉part,␊
1168␉␉␉␉␉␉0, 0, 0, 0, 0, 0, 0,␊
1169␉␉␉␉␉␉(BVFree)free,␊
1170␉␉␉␉␉␉0,␊
1171␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1172␉␉␉␉␉break;␊
1173␉␉␉}␊
1174␊
1175␉␉␉if ( bvr )␊
1176␉␉␉{␊
1177␉␉␉␉bvr->next = map->bvr;␊
1178␉␉␉␉map->bvr = bvr;␊
1179␉␉␉␉map->bvrcnt++;␊
1180␉␉␉}␊
1181␉␉}␊
1182␊
1183#if UFS_SUPPORT␊
1184␉␉// Booting from a CD with an UFS filesystem embedded␊
1185␉␉// in a booter partition.␊
1186␊
1187␉␉␉if ( booterUFS )␊
1188␉␉␉{␊
1189␉␉␉␉if ( map->bvrcnt == 0 )␊
1190␉␉␉␉{␊
1191␉␉␉␉␉map->bvr = booterUFS;␊
1192␉␉␉␉␉map->bvrcnt++;␊
1193␉␉␉␉}␊
1194␉␉␉␉else␊
1195␉␉␉␉{␊
1196␉␉␉␉␉free( booterUFS );␊
1197␉␉␉␉}␊
1198␉␉␉}␊
1199#endif␊
1200␉␉}␊
1201␉} while (0);␊
1202␊
1203#if UNUSED␊
1204␉/*␊
1205␉ * If no FDisk partition, then we will check for␊
1206␉ * an Apple partition map elsewhere.␊
1207␉ */␊
1208␉if (map && map->bvrcnt == 0)␊
1209␉{␊
1210␉␉static struct fdisk_part cdpart;␊
1211␉␉cdpart.systid = 0xCD;␊
1212␊
1213␉␉/* Let's try assuming we are on a hybrid HFS/ISO9660 CD. */␊
1214␉␉bvr = newFDiskBVRef(␊
1215␉␉␉biosdev, 0,␊
1216␉␉␉0,␊
1217␉␉␉&cdpart,␊
1218␉␉␉HFSInitPartition,␊
1219␉␉␉HFSLoadFile,␊
1220␉␉␉HFSReadFile,␊
1221␉␉␉HFSGetDirEntry,␊
1222␉␉␉HFSGetFileBlock,␊
1223␉␉␉HFSGetUUID,␊
1224␉␉␉HFSGetDescription,␊
1225␉␉␉HFSFree,␊
1226␉␉␉0,␊
1227␉␉␉kBIOSDevTypeHardDrive, 0);␊
1228␉␉bvr->next = map->bvr;␊
1229␉␉map->bvr = bvr;␊
1230␉␉map->bvrcnt++;␊
1231␉}␊
1232#endif␊
1233␉// Actually this should always be true given the above code␊
1234␉// (unless malloc failed above)␊
1235␉if(map && (map == gDiskBVMap))␊
1236␉{␊
1237␉␉// Don't leave a null map in the chain␊
1238␉␉if((map->bvrcnt == 0) && (map->bvr == NULL))␊
1239␉␉{␊
1240␉␉␉gDiskBVMap = map->next;␊
1241␉␉␉free(map);␊
1242␉␉␉map = NULL;␊
1243␉␉}␊
1244␉}␊
1245␊
1246␉if (countPtr) *countPtr = map ? map->bvrcnt : 0;␊
1247␊
1248␉return map ? map->bvr : NULL;␊
1249}␊
1250␊
1251//==============================================================================␊
1252␊
1253static BVRef diskScanAPMBootVolumes( int biosdev, int * countPtr )␊
1254{␊
1255␉struct DiskBVMap␉*map;␊
1256␉struct Block0␉␉*block0_p;␊
1257␉unsigned int␉␉blksize;␊
1258␉unsigned int␉␉factor;␊
1259␉void␉*buffer = malloc(BPS);␊
1260␊
1261␉if (!buffer)␊
1262␉{␊
1263␉␉return NULL;␊
1264␉}␊
1265␊
1266␉bzero(buffer,BPS);␊
1267␊
1268␉/* Check for alternate block size */␊
1269␉if (readBytes( biosdev, 0, 0, BPS, buffer ) != 0)␊
1270␉{␊
1271␉␉return NULL;␊
1272␉}␊
1273␊
1274␉block0_p = buffer;␊
1275␉if (OSSwapBigToHostInt16(block0_p->sbSig) == BLOCK0_SIGNATURE)␊
1276␉{␊
1277␉␉blksize = OSSwapBigToHostInt16(block0_p->sbBlkSize);␊
1278␉␉if (blksize != BPS)␊
1279␉␉{␊
1280␉␉␉free(buffer);␊
1281␉␉␉buffer = malloc(blksize);␊
1282␉␉␉if (!buffer)␊
1283␉␉␉{␊
1284␉␉␉␉return NULL;␊
1285␉␉␉}␊
1286␉␉␉bzero(buffer,BPS);␊
1287␉␉}␊
1288␉␉factor = blksize / BPS;␊
1289␉}␊
1290␉else␊
1291␉{␊
1292␉␉blksize = BPS;␊
1293␉␉factor = 1;␊
1294␉}␊
1295␊
1296␉do␊
1297␉{␊
1298␉␉// Create a new mapping.␊
1299␊
1300␉␉map = (struct DiskBVMap *) malloc( sizeof(*map) );␊
1301␉␉if ( map )␊
1302␉␉{␊
1303␉␉␉int error;␊
1304␉␉␉DPME *dpme_p = (DPME *)buffer;␊
1305␉␉␉UInt32 i, npart = UINT_MAX;␊
1306␉␉␉BVRef bvr;␊
1307␊
1308␉␉␉map->biosdev = biosdev;␊
1309␉␉␉map->bvr = NULL;␊
1310␉␉␉map->bvrcnt = 0;␊
1311␉␉␉map->next = gDiskBVMap;␊
1312␉␉␉gDiskBVMap = map;␊
1313␊
1314␉␉␉for (i = 0; i < npart; i++)␊
1315␉␉␉{␊
1316␉␉␉␉error = readBytes( biosdev, (kAPMSector + i) * factor, 0, blksize, buffer );␊
1317␊
1318␉␉␉␉if (error || OSSwapBigToHostInt16(dpme_p->dpme_signature) != DPME_SIGNATURE)␊
1319␉␉␉␉{␊
1320␉␉␉␉␉break;␊
1321␉␉␉␉}␊
1322␊
1323␉␉␉␉if (i == 0)␊
1324␉␉␉␉{␊
1325␉␉␉␉␉npart = OSSwapBigToHostInt32(dpme_p->dpme_map_entries);␊
1326␉␉␉␉}␊
1327␉␉␉␉/*␊
1328␉␉␉␉printf("name = %s, %s%s %d -> %d [%d -> %d] {%d}\n",␊
1329␉␉␉␉dpme.dpme_name, dpme.dpme_type, (dpme.dpme_flags & DPME_FLAGS_BOOTABLE) ? "(bootable)" : "",␊
1330␉␉␉␉dpme.dpme_pblock_start, dpme.dpme_pblocks,␊
1331␉␉␉␉dpme.dpme_lblock_start, dpme.dpme_lblocks,␊
1332␉␉␉␉dpme.dpme_boot_block);␊
1333␉␉␉␉*/␊
1334␊
1335␉␉␉␉if (strncmp(dpme_p->dpme_type, "Apple_HFS", sizeof("Apple_HFS")) == 0)␊
1336␉␉␉␉{␊
1337␉␉␉␉␉bvr = newAPMBVRef(biosdev,␊
1338␉␉␉␉␉i,␊
1339␉␉␉␉␉OSSwapBigToHostInt32(dpme_p->dpme_pblock_start) * factor,␊
1340␉␉␉␉␉dpme_p,␊
1341␉␉␉␉␉HFSInitPartition,␊
1342␉␉␉␉␉HFSLoadFile,␊
1343␉␉␉␉␉HFSReadFile,␊
1344␉␉␉␉␉HFSGetDirEntry,␊
1345␉␉␉␉␉HFSGetFileBlock,␊
1346␉␉␉␉␉HFSGetUUID,␊
1347␉␉␉␉␉HFSGetDescription,␊
1348␉␉␉␉␉HFSFree,␊
1349␉␉␉␉␉0,␊
1350␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1351␉␉␉␉␉bvr->next = map->bvr;␊
1352␉␉␉␉␉map->bvr = bvr;␊
1353␉␉␉␉␉map->bvrcnt++;␊
1354␉␉␉␉}␊
1355␉␉␉}␊
1356␉␉}␊
1357␉} while (0);␊
1358␊
1359␉if (buffer)␊
1360␉{␊
1361␉␉free(buffer);␊
1362␉}␊
1363␊
1364␉if (countPtr)␊
1365␉{␊
1366␉␉*countPtr = map ? map->bvrcnt : 0;␊
1367␉}␊
1368␊
1369␉return map ? map->bvr : NULL;␊
1370}␊
1371␊
1372//==============================================================================␊
1373␊
1374static bool isPartitionUsed(gpt_ent * partition)␊
1375{␊
1376␊
1377␉// Ask whether the given partition is used.␊
1378␊
1379␉return efi_guid_is_null((EFI_GUID const*)partition->ent_type) ? false : true;␊
1380}␊
1381␊
1382//==============================================================================␊
1383␊
1384static BVRef diskScanGPTBootVolumes(int biosdev, int * countPtr)␊
1385{␊
1386␉struct DiskBVMap *map = NULL;␊
1387␊
1388␉void *buffer = malloc(BPS);␊
1389␊
1390␉int error;␊
1391␊
1392␉if ((error = readBytes( biosdev, /*secno*/0, 0, BPS, buffer )) != 0)␊
1393␉{␊
1394␉␉verbose("Failed to read boot sector from BIOS device %02xh. Error=%d\n", biosdev, error);␊
1395␉␉goto scanErr;␊
1396␉}␊
1397␉struct REAL_disk_blk0 *fdiskMap = buffer;␊
1398␉if ( OSSwapLittleToHostInt16(fdiskMap->signature) != DISK_SIGNATURE )␊
1399␉{␊
1400␉␉verbose("Failed to find boot signature on BIOS device %02xh\n", biosdev);␊
1401␉␉goto scanErr;␊
1402␉}␊
1403␊
1404␉int fdiskID = 0;␊
1405␉unsigned index;␊
1406␉for ( index = 0; index < FDISK_NPART; index++ )␊
1407␉{␊
1408␉␉if ( fdiskMap->parts[index].systid )␊
1409␉␉{␊
1410␉␉␉if ( fdiskMap->parts[index].systid == 0xEE )␊
1411␉␉␉{␊
1412␉␉␉␉// Fail if two 0xEE partitions are present which␊
1413␉␉␉␉// means the FDISK code will wind up parsing it.␊
1414␉␉␉␉if ( fdiskID )␊
1415␉␉␉␉{␊
1416␉␉␉␉␉goto scanErr;␊
1417␉␉␉␉}␊
1418␊
1419␉␉␉␉fdiskID = index + 1;␊
1420␉␉␉}␊
1421␉␉}␊
1422␉}␊
1423␊
1424␉if ( fdiskID == 0 )␊
1425␉{␊
1426␉␉goto scanErr;␊
1427␉}␊
1428␊
1429␉verbose("Attempting to read GPT\n");␊
1430␊
1431␉if(readBytes(biosdev, 1, 0, BPS, buffer) != 0)␊
1432␉{␊
1433␉␉goto scanErr;␊
1434␉}␊
1435␊
1436␉gpt_hdr *headerMap = buffer;␊
1437␊
1438␉// Determine whether the partition header signature is present.␊
1439␊
1440␉if ( memcmp(headerMap->hdr_sig, GPT_HDR_SIG, strlen(GPT_HDR_SIG)) )␊
1441␉{␊
1442␉␉goto scanErr;␊
1443␉}␊
1444␊
1445␉// Determine whether the partition header size is valid.␊
1446␊
1447␉UInt32 headerCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_self);␊
1448␉UInt32 headerSize = OSSwapLittleToHostInt32(headerMap->hdr_size);␊
1449␊
1450␉if (headerSize < offsetof(gpt_hdr, padding))␊
1451␉{␊
1452␉␉goto scanErr;␊
1453␉}␊
1454␊
1455␉if ( headerSize > BPS )␊
1456␉{␊
1457␉␉goto scanErr;␊
1458␉}␊
1459␊
1460␉// Determine whether the partition header checksum is valid.␊
1461␊
1462␉headerMap->hdr_crc_self = 0;␊
1463␊
1464␉if ( crc32(0, headerMap, headerSize) != headerCheck )␊
1465␉{␊
1466␉␉goto scanErr;␊
1467␉}␊
1468␊
1469␉// Determine whether the partition entry size is valid.␊
1470␊
1471␉UInt64␉␉gptBlock␉= 0;␊
1472␉UInt32␉␉gptCheck␉= 0;␊
1473␉UInt32␉␉gptCount␉= 0;␊
1474␉UInt32␉␉gptID␉␉= 0;␊
1475␉gpt_ent␉␉*gptMap␉␉= 0;␊
1476␉UInt32␉␉gptSize␉␉= 0;␊
1477␊
1478␉gptBlock = OSSwapLittleToHostInt64(headerMap->hdr_lba_table);␊
1479␉gptCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_table);␊
1480␉gptCount = OSSwapLittleToHostInt32(headerMap->hdr_entries);␊
1481␉gptSize = OSSwapLittleToHostInt32(headerMap->hdr_entsz);␊
1482␊
1483␉if ( gptSize < sizeof(gpt_ent) )␊
1484␉{␊
1485␉␉goto scanErr;␊
1486␉}␊
1487␊
1488␉// Allocate a buffer large enough to hold one map, rounded to a media block.␊
1489␉free(buffer);␊
1490␉buffer = NULL;␊
1491␊
1492␉UInt32 bufferSize = IORound(gptCount * gptSize, BPS);␊
1493␉if (bufferSize == 0)␊
1494␉{␊
1495␉␉goto scanErr;␊
1496␉}␊
1497␉buffer = malloc(bufferSize);␊
1498␉if (!buffer)␊
1499␉{␊
1500 ␉goto scanErr;␊
1501␉}␊
1502␊
1503␉bzero(buffer,bufferSize);␊
1504␊
1505␉if (readBytes(biosdev, gptBlock, 0, bufferSize, buffer) != 0)␊
1506␉{␊
1507␉␉goto scanErr;␊
1508␉}␊
1509␉verbose("Read GPT\n");␊
1510␊
1511␉// Allocate a new map for this BIOS device and insert it into the chain␊
1512␉map = malloc(sizeof(*map));␊
1513␉if (!map)␊
1514␉{␊
1515␉␉goto scanErr;␊
1516␉}␊
1517␉map->biosdev = biosdev;␊
1518␉map->bvr = NULL;␊
1519␉map->bvrcnt = 0;␊
1520␉map->next = gDiskBVMap;␊
1521␉gDiskBVMap = map;␊
1522␊
1523␉// fdisk like partition type id.␊
1524␉int fsType = 0;␊
1525␊
1526␉for(gptID = 1; gptID <= gptCount; ++gptID)␊
1527␉{␊
1528␉␉BVRef bvr = NULL;␊
1529␉␉unsigned int bvrFlags = 0;␊
1530␊
1531␉␉// size on disk can be larger than sizeof(gpt_ent)␊
1532␉␉gptMap = (gpt_ent *)(buffer + ((gptID - 1) * gptSize));␊
1533␊
1534␉␉// NOTE: EFI_GUID's are in LE and we know we're on an x86.␊
1535␉␉// The IOGUIDPartitionScheme.cpp code uses byte-based UUIDs, we don't.␊
1536␊
1537␉␉if (isPartitionUsed(gptMap))␊
1538␉␉{␊
1539␉␉␉char stringuuid[100];␊
1540␉␉␉efi_guid_unparse_upper((EFI_GUID*)gptMap->ent_type, stringuuid);␊
1541␉␉␉verbose("Reading GPT partition %d, type %s\n", (unsigned) gptID, stringuuid);␊
1542␊
1543␉␉␉// Getting fdisk like partition type.␊
1544␉␉␉fsType = probeFileSystem(biosdev, gptMap->ent_lba_start);␊
1545␊
1546␉␉␉if ( (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) || (efi_guid_compare(&GPT_HFS_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) )␊
1547␉␉␉{␊
1548␉␉␉␉bvrFlags = (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ? kBVFlagBooter : 0;␊
1549␉␉␉␉bvr = newGPTBVRef(biosdev,␊
1550␉␉␉␉gptID,␊
1551␉␉␉␉gptMap->ent_lba_start,␊
1552␉␉␉␉gptMap,␊
1553␉␉␉␉HFSInitPartition,␊
1554␉␉␉␉HFSLoadFile,␊
1555␉␉␉␉HFSReadFile,␊
1556␉␉␉␉HFSGetDirEntry,␊
1557␉␉␉␉HFSGetFileBlock,␊
1558␉␉␉␉HFSGetUUID,␊
1559␉␉␉␉HFSGetDescription,␊
1560␉␉␉␉HFSFree,␊
1561␉␉␉␉0,␊
1562␉␉␉␉kBIOSDevTypeHardDrive, bvrFlags);␊
1563␉␉␉}␊
1564␊
1565␉␉␉// zef - foreign OS support␊
1566␉␉␉if ((efi_guid_compare(&GPT_BASICDATA_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ||␊
1567␉␉␉␉(efi_guid_compare(&GPT_BASICDATA2_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) )␊
1568␉␉␉{␊
1569␉␉␉␉switch (fsType)␊
1570␉␉␉␉{␊
1571␉␉␉␉␉case FDISK_NTFS:␊
1572␉␉␉␉␉␉bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,␊
1573␉␉␉␉␉␉0, 0, 0, 0, 0, NTFSGetUUID, NTFSGetDescription,␊
1574␉␉␉␉␉␉(BVFree)free, 0, kBIOSDevTypeHardDrive, 0);␊
1575␉␉␉␉␉␉break;␊
1576␊
1577␉␉␉␉␉case FDISK_LINUX:␊
1578␉␉␉␉␉␉bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,␊
1579␉␉␉␉␉␉0, 0, 0, 0, 0, EX2GetUUID, EX2GetDescription,␊
1580␉␉␉␉␉␉(BVFree)free, 0, kBIOSDevTypeHardDrive, 0);␊
1581␉␉␉␉␉␉break;␊
1582␊
1583␉␉␉␉␉case FDISK_FAT32:␊
1584␉␉␉␉␉case FDISK_DOS12:␊
1585␉␉␉␉␉case FDISK_DOS16B:␊
1586␉␉␉␉␉␉bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,␊
1587␉␉␉␉␉␉␉␉MSDOSInitPartition,␊
1588␉␉␉␉␉␉␉␉MSDOSLoadFile,␊
1589␉␉␉␉␉␉␉␉MSDOSReadFile,␊
1590␉␉␉␉␉␉␉␉MSDOSGetDirEntry,␊
1591␉␉␉␉␉␉␉␉MSDOSGetFileBlock,␊
1592␉␉␉␉␉␉␉␉MSDOSGetUUID,␊
1593␉␉␉␉␉␉␉␉MSDOSGetDescription,␊
1594␉␉␉␉␉␉␉␉MSDOSFree,␊
1595␉␉␉␉␉␉␉␉0, kBIOSDevTypeHardDrive, 0);␊
1596␉␉␉␉␉␉break;␊
1597␊
1598␉␉␉␉␉case FDISK_PSEUDO_EXFAT:␊
1599␉␉␉␉␉␉bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,␊
1600␉␉␉␉␉␉␉␉␉␉ EXFATInitPartition,␊
1601␉␉␉␉␉␉␉␉␉␉ EXFATLoadFile,␊
1602␉␉␉␉␉␉␉␉␉␉ EXFATReadFile,␊
1603␉␉␉␉␉␉␉␉␉␉ EXFATGetDirEntry,␊
1604␉␉␉␉␉␉␉␉␉␉ EXFATGetFileBlock,␊
1605␉␉␉␉␉␉␉␉␉␉ EXFATGetUUID,␊
1606␉␉␉␉␉␉␉␉␉␉ EXFATGetDescription,␊
1607␉␉␉␉␉␉␉␉␉␉ EXFATFree,␊
1608␉␉␉␉␉␉␉␉␉␉ 0, kBIOSDevTypeHardDrive, 0);␊
1609␉␉␉␉␉␉break;␊
1610␊
1611␉␉␉␉␉default:␊
1612␉␉␉␉␉␉bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,␊
1613␉␉␉␉␉␉0, 0, 0, 0, 0, 0, 0,␊
1614␉␉␉␉␉␉(BVFree)free, 0, kBIOSDevTypeHardDrive, 0);␊
1615␉␉␉␉␉␉break;␊
1616␉␉␉␉}␊
1617␊
1618␉␉␉}␊
1619␊
1620␉␉␉// turbo - save our booter partition␊
1621␉␉␉// zef - only on original boot device␊
1622␉␉␉if ( (efi_guid_compare(&GPT_EFISYS_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ) {␊
1623␉␉␉␉switch (fsType) {␊
1624␉␉␉␉␉case FDISK_HFS:␊
1625␉␉␉␉␉if (readBootSector( biosdev, gptMap->ent_lba_start, (void *)0x7e00 ) == 0) {␊
1626␉␉␉␉␉␉bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,␊
1627␉␉␉␉␉␉HFSInitPartition,␊
1628␉␉␉␉␉␉HFSLoadFile,␊
1629␉␉␉␉␉␉HFSReadFile,␊
1630␉␉␉␉␉␉HFSGetDirEntry,␊
1631␉␉␉␉␉␉HFSGetFileBlock,␊
1632␉␉␉␉␉␉HFSGetUUID,␊
1633␉␉␉␉␉␉HFSGetDescription,␊
1634␉␉␉␉␉␉HFSFree,␊
1635␉␉␉␉␉␉0, kBIOSDevTypeHardDrive, kBVFlagEFISystem);␊
1636␉␉␉␉␉}␊
1637␉␉␉␉␉break;␊
1638␊
1639␉␉␉␉␉case FDISK_FAT32:␊
1640␉␉␉␉␉if (testFAT32EFIBootSector( biosdev, gptMap->ent_lba_start, (void *)0x7e00 ) == 0) {␊
1641␉␉␉␉␉␉bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,␊
1642␉␉␉␉␉␉MSDOSInitPartition,␊
1643␉␉␉␉␉␉MSDOSLoadFile,␊
1644␉␉␉␉␉␉MSDOSReadFile,␊
1645␉␉␉␉␉␉MSDOSGetDirEntry,␊
1646␉␉␉␉␉␉MSDOSGetFileBlock,␊
1647␉␉␉␉␉␉MSDOSGetUUID,␊
1648␉␉␉␉␉␉MSDOSGetDescription,␊
1649␉␉␉␉␉␉MSDOSFree,␊
1650␉␉␉␉␉␉0, kBIOSDevTypeHardDrive, kBVFlagEFISystem);␊
1651␉␉␉␉␉}␊
1652␉␉␉␉␉break;␊
1653␊
1654␉␉␉␉␉default:␊
1655␉␉␉␉␉if (biosdev == gBIOSDev)␊
1656␉␉␉␉␉{␊
1657␉␉␉␉␉␉gBIOSBootVolume = bvr;␊
1658␉␉␉␉␉}␊
1659␉␉␉␉␉break;␊
1660␉␉␉␉}␊
1661␉␉␉}␊
1662␊
1663␉␉␉if (bvr)␊
1664␉␉␉{␊
1665␉␉␉␉// Fixup bvr with the fake fdisk partition type.␊
1666␉␉␉␉if (fsType > 0) {␊
1667␉␉␉␉␉bvr->part_type = fsType;␊
1668␉␉␉␉}␊
1669␊
1670␉␉␉␉bvr->next = map->bvr;␊
1671␉␉␉␉map->bvr = bvr;␊
1672␉␉␉␉++map->bvrcnt;␊
1673␉␉␉}␊
1674␊
1675␉␉}␊
1676␉}␊
1677␊
1678␉scanErr:␊
1679␉if (buffer)␊
1680␉{␊
1681␉␉free(buffer);␊
1682␉}␊
1683␊
1684␉if(map)␊
1685␉{␊
1686␉␉if(countPtr) *countPtr = map->bvrcnt;␊
1687␉␉{␊
1688␉␉␉return map->bvr;␊
1689␉␉}␊
1690␊
1691␉}␊
1692␉else␊
1693␉{␊
1694␉␉if(countPtr) *countPtr = 0;␊
1695␉␉{␊
1696␉␉␉return NULL;␊
1697␉␉}␊
1698␉}␊
1699}␊
1700␊
1701//==============================================================================␊
1702␊
1703static bool getOSVersion(BVRef bvr, char *str)␊
1704{␊
1705␉bool valid = false;␉␊
1706␉config_file_t systemVersion;␊
1707␉char dirSpec[512];␊
1708␊
1709␉/*␊
1710␉ * Only look for OS Version on HFS+␊
1711␉ */␊
1712␉if (bvr->fs_readfile != HFSReadFile)␊
1713␉{␊
1714␉␉return valid;␊
1715␉}␊
1716␊
1717␉// OS X Recovery␊
1718␉sprintf(dirSpec, "hd(%d,%d)/com.apple.recovery.boot/SystemVersion.plist", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
1719␊
1720␉if (!loadConfigFile(dirSpec, &systemVersion))␊
1721␉{␊
1722␉␉bvr->OSisInstaller = true;␊
1723␉␉valid = true;␊
1724␉}␊
1725␊
1726␉if (!valid)␊
1727␉{␊
1728␉␉// OS X Standard␊
1729␉␉snprintf(dirSpec, sizeof(dirSpec), "hd(%d,%d)/System/Library/CoreServices/SystemVersion.plist", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
1730␊
1731␉␉if (!loadConfigFile(dirSpec, &systemVersion))␊
1732␉␉{␊
1733␉␉␉bvr->OSisInstaller = false;␊
1734␉␉␉valid = true;␊
1735␉␉}␊
1736␉␉else␊
1737␉␉{␊
1738␉␉␉// OS X Server␊
1739␉␉␉snprintf(dirSpec, sizeof(dirSpec), "hd(%d,%d)/System/Library/CoreServices/ServerVersion.plist", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
1740␊
1741␉␉␉if (!loadConfigFile(dirSpec, &systemVersion))␊
1742␉␉␉{␊
1743␉␉␉␉bvr->OSisServer = false;␊
1744␉␉␉␉valid = true;␊
1745␉␉␉}␊
1746/*␉␉␉else␊
1747␉␉␉{␊
1748␉␉␉␉snprintf(dirSpec, sizeof(dirSpec), "hd(%d,%d)/.IAProductInfo", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
1749␊
1750␉␉␉␉if (!loadConfigFile(dirSpec, &systemVersion))␊
1751␉␉␉␉{␊
1752␊
1753␉␉␉␉}␊
1754␉␉␉}␊
1755*/␊
1756␉␉}␊
1757␊
1758␉␉if ( LION )␊
1759␉␉{␊
1760␉␉␉int fh = -1;␊
1761␉␉␉snprintf(dirSpec, sizeof(dirSpec), "hd(%d,%d)/.PhysicalMediaInstall", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
1762␉␉␉fh = open(dirSpec, 0);␊
1763␊
1764␉␉␉if (fh >= 0)␊
1765␉␉␉{␊
1766␉␉␉␉valid = true;␊
1767␉␉␉␉bvr->OSisInstaller = true;␊
1768␉␉␉␉strcpy(bvr->OSVersion, "10.7"); // 10.7 +␊
1769␉␉␉␉close(fh);␊
1770␉␉␉}␊
1771␉␉␉else␊
1772␉␉␉{␊
1773␉␉␉␉close(fh);␊
1774␉␉␉}␊
1775␉␉}␊
1776␊
1777// Mountain Lion ?␊
1778␊
1779␉␉if ( MAVERICKS )␊
1780␉␉{␊
1781␉␉␉int fh = -1;␊
1782␉␉␉snprintf(dirSpec, sizeof(dirSpec), "hd(%d,%d)/.IAPhysicalMedia", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
1783␉␉␉fh = open(dirSpec, 0);␊
1784␊
1785␉␉␉if (fh >= 0)␊
1786␉␉␉{␊
1787␉␉␉␉valid = true;␊
1788␉␉␉␉bvr->OSisInstaller = true;␊
1789␉␉␉␉strcpy(bvr->OSVersion, "10.9"); // 10.9 +␊
1790␉␉␉}␊
1791␉␉␉else␊
1792␉␉␉{␊
1793␉␉␉␉close(fh);␊
1794␉␉␉}␊
1795␉␉}␊
1796␊
1797// Yosemite ?␊
1798␊
1799␉}␊
1800␊
1801␉if (valid)␊
1802␉{␊
1803␉␉const char *val;␊
1804␉␉int len;␊
1805␊
1806␉␉if (getValueForKey(kProductVersion, &val, &len, &systemVersion))␊
1807␉␉{␊
1808␉␉␉// getValueForKey uses const char for val␊
1809␉␉␉// so copy it and trim␊
1810␉␉␉*str = '\0';␊
1811␉␉␉strncat(str, val, MIN(len, 5));␊
1812␉␉␉if(str[4] == '.')␊
1813␉␉␉{␊
1814␉␉␉␉str[4] = '\0';␊
1815␉␉␉}␊
1816␉␉}␊
1817␉␉else␊
1818␉␉{␊
1819␉␉␉valid = false;␊
1820␉␉}␊
1821␉}␊
1822␊
1823␉return valid;␊
1824}␊
1825␊
1826//==============================================================================␊
1827␊
1828static void scanFSLevelBVRSettings(BVRef chain)␊
1829{␊
1830␉BVRef bvr;␊
1831␉char dirSpec[512], fileSpec[512];␊
1832␉char label[BVSTRLEN];␊
1833␉int ret;␊
1834␉long flags;␊
1835␉u_int32_t time;␊
1836␉int fh, fileSize, error;␊
1837␊
1838␉for (bvr = chain; bvr; bvr = bvr->next)␊
1839␉{␊
1840␉␉ret = -1;␊
1841␉␉error = 0;␊
1842␊
1843␉␉//␊
1844␉␉// Check for alternate volume label on boot helper partitions.␊
1845␉␉//␊
1846␉␉if (bvr->flags & kBVFlagBooter)␊
1847␉␉{␊
1848␉␉␉snprintf(dirSpec, sizeof(dirSpec), "hd(%d,%d)/System/Library/CoreServices/", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
1849␉␉␉strlcpy(fileSpec, ".disk_label.contentDetails", sizeof(fileSpec));␊
1850␉␉␉ret = GetFileInfo(dirSpec, fileSpec, &flags, &time);␊
1851␉␉␉if (!ret)␊
1852␉␉␉{␊
1853␉␉␉␉strlcat(dirSpec, fileSpec, sizeof(dirSpec));␊
1854␉␉␉␉fh = open(dirSpec,0);␊
1855␊
1856␉␉␉␉fileSize = file_size(fh);␊
1857␉␉␉␉if (fileSize > 0 && fileSize < BVSTRLEN)␊
1858␉␉␉␉{␊
1859␉␉␉␉␉if (read(fh, label, fileSize) != fileSize)␊
1860␉␉␉␉␉{␊
1861␉␉␉␉␉␉error = -1;␊
1862␉␉␉␉␉}␊
1863␉␉␉␉}␊
1864␉␉␉␉else␊
1865␉␉␉␉{␊
1866␉␉␉␉␉error = -1;␊
1867␉␉␉␉}␊
1868␊
1869␉␉␉␉close(fh);␊
1870␊
1871␉␉␉␉if (!error)␊
1872␉␉␉␉{␊
1873␉␉␉␉␉label[fileSize] = '\0';␊
1874␉␉␉␉␉strlcpy(bvr->altlabel, label, sizeof(bvr->altlabel));␊
1875␉␉␉␉}␊
1876␉␉␉}␊
1877␉␉}␊
1878␊
1879␉␉// Check for SystemVersion.plist or ServerVersion.plist to determine if a volume hosts an installed system.␊
1880␊
1881␉␉if (bvr->flags & kBVFlagNativeBoot)␊
1882␉␉{␊
1883␉␉␉if (getOSVersion(bvr, bvr->OSVersion) == true)␊
1884␉␉␉{␊
1885␉␉␉␉bvr->flags |= kBVFlagSystemVolume;␊
1886␉␉␉}␊
1887␉␉}␊
1888␊
1889␉}␊
1890}␊
1891␊
1892//==============================================================================␊
1893␊
1894void rescanBIOSDevice(int biosdev)␊
1895{␊
1896␉struct DiskBVMap *oldMap = diskResetBootVolumes(biosdev);␊
1897␉if (oldMap == NULL)␊
1898␉{␊
1899␉␉return;␊
1900␉}␊
1901␊
1902␉CacheReset();␊
1903␉diskFreeMap(oldMap);␊
1904␉oldMap = NULL;␊
1905␉scanBootVolumes(biosdev, 0);␊
1906}␊
1907␊
1908//==============================================================================␊
1909␊
1910struct DiskBVMap* diskResetBootVolumes(int biosdev)␊
1911{␊
1912␉struct DiskBVMap * map;␊
1913␉struct DiskBVMap *prevMap = NULL;␊
1914␉for ( map = gDiskBVMap; map; prevMap = map, map = map->next ) {␊
1915␉␉if ( biosdev == map->biosdev ) {␊
1916␉␉␉break;␊
1917␉␉}␊
1918␉}␊
1919␊
1920␉if(map != NULL) {␊
1921␉␉verbose("Resetting BIOS device %xh\n", biosdev);␊
1922␉␉// Reset the biosbuf cache␊
1923␉␉cache_valid = false;␊
1924␉␉if(map == gDiskBVMap)␊
1925␉␉{␊
1926␉␉␉gDiskBVMap = map->next;␊
1927␉␉}␊
1928␉␉else if(prevMap != NULL)␊
1929␉␉{␊
1930␉␉␉prevMap->next = map->next;␊
1931␉␉}␊
1932␉␉else␊
1933␉␉{␊
1934␉␉␉stop("diskResetBootVolumes error\n");␊
1935␉␉␉return NULL;␊
1936␉␉}␊
1937␉}␊
1938␉// Return the old map, either to be freed, or reinserted later␊
1939␉return map;␊
1940}␊
1941␊
1942//==============================================================================␊
1943␊
1944// Frees a DiskBVMap and all of its BootVolume's␊
1945void diskFreeMap(struct DiskBVMap *map)␊
1946{␊
1947␉if(map != NULL)␊
1948␉{␊
1949␉␉while(map->bvr != NULL)␊
1950␉␉{␊
1951␉␉␉BVRef bvr = map->bvr;␊
1952␉␉␉map->bvr = bvr->next;␊
1953␉␉␉(*bvr->bv_free)(bvr);␊
1954␉␉}␊
1955␊
1956␉␉free(map);␊
1957␉}␊
1958}␊
1959␊
1960//==============================================================================␊
1961␊
1962BVRef diskScanBootVolumes(int biosdev, int * countPtr)␊
1963{␊
1964␉struct DiskBVMap *map;␊
1965␉BVRef bvr;␊
1966␉int count = 0;␊
1967␊
1968␉// Find an existing mapping for this device.␊
1969␊
1970␉for (map = gDiskBVMap; map; map = map->next)␊
1971␉{␊
1972␉␉if (biosdev == map->biosdev)␊
1973␉␉{␊
1974␉␉␉count = map->bvrcnt;␊
1975␉␉␉break;␊
1976␉␉}␊
1977␉}␊
1978␊
1979␉if (map == NULL)␊
1980␉{␊
1981␉␉bvr = diskScanGPTBootVolumes(biosdev, &count);␊
1982␉␉if (bvr == NULL)␊
1983␉␉{␊
1984␉␉␉bvr = diskScanFDiskBootVolumes(biosdev, &count);␊
1985␉␉}␊
1986␊
1987␉␉if (bvr == NULL)␊
1988␉␉{␊
1989␉␉␉bvr = diskScanAPMBootVolumes(biosdev, &count);␊
1990␉␉}␊
1991␊
1992␉␉if (bvr)␊
1993␉␉{␊
1994␉␉␉scanFSLevelBVRSettings(bvr);␊
1995␉␉}␊
1996␉}␊
1997␉else␊
1998␉{␊
1999␉␉bvr = map->bvr;␊
2000␉}␊
2001␊
2002␉if (countPtr)␊
2003␉{␊
2004␉␉*countPtr += count;␊
2005␉}␊
2006␊
2007␉return bvr;␊
2008}␊
2009␊
2010//==============================================================================␊
2011␊
2012BVRef getBVChainForBIOSDev(int biosdev)␊
2013{␊
2014␉BVRef chain = NULL;␊
2015␉struct DiskBVMap * map = NULL;␊
2016␊
2017␉for (map = gDiskBVMap; map; map = map->next)␊
2018␉{␊
2019␉␉if (map->biosdev == biosdev)␊
2020␉␉{␊
2021␉␉␉chain = map->bvr;␊
2022␉␉␉break;␊
2023␉␉}␊
2024␉}␊
2025␊
2026␉return chain;␊
2027}␊
2028␊
2029//==============================================================================␊
2030␊
2031BVRef newFilteredBVChain(int minBIOSDev, int maxBIOSDev, unsigned int allowFlags, unsigned int denyFlags, int *count)␊
2032{␊
2033␉BVRef chain = NULL;␊
2034␉BVRef bvr = NULL;␊
2035␉BVRef newBVR = NULL;␊
2036␉BVRef prevBVR = NULL;␊
2037␊
2038␉struct DiskBVMap * map = NULL;␊
2039␉int bvCount = 0;␊
2040␊
2041␉const char *raw = 0;␊
2042␉char* val = 0;␊
2043␉int len;␊
2044 ␊
2045␉getValueForKey(kHidePartition, &raw, &len, &bootInfo->chameleonConfig);␊
2046␉if(raw)␊
2047␉{␊
2048␉␉val = XMLDecode(raw); ␊
2049␉}␊
2050␊
2051␉/*␊
2052␉ * Traverse gDISKBVmap to get references for␊
2053␉ * individual bvr chains of each drive.␊
2054␉ */␊
2055␉for (map = gDiskBVMap; map; map = map->next)␊
2056␉{␊
2057␉␉for (bvr = map->bvr; bvr; bvr = bvr->next)␊
2058␉␉{␊
2059␉␉␉/*␊
2060␉␉␉ * Save the last bvr.␊
2061␉␉␉ */␊
2062␉␉␉if (newBVR)␊
2063␉␉␉{␊
2064␉␉␉␉prevBVR = newBVR;␊
2065␉␉␉}␊
2066␊
2067␉␉␉/*␊
2068␉␉␉ * Allocate and copy the matched bvr entry into a new one.␊
2069␉␉␉ */␊
2070␉␉␉newBVR = (BVRef) malloc(sizeof(*newBVR));␊
2071␉␉␉if (!newBVR)␊
2072␉␉␉{␊
2073␉␉␉␉continue;␊
2074␉␉␉}␊
2075␉␉␉bzero(newBVR,sizeof(*newBVR));␊
2076␊
2077␉␉␉bcopy(bvr, newBVR, sizeof(*newBVR));␊
2078␊
2079␉␉␉/*␊
2080␉␉␉ * Adjust the new bvr's fields.␊
2081␉␉␉ */␊
2082␉␉␉newBVR->next = NULL;␊
2083␉␉␉newBVR->filtered = true;␊
2084␊
2085␉␉␉if ( (!allowFlags || newBVR->flags & allowFlags)␊
2086␉␉␉␉&& (!denyFlags || !(newBVR->flags & denyFlags) )␊
2087␉␉␉␉&& (newBVR->biosdev >= minBIOSDev && newBVR->biosdev <= maxBIOSDev)␊
2088␉␉␉␉)␊
2089␉␉␉{␊
2090␉␉␉␉newBVR->visible = true;␊
2091␉␉␉}␊
2092␊
2093␉␉␉/*␊
2094␉␉␉ * Looking for "Hide Partition" entries in 'hd(x,y)|uuid|"label" hd(m,n)|uuid|"label"' format,␊
2095␉␉␉ * to be able to hide foreign partitions from the boot menu.␊
2096␉␉␉ *␊
2097␉␉␉ */␊
2098␉␉␉if ( (newBVR->flags & kBVFlagForeignBoot) )␊
2099␉␉␉{␊
2100␉␉␉␉char *start, *next = val;␊
2101␉␉␉␉long len = 0; ␊
2102␉␉␉␉do␊
2103␉␉␉␉{␊
2104␉␉␉␉␉start = strbreak(next, &next, &len);␊
2105␉␉␉␉␉if(len && matchVolumeToString(newBVR, start, len) )␊
2106␉␉␉␉␉{␊
2107␉␉␉␉␉␉newBVR->visible = false;␊
2108␉␉␉␉␉}␊
2109␉␉␉␉}␊
2110␉␉␉␉while ( next && *next );␊
2111␉␉␉}␊
2112␊
2113␉␉␉/*␊
2114␉␉␉ * Use the first bvr entry as the starting chain pointer.␊
2115␉␉␉ */␊
2116␉␉␉if (!chain)␊
2117␉␉␉{␊
2118␉␉␉␉chain = newBVR;␊
2119␉␉␉}␊
2120␊
2121␉␉␉/*␊
2122␉␉␉ * Update the previous bvr's link pointer to use the new memory area.␊
2123␉␉␉ */␊
2124␉␉␉if (prevBVR)␊
2125␉␉␉{␊
2126␉␉␉␉prevBVR->next = newBVR;␊
2127␉␉␉}␊
2128␊
2129␉␉␉if (newBVR->visible)␊
2130␉␉␉{␊
2131␉␉␉␉bvCount++;␊
2132␉␉␉}␊
2133␉␉}␊
2134␉}␊
2135␊
2136#if DEBUG //Azi: warning - too big for boot-log.. far too big.. i mean HUGE!! :P␊
2137␉for (bvr = chain; bvr; bvr = bvr->next)␊
2138␉{␊
2139␉␉if (!bvr)␊
2140␉␉{␊
2141␉␉␉break;␊
2142␉␉}␊
2143␉␉printf(" bvr: %d, dev: %d, part: %d, flags: %d, vis: %d\n", bvr, bvr->biosdev, bvr->part_no, bvr->flags, bvr->visible);␊
2144␉}␊
2145␉printf("count: %d\n", bvCount);␊
2146␉getchar();␊
2147#endif␊
2148␊
2149␉*count = bvCount;␊
2150␊
2151␉free(val); ␊
2152␉return chain;␊
2153}␊
2154␊
2155//==============================================================================␊
2156␊
2157int freeFilteredBVChain(const BVRef chain)␊
2158{␊
2159␉int ret = 1;␊
2160␉BVRef bvr = chain;␊
2161␉BVRef nextBVR = NULL;␊
2162 ␊
2163␉while (bvr)␊
2164␉{␊
2165␉␉if (!bvr)␊
2166␉␉{␊
2167␉␉␉break;␊
2168␉␉}␊
2169␊
2170␉␉nextBVR = bvr->next;␊
2171␊
2172␉␉if (bvr->filtered)␊
2173␉␉{␊
2174␉␉␉free(bvr);␊
2175␉␉}␊
2176␉␉else␊
2177␉␉{␊
2178␉␉␉ret = 0;␊
2179␉␉␉break;␊
2180␉␉}␊
2181␊
2182␉␉bvr = nextBVR;␊
2183␉}␊
2184␊
2185␉return ret;␊
2186}␊
2187␊
2188//==============================================================================␊
2189␊
2190bool matchVolumeToString( BVRef bvr, const char* match, long matchLen)␊
2191{␊
2192␉char testStr[128];␊
2193␊
2194␉if ( !bvr || !match || !*match)␊
2195␉{␊
2196␉␉return 0;␊
2197␉}␊
2198␊
2199␉if ( bvr->biosdev < 0x80 || bvr->biosdev >= 0x100 )␊
2200␉{␊
2201 return 0;␊
2202␉}␊
2203␊
2204␉// Try to match hd(x,y) first.␊
2205␉snprintf(testStr, sizeof(testStr), "hd(%d,%d)", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
2206␉if ( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) )␊
2207␉{␊
2208␉␉return true;␊
2209␉}␊
2210␊
2211␉// Try to match volume UUID.␊
2212␉if ( bvr->fs_getuuid && bvr->fs_getuuid(bvr, testStr) == 0)␊
2213␉{␊
2214␉␉if ( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) )␊
2215␉␉{␊
2216␉␉␉return true;␊
2217␉␉}␊
2218␉}␊
2219␊
2220␉// Try to match volume label (always quoted).␊
2221␉if ( bvr->description )␊
2222␉{␊
2223␉␉bvr->description(bvr, testStr, sizeof(testStr)-1);␊
2224␉␉if ( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) )␊
2225␉␉{␊
2226␉␉␉return true;␊
2227␉␉}␊
2228␉}␊
2229␊
2230␉return false;␊
2231}␊
2232␊
2233//==============================================================================␊
2234␊
2235/* If Rename Partition has defined an alias, then extract it for description purpose.␊
2236 * The format for the rename string is the following:␊
2237 * hd(x,y)|uuid|"label" "alias";hd(m,n)|uuid|"label" "alias"; etc...␊
2238 */␊
2239␊
2240static bool getVolumeLabelAlias(BVRef bvr, char* str, long strMaxLen)␊
2241{␊
2242␉char *aliasList, *entryStart, *entryNext;␊
2243 ␊
2244␉if ( !str || strMaxLen <= 0)␊
2245␉{␊
2246␉␉return false;␊
2247␉}␊
2248␊
2249␉aliasList = XMLDecode(getStringForKey(kRenamePartition, &bootInfo->chameleonConfig));␊
2250␉if ( !aliasList )␊
2251␉{␊
2252␉␉return false;␊
2253␉}␊
2254␊
2255␉for ( entryStart = entryNext = aliasList; entryNext && *entryNext; entryStart = entryNext )␊
2256␉{␊
2257␉␉char *volStart, *volEnd, *aliasStart;␊
2258␉␉long volLen, aliasLen;␊
2259 ␊
2260␉␉// Delimit current entry␊
2261␉␉entryNext = strchr(entryStart, ';');␊
2262␉␉if ( entryNext )␊
2263␉␉{␊
2264␉␉␉*entryNext = '\0';␊
2265␉␉␉entryNext++;␊
2266␉␉}␊
2267 ␊
2268␉␉volStart = strbreak(entryStart, &volEnd, &volLen);␊
2269␉␉if(!volLen)␊
2270␉␉{␊
2271␉␉␉continue;␊
2272␉␉}␊
2273␊
2274␉␉aliasStart = strbreak(volEnd, 0, &aliasLen);␊
2275␉␉if(!aliasLen)␊
2276␉␉{␊
2277␉␉␉continue;␊
2278␉␉}␊
2279␊
2280␉␉if ( matchVolumeToString(bvr, volStart, volLen) )␊
2281␉␉{␊
2282␉␉␉strncat(str, aliasStart, MIN(strMaxLen, aliasLen));␊
2283␉␉␉free(aliasList);␊
2284␊
2285␉␉␉return true;␊
2286␉␉}␊
2287␉}␊
2288 ␊
2289␉free(aliasList);␊
2290␉return false;␊
2291}␊
2292␊
2293//==============================================================================␊
2294␊
2295void getBootVolumeDescription( BVRef bvr, char *str, long strMaxLen, bool useDeviceDescription )␊
2296{␊
2297␉unsigned char type;␊
2298␉char *p = str;␊
2299 ␊
2300␉if(!bvr || !p || strMaxLen <= 0)␊
2301␉{␊
2302␉␉return;␊
2303␉}␊
2304␊
2305␉type = (unsigned char) bvr->part_type;␊
2306␊
2307␉if (useDeviceDescription)␊
2308␉{␊
2309␉␉int len = getDeviceDescription(bvr, str);␊
2310␉␉if(len >= strMaxLen)␊
2311␉␉{␊
2312␉␉␉return;␊
2313␉␉}␊
2314␊
2315␉␉strcpy(str + len, bvr->OSisInstaller ? " (Installer " : " (");␊
2316␉␉len += bvr->OSisInstaller ? 12 : 2;␊
2317␉␉strcpy(str + len, bvr->OSVersion);␊
2318␉␉len += strlen(bvr->OSVersion);␊
2319␉␉strcpy(str + len, ") ");␊
2320␉␉len += 2;␊
2321␊
2322␉␉strMaxLen -= len;␊
2323␉␉p += len;␊
2324␉}␊
2325␊
2326␉/* See if a partition rename is preferred */␊
2327␉if (getVolumeLabelAlias(bvr, p, strMaxLen))␊
2328␉{␊
2329␉␉strncpy(bvr->label, p, strMaxLen); ␊
2330␉␉return; // we're done here no need to seek for real name␊
2331␉}␊
2332␊
2333␉// Get the volume label using filesystem specific functions or use the alternate volume label if available.␊
2334␊
2335␉if (*bvr->altlabel != '\0')␊
2336␉{␊
2337␉␉strncpy(p, bvr->altlabel, strMaxLen);␊
2338␉}␊
2339␉else if (bvr->description)␊
2340␉{␊
2341␉␉bvr->description(bvr, p, strMaxLen);␊
2342␉}␊
2343␊
2344␉if (*p == '\0')␊
2345␉{␊
2346␉␉const char * name = getNameForValue( fdiskTypes, type );␊
2347␊
2348␉␉if (name == NULL)␊
2349␉␉{␊
2350␉␉␉name = bvr->type_name;␊
2351␉␉}␊
2352␊
2353␉␉if (name == NULL)␊
2354␉␉{␊
2355␉␉␉snprintf(p, strMaxLen, "TYPE %02X", type);␊
2356␉␉}␊
2357␉␉else␊
2358␉␉{␊
2359␉␉␉strncpy(p, name, strMaxLen);␊
2360␉␉}␊
2361␉}␊
2362␊
2363␉// Set the devices label␊
2364␉strncpy(bvr->label, p, sizeof bvr->label);␊
2365}␊
2366␊
2367␊
2368//==============================================================================␊
2369␊
2370int readBootSector(int biosdev, unsigned int secno, void *buffer)␊
2371{␊
2372␉int error;␊
2373␉struct disk_blk0 * bootSector = (struct disk_blk0 *)buffer;␊
2374␊
2375␉if (bootSector == NULL)␊
2376␉{␊
2377␉␉if (gBootSector == NULL)␊
2378␉␉{␊
2379␉␉␉gBootSector = (struct disk_blk0 *)malloc(sizeof(*gBootSector));␊
2380␊
2381␉␉␉if (gBootSector == NULL)␊
2382␉␉␉{␊
2383␉␉␉␉return -1;␊
2384␉␉␉}␊
2385␉␉}␊
2386␊
2387␉␉bootSector = gBootSector;␊
2388␉}␊
2389␊
2390␉error = readBytes(biosdev, secno, 0, BPS, bootSector);␊
2391␊
2392␉if (error || bootSector->signature != DISK_SIGNATURE)␊
2393␉{␊
2394␉␉return -1;␊
2395␉}␊
2396␉return 0;␊
2397}␊
2398␊
2399//==============================================================================␊
2400␊
2401/*␊
2402 * Format of boot1f32 block.␊
2403 */␊
2404␊
2405#define BOOT1F32_MAGIC "BOOT "␊
2406#define BOOT1F32_MAGICLEN 11␊
2407␊
2408struct disk_boot1f32_blk␊
2409{␊
2410␉unsigned char init[3];␊
2411␉unsigned char fsheader[87];␊
2412␉unsigned char magic[BOOT1F32_MAGICLEN];␊
2413␉unsigned char bootcode[409];␊
2414␉unsigned short signature;␊
2415};␊
2416␊
2417//==============================================================================␊
2418␊
2419int testFAT32EFIBootSector(int biosdev, unsigned int secno, void *buffer)␊
2420{␊
2421␉struct disk_boot1f32_blk *bootSector = (struct disk_boot1f32_blk *)buffer;␊
2422␉int error;␊
2423␊
2424␉if (bootSector == NULL)␊
2425␉{␊
2426␉␉if (gBootSector == NULL)␊
2427␉␉{␊
2428␉␉␉gBootSector = (struct disk_blk0 *)malloc(sizeof(*gBootSector));␊
2429␉␉␉if ( gBootSector == NULL )␊
2430␉␉␉{␊
2431␉␉␉␉return -1;␊
2432␉␉␉}␊
2433␉␉}␊
2434␉␉bootSector = (struct disk_boot1f32_blk *)gBootSector;␊
2435␉}␊
2436␊
2437␉error = readBytes(biosdev, secno, 0, BPS, bootSector);␊
2438␉if (error || bootSector->signature != DISK_SIGNATURE || strncmp((const char *)bootSector->magic, BOOT1F32_MAGIC, BOOT1F32_MAGICLEN) )␊
2439␉{␊
2440␉␉return -1;␊
2441␉}␊
2442␉return 0;␊
2443}␊
2444␊
2445␊
2446//==============================================================================␊
2447// Handle seek request from filesystem modules.␊
2448␊
2449void diskSeek(BVRef bvr, long long position)␊
2450{␊
2451␉bvr->fs_boff = position / BPS;␊
2452␉bvr->fs_byteoff = position % BPS;␊
2453}␊
2454␊
2455␊
2456//==============================================================================␊
2457// Handle read request from filesystem modules.␊
2458␊
2459int diskRead(BVRef bvr, long addr, long length)␊
2460{␊
2461␉return readBytes(bvr->biosdev, bvr->fs_boff + bvr->part_boff, bvr->fs_byteoff, length, (void *) addr);␊
2462}␊
2463␊
2464//==============================================================================␊
2465␊
2466int rawDiskRead( BVRef bvr, unsigned int secno, void *buffer, unsigned int len )␊
2467{␊
2468␉int secs;␊
2469␉unsigned char *cbuf = (unsigned char *)buffer;␊
2470␉unsigned int copy_len;␊
2471␉int rc;␊
2472␊
2473␉if ((len & (BPS-1)) != 0)␊
2474␉{␊
2475␉␉error("raw disk read not sector aligned");␊
2476␉␉return -1;␊
2477␉}␊
2478␉secno += bvr->part_boff;␊
2479␊
2480␉cache_valid = false;␊
2481␊
2482␉while (len > 0)␊
2483␉{␊
2484␉␉secs = len / BPS;␊
2485␉␉if (secs > N_CACHE_SECS)␊
2486␉␉{␊
2487␉␉␉secs = N_CACHE_SECS;␊
2488␉␉}␊
2489␉␉copy_len = secs * BPS;␊
2490␊
2491␉␉//printf("rdr: ebiosread(%d, %d, %d)\n", bvr->biosdev, secno, secs);␊
2492␉␉if ((rc = ebiosread(bvr->biosdev, secno, secs)) != 0)␊
2493␉␉{␊
2494␉␉␉/* Ignore corrected ECC errors */␊
2495␉␉␉if (rc != ECC_CORRECTED_ERR)␊
2496␉␉␉{␊
2497␉␉␉␉error(" EBIOS read error: %s\n", bios_error(rc), rc);␊
2498␉␉␉␉error(" Block %d Sectors %d\n", secno, secs);␊
2499␉␉␉␉return rc;␊
2500␉␉␉}␊
2501␉␉}␊
2502␉␉bcopy( trackbuf, cbuf, copy_len );␊
2503␉␉len -= copy_len;␊
2504␉␉cbuf += copy_len;␊
2505␉␉secno += secs;␊
2506␉␉spinActivityIndicator(secs);␊
2507␉}␊
2508␊
2509␉return 0;␊
2510}␊
2511␊
2512//==============================================================================␊
2513␊
2514int rawDiskWrite( BVRef bvr, unsigned int secno, void *buffer, unsigned int len )␊
2515{␊
2516 int secs;␊
2517 unsigned char *cbuf = (unsigned char *)buffer;␊
2518 unsigned int copy_len;␊
2519 int rc;␊
2520␊
2521␉if ((len & (BPS-1)) != 0)␊
2522␉{␊
2523␉␉error("raw disk write not sector aligned");␊
2524␉␉return -1;␊
2525␉}␊
2526␉secno += bvr->part_boff;␊
2527␊
2528␉cache_valid = false;␊
2529␊
2530␉while (len > 0)␊
2531␉{␊
2532␉␉secs = len / BPS;␊
2533␉␉if (secs > N_CACHE_SECS)␊
2534␉␉{␊
2535␉␉␉secs = N_CACHE_SECS;␊
2536␉␉}␊
2537␉␉copy_len = secs * BPS;␊
2538␊
2539␉␉bcopy( cbuf, trackbuf, copy_len );␊
2540␉␉//printf("rdr: ebioswrite(%d, %d, %d)\n", bvr->biosdev, secno, secs);␊
2541␉␉if ((rc = ebioswrite(bvr->biosdev, secno, secs)) != 0)␊
2542␉␉{␊
2543␉␉␉error(" EBIOS write error: %s\n", bios_error(rc), rc);␊
2544␉␉␉error(" Block %d Sectors %d\n", secno, secs);␊
2545␉␉␉return rc;␊
2546␉␉}␊
2547␊
2548␉␉len -= copy_len;␊
2549␉␉cbuf += copy_len;␊
2550␉␉secno += secs;␊
2551␉␉spinActivityIndicator(secs);␊
2552␉}␊
2553␊
2554␉return 0;␊
2555}␊
2556␊
2557//==============================================================================␊
2558␊
2559int diskIsCDROM(BVRef bvr)␊
2560{␊
2561␉struct driveInfo di;␊
2562␊
2563␉if (getDriveInfo(bvr->biosdev, &di) == 0 && di.no_emulation)␊
2564␉{␊
2565␉␉return 1;␊
2566␉}␊
2567␉return 0;␊
2568}␊
2569␊
2570//==============================================================================␊
2571␊
2572int biosDevIsCDROM(int biosdev)␊
2573{␊
2574␉struct driveInfo di;␊
2575␊
2576␉if (getDriveInfo(biosdev, &di) == 0 && di.no_emulation)␊
2577␉{␊
2578␉␉return 1;␊
2579␉}␊
2580␉return 0;␊
2581}␊
2582

Archive Download this file

Revision: 2630