From f495cc1e93710c233292a503720ec235a61b685c Mon Sep 17 00:00:00 2001 From: Marvin Borner Date: Wed, 18 Mar 2020 17:32:50 +0100 Subject: Applied official linux kernel code style guidelines Due to my change to vim and the clang-format plugin this was needed! --- src/kernel/fs/ata_pio.c | 221 ++++++++++++++++++---------------- src/kernel/fs/ata_pio.h | 20 +-- src/kernel/fs/atapi_pio.c | 38 +++--- src/kernel/fs/atapi_pio.h | 14 +-- src/kernel/fs/elf.h | 66 +++++----- src/kernel/fs/elfloader.c | 90 +++++++------- src/kernel/fs/install.c | 140 ++++++++++----------- src/kernel/fs/iso9660/iso9660.c | 95 +++++++-------- src/kernel/fs/iso9660/iso9660.h | 4 +- src/kernel/fs/load.c | 86 +++++++------ src/kernel/fs/load.h | 14 +-- src/kernel/fs/marfs/directory.c | 96 ++++++++------- src/kernel/fs/marfs/disklevel.c | 30 ++--- src/kernel/fs/marfs/marfs.h | 40 +++--- src/kernel/fs/marfs/new_file.c | 169 +++++++++++++------------- src/kernel/fs/marfs/read_whole_file.c | 90 +++++++------- src/kernel/fs/marfs/sectorlevel.c | 143 +++++++++++----------- src/kernel/fs/vfs.c | 42 +++---- src/kernel/fs/vfs.h | 46 +++---- 19 files changed, 743 insertions(+), 701 deletions(-) (limited to 'src/kernel/fs') diff --git a/src/kernel/fs/ata_pio.c b/src/kernel/fs/ata_pio.c index ef9a23e..1786e66 100644 --- a/src/kernel/fs/ata_pio.c +++ b/src/kernel/fs/ata_pio.c @@ -4,122 +4,139 @@ struct ata_interface *new_ata(uint8_t master, uint16_t port_base) { - struct ata_interface *ret = (struct ata_interface *) kmalloc(sizeof(struct ata_interface)); - - ret->master = master; - ret->data_port = port_base; - ret->error_port = (uint16_t) (port_base + 0x1); - ret->sector_count_port = (uint16_t) (port_base + 0x2); - ret->lba_low_port = (uint16_t) (port_base + 0x3); - ret->lba_mid_port = (uint16_t) (port_base + 0x4); - ret->lba_high_port = (uint16_t) (port_base + 0x5); - ret->device_port = (uint16_t) (port_base + 0x6); - ret->command_port = (uint16_t) (port_base + 0x7); - ret->control_port = (uint16_t) (port_base + 0x206); - - return ret; + struct ata_interface *ret = (struct ata_interface *)kmalloc(sizeof(struct ata_interface)); + + ret->master = master; + ret->data_port = port_base; + ret->error_port = (uint16_t)(port_base + 0x1); + ret->sector_count_port = (uint16_t)(port_base + 0x2); + ret->lba_low_port = (uint16_t)(port_base + 0x3); + ret->lba_mid_port = (uint16_t)(port_base + 0x4); + ret->lba_high_port = (uint16_t)(port_base + 0x5); + ret->device_port = (uint16_t)(port_base + 0x6); + ret->command_port = (uint16_t)(port_base + 0x7); + ret->control_port = (uint16_t)(port_base + 0x206); + + return ret; } uint8_t ata_identify(struct ata_interface *interface, uint16_t *ret_data) { - outb(interface->device_port, (uint8_t) (interface->master ? 0xA0 : 0xB0)); - outb(interface->control_port, 0); - - outb(interface->device_port, 0xA0); - uint8_t status = inb(interface->command_port); - if (status == 0xFF) return 1; - - outb(interface->device_port, (uint8_t) (interface->master ? 0xA0 : 0xB0)); - outb(interface->sector_count_port, 0); - outb(interface->lba_low_port, 0); - outb(interface->lba_mid_port, 0); - outb(interface->lba_high_port, 0); - outb(interface->command_port, 0xEC); // Identify command - - status = inb(interface->command_port); - if (!status) return 1; - - while (((status & 0x80) == 0x80) && ((status & 0x01) != 0x01)) { - status = inb(interface->command_port); - } - - if (status & 0x01) return 1; - - for (int i = 0; i < 256; i++) ret_data[i] = inw(interface->data_port); - return 0; + outb(interface->device_port, (uint8_t)(interface->master ? 0xA0 : 0xB0)); + outb(interface->control_port, 0); + + outb(interface->device_port, 0xA0); + uint8_t status = inb(interface->command_port); + if (status == 0xFF) + return 1; + + outb(interface->device_port, (uint8_t)(interface->master ? 0xA0 : 0xB0)); + outb(interface->sector_count_port, 0); + outb(interface->lba_low_port, 0); + outb(interface->lba_mid_port, 0); + outb(interface->lba_high_port, 0); + outb(interface->command_port, 0xEC); // Identify command + + status = inb(interface->command_port); + if (!status) + return 1; + + while (((status & 0x80) == 0x80) && ((status & 0x01) != 0x01)) { + status = inb(interface->command_port); + } + + if (status & 0x01) + return 1; + + for (int i = 0; i < 256; i++) + ret_data[i] = inw(interface->data_port); + return 0; } uint8_t *ata_read28(struct ata_interface *interface, uint32_t sector) { - if (sector > 0x0FFFFFFF) return 0; - - outb(interface->device_port, (uint8_t) ((interface->master ? 0xE0 : 0xF0) | ((sector & 0x0F000000) >> 24))); - - uint8_t status = 0; - for (int i = 0; i < 5; i++) status = inb(interface->command_port); - if (status == 0xFF) return 0; - - outb(interface->error_port, 0); - outb(interface->sector_count_port, 1); - outb(interface->lba_low_port, (uint8_t) (sector & 0x000000FF)); - outb(interface->lba_mid_port, (uint8_t) ((sector & 0x0000FF00) >> 8)); - outb(interface->lba_high_port, (uint8_t) ((sector & 0x00FF0000) >> 16)); - outb(interface->command_port, 0x20); // Read command - - status = inb(interface->command_port); - while ((status & 0x80) && !(status & 0x01)) status = inb(interface->command_port); - - uint8_t *ret = (uint8_t *) kmalloc(BYTES_PER_SECTOR); - for (int i = 0; i < BYTES_PER_SECTOR; i += 2) { - uint16_t data = inw(interface->data_port); - ret[i] = (uint8_t) (data & 0xFF); - ret[i + 1] = (uint8_t) ((data >> 8) & 0xFF); - } - return ret; + if (sector > 0x0FFFFFFF) + return 0; + + outb(interface->device_port, + (uint8_t)((interface->master ? 0xE0 : 0xF0) | ((sector & 0x0F000000) >> 24))); + + uint8_t status = 0; + for (int i = 0; i < 5; i++) + status = inb(interface->command_port); + if (status == 0xFF) + return 0; + + outb(interface->error_port, 0); + outb(interface->sector_count_port, 1); + outb(interface->lba_low_port, (uint8_t)(sector & 0x000000FF)); + outb(interface->lba_mid_port, (uint8_t)((sector & 0x0000FF00) >> 8)); + outb(interface->lba_high_port, (uint8_t)((sector & 0x00FF0000) >> 16)); + outb(interface->command_port, 0x20); // Read command + + status = inb(interface->command_port); + while ((status & 0x80) && !(status & 0x01)) + status = inb(interface->command_port); + + uint8_t *ret = (uint8_t *)kmalloc(BYTES_PER_SECTOR); + for (int i = 0; i < BYTES_PER_SECTOR; i += 2) { + uint16_t data = inw(interface->data_port); + ret[i] = (uint8_t)(data & 0xFF); + ret[i + 1] = (uint8_t)((data >> 8) & 0xFF); + } + return ret; } uint8_t ata_write28(struct ata_interface *interface, uint32_t sector, const uint8_t *contents) { - if (sector > 0x0FFFFFFF) return 1; - cli(); - - outb(interface->device_port, (uint8_t) ((interface->master ? 0xE0 : 0xF0) | ((sector & 0x0F000000) >> 24))); - - uint8_t status = 0; - for (int i = 0; i < 5; i++) status = inb(interface->command_port); - if (status == 0xFF) return 1; - - outb(interface->error_port, 0); - outb(interface->sector_count_port, 1); - outb(interface->lba_low_port, (uint8_t) (sector & 0x000000FF)); - outb(interface->lba_mid_port, (uint8_t) ((sector & 0x0000FF00) >> 8)); - outb(interface->lba_high_port, (uint8_t) ((sector & 0x00FF0000) >> 16)); - outb(interface->command_port, 0x30); // Write command - - while ((status & 0x80) || !(status & 0x08)) status = inb(interface->command_port); - - if (status & (0x01 || 0x20)) return 2; - - for (int i = 0; i < BYTES_PER_SECTOR; i += 2) { - uint16_t data = contents[i]; - data |= ((uint16_t) contents[i + 1]) << 8; - outw(interface->data_port, data); - } - - outb(interface->command_port, 0xE7); // Flush command - - for (int i = 0; i < 5; i++) status = inb(interface->command_port); - if (!status) return 3; - - while ((status & 0x80) && !(status & 0x01)) { - status = inb(interface->command_port); - } - - return 0; + if (sector > 0x0FFFFFFF) + return 1; + cli(); + + outb(interface->device_port, + (uint8_t)((interface->master ? 0xE0 : 0xF0) | ((sector & 0x0F000000) >> 24))); + + uint8_t status = 0; + for (int i = 0; i < 5; i++) + status = inb(interface->command_port); + if (status == 0xFF) + return 1; + + outb(interface->error_port, 0); + outb(interface->sector_count_port, 1); + outb(interface->lba_low_port, (uint8_t)(sector & 0x000000FF)); + outb(interface->lba_mid_port, (uint8_t)((sector & 0x0000FF00) >> 8)); + outb(interface->lba_high_port, (uint8_t)((sector & 0x00FF0000) >> 16)); + outb(interface->command_port, 0x30); // Write command + + while ((status & 0x80) || !(status & 0x08)) + status = inb(interface->command_port); + + if (status & (0x01 || 0x20)) + return 2; + + for (int i = 0; i < BYTES_PER_SECTOR; i += 2) { + uint16_t data = contents[i]; + data |= ((uint16_t)contents[i + 1]) << 8; + outw(interface->data_port, data); + } + + outb(interface->command_port, 0xE7); // Flush command + + for (int i = 0; i < 5; i++) + status = inb(interface->command_port); + if (!status) + return 3; + + while ((status & 0x80) && !(status & 0x01)) { + status = inb(interface->command_port); + } + + return 0; } uint8_t ata_clear28(struct ata_interface *interface, uint32_t sector) { - uint8_t empty_sector[512] = {0}; - return ata_write28(interface, sector, empty_sector); + uint8_t empty_sector[512] = { 0 }; + return ata_write28(interface, sector, empty_sector); } diff --git a/src/kernel/fs/ata_pio.h b/src/kernel/fs/ata_pio.h index fa08a0c..bb62805 100644 --- a/src/kernel/fs/ata_pio.h +++ b/src/kernel/fs/ata_pio.h @@ -6,16 +6,16 @@ #define BYTES_PER_SECTOR 512 struct ata_interface { - uint8_t master; - uint16_t data_port; - uint16_t error_port; - uint16_t sector_count_port; - uint16_t lba_low_port; - uint16_t lba_mid_port; - uint16_t lba_high_port; - uint16_t device_port; - uint16_t command_port; - uint16_t control_port; + uint8_t master; + uint16_t data_port; + uint16_t error_port; + uint16_t sector_count_port; + uint16_t lba_low_port; + uint16_t lba_mid_port; + uint16_t lba_high_port; + uint16_t device_port; + uint16_t command_port; + uint16_t control_port; }; struct ata_interface *new_ata(uint8_t master, uint16_t port_base); diff --git a/src/kernel/fs/atapi_pio.c b/src/kernel/fs/atapi_pio.c index 39f32b6..6f0e3a6 100644 --- a/src/kernel/fs/atapi_pio.c +++ b/src/kernel/fs/atapi_pio.c @@ -4,29 +4,29 @@ void ATAPI_read(uint16_t nblocks, uint32_t lba) { - struct dapack *d = (struct dapack *) ATAPI_PIO_DAPACK; - d->size = 0x10; - d->null = 0x00; - d->blk_count = nblocks; - d->b_offset = ATAPI_PIO_BUFFER; - d->b_segment = 0x0000; - d->start = lba; - d->upper_lba_bits = 0x00000000; + struct dapack *d = (struct dapack *)ATAPI_PIO_DAPACK; + d->size = 0x10; + d->null = 0x00; + d->blk_count = nblocks; + d->b_offset = ATAPI_PIO_BUFFER; + d->b_segment = 0x0000; + d->start = lba; + d->upper_lba_bits = 0x00000000; - regs16_t regs; - regs.ax = 0x4200; - regs.dx = ATAPI_PIO_DRIVE; - regs.ds = 0; - regs.si = ATAPI_PIO_DAPACK; + regs16_t regs; + regs.ax = 0x4200; + regs.dx = ATAPI_PIO_DRIVE; + regs.ds = 0; + regs.si = ATAPI_PIO_DAPACK; - v86(LBA_READ_INT, ®s); + v86(LBA_READ_INT, ®s); } void ATAPI_granular_read(uint32_t nblocks, uint32_t lba, uint8_t *output) { - for (uint32_t i = 0; i < nblocks; i++) { - ATAPI_read(1, lba + i); - for (uint16_t j = 0; j < ATAPI_SECTOR_SIZE; j++) - output[j + (2048 * i)] = ((uint8_t *) ATAPI_PIO_BUFFER)[j]; - } + for (uint32_t i = 0; i < nblocks; i++) { + ATAPI_read(1, lba + i); + for (uint16_t j = 0; j < ATAPI_SECTOR_SIZE; j++) + output[j + (2048 * i)] = ((uint8_t *)ATAPI_PIO_BUFFER)[j]; + } } \ No newline at end of file diff --git a/src/kernel/fs/atapi_pio.h b/src/kernel/fs/atapi_pio.h index 20bef43..b7ddee8 100644 --- a/src/kernel/fs/atapi_pio.h +++ b/src/kernel/fs/atapi_pio.h @@ -10,13 +10,13 @@ #define ATAPI_SECTOR_SIZE 2048 struct dapack { - uint8_t size; - uint8_t null; - uint16_t blk_count; - uint16_t b_offset; - uint16_t b_segment; - uint32_t start; - uint32_t upper_lba_bits; + uint8_t size; + uint8_t null; + uint16_t blk_count; + uint16_t b_offset; + uint16_t b_segment; + uint32_t start; + uint32_t upper_lba_bits; } __attribute__((packed)); void ATAPI_read(uint16_t nblocks, uint32_t lba); diff --git a/src/kernel/fs/elf.h b/src/kernel/fs/elf.h index 9be6b4d..5a412fb 100644 --- a/src/kernel/fs/elf.h +++ b/src/kernel/fs/elf.h @@ -4,48 +4,48 @@ #include typedef struct { - uint32_t sig; + uint32_t sig; } elf_priv_data; typedef struct { - unsigned char e_ident[16]; - uint16_t e_type; - uint16_t e_machine; - uint32_t e_version; - uint32_t e_entry; - uint32_t e_phoff; - uint32_t e_shoff; - uint32_t e_flags; - uint16_t e_ehsize; - uint16_t e_phentsize; - uint16_t e_phnum; - uint16_t e_shentsize; - uint16_t e_shnum; - uint16_t e_shstrndx; + unsigned char e_ident[16]; + uint16_t e_type; + uint16_t e_machine; + uint32_t e_version; + uint32_t e_entry; + uint32_t e_phoff; + uint32_t e_shoff; + uint32_t e_flags; + uint16_t e_ehsize; + uint16_t e_phentsize; + uint16_t e_phnum; + uint16_t e_shentsize; + uint16_t e_shnum; + uint16_t e_shstrndx; } elf_header_t; typedef struct { - uint32_t sh_name; - uint32_t sh_type; - uint32_t sh_flags; - uint32_t sh_addr; - uint32_t sh_offset; - uint32_t sh_size; - uint32_t sh_link; - uint32_t sh_info; - uint32_t sh_addralign; - uint32_t sh_entsize; + uint32_t sh_name; + uint32_t sh_type; + uint32_t sh_flags; + uint32_t sh_addr; + uint32_t sh_offset; + uint32_t sh_size; + uint32_t sh_link; + uint32_t sh_info; + uint32_t sh_addralign; + uint32_t sh_entsize; } elf_section_header_t; typedef struct { - uint32_t p_type; - uint32_t p_offset; - uint32_t p_vaddr; - uint32_t p_paddr; - uint32_t p_filesz; - uint32_t p_memsz; - uint32_t p_flags; - uint32_t p_align; + uint32_t p_type; + uint32_t p_offset; + uint32_t p_vaddr; + uint32_t p_paddr; + uint32_t p_filesz; + uint32_t p_memsz; + uint32_t p_flags; + uint32_t p_align; } elf_program_header_t; void elf_init(); diff --git a/src/kernel/fs/elfloader.c b/src/kernel/fs/elfloader.c index 5b81a5e..8b80553 100644 --- a/src/kernel/fs/elfloader.c +++ b/src/kernel/fs/elfloader.c @@ -7,58 +7,58 @@ elf_priv_data *elf_probe(uint8_t *buf) { - elf_header_t *header = (elf_header_t *) buf; - /* The first four bytes are 0x7f and 'ELF' */ - if (header->e_ident[0] == 0x7f && - header->e_ident[1] == 'E' && header->e_ident[2] == 'L' && header->e_ident[3] == 'F') { - /* Valid ELF! */ - serial_printf("Buffer is valid ELF file!"); - return (void *) 1; - } - return 0; + elf_header_t *header = (elf_header_t *)buf; + /* The first four bytes are 0x7f and 'ELF' */ + if (header->e_ident[0] == 0x7f && header->e_ident[1] == 'E' && header->e_ident[2] == 'L' && + header->e_ident[3] == 'F') { + /* Valid ELF! */ + serial_printf("Buffer is valid ELF file!"); + return (void *)1; + } + return 0; } uint8_t elf_start(uint8_t *buf) { - elf_header_t *header = (elf_header_t *) buf; - serial_printf("Type: %s%s%s", - header->e_ident[4] == 1 ? "32bit " : "64 bit", - header->e_ident[5] == 1 ? "Little Endian " : "Big endian ", - header->e_ident[6] == 1 ? "True ELF " : "buggy ELF "); - if (header->e_type != 2) { - serial_printf("File is not executable!"); - return 0; - } - /* Map the virtual space */ - uint32_t phys_loc = loader_get_unused_load_location(); - uint32_t cr3 = kmalloc(4096); - /* Find first program header and loop through them */ - elf_program_header_t *ph = (elf_program_header_t *) (buf + header->e_phoff); - for (int i = 0; i < header->e_phnum; i++, ph++) { - switch (ph->p_type) { - case 0: /* NULL */ - break; - case 1: /* LOAD */ - serial_printf("LOAD: offset 0x%x vaddr 0x%x paddr 0x%x filesz 0x%x memsz 0x%x", - ph->p_offset, ph->p_vaddr, ph->p_paddr, ph->p_filesz, ph->p_memsz); - paging_map(phys_loc, ph->p_vaddr, PT_PRESENT | PT_RW | PT_USED); - memcpy(ph->p_vaddr, buf + ph->p_offset, ph->p_filesz); - break; - default: /* @TODO add more */ - serial_printf("Unsupported p_type! Bail out!"); - return 0; - } - } + elf_header_t *header = (elf_header_t *)buf; + serial_printf("Type: %s%s%s", header->e_ident[4] == 1 ? "32bit " : "64 bit", + header->e_ident[5] == 1 ? "Little Endian " : "Big endian ", + header->e_ident[6] == 1 ? "True ELF " : "buggy ELF "); + if (header->e_type != 2) { + serial_printf("File is not executable!"); + return 0; + } + /* Map the virtual space */ + uint32_t phys_loc = loader_get_unused_load_location(); + uint32_t cr3 = kmalloc(4096); + /* Find first program header and loop through them */ + elf_program_header_t *ph = (elf_program_header_t *)(buf + header->e_phoff); + for (int i = 0; i < header->e_phnum; i++, ph++) { + switch (ph->p_type) { + case 0: /* NULL */ + break; + case 1: /* LOAD */ + serial_printf( + "LOAD: offset 0x%x vaddr 0x%x paddr 0x%x filesz 0x%x memsz 0x%x", + ph->p_offset, ph->p_vaddr, ph->p_paddr, ph->p_filesz, ph->p_memsz); + paging_map(phys_loc, ph->p_vaddr, PT_PRESENT | PT_RW | PT_USED); + memcpy(ph->p_vaddr, buf + ph->p_offset, ph->p_filesz); + break; + default: /* @TODO add more */ + serial_printf("Unsupported p_type! Bail out!"); + return 0; + } + } - return 0;//START("elf32", header->e_entry); + return 0; //START("elf32", header->e_entry); } void elf_init() { - loader_t *elfloader = (loader_t *) kmalloc(sizeof(loader_t)); - elfloader->name = "ELF32"; - elfloader->probe = (void *) elf_probe; - elfloader->start = (void *) elf_start; - register_loader(elfloader); - // _kill(); + loader_t *elfloader = (loader_t *)kmalloc(sizeof(loader_t)); + elfloader->name = "ELF32"; + elfloader->probe = (void *)elf_probe; + elfloader->start = (void *)elf_start; + register_loader(elfloader); + // _kill(); } \ No newline at end of file diff --git a/src/kernel/fs/install.c b/src/kernel/fs/install.c index 0c3d824..b4f5275 100644 --- a/src/kernel/fs/install.c +++ b/src/kernel/fs/install.c @@ -12,83 +12,83 @@ void install_melvix() { - info("You're booting from a CD, Melvix will only run after an installation"); - cli(); - struct ata_interface *primary_master = new_ata(1, 0x1F0); - if (marfs_init(primary_master) != 0) { - panic("No HDD found!"); - } + info("You're booting from a CD, Melvix will only run after an installation"); + cli(); + struct ata_interface *primary_master = new_ata(1, 0x1F0); + if (marfs_init(primary_master) != 0) { + panic("No HDD found!"); + } - struct marfs_superblock *currentSB = marfs_read_superblock(); - if (currentSB->signature == 0x1083B99F34B59645) { // WEEEOOOWEEEOOO - panic("Melvix seems to be already installed!"); - } - kfree(currentSB); + struct marfs_superblock *currentSB = marfs_read_superblock(); + if (currentSB->signature == 0x1083B99F34B59645) { // WEEEOOOWEEEOOO + panic("Melvix seems to be already installed!"); + } + kfree(currentSB); - info("Installing...\n"); + info("Installing...\n"); - // Copy MBR - info("Copying MBR... "); - serial_printf("Copying MBR... "); - char *stage1_p[] = {"BOOT", "HDD1.BIN"}; - struct iso9660_entity *stage1_e = ISO9660_get(stage1_p, 2); - if (!stage1_e) - panic("Couldn't find the first HDD bootloader!"); - uint8_t *stage1 = ISO9660_read(stage1_e); - kfree(stage1_e); - marfs_write_mbr(stage1); + // Copy MBR + info("Copying MBR... "); + serial_printf("Copying MBR... "); + char *stage1_p[] = { "BOOT", "HDD1.BIN" }; + struct iso9660_entity *stage1_e = ISO9660_get(stage1_p, 2); + if (!stage1_e) + panic("Couldn't find the first HDD bootloader!"); + uint8_t *stage1 = ISO9660_read(stage1_e); + kfree(stage1_e); + marfs_write_mbr(stage1); - // Format disk - info("Formatting disk..."); - serial_printf("Formatting disk..."); - marfs_format(); + // Format disk + info("Formatting disk..."); + serial_printf("Formatting disk..."); + marfs_format(); - // Copy second stage - info("Copying second stage..."); - serial_printf("Copying second stage..."); - char *stage2_p[] = {"BOOT", "HDD2.BIN"}; - struct iso9660_entity *stage2_e = ISO9660_get(stage2_p, 2); - if (!stage2_e) - panic("Couldn't find the second HDD bootloader!"); - uint8_t *stage2 = ISO9660_read(stage2_e); - marfs_new_file(stage2_e->length, stage2, 0, 0, 0); - kfree(stage2_e); + // Copy second stage + info("Copying second stage..."); + serial_printf("Copying second stage..."); + char *stage2_p[] = { "BOOT", "HDD2.BIN" }; + struct iso9660_entity *stage2_e = ISO9660_get(stage2_p, 2); + if (!stage2_e) + panic("Couldn't find the second HDD bootloader!"); + uint8_t *stage2 = ISO9660_read(stage2_e); + marfs_new_file(stage2_e->length, stage2, 0, 0, 0); + kfree(stage2_e); - // Copy the kernel - info("Copying the kernel..."); - serial_printf("Copying the kernel..."); - char *kernel_p[] = {"BOOT", "KERNEL.BIN"}; - struct iso9660_entity *kernel_e = ISO9660_get(kernel_p, 2); - if (!kernel_e) - panic("WTH Kernel not found!?"); - uint8_t *kernel = (uint8_t *) kmalloc(kernel_e->length + 2048); - ATAPI_granular_read(1 + (kernel_e->length / 2048), kernel_e->lba, kernel); - marfs_new_file(kernel_e->length, kernel, 0, 0, 0); - kfree(kernel); - kfree(kernel_e); + // Copy the kernel + info("Copying the kernel..."); + serial_printf("Copying the kernel..."); + char *kernel_p[] = { "BOOT", "KERNEL.BIN" }; + struct iso9660_entity *kernel_e = ISO9660_get(kernel_p, 2); + if (!kernel_e) + panic("WTH Kernel not found!?"); + uint8_t *kernel = (uint8_t *)kmalloc(kernel_e->length + 2048); + ATAPI_granular_read(1 + (kernel_e->length / 2048), kernel_e->lba, kernel); + marfs_new_file(kernel_e->length, kernel, 0, 0, 0); + kfree(kernel); + kfree(kernel_e); - // Copy the userspace binary - info("Copying userspace... "); - serial_printf("Copying userspace... "); - char *userspace_p[] = {"USER.BIN"}; - struct iso9660_entity *userspace_e = ISO9660_get(userspace_p, 1); - if (!userspace_e) - panic("Userspace not found!"); - uint8_t *userspace = ISO9660_read(userspace_e); - marfs_new_file(userspace_e->length, userspace, 0, 0, 0); - kfree(userspace_e); + // Copy the userspace binary + info("Copying userspace... "); + serial_printf("Copying userspace... "); + char *userspace_p[] = { "USER.BIN" }; + struct iso9660_entity *userspace_e = ISO9660_get(userspace_p, 1); + if (!userspace_e) + panic("Userspace not found!"); + uint8_t *userspace = ISO9660_read(userspace_e); + marfs_new_file(userspace_e->length, userspace, 0, 0, 0); + kfree(userspace_e); - // Copy the global font binary - info("Copying font... "); - serial_printf("Copying font... "); - char *font_p[] = {"FONT.BIN"}; - struct iso9660_entity *font_e = ISO9660_get(font_p, 1); - marfs_new_file(font_e->length, (uint8_t *) font, 0, 0, 0); - kfree(font_e); + // Copy the global font binary + info("Copying font... "); + serial_printf("Copying font... "); + char *font_p[] = { "FONT.BIN" }; + struct iso9660_entity *font_e = ISO9660_get(font_p, 1); + marfs_new_file(font_e->length, (uint8_t *)font, 0, 0, 0); + kfree(font_e); - info("Installation successful!"); - serial_printf("Installation successful! (in %d ticks)", get_time()); - // timer_wait(200); - acpi_poweroff(); - halt_loop(); + info("Installation successful!"); + serial_printf("Installation successful! (in %d ticks)", get_time()); + // timer_wait(200); + acpi_poweroff(); + halt_loop(); } diff --git a/src/kernel/fs/iso9660/iso9660.c b/src/kernel/fs/iso9660/iso9660.c index 81ef18a..ab00c31 100644 --- a/src/kernel/fs/iso9660/iso9660.c +++ b/src/kernel/fs/iso9660/iso9660.c @@ -6,57 +6,54 @@ struct iso9660_entity *ISO9660_get(char **dirs, uint8_t dirs_sz) { - ATAPI_read(1, 0x10); - uint32_t last_len = *(uint32_t *) ( - ATAPI_PIO_BUFFER + - ISO9660_ROOT_RECORD_OFFSET + - ISO9660_DIR_EAR_LENGTH - ); - uint32_t last_lba = *(uint32_t *) ( - ATAPI_PIO_BUFFER + - ISO9660_ROOT_RECORD_OFFSET + - ISO9660_DIR_EAR_LBA - ); - - for (uint8_t dirs_i = 0; dirs_i < dirs_sz; dirs_i++) { - ATAPI_read((last_len % 2048 != 0) + (last_len / 2048), last_lba); - - uint8_t found = 0; - for (uint32_t i = 0; i < last_len && !found;) { - if (!*(uint8_t *) (ATAPI_PIO_BUFFER + i + ISO9660_DIR_RECORD_LENGTH)) - break; - - char *filename = (char *) (ATAPI_PIO_BUFFER + i + ISO9660_DIR_FILENAME); - - for (uint32_t j = 0; j < ISO9660_DIR_FILENAME_LENGTH; j++) { - if (filename[j] == ';') { - filename[j] = 0; - break; - } - } - - if (strcmp(dirs[dirs_i], filename) == 0) { - found = 1; - last_lba = *(uint32_t *) (ATAPI_PIO_BUFFER + i + ISO9660_DIR_EAR_LBA); - last_len = *(uint32_t *) (ATAPI_PIO_BUFFER + i + ISO9660_DIR_EAR_LENGTH); - } else { - i += *(uint8_t *) (ATAPI_PIO_BUFFER + i + ISO9660_DIR_RECORD_LENGTH); - } - } - - if (!found) { - return (struct iso9660_entity *) 0; - } - } - - struct iso9660_entity *ret = (struct iso9660_entity *) kmalloc(sizeof(struct iso9660_entity)); - ret->lba = last_lba; - ret->length = last_len; - return ret; + ATAPI_read(1, 0x10); + uint32_t last_len = *(uint32_t *)(ATAPI_PIO_BUFFER + ISO9660_ROOT_RECORD_OFFSET + + ISO9660_DIR_EAR_LENGTH); + uint32_t last_lba = + *(uint32_t *)(ATAPI_PIO_BUFFER + ISO9660_ROOT_RECORD_OFFSET + ISO9660_DIR_EAR_LBA); + + for (uint8_t dirs_i = 0; dirs_i < dirs_sz; dirs_i++) { + ATAPI_read((last_len % 2048 != 0) + (last_len / 2048), last_lba); + + uint8_t found = 0; + for (uint32_t i = 0; i < last_len && !found;) { + if (!*(uint8_t *)(ATAPI_PIO_BUFFER + i + ISO9660_DIR_RECORD_LENGTH)) + break; + + char *filename = (char *)(ATAPI_PIO_BUFFER + i + ISO9660_DIR_FILENAME); + + for (uint32_t j = 0; j < ISO9660_DIR_FILENAME_LENGTH; j++) { + if (filename[j] == ';') { + filename[j] = 0; + break; + } + } + + if (strcmp(dirs[dirs_i], filename) == 0) { + found = 1; + last_lba = + *(uint32_t *)(ATAPI_PIO_BUFFER + i + ISO9660_DIR_EAR_LBA); + last_len = *(uint32_t *)(ATAPI_PIO_BUFFER + i + + ISO9660_DIR_EAR_LENGTH); + } else { + i += *(uint8_t *)(ATAPI_PIO_BUFFER + i + ISO9660_DIR_RECORD_LENGTH); + } + } + + if (!found) { + return (struct iso9660_entity *)0; + } + } + + struct iso9660_entity *ret = + (struct iso9660_entity *)kmalloc(sizeof(struct iso9660_entity)); + ret->lba = last_lba; + ret->length = last_len; + return ret; } uint8_t *ISO9660_read(struct iso9660_entity *entity) { - ATAPI_read((entity->length % 2048 != 0) + (entity->length / 2048), entity->lba); - return (uint8_t *) ATAPI_PIO_BUFFER; + ATAPI_read((entity->length % 2048 != 0) + (entity->length / 2048), entity->lba); + return (uint8_t *)ATAPI_PIO_BUFFER; } \ No newline at end of file diff --git a/src/kernel/fs/iso9660/iso9660.h b/src/kernel/fs/iso9660/iso9660.h index 86629e4..9ba9cfa 100644 --- a/src/kernel/fs/iso9660/iso9660.h +++ b/src/kernel/fs/iso9660/iso9660.h @@ -11,8 +11,8 @@ #include struct iso9660_entity { - uint32_t lba; - uint32_t length; + uint32_t lba; + uint32_t length; }; struct iso9660_entity *ISO9660_get(char **dirs, uint8_t dirs_sz); diff --git a/src/kernel/fs/load.c b/src/kernel/fs/load.c index 5a476b5..7227f9b 100644 --- a/src/kernel/fs/load.c +++ b/src/kernel/fs/load.c @@ -10,29 +10,32 @@ void load_binaries() { - userspace = (uint32_t) kmalloc(10000); - font = (struct font *) kmalloc(100000);; // High quality shit + userspace = (uint32_t)kmalloc(10000); + font = (struct font *)kmalloc(100000); + ; // High quality shit - uint8_t boot_drive_id = (uint8_t) (*((uint8_t *) 0x9000)); - if (boot_drive_id != 0xE0) { - struct ata_interface *primary_master = new_ata(1, 0x1F0); - marfs_init(primary_master); - marfs_read_whole_file(4, (uint8_t *) userspace); - marfs_read_whole_file(5, (uint8_t *) font); - } else { - char *font_p[] = {"FONT.BIN"}; - struct iso9660_entity *font_e = ISO9660_get(font_p, 1); - if (!font_e) panic("Font not found!"); - ATAPI_granular_read(1 + (font_e->length / 2048), font_e->lba, (uint8_t *) font); - kfree(font_e); + uint8_t boot_drive_id = (uint8_t)(*((uint8_t *)0x9000)); + if (boot_drive_id != 0xE0) { + struct ata_interface *primary_master = new_ata(1, 0x1F0); + marfs_init(primary_master); + marfs_read_whole_file(4, (uint8_t *)userspace); + marfs_read_whole_file(5, (uint8_t *)font); + } else { + char *font_p[] = { "FONT.BIN" }; + struct iso9660_entity *font_e = ISO9660_get(font_p, 1); + if (!font_e) + panic("Font not found!"); + ATAPI_granular_read(1 + (font_e->length / 2048), font_e->lba, (uint8_t *)font); + kfree(font_e); - char *user_p[] = {"USER.BIN"}; - struct iso9660_entity *user_e = ISO9660_get(user_p, 1); - if (!user_e) panic("Userspace binary not found!"); - ATAPI_granular_read(1 + (user_e->length / 2048), user_e->lba, (uint8_t *) userspace); - kfree(user_e); - } - vga_log("Successfully loaded binaries"); + char *user_p[] = { "USER.BIN" }; + struct iso9660_entity *user_e = ISO9660_get(user_p, 1); + if (!user_e) + panic("Userspace binary not found!"); + ATAPI_granular_read(1 + (user_e->length / 2048), user_e->lba, (uint8_t *)userspace); + kfree(user_e); + } + vga_log("Successfully loaded binaries"); } #define MAX_LOADERS 16 @@ -44,35 +47,38 @@ uint32_t last_load_loc = 0x400000; void loader_init() { - serial_printf("Setting up loader"); - loaders = (loader_t **) kmalloc(MAX_LOADERS * sizeof(uint32_t)); - memset(loaders, 0, MAX_LOADERS * sizeof(uint32_t)); - // _kill(); + serial_printf("Setting up loader"); + loaders = (loader_t **)kmalloc(MAX_LOADERS * sizeof(uint32_t)); + memset(loaders, 0, MAX_LOADERS * sizeof(uint32_t)); + // _kill(); } void register_loader(loader_t *load) { - if (last_loader + 1 > MAX_LOADERS) return; - if (!load) return; - loaders[last_loader] = load; - last_loader++; - serial_printf("Registered %s loader as id %d", load->name, last_loader - 1); + if (last_loader + 1 > MAX_LOADERS) + return; + if (!load) + return; + loaders[last_loader] = load; + last_loader++; + serial_printf("Registered %s loader as id %d", load->name, last_loader - 1); } uint32_t loader_get_unused_load_location() { - last_load_loc += 0x400000; - return last_load_loc; + last_load_loc += 0x400000; + return last_load_loc; } uint8_t exec_start(uint8_t *buf) { - for (int i = 0; i < MAX_LOADERS; i++) { - if (!loaders[i]) break; - void *priv = loaders[i]->probe(buf); - if (priv) { - return loaders[i]->start(buf, priv); - } - } - return 0; + for (int i = 0; i < MAX_LOADERS; i++) { + if (!loaders[i]) + break; + void *priv = loaders[i]->probe(buf); + if (priv) { + return loaders[i]->start(buf, priv); + } + } + return 0; } \ No newline at end of file diff --git a/src/kernel/fs/load.h b/src/kernel/fs/load.h index 4ba545f..468501c 100644 --- a/src/kernel/fs/load.h +++ b/src/kernel/fs/load.h @@ -8,20 +8,20 @@ uint32_t userspace; struct font *font; struct font { - uint16_t font_32[758][32]; - uint16_t font_24[758][24]; - uint8_t font_16[758][16]; - uint16_t cursor[19]; + uint16_t font_32[758][32]; + uint16_t font_24[758][24]; + uint8_t font_16[758][16]; + uint16_t cursor[19]; }; void load_binaries(); typedef struct { - char *name; + char *name; - void *(*probe)(uint8_t *buf); + void *(*probe)(uint8_t *buf); - uint8_t (*start)(uint8_t *buf, void *priv); + uint8_t (*start)(uint8_t *buf, void *priv); } loader_t; void loader_init(); diff --git a/src/kernel/fs/marfs/directory.c b/src/kernel/fs/marfs/directory.c index fd8ecd6..f4a5b04 100644 --- a/src/kernel/fs/marfs/directory.c +++ b/src/kernel/fs/marfs/directory.c @@ -6,54 +6,58 @@ uint32_t marfs_new_dir(uint32_t uid) { - return marfs_new_file(0, 0, uid, 0, 1); + return marfs_new_file(0, 0, uid, 0, 1); } - void marfs_add_to_dir(uint32_t lba_inode, char *filename, uint32_t lba) { - struct marfs_inode *inode = (struct marfs_inode *) ata_read28(interface, lba_inode); - - // Read the content - uint8_t *old = marfs_allocate_and_read_whole_file(lba_inode); - - // Allocate memory - uint8_t *contents = (uint8_t *) kmalloc((uint32_t) (inode->size + strlen(filename) + 1 + 4)); - - // Copy the content - uint8_t last_was_null = 0; - uint64_t new_size = 0; - for (uint64_t i = 0; i < inode->size; i++) { - if (old[i] == 0 && last_was_null) continue; - - contents[new_size++] = old[i]; - last_was_null = (uint8_t) (old[i] == 0); - } - kfree(old); - - // Append new file - for (size_t i = 0; i <= strlen(filename); i++) contents[new_size++] = (uint8_t) filename[i]; - for (signed char j = 24; j > 0; j -= 8) contents[new_size++] = (uint8_t) ((lba >> j) & 0xFF); - - // Free the blocks - uint32_t new_size_in_blocks = (uint32_t) (new_size / 512); - if (new_size % 512) new_size_in_blocks++; - for (uint32_t i = 0; i < new_size_in_blocks; i++) - marfs_mark_block_as_free(marfs_get_block(inode, i)); - - // Overwrite - uint32_t aux_inode = marfs_new_file(new_size, contents, 0xDEADBEEF, 0, 0); - struct marfs_inode *real_aux_inode = (struct marfs_inode *) ata_read28(interface, aux_inode); - for (uint8_t i = 0; i < 10; i++) inode->DBPs[i] = real_aux_inode->DBPs[i]; - inode->ext_1 = real_aux_inode->ext_1; - inode->ext_2 = real_aux_inode->ext_2; - inode->ext_3 = real_aux_inode->ext_3; - inode->ext_4 = real_aux_inode->ext_4; - real_aux_inode->is_used = 0; - ata_write28(interface, aux_inode, (uint8_t *) real_aux_inode); - kfree(real_aux_inode); - - inode->size = new_size; - ata_write28(interface, lba_inode, (uint8_t *) inode); - kfree(inode); + struct marfs_inode *inode = (struct marfs_inode *)ata_read28(interface, lba_inode); + + // Read the content + uint8_t *old = marfs_allocate_and_read_whole_file(lba_inode); + + // Allocate memory + uint8_t *contents = (uint8_t *)kmalloc((uint32_t)(inode->size + strlen(filename) + 1 + 4)); + + // Copy the content + uint8_t last_was_null = 0; + uint64_t new_size = 0; + for (uint64_t i = 0; i < inode->size; i++) { + if (old[i] == 0 && last_was_null) + continue; + + contents[new_size++] = old[i]; + last_was_null = (uint8_t)(old[i] == 0); + } + kfree(old); + + // Append new file + for (size_t i = 0; i <= strlen(filename); i++) + contents[new_size++] = (uint8_t)filename[i]; + for (signed char j = 24; j > 0; j -= 8) + contents[new_size++] = (uint8_t)((lba >> j) & 0xFF); + + // Free the blocks + uint32_t new_size_in_blocks = (uint32_t)(new_size / 512); + if (new_size % 512) + new_size_in_blocks++; + for (uint32_t i = 0; i < new_size_in_blocks; i++) + marfs_mark_block_as_free(marfs_get_block(inode, i)); + + // Overwrite + uint32_t aux_inode = marfs_new_file(new_size, contents, 0xDEADBEEF, 0, 0); + struct marfs_inode *real_aux_inode = (struct marfs_inode *)ata_read28(interface, aux_inode); + for (uint8_t i = 0; i < 10; i++) + inode->DBPs[i] = real_aux_inode->DBPs[i]; + inode->ext_1 = real_aux_inode->ext_1; + inode->ext_2 = real_aux_inode->ext_2; + inode->ext_3 = real_aux_inode->ext_3; + inode->ext_4 = real_aux_inode->ext_4; + real_aux_inode->is_used = 0; + ata_write28(interface, aux_inode, (uint8_t *)real_aux_inode); + kfree(real_aux_inode); + + inode->size = new_size; + ata_write28(interface, lba_inode, (uint8_t *)inode); + kfree(inode); } diff --git a/src/kernel/fs/marfs/disklevel.c b/src/kernel/fs/marfs/disklevel.c index 106540e..f814f80 100644 --- a/src/kernel/fs/marfs/disklevel.c +++ b/src/kernel/fs/marfs/disklevel.c @@ -4,21 +4,23 @@ void marfs_format(void) { - // Create superblock - struct marfs_superblock sb; - sb.signature = 0x1083B99F34B59645; // Huh, magic?! - sb.n_inodes = (marfs_get_max_lba() - 2) >> 5; - sb.n_chunks = (marfs_get_max_lba() - (2 + sb.n_inodes)) >> 9; - sb.n_first_unallocated_inode = 0; - sb.s_first_inode = 2; - sb.s_first_chunk = 2 + sb.n_inodes; + // Create superblock + struct marfs_superblock sb; + sb.signature = 0x1083B99F34B59645; // Huh, magic?! + sb.n_inodes = (marfs_get_max_lba() - 2) >> 5; + sb.n_chunks = (marfs_get_max_lba() - (2 + sb.n_inodes)) >> 9; + sb.n_first_unallocated_inode = 0; + sb.s_first_inode = 2; + sb.s_first_chunk = 2 + sb.n_inodes; - // Write to disk - marfs_write_superblock(&sb); + // Write to disk + marfs_write_superblock(&sb); - // Initialize the inodes - for (uint32_t i = 0; i < sb.n_inodes; i++) ata_clear28(interface, 2 + i); + // Initialize the inodes + for (uint32_t i = 0; i < sb.n_inodes; i++) + ata_clear28(interface, 2 + i); - // Initialize the chunks - for (uint32_t i = 0; i < sb.n_chunks; i++) ata_clear28(interface, sb.s_first_chunk + i * 512); + // Initialize the chunks + for (uint32_t i = 0; i < sb.n_chunks; i++) + ata_clear28(interface, sb.s_first_chunk + i * 512); } diff --git a/src/kernel/fs/marfs/marfs.h b/src/kernel/fs/marfs/marfs.h index 67b693c..f2dfa1c 100644 --- a/src/kernel/fs/marfs/marfs.h +++ b/src/kernel/fs/marfs/marfs.h @@ -4,29 +4,29 @@ #include struct marfs_superblock { - uint64_t signature; - uint32_t n_inodes; - uint32_t n_chunks; - uint32_t n_first_unallocated_inode; - uint32_t s_first_inode; - uint32_t s_first_chunk; + uint64_t signature; + uint32_t n_inodes; + uint32_t n_chunks; + uint32_t n_first_unallocated_inode; + uint32_t s_first_inode; + uint32_t s_first_chunk; } __attribute__((packed)); struct marfs_inode { - uint64_t size; - uint32_t creation_time; - uint32_t last_mod_time; - uint32_t last_access_time; - uint32_t n_blocks; - uint32_t DBPs[10]; - uint32_t ext_1; - uint32_t ext_2; - uint32_t ext_3; - uint32_t ext_4; - uint32_t uid; - uint8_t is_app; - uint8_t is_dir; - uint8_t is_used; + uint64_t size; + uint32_t creation_time; + uint32_t last_mod_time; + uint32_t last_access_time; + uint32_t n_blocks; + uint32_t DBPs[10]; + uint32_t ext_1; + uint32_t ext_2; + uint32_t ext_3; + uint32_t ext_4; + uint32_t uid; + uint8_t is_app; + uint8_t is_dir; + uint8_t is_used; } __attribute__((packed)); struct ata_interface *interface; diff --git a/src/kernel/fs/marfs/new_file.c b/src/kernel/fs/marfs/new_file.c index 8f85ffa..d278ad2 100644 --- a/src/kernel/fs/marfs/new_file.c +++ b/src/kernel/fs/marfs/new_file.c @@ -7,98 +7,105 @@ static uint8_t last_max_level = 0; void marfs_update_recursive(uint8_t level, uint32_t i, uint32_t rec_lba, uint32_t real_lba) { - if (level > last_max_level) last_max_level = level; - uint32_t *contents = (uint32_t *) ata_read28(interface, rec_lba); + if (level > last_max_level) + last_max_level = level; + uint32_t *contents = (uint32_t *)ata_read28(interface, rec_lba); - uint32_t idx = i - 10; - if (last_max_level > 1) idx -= 1 << 7; - if (last_max_level > 2) idx -= 1 << (7 * 2); - if (last_max_level > 3) idx -= 1 << (7 * 3); - idx >>= 7 * (level - 1); + uint32_t idx = i - 10; + if (last_max_level > 1) + idx -= 1 << 7; + if (last_max_level > 2) + idx -= 1 << (7 * 2); + if (last_max_level > 3) + idx -= 1 << (7 * 3); + idx >>= 7 * (level - 1); - if (level > 1) { - if (!contents[idx]) { - contents[idx] = marfs_get_free_lba_block(); - marfs_mark_block_as_used(contents[idx]); - } - } else { - contents[idx] = real_lba; - } + if (level > 1) { + if (!contents[idx]) { + contents[idx] = marfs_get_free_lba_block(); + marfs_mark_block_as_used(contents[idx]); + } + } else { + contents[idx] = real_lba; + } - ata_write28(interface, rec_lba, (uint8_t *) contents); + ata_write28(interface, rec_lba, (uint8_t *)contents); - uint32_t contents_idx = contents[idx]; - kfree(contents); - if (level != 1) { - marfs_update_recursive((uint8_t) (level - 1), i, contents_idx, real_lba); - } - last_max_level = 0; + uint32_t contents_idx = contents[idx]; + kfree(contents); + if (level != 1) { + marfs_update_recursive((uint8_t)(level - 1), i, contents_idx, real_lba); + } + last_max_level = 0; } uint32_t marfs_new_file(uint64_t size, uint8_t *data, uint32_t uid, uint8_t exec, uint8_t dir) { - struct marfs_inode *inode = (struct marfs_inode *) kmalloc(512); - inode->size = size; - inode->creation_time = inode->last_mod_time = inode->last_access_time = 0; // TODO: POSIX time - inode->n_blocks = (uint32_t) (size / 512); - if (size % 512) inode->n_blocks++; - inode->uid = uid; - inode->is_app = exec; - inode->is_dir = dir; - inode->is_used = 1; + struct marfs_inode *inode = (struct marfs_inode *)kmalloc(512); + inode->size = size; + inode->creation_time = inode->last_mod_time = inode->last_access_time = + 0; // TODO: POSIX time + inode->n_blocks = (uint32_t)(size / 512); + if (size % 512) + inode->n_blocks++; + inode->uid = uid; + inode->is_app = exec; + inode->is_dir = dir; + inode->is_used = 1; - uint32_t size_in_blocks = inode->n_blocks; + uint32_t size_in_blocks = inode->n_blocks; - uint32_t lba_singly, lba_doubly, lba_triply, lba_quadruply; - lba_singly = lba_doubly = lba_triply = lba_quadruply = 0; - for (uint32_t i = 0; i < size_in_blocks; i++) { - uint32_t this_block = marfs_get_free_lba_block(); - if (i != size_in_blocks - 1) { - ata_write28(interface, this_block, data); - } else if (size % 512) { - uint8_t contents[512] = {0}; - for (uint16_t i = 0; i < size % 512; i++) contents[i] = data[i]; - ata_write28(interface, this_block, contents); - } - data += 512; - marfs_mark_block_as_used(this_block); + uint32_t lba_singly, lba_doubly, lba_triply, lba_quadruply; + lba_singly = lba_doubly = lba_triply = lba_quadruply = 0; + for (uint32_t i = 0; i < size_in_blocks; i++) { + uint32_t this_block = marfs_get_free_lba_block(); + if (i != size_in_blocks - 1) { + ata_write28(interface, this_block, data); + } else if (size % 512) { + uint8_t contents[512] = { 0 }; + for (uint16_t i = 0; i < size % 512; i++) + contents[i] = data[i]; + ata_write28(interface, this_block, contents); + } + data += 512; + marfs_mark_block_as_used(this_block); - if (i > 9 + (128 * 128 * 128)) { - if (!lba_quadruply) { - lba_quadruply = marfs_get_free_lba_block(); - marfs_mark_block_as_used(lba_quadruply); - inode->ext_4 = lba_quadruply; - } - marfs_update_recursive(4, i, lba_quadruply, this_block); - } else if (i > 9 + (128 * 128)) { - if (!lba_triply) { - lba_triply = marfs_get_free_lba_block(); - marfs_mark_block_as_used(lba_triply); - inode->ext_3 = lba_triply; - } - marfs_update_recursive(3, i, lba_triply, this_block); - } else if (i > 9 + 128) { - if (!lba_doubly) { - lba_doubly = marfs_get_free_lba_block(); - marfs_mark_block_as_used(lba_doubly); - inode->ext_2 = lba_doubly; - } - marfs_update_recursive(2, i, lba_doubly, this_block); - } else if (i > 9) { - if (!lba_singly) { - lba_singly = marfs_get_free_lba_block(); - marfs_mark_block_as_used(lba_singly); - inode->ext_1 = lba_singly; - } - marfs_update_recursive(1, i, lba_singly, this_block); - } else { - inode->DBPs[i] = this_block; - } - } + if (i > 9 + (128 * 128 * 128)) { + if (!lba_quadruply) { + lba_quadruply = marfs_get_free_lba_block(); + marfs_mark_block_as_used(lba_quadruply); + inode->ext_4 = lba_quadruply; + } + marfs_update_recursive(4, i, lba_quadruply, this_block); + } else if (i > 9 + (128 * 128)) { + if (!lba_triply) { + lba_triply = marfs_get_free_lba_block(); + marfs_mark_block_as_used(lba_triply); + inode->ext_3 = lba_triply; + } + marfs_update_recursive(3, i, lba_triply, this_block); + } else if (i > 9 + 128) { + if (!lba_doubly) { + lba_doubly = marfs_get_free_lba_block(); + marfs_mark_block_as_used(lba_doubly); + inode->ext_2 = lba_doubly; + } + marfs_update_recursive(2, i, lba_doubly, this_block); + } else if (i > 9) { + if (!lba_singly) { + lba_singly = marfs_get_free_lba_block(); + marfs_mark_block_as_used(lba_singly); + inode->ext_1 = lba_singly; + } + marfs_update_recursive(1, i, lba_singly, this_block); + } else { + inode->DBPs[i] = this_block; + } + } - // Write the inode - uint32_t inode_lba = marfs_get_free_lba_inode(); - ata_write28(interface, inode_lba, (uint8_t *) inode); + // Write the inode + uint32_t inode_lba = marfs_get_free_lba_inode(); + ata_write28(interface, inode_lba, (uint8_t *)inode); - return inode_lba; + return inode_lba; } \ No newline at end of file diff --git a/src/kernel/fs/marfs/read_whole_file.c b/src/kernel/fs/marfs/read_whole_file.c index f530441..eb49dfe 100644 --- a/src/kernel/fs/marfs/read_whole_file.c +++ b/src/kernel/fs/marfs/read_whole_file.c @@ -7,63 +7,71 @@ static uint8_t last_max_level = 0; uint32_t marfs_get_recursive(uint8_t level, uint32_t i, uint32_t rec_lba) { - if (level > last_max_level) last_max_level = level; - uint32_t *contents = (uint32_t *) ata_read28(interface, rec_lba); - uint32_t idx = i - 10; - if (last_max_level > 1) idx -= 1 << 7; - if (last_max_level > 2) idx -= 1 << (7 * 2); - if (last_max_level > 3) idx -= 1 << (7 * 3); - idx >>= 7 * (level - 1); + if (level > last_max_level) + last_max_level = level; + uint32_t *contents = (uint32_t *)ata_read28(interface, rec_lba); + uint32_t idx = i - 10; + if (last_max_level > 1) + idx -= 1 << 7; + if (last_max_level > 2) + idx -= 1 << (7 * 2); + if (last_max_level > 3) + idx -= 1 << (7 * 3); + idx >>= 7 * (level - 1); - uint32_t next_rec_lba = contents[idx]; - kfree(contents); + uint32_t next_rec_lba = contents[idx]; + kfree(contents); - uint32_t toRet; - if (level > 1) toRet = marfs_get_recursive((uint8_t) (level - 1), i, next_rec_lba); - else toRet = next_rec_lba; - last_max_level = 0; - return toRet; + uint32_t toRet; + if (level > 1) + toRet = marfs_get_recursive((uint8_t)(level - 1), i, next_rec_lba); + else + toRet = next_rec_lba; + last_max_level = 0; + return toRet; } uint32_t marfs_get_block(struct marfs_inode *inode, uint32_t i) { - if (i > 9 + (128 * 128 * 128)) { - return marfs_get_recursive(4, i, inode->ext_4); - } else if (i > 9 + (128 * 128)) { - return marfs_get_recursive(3, i, inode->ext_3); - } else if (i > 9 + 128) { - return marfs_get_recursive(2, i, inode->ext_2); - } else if (i > 9) { - return marfs_get_recursive(1, i, inode->ext_1); - } else { - return inode->DBPs[i]; - } + if (i > 9 + (128 * 128 * 128)) { + return marfs_get_recursive(4, i, inode->ext_4); + } else if (i > 9 + (128 * 128)) { + return marfs_get_recursive(3, i, inode->ext_3); + } else if (i > 9 + 128) { + return marfs_get_recursive(2, i, inode->ext_2); + } else if (i > 9) { + return marfs_get_recursive(1, i, inode->ext_1); + } else { + return inode->DBPs[i]; + } } void marfs_read_whole_file(uint32_t lba_inode, uint8_t *buffer) { - struct marfs_inode *inode = (struct marfs_inode *) ata_read28(interface, lba_inode); + struct marfs_inode *inode = (struct marfs_inode *)ata_read28(interface, lba_inode); - uint32_t size_in_blocks = inode->n_blocks; - for (uint32_t i = 0; i < size_in_blocks; i++) { - uint32_t this_block = marfs_get_block(inode, i); - uint8_t *this_block_contents = ata_read28(interface, this_block); - uint16_t upper_bound = (uint16_t) ((i != size_in_blocks - 1) ? 512 : (inode->size % 512)); - for (uint16_t j = 0; j < upper_bound; j++) buffer[(i * 512) + j] = this_block_contents[j]; - kfree(this_block_contents); - } + uint32_t size_in_blocks = inode->n_blocks; + for (uint32_t i = 0; i < size_in_blocks; i++) { + uint32_t this_block = marfs_get_block(inode, i); + uint8_t *this_block_contents = ata_read28(interface, this_block); + uint16_t upper_bound = + (uint16_t)((i != size_in_blocks - 1) ? 512 : (inode->size % 512)); + for (uint16_t j = 0; j < upper_bound; j++) + buffer[(i * 512) + j] = this_block_contents[j]; + kfree(this_block_contents); + } - kfree(inode); + kfree(inode); } // TODO: Beautify uint8_t *marfs_allocate_and_read_whole_file(uint32_t lba_inode) { - struct marfs_inode *inode = (struct marfs_inode *) ata_read28(interface, lba_inode); - uint64_t size = inode->size; - kfree(inode); + struct marfs_inode *inode = (struct marfs_inode *)ata_read28(interface, lba_inode); + uint64_t size = inode->size; + kfree(inode); - uint8_t *buffer = (uint8_t *) kmalloc((uint32_t) size); - marfs_read_whole_file(lba_inode, buffer); - return buffer; + uint8_t *buffer = (uint8_t *)kmalloc((uint32_t)size); + marfs_read_whole_file(lba_inode, buffer); + return buffer; } \ No newline at end of file diff --git a/src/kernel/fs/marfs/sectorlevel.c b/src/kernel/fs/marfs/sectorlevel.c index 96a24ba..e84e1f2 100644 --- a/src/kernel/fs/marfs/sectorlevel.c +++ b/src/kernel/fs/marfs/sectorlevel.c @@ -5,114 +5,117 @@ uint8_t marfs_init(struct ata_interface *_interface) { - interface = _interface; - uint16_t identify_data[256 * 2]; - uint8_t ret = ata_identify(interface, identify_data); - max_lba = (identify_data[61] << 16) + identify_data[60]; - return ret; + interface = _interface; + uint16_t identify_data[256 * 2]; + uint8_t ret = ata_identify(interface, identify_data); + max_lba = (identify_data[61] << 16) + identify_data[60]; + return ret; } uint32_t marfs_get_max_lba(void) { - return max_lba; + return max_lba; } uint8_t marfs_write_mbr(uint8_t *mbr) { - return ata_write28(interface, 0, mbr); + return ata_write28(interface, 0, mbr); } struct marfs_superblock *marfs_read_superblock() { - struct marfs_superblock *p = (struct marfs_superblock *) ata_read28(interface, 1); - sb_cache = *p; - return p; + struct marfs_superblock *p = (struct marfs_superblock *)ata_read28(interface, 1); + sb_cache = *p; + return p; } uint8_t marfs_write_superblock(struct marfs_superblock *sb) { - sb_cache = *sb; - return ata_write28(interface, 1, (uint8_t *) sb); + sb_cache = *sb; + return ata_write28(interface, 1, (uint8_t *)sb); } uint32_t marfs_get_free_lba_block(void) { - uint32_t offset = 2 + sb_cache.s_first_chunk; - uint8_t *p = 0; - for (uint32_t i = 0; i < sb_cache.n_chunks; i++) { - p = ata_read28(interface, offset); - if (!(*p & 0x80)) break; - kfree(p); - offset += 512; - } - - offset++; - for (uint16_t i = 1; i < 512; i++) { - if (!p[i]) break; - offset++; - } - kfree(p); - - ata_clear28(interface, offset); - - return offset; + uint32_t offset = 2 + sb_cache.s_first_chunk; + uint8_t *p = 0; + for (uint32_t i = 0; i < sb_cache.n_chunks; i++) { + p = ata_read28(interface, offset); + if (!(*p & 0x80)) + break; + kfree(p); + offset += 512; + } + + offset++; + for (uint16_t i = 1; i < 512; i++) { + if (!p[i]) + break; + offset++; + } + kfree(p); + + ata_clear28(interface, offset); + + return offset; } static uint8_t marfs_mark_block(uint32_t lba_sector, uint8_t mode) { - lba_sector -= 2; - lba_sector -= sb_cache.s_first_chunk; - uint16_t block_in_chunk = (uint16_t) (lba_sector % 512); - lba_sector /= 512; - lba_sector = 2 + sb_cache.s_first_chunk + (512 * lba_sector); - - uint8_t *p = ata_read28(interface, lba_sector); - p[block_in_chunk] = mode; - - if (mode == 0) { - p[0] = 0; - } else { - uint8_t full_chunk = 1; - for (uint16_t i = 1; i < 512; i++) { - if (!p[i]) { - full_chunk = 0; - break; - } - } - p[0] = full_chunk; - } - - uint8_t ret = ata_write28(interface, lba_sector, p); - kfree(p); - return ret; + lba_sector -= 2; + lba_sector -= sb_cache.s_first_chunk; + uint16_t block_in_chunk = (uint16_t)(lba_sector % 512); + lba_sector /= 512; + lba_sector = 2 + sb_cache.s_first_chunk + (512 * lba_sector); + + uint8_t *p = ata_read28(interface, lba_sector); + p[block_in_chunk] = mode; + + if (mode == 0) { + p[0] = 0; + } else { + uint8_t full_chunk = 1; + for (uint16_t i = 1; i < 512; i++) { + if (!p[i]) { + full_chunk = 0; + break; + } + } + p[0] = full_chunk; + } + + uint8_t ret = ata_write28(interface, lba_sector, p); + kfree(p); + return ret; } uint8_t marfs_mark_block_as_free(uint32_t lba_sector) { - return marfs_mark_block(lba_sector, 0); + return marfs_mark_block(lba_sector, 0); } uint8_t marfs_mark_block_as_used(uint32_t lba_sector) { - return marfs_mark_block(lba_sector, 1); + return marfs_mark_block(lba_sector, 1); } uint32_t marfs_get_free_lba_inode(void) { - uint32_t offset; - for (offset = 2; offset < 2 + sb_cache.n_inodes; offset++) { - struct marfs_inode *inode = (struct marfs_inode *) ata_read28(interface, offset); - uint8_t used = inode->is_used; - kfree(inode); - if (!used) break; - } - return offset; + uint32_t offset; + for (offset = 2; offset < 2 + sb_cache.n_inodes; offset++) { + struct marfs_inode *inode = (struct marfs_inode *)ata_read28(interface, offset); + uint8_t used = inode->is_used; + kfree(inode); + if (!used) + break; + } + return offset; } void marfs_mark_inode_as_free(uint32_t lba_sector) { - struct marfs_inode *inode = (struct marfs_inode *) ata_read28(interface, lba_sector); - inode->is_used = 0; - ata_write28(interface, lba_sector, (uint8_t *) inode); - kfree(inode); + struct marfs_inode *inode = (struct marfs_inode *)ata_read28(interface, lba_sector); + inode->is_used = 0; + ata_write28(interface, lba_sector, (uint8_t *)inode); + kfree(inode); } \ No newline at end of file diff --git a/src/kernel/fs/vfs.c b/src/kernel/fs/vfs.c index 702851e..9aeadf0 100644 --- a/src/kernel/fs/vfs.c +++ b/src/kernel/fs/vfs.c @@ -4,46 +4,44 @@ fs_node_t *fs_root = 0; uint32_t read_fs(fs_node_t *node, uint32_t offset, uint32_t size, uint8_t *buffer) { - if (node->read != 0) - return node->read(node, offset, size, buffer); - else - return 0; + if (node->read != 0) + return node->read(node, offset, size, buffer); + else + return 0; } uint32_t write_fs(fs_node_t *node, uint32_t offset, uint32_t size, uint8_t *buffer) { - if (node->write != 0) - return node->write(node, offset, size, buffer); - else - return 0; + if (node->write != 0) + return node->write(node, offset, size, buffer); + else + return 0; } void open_fs(fs_node_t *node, uint8_t read, uint8_t write) { - if (node->open != 0) - return node->open(node); + if (node->open != 0) + return node->open(node); } void close_fs(fs_node_t *node) { - if (node->close != 0) - return node->close(node); + if (node->close != 0) + return node->close(node); } struct dirent *readdir_fs(fs_node_t *node, uint32_t index) { - if ((node->flags & 0x7) == FS_DIRECTORY && - node->readdir != 0) - return node->readdir(node, index); - else - return 0; + if ((node->flags & 0x7) == FS_DIRECTORY && node->readdir != 0) + return node->readdir(node, index); + else + return 0; } fs_node_t *finddir_fs(fs_node_t *node, char *name) { - if ((node->flags & 0x7) == FS_DIRECTORY && - node->finddir != 0) - return node->finddir(node, name); - else - return 0; + if ((node->flags & 0x7) == FS_DIRECTORY && node->finddir != 0) + return node->finddir(node, name); + else + return 0; } diff --git a/src/kernel/fs/vfs.h b/src/kernel/fs/vfs.h index 5a72861..80b854a 100644 --- a/src/kernel/fs/vfs.h +++ b/src/kernel/fs/vfs.h @@ -3,13 +3,13 @@ #include -#define FS_FILE 0x01 -#define FS_DIRECTORY 0x02 -#define FS_CHARDEVICE 0x03 +#define FS_FILE 0x01 +#define FS_DIRECTORY 0x02 +#define FS_CHARDEVICE 0x03 #define FS_BLOCKDEVICE 0x04 -#define FS_PIPE 0x05 -#define FS_SYMLINK 0x06 -#define FS_MOUNTPOINT 0x08 +#define FS_PIPE 0x05 +#define FS_SYMLINK 0x06 +#define FS_MOUNTPOINT 0x08 struct fs_node; @@ -26,26 +26,26 @@ typedef struct dirent *(*readdir_type_t)(struct fs_node *, uint32_t); typedef struct fs_node *(*finddir_type_t)(struct fs_node *, char *name); typedef struct fs_node { - char name[128]; - uint32_t mask; - uint32_t uid; - uint32_t gid; - uint32_t flags; - uint32_t inode; - uint32_t length; - uint32_t impl; - read_type_t read; - write_type_t write; - open_type_t open; - close_type_t close; - readdir_type_t readdir; - finddir_type_t finddir; - struct fs_node *ptr; + char name[128]; + uint32_t mask; + uint32_t uid; + uint32_t gid; + uint32_t flags; + uint32_t inode; + uint32_t length; + uint32_t impl; + read_type_t read; + write_type_t write; + open_type_t open; + close_type_t close; + readdir_type_t readdir; + finddir_type_t finddir; + struct fs_node *ptr; } fs_node_t; struct dirent { - char name[128]; - uint32_t ino; + char name[128]; + uint32_t ino; }; extern fs_node_t *fs_root; -- cgit v1.2.3