RickRongen/my-kern
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

feat: refactor to use gcc types

Browse Source
This commit is contained in:
Rick Rongen
2021-02-12 22:16:03 +01:00
parent 555c1177a6
commit 8f615b259c
33 changed files with 419 additions and 361 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
kernel/fs/fat.c
View File

@@ -17,90 +17,90 @@
typedef struct {
struct {
u8 jump[3];
uint8_t jump[3];
char oem_identifier[8];
u16 bytes_per_sector;
u8 sectors_per_cluster;
u16 reserved_sectors;
u8 fats;
u16 directories;
u16 total_sectors;
u8 media_descriptor;
u16 sectors_per_fat;
u16 sectors_per_track;
u16 heads_sides;
u32 hidden_sectors;
u32 large_total_sectors;
uint16_t bytes_per_sector;
uint8_t sectors_per_cluster;
uint16_t reserved_sectors;
uint8_t fats;
uint16_t directories;
uint16_t total_sectors;
uint8_t media_descriptor;
uint16_t sectors_per_fat;
uint16_t sectors_per_track;
uint16_t heads_sides;
uint32_t hidden_sectors;
uint32_t large_total_sectors;
} __attribute((packed)) bpb;
union {
struct {
u8 drive_number;
u8 flags;
u8 signature;
u32 serial;
u8 label[11];
u8 system_id[8];
uint8_t drive_number;
uint8_t flags;
uint8_t signature;
uint32_t serial;
uint8_t label[11];
uint8_t system_id[8];
} __attribute((packed)) ebr_12_16;
struct {
u32 sectors_per_fat;
u16 flags;
u16 fat_version;
u32 root_directory;
u16 fs_info;
u16 backup_boot;
u8 reserved[12];
u8 drive_number;
u8 flags_nt;
u8 signature;
u32 serial;
u8 label[11];
u8 system_id[8];
uint32_t sectors_per_fat;
uint16_t flags;
uint16_t fat_version;
uint32_t root_directory;
uint16_t fs_info;
uint16_t backup_boot;
uint8_t reserved[12];
uint8_t drive_number;
uint8_t flags_nt;
uint8_t signature;
uint32_t serial;
uint8_t label[11];
uint8_t system_id[8];
} __attribute((packed)) ebr_32;
};
} __attribute((packed)) fat_bpb;
typedef struct {
u8 hours: 5;
u8 minutes: 6;
u8 seconds: 5;
uint8_t hours: 5;
uint8_t minutes: 6;
uint8_t seconds: 5;
} __attribute((packed)) time_83;
typedef struct {
u8 hours: 5;
u8 minutes: 6;
u8 seconds: 5;
uint8_t hours: 5;
uint8_t minutes: 6;
uint8_t seconds: 5;
} __attribute((packed)) date_83;
typedef struct {
union {
struct {
u8 name[11];
u8 attributes;
u8 reserved;
u8 created_seconds;
uint8_t name[11];
uint8_t attributes;
uint8_t reserved;
uint8_t created_seconds;
time_83 created_time;
date_83 created_date;
date_83 access_date;
u16 high_first_cluster;
uint16_t high_first_cluster;
time_83 last_mod_time;
date_83 last_mod_date;
u16 low_first_cluster;
u32 file_size;
uint16_t low_first_cluster;
uint32_t file_size;
} __attribute((packed)) name_83;
struct {
u8 order;
u16 text_1[5];
u8 attribute;
u8 long_entry_type;
u8 checksum;
u16 text_2[6];
u16 reserved;
u16 text_3[2];
uint8_t order;
uint16_t text_1[5];
uint8_t attribute;
uint8_t long_entry_type;
uint8_t checksum;
uint16_t text_2[6];
uint16_t reserved;
uint16_t text_3[2];
} __attribute((packed)) long_name;
};
} __attribute((packed)) fat_directory_entry;
u8 fat_check_device(const block_device *device, u8 *first_sector);
uint8_t fat_check_device(const block_device *device, uint8_t *first_sector);
block_dev_driver fat_driver = {
.name = "fat",
@@ -119,22 +119,22 @@ void print_chars(char *chars, int amount) {
}
}
u8 fat_check_device(const block_device *device, u8 *first_sector) {
uint8_t fat_check_device(const block_device *device, uint8_t *first_sector) {
fat_bpb bpb;
memcpy((u8 *) &bpb, first_sector, sizeof(fat_bpb));
memcpy((uint8_t *) &bpb, first_sector, sizeof(fat_bpb));
printf("OEM: ");
print_chars(bpb.bpb.oem_identifier, 11);
printf("\n");
u32 total_sectors = bpb.bpb.total_sectors == 0 ? bpb.bpb.large_total_sectors : bpb.bpb.total_sectors;
u32 fat_size = bpb.bpb.sectors_per_fat == 0 ? bpb.ebr_32.sectors_per_fat : bpb.bpb.sectors_per_fat;
u32 root_dir_sectors = ((bpb.bpb.directories * 32) + (bpb.bpb.bytes_per_sector - 1)) / bpb.bpb.bytes_per_sector;
u32 first_data_sector = bpb.bpb.reserved_sectors + (bpb.bpb.fats * fat_size) + root_dir_sectors;
u32 first_fat_sector = bpb.bpb.reserved_sectors;
u32 data_sectors = total_sectors - (bpb.bpb.reserved_sectors + (bpb.bpb.fats * fat_size) + root_dir_sectors);
u32 total_clusters = data_sectors / bpb.bpb.sectors_per_cluster;
uint32_t total_sectors = bpb.bpb.total_sectors == 0 ? bpb.bpb.large_total_sectors : bpb.bpb.total_sectors;
uint32_t fat_size = bpb.bpb.sectors_per_fat == 0 ? bpb.ebr_32.sectors_per_fat : bpb.bpb.sectors_per_fat;
uint32_t root_dir_sectors = ((bpb.bpb.directories * 32) + (bpb.bpb.bytes_per_sector - 1)) / bpb.bpb.bytes_per_sector;
uint32_t first_data_sector = bpb.bpb.reserved_sectors + (bpb.bpb.fats * fat_size) + root_dir_sectors;
uint32_t first_fat_sector = bpb.bpb.reserved_sectors;
uint32_t data_sectors = total_sectors - (bpb.bpb.reserved_sectors + (bpb.bpb.fats * fat_size) + root_dir_sectors);
uint32_t total_clusters = data_sectors / bpb.bpb.sectors_per_cluster;
u8 fat_type;
uint8_t fat_type;
if (total_clusters < 4085) {
fat_type = FAT_TYPE_12;
} else if (total_clusters < 65525) {
@@ -147,7 +147,7 @@ u8 fat_check_device(const block_device *device, u8 *first_sector) {
// dump dir
// fat12/16 only
u32 first_root_dir_sector = first_data_sector - root_dir_sectors;
uint32_t first_root_dir_sector = first_data_sector - root_dir_sectors;
// todo fat32
fat_directory_entry *entries = malloc(root_dir_sectors * bpb.bpb.bytes_per_sector);
device->access(device, BLOCK_DEV_DIRECTION_READ, first_root_dir_sector, root_dir_sectors, entries);
@@ -158,13 +158,13 @@ u8 fat_check_device(const block_device *device, u8 *first_sector) {
}
typedef struct {
u32 sector;
u32 value;
uint32_t sector;
uint32_t value;
} table_result;
table_result
get_fat_table_value(u8 fat_type, const u8 *fat_table, u32 active_cluster, u32 first_fat_cluster, u32 sector_size) {
u32 fat_offset;
get_fat_table_value(uint8_t fat_type, const uint8_t *fat_table, uint32_t active_cluster, uint32_t first_fat_cluster, uint32_t sector_size) {
uint32_t fat_offset;
table_result result = {
.value = 0,
.sector = 0,
@@ -173,7 +173,7 @@ get_fat_table_value(u8 fat_type, const u8 *fat_table, u32 active_cluster, u32 fi
case FAT_TYPE_12:
fat_offset = active_cluster * (active_cluster / 2);
result.sector = first_fat_cluster + (fat_offset / sector_size);
result.value = *(u16 *) &fat_table[fat_offset % sector_size];
result.value = *(uint16_t *) &fat_table[fat_offset % sector_size];
if (active_cluster & 0x1) {
result.value = result.value >> 4;
} else {
@@ -183,13 +183,13 @@ get_fat_table_value(u8 fat_type, const u8 *fat_table, u32 active_cluster, u32 fi
case FAT_TYPE_16:
fat_offset = active_cluster * 2;
result.sector = first_fat_cluster + (fat_offset / sector_size);
result.value = *(u16 *) &fat_table[fat_offset % sector_size];
result.value = *(uint16_t *) &fat_table[fat_offset % sector_size];
return result;
case FAT_TYPE_32:
case FAT_TYPE_EXFAT:
fat_offset = active_cluster * 4;
result.sector = first_fat_cluster + (fat_offset / sector_size);
result.value = *(u32 *) &fat_table[fat_offset % sector_size] & 0x0FFFFFFF;
result.value = *(uint32_t *) &fat_table[fat_offset % sector_size] & 0x0FFFFFFF;
return result;
default:
break;