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

Spinlock save cpu flags

Browse Source
This commit is contained in:
Kamil Kowalczyk
2026-03-12 22:48:34 +01:00
parent 19793e9126
commit 4760818118
50 changed files with 704 additions and 461 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
kernel/fs/fat1.c
View File

@@ -6,11 +6,13 @@
#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) {
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) {
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);
}

32
kernel/fs/fatfs.c
View File

@@ -20,6 +20,8 @@
static int fat1_diskio_read (struct fatfs_ctx* ctx, uint32_t sector, uint8_t* buffer,
uint32_t sector_count) {
uint64_t fd;
struct vfs_volume* volume = ctx->udata;
struct device* back_device = volume->back_device;
@@ -30,11 +32,11 @@ static int fat1_diskio_read (struct fatfs_ctx* ctx, uint32_t sector, uint8_t* bu
size_t phys_sector, phys_sector_count;
int ret;
spin_lock (&back_device->lock);
spin_lock (&back_device->lock, &fd);
ret = device_op (back_device, XDRV_GET_SECTOR_SIZE, ctx->proc, ctx->rctx, &sector_size);
if (ret < 0) {
spin_unlock (&back_device->lock);
spin_unlock (&back_device->lock, fd);
return 0;
}
@@ -44,11 +46,11 @@ static int fat1_diskio_read (struct fatfs_ctx* ctx, uint32_t sector, uint8_t* bu
ret = device_op (back_device, XDRV_READ, ctx->proc, ctx->rctx, &phys_sector, &phys_sector_count,
buffer);
if (ret < 0) {
spin_unlock (&back_device->lock);
spin_unlock (&back_device->lock, fd);
return 0;
}
spin_unlock (&back_device->lock);
spin_unlock (&back_device->lock, fd);
if (ret < 0)
return 0;
@@ -57,6 +59,8 @@ static int fat1_diskio_read (struct fatfs_ctx* ctx, uint32_t sector, uint8_t* bu
static int fat1_diskio_write (struct fatfs_ctx* ctx, uint32_t sector, uint8_t* buffer,
uint32_t sector_count) {
uint64_t fd;
struct vfs_volume* volume = ctx->udata;
struct device* back_device = volume->back_device;
@@ -67,11 +71,11 @@ static int fat1_diskio_write (struct fatfs_ctx* ctx, uint32_t sector, uint8_t* b
size_t phys_sector, phys_sector_count;
int ret;
spin_lock (&back_device->lock);
spin_lock (&back_device->lock, &fd);
ret = device_op (back_device, XDRV_GET_SECTOR_SIZE, ctx->proc, ctx->rctx, &sector_size);
if (ret < 0) {
spin_unlock (&back_device->lock);
spin_unlock (&back_device->lock, fd);
return 0;
}
@@ -81,11 +85,11 @@ static int fat1_diskio_write (struct fatfs_ctx* ctx, uint32_t sector, uint8_t* b
ret = device_op (back_device, XDRV_WRITE, ctx->proc, ctx->rctx, &phys_sector, &phys_sector_count,
buffer);
if (ret < 0) {
spin_unlock (&back_device->lock);
spin_unlock (&back_device->lock, fd);
return 0;
}
spin_unlock (&back_device->lock);
spin_unlock (&back_device->lock, fd);
if (ret < 0)
return 0;
@@ -124,15 +128,17 @@ int fatfs_mount (struct vfs_volume* volume, struct proc* proc, struct reschedule
}
int fatfs16_format (struct vfs_volume* volume, struct proc* proc, struct reschedule_ctx* rctx) {
uint64_t fd;
struct fatfs_ctx* fatfs_ctx = volume->udata;
struct device* back_device = volume->back_device;
size_t total_size;
fatfs_ctx->proc = proc;
fatfs_ctx->rctx = rctx;
spin_lock (&back_device->lock);
spin_lock (&back_device->lock, &fd);
device_op (back_device, XDRV_GET_SIZE, proc, rctx, &total_size);
spin_unlock (&back_device->lock);
spin_unlock (&back_device->lock, fd);
size_t sectors = div_align_up (total_size, FAT_SECTOR_SIZE);
int r = fatfs_format_fat16 (fatfs_ctx, &fatfs_ctx->_fs, sectors, "mop3 fat16");
@@ -140,15 +146,17 @@ int fatfs16_format (struct vfs_volume* volume, struct proc* proc, struct resched
}
int fatfs32_format (struct vfs_volume* volume, struct proc* proc, struct reschedule_ctx* rctx) {
uint64_t fd;
struct fatfs_ctx* fatfs_ctx = volume->udata;
struct device* back_device = volume->back_device;
size_t total_size;
fatfs_ctx->proc = proc;
fatfs_ctx->rctx = rctx;
spin_lock (&back_device->lock);
spin_lock (&back_device->lock, &fd);
device_op (back_device, XDRV_GET_SIZE, proc, rctx, &total_size);
spin_unlock (&back_device->lock);
spin_unlock (&back_device->lock, fd);
size_t sectors = div_align_up (total_size, FAT_SECTOR_SIZE);
int r = fatfs_format_fat32 (fatfs_ctx, &fatfs_ctx->_fs, sectors, "mop3 fat32");

11
kernel/fs/tarfs.c
View File

@@ -68,6 +68,7 @@ static size_t tar_parse (struct tarfs* tarfs, uint8_t* addr, size_t max_size) {
int tarfs_mount (struct vfs_volume* volume, struct proc* proc, struct reschedule_ctx* rctx,
bool format) {
(void)format;
uint64_t fd;
struct tarfs* tarfs = malloc (sizeof (*tarfs));
@@ -82,18 +83,18 @@ int tarfs_mount (struct vfs_volume* volume, struct proc* proc, struct reschedule
size_t total_size, sector_size;
int ret;
spin_lock (&back_device->lock);
spin_lock (&back_device->lock, &fd);
ret = device_op (back_device, XDRV_GET_SIZE, NULL, NULL, &total_size);
if (ret < 0) {
spin_unlock (&back_device->lock);
spin_unlock (&back_device->lock, fd);
free (volume->udata);
return ret;
}
ret = device_op (back_device, XDRV_GET_SECTOR_SIZE, NULL, NULL, &sector_size);
if (ret < 0) {
spin_unlock (&back_device->lock);
spin_unlock (&back_device->lock, fd);
free (volume->udata);
return ret;
}
@@ -101,7 +102,7 @@ int tarfs_mount (struct vfs_volume* volume, struct proc* proc, struct reschedule
uint8_t* buffer = malloc (total_size);
if (buffer == NULL) {
spin_unlock (&back_device->lock);
spin_unlock (&back_device->lock, fd);
free (volume->udata);
volume->udata = NULL;
return ret;
@@ -113,7 +114,7 @@ int tarfs_mount (struct vfs_volume* volume, struct proc* proc, struct reschedule
ret = device_op (back_device, XDRV_READ, proc, rctx, &sector, &sector_count, dest);
}
spin_unlock (&back_device->lock);
spin_unlock (&back_device->lock, fd);
if (ret < 0) {
free (buffer);

100
kernel/fs/vfs.c
View File

@@ -22,14 +22,16 @@
static struct vfs_volume_table volume_table;
static struct vfs_volume* vfs_find_volume (const char* volume) {
uint64_t fvt;
struct hash_node_link* found_link = NULL;
size_t volume_len = strlen_null (volume);
uint32_t hash = hash_fnv32 (volume, volume_len);
spin_lock (&volume_table.lock);
spin_lock (&volume_table.lock, &fvt);
hash_find (&volume_table, volume, volume_len, hash, lengthof (volume_table.volume_buckets),
volume_buckets, struct vfs_volume, volume_table_link, key, found_link);
spin_unlock (&volume_table.lock);
spin_unlock (&volume_table.lock, fvt);
if (found_link == NULL)
return NULL;
@@ -39,6 +41,8 @@ static struct vfs_volume* vfs_find_volume (const char* volume) {
int vfs_create_volume (struct proc* proc, struct reschedule_ctx* rctx, const char* key, int fs_type,
struct device* back_device, bool format) {
uint64_t fvt;
if (strlen_null (key) > VOLUME_MAX)
return -ST_OOB_ERROR;
@@ -102,49 +106,53 @@ int vfs_create_volume (struct proc* proc, struct reschedule_ctx* rctx, const cha
uint32_t mp_hash = hash_fnv32 (volume->key, strlen_null (volume->key));
spin_lock (&volume_table.lock);
spin_lock (&volume_table.lock, &fvt);
hash_insert (&volume_table, &volume->volume_table_link, mp_hash,
lengthof (volume_table.volume_buckets), volume_buckets);
spin_unlock (&volume_table.lock);
spin_unlock (&volume_table.lock, fvt);
return ST_OK;
}
int vfs_volume_open (struct proc* proc, const char* volume_name, struct reschedule_ctx* rctx) {
uint64_t fv;
struct vfs_volume* volume = vfs_find_volume (volume_name);
if (volume == NULL)
return -ST_NOT_FOUND;
spin_lock (&volume->lock);
spin_lock (&volume->lock, &fv);
if (!volume->locked) {
volume->locked = true;
volume->owner = proc;
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return ST_OK;
} else {
proc_sq_suspend (proc, &volume->sq, &volume->lock, rctx);
proc_sq_suspend (proc, &volume->sq, &volume->lock, fv, rctx);
return ST_OK;
}
}
int vfs_volume_close (struct proc* proc, const char* volume_name, struct reschedule_ctx* rctx) {
uint64_t fv, fvsq;
struct vfs_volume* volume = vfs_find_volume (volume_name);
if (volume == NULL)
return -ST_NOT_FOUND;
spin_lock (&volume->lock);
spin_lock (&volume->lock, &fv);
if (volume->locked && volume->owner != proc) {
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return -ST_PERMISSION_ERROR;
}
spin_lock (&volume->sq.lock);
spin_lock (&volume->sq.lock, &fvsq);
struct list_node_link* node = volume->sq.proc_list;
@@ -155,8 +163,8 @@ int vfs_volume_close (struct proc* proc, const char* volume_name, struct resched
volume->owner = resumed_proc;
volume->locked = true;
spin_unlock (&volume->sq.lock);
spin_unlock (&volume->lock);
spin_unlock (&volume->sq.lock, fvsq);
spin_unlock (&volume->lock, fv);
proc_sq_resume (resumed_proc, sq_entry, rctx);
return ST_OK;
@@ -165,159 +173,175 @@ int vfs_volume_close (struct proc* proc, const char* volume_name, struct resched
volume->locked = false;
volume->owner = NULL;
spin_unlock (&volume->sq.lock);
spin_unlock (&volume->lock);
spin_unlock (&volume->sq.lock, fvsq);
spin_unlock (&volume->lock, fv);
return ST_OK;
}
int vfs_format (struct proc* proc, struct reschedule_ctx* rctx, const char* volume_name) {
uint64_t fv;
struct vfs_volume* volume = vfs_find_volume (volume_name);
if (volume == NULL)
return -ST_NOT_FOUND;
spin_lock (&volume->lock);
spin_lock (&volume->lock, &fv);
if (volume->locked && volume->owner != proc) {
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return -ST_PERMISSION_ERROR;
}
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return volume->driver_ops.format (volume, proc, rctx);
}
int vfs_read_file (struct proc* proc, struct reschedule_ctx* rctx, const char* volume_name,
const char* path, uint8_t* buffer, size_t off, size_t size) {
uint64_t fv;
struct vfs_volume* volume = vfs_find_volume (volume_name);
if (volume == NULL)
return -ST_NOT_FOUND;
spin_lock (&volume->lock);
spin_lock (&volume->lock, &fv);
if (volume->locked && volume->owner != proc) {
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return -ST_PERMISSION_ERROR;
}
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return volume->driver_ops.read_file (volume, proc, rctx, path, buffer, off, size);
}
int vfs_write_file (struct proc* proc, struct reschedule_ctx* rctx, const char* volume_name,
const char* path, uint8_t* buffer, size_t off, size_t size, uint32_t flags) {
uint64_t fv;
struct vfs_volume* volume = vfs_find_volume (volume_name);
if (volume == NULL)
return -ST_NOT_FOUND;
spin_lock (&volume->lock);
spin_lock (&volume->lock, &fv);
if (volume->locked && volume->owner != proc) {
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return -ST_PERMISSION_ERROR;
}
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return volume->driver_ops.write_file (volume, proc, rctx, path, buffer, off, size, flags);
}
int vfs_create_file (struct proc* proc, struct reschedule_ctx* rctx, const char* volume_name,
const char* path) {
uint64_t fv;
struct vfs_volume* volume = vfs_find_volume (volume_name);
if (volume == NULL)
return -ST_NOT_FOUND;
spin_lock (&volume->lock);
spin_lock (&volume->lock, &fv);
if (volume->locked && volume->owner != proc) {
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return -ST_PERMISSION_ERROR;
}
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return volume->driver_ops.create_file (volume, proc, rctx, path);
}
int vfs_describe (struct proc* proc, struct reschedule_ctx* rctx, const char* volume_name,
const char* path, struct desc* desc) {
uint64_t fv;
struct vfs_volume* volume = vfs_find_volume (volume_name);
if (volume == NULL)
return -ST_NOT_FOUND;
spin_lock (&volume->lock);
spin_lock (&volume->lock, &fv);
if (volume->locked && volume->owner != proc) {
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return -ST_PERMISSION_ERROR;
}
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return volume->driver_ops.describe (volume, proc, rctx, path, desc);
}
int vfs_read_dir_entry (struct proc* proc, struct reschedule_ctx* rctx, const char* volume_name,
const char* path, struct dir_entry* entry, size_t entry_num) {
uint64_t fv;
struct vfs_volume* volume = vfs_find_volume (volume_name);
if (volume == NULL)
return -ST_NOT_FOUND;
spin_lock (&volume->lock);
spin_lock (&volume->lock, &fv);
if (volume->locked && volume->owner != proc) {
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return -ST_PERMISSION_ERROR;
}
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return volume->driver_ops.read_dir_entry (volume, proc, rctx, path, entry, entry_num);
}
int vfs_create_dir (struct proc* proc, struct reschedule_ctx* rctx, const char* volume_name,
const char* path) {
uint64_t fv;
struct vfs_volume* volume = vfs_find_volume (volume_name);
if (volume == NULL)
return -ST_NOT_FOUND;
spin_lock (&volume->lock);
spin_lock (&volume->lock, &fv);
if (volume->locked && volume->owner != proc) {
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return -ST_PERMISSION_ERROR;
}
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return volume->driver_ops.create_dir (volume, proc, rctx, path);
}
int vfs_remove (struct proc* proc, struct reschedule_ctx* rctx, const char* volume_name,
const char* path) {
uint64_t fv;
struct vfs_volume* volume = vfs_find_volume (volume_name);
if (volume == NULL)
return -ST_NOT_FOUND;
spin_lock (&volume->lock);
spin_lock (&volume->lock, &fv);
if (volume->locked && volume->owner != proc) {
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return -ST_PERMISSION_ERROR;
}
spin_unlock (&volume->lock);
spin_unlock (&volume->lock, fv);
return volume->driver_ops.remove (volume, proc, rctx, path);
}