diff --git a/apps/installer.cpp b/apps/installer.cpp index 5940220..0466df2 100644 --- a/apps/installer.cpp +++ b/apps/installer.cpp @@ -12,6 +12,7 @@ #include #include #include +#include #include #define Log(...) @@ -67,6 +68,7 @@ EsListView *drivesList; EsPanel *driveInformation; EsObjectID selectedDriveID; EsButton *installButton; +EsButton *useMBRCheckbox; EsButton *finishButton; EsPanel *switcher; EsPanel *panelInstallOptions; @@ -78,10 +80,13 @@ EsTextbox *userNameTextbox; EsTextDisplay *progressDisplay; const char *cSelectedFont; uint8_t progress; -bool onWaitScreen, startedInstallation; +bool onWaitScreen; +bool startedInstallation; +bool useMBR; EsBlockDeviceInformation blockDeviceInformation; EsHandle driveHandle; EsFileOffset partitionOffset; +EsFileOffset partitionBytes; EsUniqueIdentifier installationIdentifier; EsMountPoint newFileSystemMountPoint; EsHandle mountNewFileSystemEvent; @@ -312,6 +317,7 @@ void ConnectedDriveRemove(EsMessageDevice device) { EsTextDisplayCreate(driveInformation, ES_CELL_H_FILL | ES_CELL_V_FILL, &styleDrivesSelectHint, INTERFACE_STRING(InstallerDriveRemoved)); selectedDriveID = 0; EsElementSetDisabled(installButton, true); + EsElementSetDisabled(useMBRCheckbox, true); } for (uintptr_t i = 0; i < connectedDrives.Length(); i++) { @@ -343,30 +349,47 @@ void ConnectedDriveSelect(uintptr_t index) { EsIconDisplay *statusIcon = EsIconDisplayCreate(messageRow, ES_CELL_V_TOP, ES_STYLE_ICON_DISPLAY_SMALL, ES_ICON_DIALOG_INFORMATION); EsSpacerCreate(messageRow, ES_CELL_V_FILL, 0, 8, 0); - uint8_t *sectorBuffer = (uint8_t *) EsHeapAllocate(information.sectorSize, false); - EsFileOffset parameters[2] = { 0, information.sectorSize }; - EsError readError = EsDeviceControl(device.handle, ES_DEVICE_CONTROL_BLOCK_READ, sectorBuffer, parameters); + uint8_t *signatureBlock = (uint8_t *) EsHeapAllocate(K_SIGNATURE_BLOCK_SIZE, false); + EsFileOffset parameters[2] = { 0, K_SIGNATURE_BLOCK_SIZE }; + EsError readError = EsDeviceControl(device.handle, ES_DEVICE_CONTROL_BLOCK_READ, signatureBlock, parameters); bool alreadyHasPartitions = false; if (readError == ES_SUCCESS && information.sectorSize >= 0x200) { - // TODO Support GPT. - MBRPartition partitions[4]; + { + MBRPartition partitions[4]; - if (MBRGetPartitions(sectorBuffer, information.sectorCount, partitions)) { - for (uintptr_t i = 0; i < 4; i++) { - if (partitions[i].present) { - alreadyHasPartitions = true; + if (MBRGetPartitions(signatureBlock, information.sectorCount, partitions)) { + for (uintptr_t i = 0; i < 4; i++) { + if (partitions[i].present) { + alreadyHasPartitions = true; + } + } + } + } + + { + GPTPartition partitions[GPT_PARTITION_COUNT]; + + if (GPTGetPartitions(signatureBlock, information.sectorCount, information.sectorSize, partitions)) { + for (uintptr_t i = 0; i < GPT_PARTITION_COUNT; i++) { + if (partitions[i].present) { + alreadyHasPartitions = true; + } } } } } - EsHeapFree(sectorBuffer); + EsHeapFree(signatureBlock); bool showCapacity = false; + // Sector sizes up to 4KB should be possible on GPT, but this hasn't been tested yet. +#if 0 + if (information.sectorSize < 0x200 || information.sectorSize > 0x1000) { +#else if (information.sectorSize != 0x200) { - // TODO Allow other sector sizes if a GPT is being used. +#endif EsIconDisplaySetIcon(statusIcon, ES_ICON_DIALOG_ERROR); EsTextDisplayCreate(messageRow, ES_CELL_H_FILL, ES_STYLE_TEXT_PARAGRAPH, INTERFACE_STRING(InstallerDriveUnsupported)); } else if (readError != ES_SUCCESS) { @@ -388,6 +411,8 @@ void ConnectedDriveSelect(uintptr_t index) { showCapacity = true; } + EsElementSetEnabled(useMBRCheckbox, information.sectorSize == 0x200); + if (showCapacity) { // TODO Localization. char buffer[128]; @@ -401,47 +426,16 @@ void ConnectedDriveSelect(uintptr_t index) { ///////////////////////////////////////////// -EsError Install() { - EsMessage m = { MSG_SET_PROGRESS }; - EsError error; - - size_t mbrBytes, stage1Bytes, stage2Bytes, kernelBytes; - void *mbr = EsFileReadAll(EsLiteral("0:/mbr.dat"), &mbrBytes); - void *stage1 = EsFileReadAll(EsLiteral("0:/stage1.dat"), &stage1Bytes); - void *stage2 = EsFileReadAll(EsLiteral("0:/stage2.dat"), &stage2Bytes); - - EsMessageDevice drive = {}; - - for (uintptr_t i = 0; i < connectedDrives.Length(); i++) { - if (connectedDrives[i].id == selectedDriveID) { - drive = connectedDrives[i]; - } - } - - EsAssert(drive.handle); - EsBlockDeviceInformation driveInformation = ConnectedDriveGetInformation(drive.handle); - blockDeviceInformation = driveInformation; - driveHandle = drive.handle; - - uint8_t *sectorBuffer = (uint8_t *) EsHeapAllocate(driveInformation.sectorSize, false); - if (!sectorBuffer) return ES_ERROR_INSUFFICIENT_RESOURCES; - - size_t bootloaderSectors = (stage1Bytes + stage2Bytes + driveInformation.sectorSize - 1) / driveInformation.sectorSize; - uint8_t *bootloader = (uint8_t *) EsHeapAllocate(bootloaderSectors * driveInformation.sectorSize, true); - EsMemoryCopy(bootloader, stage1, stage1Bytes); - EsMemoryCopy(bootloader + stage1Bytes, stage2, stage2Bytes); - - m.user.context1.u = 1; - EsMessagePost(nullptr, &m); - +EsError InstallMBR(EsBlockDeviceInformation driveInformation, uint8_t *sectorBuffer, EsMessageDevice drive, + void *mbr, EsMessage m, uint8_t *bootloader, size_t bootloaderSectors) { // Create the partition table. - // TODO GPT. // TODO Adding new entries to existing tables. EsAssert(driveInformation.sectorSize == 0x200); + EsError error; partitionOffset = 0x800; - EsFileOffset partitionBytes = driveInformation.sectorSize * (driveInformation.sectorCount - partitionOffset); + partitionBytes = driveInformation.sectorSize * (driveInformation.sectorCount - partitionOffset); uint32_t partitions[16] = { 0x80 /* bootable */, 0x83 /* type */ }; uint16_t bootSignature = 0xAA55; @@ -473,17 +467,337 @@ EsError Install() { m.user.context1.u = 4; EsMessagePost(nullptr, &m); - // Format the partition. + return ES_SUCCESS; +} +void GenerateGUID(uint8_t *destination) { + for (uintptr_t i = 0; i < 16; i++) { + destination[i] = EsRandomU8(); + } + + destination[7] = 0x40 | (destination[6] & 0x0F); + destination[8] = 0x80 | (destination[6] & 0x3F); +} + +EsError FATAddFile(FATDirectoryEntry *directory, size_t directoryEntries, uint16_t *fat, + EsFileOffset totalSectors, EsFileOffset sectorOffset, bool isDirectory, + const char *name, void *file, size_t fileBytes, EsHandle driveHandle) { + // Allocate the sector extent. + + EsFileOffset sectorFirst = 0; + size_t sectorCount = (fileBytes + blockDeviceInformation.sectorSize - 1) / blockDeviceInformation.sectorSize; + + for (uintptr_t i = 2; i < totalSectors - sectorOffset + 2; i++) { + if (!fat[i]) { + sectorFirst = i; + break; + } + } + + EsAssert(sectorFirst); + + for (uintptr_t i = 0; i < sectorCount; i++) { + fat[sectorFirst + i] = i == sectorCount - 1 ? 0xFFF8 : sectorFirst + i + 1; + } + + // Write out the file contents. + + uint8_t *buffer = (uint8_t *) EsHeapAllocate(sectorCount * blockDeviceInformation.sectorSize, true); + EsMemoryCopy(buffer, file, fileBytes); + EsFileOffset parameters[2] = {}; + parameters[0] = (sectorFirst + sectorOffset) * blockDeviceInformation.sectorSize; + parameters[1] = sectorCount * blockDeviceInformation.sectorSize; + EsError error = EsDeviceControl(driveHandle, ES_DEVICE_CONTROL_BLOCK_WRITE, buffer, parameters); + EsHeapFree(buffer); + if (error != ES_SUCCESS) return error; + + // Create the directory entry. + + FATDirectoryEntry *entry = nullptr; + + for (uintptr_t i = 0; i < directoryEntries; i++) { + if (!directory[i].name[0]) { + entry = directory + i; + break; + } + } + + EsAssert(entry); + EsMemoryCopy(entry->name, name, 11); + entry->firstClusterHigh = sectorFirst >> 16; + entry->firstClusterLow = sectorFirst & 0xFFFF; + entry->fileSizeBytes = isDirectory ? 0 : fileBytes; + entry->attributes = isDirectory ? 0x10 : 0x00; + entry->creationDate = 33; + entry->accessedDate = 33; + entry->modificationDate = 33; + + return ES_SUCCESS; +} + +EsError InstallGPT(EsBlockDeviceInformation driveInformation, EsMessageDevice drive, EsMessage m, + void *uefi1, size_t uefi1Bytes, void *uefi2, size_t uefi2Bytes) { + // Create the partition table. + // TODO Adding new entries to existing tables. + + const uint8_t espGUID[] = { 0x28, 0x73, 0x2A, 0xC1, 0x1F, 0xF8, 0xD2, 0x11, 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B }; + const uint8_t dataGUID[] = { 0xAF, 0x3D, 0xC6, 0x0F, 0x83, 0x84, 0x72, 0x47, 0x8E, 0x79, 0x3D, 0x69, 0xD8, 0x47, 0x7D, 0xE4 }; + + EsError error; + EsFileOffset parameters[2] = {}; + + size_t partitionEntryCount = 0x80; + size_t tableSectors = (partitionEntryCount * sizeof(GPTEntry) + driveInformation.sectorSize - 1) / driveInformation.sectorSize; + + ProtectiveMBR *mbr = (ProtectiveMBR *) EsHeapAllocate(driveInformation.sectorSize, true); + uint32_t mbrEntry[4]; + mbrEntry[0] = 0x00020000; + mbrEntry[1] = 0xFFFFFFEE; + mbrEntry[2] = 0x00000001; + mbrEntry[3] = driveInformation.sectorCount > 0xFFFFFFFF ? 0xFFFFFFFF : driveInformation.sectorCount - 1; + mbr->signature = 0xAA55; + EsMemoryCopy(mbr->entry, mbrEntry, 16); + + GPTHeader *header = (GPTHeader *) EsHeapAllocate(driveInformation.sectorSize, true); + EsMemoryCopy(header->signature, "EFI PART", 8); + header->revision = 0x00010000; + header->headerBytes = 0x5C; + header->headerSelfLBA = 1; + header->headerBackupLBA = driveInformation.sectorCount - 1; + header->firstUsableLBA = 2 + tableSectors; + header->lastUsableLBA = driveInformation.sectorCount - 2; + GenerateGUID(header->driveGUID); + header->tableLBA = 2; + header->partitionEntryCount = partitionEntryCount; + header->partitionEntryBytes = sizeof(GPTEntry); + + GPTEntry *partitionTable = (GPTEntry *) EsHeapAllocate(partitionEntryCount * sizeof(GPTEntry), true); + EsMemoryCopy(partitionTable[0].typeGUID, espGUID, 16); + GenerateGUID(partitionTable[0].partitionGUID); + partitionTable[0].firstLBA = header->firstUsableLBA; + partitionTable[0].lastLBA = partitionTable[0].firstLBA + 16777216 / driveInformation.sectorSize - 1; + EsMemoryCopy(partitionTable[1].typeGUID, dataGUID, 16); + GenerateGUID(partitionTable[1].partitionGUID); + partitionTable[1].firstLBA = partitionTable[0].lastLBA + 1; + partitionTable[1].lastLBA = header->lastUsableLBA; + + header->tableCRC32 = CalculateCRC32(partitionTable, partitionEntryCount * sizeof(GPTEntry)); + header->headerCRC32 = CalculateCRC32(header, header->headerBytes); + + GPTHeader *backupHeader = (GPTHeader *) EsHeapAllocate(driveInformation.sectorSize, true); + EsMemoryCopy(backupHeader, header, driveInformation.sectorSize); + backupHeader->headerSelfLBA = header->headerBackupLBA; + backupHeader->headerBackupLBA = header->headerSelfLBA; + backupHeader->headerCRC32 = 0; + backupHeader->headerCRC32 = CalculateCRC32(backupHeader, header->headerBytes); + + parameters[0] = 0; + parameters[1] = driveInformation.sectorSize; + error = EsDeviceControl(drive.handle, ES_DEVICE_CONTROL_BLOCK_WRITE, mbr, parameters); + if (error != ES_SUCCESS) return error; + parameters[0] = header->headerSelfLBA * driveInformation.sectorSize; + parameters[1] = driveInformation.sectorSize; + error = EsDeviceControl(drive.handle, ES_DEVICE_CONTROL_BLOCK_WRITE, header, parameters); + if (error != ES_SUCCESS) return error; + parameters[0] = header->tableLBA * driveInformation.sectorSize; + parameters[1] = driveInformation.sectorSize * tableSectors; + error = EsDeviceControl(drive.handle, ES_DEVICE_CONTROL_BLOCK_WRITE, partitionTable, parameters); + if (error != ES_SUCCESS) return error; + parameters[0] = header->headerBackupLBA * driveInformation.sectorSize; + parameters[1] = driveInformation.sectorSize; + error = EsDeviceControl(drive.handle, ES_DEVICE_CONTROL_BLOCK_WRITE, backupHeader, parameters); + if (error != ES_SUCCESS) return error; + + partitionOffset = partitionTable[1].firstLBA; + partitionBytes = (partitionTable[1].lastLBA - partitionTable[1].firstLBA + 1) * driveInformation.sectorSize; + + m.user.context1.u = 2; + EsMessagePost(nullptr, &m); + + // Load the kernel. + + size_t kernelBytes; void *kernel = EsFileReadAll(EsLiteral(K_OS_FOLDER "/Kernel.esx"), &kernelBytes); + if (!kernel) return ES_ERROR_FILE_DOES_NOT_EXIST; + + m.user.context1.u = 3; + EsMessagePost(nullptr, &m); + + // Format the ESP. + + EsAssert(driveInformation.sectorSize >= 0x200 && driveInformation.sectorSize <= 0x1000); // We only support FAT16. + + EsFileOffset espOffset = partitionTable[0].firstLBA; + EsFileOffset espSectors = partitionTable[0].lastLBA - partitionTable[0].firstLBA + 1; + EsAssert(espSectors * driveInformation.sectorSize == 16777216 && espSectors < 0x10000); + + SuperBlock16 *superBlock = (SuperBlock16 *) EsHeapAllocate(driveInformation.sectorSize, true); + superBlock->jmp[0] = 0xEB; + superBlock->jmp[1] = 0x3C; + superBlock->jmp[2] = 0x90; + EsMemoryCopy(superBlock->oemName, "MSWIN4.1", 8); + superBlock->bytesPerSector = driveInformation.sectorSize; + superBlock->sectorsPerCluster = 1; + superBlock->reservedSectors = 1; + superBlock->fatCount = 2; + superBlock->rootDirectoryEntries = 512; + superBlock->totalSectors = espSectors; + superBlock->mediaDescriptor = 0xF8; + superBlock->sectorsPerFAT16 = (superBlock->totalSectors * 2 + driveInformation.sectorSize - 1) / driveInformation.sectorSize; + superBlock->sectorsPerTrack = 63; + superBlock->heads = 256; + superBlock->deviceID = 0x80; + superBlock->signature = 0x29; + superBlock->serial = (uint32_t) EsRandomU64(); + EsMemoryCopy(superBlock->label, "EFI SYSTEM ", 11); + EsMemoryCopy(&superBlock->systemIdentifier, "FAT16 ", 8); + superBlock->_unused1[448] = 0x55; + superBlock->_unused1[449] = 0xAA; + + uint32_t rootDirectoryOffset = superBlock->reservedSectors + superBlock->fatCount * superBlock->sectorsPerFAT16 + espOffset; + uint32_t rootDirectorySectors = (superBlock->rootDirectoryEntries * sizeof(FATDirectoryEntry) + (superBlock->bytesPerSector - 1)) / superBlock->bytesPerSector; + uint32_t sectorOffset = rootDirectoryOffset + rootDirectorySectors - 2 * superBlock->sectorsPerCluster; + size_t directoryEntriesPerSector = driveInformation.sectorSize / sizeof(FATDirectoryEntry); + + uint16_t *fat = (uint16_t *) EsHeapAllocate(superBlock->sectorsPerFAT16 * driveInformation.sectorSize, true); + fat[0] = 0xFFF8; + fat[1] = 0xFFFF; + + FATDirectoryEntry *bootDirectory = (FATDirectoryEntry *) EsHeapAllocate(driveInformation.sectorSize, true); + // TODO Add self and parent entries. + FATAddDotFiles(bootDirectory, directoryEntriesPerSector); + error = FATAddFile(bootDirectory, directoryEntriesPerSector, fat, superBlock->totalSectors, sectorOffset, false, + "BOOTX64 EFI", uefi1, uefi1Bytes, drive.handle); + if (error != ES_SUCCESS) return error; + + FATDirectoryEntry *efiDirectory = (FATDirectoryEntry *) EsHeapAllocate(driveInformation.sectorSize, true); + // TODO Add self and parent entries. + error = FATAddFile(efiDirectory, directoryEntriesPerSector, fat, superBlock->totalSectors, sectorOffset, true, + "BOOT ", bootDirectory, driveInformation.sectorSize, drive.handle); + if (error != ES_SUCCESS) return error; + + FATDirectoryEntry *rootDirectory = (FATDirectoryEntry *) EsHeapAllocate(rootDirectorySectors * driveInformation.sectorSize, true); + error = FATAddFile(rootDirectory, superBlock->rootDirectoryEntries, fat, superBlock->totalSectors, sectorOffset, false, + "ESLOADERBIN", uefi2, uefi2Bytes, drive.handle); + if (error != ES_SUCCESS) return error; + error = FATAddFile(rootDirectory, superBlock->rootDirectoryEntries, fat, superBlock->totalSectors, sectorOffset, false, + "ESKERNELESX", kernel, kernelBytes, drive.handle); + if (error != ES_SUCCESS) return error; + error = FATAddFile(rootDirectory, superBlock->rootDirectoryEntries, fat, superBlock->totalSectors, sectorOffset, false, + "ESIID DAT", &installationIdentifier, 16, drive.handle); + if (error != ES_SUCCESS) return error; + error = FATAddFile(rootDirectory, superBlock->rootDirectoryEntries, fat, superBlock->totalSectors, sectorOffset, true, + "EFI ", efiDirectory, driveInformation.sectorSize, drive.handle); + if (error != ES_SUCCESS) return error; + + m.user.context1.u = 4; + EsMessagePost(nullptr, &m); + + parameters[0] = espOffset * driveInformation.sectorSize; + parameters[1] = driveInformation.sectorSize; + error = EsDeviceControl(drive.handle, ES_DEVICE_CONTROL_BLOCK_WRITE, superBlock, parameters); + if (error != ES_SUCCESS) return error; + parameters[0] = (espOffset + 1) * driveInformation.sectorSize; + parameters[1] = superBlock->sectorsPerFAT16 * driveInformation.sectorSize; + error = EsDeviceControl(drive.handle, ES_DEVICE_CONTROL_BLOCK_WRITE, fat, parameters); + if (error != ES_SUCCESS) return error; + parameters[0] = (espOffset + 1 + superBlock->sectorsPerFAT16) * driveInformation.sectorSize; + parameters[1] = superBlock->sectorsPerFAT16 * driveInformation.sectorSize; + error = EsDeviceControl(drive.handle, ES_DEVICE_CONTROL_BLOCK_WRITE, fat, parameters); + if (error != ES_SUCCESS) return error; + parameters[0] = rootDirectoryOffset * driveInformation.sectorSize; + parameters[1] = rootDirectorySectors * driveInformation.sectorSize; + error = EsDeviceControl(drive.handle, ES_DEVICE_CONTROL_BLOCK_WRITE, rootDirectory, parameters); + if (error != ES_SUCCESS) return error; + + // Cleanup. + + EsHeapFree(mbr); + EsHeapFree(header); + EsHeapFree(partitionTable); + EsHeapFree(backupHeader); + EsHeapFree(superBlock); + EsHeapFree(fat); + EsHeapFree(rootDirectory); + EsHeapFree(efiDirectory); + EsHeapFree(bootDirectory); m.user.context1.u = 6; EsMessagePost(nullptr, &m); + return ES_SUCCESS; +} + +EsError Install() { + EsMessage m = { MSG_SET_PROGRESS }; + EsError error; + for (int i = 0; i < 16; i++) { installationIdentifier.d[i] = EsRandomU8(); } + size_t mbrBytes, stage1Bytes, stage2Bytes, uefi1Bytes, uefi2Bytes, kernelBytes; + void *mbr = EsFileReadAll(EsLiteral("0:/mbr.dat"), &mbrBytes); + void *stage1 = EsFileReadAll(EsLiteral("0:/stage1.dat"), &stage1Bytes); + void *stage2 = EsFileReadAll(EsLiteral("0:/stage2.dat"), &stage2Bytes); + void *uefi1 = EsFileReadAll(EsLiteral("0:/uefi1.dat"), &uefi1Bytes); + void *uefi2 = EsFileReadAll(EsLiteral("0:/uefi2.dat"), &uefi2Bytes); + + if (!mbr || !stage1 || !stage2 || !uefi1 || !uefi2) { + return ES_ERROR_FILE_DOES_NOT_EXIST; + } + + EsMessageDevice drive = {}; + + for (uintptr_t i = 0; i < connectedDrives.Length(); i++) { + if (connectedDrives[i].id == selectedDriveID) { + drive = connectedDrives[i]; + } + } + + EsAssert(drive.handle); + EsBlockDeviceInformation driveInformation = ConnectedDriveGetInformation(drive.handle); + blockDeviceInformation = driveInformation; + driveHandle = drive.handle; + + uint8_t *sectorBuffer = (uint8_t *) EsHeapAllocate(driveInformation.sectorSize, false); + if (!sectorBuffer) return ES_ERROR_INSUFFICIENT_RESOURCES; + + size_t bootloaderSectors = (stage1Bytes + stage2Bytes + driveInformation.sectorSize - 1) / driveInformation.sectorSize; + uint8_t *bootloader = (uint8_t *) EsHeapAllocate(bootloaderSectors * driveInformation.sectorSize, true); + EsMemoryCopy(bootloader, stage1, stage1Bytes); + EsMemoryCopy(bootloader + stage1Bytes, stage2, stage2Bytes); + + m.user.context1.u = 1; + EsMessagePost(nullptr, &m); + + // Create the partitions and possibly install the bootloader. + + if (useMBR) { + error = InstallMBR(driveInformation, sectorBuffer, drive, mbr, m, bootloader, bootloaderSectors); + } else { + error = InstallGPT(driveInformation, drive, m, uefi1, uefi1Bytes, uefi2, uefi2Bytes); + } + + if (error != ES_SUCCESS) { + return error; + } + + // Format the partition. + + void *kernel; + + if (useMBR) { + kernel = EsFileReadAll(EsLiteral(K_OS_FOLDER "/Kernel.esx"), &kernelBytes); + if (!kernel) return ES_ERROR_FILE_DOES_NOT_EXIST; + m.user.context1.u = 6; + EsMessagePost(nullptr, &m); + } else { + // The kernel is located on the ESP. + kernel = nullptr; + kernelBytes = 0; + } + Format(partitionBytes, interfaceString_InstallerVolumeLabel, installationIdentifier, kernel, kernelBytes); FlushWriteBuffer(); @@ -537,6 +851,7 @@ void ButtonRestart(EsInstance *, EsElement *, EsCommand *) { } void ButtonInstall(EsInstance *, EsElement *, EsCommand *) { + useMBR = EsButtonGetCheck(useMBRCheckbox) == ES_CHECK_CHECKED; EsPanelSwitchTo(switcher, panelCustomizeOptions, ES_TRANSITION_FADE_IN); EsElementFocus(userNameTextbox); startedInstallation = true; @@ -633,6 +948,8 @@ void _start() { driveInformation = EsPanelCreate(drivesSplit, ES_CELL_H_FILL | ES_CELL_V_FILL); EsTextDisplayCreate(driveInformation, ES_CELL_H_FILL | ES_CELL_V_FILL, &styleDrivesSelectHint, INTERFACE_STRING(InstallerDrivesSelectHint)); + useMBRCheckbox = EsButtonCreate(panelInstallOptions, ES_CELL_H_FILL | ES_BUTTON_CHECKBOX | ES_ELEMENT_DISABLED, 0, INTERFACE_STRING(InstallerUseMBR)); + EsPanel *buttonsRow = EsPanelCreate(panelInstallOptions, ES_CELL_H_FILL | ES_PANEL_HORIZONTAL, &styleButtonsRow); EsButtonOnCommand(EsButtonCreate(buttonsRow, ES_FLAGS_DEFAULT, 0, INTERFACE_STRING(InstallerViewLicenses)), ButtonViewLicenses); EsButtonOnCommand(EsButtonCreate(buttonsRow, ES_FLAGS_DEFAULT, 0, INTERFACE_STRING(DesktopShutdownAction)), ButtonShutdown); diff --git a/drivers/fat.cpp b/drivers/fat.cpp index 820e6ac..ec3cc47 100644 --- a/drivers/fat.cpp +++ b/drivers/fat.cpp @@ -3,67 +3,10 @@ // TODO Long file names. #include +#include #define SECTOR_SIZE (512) -struct SuperBlockCommon { - uint8_t _unused0[11]; - uint16_t bytesPerSector; - uint8_t sectorsPerCluster; - uint16_t reservedSectors; - uint8_t fatCount; - uint16_t rootDirectoryEntries; - uint16_t totalSectors; - uint8_t mediaDescriptor; - uint16_t sectorsPerFAT16; - uint16_t sectorsPerTrack; - uint16_t heads; - uint32_t hiddenSectors; - uint32_t largeSectorCount; -} ES_STRUCT_PACKED; - -struct SuperBlock16 : SuperBlockCommon { - uint8_t deviceID; - uint8_t flags; - uint8_t signature; - uint32_t serial; - uint8_t label[11]; - uint64_t systemIdentifier; - uint8_t _unused1[450]; -} ES_STRUCT_PACKED; - -struct SuperBlock32 : SuperBlockCommon { - uint32_t sectorsPerFAT32; - uint16_t flags; - uint16_t version; - uint32_t rootDirectoryCluster; - uint16_t fsInfoSector; - uint16_t backupBootSector; - uint8_t _unused0[12]; - uint8_t deviceID; - uint8_t flags2; - uint8_t signature; - uint32_t serial; - uint8_t label[11]; - uint64_t systemIdentifier; - uint8_t _unused1[422]; -} ES_STRUCT_PACKED; - -struct DirectoryEntry { - uint8_t name[11]; - uint8_t attributes; - uint8_t _reserved0; - uint8_t creationTimeSeconds; - uint16_t creationTime; - uint16_t creationDate; - uint16_t accessedDate; - uint16_t firstClusterHigh; - uint16_t modificationTime; - uint16_t modificationDate; - uint16_t firstClusterLow; - uint32_t fileSizeBytes; -} ES_STRUCT_PACKED; - struct Volume : KFileSystem { union { char _unused0[SECTOR_SIZE]; @@ -82,7 +25,7 @@ struct Volume : KFileSystem { #define TYPE_FAT32 (32) int type; - DirectoryEntry *rootDirectoryEntries; + FATDirectoryEntry *rootDirectoryEntries; }; struct DirectoryEntryReference { @@ -91,11 +34,11 @@ struct DirectoryEntryReference { struct FSNode { Volume *volume; - DirectoryEntry entry; + FATDirectoryEntry entry; // The root directory is loaded during fileSystem mount. // If this is non-null, run directory data from here. - DirectoryEntry *rootDirectory; + FATDirectoryEntry *rootDirectory; }; static uint32_t NextCluster(Volume *volume, uint32_t currentCluster) { @@ -149,14 +92,14 @@ static EsError Load(KNode *_directory, KNode *_node, KNodeMetadata *, const void EsDefer(EsHeapFree(clusterBuffer, 0, K_FIXED)); DirectoryEntryReference reference = *(DirectoryEntryReference *) entryData; - DirectoryEntry entry; + FATDirectoryEntry entry; if (!directory->rootDirectory) { EsError error = volume->Access((reference.cluster * superBlock->sectorsPerCluster + volume->sectorOffset) * SECTOR_SIZE, superBlock->sectorsPerCluster * SECTOR_SIZE, K_ACCESS_READ, (uint8_t *) clusterBuffer, ES_FLAGS_DEFAULT); if (error != ES_SUCCESS) return error; - entry = *(DirectoryEntry *) (clusterBuffer + reference.offset); + entry = *(FATDirectoryEntry *) (clusterBuffer + reference.offset); } else { entry = directory->rootDirectory[reference.offset]; } @@ -244,8 +187,8 @@ static EsError Scan(const char *_name, size_t nameLength, KNode *node) { if (error != ES_SUCCESS) SCAN_FAILURE("Could not read cluster.\n", error); } - for (uintptr_t i = 0; i < superBlock->sectorsPerCluster * SECTOR_SIZE / sizeof(DirectoryEntry); i++, directoryPosition++) { - DirectoryEntry *entry = directory->rootDirectory ? (directory->rootDirectory + directoryPosition) : ((DirectoryEntry *) clusterBuffer + i); + for (uintptr_t i = 0; i < superBlock->sectorsPerCluster * SECTOR_SIZE / sizeof(FATDirectoryEntry); i++, directoryPosition++) { + FATDirectoryEntry *entry = directory->rootDirectory ? (directory->rootDirectory + directoryPosition) : ((FATDirectoryEntry *) clusterBuffer + i); if (entry->name[0] == 0xE5 || entry->attributes == 0x0F || (entry->attributes & 8)) goto nextEntry; if (!entry->name[0]) return ES_ERROR_FILE_DOES_NOT_EXIST; @@ -268,7 +211,7 @@ static EsError Scan(const char *_name, size_t nameLength, KNode *node) { while (currentCluster < volume->terminateCluster) { currentCluster = NextCluster(volume, currentCluster); - metadata.directoryChildren += SECTOR_SIZE * superBlock->sectorsPerCluster / sizeof(DirectoryEntry); + metadata.directoryChildren += SECTOR_SIZE * superBlock->sectorsPerCluster / sizeof(FATDirectoryEntry); } } @@ -310,8 +253,8 @@ static EsError Enumerate(KNode *node) { if (error != ES_SUCCESS) ENUMERATE_FAILURE("Could not read cluster.\n", error); } - for (uintptr_t i = 0; i < superBlock->sectorsPerCluster * SECTOR_SIZE / sizeof(DirectoryEntry); i++, directoryPosition++) { - DirectoryEntry *entry = directory->rootDirectory ? (directory->rootDirectory + directoryPosition) : ((DirectoryEntry *) clusterBuffer + i); + for (uintptr_t i = 0; i < superBlock->sectorsPerCluster * SECTOR_SIZE / sizeof(FATDirectoryEntry); i++, directoryPosition++) { + FATDirectoryEntry *entry = directory->rootDirectory ? (directory->rootDirectory + directoryPosition) : ((FATDirectoryEntry *) clusterBuffer + i); if (entry->name[0] == 0xE5 || entry->attributes == 0x0F || (entry->attributes & 8)) continue; if (!entry->name[0]) { @@ -391,7 +334,7 @@ static bool Mount(Volume *volume) { } uint32_t rootDirectoryOffset = superBlock->reservedSectors + superBlock->fatCount * sectorsPerFAT; - uint32_t rootDirectorySectors = (superBlock->rootDirectoryEntries * sizeof(DirectoryEntry) + (SECTOR_SIZE - 1)) / SECTOR_SIZE; + uint32_t rootDirectorySectors = (superBlock->rootDirectoryEntries * sizeof(FATDirectoryEntry) + (SECTOR_SIZE - 1)) / SECTOR_SIZE; volume->sectorOffset = rootDirectoryOffset + rootDirectorySectors - 2 * superBlock->sectorsPerCluster; @@ -417,10 +360,10 @@ static bool Mount(Volume *volume) { while (currentCluster < volume->terminateCluster) { currentCluster = NextCluster(volume, currentCluster); - volume->rootDirectoryInitialChildren += SECTOR_SIZE * superBlock->sectorsPerCluster / sizeof(DirectoryEntry); + volume->rootDirectoryInitialChildren += SECTOR_SIZE * superBlock->sectorsPerCluster / sizeof(FATDirectoryEntry); } } else { - root->rootDirectory = (DirectoryEntry *) EsHeapAllocate(rootDirectorySectors * SECTOR_SIZE, true, K_FIXED); + root->rootDirectory = (FATDirectoryEntry *) EsHeapAllocate(rootDirectorySectors * SECTOR_SIZE, true, K_FIXED); volume->rootDirectoryEntries = root->rootDirectory; error = volume->Access(rootDirectoryOffset * SECTOR_SIZE, rootDirectorySectors * SECTOR_SIZE, @@ -479,7 +422,7 @@ static void DeviceAttach(KDevice *parent) { volume->nameBytes = sizeof(volume->sb32.label); EsMemoryCopy(volume->name, volume->sb32.label, volume->nameBytes); } else { - if (volume->rootDirectoryEntries[0].attributes & 8) { + if ((volume->rootDirectoryEntries[0].attributes & 8) && (volume->rootDirectoryEntries[0].attributes != 0x0F)) { volume->nameBytes = sizeof(volume->rootDirectoryEntries[0].name); EsMemoryCopy(volume->name, volume->rootDirectoryEntries[0].name, volume->nameBytes); } else { diff --git a/res/Theme Source.dat b/res/Theme Source.dat index d21cb2c..5c20fb8 100644 Binary files a/res/Theme Source.dat and b/res/Theme Source.dat differ diff --git a/res/Themes/Theme.dat b/res/Themes/Theme.dat index 32ede28..390f26b 100644 Binary files a/res/Themes/Theme.dat and b/res/Themes/Theme.dat differ diff --git a/shared/fat.cpp b/shared/fat.cpp new file mode 100644 index 0000000..a07855b --- /dev/null +++ b/shared/fat.cpp @@ -0,0 +1,58 @@ +struct SuperBlockCommon { + uint8_t jmp[3]; + uint8_t oemName[8]; + uint16_t bytesPerSector; + uint8_t sectorsPerCluster; + uint16_t reservedSectors; + uint8_t fatCount; + uint16_t rootDirectoryEntries; + uint16_t totalSectors; + uint8_t mediaDescriptor; + uint16_t sectorsPerFAT16; + uint16_t sectorsPerTrack; + uint16_t heads; + uint32_t hiddenSectors; + uint32_t largeSectorCount; +} ES_STRUCT_PACKED; + +struct SuperBlock16 : SuperBlockCommon { + uint8_t deviceID; + uint8_t flags; + uint8_t signature; + uint32_t serial; + uint8_t label[11]; + uint64_t systemIdentifier; + uint8_t _unused1[450]; +} ES_STRUCT_PACKED; + +struct SuperBlock32 : SuperBlockCommon { + uint32_t sectorsPerFAT32; + uint16_t flags; + uint16_t version; + uint32_t rootDirectoryCluster; + uint16_t fsInfoSector; + uint16_t backupBootSector; + uint8_t _unused0[12]; + uint8_t deviceID; + uint8_t flags2; + uint8_t signature; + uint32_t serial; + uint8_t label[11]; + uint64_t systemIdentifier; + uint8_t _unused1[422]; +} ES_STRUCT_PACKED; + +struct FATDirectoryEntry { + uint8_t name[11]; + uint8_t attributes; + uint8_t _reserved0; + uint8_t creationTimeSeconds; + uint16_t creationTime; + uint16_t creationDate; + uint16_t accessedDate; + uint16_t firstClusterHigh; + uint16_t modificationTime; + uint16_t modificationDate; + uint16_t firstClusterLow; + uint32_t fileSizeBytes; +} ES_STRUCT_PACKED; diff --git a/shared/partitions.cpp b/shared/partitions.cpp index f899011..f829ce7 100644 --- a/shared/partitions.cpp +++ b/shared/partitions.cpp @@ -65,6 +65,39 @@ typedef struct GPTPartition { bool present, isESP; } GPTPartition; +typedef struct GPTHeader { + uint8_t signature[8]; + uint32_t revision; + uint32_t headerBytes; + uint32_t headerCRC32; + uint32_t _reserved0; + uint64_t headerSelfLBA; + uint64_t headerBackupLBA; + uint64_t firstUsableLBA; + uint64_t lastUsableLBA; + uint8_t driveGUID[16]; + uint64_t tableLBA; + uint32_t partitionEntryCount; + uint32_t partitionEntryBytes; + uint32_t tableCRC32; +} GPTHeader; + +typedef struct GPTEntry { + uint8_t typeGUID[16]; + uint8_t partitionGUID[16]; + uint64_t firstLBA; + uint64_t lastLBA; + uint64_t attributes; + uint16_t name[36]; +} GPTEntry; + +typedef struct ProtectiveMBR { + uint8_t _unused0[446]; + uint8_t entry[16]; + uint8_t _unused1[48]; + uint16_t signature; +} ProtectiveMBR; + bool GPTGetPartitions(uint8_t *block /* K_SIGNATURE_BLOCK_SIZE */, EsFileOffset sectorCount, EsFileOffset sectorBytes, GPTPartition *partitions /* GPT_PARTITION_COUNT */) { for (uintptr_t i = 0; i < GPT_PARTITION_COUNT; i++) { diff --git a/shared/strings.cpp b/shared/strings.cpp index a1931ab..e0961f5 100644 --- a/shared/strings.cpp +++ b/shared/strings.cpp @@ -320,6 +320,7 @@ DEFINE_INTERFACE_STRING(InstallerProgressMessage, "Installing, please wait" ELLI DEFINE_INTERFACE_STRING(InstallerCompleteFromOther, "Installation has completed successfully. Remove the installation disk, and restart your computer."); DEFINE_INTERFACE_STRING(InstallerCompleteFromUSB, "Installation has completed successfully. Disconnect the installation USB, and restart your computer."); DEFINE_INTERFACE_STRING(InstallerVolumeLabel, "Essence HD"); +DEFINE_INTERFACE_STRING(InstallerUseMBR, "Use legacy BIOS boot (select for older computers)"); // TODO System Monitor.