Chameleon

Chameleon Svn Source Tree

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

Source at commit 536 created 9 years 9 months ago.
By meklort, #ifdef to #ifndef. Various other changes
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/*
33 * INTEL CORPORATION PROPRIETARY INFORMATION
34 *
35 * This software is supplied under the terms of a license agreement or
36 * nondisclosure agreement with Intel Corporation and may not be copied
37 * nor disclosed except in accordance with the terms of that agreement.
38 *
39 * Copyright 1988, 1989 Intel Corporation
40 */
41
42/*
43 * Copyright 1993 NeXT Computer, Inc.
44 * All rights reserved.
45 */
46
47/* Copyright 2007 VMware Inc.
48 "Preboot" ramdisk support added by David Elliott
49 GPT support added by David Elliott. Based on IOGUIDPartitionScheme.cpp.
50 */
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#include "libsaio.h"
59#include "boot.h"
60#include "bootstruct.h"
61#include "fdisk.h"
62#if UFS_SUPPORT
63#include "ufs.h"
64#endif
65#include "hfs.h"
66#include "ntfs.h"
67#include "msdos.h"
68#include "ext2fs.h"
69
70#include "xml.h"
71#include "disk.h"
72
73#include <limits.h>
74#include <IOKit/storage/IOApplePartitionScheme.h>
75#include <IOKit/storage/IOGUIDPartitionScheme.h>
76typedef struct gpt_hdr gpt_hdr;
77typedef struct gpt_ent gpt_ent;
78
79// For EFI_GUID
80#include "efi.h"
81#include "efi_tables.h"
82
83#define PROBEFS_SIZE BPS * 4 /* buffer size for filesystem probe */
84#define CD_BPS 2048 /* CD-ROM block size */
85#define N_CACHE_SECS (BIOS_LEN / BPS) /* Must be a multiple of 4 for CD-ROMs */
86#define UFS_FRONT_PORCH 0
87#define kAPMSector 2 /* Sector number of Apple partition map */
88#define kAPMCDSector 8 /* Translated sector of Apple partition map on a CD */
89
90/*
91 * IORound and IOTrunc convenience functions, in the spirit
92 * of vm's round_page() and trunc_page().
93 */
94#define IORound(value,multiple) \
95((((value) + (multiple) - 1) / (multiple)) * (multiple))
96
97#define IOTrunc(value,multiple) \
98(((value) / (multiple)) * (multiple));
99
100/*
101 * trackbuf points to the start of the track cache. Biosread()
102 * will store the sectors read from disk to this memory area.
103 *
104 * biosbuf points to a sector within the track cache, and is
105 * updated by Biosread().
106 */
107static char * const trackbuf = (char *) ptov(BIOS_ADDR);
108static char * biosbuf;
109
110/*
111 * Map a disk drive to bootable volumes contained within.
112 */
113struct DiskBVMap {
114 int biosdev; // BIOS device number (unique)
115 BVRef bvr; // chain of boot volumes on the disk
116 int bvrcnt; // number of boot volumes
117 struct DiskBVMap * next; // linkage to next mapping
118};
119
120static struct DiskBVMap * gDiskBVMap = NULL;
121static struct disk_blk0 * gBootSector = NULL;
122
123// Function pointers to be filled in if ramdisks are available:
124int (*p_ramdiskReadBytes)( int biosdev, unsigned int blkno,
125 unsigned int byteoff,
126 unsigned int byteCount, void * buffer ) = NULL;
127int (*p_get_ramdisk_info)(int biosdev, struct driveInfo *dip) = NULL;
128
129
130extern void spinActivityIndicator(int sectors);
131
132//==========================================================================
133
134static int getDriveInfo( int biosdev, struct driveInfo *dip )
135{
136 static struct driveInfo cached_di;
137 int cc;
138
139 // Real BIOS devices are 8-bit, so anything above that is for internal use.
140 // Don't cache ramdisk drive info since it doesn't require several BIOS
141 // calls and is thus not worth it.
142 if(biosdev >= 0x100)
143 {
144 if(p_get_ramdisk_info != NULL)
145 cc = (*p_get_ramdisk_info)(biosdev, dip);
146 else
147 cc = -1;
148 if(cc < 0)
149 {
150 dip->valid = 0;
151 return -1;
152 }
153 else
154 return 0;
155 }
156
157 if ( !cached_di.valid || biosdev != cached_di.biosdev )
158 {
159cc = get_drive_info(biosdev, &cached_di);
160 if (cc < 0) {
161cached_di.valid = 0;
162 DEBUG_DISK(("get_drive_info returned error\n"));
163return (-1); // BIOS call error
164}
165 }
166
167 bcopy(&cached_di, dip, sizeof(cached_di));
168
169 return 0;
170}
171
172//==========================================================================
173// Maps (E)BIOS return codes to message strings.
174
175struct NamedValue {
176 unsigned char value;
177 const char * name;
178};
179
180static const char * getNameForValue( const struct NamedValue * nameTable,
181unsigned char value )
182{
183 const struct NamedValue * np;
184
185 for ( np = nameTable; np->value; np++)
186 if (np->value == value)
187 return np->name;
188
189 return NULL;
190}
191
192#define ECC_CORRECTED_ERR 0x11
193
194static const struct NamedValue bios_errors[] = {
195 { 0x10, "Media error" },
196 { 0x11, "Corrected ECC error" },
197 { 0x20, "Controller or device error" },
198 { 0x40, "Seek failed" },
199 { 0x80, "Device timeout" },
200 { 0xAA, "Drive not ready" },
201 { 0x00, 0 }
202};
203
204static const char * bios_error(int errnum)
205{
206 static char errorstr[] = "Error 0x00";
207 const char * errname;
208
209 errname = getNameForValue( bios_errors, errnum );
210 if ( errname ) return errname;
211
212 sprintf(errorstr, "Error 0x%02x", errnum);
213 return errorstr; // No string, print error code only
214}
215
216//==========================================================================
217// Use BIOS INT13 calls to read the sector specified. This function will
218// also perform read-ahead to cache a few subsequent sector to the sector
219// cache.
220//
221// Return:
222// 0 on success, or an error code from INT13/F2 or INT13/F42 BIOS call.
223
224static bool cache_valid = false;
225
226static int Biosread( int biosdev, unsigned long long secno )
227{
228 static int xbiosdev, xcyl, xhead;
229 static unsigned int xsec, xnsecs;
230 struct driveInfo di;
231
232 int rc = -1;
233 int cyl, head, sec;
234 int tries = 0;
235 int bps, divisor;
236
237 if (getDriveInfo(biosdev, &di) < 0) {
238return -1;
239 }
240 if (di.no_emulation) {
241/* Always assume 2k block size; BIOS may lie about geometry */
242bps = 2048;
243 } else {
244bps = di.di.params.phys_nbps;
245 if (bps == 0) {
246 return -1;
247 }
248 }
249 divisor = bps / BPS;
250
251 DEBUG_DISK(("Biosread dev %x sec %d bps %d\n", biosdev, secno, bps));
252
253 // To read the disk sectors, use EBIOS if we can. Otherwise,
254 // revert to the standard BIOS calls.
255
256 if ((biosdev >= kBIOSDevTypeHardDrive) &&
257 (di.uses_ebios & EBIOS_FIXED_DISK_ACCESS))
258 {
259 if (cache_valid &&
260 (biosdev == xbiosdev) &&
261 (secno >= xsec) &&
262 ((unsigned int)secno < (xsec + xnsecs)))
263 {
264 biosbuf = trackbuf + (BPS * (secno - xsec));
265 return 0;
266 }
267
268 xnsecs = N_CACHE_SECS;
269 xsec = (secno / divisor) * divisor;
270 cache_valid = false;
271
272 while ((rc = ebiosread(biosdev, secno / divisor, xnsecs / divisor)) && (++tries < 5))
273 {
274 if (rc == ECC_CORRECTED_ERR) {
275 /* Ignore corrected ECC errors */
276 rc = 0;
277 break;
278 }
279 error(" EBIOS read error: %s\n", bios_error(rc), rc);
280 error(" Block 0x%x Sectors %d\n", secno, xnsecs);
281 sleep(1);
282 }
283 }
284 else
285 {
286/* spc = spt * heads */
287int spc = (di.di.params.phys_spt * di.di.params.phys_heads);
288 cyl = secno / spc;
289 head = (secno % spc) / di.di.params.phys_spt;
290 sec = secno % di.di.params.phys_spt;
291
292 if (cache_valid &&
293 (biosdev == xbiosdev) &&
294 (cyl == xcyl) &&
295 (head == xhead) &&
296 ((unsigned int)sec >= xsec) &&
297 ((unsigned int)sec < (xsec + xnsecs)))
298 {
299 // this sector is in trackbuf cache
300 biosbuf = trackbuf + (BPS * (sec - xsec));
301 return 0;
302 }
303
304 // Cache up to a track worth of sectors, but do not cross a
305 // track boundary.
306
307 xcyl = cyl;
308 xhead = head;
309 xsec = sec;
310 xnsecs = ((unsigned int)(sec + N_CACHE_SECS) > di.di.params.phys_spt) ? (di.di.params.phys_spt - sec) : N_CACHE_SECS;
311 cache_valid = false;
312
313 while ((rc = biosread(biosdev, cyl, head, sec, xnsecs)) &&
314 (++tries < 5))
315 {
316 if (rc == ECC_CORRECTED_ERR) {
317 /* Ignore corrected ECC errors */
318 rc = 0;
319 break;
320 }
321 error(" BIOS read error: %s\n", bios_error(rc), rc);
322 error(" Block %d, Cyl %d Head %d Sector %d\n",
323 secno, cyl, head, sec);
324 sleep(1);
325 }
326 }
327
328 // If the BIOS reported success, mark the sector cache as valid.
329
330 if (rc == 0) {
331 cache_valid = true;
332 }
333 biosbuf = trackbuf + (secno % divisor) * BPS;
334 xbiosdev = biosdev;
335
336 spinActivityIndicator(xnsecs);
337
338 return rc;
339}
340
341//==========================================================================
342
343int testBiosread( int biosdev, unsigned long long secno )
344{
345return Biosread(biosdev, secno);
346}
347
348//==========================================================================
349
350static int readBytes( int biosdev, unsigned long long blkno,
351 unsigned int byteoff,
352 unsigned int byteCount, void * buffer )
353{
354 // ramdisks require completely different code for reading.
355 if(p_ramdiskReadBytes != NULL && biosdev >= 0x100)
356 return (*p_ramdiskReadBytes)(biosdev, blkno, byteoff, byteCount, buffer);
357
358 char * cbuf = (char *) buffer;
359 int error;
360 int copy_len;
361
362 DEBUG_DISK(("%s: dev %x block %x [%d] -> 0x%x...", __FUNCTION__,
363 biosdev, blkno, byteCount, (unsigned)cbuf));
364
365 for ( ; byteCount; cbuf += copy_len, blkno++ )
366 {
367 error = Biosread( biosdev, blkno );
368 if ( error )
369 {
370 DEBUG_DISK(("error\n"));
371 return (-1);
372 }
373
374 copy_len = ((byteCount + byteoff) > BPS) ? (BPS - byteoff) : byteCount;
375 bcopy( biosbuf + byteoff, cbuf, copy_len );
376 byteCount -= copy_len;
377 byteoff = 0;
378 }
379
380 DEBUG_DISK(("done\n"));
381
382 return 0;
383}
384
385//==========================================================================
386
387static int isExtendedFDiskPartition( const struct fdisk_part * part )
388{
389 static unsigned char extParts[] =
390 {
391 0x05, /* Extended */
392 0x0f, /* Win95 extended */
393 0x85, /* Linux extended */
394 };
395
396 unsigned int i;
397
398 for (i = 0; i < sizeof(extParts)/sizeof(extParts[0]); i++)
399 {
400 if (extParts[i] == part->systid) return 1;
401 }
402 return 0;
403}
404
405//==========================================================================
406
407static int getNextFDiskPartition( int biosdev, int * partno,
408 const struct fdisk_part ** outPart )
409{
410 static int sBiosdev = -1;
411 static int sNextPartNo;
412 static unsigned int sFirstBase;
413 static unsigned int sExtBase;
414 static unsigned int sExtDepth;
415 static struct fdisk_part * sExtPart;
416 struct fdisk_part * part;
417
418 if ( sBiosdev != biosdev || *partno < 0 )
419 {
420 // Fetch MBR.
421 if ( readBootSector( biosdev, DISK_BLK0, 0 ) ) return 0;
422
423 sBiosdev = biosdev;
424 sNextPartNo = 0;
425 sFirstBase = 0;
426 sExtBase = 0;
427 sExtDepth = 0;
428 sExtPart = NULL;
429 }
430
431 while (1)
432 {
433 part = NULL;
434
435 if ( sNextPartNo < FDISK_NPART )
436 {
437 part = (struct fdisk_part *) gBootSector->parts[sNextPartNo];
438 }
439 else if ( sExtPart )
440 {
441 unsigned int blkno = sExtPart->relsect + sFirstBase;
442
443 // Save the block offset of the first extended partition.
444
445 if (sExtDepth == 0) {
446 sFirstBase = blkno;
447 }
448 sExtBase = blkno;
449
450 // Load extended partition table.
451
452 if ( readBootSector( biosdev, blkno, 0 ) == 0 )
453 {
454 sNextPartNo = 0;
455 sExtDepth++;
456 sExtPart = NULL;
457 continue;
458 }
459 // Fall through to part == NULL
460 }
461
462 if ( part == NULL ) break; // Reached end of partition chain.
463
464 // Advance to next partition number.
465
466 sNextPartNo++;
467
468 if ( isExtendedFDiskPartition(part) )
469 {
470 sExtPart = part;
471 continue;
472 }
473
474 // Skip empty slots.
475
476 if ( part->systid == 0x00 )
477 {
478 continue;
479 }
480
481 // Change relative offset to an absolute offset.
482 part->relsect += sExtBase;
483
484 *outPart = part;
485 *partno = sExtDepth ? (int)(sExtDepth + FDISK_NPART) : sNextPartNo;
486
487 break;
488 }
489
490 return (part != NULL);
491}
492
493//==========================================================================
494
495static BVRef newFDiskBVRef( int biosdev, int partno, unsigned int blkoff,
496 const struct fdisk_part * part,
497 FSInit initFunc, FSLoadFile loadFunc,
498 FSReadFile readFunc,
499 FSGetDirEntry getdirFunc,
500 FSGetFileBlock getBlockFunc,
501 FSGetUUID getUUIDFunc,
502 BVGetDescription getDescriptionFunc,
503 BVFree bvFreeFunc,
504 int probe, int type, unsigned int bvrFlags )
505{
506 BVRef bvr = (BVRef) malloc( sizeof(*bvr) );
507 if ( bvr )
508 {
509 bzero(bvr, sizeof(*bvr));
510
511 bvr->biosdev = biosdev;
512 bvr->part_no = partno;
513 bvr->part_boff = blkoff;
514 bvr->part_type = part->systid;
515 bvr->fs_loadfile = loadFunc;
516 bvr->fs_readfile = readFunc;
517 bvr->fs_getdirentry = getdirFunc;
518 bvr->fs_getfileblock= getBlockFunc;
519 bvr->fs_getuuid = getUUIDFunc;
520 bvr->description = getDescriptionFunc;
521 bvr->type = type;
522 bvr->bv_free = bvFreeFunc;
523
524 if ((part->bootid & FDISK_ACTIVE) && (part->systid == FDISK_HFS))
525 bvr->flags |= kBVFlagPrimary;
526
527 // Probe the filesystem.
528
529 if ( initFunc )
530 {
531 bvr->flags |= kBVFlagNativeBoot;
532
533 if ( probe && initFunc( bvr ) != 0 )
534 {
535 // filesystem probe failed.
536
537 DEBUG_DISK(("%s: failed probe on dev %x part %d\n",
538 __FUNCTION__, biosdev, partno));
539
540 (*bvr->bv_free)(bvr);
541 bvr = NULL;
542 }
543 if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 )
544 {
545 bvr->flags |= kBVFlagBootable;
546 }
547 }
548 else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 )
549 {
550 bvr->flags |= kBVFlagForeignBoot;
551 }
552 else
553 {
554 (*bvr->bv_free)(bvr);
555 bvr = NULL;
556 }
557 }
558 if (bvr) bvr->flags |= bvrFlags;
559 return bvr;
560}
561
562//==========================================================================
563
564BVRef newAPMBVRef( int biosdev, int partno, unsigned int blkoff,
565 const DPME * part,
566 FSInit initFunc, FSLoadFile loadFunc,
567 FSReadFile readFunc,
568 FSGetDirEntry getdirFunc,
569 FSGetFileBlock getBlockFunc,
570 FSGetUUID getUUIDFunc,
571 BVGetDescription getDescriptionFunc,
572 BVFree bvFreeFunc,
573 int probe, int type, unsigned int bvrFlags )
574{
575 BVRef bvr = (BVRef) malloc( sizeof(*bvr) );
576 if ( bvr )
577 {
578 bzero(bvr, sizeof(*bvr));
579
580 bvr->biosdev = biosdev;
581 bvr->part_no = partno;
582 bvr->part_boff = blkoff;
583 bvr->fs_loadfile = loadFunc;
584 bvr->fs_readfile = readFunc;
585 bvr->fs_getdirentry = getdirFunc;
586 bvr->fs_getfileblock= getBlockFunc;
587 bvr->fs_getuuid = getUUIDFunc;
588 bvr->description = getDescriptionFunc;
589 bvr->type = type;
590 bvr->bv_free = bvFreeFunc;
591 strlcpy(bvr->name, part->dpme_name, DPISTRLEN);
592 strlcpy(bvr->type_name, part->dpme_type, DPISTRLEN);
593
594 /*
595 if ( part->bootid & FDISK_ACTIVE )
596 bvr->flags |= kBVFlagPrimary;
597 */
598
599 // Probe the filesystem.
600
601 if ( initFunc )
602 {
603 bvr->flags |= kBVFlagNativeBoot | kBVFlagBootable | kBVFlagSystemVolume;
604
605 if ( probe && initFunc( bvr ) != 0 )
606 {
607 // filesystem probe failed.
608
609 DEBUG_DISK(("%s: failed probe on dev %x part %d\n",
610 __FUNCTION__, biosdev, partno));
611
612 (*bvr->bv_free)(bvr);
613 bvr = NULL;
614 }
615 }
616 /*
617 else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 )
618 {
619 bvr->flags |= kBVFlagForeignBoot;
620 }
621 */
622 else
623 {
624 (*bvr->bv_free)(bvr);
625 bvr = NULL;
626 }
627 }
628 if (bvr) bvr->flags |= bvrFlags;
629 return bvr;
630}
631
632//==========================================================================
633
634// HFS+ GUID in LE form
635EFI_GUID const GPT_HFS_GUID= { 0x48465300, 0x0000, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } };
636// turbo - also our booter partition
637EFI_GUID const GPT_BOOT_GUID= { 0x426F6F74, 0x0000, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } };
638// turbo - or an efi system partition
639EFI_GUID const GPT_EFISYS_GUID= { 0xC12A7328, 0xF81F, 0x11D2, { 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B } };
640// zef - basic data partition EBD0A0A2-B9E5-4433-87C0-68B6B72699C7 for foreign OS support
641EFI_GUID const GPT_BASICDATA_GUID = { 0xEBD0A0A2, 0xB9E5, 0x4433, { 0x87, 0xC0, 0x68, 0xB6, 0xB7, 0x26, 0x99, 0xC7 } };
642EFI_GUID const GPT_BASICDATA2_GUID = { 0xE3C9E316, 0x0B5C, 0x4DB8, { 0x81, 0x7D, 0xF9, 0x2D, 0xF0, 0x02, 0x15, 0xAE } };
643
644
645BVRef newGPTBVRef( int biosdev, int partno, unsigned int blkoff,
646 const gpt_ent * part,
647 FSInit initFunc, FSLoadFile loadFunc,
648 FSReadFile readFunc,
649 FSGetDirEntry getdirFunc,
650 FSGetFileBlock getBlockFunc,
651 FSGetUUID getUUIDFunc,
652 BVGetDescription getDescriptionFunc,
653 BVFree bvFreeFunc,
654 int probe, int type, unsigned int bvrFlags )
655{
656 BVRef bvr = (BVRef) malloc( sizeof(*bvr) );
657 if ( bvr )
658 {
659 bzero(bvr, sizeof(*bvr));
660
661 bvr->biosdev = biosdev;
662 bvr->part_no = partno;
663 bvr->part_boff = blkoff;
664 bvr->fs_loadfile = loadFunc;
665 bvr->fs_readfile = readFunc;
666 bvr->fs_getdirentry = getdirFunc;
667 bvr->fs_getfileblock= getBlockFunc;
668 bvr->fs_getuuid = getUUIDFunc;
669 bvr->description = getDescriptionFunc;
670 bvr->type = type;
671 bvr->bv_free = bvFreeFunc;
672 // FIXME: UCS-2 -> UTF-8 the name
673 strlcpy(bvr->name, "----", DPISTRLEN);
674 if ( (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)part->ent_type) == 0) ||
675(efi_guid_compare(&GPT_HFS_GUID, (EFI_GUID const*)part->ent_type) == 0) )
676strlcpy(bvr->type_name, "GPT HFS+", DPISTRLEN);
677 else
678strlcpy(bvr->type_name, "GPT Unknown", DPISTRLEN);
679
680 /*
681 if ( part->bootid & FDISK_ACTIVE )
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",
696 __FUNCTION__, biosdev, partno));
697
698 (*bvr->bv_free)(bvr);
699 bvr = NULL;
700 }
701 if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 )
702 {
703 bvr->flags |= kBVFlagBootable;
704 }
705 }
706 else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 )
707 {
708 bvr->flags |= kBVFlagForeignBoot;
709 }
710 else
711 {
712 (*bvr->bv_free)(bvr);
713 bvr = NULL;
714 }
715 }
716 if (bvr) bvr->flags |= bvrFlags;
717 return bvr;
718}
719
720//==========================================================================
721
722/* A note on partition numbers:
723 * IOKit makes the primary partitions numbers 1-4, and then
724 * extended partitions are numbered consecutively 5 and up.
725 * So, for example, if you have two primary partitions and
726 * one extended partition they will be numbered 1, 2, 5.
727 */
728
729static BVRef diskScanFDiskBootVolumes( int biosdev, int * countPtr )
730{
731 const struct fdisk_part * part;
732 struct DiskBVMap * map;
733 int partno = -1;
734 BVRef bvr;
735#if UFS_SUPPORT
736 BVRef booterUFS = NULL;
737#endif
738 int spc;
739 struct driveInfo di;
740 boot_drive_info_t *dp;
741
742 /* Initialize disk info */
743 if (getDriveInfo(biosdev, &di) != 0) {
744return NULL;
745 }
746 dp = &di.di;
747 spc = (dp->params.phys_spt * dp->params.phys_heads);
748 if (spc == 0) {
749/* This is probably a CD-ROM; punt on the geometry. */
750spc = 1;
751 }
752
753 do {
754 // Create a new mapping.
755
756 map = (struct DiskBVMap *) malloc( sizeof(*map) );
757 if ( map )
758 {
759 map->biosdev = biosdev;
760 map->bvr = NULL;
761 map->bvrcnt = 0;
762 map->next = gDiskBVMap;
763 gDiskBVMap = map;
764
765 // Create a record for each partition found on the disk.
766
767 while ( getNextFDiskPartition( biosdev, &partno, &part ) )
768 {
769 DEBUG_DISK(("%s: part %d [%x]\n", __FUNCTION__,
770 partno, part->systid));
771 bvr = 0;
772
773 switch ( part->systid )
774 {
775#if UFS_SUPPORT
776 case FDISK_UFS:
777bvr = newFDiskBVRef(
778biosdev, partno,
779part->relsect + UFS_FRONT_PORCH/BPS,
780part,
781UFSInitPartition,
782UFSLoadFile,
783UFSReadFile,
784UFSGetDirEntry,
785UFSGetFileBlock,
786UFSGetUUID,
787UFSGetDescription,
788UFSFree,
7890,
790kBIOSDevTypeHardDrive, 0);
791 break;
792#endif
793
794 case FDISK_HFS:
795 bvr = newFDiskBVRef(
796biosdev, partno,
797part->relsect,
798part,
799HFSInitPartition,
800HFSLoadFile,
801HFSReadFile,
802HFSGetDirEntry,
803HFSGetFileBlock,
804HFSGetUUID,
805HFSGetDescription,
806HFSFree,
8070,
808kBIOSDevTypeHardDrive, 0);
809 break;
810
811// turbo - we want the booter type scanned also
812 case FDISK_BOOTER:
813 if (part->bootid & FDISK_ACTIVE)
814gBIOSBootVolume = newFDiskBVRef(
815biosdev, partno,
816part->relsect,
817part,
818HFSInitPartition,
819HFSLoadFile,
820HFSReadFile,
821HFSGetDirEntry,
822HFSGetFileBlock,
823HFSGetUUID,
824HFSGetDescription,
825HFSFree,
8260,
827kBIOSDevTypeHardDrive, 0);
828 break;
829
830#if UFS_SUPPORT
831 case FDISK_BOOTER:
832 booterUFS = newFDiskBVRef(
833 biosdev, partno,
834 ((part->relsect + spc - 1) / spc) * spc,
835 part,
836 UFSInitPartition,
837 UFSLoadFile,
838 UFSReadFile,
839 UFSGetDirEntry,
840 UFSGetFileBlock,
841 UFSGetUUID,
842 UFSGetDescription,
843 UFSFree,
844 0,
845 kBIOSDevTypeHardDrive, 0);
846 break;
847#endif
848
849 case FDISK_FAT32:
850 case FDISK_DOS12:
851 case FDISK_DOS16S:
852 case FDISK_DOS16B:
853 case FDISK_SMALLFAT32:
854 case FDISK_DOS16SLBA:
855bvr = newFDiskBVRef(
856biosdev, partno,
857part->relsect,
858part,
859MSDOSInitPartition,
860MSDOSLoadFile,
861MSDOSReadFile,
862MSDOSGetDirEntry,
863MSDOSGetFileBlock,
864MSDOSGetUUID,
865MSDOSGetDescription,
866MSDOSFree,
8670,
868kBIOSDevTypeHardDrive, 0);
869break;
870#ifndef OPTION_ROM
871 case FDISK_NTFS:
872bvr = newFDiskBVRef(
873biosdev, partno,
874part->relsect,
875part,
8760, 0, 0, 0, 0,
877NTFSGetUUID,
878NTFSGetDescription,
879(BVFree)free,
8800, kBIOSDevTypeHardDrive, 0);
881break;
882
883 case FDISK_LINUX:
884bvr = newFDiskBVRef(
885biosdev, partno,
886part->relsect,
887part,
8880, 0, 0, 0, 0, 0,
889EX2GetDescription,
890(BVFree)free,
8910, kBIOSDevTypeHardDrive, 0);
892break;
893#endif
894 default:
895 bvr = newFDiskBVRef(
896biosdev, partno,
897part->relsect,
898part,
8990, 0, 0, 0, 0, 0, 0,
900(BVFree)free,
9010,
902kBIOSDevTypeHardDrive, 0);
903break;
904 }
905
906 if ( bvr )
907 {
908 bvr->next = map->bvr;
909 map->bvr = bvr;
910 map->bvrcnt++;
911 }
912 }
913
914#if UFS_SUPPORT
915 // Booting from a CD with an UFS filesystem embedded
916 // in a booter partition.
917
918 if ( booterUFS )
919 {
920 if ( map->bvrcnt == 0 )
921 {
922 map->bvr = booterUFS;
923 map->bvrcnt++;
924 }
925 else free( booterUFS );
926 }
927#endif
928 }
929 } while (0);
930
931 /*
932 * If no FDisk partition, then we will check for
933 * an Apple partition map elsewhere.
934 */
935#if UNUSED
936 if (map->bvrcnt == 0) {
937static struct fdisk_part cdpart;
938cdpart.systid = 0xCD;
939
940/* Let's try assuming we are on a hybrid HFS/ISO9660 CD. */
941bvr = newFDiskBVRef(
942biosdev, 0,
9430,
944&cdpart,
945HFSInitPartition,
946HFSLoadFile,
947 HFSReadFile,
948HFSGetDirEntry,
949 HFSGetFileBlock,
950 HFSGetUUID,
9510,
952kBIOSDevTypeHardDrive);
953bvr->next = map->bvr;
954map->bvr = bvr;
955map->bvrcnt++;
956 }
957#endif
958 // Actually this should always be true given the above code
959 if(map == gDiskBVMap)
960 {
961 // Don't leave a null map in the chain
962 if(map->bvrcnt == 0 && map->bvr == NULL)
963 {
964 gDiskBVMap = map->next;
965 free(map);
966 map = NULL;
967 }
968 }
969
970 if (countPtr) *countPtr = map ? map->bvrcnt : 0;
971
972 return map ? map->bvr : NULL;
973}
974
975//==========================================================================
976
977static BVRef diskScanAPMBootVolumes( int biosdev, int * countPtr )
978{
979 struct DiskBVMap * map;
980 struct Block0 *block0_p;
981 unsigned int blksize;
982 unsigned int factor;
983 void *buffer = malloc(BPS);
984
985 /* Check for alternate block size */
986 if (readBytes( biosdev, 0, 0, BPS, buffer ) != 0) {
987 return NULL;
988 }
989 block0_p = buffer;
990 if (OSSwapBigToHostInt16(block0_p->sbSig) == BLOCK0_SIGNATURE) {
991 blksize = OSSwapBigToHostInt16(block0_p->sbBlkSize);
992 if (blksize != BPS) {
993 free(buffer);
994 buffer = malloc(blksize);
995 }
996 factor = blksize / BPS;
997 } else {
998 blksize = BPS;
999 factor = 1;
1000 }
1001
1002 do {
1003 // Create a new mapping.
1004
1005 map = (struct DiskBVMap *) malloc( sizeof(*map) );
1006 if ( map )
1007 {
1008 int error;
1009 DPME *dpme_p = (DPME *)buffer;
1010 UInt32 i, npart = UINT_MAX;
1011 BVRef bvr;
1012
1013 map->biosdev = biosdev;
1014 map->bvr = NULL;
1015 map->bvrcnt = 0;
1016 map->next = gDiskBVMap;
1017 gDiskBVMap = map;
1018
1019 for (i=0; i<npart; i++) {
1020 error = readBytes( biosdev, (kAPMSector + i) * factor, 0, blksize, buffer );
1021
1022 if (error || OSSwapBigToHostInt16(dpme_p->dpme_signature) != DPME_SIGNATURE) {
1023 break;
1024 }
1025
1026 if (i==0) {
1027 npart = OSSwapBigToHostInt32(dpme_p->dpme_map_entries);
1028 }
1029 /*
1030 printf("name = %s, %s%s %d -> %d [%d -> %d] {%d}\n",
1031 dpme.dpme_name, dpme.dpme_type, (dpme.dpme_flags & DPME_FLAGS_BOOTABLE) ? "(bootable)" : "",
1032 dpme.dpme_pblock_start, dpme.dpme_pblocks,
1033 dpme.dpme_lblock_start, dpme.dpme_lblocks,
1034 dpme.dpme_boot_block);
1035 */
1036
1037 if (strcmp(dpme_p->dpme_type, "Apple_HFS") == 0) {
1038 bvr = newAPMBVRef(biosdev,
1039 i,
1040 OSSwapBigToHostInt32(dpme_p->dpme_pblock_start) * factor,
1041 dpme_p,
1042 HFSInitPartition,
1043 HFSLoadFile,
1044 HFSReadFile,
1045 HFSGetDirEntry,
1046 HFSGetFileBlock,
1047 HFSGetUUID,
1048 HFSGetDescription,
1049 HFSFree,
1050 0,
1051 kBIOSDevTypeHardDrive, 0);
1052 bvr->next = map->bvr;
1053 map->bvr = bvr;
1054 map->bvrcnt++;
1055 }
1056 }
1057 }
1058 } while (0);
1059
1060 free(buffer);
1061
1062 if (countPtr) *countPtr = map ? map->bvrcnt : 0;
1063
1064 return map ? map->bvr : NULL;
1065}
1066
1067//==========================================================================
1068
1069// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1070
1071/*
1072 * Trying to figure out the filsystem type of a given partition.
1073 */
1074static int probeFileSystem(int biosdev, unsigned int blkoff)
1075{
1076// detected filesystem type;
1077int result = -1;
1078int fatbits;
1079
1080// Allocating buffer for 4 sectors.
1081const void * probeBuffer = malloc(PROBEFS_SIZE);
1082if (probeBuffer == NULL)
1083goto exit;
1084
1085// Reading first 4 sectors of current partition
1086int error = readBytes(biosdev, blkoff, 0, PROBEFS_SIZE, (void *)probeBuffer);
1087if (error)
1088goto exit;
1089
1090if (HFSProbe(probeBuffer))
1091result = FDISK_HFS;
1092#ifndef OPTION_ROM
1093else if (EX2Probe(probeBuffer))
1094result = FDISK_LINUX;
1095else if (NTFSProbe(probeBuffer))
1096result = FDISK_NTFS;
1097#endif
1098else if (fatbits=MSDOSProbe(probeBuffer))
1099{
1100switch (fatbits)
1101{
1102case 32:
1103default:
1104result = FDISK_FAT32;
1105break;
1106case 16:
1107result = FDISK_DOS16B;
1108break;
1109case 12:
1110result = FDISK_DOS12;
1111break;
1112}
1113}
1114else
1115// Couldn't detect filesystem type
1116result = 0;
1117
1118exit:
1119if (probeBuffer != NULL) free((void *)probeBuffer);
1120return result;
1121}
1122
1123static bool isPartitionUsed(gpt_ent * partition)
1124{
1125 //
1126 // Ask whether the given partition is used.
1127 //
1128
1129 return efi_guid_is_null((EFI_GUID const*)partition->ent_type) ? false : true;
1130}
1131
1132// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1133
1134static BVRef diskScanGPTBootVolumes( int biosdev, int * countPtr )
1135{
1136 struct DiskBVMap * map = NULL;
1137 void *buffer = malloc(BPS);
1138 int error;
1139 if ( error = readBytes( biosdev, /*secno*/0, 0, BPS, buffer ) != 0) {
1140 verbose("Failed to read boot sector from BIOS device %02xh. Error=%d\n", biosdev, error);
1141 goto scanErr;
1142 }
1143 struct REAL_disk_blk0 *fdiskMap = buffer;
1144 if ( OSSwapLittleToHostInt16(fdiskMap->signature) != DISK_SIGNATURE )
1145 {
1146 verbose("Failed to find boot signature on BIOS device %02xh\n", biosdev);
1147 goto scanErr;
1148 }
1149
1150 int fdiskID = 0;
1151 unsigned index;
1152 for ( index = 0; index < FDISK_NPART; index++ )
1153 {
1154 if ( fdiskMap->parts[index].systid )
1155 {
1156 if ( fdiskMap->parts[index].systid == 0xEE )
1157 {
1158 // Fail if two 0xEE partitions are present which
1159 // means the FDISK code will wind up parsing it.
1160 if ( fdiskID ) goto scanErr;
1161
1162 fdiskID = index + 1;
1163 }
1164 }
1165 }
1166
1167 if ( fdiskID == 0 ) goto scanErr;
1168 verbose("Attempting to read GPT\n");
1169
1170 if(readBytes(biosdev, 1, 0, BPS, buffer) != 0)
1171 goto scanErr;
1172
1173 gpt_hdr *headerMap = buffer;
1174
1175 // Determine whether the partition header signature is present.
1176
1177 if ( memcmp(headerMap->hdr_sig, GPT_HDR_SIG, strlen(GPT_HDR_SIG)) )
1178 {
1179 goto scanErr;
1180 }
1181
1182 // Determine whether the partition header size is valid.
1183
1184 UInt32 headerCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_self);
1185 UInt32 headerSize = OSSwapLittleToHostInt32(headerMap->hdr_size);
1186
1187 if ( headerSize < offsetof(gpt_hdr, padding) )
1188 {
1189 goto scanErr;
1190 }
1191
1192 if ( headerSize > BPS )
1193 {
1194 goto scanErr;
1195 }
1196
1197 // Determine whether the partition header checksum is valid.
1198
1199 headerMap->hdr_crc_self = 0;
1200
1201 if ( crc32(0, headerMap, headerSize) != headerCheck )
1202 {
1203 goto scanErr;
1204 }
1205
1206 // Determine whether the partition entry size is valid.
1207
1208 UInt64 gptBlock = 0;
1209 UInt32 gptCheck = 0;
1210 UInt32 gptCount = 0;
1211 UInt32 gptID = 0;
1212 gpt_ent * gptMap = 0;
1213 UInt32 gptSize = 0;
1214
1215 gptBlock = OSSwapLittleToHostInt64(headerMap->hdr_lba_table);
1216 gptCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_table);
1217 gptCount = OSSwapLittleToHostInt32(headerMap->hdr_entries);
1218 gptSize = OSSwapLittleToHostInt32(headerMap->hdr_entsz);
1219
1220 if ( gptSize < sizeof(gpt_ent) )
1221 {
1222 goto scanErr;
1223 }
1224
1225 // Allocate a buffer large enough to hold one map, rounded to a media block.
1226 free(buffer);
1227 buffer = NULL;
1228
1229 UInt32 bufferSize = IORound(gptCount * gptSize, BPS);
1230 if(bufferSize == 0)
1231 goto scanErr;
1232 buffer = malloc(bufferSize);
1233
1234 if(readBytes(biosdev, gptBlock, 0, bufferSize, buffer) != 0)
1235 goto scanErr;
1236
1237 verbose("Read GPT\n");
1238
1239 // Allocate a new map for this BIOS device and insert it into the chain
1240 map = malloc(sizeof(*map));
1241 map->biosdev = biosdev;
1242 map->bvr = NULL;
1243 map->bvrcnt = 0;
1244 map->next = gDiskBVMap;
1245 gDiskBVMap = map;
1246
1247 // fdisk like partition type id.
1248 int fsType = 0;
1249
1250 for(gptID = 1; gptID <= gptCount; ++gptID)
1251 {
1252BVRef bvr = NULL;
1253unsigned int bvrFlags = 0;
1254
1255 // size on disk can be larger than sizeof(gpt_ent)
1256 gptMap = (gpt_ent *) ( buffer + ( (gptID - 1) * gptSize) );
1257
1258 // NOTE: EFI_GUID's are in LE and we know we're on an x86.
1259 // The IOGUIDPartitionScheme.cpp code uses byte-based UUIDs, we don't.
1260
1261 if(isPartitionUsed(gptMap))
1262 {
1263 char stringuuid[100];
1264 efi_guid_unparse_upper((EFI_GUID*)gptMap->ent_type, stringuuid);
1265 verbose("Reading GPT partition %d, type %s\n", gptID, stringuuid);
1266
1267 // Getting fdisk like partition type.
1268 fsType = probeFileSystem(biosdev, gptMap->ent_lba_start);
1269
1270 if ( (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ||
1271(efi_guid_compare(&GPT_HFS_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) )
1272 {
1273 bvrFlags = (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ? kBVFlagBooter : 0;
1274 bvr = newGPTBVRef(biosdev,
1275 gptID,
1276 gptMap->ent_lba_start,
1277 gptMap,
1278 HFSInitPartition,
1279 HFSLoadFile,
1280 HFSReadFile,
1281 HFSGetDirEntry,
1282 HFSGetFileBlock,
1283 HFSGetUUID,
1284 HFSGetDescription,
1285 HFSFree,
1286 0,
1287 kBIOSDevTypeHardDrive, bvrFlags);
1288 }
1289
1290// zef - foreign OS support
1291 if ( (efi_guid_compare(&GPT_BASICDATA_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ||
1292(efi_guid_compare(&GPT_BASICDATA2_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) )
1293 {
1294
1295switch (fsType)
1296{
1297#ifndef OPTION_ROM
1298case FDISK_NTFS:
1299bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,
1300 0, 0, 0, 0, 0, 0, NTFSGetDescription,
1301 (BVFree)free, 0, kBIOSDevTypeHardDrive, 0);
1302break;
1303#endif
1304default:
1305bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,
1306 0, 0, 0, 0, 0, 0, 0,
1307 (BVFree)free, 0, kBIOSDevTypeHardDrive, 0);
1308break;
1309}
1310
1311 }
1312
1313 // turbo - save our booter partition
1314 // zef - only on original boot device
1315 if ( (efi_guid_compare(&GPT_EFISYS_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) )
1316 {
1317switch (fsType)
1318{
1319case FDISK_HFS:
1320if (readBootSector( biosdev, gptMap->ent_lba_start, (void *)0x7e00 ) == 0)
1321{
1322bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,
1323 HFSInitPartition,
1324 HFSLoadFile,
1325 HFSReadFile,
1326 HFSGetDirEntry,
1327 HFSGetFileBlock,
1328 HFSGetUUID,
1329 HFSGetDescription,
1330 HFSFree,
1331 0, kBIOSDevTypeHardDrive, kBVFlagEFISystem);
1332}
1333break;
1334
1335case FDISK_FAT32:
1336if (testFAT32EFIBootSector( biosdev, gptMap->ent_lba_start, (void *)0x7e00 ) == 0)
1337{
1338bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap,
1339 MSDOSInitPartition,
1340 MSDOSLoadFile,
1341 MSDOSReadFile,
1342 MSDOSGetDirEntry,
1343 MSDOSGetFileBlock,
1344 MSDOSGetUUID,
1345 MSDOSGetDescription,
1346 MSDOSFree,
1347 0, kBIOSDevTypeHardDrive, kBVFlagEFISystem);
1348}
1349break;
1350
1351if (biosdev == gBIOSDev)
1352gBIOSBootVolume = bvr;
1353}
1354 }
1355
1356if (bvr)
1357{
1358// Fixup bvr with the fake fdisk partition type.
1359if (fsType > 0) bvr->part_type = fsType;
1360
1361bvr->next = map->bvr;
1362map->bvr = bvr;
1363++map->bvrcnt;
1364}
1365
1366 }
1367 }
1368
1369scanErr:
1370 free(buffer);
1371
1372 if(map)
1373 {
1374 if(countPtr) *countPtr = map->bvrcnt;
1375 return map->bvr;
1376 }
1377 else
1378 {
1379 if(countPtr) *countPtr = 0;
1380 return NULL;
1381 }
1382}
1383
1384//==========================================================================
1385
1386static void scanFSLevelBVRSettings(BVRef chain)
1387{
1388BVRef bvr;
1389char dirSpec[512], fileSpec[512];
1390char label[BVSTRLEN];
1391int ret;
1392long flags, time;
1393int fh, fileSize, error;
1394
1395for (bvr = chain; bvr; bvr = bvr->next)
1396{
1397ret = -1;
1398error = 0;
1399
1400//
1401// Check for alternate volume label on boot helper partitions.
1402//
1403if (bvr->flags & kBVFlagBooter)
1404{
1405sprintf(dirSpec, "hd(%d,%d)/System/Library/CoreServices/", BIOS_DEV_UNIT(bvr), bvr->part_no);
1406strcpy(fileSpec, ".disk_label.contentDetails");
1407ret = GetFileInfo(dirSpec, fileSpec, &flags, &time);
1408if (!ret)
1409{
1410fh = open(strcat(dirSpec, fileSpec), 0);
1411fileSize = file_size(fh);
1412if (fileSize > 0 && fileSize < BVSTRLEN)
1413{
1414if (read(fh, label, fileSize) != fileSize)
1415error = -1;
1416}
1417else
1418error = -1;
1419
1420close(fh);
1421
1422if (!error)
1423{
1424label[fileSize] = '\0';
1425strcpy(bvr->altlabel, label);
1426}
1427}
1428}
1429
1430//
1431// Check for SystemVersion.plist or ServerVersion.plist
1432// to determine if a volume hosts an installed system.
1433//
1434if (bvr->flags & kBVFlagNativeBoot)
1435{
1436sprintf(dirSpec, "hd(%d,%d)/System/Library/CoreServices/", BIOS_DEV_UNIT(bvr), bvr->part_no);
1437strcpy(fileSpec, "SystemVersion.plist");
1438ret = GetFileInfo(dirSpec, fileSpec, &flags, &time);
1439
1440if (ret == -1)
1441{
1442strcpy(fileSpec, "ServerVersion.plist");
1443ret = GetFileInfo(dirSpec, fileSpec, &flags, &time);
1444}
1445
1446if (!ret)
1447bvr->flags |= kBVFlagSystemVolume;
1448}
1449
1450}
1451}
1452#ifndef OPTION_ROM
1453void rescanBIOSDevice(int biosdev)
1454{
1455struct DiskBVMap *oldMap = diskResetBootVolumes(biosdev);
1456CacheReset();
1457diskFreeMap(oldMap);
1458oldMap = NULL;
1459scanBootVolumes(biosdev, 0);
1460}
1461#endif
1462
1463struct DiskBVMap* diskResetBootVolumes(int biosdev)
1464{
1465 struct DiskBVMap * map;
1466 struct DiskBVMap *prevMap = NULL;
1467 for ( map = gDiskBVMap; map; prevMap = map, map = map->next ) {
1468 if ( biosdev == map->biosdev ) {
1469 break;
1470 }
1471 }
1472 if(map != NULL)
1473 {
1474 verbose("Resetting BIOS device %xh\n", biosdev);
1475 // Reset the biosbuf cache
1476 cache_valid = false;
1477 if(map == gDiskBVMap)
1478 gDiskBVMap = map->next;
1479 else if(prevMap != NULL)
1480 prevMap->next = map->next;
1481 else
1482 stop("");
1483 }
1484 // Return the old map, either to be freed, or reinserted later
1485 return map;
1486}
1487
1488// Frees a DiskBVMap and all of its BootVolume's
1489void diskFreeMap(struct DiskBVMap *map)
1490{
1491 if(map != NULL)
1492 {
1493 while(map->bvr != NULL)
1494 {
1495 BVRef bvr = map->bvr;
1496 map->bvr = bvr->next;
1497 (*bvr->bv_free)(bvr);
1498 }
1499 free(map);
1500 }
1501}
1502
1503BVRef diskScanBootVolumes( int biosdev, int * countPtr )
1504{
1505 struct DiskBVMap * map;
1506 BVRef bvr;
1507 int count = 0;
1508
1509 // Find an existing mapping for this device.
1510
1511 for ( map = gDiskBVMap; map; map = map->next ) {
1512 if ( biosdev == map->biosdev ) {
1513 count = map->bvrcnt;
1514 break;
1515 }
1516 }
1517
1518 if (map == NULL) {
1519 bvr = diskScanGPTBootVolumes(biosdev, &count);
1520 if (bvr == NULL) {
1521bvr = diskScanFDiskBootVolumes(biosdev, &count);
1522 }
1523 if (bvr == NULL) {
1524bvr = diskScanAPMBootVolumes(biosdev, &count);
1525 }
1526 if (bvr)
1527 {
1528scanFSLevelBVRSettings(bvr);
1529 }
1530 } else {
1531 bvr = map->bvr;
1532 }
1533 if (countPtr) *countPtr += count;
1534 return bvr;
1535}
1536
1537BVRef getBVChainForBIOSDev(int biosdev)
1538{
1539BVRef chain = NULL;
1540struct DiskBVMap * map = NULL;
1541
1542for (map = gDiskBVMap; map; map = map->next)
1543{
1544if (map->biosdev == biosdev)
1545{
1546chain = map->bvr;
1547break;
1548}
1549}
1550
1551return chain;
1552}
1553
1554BVRef newFilteredBVChain(int minBIOSDev, int maxBIOSDev, unsigned int allowFlags, unsigned int denyFlags, int *count)
1555{
1556BVRef chain = NULL;
1557BVRef bvr = NULL;
1558BVRef newBVR = NULL;
1559BVRef prevBVR = NULL;
1560
1561struct DiskBVMap * map = NULL;
1562int bvCount = 0;
1563
1564const char *raw = 0;
1565char* val = 0;
1566int len;
1567
1568getValueForKey(kHidePartition, &raw, &len, &bootInfo->bootConfig);
1569if(raw)
1570{
1571val = XMLDecode(raw);
1572}
1573
1574/*
1575 * Traverse gDISKBVmap to get references for
1576 * individual bvr chains of each drive.
1577 */
1578for (map = gDiskBVMap; map; map = map->next)
1579{
1580for (bvr = map->bvr; bvr; bvr = bvr->next)
1581{
1582/*
1583 * Save the last bvr.
1584 */
1585if (newBVR) prevBVR = newBVR;
1586
1587/*
1588 * Allocate and copy the matched bvr entry into a new one.
1589 */
1590newBVR = (BVRef) malloc(sizeof(*newBVR));
1591bcopy(bvr, newBVR, sizeof(*newBVR));
1592
1593/*
1594 * Adjust the new bvr's fields.
1595 */
1596newBVR->next = NULL;
1597newBVR->filtered = true;
1598
1599if ( (!allowFlags || newBVR->flags & allowFlags)
1600&& (!denyFlags || !(newBVR->flags & denyFlags) )
1601&& (newBVR->biosdev >= minBIOSDev && newBVR->biosdev <= maxBIOSDev)
1602)
1603newBVR->visible = true;
1604
1605/* Looking for "Hide Partition" entries in 'hd(x,y)|uuid|"label" hd(m,n)|uuid|"label"' format
1606 * to be able to hide foreign partitions from the boot menu.
1607 */
1608if ( (newBVR->flags & kBVFlagForeignBoot) )
1609{
1610char *start, *next = val;
1611long len = 0;
1612do
1613{
1614start = strbreak(next, &next, &len);
1615if(len && matchVolumeToString(newBVR, start, len) )
1616newBVR->visible = false;
1617}
1618while ( next && *next );
1619}
1620
1621/*
1622 * Use the first bvr entry as the starting chain pointer.
1623 */
1624if (!chain)
1625chain = newBVR;
1626
1627/*
1628 * Update the previous bvr's link pointer to use the new memory area.
1629 */
1630if (prevBVR)
1631prevBVR->next = newBVR;
1632
1633if (newBVR->visible)
1634bvCount++;
1635}
1636}
1637
1638#if DEBUG
1639for (bvr = chain; bvr; bvr = bvr->next)
1640{
1641printf(" bvr: %d, dev: %d, part: %d, flags: %d, vis: %d\n", bvr, bvr->biosdev, bvr->part_no, bvr->flags, bvr->visible);
1642}
1643printf("count: %d\n", bvCount);
1644getc();
1645#endif
1646
1647*count = bvCount;
1648
1649free(val);
1650return chain;
1651}
1652
1653int freeFilteredBVChain(const BVRef chain)
1654{
1655int ret = 1;
1656BVRef bvr = chain;
1657BVRef nextBVR = NULL;
1658
1659while (bvr)
1660{
1661nextBVR = bvr->next;
1662
1663if (bvr->filtered)
1664{
1665free(bvr);
1666}
1667else
1668{
1669ret = 0;
1670break;
1671}
1672
1673bvr = nextBVR;
1674}
1675
1676return ret;
1677}
1678
1679//==========================================================================
1680
1681static const struct NamedValue fdiskTypes[] =
1682{
1683#ifndef OPTION_ROM
1684 { FDISK_NTFS, "Windows NTFS" },
1685#endif
1686{ FDISK_DOS12, "Windows FAT12" },
1687{ FDISK_DOS16B, "Windows FAT16" },
1688{ FDISK_DOS16S, "Windows FAT16" },
1689{ FDISK_DOS16SLBA, "Windows FAT16" },
1690{ FDISK_SMALLFAT32, "Windows FAT32" },
1691{ FDISK_FAT32, "Windows FAT32" },
1692#ifndef OPTION_ROM
1693 { FDISK_LINUX, "Linux" },
1694#endif
1695 { FDISK_UFS, "Apple UFS" },
1696 { FDISK_HFS, "Apple HFS" },
1697 { FDISK_BOOTER, "Apple Boot/UFS" },
1698 { 0xCD, "CD-ROM" },
1699 { 0x00, 0 } /* must be last */
1700};
1701
1702//==========================================================================
1703
1704bool matchVolumeToString( BVRef bvr, const char* match, long matchLen)
1705{
1706char testStr[128];
1707
1708if ( !bvr || !match || !*match)
1709return 0;
1710
1711if ( bvr->biosdev < 0x80 || bvr->biosdev >= 0x100 )
1712 return 0;
1713
1714 // Try to match hd(x,y) first.
1715 sprintf(testStr, "hd(%d,%d)", BIOS_DEV_UNIT(bvr), bvr->part_no);
1716 if ( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) )
1717 return true;
1718
1719 // Try to match volume UUID.
1720 if ( bvr->fs_getuuid && bvr->fs_getuuid(bvr, testStr) == 0)
1721 {
1722 if( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) )
1723 return true;
1724 }
1725
1726 // Try to match volume label (always quoted).
1727 if ( bvr->description )
1728 {
1729 bvr->description(bvr, testStr, sizeof(testStr)-1);
1730 if( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) )
1731 return true;
1732 }
1733
1734 return false;
1735}
1736
1737/* If Rename Partition has defined an alias, then extract it for description purpose
1738 * The format for the rename string is the following:
1739 * hd(x,y)|uuid|"label" "alias";hd(m,n)|uuid|"label" etc; ...
1740 */
1741
1742bool getVolumeLabelAlias(BVRef bvr, char* str, long strMaxLen)
1743{
1744 char *aliasList, *entryStart, *entryNext;
1745
1746 if ( !str || strMaxLen <= 0)
1747 return false;
1748
1749 aliasList = XMLDecode(getStringForKey(kRenamePartition, &bootInfo->bootConfig));
1750 if ( !aliasList )
1751 return false;
1752
1753 for ( entryStart = entryNext = aliasList;
1754 entryNext && *entryNext;
1755 entryStart = entryNext )
1756 {
1757 char *volStart, *volEnd, *aliasStart;
1758 long volLen, aliasLen;
1759
1760 // Delimit current entry
1761 entryNext = strchr(entryStart, ';');
1762 if ( entryNext )
1763 {
1764 *entryNext = '\0';
1765 entryNext++;
1766 }
1767
1768 volStart = strbreak(entryStart, &volEnd, &volLen);
1769 if(!volLen)
1770 continue;
1771
1772 aliasStart = strbreak(volEnd, 0, &aliasLen);
1773 if(!aliasLen)
1774 continue;
1775
1776 if ( matchVolumeToString(bvr, volStart, volLen) )
1777 {
1778 strncat(str, aliasStart, min(strMaxLen, aliasLen));
1779 free(aliasList);
1780
1781 return true;
1782 }
1783 }
1784
1785 free(aliasList);
1786 return false;
1787}
1788
1789void getBootVolumeDescription( BVRef bvr, char * str, long strMaxLen, bool useDeviceDescription )
1790{
1791 unsigned char type;
1792 char *p = str;
1793
1794 if(!bvr || !p || strMaxLen <= 0)
1795 return;
1796
1797 type = (unsigned char) bvr->part_type;
1798
1799 if (useDeviceDescription)
1800 {
1801 int len = getDeviceDescription(bvr, str);
1802 if(len >= strMaxLen)
1803 return;
1804
1805 strcpy(str + len, " ");
1806 len++;
1807 strMaxLen -= len;
1808 p += len;
1809 }
1810
1811 /* See if a partition rename is preferred */
1812 if(getVolumeLabelAlias(bvr, p, strMaxLen)) {
1813 strncpy(bvr->label, p, strMaxLen);
1814 return; // we're done here no need to seek for real name
1815 }
1816
1817 //
1818 // Get the volume label using filesystem specific functions
1819 // or use the alternate volume label if available.
1820 //
1821if (*bvr->altlabel != '\0')
1822 strncpy(p, bvr->altlabel, strMaxLen);
1823else if (bvr->description)
1824 bvr->description(bvr, p, strMaxLen);
1825
1826 if (*p == '\0') {
1827 const char * name = getNameForValue( fdiskTypes, type );
1828 if (name == NULL) {
1829 name = bvr->type_name;
1830 }
1831 if (name == NULL) {
1832 sprintf(p, "TYPE %02x", type);
1833 } else {
1834 strncpy(p, name, strMaxLen);
1835 }
1836 }
1837
1838 // Set the devices label
1839 sprintf(bvr->label, p);
1840}
1841
1842//==========================================================================
1843int readBootSector( int biosdev, unsigned int secno, void * buffer )
1844{
1845 struct disk_blk0 * bootSector = (struct disk_blk0 *) buffer;
1846 int error;
1847
1848 if ( bootSector == NULL )
1849 {
1850 if ( gBootSector == NULL )
1851 {
1852 gBootSector = (struct disk_blk0 *) malloc(sizeof(*gBootSector));
1853 if ( gBootSector == NULL ) return -1;
1854 }
1855 bootSector = gBootSector;
1856 }
1857
1858 error = readBytes( biosdev, secno, 0, BPS, bootSector );
1859 if ( error || bootSector->signature != DISK_SIGNATURE )
1860 return -1;
1861
1862 return 0;
1863}
1864
1865/*
1866 * Format of boot1f32 block.
1867 */
1868
1869#define BOOT1F32_MAGIC "BOOT "
1870#define BOOT1F32_MAGICLEN 11
1871
1872struct disk_boot1f32_blk {
1873 unsigned char init[3];
1874 unsigned char fsheader[87];
1875 unsigned char magic[BOOT1F32_MAGICLEN];
1876 unsigned char bootcode[409];
1877 unsigned short signature;
1878};
1879
1880int testFAT32EFIBootSector( int biosdev, unsigned int secno, void * buffer )
1881{
1882 struct disk_boot1f32_blk * bootSector = (struct disk_boot1f32_blk *) buffer;
1883 int error;
1884
1885 if ( bootSector == NULL )
1886 {
1887 if ( gBootSector == NULL )
1888 {
1889 gBootSector = (struct disk_blk0 *) malloc(sizeof(*gBootSector));
1890 if ( gBootSector == NULL ) return -1;
1891 }
1892 bootSector = (struct disk_boot1f32_blk *) gBootSector;
1893 }
1894
1895 error = readBytes( biosdev, secno, 0, BPS, bootSector );
1896 if ( error || bootSector->signature != DISK_SIGNATURE
1897|| strncmp((const char *)bootSector->magic, BOOT1F32_MAGIC, BOOT1F32_MAGICLEN) )
1898return -1;
1899
1900 return 0;
1901}
1902
1903//==========================================================================
1904// Handle seek request from filesystem modules.
1905
1906void diskSeek( BVRef bvr, long long position )
1907{
1908 bvr->fs_boff = position / BPS;
1909 bvr->fs_byteoff = position % BPS;
1910}
1911
1912//==========================================================================
1913// Handle read request from filesystem modules.
1914
1915int diskRead( BVRef bvr, long addr, long length )
1916{
1917 return readBytes( bvr->biosdev,
1918 bvr->fs_boff + bvr->part_boff,
1919 bvr->fs_byteoff,
1920 length,
1921 (void *) addr );
1922}
1923
1924int rawDiskRead( BVRef bvr, unsigned int secno, void *buffer, unsigned int len )
1925{
1926 int secs;
1927 unsigned char *cbuf = (unsigned char *)buffer;
1928 unsigned int copy_len;
1929 int rc;
1930
1931 if ((len & (BPS-1)) != 0) {
1932 error("raw disk read not sector aligned");
1933 return -1;
1934 }
1935 secno += bvr->part_boff;
1936
1937 cache_valid = false;
1938
1939 while (len > 0) {
1940 secs = len / BPS;
1941 if (secs > N_CACHE_SECS) secs = N_CACHE_SECS;
1942 copy_len = secs * BPS;
1943
1944 //printf("rdr: ebiosread(%d, %d, %d)\n", bvr->biosdev, secno, secs);
1945 if ((rc = ebiosread(bvr->biosdev, secno, secs)) != 0) {
1946 /* Ignore corrected ECC errors */
1947 if (rc != ECC_CORRECTED_ERR) {
1948 error(" EBIOS read error: %s\n", bios_error(rc), rc);
1949 error(" Block %d Sectors %d\n", secno, secs);
1950 return rc;
1951 }
1952 }
1953 bcopy( trackbuf, cbuf, copy_len );
1954 len -= copy_len;
1955 cbuf += copy_len;
1956 secno += secs;
1957 spinActivityIndicator(secs);
1958 }
1959
1960 return 0;
1961}
1962
1963int rawDiskWrite( BVRef bvr, unsigned int secno, void *buffer, unsigned int len )
1964{
1965 int secs;
1966 unsigned char *cbuf = (unsigned char *)buffer;
1967 unsigned int copy_len;
1968 int rc;
1969
1970 if ((len & (BPS-1)) != 0) {
1971 error("raw disk write not sector aligned");
1972 return -1;
1973 }
1974 secno += bvr->part_boff;
1975
1976 cache_valid = false;
1977
1978 while (len > 0) {
1979 secs = len / BPS;
1980 if (secs > N_CACHE_SECS) secs = N_CACHE_SECS;
1981 copy_len = secs * BPS;
1982
1983 bcopy( cbuf, trackbuf, copy_len );
1984 //printf("rdr: ebioswrite(%d, %d, %d)\n", bvr->biosdev, secno, secs);
1985 if ((rc = ebioswrite(bvr->biosdev, secno, secs)) != 0) {
1986 error(" EBIOS write error: %s\n", bios_error(rc), rc);
1987 error(" Block %d Sectors %d\n", secno, secs);
1988 return rc;
1989 }
1990 len -= copy_len;
1991 cbuf += copy_len;
1992 secno += secs;
1993 spinActivityIndicator(secs);
1994 }
1995
1996 return 0;
1997}
1998
1999
2000int diskIsCDROM(BVRef bvr)
2001{
2002 struct driveInfo di;
2003
2004 if (getDriveInfo(bvr->biosdev, &di) == 0 && di.no_emulation) {
2005return 1;
2006 }
2007 return 0;
2008}
2009
2010int biosDevIsCDROM(int biosdev)
2011{
2012 struct driveInfo di;
2013
2014 if (getDriveInfo(biosdev, &di) == 0 && di.no_emulation)
2015 {
2016 return 1;
2017 }
2018 return 0;
2019}
2020

Archive Download this file

Revision: 536