Aren/rulimine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Binary release v2.92

Browse Source
This commit is contained in:
mintsuki 2022-03-31 07:11:18 +00:00
parent 4bf011d37f
commit 65420ef76e
12 changed files with 1338 additions and 1281 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
BOOTIA32.EFI
View File

Binary file not shown.

BIN
BOOTX64.EFI
View File

Binary file not shown.

BIN
limine-cd.bin
View File

Binary file not shown.

BIN
limine-eltorito-efi.bin
View File

Binary file not shown.

BIN
limine-hdd.bin
View File

Binary file not shown.

2446
limine-hdd.h
View File

File diff suppressed because it is too large Load Diff

BIN
limine-install-linux-x86_32
View File

Binary file not shown.

BIN
limine-install-linux-x86_64
View File

Binary file not shown.

BIN
limine-install-win32.exe
View File

Binary file not shown.

173
limine-install.c
View File

@ -130,6 +130,44 @@ static uint32_t crc32(void *_stream, size_t len) {
return ret;
}
static bool bigendian = false;
static uint16_t endswap16(uint16_t value) {
uint16_t ret = 0;
ret |= (value >> 8) & 0x00ff;
ret |= (value << 8) & 0xff00;
return ret;
}
static uint32_t endswap32(uint32_t value) {
uint32_t ret = 0;
ret |= (value >> 24) & 0x000000ff;
ret |= (value >> 8) & 0x0000ff00;
ret |= (value << 8) & 0x00ff0000;
ret |= (value << 24) & 0xff000000;
return ret;
}
static uint64_t endswap64(uint64_t value) {
uint64_t ret = 0;
ret |= (value >> 56) & 0x00000000000000ff;
ret |= (value >> 40) & 0x000000000000ff00;
ret |= (value >> 24) & 0x0000000000ff0000;
ret |= (value >> 8) & 0x00000000ff000000;
ret |= (value << 8) & 0x000000ff00000000;
ret |= (value << 24) & 0x0000ff0000000000;
ret |= (value << 40) & 0x00ff000000000000;
ret |= (value << 56) & 0xff00000000000000;
return ret;
}
#define ENDSWAP(VALUE) (bigendian ? ( \
sizeof(VALUE) == 1 ? (VALUE) : \
sizeof(VALUE) == 2 ? endswap16(VALUE) : \
sizeof(VALUE) == 4 ? endswap32(VALUE) : \
sizeof(VALUE) == 8 ? endswap64(VALUE) : (abort(), 1) \
) : (VALUE))
static enum {
CACHE_CLEAN,
CACHE_DIRTY
@ -280,6 +318,10 @@ int main(int argc, char *argv[]) {
size_t bootloader_file_size = sizeof(_binary_limine_hdd_bin_data);
uint8_t orig_mbr[70], timestamp[6];
uint32_t endcheck = 0x12345678;
uint8_t endbyte = *((uint8_t *)&endcheck);
bigendian = endbyte == 0x12;
if (argc < 2) {
printf("Usage: %s <device> [GPT partition index]\n", argv[0]);
goto cleanup;
@ -324,8 +366,8 @@ int main(int argc, char *argv[]) {
struct gpt_table_header secondary_gpt_header;
if (gpt) {
fprintf(stderr, "Secondary header at LBA 0x%" PRIx64 ".\n",
gpt_header.alternate_lba);
device_read(&secondary_gpt_header, lb_size * gpt_header.alternate_lba,
ENDSWAP(gpt_header.alternate_lba));
device_read(&secondary_gpt_header, lb_size * ENDSWAP(gpt_header.alternate_lba),
sizeof(struct gpt_table_header));
if (!strncmp(secondary_gpt_header.signature, "EFI PART", 8)) {
fprintf(stderr, "Secondary header valid.\n");
@ -340,71 +382,78 @@ int main(int argc, char *argv[]) {
// Do all sanity checks on MBR
mbr = 1;
uint16_t hint = 0;
device_read(&hint, 218, sizeof(uint16_t));
if (hint != 0) {
uint8_t hint8 = 0;
uint16_t hint16 = 0;
device_read(&hint16, 218, sizeof(uint16_t));
hint16 = ENDSWAP(hint16);
if (hint16 != 0) {
if (!force_mbr) {
mbr = 0;
} else {
hint = 0;
device_write(&hint, 218, sizeof(uint16_t));
hint16 = 0;
hint16 = ENDSWAP(hint16);
device_write(&hint16, 218, sizeof(uint16_t));
}
}
device_read(&hint, 444, sizeof(uint16_t));
if (hint != 0 && hint != 0x5a5a) {
device_read(&hint16, 444, sizeof(uint16_t));
hint16 = ENDSWAP(hint16);
if (hint16 != 0 && hint16 != 0x5a5a) {
if (!force_mbr) {
mbr = 0;
} else {
hint = 0;
device_write(&hint, 444, sizeof(uint16_t));
hint16 = 0;
hint16 = ENDSWAP(hint16);
device_write(&hint16, 444, sizeof(uint16_t));
}
}
device_read(&hint, 510, sizeof(uint16_t));
if (hint != 0xaa55) {
device_read(&hint16, 510, sizeof(uint16_t));
hint16 = ENDSWAP(hint16);
if (hint16 != 0xaa55) {
if (!force_mbr) {
mbr = 0;
} else {
hint = 0xaa55;
device_write(&hint, 510, sizeof(uint16_t));
hint16 = 0xaa55;
hint16 = ENDSWAP(hint16);
device_write(&hint16, 510, sizeof(uint16_t));
}
}
device_read(&hint, 446, sizeof(uint8_t));
if ((uint8_t)hint != 0x00 && (uint8_t)hint != 0x80) {
device_read(&hint8, 446, sizeof(uint8_t));
if (hint8 != 0x00 && hint8 != 0x80) {
if (!force_mbr) {
mbr = 0;
} else {
hint = (uint8_t)hint & 0x80 ? 0x80 : 0x00;
device_write(&hint, 446, sizeof(uint8_t));
hint8 = hint8 & 0x80 ? 0x80 : 0x00;
device_write(&hint8, 446, sizeof(uint8_t));
}
}
device_read(&hint, 462, sizeof(uint8_t));
if ((uint8_t)hint != 0x00 && (uint8_t)hint != 0x80) {
device_read(&hint8, 462, sizeof(uint8_t));
if (hint8 != 0x00 && hint8 != 0x80) {
if (!force_mbr) {
mbr = 0;
} else {
hint = (uint8_t)hint & 0x80 ? 0x80 : 0x00;
device_write(&hint, 462, sizeof(uint8_t));
hint8 = hint8 & 0x80 ? 0x80 : 0x00;
device_write(&hint8, 462, sizeof(uint8_t));
}
}
device_read(&hint, 478, sizeof(uint8_t));
if ((uint8_t)hint != 0x00 && (uint8_t)hint != 0x80) {
device_read(&hint8, 478, sizeof(uint8_t));
if (hint8 != 0x00 && hint8 != 0x80) {
if (!force_mbr) {
mbr = 0;
} else {
hint = (uint8_t)hint & 0x80 ? 0x80 : 0x00;
device_write(&hint, 478, sizeof(uint8_t));
hint8 = hint8 & 0x80 ? 0x80 : 0x00;
device_write(&hint8, 478, sizeof(uint8_t));
}
}
device_read(&hint, 494, sizeof(uint8_t));
if ((uint8_t)hint != 0x00 && (uint8_t)hint != 0x80) {
device_read(&hint8, 494, sizeof(uint8_t));
if (hint8 != 0x00 && hint8 != 0x80) {
if (!force_mbr) {
mbr = 0;
} else {
hint = (uint8_t)hint & 0x80 ? 0x80 : 0x00;
device_write(&hint, 494, sizeof(uint8_t));
hint8 = hint8 & 0x80 ? 0x80 : 0x00;
device_write(&hint8, 494, sizeof(uint8_t));
}
}
@ -427,13 +476,15 @@ int main(int argc, char *argv[]) {
device_write(hintc, 54, 5);
}
}
device_read(&hint, 1080, sizeof(uint16_t));
if (hint == 0xef53) {
device_read(&hint16, 1080, sizeof(uint16_t));
hint16 = ENDSWAP(hint16);
if (hint16 == 0xef53) {
if (!force_mbr) {
mbr = 0;
} else {
hint = 0;
device_write(&hint, 1080, sizeof(uint16_t));
hint16 = 0;
hint16 = ENDSWAP(hint16);
device_write(&hint16, 1080, sizeof(uint16_t));
}
}
}
@ -463,14 +514,14 @@ int main(int argc, char *argv[]) {
uint32_t partition_num;
sscanf(argv[2], "%" SCNu32, &partition_num);
partition_num--;
if (partition_num > gpt_header.number_of_partition_entries) {
if (partition_num > ENDSWAP(gpt_header.number_of_partition_entries)) {
fprintf(stderr, "ERROR: Partition number is too large.\n");
goto cleanup;
}
struct gpt_entry gpt_entry;
device_read(&gpt_entry,
(gpt_header.partition_entry_lba * lb_size)
(ENDSWAP(gpt_header.partition_entry_lba) * lb_size)
+ (partition_num * sizeof(struct gpt_entry)),
sizeof(struct gpt_entry));
@ -482,7 +533,7 @@ int main(int argc, char *argv[]) {
fprintf(stderr, "GPT partition specified. Installing there instead of embedding.\n");
stage2_loc_a = gpt_entry.starting_lba * lb_size;
stage2_loc_a = ENDSWAP(gpt_entry.starting_lba) * lb_size;
stage2_loc_b = stage2_loc_a + stage2_size_a;
if (stage2_loc_b & (lb_size - 1))
stage2_loc_b = (stage2_loc_b + lb_size) & ~(lb_size - 1);
@ -490,10 +541,10 @@ int main(int argc, char *argv[]) {
fprintf(stderr, "GPT partition NOT specified. Attempting GPT embedding.\n");
int64_t max_partition_entry_used = -1;
for (int64_t i = 0; i < (int64_t)gpt_header.number_of_partition_entries; i++) {
for (int64_t i = 0; i < (int64_t)ENDSWAP(gpt_header.number_of_partition_entries); i++) {
struct gpt_entry gpt_entry;
device_read(&gpt_entry,
(gpt_header.partition_entry_lba * lb_size)
(ENDSWAP(gpt_header.partition_entry_lba) * lb_size)
+ (i * sizeof(struct gpt_entry)),
sizeof(struct gpt_entry));
@ -504,17 +555,17 @@ int main(int argc, char *argv[]) {
}
}
stage2_loc_a = (gpt_header.partition_entry_lba + 32) * lb_size;
stage2_loc_a = (ENDSWAP(gpt_header.partition_entry_lba) + 32) * lb_size;
stage2_loc_a -= stage2_size_a;
stage2_loc_a &= ~(lb_size - 1);
stage2_loc_b = (secondary_gpt_header.partition_entry_lba + 32) * lb_size;
stage2_loc_b = (ENDSWAP(secondary_gpt_header.partition_entry_lba) + 32) * lb_size;
stage2_loc_b -= stage2_size_b;
stage2_loc_b &= ~(lb_size - 1);
size_t partition_entries_per_lb =
lb_size / gpt_header.size_of_partition_entry;
lb_size / ENDSWAP(gpt_header.size_of_partition_entry);
size_t new_partition_array_lba_size =
stage2_loc_a / lb_size - gpt_header.partition_entry_lba;
stage2_loc_a / lb_size - ENDSWAP(gpt_header.partition_entry_lba);
size_t new_partition_entry_count =
new_partition_array_lba_size * partition_entries_per_lb;
@ -526,51 +577,53 @@ int main(int argc, char *argv[]) {
fprintf(stderr, "New maximum count of partition entries: %zu.\n", new_partition_entry_count);
// Zero out unused partitions
void *empty = calloc(1, gpt_header.size_of_partition_entry);
void *empty = calloc(1, ENDSWAP(gpt_header.size_of_partition_entry));
for (size_t i = max_partition_entry_used + 1; i < new_partition_entry_count; i++) {
device_write(empty,
gpt_header.partition_entry_lba * lb_size + i * gpt_header.size_of_partition_entry,
gpt_header.size_of_partition_entry);
ENDSWAP(gpt_header.partition_entry_lba) * lb_size + i * ENDSWAP(gpt_header.size_of_partition_entry),
ENDSWAP(gpt_header.size_of_partition_entry));
}
for (size_t i = max_partition_entry_used + 1; i < new_partition_entry_count; i++) {
device_write(empty,
secondary_gpt_header.partition_entry_lba * lb_size + i * secondary_gpt_header.size_of_partition_entry,
secondary_gpt_header.size_of_partition_entry);
ENDSWAP(secondary_gpt_header.partition_entry_lba) * lb_size + i * ENDSWAP(secondary_gpt_header.size_of_partition_entry),
ENDSWAP(secondary_gpt_header.size_of_partition_entry));
}
free(empty);
uint8_t *partition_array =
malloc(new_partition_entry_count * gpt_header.size_of_partition_entry);
malloc(new_partition_entry_count * ENDSWAP(gpt_header.size_of_partition_entry));
if (partition_array == NULL) {
perror("ERROR");
goto cleanup;
}
device_read(partition_array,
gpt_header.partition_entry_lba * lb_size,
new_partition_entry_count * gpt_header.size_of_partition_entry);
ENDSWAP(gpt_header.partition_entry_lba) * lb_size,
new_partition_entry_count * ENDSWAP(gpt_header.size_of_partition_entry));
uint32_t crc32_partition_array =
crc32(partition_array,
new_partition_entry_count * gpt_header.size_of_partition_entry);
new_partition_entry_count * ENDSWAP(gpt_header.size_of_partition_entry));
free(partition_array);
gpt_header.partition_entry_array_crc32 = crc32_partition_array;
gpt_header.number_of_partition_entries = new_partition_entry_count;
gpt_header.partition_entry_array_crc32 = ENDSWAP(crc32_partition_array);
gpt_header.number_of_partition_entries = ENDSWAP(new_partition_entry_count);
gpt_header.crc32 = 0;
gpt_header.crc32 = crc32(&gpt_header, 92);
gpt_header.crc32 = ENDSWAP(gpt_header.crc32);
device_write(&gpt_header,
lb_size,
sizeof(struct gpt_table_header));
secondary_gpt_header.partition_entry_array_crc32 = crc32_partition_array;
secondary_gpt_header.partition_entry_array_crc32 = ENDSWAP(crc32_partition_array);
secondary_gpt_header.number_of_partition_entries =
new_partition_entry_count;
ENDSWAP(new_partition_entry_count);
secondary_gpt_header.crc32 = 0;
secondary_gpt_header.crc32 = crc32(&secondary_gpt_header, 92);
secondary_gpt_header.crc32 = ENDSWAP(secondary_gpt_header.crc32);
device_write(&secondary_gpt_header,
lb_size * gpt_header.alternate_lba,
lb_size * ENDSWAP(gpt_header.alternate_lba),
sizeof(struct gpt_table_header));
}
} else {
@ -595,9 +648,13 @@ int main(int argc, char *argv[]) {
stage2_loc_b, stage2_size - stage2_size_a);
// Hardcode in the bootsector the location of stage 2 halves
stage2_size_a = ENDSWAP(stage2_size_a);
device_write(&stage2_size_a, 0x1a4 + 0, sizeof(uint16_t));
stage2_size_b = ENDSWAP(stage2_size_b);
device_write(&stage2_size_b, 0x1a4 + 2, sizeof(uint16_t));
stage2_loc_a = ENDSWAP(stage2_loc_a);
device_write(&stage2_loc_a, 0x1a4 + 4, sizeof(uint64_t));
stage2_loc_b = ENDSWAP(stage2_loc_b);
device_write(&stage2_loc_b, 0x1a4 + 12, sizeof(uint64_t));
// Write back timestamp

BIN
limine-pxe.bin
View File

Binary file not shown.

BIN
limine.sys
View File

Binary file not shown.