lots of progress

currently, BAR fields of IDE drives are all returning zero, and the ATA read function isn't working. i'm not sure why.
i'm going to work on VESA next, and come back to the IDE driver later

32 files changed, 1107 insertions, 584 deletions

diff --git a/src/kernel/ata.c b/src/kernel/ata.c
deleted file mode 100644
index 0e6cc4e..0000000
--- a/src/kernel/ata.c
+++ /dev/null
@@ -1,113 +0,0 @@
-#include <stdint.h>
-#include "panic.h"
-#include "util.h"
-#include "ata.h"
-
-enum {
-  AP_PRIMARY   = 0x01f0,
-  AP_SECONDARY = 0x0170,
-
-  AP_DATA  = 0x0,
-  AP_ERROR = 0x1,
-  AP_FEAT  = 0x1,
-  AP_COUNT = 0x2,
-  AP_SEC   = 0x3,
-  AP_CYL_L = 0x4,
-  AP_CYL_H = 0x5,
-  AP_HD_DR = 0x6,
-  AP_LBA0  = 0x3,
-  AP_LBA1  = 0x4,
-  AP_LBA2  = 0x5,
-  AP_L3_DR = 0x6,
-  AP_STAT  = 0x7,
-  AP_CMD   = 0x7,
-
-  APC_STAT = 0x0206,
-  APC_CTRL = 0x0206,
-  APC_ADDR = 0x0207
-};
-
-enum {
-  ADR_BASE  = 0xa0,
-  ADR_CASCD = 0x10,
-  ADR_LBA   = 0x40
-};
-
-enum {
-  AS_ERROR   = 0x01,
-  AS_INDEX   = 0x02,
-  AS_CORRECT = 0x04,
-  AS_DREADY  = 0x08,
-  AS_SERVICE = 0x10,
-  AS_FAULT   = 0x20,
-  AS_READY   = 0x40,
-  AS_BUSY    = 0x80
-};
-
-enum {
-  AC_READ  = 0x20,
-  AC_WRITE = 0x30,
-  AC_FLUSH = 0xe7
-};
-
-void ata_ldelay() {
-  uint16_t i = 65535;
-  while (i--)
-    ;
-}
-
-void ata_sdelay() {
-  uint8_t i = 255;
-  while (i--)
-    ;
-}
-
-void ata_dpoll() {
-  uint8_t s;
-  while ((s = inb(AP_PRIMARY | AP_STAT) & (AS_BUSY | AS_DREADY)) != AS_DREADY)
-    if (s & (AS_ERROR | AS_FAULT))
-      panic("ATA controller error or fault.");
-}
-
-uint8_t read_sectors(uint16_t start, uint8_t count, void *buffer) {
-  outb(AP_PRIMARY | AP_L3_DR, ADR_BASE | ADR_LBA);
-  outb(AP_PRIMARY | AP_LBA2, 0);
-  outb(AP_PRIMARY | AP_LBA1, start >> 8);
-  outb(AP_PRIMARY | AP_LBA0, start & 0xff);
-  outb(AP_PRIMARY | AP_COUNT, count);
-  outb(AP_PRIMARY | AP_CMD, AC_READ);
-  uint8_t i = count - 1;
-  uint16_t *ptr = buffer;
-  do {
-    ata_dpoll();
-    uint8_t j = 255;
-    do
-      *(ptr++) = inw(AP_PRIMARY | AP_DATA);
-    while (j--);
-    ata_ldelay();
-  } while (i--);
-  return count;//TODO: return early if necessary
-}
-
-uint8_t write_sectors(uint16_t start, uint8_t count, void *buffer) {
-  outb(AP_PRIMARY | AP_L3_DR, ADR_BASE | ADR_LBA);
-  outb(AP_PRIMARY | AP_LBA2, 0);
-  outb(AP_PRIMARY | AP_LBA1, start >> 8);
-  outb(AP_PRIMARY | AP_LBA0, start & 0xff);
-  outb(AP_PRIMARY | AP_COUNT, count);
-  outb(AP_PRIMARY | AP_CMD, AC_WRITE);
-  uint8_t i = 0;
-  uint16_t *ptr = buffer;
-  do {
-    ata_dpoll();
-    uint8_t j = 0;
-    do {
-      ata_sdelay();
-      outw(AP_PRIMARY | AP_DATA, *(ptr++));
-    }
-    while (++j);
-    ata_ldelay();
-  } while (++i != count);
-  outb(AP_PRIMARY | AP_CMD, AC_FLUSH);
-  return count;//TODO: return early if necessary
-}
\ No newline at end of file
diff --git a/src/kernel/ata.h b/src/kernel/ata.h
index 605f991..7c42cdb 100644
--- a/src/kernel/ata.h
+++ b/src/kernel/ata.h
@@ -1,6 +1,75 @@
-#include <stdint.h>
+enum {
+  ATA_STATUS_BUSY        = 0x80,
+  ATA_STATUS_DRIVE_READY = 0x40,
+  ATA_STATUS_DRIVE_FAULT = 0x20,
+  ATA_STATUS_SEEK_DONE   = 0x10,
+  ATA_STATUS_DATA_READY  = 0x08,
+  ATA_STATUS_CORRECTED   = 0x04,
+  ATA_STATUS_INDEX       = 0x02,
+  ATA_STATUS_ERROR       = 0x01
+};
 
-void init_ata();
+enum {
+  ATA_ERROR_BAD_BLOCK      = 0x80,
+  ATA_ERROR_UNCORRECTABLE  = 0x40,
+  ATA_ERROR_MEDIA_SWAPPED  = 0x20,
+  ATA_ERROR_NO_ID_MARK     = 0x10,
+  ATA_ERROR_MEDIA_SWAPPING = 0x08,
+  ATA_ERROR_ABORTED_CMD    = 0x04,
+  ATA_ERROR_NO_TRACK_ZERO  = 0x02,
+  ATA_ERROR_NO_ADDR_MARK   = 0x01
+};
 
-uint8_t read_sectors(uint16_t start, uint8_t count, void *buffer);
-uint8_t write_sectors(uint16_t start, uint8_t count, void *buffer);
\ No newline at end of file
+enum {
+  ATA_CMD_READ      = 0x20,
+  ATA_CMD_WRITE     = 0x30,
+  ATA_CMD_WRITE_EXT = 0x34,
+  ATA_CMD_READ_EXT  = 0x40,
+  ATAPI_CMD         = 0xa0,
+  ATAPI_CMD_ID      = 0xa1,
+  ATA_CMD_FLUSH     = 0xe7,
+  ATA_CMD_FLUSH_EXT = 0xea,
+  ATA_CMD_ID        = 0xec,
+};
+
+enum {
+  ATAPI_CMD_EJECT = 0x1b,
+  ATAPI_CMD_READ  = 0xa8
+};
+
+enum {
+  ATA_REG_DATA       = 0x0,
+  ATA_REG_ERROR      = 0x1,
+  ATA_REG_FEAT       = 0x1,
+  ATA_REG_COUNT_LOW  = 0x2,
+  ATA_REG_LBA0       = 0x3,
+  ATA_REG_LBA1       = 0x4,
+  ATA_REG_LBA2       = 0x5,
+  ATA_REG_SELECT     = 0x6,
+  ATA_REG_CMD        = 0x7,
+  ATA_REG_STATUS     = 0x7,
+  ATA_REG_COUNT_HIGH = 0x8,
+  ATA_REG_LBA3       = 0x9,
+  ATA_REG_LBA4       = 0xa,
+  ATA_REG_LBA5       = 0xb,
+  ATA_REG_CONTROL    = 0xc,
+  ATA_REG_ALT_STATUS = 0xc,
+  ATA_REG_ADDR       = 0xd
+};
+
+enum {
+  ATA_MASTER_SELECT = 0xa0,
+  ATA_SLAVE_SELECT  = 0xb0
+};
+
+enum {
+  ATA_SET_EXT = 0x04000000
+};
+
+enum {
+  ATA_CAP_LBA = 0x00000200
+};
+
+enum {
+  ATA_CONTROL_NO_IRQS = 0x02
+};
\ No newline at end of file
diff --git a/src/kernel/boot.h b/src/kernel/boot.h
new file mode 100644
index 0000000..b3d3e76
--- /dev/null
+++ b/src/kernel/boot.h
@@ -0,0 +1,26 @@
+#ifndef BOOT_H
+#define BOOT_H
+
+#include <stdint.h>
+
+enum {
+  BIS_PCI = 0x80
+};
+
+enum {
+  PHC_CS_M1 = 0x01,
+  PHC_CS_M2 = 0x02,
+  PHC_SC_M1 = 0x10,
+  PHC_SC_M2 = 0x20
+};
+
+#define BOOT_INFO \
+  ((struct { \
+    uint8_t support_flags; \
+    uint8_t pci_hw_char; \
+    uint8_t pci_minor_bcd; \
+    uint8_t pci_major_bcd; \
+    uint8_t last_pci_bus; \
+  } __attribute__ ((__packed__)) *)0x4000)
+
+#endif
\ No newline at end of file
diff --git a/src/kernel/drive.c b/src/kernel/drive.c
new file mode 100644
index 0000000..bf27ec6
--- /dev/null
+++ b/src/kernel/drive.c
@@ -0,0 +1,38 @@
+#include "drive.h"
+#include "fat.h"
+#include "panic.h"
+
+uint8_t n_drives = 0;
+struct drive drives[256];
+
+drive_file_id_t unknown_get_file(struct drive *d, char *path) {
+  return 0;
+}
+
+void unknown_free_file(struct drive *d, drive_file_id_t fid) {
+  panic("Free file called on unknown file system");
+}
+
+void unknown_load_sector(struct drive *d, drive_file_id_t fid, uint32_t sector, void *at) {
+  panic("Load sector called on unknown file system");
+}
+
+uint32_t unknown_get_free_sectors(struct drive *d) {
+  return d->n_sectors;
+}
+
+void determine_fs(struct drive *d) {
+  if (try_fat_init_drive(d))
+    return;
+
+  d->fs_type = "Unknown";
+  d->get_file = &unknown_get_file;
+  d->free_file = &unknown_free_file;
+  d->load_sector = &unknown_load_sector;
+  d->get_free_sectors = &unknown_get_free_sectors;
+}
+
+void commit_drive(struct drive data) {
+  determine_fs(&data);
+  drives[n_drives++] = data;
+}
\ No newline at end of file
diff --git a/src/kernel/drive.h b/src/kernel/drive.h
new file mode 100644
index 0000000..8d3f3b2
--- /dev/null
+++ b/src/kernel/drive.h
@@ -0,0 +1,34 @@
+#ifndef DRIVE_H
+#define DRIVE_H
+
+#include <stdint.h>
+
+typedef uint8_t drive_file_id_t;
+
+typedef uint8_t fs_id_t;
+typedef uint8_t drive_id_t;
+
+#define MAX_DRIVES 256
+
+struct drive {
+  char *drive_type;
+  char *fs_type;
+
+  uint8_t (*read_sectors)(struct drive *d, uint32_t start, uint32_t count, void *buffer);
+  uint8_t (*write_sectors)(struct drive *d, uint32_t start, uint32_t count, void *buffer);
+  uint32_t n_sectors;
+  drive_id_t drive_id;
+
+  drive_file_id_t (*get_file)(struct drive *d, char *path);
+  void (*free_file)(struct drive *d, drive_file_id_t fid);
+  void (*load_sector)(struct drive *d, drive_file_id_t fid, uint32_t sector, void *at);
+  uint32_t (*get_free_sectors)(struct drive *d);
+  fs_id_t fs_id;
+};
+
+extern uint8_t n_drives;
+extern struct drive drives[MAX_DRIVES];
+
+void commit_drive(struct drive data);
+
+#endif
\ No newline at end of file
diff --git a/src/kernel/link.ld b/src/kernel/elf-link.ld
index 7c7b28d..a0d60f9 100644
--- a/src/kernel/link.ld
+++ b/src/kernel/elf-link.ld
@@ -3,15 +3,19 @@ OUTPUT_ARCH(i386)
 
 SECTIONS {
   . = 0x00030000;
-  .entry : {
+  .text : {
     */main.o(.text)
-  }
-  .bin : {
     *(.text)
+  }
+  .rodata : {
     *(.rodata)
+  }
+  .data : {
     *(.data)
   }
+  . = 0x10000000;
   .bss : {
     *(.bss)
+    kernel_bss_end = .;
   }
-}
+}
\ No newline at end of file
diff --git a/src/kernel/fat.c b/src/kernel/fat.c
index b8d1c3b..087d79e 100644
--- a/src/kernel/fat.c
+++ b/src/kernel/fat.c
@@ -1,115 +1,210 @@
 #include "fat.h"
 #include "ata.h"
 #include "panic.h"
-#include "fs.h"
+#include "drive.h"
+#include "mem.h"
+#include "util.h"
 
-void load_fat() {
-  read_sectors(FAT_INFO->reserved_sectors, FAT_INFO->sectors_per_fat, FAT);
+#define MAX_FAT_DRIVES 16
+#define MAX_OPEN_FILES_PER_DRIVE 32
+
+enum {
+  FA_READ_ONLY = 0x01,
+  FA_HIDDEN    = 0x02,
+  FA_SYSTEM    = 0x04,
+  FA_LABEL     = 0x08,
+  FA_DIRECTORY = 0x10,
+  FA_ARCHIVE   = 0x20,
+
+  FA_LFN       = 0x0f
+};
+
+struct directory_entry {
+  uint8_t name[11];
+  uint8_t attrib;
+  uint8_t name_case;
+  uint8_t created_decimal;
+  uint16_t created_time;
+  uint16_t created_date;
+  uint16_t accessed_date;
+  uint16_t ignore;
+  uint16_t modified_time;
+  uint16_t modified_date;
+  uint16_t first_cluster;
+  uint32_t length;
+} __attribute__ ((packed));
+
+struct fat_info {
+  //3 bytes jump
+  uint8_t  oem[8];
+  uint16_t bytes_per_sector;//Assumed to be 512
+  uint8_t  sectors_per_cluster;//Assumed to be 1
+  uint16_t reserved_sectors;
+  uint8_t  fats;//Only first is used
+  uint16_t root_entries;
+  uint16_t sectors;//Assumed not to be 0
+  uint8_t  media_type;
+  uint16_t sectors_per_fat;
+  uint16_t sectors_per_track;
+  uint16_t heads;
+  uint32_t hidden_sectors;
+  uint32_t sectors_long;
+  uint8_t  drive_number;
+  uint8_t  reserved;
+  uint8_t  ext_boot_marker;
+  uint32_t volume_id;
+  uint8_t  label[11];
+  uint8_t  fs_type[8];
+} __attribute__ ((packed));
+
+#define CTOS(c, fi) ((fi)->reserved_sectors + (fi)->sectors_per_fat * (fi)->fats + ((fi)->root_entries >> 4) + (c) - 2)
+
+struct fat_drive_info {
+  struct fat_info *fi;
+  uint16_t *fat;
+  struct directory_entry open_files[MAX_OPEN_FILES_PER_DRIVE];
+};
+
+struct fat_drive_info infos[MAX_FAT_DRIVES];
+uint8_t next_id = 0;
+
+#define FI(n) ((struct fat_info *)(infos[n].fi + 3))
+#define FN(n, f) (infos[n].open_files[f - 1])
+
+uint8_t fat_driver_buffer[512];
+struct fat_info *next_fi;
+
+void alloc_next_fi() {
+  if (!((uint32_t)(next_fi = (struct fat_info *)((uint32_t)next_fi + 64)) & 0xfff))
+    if (!(next_fi = allocate_pages(1)))
+      panic("Out of memory in FAT driver.");
 }
 
-bool to_fat_name(uint8_t *sname, uint8_t *fname) {
-  uint8_t *sp = sname, *fp = fname;
-  while (*sp != '.') {
-    if (!*sp) {
-      while (fp != fname + 11)
-        *(fp++) = ' ';
-      return false;
-    }
-    if (sp == sname + 8)
-      return true;
-    *(fp++) = *(sp++);
-  }
-  while (fp != fname + 8)
-    *(fp++) = ' ';
-  while (*++sp) {
-    if (fp == fname + 11)
-      return true;
-    *(fp++) = *sp;
+struct drive *cur_drive;
+fs_id_t cur_id;
+struct directory_entry *cur_dir;
+
+//loads cluster `c`
+void load_cluster(uint16_t c, void *to) {
+  if (c == 0) {
+    *(uint8_t *)to = 0;
+    return;
   }
-  while (fp != fname + 11)
-    *(fp++) = ' ';
-  return false;
+
+  uint32_t s = CTOS(c, FI(cur_id));
+  cur_drive->read_sectors(cur_drive, s, 1, to);
 }
 
-bool check_fat_names(uint8_t *lname, uint8_t *rname) {
-  return (* (uint32_t *)lname       ==  *(uint32_t *)rname) &&
-         (*((uint32_t *)lname +  1) == *((uint32_t *)rname +  1)) &&
-         (*((uint16_t *)lname +  4) == *((uint16_t *)rname +  4)) &&
-         (*(            lname + 10) == *(            rname + 10));
+uint16_t next_cluster(uint16_t c) {
+  panic("TODO: compute next sector (or 0 for none)");
 }
 
-struct directory_entry buffer[16];
-uint16_t dir_start, buffer_from;
+static inline bool check_fat_names(uint8_t *a, uint8_t *b) {
+  return (((uint32_t *)a)[0] == ((uint32_t *)b)[0]) &&
+         (((uint32_t *)a)[1] == ((uint32_t *)b)[1]) &&
+         (((uint16_t *)a)[8] == ((uint16_t *)b)[8]) &&
+         (((uint8_t *)a)[10] == ((uint8_t *)b)[10]);
+}
 
+//after: cur_dir -> specified entry in root
+bool try_locate_root_entry(uint8_t *fat_name) {
+  uint32_t cur_dir_sect = FI(cur_id)->reserved_sectors + FI(cur_id)->sectors_per_fat * FI(cur_id)->fats - 1;
+  cur_dir = (struct directory_entry *)(fat_driver_buffer + 512);
+  while (true) {
+    if (cur_dir == (struct directory_entry *)(fat_driver_buffer + 512)) {
+      cur_dir = (struct directory_entry *)fat_driver_buffer;
+      ++cur_dir_sect;
+      cur_drive->read_sectors(cur_drive, cur_dir_sect, 1, cur_dir);
+    }
+    if (!*(uint8_t *)cur_dir)
+      return false;
+    if (check_fat_names(cur_dir->name, fat_name))
+      return true;
+    else
+      ++cur_dir;
+  }
+}
 
-void load_root() {
-  dir_start = FAT_INFO->reserved_sectors + FAT_INFO->sectors_per_fat;
+//before: cur_dir -> entry of dir to search
+//after: cur_dir -> specified entry in dir
+bool try_locate_entry(uint8_t *fat_name) {
+  uint16_t cur_dir_cluster = cur_dir->first_cluster;
+  load_cluster(cur_dir_cluster, fat_driver_buffer);
+  cur_dir = (struct directory_entry *)fat_driver_buffer;
+  while (true) {
+    if (cur_dir == (struct directory_entry *)(fat_driver_buffer + 512)) {
+      cur_dir = (struct directory_entry *)fat_driver_buffer;
+      ++cur_dir_cluster;
+      load_cluster(cur_dir_cluster = next_cluster(cur_dir_cluster), fat_driver_buffer);
+    }
+    if (!*(uint8_t *)cur_dir)
+      return false;
+    if (check_fat_names(cur_dir -> name, fat_name))
+      return true;
+    else
+      ++cur_dir;
+  }
 }
 
-struct directory_entry *load_subentry(uint8_t *name) {
-  uint8_t fname[11];
-  if (to_fat_name(name, fname))
-    return 0;
-  struct directory_entry *ptr = buffer;
-  uint16_t dir_current = dir_start;
-  read_sectors(buffer_from = dir_current, 1, buffer);
-  while (*(uint8_t *)ptr) {
-    if (check_fat_names(ptr->name, fname))
-      return ptr;
-    if (++ptr == buffer + 16) {
-      read_sectors(buffer_from = ++dir_current, 1, buffer);
-      ptr = buffer;
+drive_file_id_t fat_get_file(struct drive *d, char *path) {
+  cur_drive = d;
+  cur_id = d->drive_id;
+  for (drive_file_id_t n = 1; n != MAX_OPEN_FILES_PER_DRIVE + 1; ++n)
+    if (!*(uint8_t *)(&FN(d->drive_id, n))) {
+      panic("TODO: open path at FN(id, n)");
+      return n;
     }
-  };
-  return 0;
+  panic("Maximum number of files open reached for FAT drive.");
 }
 
-bool load_subdir(uint8_t *name) {
-  struct directory_entry *e = load_subentry(name);
-  if (!e)
-    return true;
-  dir_start = CTOS(e->first_cluster);
-  return false;
+void fat_free_file(struct drive *d, drive_file_id_t fid) {
+  *(uint8_t *)(&FN(d->drive_id, fid)) = 0;
 }
 
-struct directory_entry *load_entry(uint8_t *path) {
-  load_root();
-  for (uint8_t *ptr = path; *ptr; ++ptr)
-    if (*ptr == '/') {
-      *ptr = 0;
-      if (load_subdir(path))
-        return 0;
-      path = ptr + 1;
-    }
-  return load_subentry(path);
+void fat_load_sector(struct drive *d, drive_file_id_t fid, uint32_t sector, void *at) {
+  cur_drive = d;
+  cur_id = d->drive_id;
+  uint16_t c = FN(d->drive_id, fid).first_cluster;
+  for (uint32_t i = 0; i < sector; ++i)
+    c = next_cluster(c);
+  load_cluster(c, at);
 }
 
-bool get_entry(uint8_t *path, struct directory_entry *at) {
-  struct directory_entry *e = load_entry(path);
-  if (!e)
-    return true;
-  *at = *e;
-  return false;
+uint32_t fat_get_free_sectors(struct drive *d) {
+  panic("TODO: get free sectors of drive");
 }
 
-bool update_entry(uint8_t *path, struct directory_entry *value) {
-  struct directory_entry *e = load_entry(path);
-  if (!e)
-    return true;
-  *e = *value;
-  write_sectors(buffer_from, 1, buffer);
-  return false;
+void init_fat() {
+  next_fi = allocate_pages(1);
 }
 
-bool create_entry(uint8_t *dir_path, struct directory_entry *value) {
-  fs_handle h = fs_open(dir_path);
-  struct directory_entry *check;
-  while (fs_read(h, 32, check))
-    if (check_fat_names(check->name, value->name)) {
-      fs_close(h);
-      return true;
-    }
-  fs_write(h, 32, value);
-  fs_close(h);
-  return false;
+bool try_fat_init_drive(struct drive *d) {
+  if (next_id >= MAX_FAT_DRIVES)
+    panic("Maximum number of FAT drives reached.");
+
+  if (!d->read_sectors(d, 0, 1, fat_driver_buffer))
+    return false;
+  memcpy(next_fi, fat_driver_buffer + 3, sizeof(struct fat_info));
+  uint32_t *fs_type_32 = (uint32_t *)next_fi->fs_type;
+  if ((fs_type_32[0] != ('F' + 'A' * 256 + 'T' + 65536 + '1' * 16777216)) ||
+      (fs_type_32[1] != ('6' + ' ' * 256 + ' ' + 65536 + ' ' * 16777216)))
+    return false;
+
+  d->fs_type = "FAT16";
+  d->get_file = &fat_get_file;
+  d->free_file = &fat_free_file;
+  d->load_sector = &fat_load_sector;
+  d->get_free_sectors = &fat_get_free_sectors;
+
+  d->fs_id = next_id;
+  infos[next_id].fi = next_fi;
+  infos[next_id].fat = allocate_pages(((next_fi->sectors_per_fat - 1) >> 3) + 1);
+  for (drive_file_id_t i = 0; i < MAX_OPEN_FILES_PER_DRIVE; ++i)
+    *(uint8_t *)&FN(next_id, i) = 0;
+
+  d->read_sectors(d, next_fi->reserved_sectors, next_fi->sectors_per_fat, infos[next_id].fat);
+
+  alloc_next_fi();
+  ++next_id;
+  return true;
 }
\ No newline at end of file
diff --git a/src/kernel/fat.h b/src/kernel/fat.h
index 73eaaae..d9db906 100644
--- a/src/kernel/fat.h
+++ b/src/kernel/fat.h
@@ -1,61 +1,12 @@
+#ifndef FAT_H
+#define FAT_H
+
 #include <stdint.h>
 #include <stdbool.h>
+#include "drive.h"
 
-#define FAT_INFO ((struct fat_info *)0x7c03)
-
-struct fat_info {
-  uint8_t  oem[8];
-  uint16_t bytes_per_sector;//Assumed to be 512
-  uint8_t  sectors_per_cluster;//Assumed to be 1
-  uint16_t reserved_sectors;
-  uint8_t  fats;//Assumed to be 1
-  uint16_t root_entries;
-  uint16_t sectors;//Assumed not to be 0
-  uint8_t  media_type;
-  uint16_t sectors_per_fat;
-  uint16_t sectors_per_track;
-  uint16_t heads;
-  uint32_t hidden_sectors;
-  uint32_t sectors_long;
-  uint8_t  drive_number;
-  uint8_t  reserved;
-  uint8_t  ext_boot_marker;
-  uint32_t volume_id;
-  uint8_t  label[11];
-  uint8_t  fs_type[8];
-} __attribute__ ((packed));
-
-enum {
-  FA_READ_ONLY = 0x01,
-  FA_HIDDEN    = 0x02,
-  FA_SYSTEM    = 0x04,
-  FA_LABEL     = 0x08,
-  FA_DIRECTORY = 0x10,
-  FA_ARCHIVE   = 0x20,
-
-  FA_LFN       = 0x0f
-};
-
-struct directory_entry {
-  uint8_t name[11];
-  uint8_t attrib;
-  uint8_t name_case;
-  uint8_t created_decimal;
-  uint16_t created_time;
-  uint16_t created_date;
-  uint16_t accessed_date;
-  uint16_t ignore;
-  uint16_t modified_time;
-  uint16_t modified_date;
-  uint16_t first_cluster;
-  uint32_t length;
-} __attribute__ ((packed));
-
-#define FAT ((uint16_t *)0x00020000)
-void load_fat();
+void init_fat();
 
-#define CTOS(c) (FAT_INFO->reserved_sectors + FAT_INFO->sectors_per_fat + (FAT_INFO->root_entries >> 4) + (c) - 2)
+bool try_fat_init_drive(struct drive *d);
 
-bool get_entry(uint8_t *path, struct directory_entry *at);
-bool update_entry(uint8_t *path, struct directory_entry *value);
-bool create_entry(uint8_t *path, struct directory_entry *value);
\ No newline at end of file
+#endif
\ No newline at end of file
diff --git a/src/kernel/fs.c b/src/kernel/fs.c
deleted file mode 100644
index 0d51c22..0000000
--- a/src/kernel/fs.c
+++ /dev/null
@@ -1,144 +0,0 @@
-#include <stdint.h>
-#include "fs.h"
-#include "ata.h"
-#include "fat.h"
-#include <stdbool.h>
-#include "panic.h"
-#include "util.h"
-
-#define MAX_HANDLES 32
-#define FILE_BUFFER(h) ((void *)(0x0002be00 + (h << 9)))
-#define HANDLE(h) ((handles - 1)[h])
-#define HEAD(h) (FILE_BUFFER(h) + HANDLE(h).seek % 512)
-
-enum {
-  FH_DIRTY     = 0x01,
-  FH_NO_WRITE  = 0x02,
-  FH_NO_EXPAND = 0x04,
-  FH_ROOT      = 0x08
-};
-
-struct handle_info {
-  uint16_t first_cluster;
-  uint16_t loaded_cluster;
-  uint32_t seek;
-  uint32_t length;
-  uint8_t flags;
-};
-
-struct handle_info handles[MAX_HANDLES];
-
-void clear_fs_handles() {
-  struct handle_info *f = handles;
-  while (f < handles + MAX_HANDLES)
-    (f++)->first_cluster = 0;
-}
-
-fs_handle next_handle() {
-  fs_handle r = 0;
-  while (HANDLE(++r).first_cluster)
-    if (r == MAX_HANDLES)
-      return 0;
-  return r;
-}
-
-void write_buffer(fs_handle handle) {
-  HANDLE(handle).flags &= ~FH_DIRTY;
-  if (HANDLE(handle).flags & FH_ROOT)
-    write_sectors(HANDLE(handle).loaded_cluster, 1, FILE_BUFFER(handle));
-  else
-    write_sectors(CTOS(HANDLE(handle).loaded_cluster), 1, FILE_BUFFER(handle));
-}
-
-void read_buffer(fs_handle handle) {
-  if (HANDLE(handle).flags & FH_DIRTY)
-    write_buffer(handle);
-  uint16_t s = HANDLE(handle).seek >> 9;
-  if (HANDLE(handle).flags & FH_ROOT) {
-    HANDLE(handle).loaded_cluster = HANDLE(handle).first_cluster + s;
-    read_sectors(HANDLE(handle).first_cluster + s, 1, FILE_BUFFER(handle));
-  }
-  else {
-    uint16_t c = HANDLE(handle).first_cluster;
-    while (s--)
-      c = FAT[c];
-    HANDLE(handle).loaded_cluster = c;
-    read_sectors(CTOS(c), 1, FILE_BUFFER(handle));
-  }
-}
-
-fs_handle fs_open(uint8_t *path) {
-  fs_handle next = next_handle();
-  if (!next)
-    return 0;
-  struct directory_entry e;
-  if (get_entry(path, &e))
-    return 0;
-  HANDLE(next).first_cluster = e.first_cluster;
-  HANDLE(next).seek = 0;
-  HANDLE(next).length = e.length;
-  HANDLE(next).flags = (e.attrib & FA_READ_ONLY ? FH_NO_WRITE  : 0) |
-                       (e.attrib & FA_SYSTEM    ? FH_NO_EXPAND : 0);
-  read_buffer(next);
-  return next;
-}
-
-fs_handle fs_open_root() {
-  fs_handle next = next_handle();
-  if (!next)
-    return 0;
-  HANDLE(next).first_cluster = FAT_INFO->reserved_sectors + FAT_INFO->sectors_per_fat;
-  HANDLE(next).seek = 0;
-  HANDLE(next).length = FAT_INFO->root_entries * 32;
-  HANDLE(next).flags = FH_NO_EXPAND | FH_ROOT;
-  read_buffer(next);
-  return next;
-}
-
-int32_t fs_seek(fs_handle handle, int32_t by) {
-  uint32_t old = HANDLE(handle).seek;
-  uint32_t to = -by > old ? 0 : old + by > HANDLE(handle).length ? HANDLE(handle).length : old + by;
-  HANDLE(handle).seek = to;
-  if ((to ^ old) & 0xfe00)
-    read_buffer(handle);
-  return to - old;
-}
-
-uint32_t fs_read(fs_handle handle, uint32_t max, void *buffer) {
-  max = HANDLE(handle).seek + max > HANDLE(handle).length ? HANDLE(handle).length - HANDLE(handle).seek : max;
-  uint32_t left = max, eos = 512 - (HANDLE(handle).seek & 0x1ff);
-  if (left < eos) {
-    memcpy(buffer, FILE_BUFFER(handle) + (HANDLE(handle).seek & 0x1ff), left);
-    HANDLE(handle).seek += left;
-    return max;
-  }
-  memcpy(buffer, FILE_BUFFER(handle) + (HANDLE(handle).seek & 0x1ff), eos);
-  left -= eos;
-  buffer += eos;
-  HANDLE(handle).seek += eos;
-  while (left >= 512) {
-    read_buffer(handle);
-    memcpy(buffer, FILE_BUFFER(handle), 512);
-    left -= 512;
-    buffer += 512;
-    HANDLE(handle).seek += 512;
-  }
-  if (left) {
-    read_buffer(handle);
-    memcpy(buffer, FILE_BUFFER(handle), left);
-    HANDLE(handle).seek += left;
-  }
-  return max;
-}
-
-uint32_t fs_write(fs_handle handle, uint32_t max, void *buffer) {
-  if (HANDLE(handle).flags & FH_NO_WRITE)
-    return 0;
-  panic("Not implemented (fs_write).");
-}
-
-void fs_close(fs_handle handle) {
-  if (HANDLE(handle).flags & FH_DIRTY)
-    write_buffer(handle);
-  HANDLE(handle).first_cluster = 0;
-}
\ No newline at end of file
diff --git a/src/kernel/fs.h b/src/kernel/fs.h
deleted file mode 100644
index e2b14c0..0000000
--- a/src/kernel/fs.h
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdint.h>
-
-void clear_fs_handles();
-
-typedef uint8_t fs_handle;
-fs_handle fs_open(uint8_t *path);
-fs_handle fs_open_root();
-int32_t fs_seek(fs_handle handle, int32_t by);
-uint32_t fs_read(fs_handle handle, uint32_t max, void *buffer);
-uint32_t fs_write(fs_handle handle, uint32_t max, void *buffer);
-void fs_close(fs_handle handle);
\ No newline at end of file
diff --git a/src/kernel/ide.c b/src/kernel/ide.c
new file mode 100644
index 0000000..a2d3895
--- /dev/null
+++ b/src/kernel/ide.c
@@ -0,0 +1,189 @@
+#include <stdint.h>
+#include <stdbool.h>
+#include "panic.h"
+#include "util.h"
+#include "drive.h"
+#include "pci.h"
+#include "ata.h"
+
+#define MAX_IDE_DRIVES 8
+
+struct ide_drive_info {
+  uint16_t base_port;
+  uint16_t control_port;
+  bool slave;
+};
+
+struct ide_drive_info ide_drives[MAX_IDE_DRIVES];
+drive_id_t n_ide_drives = 0;
+
+void spin_delay() {
+  for (uint32_t i = -1; i; --i)
+    ;
+}
+
+//return true on error condition
+bool poll(struct ide_drive_info *info) {
+  spin_delay();
+
+  uint8_t status;
+
+  while ((status = inb(info->base_port | ATA_REG_STATUS)) & ATA_STATUS_BUSY)
+    ;
+
+  return (status & (ATA_STATUS_ERROR | ATA_STATUS_DRIVE_FAULT)) || !(status & ATA_STATUS_DRIVE_READY);
+}
+
+uint8_t ide_ata_rs(struct drive *d, uint32_t start, uint32_t count, void *buffer) {
+  if (start & 0xf0000000)
+    panic("IDE ATA driver only supports LBA28 addressing currently.");
+
+  struct ide_drive_info *info = ide_drives + d->drive_id;
+
+  if (start + count > d->n_sectors)
+    count = d->n_sectors - start;
+
+  if (count & 0xffffff00)
+    panic("IDE ATA driver only supports reading up to 128k at a time currently.");
+
+  uint32_t lba = start & 0x00ffffff;
+
+  uint32_t spin = -1;
+  while (inb(info->base_port | ATA_REG_STATUS) & ATA_STATUS_BUSY)
+    if (!spin--)
+      panic("Spun out in IDE ATA reading");
+
+  outb(info->base_port | ATA_REG_SELECT, (info->slave ? 0xf0 : 0xe0) | (start >> 24));
+  outb(info->base_port | ATA_REG_COUNT_LOW, count);
+  outb(info->base_port | ATA_REG_LBA0, lba);
+  outb(info->base_port | ATA_REG_LBA1, lba >> 8);
+  outb(info->base_port | ATA_REG_LBA2, lba >> 16);
+
+  uint16_t *buffer_16 = buffer;
+
+  for (uint16_t i = 0; i < count; ++i) {
+    if (poll(info))
+      return i;
+    for (uint16_t j = 0; j < 256; ++j)
+      *buffer_16++ = inw(info->base_port + ATA_REG_DATA);
+  }
+
+  return count;
+}
+
+uint8_t ide_ata_ws(struct drive *d, uint32_t start, uint32_t count, void *buffer) {
+  panic("IDE ATA writing not implemented yet");
+  return 0;
+}
+
+uint8_t ide_atapi_rs(struct drive *d, uint32_t start, uint32_t count, void *buffer) {
+  //panic("IDE ATAPI reading not implemented yet");
+  return 0;
+}
+
+uint8_t ide_atapi_ws(struct drive *d, uint32_t start, uint32_t count, void *buffer) {
+  panic("IDE ATAPI writing not implemented yet");
+  return 0;
+}
+
+struct id_space {
+  uint16_t device_type;//0
+  uint8_t skip1[98 - 2];
+  uint16_t capabilities;//98
+  uint8_t skip2[120 - (98 + 2)];
+  uint32_t max_lba;//120
+  uint8_t skip3[164 - (120 + 4)];
+  uint32_t command_sets;//164
+  uint8_t skip4[200 - (164 + 4)];
+  uint32_t max_lba_ext;//200
+  uint8_t skip5[512 - (200 + 4)];
+} __attribute__ ((__packed__));
+
+void read_id_space(uint16_t base_port, struct id_space *to) {
+  uint32_t *to_32 = (uint32_t *)to;
+  for (uint8_t i = 0; i < 128; ++i)
+    *(to_32++) = ind(base_port | ATA_REG_DATA);
+}
+
+void test_drive(uint16_t base_port, uint16_t control_port, bool slave) {
+  outb(base_port | ATA_REG_SELECT, slave ? ATA_SLAVE_SELECT : ATA_MASTER_SELECT);
+  spin_delay();
+
+  outb(base_port | ATA_REG_CMD, ATA_CMD_ID);
+  spin_delay();
+
+  if (!inb(base_port | ATA_REG_STATUS))
+    return;
+
+  if (n_ide_drives == MAX_IDE_DRIVES)
+    panic("Maximum IDE drives reached");
+
+  outb(base_port | ATA_REG_CONTROL, ATA_CONTROL_NO_IRQS);
+
+  struct ide_drive_info *this_drive = ide_drives + n_ide_drives;
+  this_drive->base_port = base_port;
+  this_drive->control_port = control_port;
+  this_drive->slave = slave;
+
+  struct drive data;
+  data.drive_id = n_ide_drives;
+
+  uint32_t spin_out = -1;
+  while (1) {//wait for identify to complete
+    uint8_t status = inb(base_port | ATA_REG_STATUS);
+    if (status & ATA_STATUS_ERROR) {
+      uint16_t type = inb(base_port | ATA_REG_LBA1) +
+                     (inb(base_port | ATA_REG_LBA2) << 8);
+
+      //These two are listed on OSDev Wiki
+      //  as being ATAPI device types.
+      if ((type != 0xeb14) && (type != 0x9669))
+        return;
+
+      outb(base_port | ATA_REG_CMD, ATAPI_CMD_ID);
+
+      data.read_sectors = &ide_atapi_rs;
+      data.write_sectors = &ide_atapi_ws;
+      data.drive_type = "IDE ATAPI";
+      break;
+    }
+    if (!(status & ATA_STATUS_BUSY) && (status & ATA_STATUS_DATA_READY)) {
+      data.read_sectors = &ide_ata_rs;
+      data.write_sectors = &ide_ata_ws;
+      data.drive_type = "IDE ATA";
+      break;
+    }
+    if (!spin_out--)
+      panic("IDE ATA identify won't complete");
+  }
+
+  struct id_space id;
+  read_id_space(base_port, &id);
+
+  if (!(id.capabilities & ATA_CAP_LBA))
+    //TODO: CHS compability driver?
+    return;
+  data.n_sectors = (id.command_sets & ATA_SET_EXT) ? id.max_lba_ext : id.max_lba;
+
+  commit_drive(data);
+  ++n_ide_drives;
+}
+
+void init_ide() {
+  uint16_t check_from = 0;
+  struct pci_device *device;
+  //double parentheses to let gcc know this assignment isn't a mistake
+  while ((device = find_pci_device_from_class_and_subclass(PCI_MASS_STORAGE, PCI_IDE, check_from, &check_from))) {
+    ++check_from;
+
+    uint16_t primary_base_port      = device->bar0 <= 1 ? 0x01f0 : device->bar0;
+    uint16_t primary_control_port   = device->bar1 <= 1 ? 0x03f6 : device->bar1;
+    uint16_t secondary_base_port    = device->bar2 <= 1 ? 0x0170 : device->bar2;
+    uint16_t secondary_control_port = device->bar3 <= 1 ? 0x0376 : device->bar3;
+
+    test_drive(primary_base_port,   primary_control_port,   false);
+    test_drive(primary_base_port,   primary_control_port,   true);
+    test_drive(secondary_base_port, secondary_control_port, false);
+    test_drive(secondary_base_port, secondary_control_port, true);
+  }
+}
\ No newline at end of file
diff --git a/src/kernel/ide.h b/src/kernel/ide.h
new file mode 100644
index 0000000..44b02ec
--- /dev/null
+++ b/src/kernel/ide.h
@@ -0,0 +1,12 @@
+#ifndef IDE_H
+#define IDE_H
+
+#include <stdint.h>
+#include "drive.h"
+
+void init_ide();
+
+uint8_t ide_read_sectors(drive_id_t id, uint32_t start, uint32_t count, void *buffer);
+uint8_t ide_write_sectors(drive_id_t id, uint32_t start, uint32_t count, void *buffer);
+
+#endif
\ No newline at end of file
diff --git a/src/kernel/main.c b/src/kernel/main.c
index 92e778c..e5c0013 100644
--- a/src/kernel/main.c
+++ b/src/kernel/main.c
@@ -1,72 +1,113 @@
 #include <stdint.h>
 #include "vga.h"
 #include "fat.h"
-#include "fs.h"
-#include "ata.h"
+#include "ide.h"
 #include "panic.h"
 #include "serial.h"
 #include "util.h"
+#include "mem.h"
+#include "pci.h"
+#include "boot.h"
+#include "vesa.h"
 
-uint8_t nbuf[11];
+char nbuf[11];
+
+#define SOTL(field) field = (void *)((*((uint16_t *)(&field) + 1) << 16) + *(uint16_t *)(&field));
+
+__attribute__ ((noreturn)) void main() {
+  SOTL(VESA_INFO->oem)
+  SOTL(VESA_INFO->modes)
+  SOTL(VESA_INFO->vendor)
+  SOTL(VESA_INFO->pname)
+  SOTL(VESA_INFO->prev)
+
+  init_mmap();
+
+  init_vesa();
+
+  init_serial();
 
-void main() {
   vga_blank();
-  vga_printsz("Initializing drivers...");
-  sinit();
-  vga_printsz("\n  Serial ready.");
-  load_fat();
-  clear_fs_handles();
-  vga_printsz("\n  File system ready.\n\nDisk info:\n  Disk label: ");
-  vga_printsn(FAT_INFO->label, 11);
-  vga_printsz("\n  Disk size:  ");
-  u16_dec(FAT_INFO->sectors >> 1, nbuf);
-  vga_printsz(nbuf);
-  vga_printsz("k\n  FAT size:   ");
-  u16_dec(FAT_INFO->sectors_per_fat >> 1, nbuf);
-  vga_printsz(nbuf);
-  vga_printsz("k\n  Root size:  ");
-  u16_dec(FAT_INFO->root_entries >> 5, nbuf);
+  vga_printsz("Portland v0.0.11\n\n");
+
+  //list vesa modes?
+
+  pci_init();
+
+  u16_dec(n_pci_devices, nbuf);
   vga_printsz(nbuf);
-  vga_printsz("k\n\nRoot directory:");
-  fs_handle root = fs_open_root();
-  struct directory_entry e;
-  while(1) {
-    fs_read(root, 32, &e);
-    if (!e.name[0])
-      break;
-    if (e.attrib == FA_LFN)
-      continue;
-    uint8_t *p = (uint8_t *)&e;
-    nbuf[3] = 0;
-    vga_printsz("\n  ");
-    vga_printsn((uint8_t *)&e.name, 11);
-    vga_printsz("  |  0x");
-    u8_hex(e.attrib, nbuf);
+  vga_printsz(" PCI device(s) found:\n");
+
+  for (uint16_t n = 0; n < n_pci_devices; ++n) {
+    struct pci_device *pd = nth_pci_device(n);
+
+    u16_hex(pd->number, nbuf);
+    vga_printsz("  ");
+    vga_printsz(nbuf);
+    vga_printsz(": ");
+
+    u16_hex(pd->id_vendor, nbuf);
+    nbuf[4] = '.';
+    u16_hex(pd->id_device, nbuf + 5);
     vga_printsz(nbuf);
-    vga_printch(' ');
-    vga_printch(e.attrib & FA_READ_ONLY ? 'R' : '_');
-    vga_printch(e.attrib & FA_HIDDEN    ? 'H' : '_');
-    vga_printch(e.attrib & FA_SYSTEM    ? 'S' : '_');
-    vga_printch(e.attrib & FA_LABEL     ? 'L' : '_');
-    vga_printch(e.attrib & FA_DIRECTORY ? 'D' : '_');
-    vga_printch(e.attrib & FA_ARCHIVE   ? 'A' : '_');
-    vga_printsz("  |  ");
-    u32_dec(e.length, nbuf);
+
+    u8_hex(pd->class, nbuf);
+    nbuf[2] = '.';
+    u8_hex(pd->subclass, nbuf + 3);
+    nbuf[5] = '.';
+    u8_hex(pd->iface, nbuf + 6);
+    vga_printsz(" (");
     vga_printsz(nbuf);
+    vga_printsz(")\n");
   }
-  fs_close(root);
-  if (root = fs_open("BLEH.TXT")) {
-    vga_printsz("\n\nContents of BLEH.TXT:");
-    uint8_t l;
-    uint8_t line[82];
-    line[0] = '\n';
-    line[1] = ' ';
-    line[2] = ' ';
-    while (l = fs_read(root, 78, line + 3)) {
-      line[l + 3] = 0;
-      vga_printsz(line);
-    }
-    fs_close(root);
+
+  vga_printch('\n');
+
+  init_fat();
+
+  init_ide();
+
+  u8_dec(n_drives, nbuf);
+  vga_printsz(nbuf);
+  vga_printsz(" drive(s) found:\n");
+
+  for (uint8_t n = 0; n < n_drives; ++n) {
+    struct drive *d = drives + n;
+
+    u8_dec(n, nbuf);
+    vga_printsz("  sd");
+    vga_printsz(nbuf);
+    vga_printsz(" (");
+    vga_printsz(d->drive_type);
+    vga_printsz("): ");
+
+    vga_printsz(d->fs_type);
+    vga_printsz(", ");
+
+    u32_dec(d->n_sectors / 2, nbuf);
+    vga_printsz(nbuf);
+    if (d->n_sectors % 2)
+      vga_printsz(".5");
+    vga_printsz("k, ");
+
+    uint32_t free_sectors = d->get_free_sectors(d);
+
+    u32_dec(free_sectors / 2, nbuf);
+    vga_printsz(nbuf);
+    if (d->n_sectors % 2)
+      vga_printsz(".5");
+    vga_printsz("k free.\n");
   }
-  halt();
+
+  vga_printch('\n');
+
+  u32_dec(pages_left * 4, nbuf);
+  vga_printsz(nbuf);
+  vga_printsz("k dynamic memory free.\n\n");
+
+  vga_printsz("Loading init process.");
+
+  vga_printsz("\n\nTODO: load and switch to init process");
+  while (1)
+    asm ("hlt");
 }
\ No newline at end of file
diff --git a/src/kernel/mem.c b/src/kernel/mem.c
new file mode 100644
index 0000000..2e8173d
--- /dev/null
+++ b/src/kernel/mem.c
@@ -0,0 +1,63 @@
+#include <stdint.h>
+#include <stdbool.h>
+#include "panic.h"
+
+#define DYNAMIC_START (0x10000000)
+#define DYNAMIC_END   (DYNAMIC_START + 65536 * 4096)
+#define PAGE_TO_ADDR(n) ((void *)(DYNAMIC_START | ((n) << 12)))
+#define ADDR_TO_PAGE(n) (((uint32_t)(n) & ~DYNAMIC_START) >> 12)
+
+#define MMAP_START (0x00010000)
+#define PAGE_USED(n) ((*(uint8_t *)(MMAP_START + (n >> 3)) >> (n & 7)) & 1)
+#define CLEAR_PAGE(n)  *(uint8_t *)(MMAP_START + (n >> 3)) &= ~(1 << (n & 7))
+#define SET_PAGE(n)    *(uint8_t *)(MMAP_START + (n >> 3)) |=   1 << (n & 7)
+
+extern const void kernel_bss_end;
+
+uint16_t pages_left;
+
+void init_mmap() {
+  volatile uint8_t *end_ptr = (uint8_t *)(DYNAMIC_END - 1);
+  uint8_t end_val = *end_ptr;
+  *end_ptr = (uint8_t)~end_val;
+  if (*end_ptr != (uint8_t)~end_val)
+    panic("Not enough memory. Must have at least 512MiB.");
+
+  for (uint32_t *m = (uint32_t *)MMAP_START; m < (uint32_t *)(MMAP_START + (65536 / 8)); ++m)
+    *m = 0;
+
+  uint16_t kernel_bss_pages = (((uint32_t)&kernel_bss_end - DYNAMIC_START - 1) >> 12) + 1;
+  for (uint16_t i = 0; i < kernel_bss_pages; ++i)
+    SET_PAGE(i);
+
+  pages_left = 65536 - kernel_bss_pages;
+}
+
+//very inneficient algorithm, just returns first hole big enough.
+//a smarter algorithm might pick the smallest one available,
+//and go by bytes (or dwords) instead of bits where possible.
+void *allocate_pages(uint16_t n) {
+  uint16_t run = 0;
+  
+  for (uint32_t page = 0; page < 65536; ++page) {
+    if (PAGE_USED(page))
+      run = 0;
+    else if (++run == n) {
+      uint16_t start = page - run + 1;
+      for (uint32_t i = start; i <= page; ++i)
+        SET_PAGE(i);
+      pages_left -= n;
+      return PAGE_TO_ADDR(start);
+    }
+  }
+
+  return 0;
+}
+
+//in the future, change this to go by bytes or dwords instead of bits.
+void free_pages(void *ptr, uint16_t n) {
+  uint16_t page = ADDR_TO_PAGE(ptr);
+  for (uint32_t i = page; i < page + n; ++i)
+    CLEAR_PAGE(i);
+  pages_left += n;
+}
\ No newline at end of file
diff --git a/src/kernel/mem.h b/src/kernel/mem.h
new file mode 100644
index 0000000..913f70b
--- /dev/null
+++ b/src/kernel/mem.h
@@ -0,0 +1,13 @@
+#ifndef MEM_H
+#define MEM_H
+
+#include <stdint.h>
+
+extern uint16_t pages_left;
+
+void init_mmap();
+
+void *allocate_pages(uint16_t n);
+void free_pages(void *ptr, uint16_t n);
+
+#endif
\ No newline at end of file
diff --git a/src/kernel/panic.c b/src/kernel/panic.c
index a463a2a..93944ff 100644
--- a/src/kernel/panic.c
+++ b/src/kernel/panic.c
@@ -2,31 +2,14 @@
 #include "vga.h"
 #include "serial.h"
 #include "util.h"
+#include "panic.h"
 
-void halt() {
-  vga_printsz("\n\nHalting...");
-  while (1)
-    asm volatile ("hlt");
-}
-
-void panic(uint8_t *message) {
-  uint32_t frame;
-  asm (
-    "movl %%ebp, %0"
-  : "=r" (frame));
+void panic(char *message) {
   vga_set_color(0x4f);
   vga_blank();
   vga_printsz("Kernel panic: ");
   vga_printsz(message);
-  vga_printsz("\n\nStack trace:");
-  uint8_t stb[6];
-  while (1) {
-    uint32_t ip = *((uint32_t *)frame + 1);
-    if (!ip)
-      halt();
-    vga_printsz("\n  0x");
-    u16_hex(ip - 0x30000 - 5, stb);//assumes would return to just after a call instruction
-    vga_printsz(stb);
-    frame = *(uint32_t *)frame;
-  }
+  vga_printsz("\nHalting.");
+  while (1)
+    asm volatile ("hlt");
 }
\ No newline at end of file
diff --git a/src/kernel/panic.h b/src/kernel/panic.h
index 8972814..7d2e9df 100644
--- a/src/kernel/panic.h
+++ b/src/kernel/panic.h
@@ -1,4 +1,8 @@
+#ifndef PANIC_H
+#define PANIC_H
+
 #include <stdint.h>
 
-void panic(uint8_t *message) __attribute__ ((noreturn));
-void halt() __attribute__ ((noreturn));
\ No newline at end of file
+void panic(char *message) __attribute__ ((noreturn));
+
+#endif
\ No newline at end of file
diff --git a/src/kernel/pci.c b/src/kernel/pci.c
new file mode 100644
index 0000000..fe96c4c
--- /dev/null
+++ b/src/kernel/pci.c
@@ -0,0 +1,77 @@
+#include "boot.h"
+#include "mem.h"
+#include "util.h"
+#include "pci.h"
+#include "panic.h"
+
+enum {
+  PCP_SELECT = 0x0cf8,
+  PCP_READ   = 0x0cfc
+};
+
+uint16_t n_pci_devices = 0;
+struct pci_device *pci_device_pages[256];
+
+#define PCI_DEVICES_PER_PAGE (4096 / sizeof(struct pci_device))
+
+struct pci_device *nth_pci_device(uint16_t n) {
+  return pci_device_pages[n / PCI_DEVICES_PER_PAGE] + (n % PCI_DEVICES_PER_PAGE);
+}
+
+struct pci_device *find_pci_device_from_class_and_subclass(uint8_t class, uint8_t subclass, uint16_t start, uint16_t *index) {
+  for (uint16_t n = start; n < n_pci_devices; ++n) {
+    struct pci_device *p = nth_pci_device(n);
+    if ((p->class == class) && (p->subclass == subclass)) {
+      *index = n;
+      return p;
+    }
+  }
+  return 0;
+}
+
+struct pci_device *next_pci_device() {
+  if (!(n_pci_devices % PCI_DEVICES_PER_PAGE))
+    pci_device_pages[n_pci_devices / PCI_DEVICES_PER_PAGE] = allocate_pages(1);
+  return nth_pci_device(n_pci_devices++);
+}
+
+static inline uint32_t pci_read_config(uint16_t number, uint8_t reg) {
+  uint32_t cspace_addr = 0x80000000 | (number << 8) | (reg << 2);
+  outd(PCP_SELECT, cspace_addr);
+
+  return ind(PCP_READ);
+}
+
+void pci_device_check(uint16_t number) {
+  uint32_t id = pci_read_config(number, 0);
+  if ((id & 0xffff) == 0xffff)
+    return;
+
+  struct pci_device *next_device = next_pci_device();
+
+  next_device->number = number;
+
+  next_device->id_vendor = id;
+  next_device->id_device = id >> 16;
+
+  uint32_t class = pci_read_config(number, 2);
+
+  next_device->class = class >> 24;
+  next_device->subclass = class >> 16;
+  next_device->iface = class >> 8;
+
+  next_device->bar0 = pci_read_config(number, 4);
+  next_device->bar1 = pci_read_config(number, 5);
+  next_device->bar2 = pci_read_config(number, 6);
+  next_device->bar3 = pci_read_config(number, 7);
+}
+
+void pci_init() {
+  if (!(BOOT_INFO->support_flags & BIS_PCI))
+    panic("No PCI support detected.");
+  if (!(BOOT_INFO->pci_hw_char & PHC_CS_M1))
+    panic("No PCI Mechanism 1 support");
+
+  for (uint32_t number = 0; number < (BOOT_INFO->last_pci_bus + 1) * 256; ++number)
+    pci_device_check(number);
+}
\ No newline at end of file
diff --git a/src/kernel/pci.h b/src/kernel/pci.h
new file mode 100644
index 0000000..1ab5936
--- /dev/null
+++ b/src/kernel/pci.h
@@ -0,0 +1,38 @@
+#ifndef PCI_H
+#define PCI_H
+
+#include <stdint.h>
+
+enum {
+  PCI_MASS_STORAGE = 0x01
+};
+
+enum {
+  PCI_IDE = 0x01
+};
+
+struct pci_device {
+  uint16_t number;
+
+  uint16_t id_vendor;
+  uint16_t id_device;
+
+  uint8_t class;
+  uint8_t subclass;
+  uint8_t iface;
+
+  uint32_t bar0;
+  uint32_t bar1;
+  uint32_t bar2;
+  uint32_t bar3;
+  //etc
+};
+
+extern uint16_t n_pci_devices;
+struct pci_device *nth_pci_device(uint16_t n);
+
+struct pci_device *find_pci_device_from_class_and_subclass(uint8_t class, uint8_t subclass, uint16_t start, uint16_t *index);
+
+void pci_init();
+
+#endif
\ No newline at end of file
diff --git a/src/kernel/plef.c b/src/kernel/plef.c
new file mode 100644
index 0000000..2cba843
--- /dev/null
+++ b/src/kernel/plef.c
@@ -0,0 +1,33 @@
+#include <stdint.h>
+#include <stdbool.h>
+#include "plef.h"
+#include "drive.h"
+#include "util.h"
+#include "task.h"
+
+#define PLEF_MAGIC 0xb9ba4c50
+
+task_handle plef_run(struct drive *d, char *path) {
+  drive_file_id_t h = d->get_file(d, path);
+  if (!h)
+    return 0;
+
+  uint8_t start[512];
+  d->load_sector(d, h, 0, start);
+
+  struct plef_header head = *(struct plef_header *)start;
+  if ((head.magic != PLEF_MAGIC) || (head.version_high)) {
+    d->free_file(d, h);
+    return 0;
+  }
+
+  uint32_t payload_addr;
+  segment_id cs = new_segment(true, head.payload_length + head.bss_length, &payload_addr);
+  segment_id ds = mirror_segment(false, cs);
+
+  fmcpy((void *)payload_addr, d, h, head.payload_offset, head.payload_length);
+
+  d->free_file(d, h);
+
+  return new_task(cs, ds, head.entry_point, head.payload_length + head.bss_length);
+}
\ No newline at end of file
diff --git a/src/kernel/plef.h b/src/kernel/plef.h
new file mode 100644
index 0000000..29100ee
--- /dev/null
+++ b/src/kernel/plef.h
@@ -0,0 +1,22 @@
+#ifndef PLEF_H
+#define PLEF_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "drive.h"
+
+typedef uint8_t task_handle;
+
+struct plef_header {
+  uint32_t magic;
+  uint16_t version_low;
+  uint16_t version_high;
+  uint32_t payload_offset;
+  uint32_t payload_length;
+  uint32_t bss_length;
+  uint32_t entry_point;
+} __attribute__ ((packed));
+
+task_handle plef_run(struct drive *d, char *path);
+
+#endif
\ No newline at end of file
diff --git a/src/kernel/serial.c b/src/kernel/serial.c
index b88c7ec..0f7abe6 100644
--- a/src/kernel/serial.c
+++ b/src/kernel/serial.c
@@ -54,7 +54,7 @@ bool serr() {
   return error;
 }
 
-void sinit() {
+void init_serial() {
   error = false;
   outb(CP_1 | CP_INT, 0);
   outb(CP_1 | CP_LINE, CL_BAUD);
@@ -64,7 +64,7 @@ void sinit() {
   outb(CP_1 | CP_FIFO, 0xc7);//?
 }
 
-void sout(uint8_t b) {
+void sout(char b) {
   if (error)
     return;
   uint16_t s = SERIAL_SPIN_LIMIT;
@@ -73,28 +73,28 @@ void sout(uint8_t b) {
       error = true;
       return;
     }
-  outb(CP_1 | CP_DATA, b);
+  outb(CP_1 | CP_DATA, (uint8_t)b);
 }
 
-void soutsz(uint8_t *s) {
+void soutsz(char *s) {
   while (*s)
     sout(*(s++));
 }
 
-void soutsn(uint8_t *s, uint8_t n) {
+void soutsn(char *s, uint8_t n) {
   while (n--)
     sout(*(s++));
 }
 
-uint8_t sin() {
+char sin() {
   if (error)
     return 0;
   while (!(inb(CP_1 | CP_LINE_S) & CLS_READ))
     ;//spin
-  return inb(CP_1 | CP_DATA);
+  return (char)inb(CP_1 | CP_DATA);
 }
 
-void sinsn(uint8_t *s, uint8_t n) {
+void sinsn(char *s, uint8_t n) {
   while (n--)
     *(s++) = sin();
 }
\ No newline at end of file
diff --git a/src/kernel/serial.h b/src/kernel/serial.h
index f0465d0..bb12edb 100644
--- a/src/kernel/serial.h
+++ b/src/kernel/serial.h
@@ -1,10 +1,15 @@
+#ifndef SERIAL_H
+#define SERIAL_H
+
 #include <stdint.h>
 #include <stdbool.h>
 
 bool serr();
-void sinit();
-void sout(uint8_t b);
-void soutsz(uint8_t *s);
-void soutsn(uint8_t *s, uint8_t n);
-uint8_t sin();
-void sinsn(uint8_t *s, uint8_t n);
\ No newline at end of file
+void init_serial();
+void sout(char b);
+void soutsz(char *s);
+void soutsn(char *s, uint8_t n);
+char sin();
+void sinsn(char *s, uint8_t n);
+
+#endif
\ No newline at end of file
diff --git a/src/kernel/task.c b/src/kernel/task.c
new file mode 100644
index 0000000..c08a195
--- /dev/null
+++ b/src/kernel/task.c
@@ -0,0 +1,14 @@
+#include "task.h"
+#include "panic.h"
+
+segment_id new_segment(bool is_code, uint32_t length, uint32_t *location_out) {
+  panic("TODO: make new segment");
+}
+
+segment_id mirror_segment(bool is_code, segment_id other) {
+  panic("TODO: make new segment with same base and limit");
+}
+
+task_handle new_task(segment_id cs, segment_id ds, uint32_t eip, uint32_t esp) {
+  panic("TODO: add task to scheduler");
+}
\ No newline at end of file
diff --git a/src/kernel/task.h b/src/kernel/task.h
new file mode 100644
index 0000000..add668b
--- /dev/null
+++ b/src/kernel/task.h
@@ -0,0 +1,14 @@
+#ifndef TASK_H
+#define TASK_H
+
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef uint8_t segment_id;
+typedef uint8_t task_handle;
+
+segment_id new_segment(bool is_code, uint32_t length, uint32_t *location_out);
+segment_id mirror_segment(bool is_code, segment_id other);
+task_handle new_task(segment_id cs, segment_id ds, uint32_t eip, uint32_t esp);
+
+#endif
\ No newline at end of file
diff --git a/src/kernel/util.asm b/src/kernel/util.asm
deleted file mode 100644
index acac17f..0000000
--- a/src/kernel/util.asm
+++ /dev/null
@@ -1,37 +0,0 @@
-bits 32
-
-global outb
-global inb
-global outw
-global inw
-
-section .text
-outb:
-  ;word [esp + 4] = port
-  ;byte [esp + 8] = value
-  mov dx, word [esp + 4]
-  mov al, byte [esp + 8]
-  out dx, al
-  ret
-
-inb:
-  ;word [esp + 4] = port
-  ;al out = value
-  mov dx, word [esp + 4]
-  in al, dx
-  ret
-
-outw:
-  ;word [esp + 4] = port
-  ;word [esp + 8] = value
-  mov dx, word [esp + 4]
-  mov ax, word [esp + 8]
-  out dx, ax
-  ret
-
-inw:
-  ;word [esp + 4] = port
-  ;ax out = value
-  mov dx, word [esp + 4]
-  in ax, dx
-  ret
\ No newline at end of file
diff --git a/src/kernel/util.c b/src/kernel/util.c
index c7a5035..1531f83 100644
--- a/src/kernel/util.c
+++ b/src/kernel/util.c
@@ -1,6 +1,7 @@
 #include <stdint.h>
 #include "panic.h"
 #include <stdbool.h>
+#include "drive.h"
 
 void memcpy(void *to, void *from, uint32_t n) {
   uint32_t *tp = to, *fp = from;
@@ -13,9 +14,36 @@ void memcpy(void *to, void *from, uint32_t n) {
     *(tpp++) = *(fpp++);
 }
 
-void u32_dec(uint32_t n, uint8_t *b) {
+void fmcpy(void *to, struct drive *d, drive_file_id_t f, uint32_t from, uint32_t n) {
+  uint8_t buf[512];
+  d->load_sector(d, f, from >> 9, buf);
+  uint16_t from_low = from & 511;
+  if (!((from_low + n) & ~511)) {
+    memcpy(to, buf + from_low, n);
+    return;
+  }
+
+  uint32_t i = 512 - from_low;
+  memcpy(to, buf + from_low, i);
+
+  n -= i;
+  uint32_t fsi = (from + i) >> 9;
+
+  while (n & ~511) {
+    d->load_sector(d, f, fsi, buf);
+    memcpy(to + i, buf, 512);
+    i += 512;
+    n -= 512;
+    ++fsi;
+  }
+
+  d->load_sector(d, f, fsi, buf);
+  memcpy(to + i, buf, n);
+}
+
+void u32_dec(uint32_t n, char *b) {
   if (!n) {
-    *(uint16_t *)b = '0';
+    *(uint16_t *)b = (uint16_t)'0';
     return;
   }
   bool zero = false;
@@ -28,12 +56,12 @@ void u32_dec(uint32_t n, uint8_t *b) {
       *(b++) = d + '0';
     }
   }
-  *b = 0;
+  *b = '\0';
 }
 
-void u16_dec(uint16_t n, uint8_t *b) {
+void u16_dec(uint16_t n, char *b) {
   if (!n) {
-    *(uint16_t *)b = '0';
+    *(uint16_t *)b = (uint16_t)'0';
     return;
   }
   bool zero = false;
@@ -46,12 +74,12 @@ void u16_dec(uint16_t n, uint8_t *b) {
       *(b++) = d + '0';
     }
   }
-  *b = 0;
+  *b = '\0';
 }
 
-void u8_dec(uint8_t n, uint8_t *b) {
+void u8_dec(uint8_t n, char *b) {
   if (!n) {
-    *(uint16_t *)b = '0';
+    *(uint16_t *)b = (uint16_t)'0';
     return;
   }
   bool zero = false;
@@ -64,42 +92,42 @@ void u8_dec(uint8_t n, uint8_t *b) {
       *(b++) = d + '0';
     }
   }
-  *b = 0;
+  *b = '\0';
 }
 
-void u32_hex(uint32_t n, uint8_t *b) {
+void u32_hex(uint32_t n, char *b) {
   uint8_t m = 28;
   while (1) {
     uint8_t d = (n >> m) & 0xf;
     *(b++) = d >= 10 ? 'a' + d - 10 : '0' + d;
     if (!m) {
-      *b = 0;
+      *b = '\0';
       return;
     }
     m -= 4;
   }
 }
 
-void u16_hex(uint16_t n, uint8_t *b) {
+void u16_hex(uint16_t n, char *b) {
   uint8_t m = 12;
   while (1) {
     uint8_t d = (n >> m) & 0xf;
     *(b++) = d >= 10 ? 'a' + d - 10 : '0' + d;
     if (!m) {
-      *b = 0;
+      *b = '\0';
       return;
     }
     m -= 4;
   }
 }
 
-void u8_hex(uint8_t n, uint8_t *b) {
+void u8_hex(uint8_t n, char *b) {
   uint8_t m = 4;
   while (1) {
     uint8_t d = (n >> m) & 0xf;
     *(b++) = d >= 10 ? 'a' + d - 10 : '0' + d;
     if (!m) {
-      *b = 0;
+      *b = '\0';
       return;
     }
     m -= 4;
diff --git a/src/kernel/util.h b/src/kernel/util.h
index e02c819..243541c 100644
--- a/src/kernel/util.h
+++ b/src/kernel/util.h
@@ -1,13 +1,54 @@
+#ifndef UTIL_H
+#define UTIL_H
+
 #include <stdint.h>
+#include "drive.h"
+
+static inline void outb(uint16_t port, uint8_t value) {
+  asm (
+    "outb %0, %1"
+  : : "a"(value), "Nd"(port));
+}
+static inline uint8_t inb(uint16_t port) {
+  uint8_t value;
+  asm volatile (
+    "inb %1, %0"
+  : "=a"(value) : "Nd"(port));
+  return value;
+}
+static inline void outw(uint16_t port, uint16_t value) {
+  asm (
+    "outw %0, %1"
+  : : "a"(value), "Nd"(port));
+}
+static inline uint16_t inw(uint16_t port) {
+  uint16_t value;
+  asm volatile (
+    "inw %1, %0"
+  : "=a"(value) : "Nd"(port));
+  return value;
+}
+static inline void outd(uint16_t port, uint32_t value) {
+  asm (
+    "outl %0, %1"
+  : : "a"(value), "Nd"(port));
+}
+static inline uint32_t ind(uint16_t port) {
+  uint32_t value;
+  asm volatile (
+    "inl %1, %0"
+  : "=a"(value) : "Nd"(port));
+  return value;
+}
 
 void memcpy(void *to, void *from, uint32_t n);
-void outb(uint16_t port, uint8_t value);
-uint8_t inb(uint16_t port);
-void outw(uint16_t port, uint16_t value);
-uint16_t inw(uint16_t port);
-void u32_dec(uint32_t n, uint8_t *b);
-void u16_dec(uint16_t n, uint8_t *b);
-void u8_dec(uint8_t n, uint8_t *b);
-void u32_hex(uint32_t n, uint8_t *b);
-void u16_hex(uint16_t n, uint8_t *b);
-void u8_hex(uint8_t n, uint8_t *b);
\ No newline at end of file
+void fmcpy(void *to, struct drive *d, drive_file_id_t f, uint32_t from, uint32_t n);
+
+void u32_dec(uint32_t n, char *b);
+void u16_dec(uint16_t n, char *b);
+void u8_dec(uint8_t n, char *b);
+void u32_hex(uint32_t n, char *b);
+void u16_hex(uint16_t n, char *b);
+void u8_hex(uint8_t n, char *b);
+
+#endif
\ No newline at end of file
diff --git a/src/kernel/vesa.c b/src/kernel/vesa.c
new file mode 100644
index 0000000..e781249
--- /dev/null
+++ b/src/kernel/vesa.c
@@ -0,0 +1,5 @@
+#include "vesa.h"
+
+void init_vesa() {
+  
+}
\ No newline at end of file
diff --git a/src/kernel/vesa.h b/src/kernel/vesa.h
new file mode 100644
index 0000000..495b593
--- /dev/null
+++ b/src/kernel/vesa.h
@@ -0,0 +1,24 @@
+#ifndef VESA_H
+#define VESA_H
+
+struct video_mode {
+  //TODO
+};
+
+#define VESA_INFO \
+  ((struct { \
+    uint32_t sig; \
+    uint16_t vbe_ver; \
+    char *oem; \
+    uint32_t capabilities; \
+    struct video_mode *modes; \
+    uint16_t vram_size_high; \
+    uint16_t soft_ver; \
+    char *vendor; \
+    char *pname; \
+    char *prev; \
+  } *)0x4200)
+
+void init_vesa();
+
+#endif
\ No newline at end of file
diff --git a/src/kernel/vga.c b/src/kernel/vga.c
index c387b22..788ce6c 100644
--- a/src/kernel/vga.c
+++ b/src/kernel/vga.c
@@ -33,7 +33,7 @@ void vga_blank() {
   cursor = VGA_START;
 }
 
-void vga_printch(uint8_t ch) {
+void vga_printch(char ch) {
   if (ch == '\n') {
 #ifdef VGA_COM_MIRROR
     soutsz("\r\n");
@@ -45,17 +45,17 @@ void vga_printch(uint8_t ch) {
 #ifdef VGA_COM_MIRROR
   sout(ch);
 #endif
-  *(cursor++) = color | ch;
+  *(cursor++) = color | (uint8_t)ch;
   if (cursor == VGA_END)
     vga_scroll();
 }
 
-void vga_printsz(uint8_t *sz) {
+void vga_printsz(char *sz) {
   while (*sz)
     vga_printch(*(sz++));
 }
 
-void vga_printsn(uint8_t *sn, uint8_t n) {
+void vga_printsn(char *sn, uint8_t n) {
   while (n--)
     vga_printch(*(sn++));
 }
\ No newline at end of file
diff --git a/src/kernel/vga.h b/src/kernel/vga.h
index 1e041df..1be2131 100644
--- a/src/kernel/vga.h
+++ b/src/kernel/vga.h
@@ -1,8 +1,13 @@
+#ifndef VGA_H
+#define VGA_H
+
 #include <stdint.h>
 
 void vga_set_color(uint8_t color);
 void vga_blank();
 void vga_scroll();
-void vga_printch(uint8_t ch);
-void vga_printsz(uint8_t *sz);
-void vga_printsn(uint8_t *sn, uint8_t n);
\ No newline at end of file
+void vga_printch(char ch);
+void vga_printsz(char *sz);
+void vga_printsn(char *sn, uint8_t n);
+
+#endif
\ No newline at end of file