Chameleon

Chameleon Svn Source Tree

Root/trunk/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␊
745BVRef newAPMBVRef( int biosdev, int partno, unsigned int blkoff,␊
746 const DPME * part,␊
747 FSInit initFunc, FSLoadFile loadFunc,␊
748 FSReadFile readFunc,␊
749 FSGetDirEntry getdirFunc,␊
750 FSGetFileBlock getBlockFunc,␊
751 FSGetUUID getUUIDFunc,␊
752 BVGetDescription getDescriptionFunc,␊
753 BVFree bvFreeFunc,␊
754 int probe, int type, unsigned int bvrFlags )␊
755{␊
756␉BVRef bvr = (BVRef)malloc(sizeof(*bvr));␊
757␉if ( bvr )␊
758␉{␊
759␉␉bzero(bvr, sizeof(*bvr));␊
760␊
761␉␉bvr->biosdev = biosdev;␊
762␉␉bvr->part_no = partno;␊
763␉␉bvr->part_boff = blkoff;␊
764␉␉bvr->fs_loadfile = loadFunc;␊
765␉␉bvr->fs_readfile = readFunc;␊
766␉␉bvr->fs_getdirentry = getdirFunc;␊
767␉␉bvr->fs_getfileblock= getBlockFunc;␊
768␉␉bvr->fs_getuuid = getUUIDFunc;␊
769␉␉bvr->description = getDescriptionFunc;␊
770␉␉bvr->type = type;␊
771␉␉bvr->bv_free = bvFreeFunc;␊
772␉␉strlcpy(bvr->name, part->dpme_name, DPISTRLEN);␊
773␉␉strlcpy(bvr->type_name, part->dpme_type, DPISTRLEN);␊
774␊
775␉␉/*␊
776␉␉if ( part->bootid & FDISK_ACTIVE )␊
777␉␉{␊
778␉␉␉bvr->flags |= kBVFlagPrimary;␊
779␉␉}␊
780␉␉*/␊
781␊
782␉␉// Probe the filesystem.␊
783␊
784␉␉if ( initFunc )␊
785␉␉{␊
786␉␉␉bvr->flags |= kBVFlagNativeBoot | kBVFlagBootable | kBVFlagSystemVolume;␊
787␊
788␉␉␉if ( probe && initFunc( bvr ) != 0 )␊
789␉␉␉{␊
790␉␉␉␉// filesystem probe failed.␊
791␊
792␉␉␉␉DEBUG_DISK(("%s: failed probe on dev %X part %d\n", __FUNCTION__, biosdev, partno));␊
793␊
794␉␉␉␉(*bvr->bv_free)(bvr);␊
795␉␉␉␉bvr = NULL;␊
796␉␉␉}␊
797␉␉}␊
798␉␉/*␊
799␉␉else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 )␊
800␉␉{␊
801␉␉␉bvr->flags |= kBVFlagForeignBoot;␊
802␉␉}␊
803␉␉*/␊
804␉␉else␊
805␉␉{␊
806␉␉␉(*bvr->bv_free)(bvr);␊
807␉␉␉bvr = NULL;␊
808␉␉}␊
809␉}␊
810␊
811␉if ( bvr )␊
812␉{␊
813␉␉bvr->flags |= bvrFlags;␊
814␉}␊
815␊
816␉return bvr;␊
817}␊
818␊
819//==============================================================================␊
820␊
821// GUID's in LE form:␊
822// HFS+ partition - 48465300-0000-11AA-AA11-00306543ECAC␊
823EFI_GUID const GPT_HFS_GUID␉␉= { 0x48465300, 0x0000, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xAF00 "Apple HFS/HFS+"␊
824␊
825// turbo - Apple Boot Partition - 426F6F74-0000-11AA-AA11-00306543ECAC␊
826EFI_GUID const GPT_BOOT_GUID␉␉= { 0x426F6F74, 0x0000, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xAB00 "Apple boot"␊
827␊
828// turbo - or an EFI System Partition - C12A7328-F81F-11D2-BA4B-00A0C93EC93B␊
829EFI_GUID const GPT_EFISYS_GUID␉␉= { 0xC12A7328, 0xF81F, 0x11D2, { 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B } }; // 0xEF00 "EFI System"␊
830␊
831// zef - Basic Data Partition - EBD0A0A2-B9E5-4433-87C0-68B6B72699C7 for foreign OS support␊
832EFI_GUID const GPT_BASICDATA_GUID␉= { 0xEBD0A0A2, 0xB9E5, 0x4433, { 0x87, 0xC0, 0x68, 0xB6, 0xB7, 0x26, 0x99, 0xC7 } }; // 0x0100 "Microsoft basic data"␊
833␊
834// Microsoft Reserved Partition - E3C9E316-0B5C-4DB8-817DF92DF00215AE␊
835EFI_GUID const GPT_BASICDATA2_GUID␉= { 0xE3C9E316, 0x0B5C, 0x4DB8, { 0x81, 0x7D, 0xF9, 0x2D, 0xF0, 0x02, 0x15, 0xAE } }; // 0x0C01 "Microsoft reserved"␊
836␊
837// Apple OSX␊
838//EFI_GUID const GPT_UFS_GUID␉␉= { 0x55465300, 0x0000, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xA800 "Apple UFS"␊
839//EFI_GUID const GPT_RAID_GUID␉␉= { 0x52414944, 0x0000, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xAF01 "Apple RAID"␊
840//EFI_GUID const GPT_RAID_OFFLINE_GUID␉= { 0x52414944, 0x5f4f, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xAF02 "Apple RAID offline"␊
841//EFI_GUID const GPT_LABEL_GUID␉␉= { 0x4C616265, 0x6C00, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xAF03 "Apple label"␊
842//EFI_GUID const GPT_APPLETV_GUID␉= { 0x5265636F, 0x7665, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xAF04 "Apple TV recovery"␊
843//EFI_GUID const GPT_CORESTORAGE_GUID␉= { 0x53746F72, 0x6167, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // 0xAF05 "Apple Core storage"␊
844// same as Apple ZFS␊
845//EFI_GUID const GPT_ZFS_GUID␉␉= { 0x6A898CC3, 0x1DD2, 0x11B2, { 0x99, 0xA6, 0x08, 0x00, 0x20, 0x73, 0x66, 0x31 } }; // 0xBF01 "Solaris /usr & Apple ZFS␊
846␊
847static BVRef newGPTBVRef( int biosdev,␊
848 int partno,␊
849 unsigned int blkoff,␊
850 const gpt_ent *part,␊
851 FSInit initFunc,␊
852 FSLoadFile loadFunc,␊
853 FSReadFile readFunc,␊
854 FSGetDirEntry getdirFunc,␊
855 FSGetFileBlock getBlockFunc,␊
856 FSGetUUID getUUIDFunc,␊
857 BVGetDescription getDescriptionFunc,␊
858 BVFree bvFreeFunc,␊
859 int probe,␊
860 int type,␊
861 unsigned int bvrFlags )␊
862{␊
863␉BVRef bvr = (BVRef)malloc(sizeof(*bvr));␊
864␉if ( bvr )␊
865␉{␊
866␉␉bzero(bvr, sizeof(*bvr));␊
867␊
868␉␉bvr->biosdev = biosdev;␊
869␉␉bvr->part_no = partno;␊
870␉␉bvr->part_boff = blkoff;␊
871␉␉bvr->fs_loadfile = loadFunc;␊
872␉␉bvr->fs_readfile = readFunc;␊
873␉␉bvr->fs_getdirentry = getdirFunc;␊
874␉␉bvr->fs_getfileblock = getBlockFunc;␊
875␉␉bvr->fs_getuuid = getUUIDFunc;␊
876␉␉bvr->description = getDescriptionFunc;␊
877␉␉bvr->type = type;␊
878␉␉bvr->bv_free = bvFreeFunc;␊
879␉␉// FIXME: UCS-2 -> UTF-8 the name␊
880␉␉strlcpy(bvr->name, "----", DPISTRLEN);␊
881␉␉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) )␊
882␉␉{␊
883␉␉␉strlcpy(bvr->type_name, "GPT HFS+", DPISTRLEN);␊
884␉␉}␊
885␉␉else␊
886␉␉{␊
887␉␉␉strlcpy(bvr->type_name, "GPT Unknown", DPISTRLEN);␊
888␉␉}␊
889␊
890␉␉/*␊
891␉␉if ( part->bootid & FDISK_ACTIVE )␊
892␉␉{␊
893␉␉␉bvr->flags |= kBVFlagPrimary;␊
894␉␉}␊
895␉␉*/␊
896␊
897␉␉// Probe the filesystem.␊
898␊
899␉␉if ( initFunc )␊
900␉␉{␊
901␉␉␉bvr->flags |= kBVFlagNativeBoot;␊
902␊
903␉␉␉if ( probe && initFunc( bvr ) != 0 )␊
904␉␉␉{␊
905␉␉␉␉// filesystem probe failed.␊
906␊
907␉␉␉␉DEBUG_DISK(("%s: failed probe on dev %x part %d\n", __FUNCTION__, biosdev, partno));␊
908␊
909␉␉␉␉(*bvr->bv_free)(bvr);␊
910␉␉␉␉bvr = NULL;␊
911␉␉␉}␊
912␉␉␉else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 )␊
913␉␉␉{␊
914␉␉␉␉bvr->flags |= kBVFlagBootable;␊
915␉␉␉}␊
916␉␉}␊
917␉␉else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 )␊
918␉␉{␊
919␉␉␉bvr->flags |= kBVFlagForeignBoot;␊
920␉␉}␊
921␉␉else␊
922␉␉{␊
923␉␉␉(*bvr->bv_free)(bvr);␊
924␉␉␉bvr = NULL;␊
925␉␉}␊
926␉}␊
927␊
928␉if ( bvr )␊
929␉{␊
930␉␉bvr->flags |= bvrFlags;␊
931␉}␊
932␊
933␉return bvr;␊
934}␊
935␊
936//==============================================================================␊
937␊
938/* A note on partition numbers:␊
939 * IOKit makes the primary partitions numbers 1-4, and then␊
940 * extended partitions are numbered consecutively 5 and up.␊
941 * So, for example, if you have two primary partitions and␊
942 * one extended partition they will be numbered 1, 2, 5.␊
943 */␊
944␊
945static BVRef diskScanFDiskBootVolumes( int biosdev, int *countPtr )␊
946{␊
947 const struct fdisk_part␉*part;␊
948 struct DiskBVMap␉␉*map;␊
949 int␉␉␉␉partno = -1;␊
950 BVRef␉␉␉bvr;␊
951#if UFS_SUPPORT␊
952 BVRef␉␉␉booterUFS = NULL;␊
953#endif␊
954 int␉␉␉␉spc;␊
955 struct driveInfo␉␉di;␊
956 boot_drive_info_t␉␉*dp;␊
957␊
958␉/* Initialize disk info */␊
959␊
960␉if (getDriveInfo(biosdev, &di) != 0)␊
961␉{␊
962␉␉return NULL;␊
963␉}␊
964␊
965␉dp = &di.di;␊
966␉spc = (dp->params.phys_spt * dp->params.phys_heads);␊
967␊
968␉if (spc == 0)␊
969␉{␊
970␉␉/* This is probably a CD-ROM; punt on the geometry. */␊
971␉␉spc = 1;␊
972␉}␊
973␊
974␉do␊
975␉{␊
976␉// Create a new mapping.␊
977␊
978␉map = (struct DiskBVMap *) malloc(sizeof(*map));␊
979␊
980␉if ( !map )␊
981␉{␊
982␉␉return NULL;␊
983␉}␊
984␊
985␉if ( map )␊
986 {␊
987␉␉map->biosdev = biosdev;␊
988␉␉map->bvr = NULL;␊
989␉␉map->bvrcnt = 0;␊
990␉␉map->next = gDiskBVMap;␊
991␉␉gDiskBVMap = map;␊
992␊
993␉␉// Create a record for each partition found on the disk.␊
994␊
995␉␉while ( getNextFDiskPartition( biosdev, &partno, &part ) )␊
996␉␉{␊
997␉␉␉DEBUG_DISK(("%s: part %d [%X]\n", __FUNCTION__, partno, part->systid));␊
998␉␉␉bvr = 0;␊
999␊
1000␉␉␉switch ( part->systid )␊
1001␉␉␉{␊
1002#if UFS_SUPPORT␊
1003␉␉␉␉case FDISK_UFS:␊
1004␉␉␉␉␉bvr = newFDiskBVRef(␊
1005␉␉␉␉␉␉biosdev, partno,␊
1006␉␉␉␉␉␉part->relsect + UFS_FRONT_PORCH/BPS,␊
1007␉␉␉␉␉␉part,␊
1008␉␉␉␉␉␉UFSInitPartition,␊
1009␉␉␉␉␉␉UFSLoadFile,␊
1010␉␉␉␉␉␉UFSReadFile,␊
1011␉␉␉␉␉␉UFSGetDirEntry,␊
1012␉␉␉␉␉␉UFSGetFileBlock,␊
1013␉␉␉␉␉␉UFSGetUUID,␊
1014␉␉␉␉␉␉UFSGetDescription,␊
1015␉␉␉␉␉␉UFSFree,␊
1016␉␉␉␉␉␉0,␊
1017␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1018␉␉␉␉␉break;␊
1019#endif␊
1020␊
1021␉␉␉␉case FDISK_HFS:␊
1022␉␉␉␉␉bvr = newFDiskBVRef(␊
1023␉␉␉␉␉␉biosdev, partno,␊
1024␉␉␉␉␉␉part->relsect,␊
1025␉␉␉␉␉␉part,␊
1026␉␉␉␉␉␉HFSInitPartition,␊
1027␉␉␉␉␉␉HFSLoadFile,␊
1028␉␉␉␉␉␉HFSReadFile,␊
1029␉␉␉␉␉␉HFSGetDirEntry,␊
1030␉␉␉␉␉␉HFSGetFileBlock,␊
1031␉␉␉␉␉␉HFSGetUUID,␊
1032␉␉␉␉␉␉HFSGetDescription,␊
1033␉␉␉␉␉␉HFSFree,␊
1034␉␉␉␉␉␉0,␊
1035␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1036␉␉␉␉␉break;␊
1037␊
1038␉␉␉␉// turbo - we want the booter type scanned also␊
1039␉␉␉␉case FDISK_BOOTER:␊
1040␉␉␉␉␉if (part->bootid & FDISK_ACTIVE)␊
1041␉␉␉␉␉{␊
1042␉␉␉␉␉␉gBIOSBootVolume = newFDiskBVRef(␊
1043␉␉␉␉␉␉␉biosdev, partno,␊
1044␉␉␉␉␉␉␉part->relsect,␊
1045␉␉␉␉␉␉␉part,␊
1046␉␉␉␉␉␉␉HFSInitPartition,␊
1047␉␉␉␉␉␉␉HFSLoadFile,␊
1048␉␉␉␉␉␉␉HFSReadFile,␊
1049␉␉␉␉␉␉␉HFSGetDirEntry,␊
1050␉␉␉␉␉␉␉HFSGetFileBlock,␊
1051␉␉␉␉␉␉␉HFSGetUUID,␊
1052␉␉␉␉␉␉␉HFSGetDescription,␊
1053␉␉␉␉␉␉␉HFSFree,␊
1054␉␉␉␉␉␉␉0,␊
1055␉␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1056␉␉␉␉␉}␊
1057␉␉␉␉␉break;␊
1058␊
1059#if UFS_SUPPORT␊
1060␉␉␉␉case FDISK_BOOTER:␊
1061␉␉␉␉␉booterUFS = newFDiskBVRef(␊
1062␉␉␉␉␉␉biosdev, partno,␊
1063␉␉␉␉␉␉((part->relsect + spc - 1) / spc) * spc,␊
1064␉␉␉␉␉␉part,␊
1065␉␉␉␉␉␉UFSInitPartition,␊
1066␉␉␉␉␉␉UFSLoadFile,␊
1067␉␉␉␉␉␉UFSReadFile,␊
1068␉␉␉␉␉␉UFSGetDirEntry,␊
1069␉␉␉␉␉␉UFSGetFileBlock,␊
1070␉␉␉␉␉␉UFSGetUUID,␊
1071␉␉␉␉␉␉UFSGetDescription,␊
1072␉␉␉␉␉␉UFSFree,␊
1073␉␉␉␉␉␉0,␊
1074␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1075␉␉␉␉␉break;␊
1076#endif␊
1077␊
1078␉␉␉␉case FDISK_FAT32:␊
1079␉␉␉␉case FDISK_DOS12:␊
1080␉␉␉␉case FDISK_DOS16S:␊
1081␉␉␉␉case FDISK_DOS16B:␊
1082␉␉␉␉case FDISK_SMALLFAT32:␊
1083␉␉␉␉case FDISK_DOS16SLBA:␊
1084␉␉␉␉␉bvr = newFDiskBVRef(␊
1085␉␉␉␉␉␉biosdev, partno,␊
1086␉␉␉␉␉␉part->relsect,␊
1087␉␉␉␉␉␉part,␊
1088␉␉␉␉␉␉MSDOSInitPartition,␊
1089␉␉␉␉␉␉MSDOSLoadFile,␊
1090␉␉␉␉␉␉MSDOSReadFile,␊
1091␉␉␉␉␉␉MSDOSGetDirEntry,␊
1092␉␉␉␉␉␉MSDOSGetFileBlock,␊
1093␉␉␉␉␉␉MSDOSGetUUID,␊
1094␉␉␉␉␉␉MSDOSGetDescription,␊
1095␉␉␉␉␉␉MSDOSFree,␊
1096␉␉␉␉␉␉0,␊
1097␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1098␉␉␉␉␉break;␊
1099␊
1100␉␉␉␉case FDISK_NTFS:␊
1101␉␉␉␉␉bvr = newFDiskBVRef(␊
1102␉␉␉␉␉␉biosdev, partno,␊
1103␉␉␉␉␉␉part->relsect,␊
1104␉␉␉␉␉␉part,␊
1105␉␉␉␉␉␉0, 0, 0, 0, 0,␊
1106␉␉␉␉␉␉NTFSGetUUID,␊
1107␉␉␉␉␉␉NTFSGetDescription,␊
1108␉␉␉␉␉␉(BVFree)free,␊
1109␉␉␉␉␉␉0,␊
1110␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1111␉␉␉␉␉break;␊
1112␊
1113␉␉␉␉case FDISK_LINUX:␊
1114␉␉␉␉␉bvr = newFDiskBVRef(␊
1115␉␉␉␉␉␉biosdev, partno,␊
1116␉␉␉␉␉␉part->relsect,␊
1117␉␉␉␉␉␉part,␊
1118␉␉␉␉␉␉0, 0, 0, 0, 0,␊
1119␉␉␉␉␉␉EX2GetUUID,␊
1120␉␉␉␉␉␉EX2GetDescription,␊
1121␉␉␉␉␉␉(BVFree)free,␊
1122␉␉␉␉␉␉0,␊
1123␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1124␉␉␉␉␉break;␊
1125␊
1126␉␉␉␉case FDISK_BEFS:␊
1127␉␉␉␉␉bvr = newFDiskBVRef(␊
1128␉␉␉␉␉␉biosdev, partno,␊
1129␉␉␉␉␉␉part->relsect,␊
1130␉␉␉␉␉␉part,␊
1131␉␉␉␉␉␉0, 0, 0, 0, 0, 0,␊
1132␉␉␉␉␉␉BeFSGetDescription,␊
1133␉␉␉␉␉␉(BVFree)free,␊
1134␉␉␉␉␉␉0,␊
1135␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1136␉␉␉␉␉break;␊
1137␊
1138␉␉␉␉case FDISK_FREEBSD:␊
1139␉␉␉␉␉bvr = newFDiskBVRef(␊
1140␉␉␉␉␉␉biosdev, partno,␊
1141␉␉␉␉␉␉part->relsect,␊
1142␉␉␉␉␉␉part,␊
1143␉␉␉␉␉␉0, 0, 0, 0, 0, 0,␊
1144␉␉␉␉␉␉FreeBSDGetDescription,␊
1145␉␉␉␉␉␉(BVFree)free,␊
1146␉␉␉␉␉␉0,␊
1147␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1148␉␉␉␉␉break;␊
1149␊
1150␉␉␉␉case FDISK_OPENBSD:␊
1151␉␉␉␉␉bvr = newFDiskBVRef(␊
1152␉␉␉␉␉␉biosdev, partno,␊
1153␉␉␉␉␉␉part->relsect,␊
1154␉␉␉␉␉␉part,␊
1155␉␉␉␉␉␉0, 0, 0, 0, 0, 0,␊
1156␉␉␉␉␉␉OpenBSDGetDescription,␊
1157␉␉␉␉␉␉(BVFree)free,␊
1158␉␉␉␉␉␉0,␊
1159␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1160␉␉␉␉␉break;␊
1161␊
1162␉␉␉␉default:␊
1163␉␉␉␉␉bvr = newFDiskBVRef(␊
1164␉␉␉␉␉␉biosdev, partno,␊
1165␉␉␉␉␉␉part->relsect,␊
1166␉␉␉␉␉␉part,␊
1167␉␉␉␉␉␉0, 0, 0, 0, 0, 0, 0,␊
1168␉␉␉␉␉␉(BVFree)free,␊
1169␉␉␉␉␉␉0,␊
1170␉␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1171␉␉␉␉␉break;␊
1172␉␉␉}␊
1173␊
1174␉␉␉if ( bvr )␊
1175␉␉␉{␊
1176␉␉␉␉bvr->next = map->bvr;␊
1177␉␉␉␉map->bvr = bvr;␊
1178␉␉␉␉map->bvrcnt++;␊
1179␉␉␉}␊
1180␉␉}␊
1181␊
1182#if UFS_SUPPORT␊
1183␉␉// Booting from a CD with an UFS filesystem embedded␊
1184␉␉// in a booter partition.␊
1185␊
1186␉␉␉if ( booterUFS )␊
1187␉␉␉{␊
1188␉␉␉␉if ( map->bvrcnt == 0 )␊
1189␉␉␉␉{␊
1190␉␉␉␉␉map->bvr = booterUFS;␊
1191␉␉␉␉␉map->bvrcnt++;␊
1192␉␉␉␉}␊
1193␉␉␉␉else␊
1194␉␉␉␉{␊
1195␉␉␉␉␉free( booterUFS );␊
1196␉␉␉␉}␊
1197␉␉␉}␊
1198#endif␊
1199␉␉}␊
1200␉} while (0);␊
1201␊
1202#if UNUSED␊
1203␉/*␊
1204␉ * If no FDisk partition, then we will check for␊
1205␉ * an Apple partition map elsewhere.␊
1206␉ */␊
1207␉if (map && map->bvrcnt == 0)␊
1208␉{␊
1209␉␉static struct fdisk_part cdpart;␊
1210␉␉cdpart.systid = 0xCD;␊
1211␊
1212␉␉/* Let's try assuming we are on a hybrid HFS/ISO9660 CD. */␊
1213␉␉bvr = newFDiskBVRef(␊
1214␉␉␉biosdev, 0,␊
1215␉␉␉0,␊
1216␉␉␉&cdpart,␊
1217␉␉␉HFSInitPartition,␊
1218␉␉␉HFSLoadFile,␊
1219␉␉␉HFSReadFile,␊
1220␉␉␉HFSGetDirEntry,␊
1221␉␉␉HFSGetFileBlock,␊
1222␉␉␉HFSGetUUID,␊
1223␉␉␉HFSGetDescription,␊
1224␉␉␉HFSFree,␊
1225␉␉␉0,␊
1226␉␉␉kBIOSDevTypeHardDrive, 0);␊
1227␉␉bvr->next = map->bvr;␊
1228␉␉map->bvr = bvr;␊
1229␉␉map->bvrcnt++;␊
1230␉}␊
1231#endif␊
1232␉// Actually this should always be true given the above code␊
1233␉// (unless malloc failed above)␊
1234␉if(map && (map == gDiskBVMap))␊
1235␉{␊
1236␉␉// Don't leave a null map in the chain␊
1237␉␉if((map->bvrcnt == 0) && (map->bvr == NULL))␊
1238␉␉{␊
1239␉␉␉gDiskBVMap = map->next;␊
1240␉␉␉free(map);␊
1241␉␉␉map = NULL;␊
1242␉␉}␊
1243␉}␊
1244␊
1245␉if (countPtr) *countPtr = map ? map->bvrcnt : 0;␊
1246␊
1247␉return map ? map->bvr : NULL;␊
1248}␊
1249␊
1250//==============================================================================␊
1251␊
1252static BVRef diskScanAPMBootVolumes( int biosdev, int * countPtr )␊
1253{␊
1254␉struct DiskBVMap␉*map;␊
1255␉struct Block0␉␉*block0_p;␊
1256␉unsigned int␉␉blksize;␊
1257␉unsigned int␉␉factor;␊
1258␉void␉*buffer = malloc(BPS);␊
1259␊
1260␉if (!buffer)␊
1261␉{␊
1262␉␉return NULL;␊
1263␉}␊
1264␊
1265␉bzero(buffer,BPS);␊
1266␊
1267␉/* Check for alternate block size */␊
1268␉if (readBytes( biosdev, 0, 0, BPS, buffer ) != 0)␊
1269␉{␊
1270␉␉return NULL;␊
1271␉}␊
1272␊
1273␉block0_p = buffer;␊
1274␉if (OSSwapBigToHostInt16(block0_p->sbSig) == BLOCK0_SIGNATURE)␊
1275␉{␊
1276␉␉blksize = OSSwapBigToHostInt16(block0_p->sbBlkSize);␊
1277␉␉if (blksize != BPS)␊
1278␉␉{␊
1279␉␉␉free(buffer);␊
1280␉␉␉buffer = malloc(blksize);␊
1281␉␉␉if (!buffer)␊
1282␉␉␉{␊
1283␉␉␉␉return NULL;␊
1284␉␉␉}␊
1285␉␉␉bzero(buffer,BPS);␊
1286␉␉}␊
1287␉␉factor = blksize / BPS;␊
1288␉}␊
1289␉else␊
1290␉{␊
1291␉␉blksize = BPS;␊
1292␉␉factor = 1;␊
1293␉}␊
1294␊
1295␉do␊
1296␉{␊
1297␉␉// Create a new mapping.␊
1298␊
1299␉␉map = (struct DiskBVMap *) malloc( sizeof(*map) );␊
1300␉␉if ( map )␊
1301␉␉{␊
1302␉␉␉int error;␊
1303␉␉␉DPME *dpme_p = (DPME *)buffer;␊
1304␉␉␉UInt32 i, npart = UINT_MAX;␊
1305␉␉␉BVRef bvr;␊
1306␊
1307␉␉␉map->biosdev = biosdev;␊
1308␉␉␉map->bvr = NULL;␊
1309␉␉␉map->bvrcnt = 0;␊
1310␉␉␉map->next = gDiskBVMap;␊
1311␉␉␉gDiskBVMap = map;␊
1312␊
1313␉␉␉for (i = 0; i < npart; i++)␊
1314␉␉␉{␊
1315␉␉␉␉error = readBytes( biosdev, (kAPMSector + i) * factor, 0, blksize, buffer );␊
1316␊
1317␉␉␉␉if (error || OSSwapBigToHostInt16(dpme_p->dpme_signature) != DPME_SIGNATURE)␊
1318␉␉␉␉{␊
1319␉␉␉␉␉break;␊
1320␉␉␉␉}␊
1321␊
1322␉␉␉␉if (i == 0)␊
1323␉␉␉␉{␊
1324␉␉␉␉␉npart = OSSwapBigToHostInt32(dpme_p->dpme_map_entries);␊
1325␉␉␉␉}␊
1326␉␉␉␉/*␊
1327␉␉␉␉printf("name = %s, %s%s %d -> %d [%d -> %d] {%d}\n",␊
1328␉␉␉␉dpme.dpme_name, dpme.dpme_type, (dpme.dpme_flags & DPME_FLAGS_BOOTABLE) ? "(bootable)" : "",␊
1329␉␉␉␉dpme.dpme_pblock_start, dpme.dpme_pblocks,␊
1330␉␉␉␉dpme.dpme_lblock_start, dpme.dpme_lblocks,␊
1331␉␉␉␉dpme.dpme_boot_block);␊
1332␉␉␉␉*/␊
1333␊
1334␉␉␉␉if (strncmp(dpme_p->dpme_type, "Apple_HFS", sizeof("Apple_HFS")) == 0)␊
1335␉␉␉␉{␊
1336␉␉␉␉␉bvr = newAPMBVRef(biosdev,␊
1337␉␉␉␉␉i,␊
1338␉␉␉␉␉OSSwapBigToHostInt32(dpme_p->dpme_pblock_start) * factor,␊
1339␉␉␉␉␉dpme_p,␊
1340␉␉␉␉␉HFSInitPartition,␊
1341␉␉␉␉␉HFSLoadFile,␊
1342␉␉␉␉␉HFSReadFile,␊
1343␉␉␉␉␉HFSGetDirEntry,␊
1344␉␉␉␉␉HFSGetFileBlock,␊
1345␉␉␉␉␉HFSGetUUID,␊
1346␉␉␉␉␉HFSGetDescription,␊
1347␉␉␉␉␉HFSFree,␊
1348␉␉␉␉␉0,␊
1349␉␉␉␉␉kBIOSDevTypeHardDrive, 0);␊
1350␉␉␉␉␉bvr->next = map->bvr;␊
1351␉␉␉␉␉map->bvr = bvr;␊
1352␉␉␉␉␉map->bvrcnt++;␊
1353␉␉␉␉}␊
1354␉␉␉}␊
1355␉␉}␊
1356␉} while (0);␊
1357␊
1358␉if (buffer)␊
1359␉{␊
1360␉␉free(buffer);␊
1361␉}␊
1362␊
1363␉if (countPtr)␊
1364␉{␊
1365␉␉*countPtr = map ? map->bvrcnt : 0;␊
1366␉}␊
1367␊
1368␉return map ? map->bvr : NULL;␊
1369}␊
1370␊
1371//==============================================================================␊
1372␊
1373static bool isPartitionUsed(gpt_ent * partition)␊
1374{␊
1375␊
1376␉// Ask whether the given partition is used.␊
1377␊
1378␉return efi_guid_is_null((EFI_GUID const*)partition->ent_type) ? false : true;␊
1379}␊
1380␊
1381//==============================================================================␊
1382␊
1383static BVRef diskScanGPTBootVolumes(int biosdev, int * countPtr)␊
1384{␊
1385␉struct DiskBVMap *map = NULL;␊
1386␊
1387␉void *buffer = malloc(BPS);␊
1388␊
1389␉int error;␊
1390␊
1391␉if ((error = readBytes( biosdev, /*secno*/0, 0, BPS, buffer )) != 0)␊
1392␉{␊
1393␉␉verbose("Failed to read boot sector from BIOS device %02xh. Error=%d\n", biosdev, error);␊
1394␉␉goto scanErr;␊
1395␉}␊
1396␉struct REAL_disk_blk0 *fdiskMap = buffer;␊
1397␉if ( OSSwapLittleToHostInt16(fdiskMap->signature) != DISK_SIGNATURE )␊
1398␉{␊
1399␉␉verbose("Failed to find boot signature on BIOS device %02xh\n", biosdev);␊
1400␉␉goto scanErr;␊
1401␉}␊
1402␊
1403␉int fdiskID = 0;␊
1404␉unsigned index;␊
1405␉for ( index = 0; index < FDISK_NPART; index++ )␊
1406␉{␊
1407␉␉if ( fdiskMap->parts[index].systid )␊
1408␉␉{␊
1409␉␉␉if ( fdiskMap->parts[index].systid == 0xEE )␊
1410␉␉␉{␊
1411␉␉␉␉// Fail if two 0xEE partitions are present which␊
1412␉␉␉␉// means the FDISK code will wind up parsing it.␊
1413␉␉␉␉if ( fdiskID )␊
1414␉␉␉␉{␊
1415␉␉␉␉␉goto scanErr;␊
1416␉␉␉␉}␊
1417␊
1418␉␉␉␉fdiskID = index + 1;␊
1419␉␉␉}␊
1420␉␉}␊
1421␉}␊
1422␊
1423␉if ( fdiskID == 0 )␊
1424␉{␊
1425␉␉goto scanErr;␊
1426␉}␊
1427␊
1428␉verbose("Attempting to read GPT\n");␊
1429␊
1430␉if(readBytes(biosdev, 1, 0, BPS, buffer) != 0)␊
1431␉{␊
1432␉␉goto scanErr;␊
1433␉}␊
1434␊
1435␉gpt_hdr *headerMap = buffer;␊
1436␊
1437␉// Determine whether the partition header signature is present.␊
1438␊
1439␉if ( memcmp(headerMap->hdr_sig, GPT_HDR_SIG, strlen(GPT_HDR_SIG)) )␊
1440␉{␊
1441␉␉goto scanErr;␊
1442␉}␊
1443␊
1444␉// Determine whether the partition header size is valid.␊
1445␊
1446␉UInt32 headerCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_self);␊
1447␉UInt32 headerSize = OSSwapLittleToHostInt32(headerMap->hdr_size);␊
1448␊
1449␉if (headerSize < offsetof(gpt_hdr, padding))␊
1450␉{␊
1451␉␉goto scanErr;␊
1452␉}␊
1453␊
1454␉if ( headerSize > BPS )␊
1455␉{␊
1456␉␉goto scanErr;␊
1457␉}␊
1458␊
1459␉// Determine whether the partition header checksum is valid.␊
1460␊
1461␉headerMap->hdr_crc_self = 0;␊
1462␊
1463␉if ( crc32(0, headerMap, headerSize) != headerCheck )␊
1464␉{␊
1465␉␉goto scanErr;␊
1466␉}␊
1467␊
1468␉// Determine whether the partition entry size is valid.␊
1469␊
1470␉UInt64␉␉gptBlock␉= 0;␊
1471␉UInt32␉␉gptCheck␉= 0;␊
1472␉UInt32␉␉gptCount␉= 0;␊
1473␉UInt32␉␉gptID␉␉= 0;␊
1474␉gpt_ent␉␉*gptMap␉␉= 0;␊
1475␉UInt32␉␉gptSize␉␉= 0;␊
1476␊
1477␉gptBlock = OSSwapLittleToHostInt64(headerMap->hdr_lba_table);␊
1478␉gptCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_table);␊
1479␉gptCount = OSSwapLittleToHostInt32(headerMap->hdr_entries);␊
1480␉gptSize = OSSwapLittleToHostInt32(headerMap->hdr_entsz);␊
1481␊
1482␉if ( gptSize < sizeof(gpt_ent) )␊
1483␉{␊
1484␉␉goto scanErr;␊
1485␉}␊
1486␊
1487␉// Allocate a buffer large enough to hold one map, rounded to a media block.␊
1488␉free(buffer);␊
1489␉buffer = NULL;␊
1490␊
1491␉UInt32 bufferSize = IORound(gptCount * gptSize, BPS);␊
1492␉if (bufferSize == 0)␊
1493␉{␊
1494␉␉goto scanErr;␊
1495␉}␊
1496␉buffer = malloc(bufferSize);␊
1497␉if (!buffer)␊
1498␉{␊
1499 ␉goto scanErr;␊
1500␉}␊
1501␊
1502␉bzero(buffer,bufferSize);␊
1503␊
1504␉if (readBytes(biosdev, gptBlock, 0, bufferSize, buffer) != 0)␊
1505␉{␊
1506␉␉goto scanErr;␊
1507␉}␊
1508␉verbose("Read GPT\n");␊
1509␊
1510␉// Allocate a new map for this BIOS device and insert it into the chain␊
1511␉map = malloc(sizeof(*map));␊
1512␉if (!map)␊
1513␉{␊
1514␉␉goto scanErr;␊
1515␉}␊
1516␉map->biosdev = biosdev;␊
1517␉map->bvr = NULL;␊
1518␉map->bvrcnt = 0;␊
1519␉map->next = gDiskBVMap;␊
1520␉gDiskBVMap = map;␊
1521␊
1522␉// fdisk like partition type id.␊
1523␉int fsType = 0;␊
1524␊
1525␉for(gptID = 1; gptID <= gptCount; ++gptID)␊
1526␉{␊
1527␉␉BVRef bvr = NULL;␊
1528␉␉unsigned int bvrFlags = 0;␊
1529␊
1530␉␉// size on disk can be larger than sizeof(gpt_ent)␊
1531␉␉gptMap = (gpt_ent *)(buffer + ((gptID - 1) * gptSize));␊
1532␊
1533␉␉// NOTE: EFI_GUID's are in LE and we know we're on an x86.␊
1534␉␉// The IOGUIDPartitionScheme.cpp code uses byte-based UUIDs, we don't.␊
1535␊
1536␉␉if (isPartitionUsed(gptMap))␊
1537␉␉{␊
1538␉␉␉char stringuuid[100];␊
1539␉␉␉efi_guid_unparse_upper((EFI_GUID*)gptMap->ent_type, stringuuid);␊
1540␉␉␉verbose("Reading GPT partition %d, type %s\n", gptID, stringuuid);␊
1541␊
1542␉␉␉// Getting fdisk like partition type.␊
1543␉␉␉fsType = probeFileSystem(biosdev, gptMap->ent_lba_start);␊
1544␊
1545␉␉␉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) )␊
1546␉␉␉{␊
1547␉␉␉␉bvrFlags = (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ? kBVFlagBooter : 0;␊
1548␉␉␉␉bvr = newGPTBVRef(biosdev,␊
1549␉␉␉␉gptID,␊
1550␉␉␉␉gptMap->ent_lba_start,␊
1551␉␉␉␉gptMap,␊
1552␉␉␉␉HFSInitPartition,␊
1553␉␉␉␉HFSLoadFile,␊
1554␉␉␉␉HFSReadFile,␊
1555␉␉␉␉HFSGetDirEntry,␊
1556␉␉␉␉HFSGetFileBlock,␊
1557␉␉␉␉HFSGetUUID,␊
1558␉␉␉␉HFSGetDescription,␊
1559␉␉␉␉HFSFree,␊
1560␉␉␉␉0,␊
1561␉␉␉␉kBIOSDevTypeHardDrive, bvrFlags);␊
1562␉␉␉}␊
1563␊
1564␉␉␉// zef - foreign OS support␊
1565␉␉␉if ((efi_guid_compare(&GPT_BASICDATA_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ||␊
1566␉␉␉␉(efi_guid_compare(&GPT_BASICDATA2_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) )␊
1567␉␉␉{␊
1568␉␉␉␉switch (fsType)␊
1569␉␉␉␉{␊
1570␉␉␉␉␉case FDISK_NTFS:␊
1571␉␉␉␉␉␉bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,␊
1572␉␉␉␉␉␉0, 0, 0, 0, 0, NTFSGetUUID, NTFSGetDescription,␊
1573␉␉␉␉␉␉(BVFree)free, 0, kBIOSDevTypeHardDrive, 0);␊
1574␉␉␉␉␉␉break;␊
1575␊
1576␉␉␉␉␉case FDISK_LINUX:␊
1577␉␉␉␉␉␉bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,␊
1578␉␉␉␉␉␉0, 0, 0, 0, 0, EX2GetUUID, EX2GetDescription,␊
1579␉␉␉␉␉␉(BVFree)free, 0, kBIOSDevTypeHardDrive, 0);␊
1580␉␉␉␉␉␉break;␊
1581␊
1582␉␉␉␉␉case FDISK_FAT32:␊
1583␉␉␉␉␉case FDISK_DOS12:␊
1584␉␉␉␉␉case FDISK_DOS16B:␊
1585␉␉␉␉␉␉bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,␊
1586␉␉␉␉␉␉␉␉MSDOSInitPartition,␊
1587␉␉␉␉␉␉␉␉MSDOSLoadFile,␊
1588␉␉␉␉␉␉␉␉MSDOSReadFile,␊
1589␉␉␉␉␉␉␉␉MSDOSGetDirEntry,␊
1590␉␉␉␉␉␉␉␉MSDOSGetFileBlock,␊
1591␉␉␉␉␉␉␉␉MSDOSGetUUID,␊
1592␉␉␉␉␉␉␉␉MSDOSGetDescription,␊
1593␉␉␉␉␉␉␉␉MSDOSFree,␊
1594␉␉␉␉␉␉␉␉0, kBIOSDevTypeHardDrive, 0);␊
1595␉␉␉␉␉␉break;␊
1596␊
1597␉␉␉␉␉case FDISK_PSEUDO_EXFAT:␊
1598␉␉␉␉␉␉bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,␊
1599␉␉␉␉␉␉␉␉␉␉ EXFATInitPartition,␊
1600␉␉␉␉␉␉␉␉␉␉ EXFATLoadFile,␊
1601␉␉␉␉␉␉␉␉␉␉ EXFATReadFile,␊
1602␉␉␉␉␉␉␉␉␉␉ EXFATGetDirEntry,␊
1603␉␉␉␉␉␉␉␉␉␉ EXFATGetFileBlock,␊
1604␉␉␉␉␉␉␉␉␉␉ EXFATGetUUID,␊
1605␉␉␉␉␉␉␉␉␉␉ EXFATGetDescription,␊
1606␉␉␉␉␉␉␉␉␉␉ EXFATFree,␊
1607␉␉␉␉␉␉␉␉␉␉ 0, kBIOSDevTypeHardDrive, 0);␊
1608␉␉␉␉␉␉break;␊
1609␊
1610␉␉␉␉␉default:␊
1611␉␉␉␉␉␉bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,␊
1612␉␉␉␉␉␉0, 0, 0, 0, 0, 0, 0,␊
1613␉␉␉␉␉␉(BVFree)free, 0, kBIOSDevTypeHardDrive, 0);␊
1614␉␉␉␉␉␉break;␊
1615␉␉␉␉}␊
1616␊
1617␉␉␉}␊
1618␊
1619␉␉␉// turbo - save our booter partition␊
1620␉␉␉// zef - only on original boot device␊
1621␉␉␉if ( (efi_guid_compare(&GPT_EFISYS_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ) {␊
1622␉␉␉␉switch (fsType) {␊
1623␉␉␉␉␉case FDISK_HFS:␊
1624␉␉␉␉␉if (readBootSector( biosdev, gptMap->ent_lba_start, (void *)0x7e00 ) == 0) {␊
1625␉␉␉␉␉␉bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,␊
1626␉␉␉␉␉␉HFSInitPartition,␊
1627␉␉␉␉␉␉HFSLoadFile,␊
1628␉␉␉␉␉␉HFSReadFile,␊
1629␉␉␉␉␉␉HFSGetDirEntry,␊
1630␉␉␉␉␉␉HFSGetFileBlock,␊
1631␉␉␉␉␉␉HFSGetUUID,␊
1632␉␉␉␉␉␉HFSGetDescription,␊
1633␉␉␉␉␉␉HFSFree,␊
1634␉␉␉␉␉␉0, kBIOSDevTypeHardDrive, kBVFlagEFISystem);␊
1635␉␉␉␉␉}␊
1636␉␉␉␉␉break;␊
1637␊
1638␉␉␉␉␉case FDISK_FAT32:␊
1639␉␉␉␉␉if (testFAT32EFIBootSector( biosdev, gptMap->ent_lba_start, (void *)0x7e00 ) == 0) {␊
1640␉␉␉␉␉␉bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,␊
1641␉␉␉␉␉␉MSDOSInitPartition,␊
1642␉␉␉␉␉␉MSDOSLoadFile,␊
1643␉␉␉␉␉␉MSDOSReadFile,␊
1644␉␉␉␉␉␉MSDOSGetDirEntry,␊
1645␉␉␉␉␉␉MSDOSGetFileBlock,␊
1646␉␉␉␉␉␉MSDOSGetUUID,␊
1647␉␉␉␉␉␉MSDOSGetDescription,␊
1648␉␉␉␉␉␉MSDOSFree,␊
1649␉␉␉␉␉␉0, kBIOSDevTypeHardDrive, kBVFlagEFISystem);␊
1650␉␉␉␉␉}␊
1651␉␉␉␉␉break;␊
1652␊
1653␉␉␉␉␉default:␊
1654␉␉␉␉␉if (biosdev == gBIOSDev)␊
1655␉␉␉␉␉{␊
1656␉␉␉␉␉␉gBIOSBootVolume = bvr;␊
1657␉␉␉␉␉}␊
1658␉␉␉␉␉break;␊
1659␉␉␉␉}␊
1660␉␉␉}␊
1661␊
1662␉␉␉if (bvr)␊
1663␉␉␉{␊
1664␉␉␉␉// Fixup bvr with the fake fdisk partition type.␊
1665␉␉␉␉if (fsType > 0) {␊
1666␉␉␉␉␉bvr->part_type = fsType;␊
1667␉␉␉␉}␊
1668␊
1669␉␉␉␉bvr->next = map->bvr;␊
1670␉␉␉␉map->bvr = bvr;␊
1671␉␉␉␉++map->bvrcnt;␊
1672␉␉␉}␊
1673␊
1674␉␉}␊
1675␉}␊
1676␊
1677␉scanErr:␊
1678␉if (buffer)␊
1679␉{␊
1680␉␉free(buffer);␊
1681␉}␊
1682␊
1683␉if(map)␊
1684␉{␊
1685␉␉if(countPtr) *countPtr = map->bvrcnt;␊
1686␉␉{␊
1687␉␉␉return map->bvr;␊
1688␉␉}␊
1689␊
1690␉}␊
1691␉else␊
1692␉{␊
1693␉␉if(countPtr) *countPtr = 0;␊
1694␉␉{␊
1695␉␉␉return NULL;␊
1696␉␉}␊
1697␉}␊
1698}␊
1699␊
1700//==============================================================================␊
1701␊
1702static bool getOSVersion(BVRef bvr, char *str)␊
1703{␊
1704␉bool valid = false;␉␊
1705␉config_file_t systemVersion;␊
1706␉char dirSpec[512];␊
1707␊
1708␉/*␊
1709␉ * Only look for OS Version on HFS+␊
1710␉ */␊
1711␉if (bvr->fs_readfile != HFSReadFile)␊
1712␉{␊
1713␉␉return valid;␊
1714␉}␊
1715␊
1716␉// OS X Recovery␊
1717␉sprintf(dirSpec, "hd(%d,%d)/com.apple.recovery.boot/SystemVersion.plist", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
1718␊
1719␉if (!loadConfigFile(dirSpec, &systemVersion))␊
1720␉{␊
1721␉␉bvr->OSisInstaller = true;␊
1722␉␉valid = true;␊
1723␉}␊
1724␊
1725␉if (!valid)␊
1726␉{␊
1727␉␉// OS X Standard␊
1728␉␉snprintf(dirSpec, sizeof(dirSpec), "hd(%d,%d)/System/Library/CoreServices/SystemVersion.plist", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
1729␊
1730␉␉if (!loadConfigFile(dirSpec, &systemVersion))␊
1731␉␉{␊
1732␉␉␉bvr->OSisInstaller = true;␊
1733␉␉␉valid = true;␊
1734␉␉}␊
1735␉␉else␊
1736␉␉{␊
1737␉␉␉// OS X Server␊
1738␉␉␉snprintf(dirSpec, sizeof(dirSpec), "hd(%d,%d)/System/Library/CoreServices/ServerVersion.plist", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
1739␊
1740␉␉␉if (!loadConfigFile(dirSpec, &systemVersion))␊
1741␉␉␉{␊
1742␉␉␉␉bvr->OSisServer = true;␊
1743␉␉␉␉valid = true;␊
1744␉␉␉}␊
1745/*␉␉␉else␊
1746␉␉␉{␊
1747␉␉␉␉snprintf(dirSpec, sizeof(dirSpec), "hd(%d,%d)/.IAProductInfo", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
1748␊
1749␉␉␉␉if (!loadConfigFile(dirSpec, &systemVersion))␊
1750␉␉␉␉{␊
1751␊
1752␉␉␉␉}␊
1753␉␉␉}␊
1754*/␊
1755␉␉}␊
1756␉}␊
1757␊
1758␉if (valid)␊
1759␉{␊
1760␉␉const char *val;␊
1761␉␉int len;␊
1762␊
1763␉␉if (getValueForKey(kProductVersion, &val, &len, &systemVersion))␊
1764␉␉{␊
1765␉␉␉// getValueForKey uses const char for val␊
1766␉␉␉// so copy it and trim␊
1767␉␉␉*str = '\0';␊
1768␉␉␉strncat(str, val, MIN(len, 5));␊
1769␉␉␉if(str[4] == '.')␊
1770␉␉␉{␊
1771␉␉␉␉str[4] = '\0';␊
1772␉␉␉}␊
1773␉␉}␊
1774␉␉else␊
1775␉␉{␊
1776␉␉␉valid = false;␊
1777␉␉}␊
1778␉}␊
1779␊
1780␉if(!valid)␊
1781␉{␊
1782␉␉int fh = -1;␊
1783␉␉snprintf(dirSpec, sizeof(dirSpec), "hd(%d,%d)/.PhysicalMediaInstall", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
1784␉␉fh = open(dirSpec, 0);␊
1785␊
1786␉␉if (fh >= 0)␊
1787␉␉{␊
1788␉␉␉valid = true;␊
1789␉␉␉bvr->OSisInstaller = true;␊
1790␉␉␉strcpy(bvr->OSVersion, "10.7"); // 10.7 +␊
1791␉␉␉close(fh);␊
1792␉␉}␊
1793␉␉else␊
1794␉␉{␊
1795␉␉␉snprintf(dirSpec, sizeof(dirSpec), "hd(%d,%d)/.IAPhysicalMedia", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
1796␉␉␉fh = open(dirSpec, 0);␊
1797␊
1798␉␉␉if (fh >= 0)␊
1799␉␉␉{␊
1800␉␉␉␉valid = true;␊
1801␉␉␉␉bvr->OSisInstaller = true;␊
1802␉␉␉␉strcpy(bvr->OSVersion, "10.9"); // 10.9 +␊
1803␉␉␉}␊
1804␉␉␉else␊
1805␉␉␉{␊
1806␉␉␉␉close(fh);␊
1807␉␉␉}␊
1808␉␉}␊
1809␉}␊
1810␉return valid;␊
1811}␊
1812␊
1813//==============================================================================␊
1814␊
1815static void scanFSLevelBVRSettings(BVRef chain)␊
1816{␊
1817␉BVRef bvr;␊
1818␉char dirSpec[512], fileSpec[512];␊
1819␉char label[BVSTRLEN];␊
1820␉int ret;␊
1821␉long flags;␊
1822␉u_int32_t time;␊
1823␉int fh, fileSize, error;␊
1824␊
1825␉for (bvr = chain; bvr; bvr = bvr->next)␊
1826␉{␊
1827␉␉ret = -1;␊
1828␉␉error = 0;␊
1829␊
1830␉␉//␊
1831␉␉// Check for alternate volume label on boot helper partitions.␊
1832␉␉//␊
1833␉␉if (bvr->flags & kBVFlagBooter)␊
1834␉␉{␊
1835␉␉␉snprintf(dirSpec, sizeof(dirSpec), "hd(%d,%d)/System/Library/CoreServices/", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
1836␉␉␉strlcpy(fileSpec, ".disk_label.contentDetails", sizeof(fileSpec));␊
1837␉␉␉ret = GetFileInfo(dirSpec, fileSpec, &flags, &time);␊
1838␉␉␉if (!ret)␊
1839␉␉␉{␊
1840␉␉␉␉strlcat(dirSpec, fileSpec, sizeof(dirSpec));␊
1841␉␉␉␉fh = open(dirSpec,0);␊
1842␊
1843␉␉␉␉fileSize = file_size(fh);␊
1844␉␉␉␉if (fileSize > 0 && fileSize < BVSTRLEN)␊
1845␉␉␉␉{␊
1846␉␉␉␉␉if (read(fh, label, fileSize) != fileSize)␊
1847␉␉␉␉␉{␊
1848␉␉␉␉␉␉error = -1;␊
1849␉␉␉␉␉}␊
1850␉␉␉␉}␊
1851␉␉␉␉else␊
1852␉␉␉␉{␊
1853␉␉␉␉␉error = -1;␊
1854␉␉␉␉}␊
1855␊
1856␉␉␉␉close(fh);␊
1857␊
1858␉␉␉␉if (!error)␊
1859␉␉␉␉{␊
1860␉␉␉␉␉label[fileSize] = '\0';␊
1861␉␉␉␉␉strlcpy(bvr->altlabel, label, sizeof(bvr->altlabel));␊
1862␉␉␉␉}␊
1863␉␉␉}␊
1864␉␉}␊
1865␊
1866␉␉// Check for SystemVersion.plist or ServerVersion.plist to determine if a volume hosts an installed system.␊
1867␊
1868␉␉if (bvr->flags & kBVFlagNativeBoot)␊
1869␉␉{␊
1870␉␉␉if (getOSVersion(bvr, bvr->OSVersion) == true)␊
1871␉␉␉{␊
1872␉␉␉␉bvr->flags |= kBVFlagSystemVolume;␊
1873␉␉␉}␊
1874␉␉}␊
1875␊
1876␉}␊
1877}␊
1878␊
1879//==============================================================================␊
1880␊
1881void rescanBIOSDevice(int biosdev)␊
1882{␊
1883␉struct DiskBVMap *oldMap = diskResetBootVolumes(biosdev);␊
1884␉if (oldMap == NULL)␊
1885␉{␊
1886␉␉return;␊
1887␉}␊
1888␊
1889␉CacheReset();␊
1890␉diskFreeMap(oldMap);␊
1891␉oldMap = NULL;␊
1892␉scanBootVolumes(biosdev, 0);␊
1893}␊
1894␊
1895//==============================================================================␊
1896␊
1897struct DiskBVMap* diskResetBootVolumes(int biosdev)␊
1898{␊
1899␉struct DiskBVMap * map;␊
1900␉struct DiskBVMap *prevMap = NULL;␊
1901␉for ( map = gDiskBVMap; map; prevMap = map, map = map->next ) {␊
1902␉␉if ( biosdev == map->biosdev ) {␊
1903␉␉␉break;␊
1904␉␉}␊
1905␉}␊
1906␊
1907␉if(map != NULL) {␊
1908␉␉verbose("Resetting BIOS device %xh\n", biosdev);␊
1909␉␉// Reset the biosbuf cache␊
1910␉␉cache_valid = false;␊
1911␉␉if(map == gDiskBVMap)␊
1912␉␉{␊
1913␉␉␉gDiskBVMap = map->next;␊
1914␉␉}␊
1915␉␉else if(prevMap != NULL)␊
1916␉␉{␊
1917␉␉␉prevMap->next = map->next;␊
1918␉␉}␊
1919␉␉else␊
1920␉␉{␊
1921␉␉␉stop("diskResetBootVolumes error\n");␊
1922␉␉␉return NULL;␊
1923␉␉}␊
1924␉}␊
1925␉// Return the old map, either to be freed, or reinserted later␊
1926␉return map;␊
1927}␊
1928␊
1929//==============================================================================␊
1930␊
1931// Frees a DiskBVMap and all of its BootVolume's␊
1932void diskFreeMap(struct DiskBVMap *map)␊
1933{␊
1934␉if(map != NULL)␊
1935␉{␊
1936␉␉while(map->bvr != NULL)␊
1937␉␉{␊
1938␉␉␉BVRef bvr = map->bvr;␊
1939␉␉␉map->bvr = bvr->next;␊
1940␉␉␉(*bvr->bv_free)(bvr);␊
1941␉␉}␊
1942␊
1943␉␉free(map);␊
1944␉}␊
1945}␊
1946␊
1947//==============================================================================␊
1948␊
1949BVRef diskScanBootVolumes(int biosdev, int * countPtr)␊
1950{␊
1951␉struct DiskBVMap *map;␊
1952␉BVRef bvr;␊
1953␉int count = 0;␊
1954␊
1955␉// Find an existing mapping for this device.␊
1956␊
1957␉for (map = gDiskBVMap; map; map = map->next)␊
1958␉{␊
1959␉␉if (biosdev == map->biosdev)␊
1960␉␉{␊
1961␉␉␉count = map->bvrcnt;␊
1962␉␉␉break;␊
1963␉␉}␊
1964␉}␊
1965␊
1966␉if (map == NULL)␊
1967␉{␊
1968␉␉bvr = diskScanGPTBootVolumes(biosdev, &count);␊
1969␉␉if (bvr == NULL)␊
1970␉␉{␊
1971␉␉␉bvr = diskScanFDiskBootVolumes(biosdev, &count);␊
1972␉␉}␊
1973␊
1974␉␉if (bvr == NULL)␊
1975␉␉{␊
1976␉␉␉bvr = diskScanAPMBootVolumes(biosdev, &count);␊
1977␉␉}␊
1978␊
1979␉␉if (bvr)␊
1980␉␉{␊
1981␉␉␉scanFSLevelBVRSettings(bvr);␊
1982␉␉}␊
1983␉}␊
1984␉else␊
1985␉{␊
1986␉␉bvr = map->bvr;␊
1987␉}␊
1988␊
1989␉if (countPtr)␊
1990␉{␊
1991␉␉*countPtr += count;␊
1992␉}␊
1993␊
1994␉return bvr;␊
1995}␊
1996␊
1997//==============================================================================␊
1998␊
1999BVRef getBVChainForBIOSDev(int biosdev)␊
2000{␊
2001␉BVRef chain = NULL;␊
2002␉struct DiskBVMap * map = NULL;␊
2003␊
2004␉for (map = gDiskBVMap; map; map = map->next)␊
2005␉{␊
2006␉␉if (map->biosdev == biosdev)␊
2007␉␉{␊
2008␉␉␉chain = map->bvr;␊
2009␉␉␉break;␊
2010␉␉}␊
2011␉}␊
2012␊
2013␉return chain;␊
2014}␊
2015␊
2016//==============================================================================␊
2017␊
2018BVRef newFilteredBVChain(int minBIOSDev, int maxBIOSDev, unsigned int allowFlags, unsigned int denyFlags, int *count)␊
2019{␊
2020␉BVRef chain = NULL;␊
2021␉BVRef bvr = NULL;␊
2022␉BVRef newBVR = NULL;␊
2023␉BVRef prevBVR = NULL;␊
2024␊
2025␉struct DiskBVMap * map = NULL;␊
2026␉int bvCount = 0;␊
2027␊
2028␉const char *raw = 0;␊
2029␉char* val = 0;␊
2030␉int len;␊
2031 ␊
2032␉getValueForKey(kHidePartition, &raw, &len, &bootInfo->chameleonConfig);␊
2033␉if(raw)␊
2034␉{␊
2035␉␉val = XMLDecode(raw); ␊
2036␉}␊
2037␊
2038␉/*␊
2039␉ * Traverse gDISKBVmap to get references for␊
2040␉ * individual bvr chains of each drive.␊
2041␉ */␊
2042␉for (map = gDiskBVMap; map; map = map->next)␊
2043␉{␊
2044␉␉for (bvr = map->bvr; bvr; bvr = bvr->next)␊
2045␉␉{␊
2046␉␉␉/*␊
2047␉␉␉ * Save the last bvr.␊
2048␉␉␉ */␊
2049␉␉␉if (newBVR)␊
2050␉␉␉{␊
2051␉␉␉␉prevBVR = newBVR;␊
2052␉␉␉}␊
2053␊
2054␉␉␉/*␊
2055␉␉␉ * Allocate and copy the matched bvr entry into a new one.␊
2056␉␉␉ */␊
2057␉␉␉newBVR = (BVRef) malloc(sizeof(*newBVR));␊
2058␉␉␉if (!newBVR)␊
2059␉␉␉{␊
2060␉␉␉␉continue;␊
2061␉␉␉}␊
2062␉␉␉bzero(newBVR,sizeof(*newBVR));␊
2063␊
2064␉␉␉bcopy(bvr, newBVR, sizeof(*newBVR));␊
2065␊
2066␉␉␉/*␊
2067␉␉␉ * Adjust the new bvr's fields.␊
2068␉␉␉ */␊
2069␉␉␉newBVR->next = NULL;␊
2070␉␉␉newBVR->filtered = true;␊
2071␊
2072␉␉␉if ( (!allowFlags || newBVR->flags & allowFlags)␊
2073␉␉␉␉&& (!denyFlags || !(newBVR->flags & denyFlags) )␊
2074␉␉␉␉&& (newBVR->biosdev >= minBIOSDev && newBVR->biosdev <= maxBIOSDev)␊
2075␉␉␉␉)␊
2076␉␉␉{␊
2077␉␉␉␉newBVR->visible = true;␊
2078␉␉␉}␊
2079␊
2080␉␉␉/*␊
2081␉␉␉ * Looking for "Hide Partition" entries in 'hd(x,y)|uuid|"label" hd(m,n)|uuid|"label"' format,␊
2082␉␉␉ * to be able to hide foreign partitions from the boot menu.␊
2083␉␉␉ *␊
2084␉␉␉ */␊
2085␉␉␉if ( (newBVR->flags & kBVFlagForeignBoot) )␊
2086␉␉␉{␊
2087␉␉␉␉char *start, *next = val;␊
2088␉␉␉␉long len = 0; ␊
2089␉␉␉␉do␊
2090␉␉␉␉{␊
2091␉␉␉␉␉start = strbreak(next, &next, &len);␊
2092␉␉␉␉␉if(len && matchVolumeToString(newBVR, start, len) )␊
2093␉␉␉␉␉{␊
2094␉␉␉␉␉␉newBVR->visible = false;␊
2095␉␉␉␉␉}␊
2096␉␉␉␉}␊
2097␉␉␉␉while ( next && *next );␊
2098␉␉␉}␊
2099␊
2100␉␉␉/*␊
2101␉␉␉ * Use the first bvr entry as the starting chain pointer.␊
2102␉␉␉ */␊
2103␉␉␉if (!chain)␊
2104␉␉␉{␊
2105␉␉␉␉chain = newBVR;␊
2106␉␉␉}␊
2107␊
2108␉␉␉/*␊
2109␉␉␉ * Update the previous bvr's link pointer to use the new memory area.␊
2110␉␉␉ */␊
2111␉␉␉if (prevBVR)␊
2112␉␉␉{␊
2113␉␉␉␉prevBVR->next = newBVR;␊
2114␉␉␉}␊
2115␊
2116␉␉␉if (newBVR->visible)␊
2117␉␉␉{␊
2118␉␉␉␉bvCount++;␊
2119␉␉␉}␊
2120␉␉}␊
2121␉}␊
2122␊
2123#if DEBUG //Azi: warning - too big for boot-log.. far too big.. i mean HUGE!! :P␊
2124␉for (bvr = chain; bvr; bvr = bvr->next)␊
2125␉{␊
2126␉␉if (!bvr)␊
2127␉␉{␊
2128␉␉␉break;␊
2129␉␉}␊
2130␉␉printf(" bvr: %d, dev: %d, part: %d, flags: %d, vis: %d\n", bvr, bvr->biosdev, bvr->part_no, bvr->flags, bvr->visible);␊
2131␉}␊
2132␉printf("count: %d\n", bvCount);␊
2133␉getchar();␊
2134#endif␊
2135␊
2136␉*count = bvCount;␊
2137␊
2138␉free(val); ␊
2139␉return chain;␊
2140}␊
2141␊
2142//==============================================================================␊
2143␊
2144int freeFilteredBVChain(const BVRef chain)␊
2145{␊
2146␉int ret = 1;␊
2147␉BVRef bvr = chain;␊
2148␉BVRef nextBVR = NULL;␊
2149 ␊
2150␉while (bvr)␊
2151␉{␊
2152␉␉if (!bvr)␊
2153␉␉{␊
2154␉␉␉break;␊
2155␉␉}␊
2156␊
2157␉␉nextBVR = bvr->next;␊
2158␊
2159␉␉if (bvr->filtered)␊
2160␉␉{␊
2161␉␉␉free(bvr);␊
2162␉␉}␊
2163␉␉else␊
2164␉␉{␊
2165␉␉␉ret = 0;␊
2166␉␉␉break;␊
2167␉␉}␊
2168␊
2169␉␉bvr = nextBVR;␊
2170␉}␊
2171␊
2172␉return ret;␊
2173}␊
2174␊
2175//==============================================================================␊
2176␊
2177bool matchVolumeToString( BVRef bvr, const char* match, long matchLen)␊
2178{␊
2179␉char testStr[128];␊
2180␊
2181␉if ( !bvr || !match || !*match)␊
2182␉{␊
2183␉␉return 0;␊
2184␉}␊
2185␊
2186␉if ( bvr->biosdev < 0x80 || bvr->biosdev >= 0x100 )␊
2187␉{␊
2188 return 0;␊
2189␉}␊
2190␊
2191␉// Try to match hd(x,y) first.␊
2192␉snprintf(testStr, sizeof(testStr), "hd(%d,%d)", BIOS_DEV_UNIT(bvr), bvr->part_no);␊
2193␉if ( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) )␊
2194␉{␊
2195␉␉return true;␊
2196␉}␊
2197␊
2198␉// Try to match volume UUID.␊
2199␉if ( bvr->fs_getuuid && bvr->fs_getuuid(bvr, testStr) == 0)␊
2200␉{␊
2201␉␉if ( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) )␊
2202␉␉{␊
2203␉␉␉return true;␊
2204␉␉}␊
2205␉}␊
2206␊
2207␉// Try to match volume label (always quoted).␊
2208␉if ( bvr->description )␊
2209␉{␊
2210␉␉bvr->description(bvr, testStr, sizeof(testStr)-1);␊
2211␉␉if ( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) )␊
2212␉␉{␊
2213␉␉␉return true;␊
2214␉␉}␊
2215␉}␊
2216␊
2217␉return false;␊
2218}␊
2219␊
2220//==============================================================================␊
2221␊
2222/* If Rename Partition has defined an alias, then extract it for description purpose.␊
2223 * The format for the rename string is the following:␊
2224 * hd(x,y)|uuid|"label" "alias";hd(m,n)|uuid|"label" "alias"; etc...␊
2225 */␊
2226␊
2227static bool getVolumeLabelAlias(BVRef bvr, char* str, long strMaxLen)␊
2228{␊
2229␉char *aliasList, *entryStart, *entryNext;␊
2230 ␊
2231␉if ( !str || strMaxLen <= 0)␊
2232␉{␊
2233␉␉return false;␊
2234␉}␊
2235␊
2236␉aliasList = XMLDecode(getStringForKey(kRenamePartition, &bootInfo->chameleonConfig));␊
2237␉if ( !aliasList )␊
2238␉{␊
2239␉␉return false;␊
2240␉}␊
2241␊
2242␉for ( entryStart = entryNext = aliasList; entryNext && *entryNext; entryStart = entryNext )␊
2243␉{␊
2244␉␉char *volStart, *volEnd, *aliasStart;␊
2245␉␉long volLen, aliasLen;␊
2246 ␊
2247␉␉// Delimit current entry␊
2248␉␉entryNext = strchr(entryStart, ';');␊
2249␉␉if ( entryNext )␊
2250␉␉{␊
2251␉␉␉*entryNext = '\0';␊
2252␉␉␉entryNext++;␊
2253␉␉}␊
2254 ␊
2255␉␉volStart = strbreak(entryStart, &volEnd, &volLen);␊
2256␉␉if(!volLen)␊
2257␉␉{␊
2258␉␉␉continue;␊
2259␉␉}␊
2260␊
2261␉␉aliasStart = strbreak(volEnd, 0, &aliasLen);␊
2262␉␉if(!aliasLen)␊
2263␉␉{␊
2264␉␉␉continue;␊
2265␉␉}␊
2266␊
2267␉␉if ( matchVolumeToString(bvr, volStart, volLen) )␊
2268␉␉{␊
2269␉␉␉strncat(str, aliasStart, MIN(strMaxLen, aliasLen));␊
2270␉␉␉free(aliasList);␊
2271␊
2272␉␉␉return true;␊
2273␉␉}␊
2274␉}␊
2275 ␊
2276␉free(aliasList);␊
2277␉return false;␊
2278}␊
2279␊
2280//==============================================================================␊
2281␊
2282void getBootVolumeDescription( BVRef bvr, char * str, long strMaxLen, bool useDeviceDescription )␊
2283{␊
2284␉unsigned char type;␊
2285␉char *p = str;␊
2286 ␊
2287␉if(!bvr || !p || strMaxLen <= 0)␊
2288␉{␊
2289␉␉return;␊
2290␉}␊
2291␊
2292␉type = (unsigned char) bvr->part_type;␊
2293␊
2294␉if (useDeviceDescription)␊
2295␉{␊
2296␉␉int len = getDeviceDescription(bvr, str);␊
2297␉␉if(len >= strMaxLen)␊
2298␉␉{␊
2299␉␉␉return;␊
2300␉␉}␊
2301␊
2302␉␉strcpy(str + len, bvr->OSisInstaller ? " (Installer " : " (");␊
2303␉␉len += bvr->OSisInstaller ? 12 : 2;␊
2304␉␉strcpy(str + len, bvr->OSVersion);␊
2305␉␉len += strlen(bvr->OSVersion);␊
2306␉␉strcpy(str + len, ") ");␊
2307␉␉len += 2;␊
2308␊
2309␉␉strMaxLen -= len;␊
2310␉␉p += len;␊
2311␉}␊
2312␊
2313␉/* See if a partition rename is preferred */␊
2314␉if (getVolumeLabelAlias(bvr, p, strMaxLen))␊
2315␉{␊
2316␉␉strncpy(bvr->label, p, strMaxLen); ␊
2317␉␉return; // we're done here no need to seek for real name␊
2318␉}␊
2319␊
2320␉// Get the volume label using filesystem specific functions or use the alternate volume label if available.␊
2321␊
2322␉if (*bvr->altlabel != '\0')␊
2323␉{␊
2324␉␉strncpy(p, bvr->altlabel, strMaxLen);␊
2325␉}␊
2326␉else if (bvr->description)␊
2327␉{␊
2328␉␉bvr->description(bvr, p, strMaxLen);␊
2329␉}␊
2330␊
2331␉if (*p == '\0')␊
2332␉{␊
2333␉␉const char * name = getNameForValue( fdiskTypes, type );␊
2334␊
2335␉␉if (name == NULL)␊
2336␉␉{␊
2337␉␉␉name = bvr->type_name;␊
2338␉␉}␊
2339␊
2340␉␉if (name == NULL)␊
2341␉␉{␊
2342␉␉␉snprintf(p, strMaxLen, "TYPE %02X", type);␊
2343␉␉}␊
2344␉␉else␊
2345␉␉{␊
2346␉␉␉strncpy(p, name, strMaxLen);␊
2347␉␉}␊
2348␉}␊
2349␊
2350␉// Set the devices label␊
2351␉snprintf(bvr->label, sizeof(bvr->label), p);␊
2352}␊
2353␊
2354␊
2355//==============================================================================␊
2356␊
2357int readBootSector(int biosdev, unsigned int secno, void *buffer)␊
2358{␊
2359␉int error;␊
2360␉struct disk_blk0 * bootSector = (struct disk_blk0 *)buffer;␊
2361␊
2362␉if (bootSector == NULL)␊
2363␉{␊
2364␉␉if (gBootSector == NULL)␊
2365␉␉{␊
2366␉␉␉gBootSector = (struct disk_blk0 *)malloc(sizeof(*gBootSector));␊
2367␊
2368␉␉␉if (gBootSector == NULL)␊
2369␉␉␉{␊
2370␉␉␉␉return -1;␊
2371␉␉␉}␊
2372␉␉}␊
2373␊
2374␉␉bootSector = gBootSector;␊
2375␉}␊
2376␊
2377␉error = readBytes(biosdev, secno, 0, BPS, bootSector);␊
2378␊
2379␉if (error || bootSector->signature != DISK_SIGNATURE)␊
2380␉{␊
2381␉␉return -1;␊
2382␉}␊
2383␉return 0;␊
2384}␊
2385␊
2386//==============================================================================␊
2387␊
2388/*␊
2389 * Format of boot1f32 block.␊
2390 */␊
2391␊
2392#define BOOT1F32_MAGIC "BOOT "␊
2393#define BOOT1F32_MAGICLEN 11␊
2394␊
2395struct disk_boot1f32_blk␊
2396{␊
2397␉unsigned char init[3];␊
2398␉unsigned char fsheader[87];␊
2399␉unsigned char magic[BOOT1F32_MAGICLEN];␊
2400␉unsigned char bootcode[409];␊
2401␉unsigned short signature;␊
2402};␊
2403␊
2404//==============================================================================␊
2405␊
2406int testFAT32EFIBootSector(int biosdev, unsigned int secno, void *buffer)␊
2407{␊
2408␉struct disk_boot1f32_blk *bootSector = (struct disk_boot1f32_blk *)buffer;␊
2409␉int error;␊
2410␊
2411␉if (bootSector == NULL)␊
2412␉{␊
2413␉␉if (gBootSector == NULL)␊
2414␉␉{␊
2415␉␉␉gBootSector = (struct disk_blk0 *)malloc(sizeof(*gBootSector));␊
2416␉␉␉if ( gBootSector == NULL )␊
2417␉␉␉{␊
2418␉␉␉␉return -1;␊
2419␉␉␉}␊
2420␉␉}␊
2421␉␉bootSector = (struct disk_boot1f32_blk *)gBootSector;␊
2422␉}␊
2423␊
2424␉error = readBytes(biosdev, secno, 0, BPS, bootSector);␊
2425␉if (error || bootSector->signature != DISK_SIGNATURE || strncmp((const char *)bootSector->magic, BOOT1F32_MAGIC, BOOT1F32_MAGICLEN) )␊
2426␉{␊
2427␉␉return -1;␊
2428␉}␊
2429␉return 0;␊
2430}␊
2431␊
2432␊
2433//==============================================================================␊
2434// Handle seek request from filesystem modules.␊
2435␊
2436void diskSeek(BVRef bvr, long long position)␊
2437{␊
2438␉bvr->fs_boff = position / BPS;␊
2439␉bvr->fs_byteoff = position % BPS;␊
2440}␊
2441␊
2442␊
2443//==============================================================================␊
2444// Handle read request from filesystem modules.␊
2445␊
2446int diskRead(BVRef bvr, long addr, long length)␊
2447{␊
2448␉return readBytes(bvr->biosdev, bvr->fs_boff + bvr->part_boff, bvr->fs_byteoff, length, (void *) addr);␊
2449}␊
2450␊
2451//==============================================================================␊
2452␊
2453int rawDiskRead( BVRef bvr, unsigned int secno, void *buffer, unsigned int len )␊
2454{␊
2455␉int secs;␊
2456␉unsigned char *cbuf = (unsigned char *)buffer;␊
2457␉unsigned int copy_len;␊
2458␉int rc;␊
2459␊
2460␉if ((len & (BPS-1)) != 0)␊
2461␉{␊
2462␉␉error("raw disk read not sector aligned");␊
2463␉␉return -1;␊
2464␉}␊
2465␉secno += bvr->part_boff;␊
2466␊
2467␉cache_valid = false;␊
2468␊
2469␉while (len > 0)␊
2470␉{␊
2471␉␉secs = len / BPS;␊
2472␉␉if (secs > N_CACHE_SECS)␊
2473␉␉{␊
2474␉␉␉secs = N_CACHE_SECS;␊
2475␉␉}␊
2476␉␉copy_len = secs * BPS;␊
2477␊
2478␉␉//printf("rdr: ebiosread(%d, %d, %d)\n", bvr->biosdev, secno, secs);␊
2479␉␉if ((rc = ebiosread(bvr->biosdev, secno, secs)) != 0)␊
2480␉␉{␊
2481␉␉␉/* Ignore corrected ECC errors */␊
2482␉␉␉if (rc != ECC_CORRECTED_ERR)␊
2483␉␉␉{␊
2484␉␉␉␉error(" EBIOS read error: %s\n", bios_error(rc), rc);␊
2485␉␉␉␉error(" Block %d Sectors %d\n", secno, secs);␊
2486␉␉␉␉return rc;␊
2487␉␉␉}␊
2488␉␉}␊
2489␉␉bcopy( trackbuf, cbuf, copy_len );␊
2490␉␉len -= copy_len;␊
2491␉␉cbuf += copy_len;␊
2492␉␉secno += secs;␊
2493␉␉spinActivityIndicator(secs);␊
2494␉}␊
2495␊
2496␉return 0;␊
2497}␊
2498␊
2499//==============================================================================␊
2500␊
2501int rawDiskWrite( BVRef bvr, unsigned int secno, void *buffer, unsigned int len )␊
2502{␊
2503 int secs;␊
2504 unsigned char *cbuf = (unsigned char *)buffer;␊
2505 unsigned int copy_len;␊
2506 int rc;␊
2507␊
2508␉if ((len & (BPS-1)) != 0)␊
2509␉{␊
2510␉␉error("raw disk write not sector aligned");␊
2511␉␉return -1;␊
2512␉}␊
2513␉secno += bvr->part_boff;␊
2514␊
2515␉cache_valid = false;␊
2516␊
2517␉while (len > 0)␊
2518␉{␊
2519␉␉secs = len / BPS;␊
2520␉␉if (secs > N_CACHE_SECS)␊
2521␉␉{␊
2522␉␉␉secs = N_CACHE_SECS;␊
2523␉␉}␊
2524␉␉copy_len = secs * BPS;␊
2525␊
2526␉␉bcopy( cbuf, trackbuf, copy_len );␊
2527␉␉//printf("rdr: ebioswrite(%d, %d, %d)\n", bvr->biosdev, secno, secs);␊
2528␉␉if ((rc = ebioswrite(bvr->biosdev, secno, secs)) != 0)␊
2529␉␉{␊
2530␉␉␉error(" EBIOS write error: %s\n", bios_error(rc), rc);␊
2531␉␉␉error(" Block %d Sectors %d\n", secno, secs);␊
2532␉␉␉return rc;␊
2533␉␉}␊
2534␊
2535␉␉len -= copy_len;␊
2536␉␉cbuf += copy_len;␊
2537␉␉secno += secs;␊
2538␉␉spinActivityIndicator(secs);␊
2539␉}␊
2540␊
2541␉return 0;␊
2542}␊
2543␊
2544//==============================================================================␊
2545␊
2546int diskIsCDROM(BVRef bvr)␊
2547{␊
2548␉struct driveInfo di;␊
2549␊
2550␉if (getDriveInfo(bvr->biosdev, &di) == 0 && di.no_emulation)␊
2551␉{␊
2552␉␉return 1;␊
2553␉}␊
2554␉return 0;␊
2555}␊
2556␊
2557//==============================================================================␊
2558␊
2559int biosDevIsCDROM(int biosdev)␊
2560{␊
2561␉struct driveInfo di;␊
2562␊
2563␉if (getDriveInfo(biosdev, &di) == 0 && di.no_emulation)␊
2564␉{␊
2565␉␉return 1;␊
2566␉}␊
2567␉return 0;␊
2568}␊
2569

Archive Download this file

Revision: 2620