kamkow1/mop3
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Device IRQs WIP

Browse Source
This commit is contained in:
Kamil Kowalczyk
2026-03-12 19:23:47 +01:00
parent 04b7355a3d
commit 19793e9126
29 changed files with 420 additions and 187 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -5,3 +5,4 @@ bochs-com1.txt
mop3dist.tar
mop3dist.tar.lz4
site/
*.img

2
kernel/amd64/intr_defs.h
View File

@@ -2,6 +2,8 @@
#define _KERNEL_AMD64_INTR_DEFS_H
#define PS2KB 32
#define IDE_DRIVE_PRIM 33
#define IDE_DRIVE_SCND 34
#define SCHED_PREEMPT_TIMER 80
#define CPU_REQUEST_SCHED 82

6
kernel/amd64/intr_stub.S
View File

@@ -26,7 +26,8 @@
; \
movq %rsp, %rdi; \
; \
movq %cr3, %rax; pushq %rax; \
movq %cr3, %rax; \
pushq %rax; \
; \
movq %rsp, %rbp; \
; \
@@ -36,7 +37,8 @@
; \
movq %rbp, %rsp; \
; \
popq %rax; movq %rax, %cr3; \
popq %rax; \
movq %rax, %cr3; \
; \
pop_regs; \
addq $16, %rsp; \

6
kernel/amd64/syscallentry.S
View File

@@ -28,7 +28,8 @@ syscall_entry:
movq %rsp, %rdi
movq %cr3, %rax; pushq %rax
movq %cr3, %rax
pushq %rax
movq %rsp, %rbp
@@ -38,7 +39,8 @@ syscall_entry:
movq %rbp, %rsp
popq %rbx; movq %rbx, %cr3
popq %rbx
movq %rbx, %cr3
pop_regs_skip_rax

8
kernel/device/debugconsole.c
View File

@@ -6,12 +6,14 @@
#include <status.h>
#include <sys/debug.h>
bool debugconsole_init (struct device* device, void* arg) {
(void)device, (void)arg;
bool debugconsole_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx) {
(void)device, (void)arg, (void)proc, (void)rctx;
return true;
}
void debugconsole_fini (struct device* device) { (void)device; }
void debugconsole_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx) {
(void)device, (void)proc, (void)rctx;
}
int debugconsole_putstr (struct device* device, struct proc* proc, struct reschedule_ctx* rctx,
void* a1, void* a2, void* a3, void* a4) {

4
kernel/device/debugconsole.h
View File

@@ -7,9 +7,9 @@
struct device;
bool debugconsole_init (struct device* device, void* arg);
bool debugconsole_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx);
void debugconsole_fini (struct device* device);
void debugconsole_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx);
int debugconsole_putstr (struct device* device, struct proc* proc, struct reschedule_ctx* rctx,
void* a1, void* a2, void* a3, void* a4);

30
kernel/device/device.c
View File

@@ -49,7 +49,8 @@ struct device* device_find (const char* key) {
}
struct device* device_create (const char* key, device_op_func_t* ops, size_t ops_len,
device_init_func_t init, device_fini_func_t fini, void* arg) {
device_init_func_t init, device_fini_func_t fini, void* arg,
struct proc* proc, struct reschedule_ctx* rctx) {
if (ops_len >= fieldlengthof (struct device, ops))
return NULL;
@@ -67,7 +68,7 @@ struct device* device_create (const char* key, device_op_func_t* ops, size_t ops
if (ops != NULL)
memcpy (device->ops, ops, ops_len * sizeof (device_op_func_t));
if (!device->init (device, arg)) {
if (!device->init (device, arg, proc, rctx)) {
free (device);
return NULL;
}
@@ -87,21 +88,30 @@ struct device* device_create (const char* key, device_op_func_t* ops, size_t ops
}
static void debugconsole_device_init (void) {
struct reschedule_ctx rctx;
memset (&rctx, 0, sizeof (rctx));
device_op_func_t ops[] = {
[DEBUGCONSOLE_PUTSTR] = &debugconsole_putstr,
};
device_create ("DEBUGCONSOLE", ops, lengthof (ops), &debugconsole_init, &debugconsole_fini, NULL);
device_create ("DEBUGCONSOLE", ops, lengthof (ops), &debugconsole_init, &debugconsole_fini, NULL, thiscpu->kproc, &rctx);
}
static void terminal_device_init (void) {
struct reschedule_ctx rctx;
memset (&rctx, 0, sizeof (rctx));
device_op_func_t ops[] = {
[TERMINAL_PUTSTR] = &terminal_putstr,
[TERMINAL_DIMENSIONS] = &terminal_dimensions,
};
device_create ("TERMINAL", ops, lengthof (ops), &terminal_init, &terminal_fini, NULL);
device_create ("TERMINAL", ops, lengthof (ops), &terminal_init, &terminal_fini, NULL, thiscpu->kproc, &rctx);
}
static void ramdisk_device_init (void) {
struct reschedule_ctx rctx;
memset (&rctx, 0, sizeof (rctx));
device_op_func_t ops[] = {
[XDRV_GET_SIZE] = &ramdrv_get_size,
[XDRV_GET_SECTOR_SIZE] = &ramdrv_get_sector_size,
@@ -139,12 +149,15 @@ static void ramdisk_device_init (void) {
.sector_size = 512,
.buffer = unpack_buffer,
};
device_create ("RD0", ops, lengthof (ops), &ramdrv_init, &ramdrv_fini, &init);
device_create ("RD0", ops, lengthof (ops), &ramdrv_init, &ramdrv_fini, &init, thiscpu->kproc, &rctx);
LZ4F_freeDecompressionContext (dctx);
}
static void temp_device_init (void) {
struct reschedule_ctx rctx;
memset (&rctx, 0, sizeof (rctx));
device_op_func_t ops[] = {
[XDRV_GET_SIZE] = &ramdrv_get_size,
[XDRV_GET_SECTOR_SIZE] = &ramdrv_get_sector_size,
@@ -157,15 +170,18 @@ static void temp_device_init (void) {
.total_size = 1024 * 1024 * 20,
.sector_size = 512,
};
device_create ("TEMP0", ops, lengthof (ops), &ramdrv_init, &ramdrv_fini, &init);
device_create ("TEMP0", ops, lengthof (ops), &ramdrv_init, &ramdrv_fini, &init, thiscpu->kproc, &rctx);
}
#if defined(__x86_64__)
static void ps2kb_device_init (void) {
struct reschedule_ctx rctx;
memset (&rctx, 0, sizeof (rctx));
device_op_func_t ops[] = {
[KB_READ_KEY] = &ps2kb_read_key,
};
device_create ("KB", ops, lengthof (ops), &ps2kb_init, &ps2kb_fini, NULL);
device_create ("KB", ops, lengthof (ops), &ps2kb_init, &ps2kb_fini, NULL, thiscpu->kproc, &rctx);
}
#endif

7
kernel/device/device.h
View File

@@ -22,8 +22,8 @@ struct device;
typedef int (*device_op_func_t) (struct device* device, struct proc*, struct reschedule_ctx* rctx,
void* a1, void* a2, void* a3, void* a4);
typedef bool (*device_init_func_t) (struct device* device, void* arg);
typedef void (*device_fini_func_t) (struct device* device);
typedef bool (*device_init_func_t) (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx);
typedef void (*device_fini_func_t) (struct device* device, struct proc* proc, struct reschedule_ctx* rctx);
struct device {
char key[0x100];
@@ -36,7 +36,8 @@ struct device {
};
struct device* device_create (const char* key, device_op_func_t* ops, size_t ops_len,
device_init_func_t init, device_fini_func_t fini, void* arg);
device_init_func_t init, device_fini_func_t fini, void* arg,
struct proc* proc, struct reschedule_ctx* rctx);
struct device* device_find (const char* key);

211
kernel/device/idedrv.c
View File

@@ -1,13 +1,18 @@
#include <amd64/io.h>
#include <amd64/intr_defs.h>
#include <amd64/apic.h>
#include <device/device.h>
#include <device/idedrv.h>
#include <device/partitions.h>
#include <devices.h>
#include <libk/std.h>
#include <libk/list.h>
#include <libk/string.h>
#include <mm/liballoc.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
#include <status.h>
#include <irq/irq.h>
#define IDE_REG_DATA 0x00
#define IDE_REG_ERROR 0x01
@@ -78,6 +83,75 @@ static void ide_delay (uint16_t ctrl) {
}
#pragma clang optimize on
static void ide_flush (struct idedrv* idedrv) {
if (idedrv->lba48)
outb (idedrv->io + IDE_REG_CMD, IDE_CMD_FLUSH48);
else
outb (idedrv->io + IDE_REG_CMD, IDE_CMD_FLUSH28);
}
static void ide_irq (void* arg, void* regs, struct reschedule_ctx* rctx) {
struct idedrv* idedrv = arg;
spin_lock (&idedrv->device->lock);
struct list_node_link* node = idedrv->requests;
if (node == NULL) {
(void)inb (idedrv->io + IDE_REG_STATUS);
spin_unlock (&idedrv->device->lock);
return;
}
struct idedrv_request* req = list_entry (node, struct idedrv_request, requests_link);
struct list_node_link* sqlist_node = req->sq.proc_list;
struct proc_sq_entry* sq_entry = list_entry (sqlist_node, struct proc_sq_entry, sq_link);
struct proc* resumed_proc = sq_entry->proc;
uint8_t status = inb (idedrv->io + IDE_REG_STATUS);
if ((status & (IDE_ERR | IDE_DRQ))) {
list_remove (idedrv->requests, &req->requests_link);
spin_unlock (&idedrv->device->lock);
proc_sq_resume (resumed_proc, sq_entry, rctx);
free (req);
return;
}
spin_lock (&resumed_proc->lock);
if (req->rw == 1) {
if ((status & IDE_DRQ)) {
uint16_t* p = req->outbuffer + (req->sector_done_count * (idedrv->sector_size / 2));
insw (idedrv->io + IDE_REG_DATA, p, idedrv->sector_size / 2);
req->sector_done_count++;
}
} else if (req->rw == 2) {
req->sector_done_count++;
if (req->sector_done_count < req->sector_count) {
uint16_t* p = req->outbuffer + (req->sector_done_count * (idedrv->sector_size / 2));
outsw (idedrv->io + IDE_REG_DATA, p, idedrv->sector_size / 2);
}
}
if (req->sector_done_count >= req->sector_count) {
if (req->rw == 2)
ide_flush (idedrv);
list_remove (idedrv->requests, &req->requests_link);
spin_unlock (&resumed_proc->lock);
spin_unlock (&idedrv->device->lock);
free (req);
proc_sq_resume (resumed_proc, sq_entry, rctx);
return;
}
spin_unlock (&resumed_proc->lock);
spin_unlock (&idedrv->device->lock);
}
void ide_probe (uint16_t io, uint16_t ctrl, uint8_t devno, struct ide_probe* probe) {
probe->flags = 0;
probe->sector_count = 0;
@@ -141,7 +215,10 @@ void ide_probe (uint16_t io, uint16_t ctrl, uint8_t devno, struct ide_probe* pro
probe->sector_size = 512;
}
static void ide_prepare (struct idedrv* idedrv, size_t sector, uint16_t sector_count) {
static void ide_prepare (struct idedrv* idedrv, size_t sector, uint16_t sector_count, bool clear) {
if (clear)
outb (idedrv->ctrl, 0x00);
if (idedrv->lba48) {
outb (idedrv->io + IDE_REG_DRIVE, 0x40 | (idedrv->devno << 4));
ide_delay (idedrv->ctrl);
@@ -167,7 +244,9 @@ static void ide_prepare (struct idedrv* idedrv, size_t sector, uint16_t sector_c
}
}
bool idedrv_init (struct device* device, void* arg) {
bool idedrv_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx) {
(void)proc, (void)rctx;
struct idedrv_init* init = arg;
struct idedrv* idedrv = malloc (sizeof (*idedrv));
@@ -175,23 +254,41 @@ bool idedrv_init (struct device* device, void* arg) {
if (idedrv == NULL)
return false;
idedrv->device = device;
idedrv->lba48 = init->lba48;
idedrv->sector_count = init->sector_count;
idedrv->sector_size = init->sector_size;
idedrv->io = init->io;
idedrv->ctrl = init->ctrl;
idedrv->devno = init->devno;
idedrv->primscnd = init->primscnd;
device->udata = idedrv;
device_probe_partitions (device);
if (idedrv->primscnd == 1) {
ioapic_route_irq (IDE_DRIVE_PRIM, 14, 0, thiscpu->lapic_id);
irq_attach (&ide_irq, idedrv, IDE_DRIVE_PRIM);
} else if (idedrv->primscnd == 2) {
ioapic_route_irq (IDE_DRIVE_SCND, 15, 0, thiscpu->lapic_id);
irq_attach (&ide_irq, idedrv, IDE_DRIVE_SCND);
}
return true;
}
void idedrv_fini (struct device* device) {
void idedrv_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx) {
struct idedrv* idedrv = device->udata;
struct list_node_link* req_link, *tmp_req_link;
list_foreach (idedrv->requests, req_link, tmp_req_link) {
struct idedrv_request* req = list_entry (req_link, struct idedrv_request, requests_link);
list_remove (idedrv->requests, &req->requests_link);
struct proc_sq_entry* sq_entry = list_entry (req->sq.proc_list, struct proc_sq_entry, sq_link);
proc_sq_resume (proc, sq_entry, rctx);
free (req);
}
irq_detach (idedrv->primscnd == 1 ? IDE_DRIVE_PRIM : IDE_DRIVE_SCND);
free (idedrv);
}
@@ -211,20 +308,47 @@ int idedrv_read (struct device* device, struct proc* proc, struct reschedule_ctx
if (sector + sector_count > idedrv->sector_count)
return -ST_OOB_ERROR;
ide_prepare (idedrv, sector, sector_count);
spin_lock (&proc->lock);
bool is_kproc = (proc->flags & PROC_KPROC) != 0;
spin_unlock (&proc->lock);
uint8_t cmd = idedrv->lba48 ? IDE_CMD_READ48 : IDE_CMD_READ28;
outb (idedrv->io + IDE_REG_CMD, cmd);
/* /1* polling *1/ */
/* if (is_kproc) { */
ide_prepare (idedrv, sector, sector_count, false);
for (uint16_t s = 0; s < sector_count; s++) {
if (!ide_wait (idedrv->io, 100000, true, true))
return -ST_XDRV_READ_ERROR;
uint8_t cmd = idedrv->lba48 ? IDE_CMD_READ48 : IDE_CMD_READ28;
outb (idedrv->io + IDE_REG_CMD, cmd);
insw (idedrv->io + IDE_REG_DATA, buffer + (s * (idedrv->sector_size / 2)),
idedrv->sector_size / 2);
}
for (uint16_t s = 0; s < sector_count; s++) {
if (!ide_wait (idedrv->io, 100000, true, true))
return -ST_XDRV_READ_ERROR;
return ST_OK;
insw (idedrv->io + IDE_REG_DATA, buffer + (s * (idedrv->sector_size / 2)), (idedrv->sector_size / 2));
}
return ST_OK;
/* } else { /1* IRQ *1/ */
/* struct idedrv_request* req = malloc (sizeof (*req)); */
/* if (req == NULL) */
/* return -ST_OOM_ERROR; */
/* memset (req, 0, sizeof (*req)); */
/* req->outbuffer = buffer; */
/* req->sector_count = sector_count; */
/* req->sector_done_count = 0; */
/* req->rw = 1; */
/* list_append (idedrv->requests, &req->requests_link); */
/* proc_sq_suspend (proc, &req->sq, NULL, rctx); */
/* ide_prepare (idedrv, sector, sector_count, true); */
/* uint8_t cmd = idedrv->lba48 ? IDE_CMD_READ48 : IDE_CMD_READ28; */
/* outb (idedrv->io + IDE_REG_CMD, cmd); */
/* return ST_OK; */
/* } */
}
int idedrv_write (struct device* device, struct proc* proc, struct reschedule_ctx* rctx, void* a1,
@@ -242,25 +366,58 @@ int idedrv_write (struct device* device, struct proc* proc, struct reschedule_ct
if (sector + sector_count > idedrv->sector_count)
return -ST_OOB_ERROR;
spin_lock (&proc->lock);
bool is_kproc = (proc->flags & PROC_KPROC) != 0;
spin_unlock (&proc->lock);
ide_prepare (idedrv, sector, sector_count);
/* /1* polling *1/ */
/* if (is_kproc) { */
ide_prepare (idedrv, sector, sector_count, false);
uint8_t cmd = idedrv->lba48 ? IDE_CMD_WRITE48 : IDE_CMD_WRITE28;
outb (idedrv->io + IDE_REG_CMD, cmd);
uint8_t cmd = idedrv->lba48 ? IDE_CMD_WRITE48 : IDE_CMD_WRITE28;
outb (idedrv->io + IDE_REG_CMD, cmd);
for (uint16_t s = 0; s < sector_count; s++) {
if (!ide_wait (idedrv->io, 100000, true, true))
return -ST_XDRV_WRITE_ERROR;
for (uint16_t s = 0; s < sector_count; s++) {
if (!ide_wait (idedrv->io, 100000, true, true))
return -ST_XDRV_WRITE_ERROR;
outsw (idedrv->io + IDE_REG_DATA, buffer + (s * (idedrv->sector_size / 2)),
idedrv->sector_size / 2);
}
outsw (idedrv->io + IDE_REG_DATA, buffer + (s * (idedrv->sector_size / 2)), (idedrv->sector_size / 2));
}
cmd = idedrv->lba48 ? IDE_CMD_FLUSH48 : IDE_CMD_FLUSH28;
outb (idedrv->io + IDE_REG_CMD, cmd);
ide_wait (idedrv->io, 100000, false, true);
return ST_OK;
/* } else { /1* IRQ *1/ */
/* struct idedrv_request* req = malloc (sizeof (*req)); */
return ST_OK;
/* if (req == NULL) */
/* return -ST_OOM_ERROR; */
/* memset (req, 0, sizeof (*req)); */
/* req->outbuffer = buffer; */
/* req->sector_count = sector_count; */
/* req->sector_done_count = 0; */
/* req->rw = 2; */
/* list_append (idedrv->requests, &req->requests_link); */
/* proc_sq_suspend (proc, &req->sq, NULL, rctx); */
/* ide_prepare (idedrv, sector, sector_count, true); */
/* uint8_t cmd = idedrv->lba48 ? IDE_CMD_WRITE48 : IDE_CMD_WRITE28; */
/* outb (idedrv->io + IDE_REG_CMD, cmd); */
/* if (!ide_wait (idedrv->io, 100000, true, true)) { */
/* list_remove (idedrv->requests, &req->requests_link); */
/* struct proc_sq_entry* sq_entry = list_entry (req->sq.proc_list, struct proc_sq_entry, sq_link); */
/* proc_sq_resume (proc, sq_entry, rctx); */
/* free (req); */
/* return -ST_XDRV_WRITE_ERROR; */
/* } */
/* outsw (idedrv->io + IDE_REG_DATA, buffer, idedrv->sector_size / 2); */
/* return ST_OK; */
/* } */
}
int idedrv_get_device_type (struct device* device, struct proc* proc, struct reschedule_ctx* rctx,

22
kernel/device/idedrv.h
View File

@@ -2,8 +2,11 @@
#define _KERNEL_DEVICE_IDEDRV_H
#include <libk/std.h>
#include <libk/list.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
#include <proc/suspension_q.h>
#include <sync/spin_lock.h>
#define IDE_PROBE_AVAIL (1 << 0)
#define IDE_PROBE_LBA48 (1 << 1)
@@ -16,14 +19,28 @@ struct idedrv_init {
size_t sector_size;
uint16_t io, ctrl;
uint8_t devno;
uint8_t primscnd;
};
struct idedrv_request {
uint16_t* outbuffer;
size_t sector_done_count;
size_t sector_count;
struct list_node_link requests_link;
struct proc_suspension_q sq;
int rw;
};
struct idedrv {
struct device* device;
bool lba48;
size_t sector_count;
size_t sector_size;
uint16_t io, ctrl;
uint8_t devno;
uint8_t primscnd;
struct list_node_link* requests;
};
struct ide_probe {
@@ -32,11 +49,12 @@ struct ide_probe {
size_t sector_size;
uint16_t io, ctrl;
uint8_t devno;
uint8_t primscnd;
};
bool idedrv_init (struct device* device, void* arg);
bool idedrv_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx);
void idedrv_fini (struct device* device);
void idedrv_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx);
int idedrv_read (struct device* device, struct proc* proc, struct reschedule_ctx* rctx, void* a1,
void* a2, void* a3, void* a4);

13
kernel/device/partdrv.c
View File

@@ -7,7 +7,9 @@
#include <proc/reschedule.h>
#include <status.h>
bool partdrv_init (struct device* device, void* arg) {
bool partdrv_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx) {
(void)proc, (void)rctx;
struct partdrv_init* init = arg;
struct partdrv* partdrv = malloc (sizeof (*partdrv));
@@ -24,7 +26,8 @@ bool partdrv_init (struct device* device, void* arg) {
return true;
}
void partdrv_fini (struct device* device) {
void partdrv_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx) {
(void)proc, (void)rctx;
struct partdrv* partdrv = device->udata;
free (partdrv);
@@ -45,7 +48,7 @@ int partdrv_read (struct device* device, struct proc* proc, struct reschedule_ct
uint8_t* buffer = a3;
spin_lock (&super->lock);
int ret = device_op (super, XDRV_READ, NULL, NULL, &sector, &sector_count, buffer);
int ret = device_op (super, XDRV_READ, proc, rctx, &sector, &sector_count, buffer);
spin_unlock (&super->lock);
return ret;
@@ -66,7 +69,7 @@ int partdrv_write (struct device* device, struct proc* proc, struct reschedule_c
uint8_t* buffer = a3;
spin_lock (&super->lock);
int ret = device_op (super, XDRV_WRITE, NULL, NULL, &sector, &sector_count, buffer);
int ret = device_op (super, XDRV_WRITE, proc, rctx, &sector, &sector_count, buffer);
spin_unlock (&super->lock);
return ret;
@@ -98,7 +101,7 @@ int partdrv_get_sector_size (struct device* device, struct proc* proc, struct re
struct partdrv* partdrv = device->udata;
spin_lock (&partdrv->super->lock);
device_op (partdrv->super, XDRV_GET_SECTOR_SIZE, NULL, NULL, secsize);
device_op (partdrv->super, XDRV_GET_SECTOR_SIZE, proc, rctx, secsize);
spin_unlock (&partdrv->super->lock);
return ST_OK;

4
kernel/device/partdrv.h
View File

@@ -19,9 +19,9 @@ struct partdrv {
size_t total_size;
};
bool partdrv_init (struct device* device, void* arg);
bool partdrv_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx);
void partdrv_fini (struct device* device);
void partdrv_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx);
int partdrv_read (struct device* device, struct proc* proc, struct reschedule_ctx* rctx, void* a1,
void* a2, void* a3, void* a4);

12
kernel/device/partitions.c
View File

@@ -9,8 +9,10 @@
#include <libk/string.h>
#include <status.h>
#include <sys/debug.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
static int device_probe_partitions_dos (struct device* device) {
static int device_probe_partitions_dos (struct proc* proc, struct reschedule_ctx* rctx, struct device* device) {
struct dos_mbr mbr;
memset (&mbr, 0, sizeof (mbr));
size_t sector = 0;
@@ -27,9 +29,9 @@ static int device_probe_partitions_dos (struct device* device) {
spin_lock (&device->lock);
device_op (device, XDRV_GET_SECTOR_SIZE, NULL, NULL, &sector_size);
device_op (device, XDRV_GET_SECTOR_SIZE, proc, rctx, &sector_size);
int ret = device_op (device, XDRV_READ, NULL, NULL, &sector, &sector_count, &mbr);
int ret = device_op (device, XDRV_READ, proc, rctx, &sector, &sector_count, &mbr);
if (ret < 0) {
spin_unlock (&device->lock);
@@ -54,7 +56,7 @@ static int device_probe_partitions_dos (struct device* device) {
memset (key, 0, sizeof (key));
snprintf (key, sizeof (key), "%sp%zu", device->key, i);
device_create (key, ops, lengthof (ops), &partdrv_init, &partdrv_fini, &init);
device_create (key, ops, lengthof (ops), &partdrv_init, &partdrv_fini, &init, proc, rctx);
}
spin_unlock (&device->lock);
@@ -62,4 +64,4 @@ static int device_probe_partitions_dos (struct device* device) {
return ST_OK;
}
int device_probe_partitions (struct device* device) { return device_probe_partitions_dos (device); }
int device_probe_partitions (struct proc* proc, struct reschedule_ctx* rctx, struct device* device) { return device_probe_partitions_dos (proc, rctx, device); }

4
kernel/device/partitions.h
View File

@@ -4,6 +4,8 @@
#include <aux/compiler.h>
#include <device/device.h>
#include <libk/std.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
struct dos_pte {
uint8_t drive_attrs;
@@ -22,6 +24,6 @@ struct dos_mbr {
uint8_t valid_sign[2];
} PACKED;
int device_probe_partitions (struct device* device);
int device_probe_partitions (struct proc* proc, struct reschedule_ctx* rctx, struct device* device);
#endif // _KERNEL_DEVICE_PARTITIONS_H

37
kernel/device/pci.c
View File

@@ -4,8 +4,10 @@
#include <device/pci_info.h>
#include <libk/lengthof.h>
#include <libk/std.h>
#include <libk/string.h>
#include <sync/spin_lock.h>
#include <sys/debug.h>
#include <sys/smp.h>
static const struct pci_driver_info pci_driver_infos[] = {
{.class = 0x01, .subclass = 0x01, .init = &pci_ide_init},
@@ -91,9 +93,9 @@ void pci_write8 (uint8_t bus, uint8_t slot, uint8_t func, uint8_t offset, uint8_
spin_unlock (&pci_lock);
}
static void pci_check_bus (uint8_t bus, pci_cb_func_t cb);
static void pci_check_bus (struct proc* proc, struct reschedule_ctx* rctx, uint8_t bus, pci_cb_func_t cb);
static void pci_check_func (uint8_t bus, uint8_t slot, uint8_t func, pci_cb_func_t cb) {
static void pci_check_func (struct proc* proc, struct reschedule_ctx* rctx, uint8_t bus, uint8_t slot, uint8_t func, pci_cb_func_t cb) {
uint32_t reg0 = pci_read32 (bus, slot, func, PCI_VENDOR_ID);
uint16_t vendor = (uint16_t)(reg0 & 0xFFFF);
@@ -112,47 +114,47 @@ static void pci_check_func (uint8_t bus, uint8_t slot, uint8_t func, pci_cb_func
.subclass = ((uint8_t)(reg8 >> 16)),
};
cb (pci_info);
cb (proc, rctx, pci_info);
/* PCI 2 PCI bridge */
if (pci_info.class == 0x06 && pci_info.subclass == 0x04) {
uint32_t reg18 = pci_read32 (bus, slot, func, 0x18);
uint8_t secondary = (uint8_t)(reg18 >> 8);
pci_check_bus (secondary, cb);
pci_check_bus (proc, rctx, secondary, cb);
}
}
static void pci_check_device (uint8_t bus, uint8_t slot, pci_cb_func_t cb) {
static void pci_check_device (struct proc* proc, struct reschedule_ctx* rctx, uint8_t bus, uint8_t slot, pci_cb_func_t cb) {
uint32_t reg0 = pci_read32 (bus, slot, 0, PCI_VENDOR_ID);
if ((uint16_t)(reg0 & 0xFFFF) == 0xFFFF)
return;
pci_check_func (bus, slot, 0, cb);
pci_check_func (proc, rctx, bus, slot, 0, cb);
/* multifunc device */
uint32_t reg0xc = pci_read32 (bus, slot, 0, PCI_CACHELINE);
if ((reg0xc >> 16) & 0x80) {
for (uint8_t func = 1; func < 8; func++)
pci_check_func (bus, slot, func, cb);
pci_check_func (proc, rctx, bus, slot, func, cb);
}
}
static void pci_check_bus (uint8_t bus, pci_cb_func_t cb) {
static void pci_check_bus (struct proc* proc, struct reschedule_ctx* rctx, uint8_t bus, pci_cb_func_t cb) {
for (uint8_t slot = 0; slot < 32; slot++)
pci_check_device (bus, slot, cb);
pci_check_device (proc, rctx, bus, slot, cb);
}
static void pci_enumerate (pci_cb_func_t cb) {
static void pci_enumerate (struct proc* proc, struct reschedule_ctx* rctx, pci_cb_func_t cb) {
uint32_t reg0xc = pci_read32 (0, 0, 0, PCI_CACHELINE);
bool is_multictrl = (reg0xc >> 16) & 0x80;
if (!is_multictrl)
pci_check_bus (0, cb);
pci_check_bus (proc, rctx, 0, cb);
else {
for (uint8_t func = 0; func < 8; func++) {
if ((pci_read32 (0, 0, func, PCI_VENDOR_ID) & 0xFFFF) != 0xFFFF)
pci_check_bus (func, cb);
pci_check_bus (proc, rctx, func, cb);
}
}
}
@@ -186,7 +188,7 @@ static void pci_string_identifiers (uint16_t vendor_id, uint16_t device_id, uint
}
}
static void pci_discovery_cb (struct pci_info pci_info) {
static void pci_discovery_cb (struct proc* proc, struct reschedule_ctx* rctx, struct pci_info pci_info) {
const char *vname, *dname, *cname;
pci_string_identifiers (pci_info.vendor, pci_info.device, pci_info.class, pci_info.subclass,
&vname, &dname, &cname);
@@ -198,9 +200,14 @@ static void pci_discovery_cb (struct pci_info pci_info) {
for (size_t driver = 0; driver < lengthof (pci_driver_infos); driver++) {
if (pci_driver_infos[driver].class == pci_info.class &&
pci_driver_infos[driver].subclass == pci_info.subclass) {
pci_driver_infos[driver].init (pci_info);
pci_driver_infos[driver].init (proc, rctx, pci_info);
}
}
}
void pci_init (void) { pci_enumerate (&pci_discovery_cb); }
void pci_init (void) {
struct reschedule_ctx rctx;
memset (&rctx, 0, sizeof (rctx));
pci_enumerate (thiscpu->kproc, &rctx, &pci_discovery_cb);
}

6
kernel/device/pci.h
View File

@@ -3,6 +3,8 @@
#include <device/pci_info.h>
#include <libk/std.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
#define PCI_CONFIG_ADDR 0xCF8
#define PCI_CONFIG_DATA 0xCFC
@@ -53,10 +55,10 @@ struct pci_class {
struct pci_driver_info {
uint8_t class;
uint8_t subclass;
bool (*init) (struct pci_info pci_info);
bool (*init) (struct proc* proc, struct reschedule_ctx* rctx, struct pci_info pci_info);
};
typedef void (*pci_cb_func_t) (struct pci_info pci_info);
typedef void (*pci_cb_func_t) (struct proc* proc, struct reschedule_ctx* rctx, struct pci_info pci_info);
void pci_init (void);

17
kernel/device/pci_ide.c
View File

@@ -3,12 +3,15 @@
#include <device/idedrv.h>
#include <device/pci.h>
#include <device/pci_info.h>
#include <device/partitions.h>
#include <devices.h>
#include <libk/fieldsizeof.h>
#include <libk/lengthof.h>
#include <libk/printf.h>
#include <libk/std.h>
#include <sys/debug.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
static atomic_int ide_counter = 0;
@@ -27,7 +30,7 @@ static const char* progif_msg[] = {
"PCI native mode controller, supports both channels switched to ISA compatibility mode, supports bus mastering",
};
static void ide_make_device (struct ide_probe probe) {
static void ide_make_device (struct proc* proc, struct reschedule_ctx* rctx, struct ide_probe probe) {
DEBUG ("Found IDE drive: io=%x ctrl=%x no=%u sector=%zu count=%zu\n", probe.io, probe.ctrl,
probe.devno, probe.sector_size, probe.sector_count);
@@ -49,14 +52,16 @@ static void ide_make_device (struct ide_probe probe) {
.io = probe.io,
.ctrl = probe.ctrl,
.devno = probe.devno,
.primscnd = probe.primscnd,
};
device_create (device_key, ops, lengthof (ops), &idedrv_init, &idedrv_fini, &init);
struct device* ide = device_create (device_key, ops, lengthof (ops), &idedrv_init, &idedrv_fini, &init, proc, rctx);
device_probe_partitions (proc, rctx, ide);
}
bool pci_ide_init (struct pci_info pci_info) {
bool pci_ide_init (struct proc* proc, struct reschedule_ctx* rctx, struct pci_info pci_info) {
uint16_t pci_cmd = pci_read16 (pci_info.bus, pci_info.slot, pci_info.func, PCI_COMMAND);
uint16_t new_cmd = pci_cmd | (1 << 0);
uint16_t new_cmd = (pci_cmd | (1 << 0)) & ~(1 << 10);
if (pci_cmd != new_cmd) {
pci_write16 (pci_info.bus, pci_info.slot, pci_info.func, PCI_COMMAND, new_cmd);
@@ -116,11 +121,13 @@ bool pci_ide_init (struct pci_info pci_info) {
if (cmd == 0)
continue;
probe.primscnd = i + 1;
for (size_t dev = 0; dev < 2; dev++) {
ide_probe (cmd, ctrl, dev, &probe);
if ((probe.flags & IDE_PROBE_AVAIL))
ide_make_device (probe);
ide_make_device (proc, rctx, probe);
}
}

4
kernel/device/pci_ide.h
View File

@@ -3,7 +3,9 @@
#include <device/pci_info.h>
#include <libk/std.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
bool pci_ide_init (struct pci_info pci_info);
bool pci_ide_init (struct proc* proc, struct reschedule_ctx* rctx, struct pci_info pci_info);
#endif // _KERNEL_DEVICE_PCI_IDE_H

8
kernel/device/ps2_kb.c
View File

@@ -229,8 +229,8 @@ static void ps2kb_set_typematic (uint8_t delay, uint8_t rate) {
outb (KB_DATA, (delay << 5) | (rate & 0x1F));
}
bool ps2kb_init (struct device* device, void* arg) {
(void)device, (void)arg;
bool ps2kb_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx) {
(void)device, (void)arg, (void)proc, (void)rctx;
ioapic_route_irq (PS2KB, 1, 0, thiscpu->lapic_id);
irq_attach (&ps2kb_irq, NULL, PS2KB);
@@ -255,8 +255,8 @@ bool ps2kb_init (struct device* device, void* arg) {
return true;
}
void ps2kb_fini (struct device* device) {
(void)device;
void ps2kb_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx) {
(void)device, (void)proc, (void)rctx;
irq_detach (PS2KB);
ringbuffer_fini (&ps2kb_ringbuffer);

4
kernel/device/ps2_kb.h
View File

@@ -11,8 +11,8 @@ struct device;
int ps2kb_read_key (struct device* device, struct proc* proc, struct reschedule_ctx* rctx, void* a1,
void* a2, void* a3, void* a4);
bool ps2kb_init (struct device* device, void* arg);
bool ps2kb_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx);
void ps2kb_fini (struct device* device);
void ps2kb_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx);
#endif // _KERNEL_DEVICE_PS2_KB_H

7
kernel/device/ramdrv.c
View File

@@ -9,7 +9,8 @@
#include <status.h>
#include <sys/debug.h>
bool ramdrv_init (struct device* device, void* arg) {
bool ramdrv_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx) {
(void)proc, (void)rctx;
struct ramdrv_init* init = arg;
struct ramdrv* ramdrv = malloc (sizeof (*ramdrv));
@@ -37,7 +38,9 @@ bool ramdrv_init (struct device* device, void* arg) {
return true;
}
void ramdrv_fini (struct device* device) {
void ramdrv_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx) {
(void)proc, (void)rctx;
struct ramdrv* ramdrv = device->udata;
free (ramdrv->buffer);

4
kernel/device/ramdrv.h
View File

@@ -20,9 +20,9 @@ struct ramdrv {
uint8_t* buffer;
};
bool ramdrv_init (struct device* device, void* arg);
bool ramdrv_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx);
void ramdrv_fini (struct device* device);
void ramdrv_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx);
int ramdrv_read (struct device* device, struct proc* proc, struct reschedule_ctx* rctx, void* a1,
void* a2, void* a3, void* a4);

8
kernel/device/terminal.c
View File

@@ -19,8 +19,8 @@ void ft_free (void* ptr, size_t size) {
free (ptr);
}
bool terminal_init (struct device* device, void* arg) {
(void)arg, (void)device;
bool terminal_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx) {
(void)arg, (void)device, (void)proc, (void)rctx;
struct limine_framebuffer_response* fb_r = limine_framebuffer_request.response;
struct limine_framebuffer* fb = fb_r->framebuffers[0];
@@ -33,7 +33,9 @@ bool terminal_init (struct device* device, void* arg) {
return true;
}
void terminal_fini (struct device* device) { (void)device; }
void terminal_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx) {
(void)device, (void)proc, (void)rctx;
}
int terminal_putstr (struct device* device, struct proc* proc, struct reschedule_ctx* rctx,
void* a1, void* a2, void* a3, void* a4) {

4
kernel/device/terminal.h
View File

@@ -8,9 +8,9 @@
struct device;
bool terminal_init (struct device* device, void* arg);
bool terminal_init (struct device* device, void* arg, struct proc* proc, struct reschedule_ctx* rctx);
void terminal_fini (struct device* device);
void terminal_fini (struct device* device, struct proc* proc, struct reschedule_ctx* rctx);
int terminal_putstr (struct device* device, struct proc* proc, struct reschedule_ctx* rctx,
void* a1, void* a2, void* a3, void* a4);

78
kernel/fs/fat1.c
View File

@@ -1,7 +1,19 @@
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter"
#pragma clang diagnostic ignored "-Wmacro-redefined"
#include <fs/fat1.h>
#include <fs/fatfs_ctx.h>
#include <proc/proc.h>
#include <proc/reschedule.h>
static int media_write (struct fatfs* _fs, struct fatfs_ctx* ctx, size_t sector, uint8_t* buffer, size_t sector_count) {
return _fs->disk_io.write_media (ctx, sector, buffer, sector_count);
}
static int media_read (struct fatfs* _fs, struct fatfs_ctx* ctx, size_t sector, uint8_t* buffer, size_t sector_count) {
return _fs->disk_io.read_media (ctx, sector, buffer, sector_count);
}
#define _KERNEL_LIBK_STRING_H
#define _KERNEL_LIBK_STD_H
@@ -225,14 +237,6 @@ typedef __WCHAR_TYPE__ wchar_t;
#define NULL ((void*)0)
#undef offsetof
#define offsetof(s, m) __builtin_offsetof (s, m)
typedef enum memory_order {
memory_order_relaxed = __ATOMIC_RELAXED,
memory_order_consume = __ATOMIC_CONSUME,
memory_order_acquire = __ATOMIC_ACQUIRE,
memory_order_release = __ATOMIC_RELEASE,
memory_order_acq_rel = __ATOMIC_ACQ_REL,
memory_order_seq_cst = __ATOMIC_SEQ_CST
} memory_order;
typedef _Atomic (_Bool) atomic_bool;
typedef _Atomic (char) atomic_char;
typedef _Atomic (signed char) atomic_schar;
@@ -270,9 +274,6 @@ typedef _Atomic (size_t) atomic_size_t;
typedef _Atomic (ptrdiff_t) atomic_ptrdiff_t;
typedef _Atomic (intmax_t) atomic_intmax_t;
typedef _Atomic (uintmax_t) atomic_uintmax_t;
typedef struct atomic_flag {
atomic_bool _Value;
} atomic_flag;
#define ATOMIC_FLAG_INIT ((atomic_flag){0})
#define atomic_store(object, desired) __c11_atomic_store (object, desired, __ATOMIC_SEQ_CST)
#define atomic_store_explicit __c11_atomic_store
@@ -813,7 +814,7 @@ static int fatfs_fat_writeback (struct fatfs_ctx* ctx, struct fatfs* fs, struct
sectors = FAT_BUFFER_SECTORS;
else
sectors = fs->fat_sectors - offset;
if (!fs->disk_io.write_media (ctx, pcur->address, pcur->sector, sectors))
if (!media_write (fs, ctx, pcur->address, pcur->sector, sectors))
return 0;
}
pcur->dirty = 0;
@@ -849,7 +850,7 @@ static struct fat_buffer* fatfs_fat_read_sector (struct fatfs_ctx* ctx, struct f
if (!fatfs_fat_writeback (ctx, fs, pcur))
return 0;
pcur->address = sector;
if (!fs->disk_io.read_media (ctx, pcur->address, pcur->sector, FAT_BUFFER_SECTORS)) {
if (!media_read (fs, ctx, pcur->address, pcur->sector, FAT_BUFFER_SECTORS)) {
pcur->address = FAT32_INVALID_CLUSTER;
return NULL;
}
@@ -904,7 +905,7 @@ void fatfs_set_fs_info_next_free_cluster (struct fatfs_ctx* ctx, struct fatfs* f
FAT32_SET_32BIT_WORD (pbuf, 492, newValue);
fs->next_free_cluster = newValue;
if (fs->disk_io.write_media)
fs->disk_io.write_media (ctx, pbuf->address, pbuf->sector, 1);
media_write (fs, ctx, pbuf->address, pbuf->sector, 1);
pbuf->address = FAT32_INVALID_CLUSTER;
pbuf->dirty = 0;
}
@@ -1180,8 +1181,7 @@ int fatfs_add_file_entry (struct fatfs_ctx* ctx, struct fatfs* fs, uint32 dirClu
if (entryCount == 0) {
fatfs_sfn_create_entry (shortfilename, size, startCluster, &shortEntry, dir);
memcpy (&fs->currentsector.sector[recordoffset], &shortEntry, sizeof (shortEntry));
return fs->disk_io.write_media (ctx, fs->currentsector.address,
fs->currentsector.sector, 1);
return media_write (fs, ctx, fs->currentsector.address, fs->currentsector.sector, 1);
} else {
entryCount--;
fatfs_filename_to_lfn (filename, &fs->currentsector.sector[recordoffset], entryCount,
@@ -1191,7 +1191,7 @@ int fatfs_add_file_entry (struct fatfs_ctx* ctx, struct fatfs* fs, uint32 dirClu
}
}
if (dirtySector) {
if (!fs->disk_io.write_media (ctx, fs->currentsector.address, fs->currentsector.sector, 1))
if (!media_write (fs, ctx, fs->currentsector.address, fs->currentsector.sector, 1))
return 0;
dirtySector = 0;
}
@@ -1215,7 +1215,7 @@ int fatfs_init (struct fatfs_ctx* ctx, struct fatfs* fs) {
fatfs_fat_init (fs);
if (!fs->disk_io.read_media)
return FAT_INIT_MEDIA_ACCESS_ERROR;
if (!fs->disk_io.read_media (ctx, 0, fs->currentsector.sector, 1))
if (!media_read (fs, ctx, 0, fs->currentsector.sector, 1))
return FAT_INIT_MEDIA_ACCESS_ERROR;
if (fs->currentsector.sector[SIGNATURE_POSITION] != 0x55 ||
fs->currentsector.sector[SIGNATURE_POSITION + 1] != 0xAA)
@@ -1245,7 +1245,7 @@ int fatfs_init (struct fatfs_ctx* ctx, struct fatfs* fs) {
fs->lba_begin = GET_32BIT_WORD (fs->currentsector.sector, PARTITION1_LBA_BEGIN_LOCATION);
else
fs->lba_begin = 0;
if (!fs->disk_io.read_media (ctx, fs->lba_begin, fs->currentsector.sector, 1))
if (!media_read (fs, ctx, fs->lba_begin, fs->currentsector.sector, 1))
return FAT_INIT_MEDIA_ACCESS_ERROR;
if (GET_16BIT_WORD (fs->currentsector.sector, 0x0B) != FAT_SECTOR_SIZE)
return FAT_INIT_INVALID_SECTOR_SIZE;
@@ -1303,11 +1303,11 @@ uint32 fatfs_lba_of_cluster (struct fatfs* fs, uint32 Cluster_Number) {
}
int fatfs_sector_read (struct fatfs_ctx* ctx, struct fatfs* fs, uint32 lba, uint8* target,
uint32 count) {
return fs->disk_io.read_media (ctx, lba, target, count);
return media_read (fs, ctx, lba, target, count);
}
int fatfs_sector_write (struct fatfs_ctx* ctx, struct fatfs* fs, uint32 lba, uint8* target,
uint32 count) {
return fs->disk_io.write_media (ctx, lba, target, count);
return media_write (fs, ctx, lba, target, count);
}
int fatfs_sector_reader (struct fatfs_ctx* ctx, struct fatfs* fs, uint32 start_cluster,
uint32 offset, uint8* target) {
@@ -1332,10 +1332,10 @@ int fatfs_sector_reader (struct fatfs_ctx* ctx, struct fatfs* fs, uint32 start_c
lba = fatfs_lba_of_cluster (fs, cluster_chain) + sector_to_read;
}
if (target)
return fs->disk_io.read_media (ctx, lba, target, 1);
return media_read (fs, ctx, lba, target, 1);
else if (lba != fs->currentsector.address) {
fs->currentsector.address = lba;
return fs->disk_io.read_media (ctx, fs->currentsector.address, fs->currentsector.sector, 1);
return media_read (fs, ctx, fs->currentsector.address, fs->currentsector.sector, 1);
} else
return 1;
}
@@ -1348,18 +1348,18 @@ int fatfs_read_sector (struct fatfs_ctx* ctx, struct fatfs* fs, uint32 cluster,
else
return 0;
if (target) {
return fs->disk_io.read_media (ctx, lba, target, 1);
return media_read (fs, ctx, lba, target, 1);
} else {
fs->currentsector.address = lba;
return fs->disk_io.read_media (ctx, fs->currentsector.address, fs->currentsector.sector, 1);
return media_read (fs, ctx, fs->currentsector.address, fs->currentsector.sector, 1);
}
} else {
if (target) {
uint32 lba = fatfs_lba_of_cluster (fs, cluster) + sector;
return fs->disk_io.read_media (ctx, lba, target, 1);
return media_read (fs, ctx, lba, target, 1);
} else {
fs->currentsector.address = fatfs_lba_of_cluster (fs, cluster) + sector;
return fs->disk_io.read_media (ctx, fs->currentsector.address, fs->currentsector.sector, 1);
return media_read (fs, ctx, fs->currentsector.address, fs->currentsector.sector, 1);
}
}
}
@@ -1374,18 +1374,18 @@ int fatfs_write_sector (struct fatfs_ctx* ctx, struct fatfs* fs, uint32 cluster,
else
return 0;
if (target) {
return fs->disk_io.write_media (ctx, lba, target, 1);
return media_write (fs, ctx, lba, target, 1);
} else {
fs->currentsector.address = lba;
return fs->disk_io.write_media (ctx, fs->currentsector.address, fs->currentsector.sector, 1);
return media_write (fs, ctx, fs->currentsector.address, fs->currentsector.sector, 1);
}
} else {
if (target) {
uint32 lba = fatfs_lba_of_cluster (fs, cluster) + sector;
return fs->disk_io.write_media (ctx, lba, target, 1);
return media_write (fs, ctx, lba, target, 1);
} else {
fs->currentsector.address = fatfs_lba_of_cluster (fs, cluster) + sector;
return fs->disk_io.write_media (ctx, fs->currentsector.address, fs->currentsector.sector, 1);
return media_write (fs, ctx, fs->currentsector.address, fs->currentsector.sector, 1);
}
}
}
@@ -1501,8 +1501,7 @@ int fatfs_update_file_length (struct fatfs_ctx* ctx, struct fatfs* fs, uint32 Cl
directoryEntry->FileSize = FAT_HTONL (fileLength);
memcpy ((uint8*)(fs->currentsector.sector + recordoffset), (uint8*)directoryEntry,
sizeof (struct fat_dir_entry));
return fs->disk_io.write_media (ctx, fs->currentsector.address,
fs->currentsector.sector, 1);
return media_write (fs, ctx, fs->currentsector.address, fs->currentsector.sector, 1);
}
}
}
@@ -1533,8 +1532,7 @@ int fatfs_mark_file_deleted (struct fatfs_ctx* ctx, struct fatfs* fs, uint32 Clu
directoryEntry->Name[0] = FILE_HEADER_DELETED;
memcpy ((uint8*)(fs->currentsector.sector + recordoffset), (uint8*)directoryEntry,
sizeof (struct fat_dir_entry));
return fs->disk_io.write_media (ctx, fs->currentsector.address,
fs->currentsector.sector, 1);
return media_write (fs, ctx, fs->currentsector.address, fs->currentsector.sector, 1);
}
}
}
@@ -1653,7 +1651,7 @@ static int fatfs_erase_sectors (struct fatfs_ctx* ctx, struct fatfs* fs, uint32
int i;
memset (fs->currentsector.sector, 0, FAT_SECTOR_SIZE);
for (i = 0; i < count; i++)
if (!fs->disk_io.write_media (ctx, lba + i, fs->currentsector.sector, 1))
if (!media_write (fs, ctx, lba + i, fs->currentsector.sector, 1))
return 0;
return 1;
}
@@ -1796,7 +1794,7 @@ static int fatfs_create_boot_sector (struct fatfs_ctx* ctx, struct fatfs* fs,
fs->currentsector.sector[510] = 0x55;
fs->currentsector.sector[511] = 0xAA;
}
if (fs->disk_io.write_media (ctx, boot_sector_lba, fs->currentsector.sector, 1))
if (media_write (fs, ctx, boot_sector_lba, fs->currentsector.sector, 1))
return 1;
else
return 0;
@@ -1821,7 +1819,7 @@ static int fatfs_create_fsinfo_sector (struct fatfs_ctx* ctx, struct fatfs* fs,
fs->currentsector.sector[495] = 0xFF;
fs->currentsector.sector[510] = 0x55;
fs->currentsector.sector[511] = 0xAA;
if (fs->disk_io.write_media (ctx, sector_lba, fs->currentsector.sector, 1))
if (media_write (fs, ctx, sector_lba, fs->currentsector.sector, 1))
return 1;
else
return 0;
@@ -1837,11 +1835,11 @@ static int fatfs_erase_fat (struct fatfs_ctx* ctx, struct fatfs* fs, int is_fat3
SET_32BIT_WORD (fs->currentsector.sector, 4, 0xFFFFFFFF);
SET_32BIT_WORD (fs->currentsector.sector, 8, 0x0FFFFFFF);
}
if (!fs->disk_io.write_media (ctx, fs->fat_begin_lba + 0, fs->currentsector.sector, 1))
if (!media_write (fs, ctx, fs->fat_begin_lba + 0, fs->currentsector.sector, 1))
return 0;
memset (fs->currentsector.sector, 0, FAT_SECTOR_SIZE);
for (i = 1; i < fs->fat_sectors * fs->num_of_fats; i++)
if (!fs->disk_io.write_media (ctx, fs->fat_begin_lba + i, fs->currentsector.sector, 1))
if (!media_write (fs, ctx, fs->fat_begin_lba + i, fs->currentsector.sector, 1))
return 0;
return 1;
}

32
kernel/proc/proc.c
View File

@@ -137,36 +137,8 @@ struct proc* proc_from_file (struct proc* proc1, const char* volume, const char*
struct desc desc;
int ret;
spin_lock (&proc1->lock);
bool is_kproc = (proc1->flags & PROC_KPROC) != 0;
spin_unlock (&proc1->lock);
if (is_kproc) {
for (;;) {
ret = vfs_volume_open (proc1, volume, rctx);
if (ret < 0)
return NULL;
spin_lock (&proc1->lock);
if (ret == ST_OK && proc1->state != PROC_SUSPENDED) {
spin_unlock (&proc1->lock);
break;
}
for (;;) {
spin_lock (&proc1->lock);
if (proc1->state != PROC_SUSPENDED) {
spin_unlock (&proc1->lock);
break;
}
spin_unlock (&proc1->lock);
}
}
}
if ((ret = vfs_volume_open (proc1, volume, rctx)) < 0)
return NULL;
if ((ret = vfs_describe (proc1, rctx, volume, path, &desc)) < 0) {
vfs_volume_close (proc1, volume, rctx);

56
kernel/syscall/syscall.c
View File

@@ -356,16 +356,19 @@ DEFINE_SYSCALL (sys_volume_open) {
/* int volume_close (void) */
DEFINE_SYSCALL (sys_volume_close) {
char cwv[VOLUME_MAX];
spin_lock (&proc->lock);
memcpy (cwv, proc->cwv, sizeof (proc->cwv));
spin_unlock (&proc->lock);
int ret = vfs_volume_close (proc, proc->cwv, rctx);
int ret = vfs_volume_close (proc, cwv, rctx);
if (ret == ST_OK) {
spin_lock (&proc->lock);
memset (proc->cwv, 0, sizeof (proc->cwv));
spin_unlock (&proc->lock);
}
spin_unlock (&proc->lock);
return SYSRESULT (ret);
}
@@ -394,10 +397,13 @@ DEFINE_SYSCALL (sys_read_file) {
if (buffer == NULL)
return SYSRESULT (-ST_BAD_ADDRESS_SPACE);
char cwv[VOLUME_MAX];
spin_lock (&proc->lock);
int ret = vfs_read_file (proc, rctx, proc->cwv, path, buffer, off, size);
memcpy (cwv, proc->cwv, sizeof (proc->cwv));
spin_unlock (&proc->lock);
int ret = vfs_read_file (proc, rctx, cwv, path, buffer, off, size);
return SYSRESULT (ret);
}
@@ -423,11 +429,14 @@ DEFINE_SYSCALL (sys_describe) {
if (desc == NULL)
return SYSRESULT (-ST_BAD_ADDRESS_SPACE);
char cwv[VOLUME_MAX];
spin_lock (&proc->lock);
int ret = vfs_describe (proc, rctx, proc->cwv, path, desc);
memcpy (cwv, proc->cwv, sizeof (proc->cwv));
spin_unlock (&proc->lock);
int ret = vfs_describe (proc, rctx, cwv, path, desc);
return SYSRESULT (ret);
}
@@ -477,11 +486,14 @@ DEFINE_SYSCALL (sys_read_dir_entry) {
if (entry == NULL)
return SYSRESULT (-ST_BAD_ADDRESS_SPACE);
char cwv[VOLUME_MAX];
spin_lock (&proc->lock);
int ret = vfs_read_dir_entry (proc, rctx, proc->cwv, path, entry, entry_num);
memcpy (cwv, proc->cwv, sizeof (proc->cwv));
spin_unlock (&proc->lock);
int ret = vfs_read_dir_entry (proc, rctx, cwv, path, entry, entry_num);
return SYSRESULT (ret);
}
@@ -501,11 +513,14 @@ DEFINE_SYSCALL (sys_create_file) {
return SYSRESULT (-ST_BAD_ADDRESS_SPACE);
const char* path = (const char*)((uintptr_t)hhdm->offset + out_paddr);
char cwv[VOLUME_MAX];
spin_lock (&proc->lock);
int ret = vfs_create_file (proc, rctx, proc->cwv, path);
memcpy (cwv, proc->cwv, sizeof (proc->cwv));
spin_unlock (&proc->lock);
int ret = vfs_create_file (proc, rctx, cwv, path);
return SYSRESULT (ret);
}
@@ -534,11 +549,14 @@ DEFINE_SYSCALL (sys_write_file) {
if (buffer == NULL)
return SYSRESULT (-ST_BAD_ADDRESS_SPACE);
char cwv[VOLUME_MAX];
spin_lock (&proc->lock);
int ret = vfs_write_file (proc, rctx, proc->cwv, path, buffer, off, size, flags);
memcpy (cwv, proc->cwv, sizeof (proc->cwv));
spin_unlock (&proc->lock);
int ret = vfs_write_file (proc, rctx, cwv, path, buffer, off, size, flags);
return SYSRESULT (ret);
}
@@ -614,11 +632,14 @@ DEFINE_SYSCALL (sys_create_dir) {
return SYSRESULT (-ST_BAD_ADDRESS_SPACE);
const char* path = (const char*)((uintptr_t)hhdm->offset + out_paddr);
char cwv[VOLUME_MAX];
spin_lock (&proc->lock);
int ret = vfs_create_dir (proc, rctx, proc->cwv, path);
memcpy (cwv, proc->cwv, sizeof (proc->cwv));
spin_unlock (&proc->lock);
int ret = vfs_create_dir (proc, rctx, cwv, path);
return SYSRESULT (ret);
}
@@ -638,11 +659,14 @@ DEFINE_SYSCALL (sys_remove) {
return SYSRESULT (-ST_BAD_ADDRESS_SPACE);
const char* path = (const char*)((uintptr_t)hhdm->offset + out_paddr);
char cwv[VOLUME_MAX];
spin_lock (&proc->lock);
int ret = vfs_remove (proc, rctx, proc->cwv, path);
memcpy (cwv, proc->cwv, sizeof (proc->cwv));
spin_unlock (&proc->lock);
int ret = vfs_remove (proc, rctx, cwv, path);
return SYSRESULT (ret);
}

7
testing/make_empty_drive.sh Executable file
View File

@@ -0,0 +1,7 @@
#!/bin/sh
set -xe
rm -f empty_drive.img
dd if=/dev/zero of=empty_drive.img bs=1M count=128

5
testing/make_test_drive.sh
View File

@@ -5,5 +5,6 @@ set -xe
rm -f test_drive.img
dd if=/dev/zero of=test_drive.img bs=1M count=128
mkfs.vfat -F 32 test_drive.img
parted test_drive.img --script mklabel msdos
parted test_drive.img --script mkpart primary fat32 1MiB 127MiB
mkfs.vfat -F 32 --offset 2048 test_drive.img