/* * Copyright (c) 1999-2003 Apple Computer, Inc. All rights reserved. * * @APPLE_LICENSE_HEADER_START@ * * Portions Copyright (c) 1999-2003 Apple Computer, Inc. All Rights * Reserved. This file contains Original Code and/or Modifications of * Original Code as defined in and that are subject to the Apple Public * Source License Version 2.0 (the "License"). You may not use this file * except in compliance with the License. Please obtain a copy of the * License at http://www.apple.com/publicsource and read it before using * this file. * * The Original Code and all software distributed under the License are * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE OR NON- INFRINGEMENT. Please see the * License for the specific language governing rights and limitations * under the License. * * @APPLE_LICENSE_HEADER_END@ */ /* * Mach Operating System * Copyright (c) 1990 Carnegie-Mellon University * Copyright (c) 1989 Carnegie-Mellon University * All rights reserved. The CMU software License Agreement specifies * the terms and conditions for use and redistribution. */ /* * INTEL CORPORATION PROPRIETARY INFORMATION * * This software is supplied under the terms of a license agreement or * nondisclosure agreement with Intel Corporation and may not be copied * nor disclosed except in accordance with the terms of that agreement. * * Copyright 1988, 1989 Intel Corporation */ /* * Copyright 1993 NeXT Computer, Inc. * All rights reserved. */ /* Copyright 2007 VMware Inc. "Preboot" ramdisk support added by David Elliott GPT support added by David Elliott. Based on IOGUIDPartitionScheme.cpp. */ #include "libsaio.h" #include "bootstruct.h" #include "platform.h" #include "sl.h" #include "convert.h" #include "fdisk.h" #ifdef UFS_SUPPORT #include "ufs.h" #define UFS_FRONT_PORCH 0 #endif #include "hfs.h" #ifndef NO_WIN_SUPPORT #include "ntfs.h" #include "msdos.h" #endif #ifndef NO_LINUX_SUPPORT #include "ext2fs.h" #endif #ifndef NO_OTHERS_BSD_SUPPORT #include "freebsd.h" #include "openbsd.h" #endif #ifndef NO_HAIKU_SUPPORT #include "befs.h" #endif #include "xml.h" #include "disk.h" #include "modules.h" #ifndef DEBUG_DISK #define DEBUG_DISK 0 #endif #if DEBUG_DISK==2 #define DBG(x...) {printf(x); sleep(1);} #elif DEBUG_DISK==1 #define DBG(x...) printf(x) #else #define DBG(x...) #endif #ifndef MIN #define MIN(x, y) ((x) < (y) ? (x) : (y)) #endif #ifndef MAX #define MAX(x, y) ((x) > (y) ? (x) : (y)) #endif #ifdef APPLE_PARTITION_MAP_SUPPORT #define UINT_MAX 0xffffffff /* max value for an unsigned int, defined in . */ #include #define kAPMSector 2 /* Sector number of Apple partition map */ #define kAPMCDSector 8 /* Translated sector of Apple partition map on a CD */ #else #define DPISTRLEN 32 // Defined in . #endif #include typedef struct gpt_hdr gpt_hdr; typedef struct gpt_ent gpt_ent; // For EFI_GUID #include "efi.h" #include "efi_tables.h" #define PROBEFS_SIZE BPS * 4 /* buffer size for filesystem probe */ #define N_CACHE_SECS (BIOS_LEN / BPS) /* Must be a multiple of 4 for CD-ROMs */ #if UNUSED #define CD_BPS 2048 /* CD-ROM block size */ #endif /* * IORound and IOTrunc convenience functions, in the spirit * of vm's round_page() and trunc_page(). */ #define IORound(value,multiple) \ ((((value) + (multiple) - 1) / (multiple)) * (multiple)) /* #define IOTrunc(value,multiple) \ (((value) / (multiple)) * (multiple)); */ /* * trackbuf points to the start of the track cache. Biosread() * will store the sectors read from disk to this memory area. * * biosbuf points to a sector within the track cache, and is * updated by Biosread(). */ static char * const trackbuf = (char *) ptov(BIOS_ADDR); static char * biosbuf; /* * Map a disk drive to bootable volumes contained within. */ struct DiskBVMap { int biosdev; // BIOS device number (unique) BVRef bvr; // chain of boot volumes on the disk int bvrcnt; // number of boot volumes struct DiskBVMap * next; // linkage to next mapping }; static struct DiskBVMap * gDiskBVMap = NULL; static struct disk_blk0 * gBootSector = NULL; #if TEXT_SPINNER extern void spinActivityIndicator(int sectors); #endif struct NamedValue { unsigned char value; const char * name; }; static int getDriveInfo( int biosdev, struct driveInfo *dip ); static const char * getNameForValue( const struct NamedValue * nameTable, unsigned char value ); static int Biosread( int biosdev, unsigned long long secno ); static int readBytes( int biosdev, unsigned long long blkno, unsigned int byteoff, unsigned int byteCount, void * buffer ); static int isExtendedFDiskPartition( const struct fdisk_part * part ); static int getNextFDiskPartition( int biosdev, int * partno, const struct fdisk_part ** outPart ); static BVRef newFDiskBVRef( int biosdev, int partno, unsigned int blkoff, const struct fdisk_part * part, FSInit initFunc, FSLoadFile loadFunc, FSReadFile readFunc, FSGetDirEntry getdirFunc, FSGetFileBlock getBlockFunc, FSGetUUID getUUIDFunc, BVGetDescription getDescriptionFunc, BVFree bvFreeFunc, int probe, int type, unsigned int bvrFlags ); static BVRef diskScanFDiskBootVolumes( int biosdev, int * countPtr ); static int probeFileSystem(int biosdev, unsigned int blkoff); static bool isPartitionUsed(gpt_ent * partition); static BVRef diskScanGPTBootVolumes( int biosdev, int * countPtr ); static void scanFSLevelBVRSettings(BVRef chain); #ifdef APPLE_PARTITION_MAP_SUPPORT static BVRef diskScanAPMBootVolumes( int biosdev, int * countPtr ); #endif static TagPtr XMLGetElementWithID( TagPtr dict, const char* id ); static bool getOSVersion(BVRef bvr, char *str); static bool CheckDarwin(BVRef bvr); static bool getOSInstallVersion(const char *dirSpec, char *str, config_file_t *systemVersion); static bool getOSInstallURL(BVRef bvr, const char *dirSpec, config_file_t *config_file); static BVRef newGPTBVRef( int biosdev, int partno, unsigned int blkoff, const gpt_ent * part, FSInit initFunc, FSLoadFile loadFunc, FSReadFile readFunc, FSGetDirEntry getdirFunc, FSGetFileBlock getBlockFunc, FSGetUUID getUUIDFunc, BVGetDescription getDescriptionFunc, BVFree bvFreeFunc, int probe, int type, unsigned int bvrFlags ); static bool getVolumeLabelAlias(BVRef bvr, char* str, long strMaxLen); //========================================================================== static int getDriveInfo( int biosdev, struct driveInfo *dip ) { static struct driveInfo cached_di; int cc; #ifndef OPTION_ROM // Real BIOS devices are 8-bit, so anything above that is for internal use. // Don't cache ramdisk drive info since it doesn't require several BIOS // calls and is thus not worth it. if(biosdev >= 0x100 && execute_hook("isRamDiskRegistred", NULL, NULL, NULL, NULL, NULL, NULL) == EFI_SUCCESS) { int ret = 0; execute_hook("p_get_ramdisk_info", &biosdev, (void *)dip, &ret, NULL, NULL, NULL); return ret; } #endif if ( !cached_di.valid || biosdev != cached_di.biosdev ) { cc = get_drive_info(biosdev, &cached_di); if (cc < 0) { cached_di.valid = 0; DEBUG_DISK(("get_drive_info returned error\n")); return (-1); // BIOS call error } } bcopy(&cached_di, dip, sizeof(cached_di)); return 0; } //========================================================================== // Maps (E)BIOS return codes to message strings. static const char * getNameForValue( const struct NamedValue * nameTable, unsigned char value ) { const struct NamedValue * np; for ( np = nameTable; np->value; np++) if (np->value == value) return np->name; return NULL; } #define ECC_CORRECTED_ERR 0x11 static const struct NamedValue bios_errors[] = { { 0x10, "Media error" }, { 0x11, "Corrected ECC error" }, { 0x20, "Controller or device error" }, { 0x40, "Seek failed" }, { 0x80, "Device timeout" }, { 0xAA, "Drive not ready" }, { 0x00, 0 } }; static const char * bios_error(int errnum) { static char errorstr[11]; const char * errname; errname = getNameForValue( bios_errors, errnum ); if ( errname ) return errname; snprintf(errorstr, sizeof(errorstr), "Error 0x%02x", errnum); return errorstr; // No string, print error code only } //========================================================================== // Use BIOS INT13 calls to read the sector specified. This function will // also perform read-ahead to cache a few subsequent sector to the sector // cache. // // Return: // 0 on success, or an error code from INT13/F2 or INT13/F42 BIOS call. static bool cache_valid = false; static int Biosread( int biosdev, unsigned long long secno ) { static int xbiosdev, xcyl, xhead; static unsigned int xsec, xnsecs; struct driveInfo di; int rc = -1; int cyl, head, sec; int tries = 0; int bps, divisor; if (getDriveInfo(biosdev, &di) < 0) { return -1; } if (di.no_emulation) { /* Always assume 2k block size; BIOS may lie about geometry */ bps = 2048; } else { bps = di.di.params.phys_nbps; if (bps == 0) { return -1; } } divisor = bps / BPS; DEBUG_DISK(("Biosread dev %x sec %llu bps %d\n", biosdev, secno, bps)); // To read the disk sectors, use EBIOS if we can. Otherwise, // revert to the standard BIOS calls. if ((biosdev >= kBIOSDevTypeHardDrive) && (di.uses_ebios & EBIOS_FIXED_DISK_ACCESS)) { if (cache_valid && (biosdev == xbiosdev) && (secno >= xsec) && ((unsigned int)secno < (xsec + xnsecs))) { biosbuf = trackbuf + (BPS * (secno - xsec)); return 0; } xnsecs = N_CACHE_SECS; xsec = (secno / divisor) * divisor; cache_valid = false; while ((rc = ebiosread(biosdev, secno / divisor, xnsecs / divisor)) && (++tries < 5)) { if (rc == ECC_CORRECTED_ERR) { /* Ignore corrected ECC errors */ rc = 0; break; } printf(" EBIOS read error (%d): %s\n", rc, bios_error(rc) ); printf(" Block 0x%llx Sectors %d\n", secno, xnsecs); sleep(1); } } else { /* spc = spt * heads */ int spc = (di.di.params.phys_spt * di.di.params.phys_heads); cyl = secno / spc; head = (secno % spc) / di.di.params.phys_spt; sec = secno % di.di.params.phys_spt; if (cache_valid && (biosdev == xbiosdev) && (cyl == xcyl) && (head == xhead) && ((unsigned int)sec >= xsec) && ((unsigned int)sec < (xsec + xnsecs))) { // this sector is in trackbuf cache biosbuf = trackbuf + (BPS * (sec - xsec)); return 0; } // Cache up to a track worth of sectors, but do not cross a // track boundary. xcyl = cyl; xhead = head; xsec = sec; xnsecs = ((unsigned int)(sec + N_CACHE_SECS) > di.di.params.phys_spt) ? (di.di.params.phys_spt - sec) : N_CACHE_SECS; cache_valid = false; while ((rc = biosread(biosdev, cyl, head, sec, xnsecs)) && (++tries < 5)) { if (rc == ECC_CORRECTED_ERR) { /* Ignore corrected ECC errors */ rc = 0; break; } printf(" BIOS read error(%d): %s\n", rc, bios_error(rc)); printf(" Block %llu, Cyl %d Head %d Sector %d\n", secno, cyl, head, sec); sleep(1); } } // If the BIOS reported success, mark the sector cache as valid. if (rc == 0) { cache_valid = true; } biosbuf = trackbuf + (secno % divisor) * BPS; xbiosdev = biosdev; #if TEXT_SPINNER spinActivityIndicator(xnsecs); #endif return rc; } //========================================================================== int testBiosread( int biosdev, unsigned long long secno ) { return Biosread(biosdev, secno); } //========================================================================== static int readBytes( int biosdev, unsigned long long blkno, unsigned int byteoff, unsigned int byteCount, void * buffer ) { #ifndef OPTION_ROM // ramdisks require completely different code for reading. if(biosdev >= 0x100 && (execute_hook("isRamDiskRegistred", NULL, NULL, NULL, NULL, NULL, NULL) == EFI_SUCCESS)){ int ret = -1; execute_hook("p_ramdiskReadBytes", &biosdev, (void*)(unsigned long)&blkno, &byteoff, &byteCount, buffer, &ret); return ret; } #endif char * cbuf = (char *) buffer; int error; int copy_len; DEBUG_DISK(("%s: dev %x block %llu [%d] -> 0x%x...", __FUNCTION__, biosdev, blkno, byteCount, (unsigned)cbuf)); for ( ; byteCount; cbuf += copy_len, blkno++ ) { error = Biosread( biosdev, blkno ); if ( error ) { DEBUG_DISK(("error\n")); return (-1); } copy_len = ((byteCount + byteoff) > BPS) ? (BPS - byteoff) : byteCount; bcopy( biosbuf + byteoff, cbuf, copy_len ); byteCount -= copy_len; byteoff = 0; } DEBUG_DISK(("done\n")); return 0; } //========================================================================== static int isExtendedFDiskPartition( const struct fdisk_part * part ) { static unsigned char extParts[] = { 0x05, /* Extended */ 0x0f, /* Win95 extended */ 0x85, /* Linux extended */ }; unsigned int i; for (i = 0; i < sizeof(extParts)/sizeof(extParts[0]); i++) { if (extParts[i] == part->systid) return 1; } return 0; } //========================================================================== static int getNextFDiskPartition( int biosdev, int * partno, const struct fdisk_part ** outPart ) { static int sBiosdev = -1; static int sNextPartNo; static unsigned int sFirstBase; static unsigned int sExtBase; static unsigned int sExtDepth; static struct fdisk_part * sExtPart; struct fdisk_part * part; if ( sBiosdev != biosdev || *partno < 0 ) { // Fetch MBR. if ( readBootSector( biosdev, DISK_BLK0, 0 ) ) return 0; sBiosdev = biosdev; sNextPartNo = 0; sFirstBase = 0; sExtBase = 0; sExtDepth = 0; sExtPart = NULL; } while (1) { part = NULL; if ( sNextPartNo < FDISK_NPART ) { part = (struct fdisk_part *) gBootSector->parts[sNextPartNo]; } else if ( sExtPart ) { unsigned int blkno = sExtPart->relsect + sFirstBase; // Save the block offset of the first extended partition. if (sExtDepth == 0) { sFirstBase = blkno; } sExtBase = blkno; // Load extended partition table. if ( readBootSector( biosdev, blkno, 0 ) == 0 ) { sNextPartNo = 0; sExtDepth++; sExtPart = NULL; continue; } // Fall through to part == NULL } if ( part == NULL ) break; // Reached end of partition chain. // Advance to next partition number. sNextPartNo++; if ( isExtendedFDiskPartition(part) ) { sExtPart = part; continue; } // Skip empty slots. if ( part->systid == 0x00 ) { continue; } // Change relative offset to an absolute offset. part->relsect += sExtBase; *outPart = part; *partno = sExtDepth ? (int)(sExtDepth + FDISK_NPART) : sNextPartNo; break; } return (part != NULL); } //========================================================================== static BVRef newFDiskBVRef( int biosdev, int partno, unsigned int blkoff, const struct fdisk_part * part, FSInit initFunc, FSLoadFile loadFunc, FSReadFile readFunc, FSGetDirEntry getdirFunc, FSGetFileBlock getBlockFunc, FSGetUUID getUUIDFunc, BVGetDescription getDescriptionFunc, BVFree bvFreeFunc, int probe, int type, unsigned int bvrFlags ) { BVRef bvr = (BVRef) malloc( sizeof(struct BootVolume) ); if ( bvr ) { bzero(bvr, sizeof(struct BootVolume)); bvr->biosdev = biosdev; bvr->part_no = partno; bvr->part_boff = blkoff; bvr->part_type = part->systid; bvr->fs_loadfile = loadFunc; bvr->fs_readfile = readFunc; bvr->fs_getdirentry = getdirFunc; bvr->fs_getfileblock= getBlockFunc; bvr->fs_getuuid = getUUIDFunc; bvr->description = getDescriptionFunc; bvr->type = type; bvr->bv_free = bvFreeFunc; if ((part->bootid & FDISK_ACTIVE) && (part->systid == FDISK_HFS)) bvr->flags |= kBVFlagPrimary; // Probe the filesystem. if ( initFunc ) { bvr->flags |= kBVFlagNativeBoot; if ( probe && initFunc( bvr ) != 0 ) { // filesystem probe failed. DEBUG_DISK(("%s: failed probe on dev %x part %d\n", __FUNCTION__, biosdev, partno)); (*bvr->bv_free)(bvr); bvr = NULL; } if ( bvr && readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) { bvr->flags |= kBVFlagBootable; } } else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) { bvr->flags |= kBVFlagForeignBoot; } else { (*bvr->bv_free)(bvr); bvr = NULL; } } if (bvr) bvr->flags |= bvrFlags; return bvr; } #ifdef APPLE_PARTITION_MAP_SUPPORT //========================================================================== BVRef newAPMBVRef( int biosdev, int partno, unsigned int blkoff, const DPME * part, FSInit initFunc, FSLoadFile loadFunc, FSReadFile readFunc, FSGetDirEntry getdirFunc, FSGetFileBlock getBlockFunc, FSGetUUID getUUIDFunc, BVGetDescription getDescriptionFunc, BVFree bvFreeFunc, int probe, int type, unsigned int bvrFlags ) { BVRef bvr = (BVRef) malloc( sizeof(struct BootVolume) ); if ( bvr ) { bzero(bvr, sizeof(struct BootVolume)); bvr->biosdev = biosdev; bvr->part_no = partno; bvr->part_boff = blkoff; bvr->fs_loadfile = loadFunc; bvr->fs_readfile = readFunc; bvr->fs_getdirentry = getdirFunc; bvr->fs_getfileblock= getBlockFunc; bvr->fs_getuuid = getUUIDFunc; bvr->description = getDescriptionFunc; bvr->type = type; bvr->bv_free = bvFreeFunc; strlcpy(bvr->name, part->dpme_name, DPISTRLEN); strlcpy(bvr->type_name, part->dpme_type, DPISTRLEN); /* if ( part->bootid & FDISK_ACTIVE ) bvr->flags |= kBVFlagPrimary; */ // Probe the filesystem. if ( initFunc ) { bvr->flags |= kBVFlagNativeBoot | kBVFlagBootable | kBVFlagSystemVolume; if ( probe && initFunc( bvr ) != 0 ) { // filesystem probe failed. DEBUG_DISK(("%s: failed probe on dev %x part %d\n", __FUNCTION__, biosdev, partno)); (*bvr->bv_free)(bvr); bvr = NULL; } } /* else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) { bvr->flags |= kBVFlagForeignBoot; } */ else { (*bvr->bv_free)(bvr); bvr = NULL; } } if (bvr) bvr->flags |= bvrFlags; return bvr; } #endif //========================================================================== // HFS+ GUID in LE form EFI_GUID const GPT_HFS_GUID = { 0x48465300, 0x0000, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // turbo - also our booter partition EFI_GUID const GPT_BOOT_GUID = { 0x426F6F74, 0x0000, 0x11AA, { 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC } }; // turbo - or an efi system partition EFI_GUID const GPT_EFISYS_GUID = { 0xC12A7328, 0xF81F, 0x11D2, { 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B } }; // zef - basic data partition EBD0A0A2-B9E5-4433-87C0-68B6B72699C7 for foreign OS support EFI_GUID const GPT_BASICDATA_GUID = { 0xEBD0A0A2, 0xB9E5, 0x4433, { 0x87, 0xC0, 0x68, 0xB6, 0xB7, 0x26, 0x99, 0xC7 } }; EFI_GUID const GPT_BASICDATA2_GUID = { 0xE3C9E316, 0x0B5C, 0x4DB8, { 0x81, 0x7D, 0xF9, 0x2D, 0xF0, 0x02, 0x15, 0xAE } }; static BVRef newGPTBVRef( int biosdev, int partno, unsigned int blkoff, const gpt_ent * part, FSInit initFunc, FSLoadFile loadFunc, FSReadFile readFunc, FSGetDirEntry getdirFunc, FSGetFileBlock getBlockFunc, FSGetUUID getUUIDFunc, BVGetDescription getDescriptionFunc, BVFree bvFreeFunc, int probe, int type, unsigned int bvrFlags ) { BVRef bvr = (BVRef) malloc( sizeof(struct BootVolume) ); if ( bvr ) { bzero(bvr, sizeof(struct BootVolume)); bvr->biosdev = biosdev; bvr->part_no = partno; bvr->part_boff = blkoff; bvr->fs_loadfile = loadFunc; bvr->fs_readfile = readFunc; bvr->fs_getdirentry = getdirFunc; bvr->fs_getfileblock= getBlockFunc; bvr->fs_getuuid = getUUIDFunc; bvr->description = getDescriptionFunc; bvr->type = type; bvr->bv_free = bvFreeFunc; // FIXME: UCS-2 -> UTF-8 the name strlcpy(bvr->name, "----", DPISTRLEN); 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) ) strlcpy(bvr->type_name, "GPT HFS+", DPISTRLEN); else strlcpy(bvr->type_name, "GPT Unknown", DPISTRLEN); /* if ( part->bootid & FDISK_ACTIVE ) bvr->flags |= kBVFlagPrimary; */ // Probe the filesystem. if ( initFunc ) { bvr->flags |= kBVFlagNativeBoot; if ( probe && initFunc( bvr ) != 0 ) { // filesystem probe failed. DEBUG_DISK(("%s: failed probe on dev %x part %d\n", __FUNCTION__, biosdev, partno)); (*bvr->bv_free)(bvr); bvr = NULL; } if ( bvr && readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) { bvr->flags |= kBVFlagBootable; } } else if ( readBootSector( biosdev, blkoff, (void *)0x7e00 ) == 0 ) { bvr->flags |= kBVFlagForeignBoot; } else { (*bvr->bv_free)(bvr); bvr = NULL; } } if (bvr) bvr->flags |= bvrFlags; return bvr; } //========================================================================== /* A note on partition numbers: * IOKit makes the primary partitions numbers 1-4, and then * extended partitions are numbered consecutively 5 and up. * So, for example, if you have two primary partitions and * one extended partition they will be numbered 1, 2, 5. */ static BVRef diskScanFDiskBootVolumes( int biosdev, int * countPtr ) { const struct fdisk_part * part; struct DiskBVMap * map; int partno = -1; BVRef bvr; #ifdef UFS_SUPPORT BVRef booterUFS = NULL; int spc; struct driveInfo di; boot_drive_info_t *dp; /* Initialize disk info */ if (getDriveInfo(biosdev, &di) != 0) { return NULL; } dp = &di.di; spc = (dp->params.phys_spt * dp->params.phys_heads); if (spc == 0) { /* This is probably a CD-ROM; punt on the geometry. */ spc = 1; } #endif // Create a new mapping. map = (struct DiskBVMap *) malloc( sizeof(struct DiskBVMap) ); if ( !map ) { return NULL; } bzero(map,sizeof(struct DiskBVMap)); do { map->biosdev = biosdev; map->bvr = NULL; map->bvrcnt = 0; map->next = gDiskBVMap; gDiskBVMap = map; // Create a record for each partition found on the disk. while ( getNextFDiskPartition( biosdev, &partno, &part ) ) { DEBUG_DISK(("%s: part %d [%x]\n", __FUNCTION__, partno, part->systid)); bvr = 0; switch ( part->systid ) { #ifdef UFS_SUPPORT case FDISK_UFS: bvr = newFDiskBVRef( biosdev, partno, part->relsect + UFS_FRONT_PORCH/BPS, part, UFSInitPartition, UFSLoadFile, UFSReadFile, UFSGetDirEntry, UFSGetFileBlock, UFSGetUUID, UFSGetDescription, UFSFree, 0, kBIOSDevTypeHardDrive, 0); break; #endif case FDISK_HFS: bvr = newFDiskBVRef( biosdev, partno, part->relsect, part, HFSInitPartition, HFSLoadFile, HFSReadFile, HFSGetDirEntry, HFSGetFileBlock, HFSGetUUID, HFSGetDescription, HFSFree, 0, kBIOSDevTypeHardDrive, 0); break; // turbo - we want the booter type scanned also case FDISK_BOOTER: if (part->bootid & FDISK_ACTIVE) { safe_set_env(envgBIOSBootVolume, (uint32_t)newFDiskBVRef( biosdev, partno, part->relsect, part, HFSInitPartition, HFSLoadFile, HFSReadFile, HFSGetDirEntry, HFSGetFileBlock, HFSGetUUID, HFSGetDescription, HFSFree, 0, kBIOSDevTypeHardDrive, 0)); break; } #ifndef UFS_SUPPORT break; #else //case FDISK_BOOTER: booterUFS = newFDiskBVRef( biosdev, partno, ((part->relsect + spc - 1) / spc) * spc, part, UFSInitPartition, UFSLoadFile, UFSReadFile, UFSGetDirEntry, UFSGetFileBlock, UFSGetUUID, UFSGetDescription, UFSFree, 0, kBIOSDevTypeHardDrive, 0); break; #endif #ifndef NO_WIN_SUPPORT case FDISK_FAT32: case FDISK_DOS12: case FDISK_DOS16S: case FDISK_DOS16B: case FDISK_SMALLFAT32: case FDISK_DOS16SLBA: bvr = newFDiskBVRef( biosdev, partno, part->relsect, part, MSDOSInitPartition, MSDOSLoadFile, MSDOSReadFile, MSDOSGetDirEntry, MSDOSGetFileBlock, MSDOSGetUUID, MSDOSGetDescription, MSDOSFree, 0, kBIOSDevTypeHardDrive, 0); break; case FDISK_NTFS: bvr = newFDiskBVRef( biosdev, partno, part->relsect, part, 0, 0, 0, 0, 0, NTFSGetUUID, NTFSGetDescription, (BVFree)free, 0, kBIOSDevTypeHardDrive, 0); break; #endif #ifndef NO_LINUX_SUPPORT case FDISK_LINUX: bvr = newFDiskBVRef( biosdev, partno, part->relsect, part, 0, 0, 0, 0, 0, 0, EX2GetDescription, (BVFree)free, 0, kBIOSDevTypeHardDrive, 0); break; #endif #ifndef NO_HAIKU_SUPPORT case FDISK_BEFS: bvr = newFDiskBVRef( biosdev, partno, part->relsect, part, 0, 0, 0, 0, 0, 0, BeFSGetDescription, (BVFree)free, 0, kBIOSDevTypeHardDrive, 0); break; #endif #ifndef NO_OTHERS_BSD_SUPPORT case FDISK_FREEBSD: bvr = newFDiskBVRef( biosdev, partno, part->relsect, part, 0, 0, 0, 0, 0, 0, FreeBSDGetDescription, (BVFree)free, 0, kBIOSDevTypeHardDrive, 0); break; case FDISK_OPENBSD: bvr = newFDiskBVRef( biosdev, partno, part->relsect, part, 0, 0, 0, 0, 0, 0, OpenBSDGetDescription, (BVFree)free, 0, kBIOSDevTypeHardDrive, 0); break; #endif default: #if UNUSED bvr = newFDiskBVRef( biosdev, partno, part->relsect, part, 0, 0, 0, 0, 0, 0, 0, (BVFree)free, 0, kBIOSDevTypeHardDrive, 0); #endif break; } if ( bvr ) { bvr->next = map->bvr; map->bvr = bvr; map->bvrcnt++; } } #ifdef UFS_SUPPORT // Booting from a CD with an UFS filesystem embedded // in a booter partition. if ( booterUFS ) { if ( map->bvrcnt == 0 ) { map->bvr = booterUFS; map->bvrcnt++; } else free( booterUFS ); } #endif } while (0); /* * If no FDisk partition, then we will check for * an Apple partition map elsewhere. */ #if UNUSED if (map->bvrcnt == 0) { static struct fdisk_part cdpart; cdpart.systid = 0xCD; /* Let's try assuming we are on a hybrid HFS/ISO9660 CD. */ bvr = newFDiskBVRef( biosdev, 0, 0, &cdpart, HFSInitPartition, HFSLoadFile, HFSReadFile, HFSGetDirEntry, HFSGetFileBlock, HFSGetUUID, HFSGetDescription, HFSFree, 0, kBIOSDevTypeHardDrive, 0); bvr->next = map->bvr; map->bvr = bvr; map->bvrcnt++; } #endif // Actually this should always be true given the above code if(map == gDiskBVMap) { // Don't leave a null map in the chain if(map->bvrcnt == 0 && map->bvr == NULL) { gDiskBVMap = map->next; free(map); map = NULL; } } if (countPtr) *countPtr = map ? map->bvrcnt : 0; return map ? map->bvr : NULL; } #ifdef APPLE_PARTITION_MAP_SUPPORT //========================================================================== static BVRef diskScanAPMBootVolumes( int biosdev, int * countPtr ) { struct DiskBVMap * map; struct Block0 *block0_p; unsigned int blksize; unsigned int factor; void *buffer = malloc(BPS); if (!buffer) { return NULL; } bzero(buffer,BPS); /* Check for alternate block size */ if (readBytes( biosdev, 0, 0, BPS, buffer ) != 0) { return NULL; } block0_p = buffer; if (OSSwapBigToHostInt16(block0_p->sbSig) == BLOCK0_SIGNATURE) { blksize = OSSwapBigToHostInt16(block0_p->sbBlkSize); if (blksize != BPS) { free(buffer); buffer = malloc(blksize); if (!buffer) { return NULL; } bzero(buffer,BPS); } factor = blksize / BPS; } else { blksize = BPS; factor = 1; } // Create a new mapping. map = (struct DiskBVMap *) malloc( sizeof(struct DiskBVMap) ); if ( !map ) { return NULL; } bzero(map,sizeof(struct DiskBVMap)); do { int error; DPME *dpme_p = (DPME *)buffer; UInt32 i, npart = UINT_MAX; BVRef bvr; map->biosdev = biosdev; map->bvr = NULL; map->bvrcnt = 0; map->next = gDiskBVMap; gDiskBVMap = map; for (i=0; idpme_signature) != DPME_SIGNATURE) { break; } if (i==0) { npart = OSSwapBigToHostInt32(dpme_p->dpme_map_entries); } /* printf("name = %s, %s%s %d -> %d [%d -> %d] {%d}\n", dpme.dpme_name, dpme.dpme_type, (dpme.dpme_flags & DPME_FLAGS_BOOTABLE) ? "(bootable)" : "", dpme.dpme_pblock_start, dpme.dpme_pblocks, dpme.dpme_lblock_start, dpme.dpme_lblocks, dpme.dpme_boot_block); */ if (strncmp(dpme_p->dpme_type, "Apple_HFS",sizeof("Apple_HFS")) == 0) { bvr = newAPMBVRef(biosdev, i, OSSwapBigToHostInt32(dpme_p->dpme_pblock_start) * factor, dpme_p, HFSInitPartition, HFSLoadFile, HFSReadFile, HFSGetDirEntry, HFSGetFileBlock, HFSGetUUID, HFSGetDescription, HFSFree, 0, kBIOSDevTypeHardDrive, 0); bvr->next = map->bvr; map->bvr = bvr; map->bvrcnt++; } } } while (0); free(buffer); if (countPtr) *countPtr = map ? map->bvrcnt : 0; return map ? map->bvr : NULL; } //========================================================================== #endif // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - /* * Trying to figure out the filsystem type of a given partition. */ static int probeFileSystem(int biosdev, unsigned int blkoff) { // detected filesystem type; int result = -1; #ifndef NO_WIN_SUPPORT int fatbits; #endif // Allocating buffer for 4 sectors. const void * probeBuffer = calloc(1,PROBEFS_SIZE); if (probeBuffer == NULL) goto exit; // Reading first 4 sectors of current partition int error = readBytes(biosdev, blkoff, 0, PROBEFS_SIZE, (void *)probeBuffer); if (error) goto exit; if (HFSProbe(probeBuffer)) result = FDISK_HFS; #ifndef NO_LINUX_SUPPORT else if (EX2Probe(probeBuffer)) result = FDISK_LINUX; #endif #ifndef NO_OTHERS_BSD_SUPPORT else if (FreeBSDProbe(probeBuffer)) result = FDISK_FREEBSD; else if (OpenBSDProbe(probeBuffer)) result = FDISK_OPENBSD; #endif #ifndef NO_HAIKU_SUPPORT else if (BeFSProbe(probeBuffer)) result = FDISK_BEFS; #endif #ifndef NO_WIN_SUPPORT else if (NTFSProbe(probeBuffer)) result = FDISK_NTFS; else if ((fatbits=MSDOSProbe(probeBuffer))) { switch (fatbits) { case 32: default: result = FDISK_FAT32; break; case 16: result = FDISK_DOS16B; break; case 12: result = FDISK_DOS12; break; } } #endif else // Couldn't detect filesystem type result = 0; exit: if (probeBuffer != NULL) free((void *)probeBuffer); return result; } static bool isPartitionUsed(gpt_ent * partition) { // // Ask whether the given partition is used. // return efi_guid_is_null((EFI_GUID const*)partition->ent_type) ? false : true; } // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - static BVRef diskScanGPTBootVolumes( int biosdev, int * countPtr ) { if (biosdev >= 0x100 && (execute_hook("isRamDiskRegistred", NULL, NULL, NULL, NULL, NULL, NULL) != EFI_SUCCESS)) return NULL; struct DiskBVMap * map = NULL; void *buffer = malloc(BPS); if (!buffer) { goto scanErr; } bzero(buffer,BPS); int error; if ( (error = readBytes( biosdev, /*secno*/0, 0, BPS, buffer )) != 0) { DBG("Failed to read boot sector from BIOS device %02xh. Error=%d\n", biosdev, error); goto scanErr; } struct REAL_disk_blk0 *fdiskMap = buffer; if ( OSSwapLittleToHostInt16(fdiskMap->signature) != DISK_SIGNATURE ) { verbose("Failed to find boot signature on BIOS device %02xh\n", biosdev); goto scanErr; } int fdiskID = 0; unsigned index; for ( index = 0; index < FDISK_NPART; index++ ) { if ( fdiskMap->parts[index].systid ) { if ( fdiskMap->parts[index].systid == 0xEE ) { // Fail if two 0xEE partitions are present which // means the FDISK code will wind up parsing it. if ( fdiskID ) goto scanErr; fdiskID = index + 1; } } } if ( fdiskID == 0 ) goto scanErr; DBG("Attempting to read GPT\n"); if(readBytes(biosdev, 1, 0, BPS, buffer) != 0) goto scanErr; gpt_hdr *headerMap = buffer; // Determine whether the partition header signature is present. if ( memcmp(headerMap->hdr_sig, GPT_HDR_SIG, strlen(GPT_HDR_SIG)) ) { goto scanErr; } // Determine whether the partition header size is valid. UInt32 headerCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_self); UInt32 headerSize = OSSwapLittleToHostInt32(headerMap->hdr_size); if ( headerSize < offsetof(gpt_hdr, padding) ) { goto scanErr; } if ( headerSize > BPS ) { goto scanErr; } // Determine whether the partition header checksum is valid. headerMap->hdr_crc_self = 0; if ( crc32(0, headerMap, headerSize) != headerCheck ) { goto scanErr; } // Determine whether the partition entry size is valid. UInt64 gptBlock = 0; //UInt32 gptCheck = 0; UInt32 gptCount = 0; UInt32 gptID = 0; gpt_ent * gptMap = 0; UInt32 gptSize = 0; gptBlock = OSSwapLittleToHostInt64(headerMap->hdr_lba_table); //gptCheck = OSSwapLittleToHostInt32(headerMap->hdr_crc_table); gptCount = OSSwapLittleToHostInt32(headerMap->hdr_entries); gptSize = OSSwapLittleToHostInt32(headerMap->hdr_entsz); if ( gptSize < sizeof(gpt_ent) ) { goto scanErr; } // Allocate a buffer large enough to hold one map, rounded to a media block. free(buffer); buffer = NULL; UInt32 bufferSize = IORound(gptCount * gptSize, BPS); if(bufferSize == 0) goto scanErr; buffer = malloc(bufferSize); if (!buffer) { goto scanErr; } bzero(buffer,bufferSize); if(readBytes(biosdev, gptBlock, 0, bufferSize, buffer) != 0) goto scanErr; DBG("Read GPT\n"); // Allocate a new map for this BIOS device and insert it into the chain map = (struct DiskBVMap *) malloc(sizeof(struct DiskBVMap)); if (!map) { goto scanErr; } bzero(map,sizeof(struct DiskBVMap)); map->biosdev = biosdev; map->bvr = NULL; map->bvrcnt = 0; map->next = gDiskBVMap; gDiskBVMap = map; // fdisk like partition type id. int fsType = 0; for(gptID = 1; gptID <= gptCount; ++gptID) { BVRef bvr = NULL; unsigned int bvrFlags = 0; // size on disk can be larger than sizeof(gpt_ent) gptMap = (gpt_ent *) ( buffer + ( (gptID - 1) * gptSize) ); // NOTE: EFI_GUID's are in LE and we know we're on an x86. // The IOGUIDPartitionScheme.cpp code uses byte-based UUIDs, we don't. if(isPartitionUsed(gptMap)) { char stringuuid[100]; efi_guid_unparse_upper((EFI_GUID*)gptMap->ent_type, stringuuid, sizeof(stringuuid)); verbose("Reading GPT partition %d, type %s\n", gptID, stringuuid); // Getting fdisk like partition type. fsType = probeFileSystem(biosdev, gptMap->ent_lba_start); 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) ) { #ifdef BOOT_HELPER_SUPPORT bvrFlags = (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ? kBVFlagBooter : 0; #else if (efi_guid_compare(&GPT_BOOT_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) continue; else bvrFlags = 0; #endif bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap, HFSInitPartition, HFSLoadFile, HFSReadFile, HFSGetDirEntry, HFSGetFileBlock, HFSGetUUID, HFSGetDescription, HFSFree, 0, kBIOSDevTypeHardDrive, bvrFlags); } // zef - foreign OS support if ( (efi_guid_compare(&GPT_BASICDATA_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) || (efi_guid_compare(&GPT_BASICDATA2_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ) { switch (fsType) { #ifndef NO_WIN_SUPPORT case FDISK_NTFS: bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap, 0, 0, 0, 0, 0, 0, NTFSGetDescription, (BVFree)free, 0, kBIOSDevTypeHardDrive, 0); break; #endif default: bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap, 0, 0, 0, 0, 0, 0, 0, (BVFree)free, 0, kBIOSDevTypeHardDrive, 0); break; } } // turbo - save our booter partition // zef - only on original boot device if ( (efi_guid_compare(&GPT_EFISYS_GUID, (EFI_GUID const*)gptMap->ent_type) == 0) ) { switch (fsType) { case FDISK_HFS: if (readBootSector( biosdev, gptMap->ent_lba_start, (void *)0x7e00 ) == 0) { bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap, HFSInitPartition, HFSLoadFile, HFSReadFile, HFSGetDirEntry, HFSGetFileBlock, HFSGetUUID, HFSGetDescription, HFSFree, 0, kBIOSDevTypeHardDrive, kBVFlagEFISystem); } break; #ifndef NO_WIN_SUPPORT case FDISK_FAT32: if (testFAT32EFIBootSector( biosdev, gptMap->ent_lba_start, (void *)0x7e00 ) == 0) { bvr = newGPTBVRef(biosdev, gptID, gptMap->ent_lba_start, gptMap, MSDOSInitPartition, MSDOSLoadFile, MSDOSReadFile, MSDOSGetDirEntry, MSDOSGetFileBlock, MSDOSGetUUID, MSDOSGetDescription, MSDOSFree, 0, kBIOSDevTypeHardDrive, kBVFlagEFISystem); } break; #endif default: if (biosdev == (int)get_env(envgBIOSDev)) safe_set_env(envgBIOSBootVolume, (uint32_t)bvr); break; } } if (bvr) { // Fixup bvr with the fake fdisk partition type. if (fsType > 0) bvr->part_type = fsType; bvr->next = map->bvr; map->bvr = bvr; ++map->bvrcnt; } } } scanErr: if (buffer) free(buffer); if(map) { if(countPtr) *countPtr = map->bvrcnt; return map->bvr; } else { if(countPtr) *countPtr = 0; return NULL; } } static TagPtr XMLGetElementWithID( TagPtr dict, const char* id ) { if(dict->type != kTagTypeArray) return 0; int element = 0; TagPtr tmp = dict->tag; int entry_count = XMLTagCount(dict); while(element < entry_count) { char *Identifier = NULL; Identifier = XMLCastString(XMLGetProperty(tmp, (const char*)"Identifier")); if (Identifier && (strcmp(Identifier, id) == 0)) { return tmp; } element++; tmp = tmp->tagNext; } return tmp; } static bool getOSInstallVersion(const char *dirSpec, char *str, config_file_t *systemVersion) { if (!loadConfigFile(dirSpec, systemVersion)) { TagPtr pkg_p = XMLCastArray(XMLGetProperty(systemVersion->dictionary, (const char*)"Packages")); if (pkg_p) { char *version = NULL; version = XMLCastString(XMLGetProperty( XMLGetElementWithID(pkg_p, "com.apple.mpkg.OSInstall"), (const char*)"Version")); if (!version) { version = XMLCastString(XMLGetProperty( XMLGetElementWithID(pkg_p, "com.apple.pkg.CompatibilityUpdate"), (const char*)"Version")); } if (version && strlen(version) >= 4) { *str = '\0'; strncat(str, version, 4); return true; } } } return false; } static bool getOSInstallURL(BVRef bvr, const char *dirSpec, config_file_t *config_file) { if (!loadConfigFile(dirSpec, config_file)) { char *encoded_url = XMLCastString(XMLGetProperty(config_file->dictionary, (const char*)"Product URL")); if (!encoded_url) { goto out; } DBG("encoded_url %s\n",encoded_url); //char * dev_id = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"; // strlen = 36 //char * osx_product = "x-osproduct://"; // strlen = 14 char * val = &encoded_url[(36+14)+1]; DBG("val %s\n",val); char * buffer = newStringFromURL(val); if (!buffer) { goto out; } DBG("buffer %s\n",buffer); strlcpy(bvr->OSInstall, buffer, sizeof(bvr->OSInstall)); free(buffer); return true; } out: return false; } static bool getOSVersion(BVRef bvr, char *str) { bool valid = false; config_file_t config_file; char dirSpec[512]; snprintf(dirSpec, sizeof(dirSpec),"hd(%d,%d)/System/Library/CoreServices/SystemVersion.plist", BIOS_DEV_UNIT(bvr), bvr->part_no); if (!loadConfigFile(dirSpec, &config_file)) { valid = true; } else { snprintf(dirSpec, sizeof(dirSpec),"hd(%d,%d)/System/Library/CoreServices/ServerVersion.plist", BIOS_DEV_UNIT(bvr), bvr->part_no); if (!loadConfigFile(dirSpec, &config_file)) { bvr->OSisServer = true; valid = true; } else { snprintf(dirSpec, sizeof(dirSpec),"hd(%d,%d)/.IAProductInfo", BIOS_DEV_UNIT(bvr), bvr->part_no); DBG("dirSpec %s\n",dirSpec); if (!loadConfigFile(dirSpec, &config_file)) { if (getOSInstallURL(bvr, dirSpec, &config_file)) { snprintf(dirSpec, sizeof(dirSpec),"hd(%d,%d)/%s/index.sproduct", BIOS_DEV_UNIT(bvr), bvr->part_no, bvr->OSInstall); DBG("dirSpec %s\n",dirSpec); if (!getOSInstallVersion(dirSpec, str, &config_file)) return false; else return true; } } } } if (valid) { const char *val; int len; if (getValueForKey(kProductVersion, &val, &len, &config_file)) { // getValueForKey uses const char for val // so copy it and trim *str = '\0'; strncat(str, val, MIN(len, 4)); } else valid = false; } return valid; } static bool CheckDarwin(BVRef bvr) { long flags, time, ret = -1; char dirspec[128]; char *kdirspec[] = { "hd(%d,%d)/mach_kernel", #if UNUSED "hd(%d,%d)/System/Library/CoreServices/mach_kernel" #endif }; bvr->kernelfound = true; snprintf(dirspec,sizeof(dirspec),kdirspec[0],BIOS_DEV_UNIT(bvr), bvr->part_no); ret = GetFileInfo(NULL, dirspec, &flags, &time); if ((ret != 0) || ((flags & kFileTypeMask) != kFileTypeFlat)) { #if UNUSED snprintf(dirspec,sizeof(dirspec),kdirspec[1],BIOS_DEV_UNIT(bvr), bvr->part_no); ret = GetFileInfo(NULL, dirspec, &flags, &time); if ((ret != 0) || ((flags & kFileTypeMask) != kFileTypeFlat)) #endif { bvr->kernelfound = false; // Non fatal, let the booter determine the directory } } if (bvr->kernelfound == true) { DBG("Kernel found !!, path : %s\n",dirspec); } return getOSVersion(bvr,bvr->OSVersion); } //========================================================================== static void scanFSLevelBVRSettings(BVRef chain) { BVRef bvr; #ifdef BOOT_HELPER_SUPPORT int ret; char label[BVSTRLEN]; char dirSpec[256]; int fh, fileSize, error; #endif for (bvr = chain; bvr < (BVRef)ULONG_MAX; bvr = bvr->next) { if (!bvr) { break; } #ifdef BOOT_HELPER_SUPPORT error = 0; // // Check for alternate volume label on boot helper partitions. // if (bvr->flags & kBVFlagBooter) { snprintf(dirSpec, sizeof(dirsSpec),"hd(%d,%d)/System/Library/CoreServices/", BIOS_DEV_UNIT(bvr), bvr->part_no); strlcpy(fileSpec, ".disk_label.contentDetails", sizeof(fileSpec)); ret = GetFileInfo(dirSpec, fileSpec, &flags, &time); if (!ret) { strlcat(dirSpec, fileSpec, sizeof(dirSpec)); fh = open(dirSpec,0); fileSize = file_size(fh); if (fileSize > 0 && fileSize < BVSTRLEN) { if (read(fh, label, fileSize) != fileSize) error = -1; } else error = -1; close(fh); if (!error) { label[fileSize] = '\0'; strlcpy(bvr->altlabel, label, sizeof(bvr->altlabel)); } } } #endif // // Check for SystemVersion.plist or ServerVersion.plist // to determine if a volume hosts an installed system. // if (bvr->flags & kBVFlagNativeBoot) { if (CheckDarwin(bvr) == true) { bvr->flags |= kBVFlagSystemVolume; } } } } #ifndef OPTION_ROM void rescanBIOSDevice(int biosdev) { struct DiskBVMap *oldMap = diskResetBootVolumes(biosdev); if (oldMap == NULL) { return; } CacheReset(); diskFreeMap(oldMap); oldMap = NULL; scanBootVolumes(biosdev, 0); } #endif struct DiskBVMap* diskResetBootVolumes(int biosdev) { struct DiskBVMap * map; struct DiskBVMap *prevMap = NULL; for ( map = gDiskBVMap; map; prevMap = map, map = map->next ) { if ( biosdev == map->biosdev ) { break; } } if(map != NULL) { verbose("Resetting BIOS device %xh\n", biosdev); // Reset the biosbuf cache cache_valid = false; if(map == gDiskBVMap) gDiskBVMap = map->next; else if(prevMap != NULL) prevMap->next = map->next; else { stop("diskResetBootVolumes error\n"); return NULL; } } // Return the old map, either to be freed, or reinserted later return map; } // Frees a DiskBVMap and all of its BootVolume's void diskFreeMap(struct DiskBVMap *map) { if(map != NULL) { while(map->bvr != NULL) { BVRef bvr = map->bvr; map->bvr = bvr->next; (*bvr->bv_free)(bvr); } free(map); } } BVRef diskScanBootVolumes( int biosdev, int * countPtr ) { struct DiskBVMap * map; BVRef bvr; int count = 0; // Find an existing mapping for this device. for ( map = gDiskBVMap; map; map = map->next ) { if ( biosdev == map->biosdev ) { count = map->bvrcnt; break; } } if (map == NULL) { bvr = diskScanGPTBootVolumes(biosdev, &count); if (bvr == NULL) { bvr = diskScanFDiskBootVolumes(biosdev, &count); } #ifdef APPLE_PARTITION_MAP_SUPPORT if (bvr == NULL) { bvr = diskScanAPMBootVolumes(biosdev, &count); } #endif if (bvr) { scanFSLevelBVRSettings(bvr); } } else { bvr = map->bvr; } if (countPtr) *countPtr += count; return bvr; } BVRef getBVChainForBIOSDev(int biosdev) { BVRef chain = NULL; struct DiskBVMap * map = NULL; for (map = gDiskBVMap; map; map = map->next) { if (map->biosdev == biosdev) { chain = map->bvr; break; } } return chain; } BVRef newFilteredBVChain(int minBIOSDev, int maxBIOSDev, unsigned int allowFlags, unsigned int denyFlags, int *count) { BVRef chain = NULL; BVRef bvr = NULL; BVRef newBVR = NULL; BVRef prevBVR = NULL; struct DiskBVMap * map = NULL; int bvCount = 0; const char *raw = 0; char* val = 0; int len; getValueForKey(kHidePartition, &raw, &len, DEFAULT_BOOT_CONFIG); if(raw) { val = XMLDecode(raw); } /* * Traverse gDISKBVmap to get references for * individual bvr chains of each drive. */ for (map = gDiskBVMap; map; map = map->next) { for (bvr = map->bvr; bvr; bvr = bvr->next) { /* * Save the last bvr. */ if (newBVR) prevBVR = newBVR; /* * Allocate and copy the matched bvr entry into a new one. */ newBVR = (BVRef) malloc(sizeof(struct BootVolume)); if (!newBVR) { continue; } bzero(newBVR,sizeof(struct BootVolume)); bcopy(bvr, newBVR, sizeof(struct BootVolume)); /* * Adjust the new bvr's fields. */ newBVR->next = NULL; newBVR->filtered = true; if ( (!allowFlags || newBVR->flags & allowFlags) && (!denyFlags || !(newBVR->flags & denyFlags) ) && (newBVR->biosdev >= minBIOSDev && newBVR->biosdev <= maxBIOSDev) ) newBVR->visible = true; /* Looking for "Hide Partition" entries in 'hd(x,y)|uuid|"label" hd(m,n)|uuid|"label"' format * to be able to hide foreign partitions from the boot menu. */ if ( (newBVR->flags & kBVFlagForeignBoot) ) { char *start, *next = val; long len = 0; do { start = strbreak(next, &next, &len); if(len && matchVolumeToString(newBVR, start, len) ) newBVR->visible = false; } while ( next && *next ); } /* * Use the first bvr entry as the starting chain pointer. */ if (!chain) chain = newBVR; /* * Update the previous bvr's link pointer to use the new memory area. */ if (prevBVR) prevBVR->next = newBVR; if (newBVR->visible) bvCount++; } } #if DEBUG for (bvr = chain; bvr < (BVRef)ULONG_MAX; bvr = bvr->next) { if (!bvr) { break; } printf(" bvr: %p, dev: %d, part: %d, flags: %d, vis: %d\n", bvr, bvr->biosdev, bvr->part_no, bvr->flags, bvr->visible); } printf("count: %d\n", bvCount); getc(); #endif *count = bvCount; free(val); return chain; } int freeFilteredBVChain(const BVRef chain) { int ret = 1; BVRef bvr = chain; BVRef nextBVR = NULL; while (bvr < (BVRef)ULONG_MAX) { if (!bvr) { break; } nextBVR = bvr->next; if (bvr->filtered) { free(bvr); } else { ret = 0; break; } bvr = nextBVR; } return ret; } //========================================================================== static const struct NamedValue fdiskTypes[] = { #ifndef NO_WIN_SUPPORT { FDISK_NTFS, "Windows NTFS" }, { FDISK_DOS12, "Windows FAT12" }, { FDISK_DOS16B, "Windows FAT16" }, { FDISK_DOS16S, "Windows FAT16" }, { FDISK_DOS16SLBA, "Windows FAT16" }, { FDISK_SMALLFAT32, "Windows FAT32" }, { FDISK_FAT32, "Windows FAT32" }, #endif #ifndef NO_OTHERS_BSD_SUPPORT { FDISK_FREEBSD, "FreeBSD" }, { FDISK_OPENBSD, "OpenBSD" }, #endif #ifndef NO_LINUX_SUPPORT { FDISK_LINUX, "Linux" }, #endif #ifdef UFS_SUPPORT { FDISK_UFS, "Apple UFS" }, #endif { FDISK_HFS, "Apple HFS" }, { FDISK_BOOTER, "Apple Boot/UFS" }, #ifndef NO_HAIKU_SUPPORT { FDISK_BEFS, "Haiku" }, #endif { 0xCD, "CD-ROM" }, { 0x00, 0 } /* must be last */ }; //========================================================================== bool matchVolumeToString( BVRef bvr, const char* match, long matchLen) { char testStr[128]; if ( !bvr || !match || !*match) return 0; if ( bvr->biosdev < 0x80 || bvr->biosdev >= 0x100 ) return 0; // Try to match hd(x,y) first. snprintf(testStr, sizeof(testStr),"hd(%d,%d)", BIOS_DEV_UNIT(bvr), bvr->part_no); if ( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) ) return true; // Try to match volume UUID. if ( bvr->fs_getuuid && bvr->fs_getuuid(bvr, testStr, sizeof(testStr)) == 0) { if( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) ) return true; } // Try to match volume label (always quoted). if ( bvr->description ) { bvr->description(bvr, testStr, sizeof(testStr)-1); if( matchLen ? !strncmp(match, testStr, matchLen) : !strcmp(match, testStr) ) return true; } return false; } /* If Rename Partition has defined an alias, then extract it for description purpose * The format for the rename string is the following: * hd(x,y)|uuid|"label" "alias";hd(m,n)|uuid|"label" etc; ... */ static bool getVolumeLabelAlias(BVRef bvr, char* str, long strMaxLen) { char *aliasList, *entryStart, *entryNext; if ( !str || strMaxLen <= 0) return false; aliasList = XMLDecode(getStringForKey(kRenamePartition, DEFAULT_BOOT_CONFIG)); if ( !aliasList ) return false; for ( entryStart = entryNext = aliasList; entryNext && *entryNext; entryStart = entryNext ) { char *volStart, *volEnd, *aliasStart; long volLen, aliasLen; // Delimit current entry entryNext = strchr(entryStart, ';'); if ( entryNext ) { *entryNext = '\0'; entryNext++; } volStart = strbreak(entryStart, &volEnd, &volLen); if(!volLen) continue; aliasStart = strbreak(volEnd, 0, &aliasLen); if(!aliasLen) continue; if ( matchVolumeToString(bvr, volStart, volLen) ) { strncat(str, aliasStart, min(strMaxLen, aliasLen)); free(aliasList); return true; } } free(aliasList); return false; } void getBootVolumeDescription( BVRef bvr, char * str, long strMaxLen, bool useDeviceDescription ) { unsigned char type; char *p = str; if(!bvr || !p || strMaxLen <= 0) return; type = (unsigned char) bvr->part_type; if (useDeviceDescription) { int len = getDeviceDescription(bvr, str, strMaxLen); if(len >= strMaxLen) return; strlcpy(str + len, " ", strMaxLen); len++; strMaxLen -= len; p += len; } /* See if a partition rename is preferred */ if(getVolumeLabelAlias(bvr, p, strMaxLen)) { strncpy(bvr->label, p, strMaxLen); return; // we're done here no need to seek for real name } // // Get the volume label using filesystem specific functions // or use the alternate volume label if available. // if (*bvr->altlabel != '\0') strncpy(p, bvr->altlabel, strMaxLen); else if (bvr->description) bvr->description(bvr, p, strMaxLen); if (*p == '\0') { const char * name = getNameForValue( fdiskTypes, type ); if (name == NULL) { name = bvr->type_name; } if (name == NULL) { snprintf(p, strMaxLen, "TYPE %02x", type); } else { strncpy(p, name, strMaxLen); } } // Set the devices label snprintf(bvr->label, sizeof(bvr->label), p); } //========================================================================== int readBootSector( int biosdev, unsigned int secno, void * buffer ) { struct disk_blk0 * bootSector = (struct disk_blk0 *) buffer; int error; if ( bootSector == NULL ) { if ( gBootSector == NULL ) { gBootSector = (struct disk_blk0 *) malloc(sizeof(struct disk_blk0)); if ( gBootSector == NULL ) return -1; bzero(gBootSector,sizeof(struct disk_blk0)); } bootSector = gBootSector; } error = readBytes( biosdev, secno, 0, BPS, bootSector ); if ( error || bootSector->signature != DISK_SIGNATURE ) return -1; return 0; } #ifndef NO_WIN_SUPPORT /* * Format of boot1f32 block. */ #define BOOT1F32_MAGIC "BOOT " #define BOOT1F32_MAGICLEN 11 struct disk_boot1f32_blk { unsigned char init[3]; unsigned char fsheader[87]; unsigned char magic[BOOT1F32_MAGICLEN]; unsigned char bootcode[409]; unsigned short signature; }; int testFAT32EFIBootSector( int biosdev, unsigned int secno, void * buffer ) { struct disk_boot1f32_blk * bootSector = (struct disk_boot1f32_blk *) buffer; int error; if ( bootSector == NULL ) { if ( gBootSector == NULL ) { gBootSector = (struct disk_blk0 *) malloc(sizeof(struct disk_blk0)); if ( gBootSector == NULL ) return -1; bzero(gBootSector,sizeof(struct disk_blk0)); } bootSector = (struct disk_boot1f32_blk *) gBootSector; } error = readBytes( biosdev, secno, 0, BPS, bootSector ); if ( error || bootSector->signature != DISK_SIGNATURE || strncmp((const char *)bootSector->magic, BOOT1F32_MAGIC, BOOT1F32_MAGICLEN) ) return -1; return 0; } #endif //========================================================================== // Handle seek request from filesystem modules. void diskSeek( BVRef bvr, long long position ) { bvr->fs_boff = position / BPS; bvr->fs_byteoff = position % BPS; } //========================================================================== // Handle read request from filesystem modules. int diskRead( BVRef bvr, long addr, long length ) { return readBytes( bvr->biosdev, bvr->fs_boff + bvr->part_boff, bvr->fs_byteoff, length, (void *) addr ); } #if UNUSED int rawDiskRead( BVRef bvr, unsigned int secno, void *buffer, unsigned int len ) { int secs; unsigned char *cbuf = (unsigned char *)buffer; unsigned int copy_len; int rc; if ((len & (BPS-1)) != 0) { printf("raw disk read not sector aligned"); return -1; } secno += bvr->part_boff; cache_valid = false; while (len > 0) { secs = len / BPS; if (secs > N_CACHE_SECS) secs = N_CACHE_SECS; copy_len = secs * BPS; //printf("rdr: ebiosread(%d, %d, %d)\n", bvr->biosdev, secno, secs); if ((rc = ebiosread(bvr->biosdev, secno, secs)) != 0) { /* Ignore corrected ECC errors */ if (rc != ECC_CORRECTED_ERR) { printf(" EBIOS read error: %s\n", bios_error(rc), rc); printf(" Block %d Sectors %d\n", secno, secs); return rc; } } bcopy( trackbuf, cbuf, copy_len ); len -= copy_len; cbuf += copy_len; secno += secs; #if TEXT_SPINNER spinActivityIndicator(secs); #endif } return 0; } int rawDiskWrite( BVRef bvr, unsigned int secno, void *buffer, unsigned int len ) { int secs; unsigned char *cbuf = (unsigned char *)buffer; unsigned int copy_len; int rc; if ((len & (BPS-1)) != 0) { printf("raw disk write not sector aligned"); return -1; } secno += bvr->part_boff; cache_valid = false; while (len > 0) { secs = len / BPS; if (secs > N_CACHE_SECS) secs = N_CACHE_SECS; copy_len = secs * BPS; bcopy( cbuf, trackbuf, copy_len ); //printf("rdr: ebioswrite(%d, %d, %d)\n", bvr->biosdev, secno, secs); if ((rc = ebioswrite(bvr->biosdev, secno, secs)) != 0) { printf(" EBIOS write error: %s\n", bios_error(rc), rc); printf(" Block %d Sectors %d\n", secno, secs); return rc; } len -= copy_len; cbuf += copy_len; secno += secs; #if TEXT_SPINNER spinActivityIndicator(secs); #endif } return 0; } #endif int diskIsCDROM(BVRef bvr) { struct driveInfo di; if (getDriveInfo(bvr->biosdev, &di) == 0 && di.no_emulation) { return 1; } return 0; } int biosDevIsCDROM(int biosdev) { struct driveInfo di; if (getDriveInfo(biosdev, &di) == 0 && di.no_emulation) { return 1; } return 0; }