diff options
| -rw-r--r-- | src/kernel/include/vfs.h | 1 | ||||
| -rw-r--r-- | src/kernel/user/nullfs.c | 166 | ||||
| -rw-r--r-- | src/kernel/user/vfs.c | 14 | ||||
| -rw-r--r-- | src/rules.make | 1 |
4 files changed, 171 insertions, 11 deletions
diff --git a/src/kernel/include/vfs.h b/src/kernel/include/vfs.h index 19f43db..af94b2a 100644 --- a/src/kernel/include/vfs.h +++ b/src/kernel/include/vfs.h @@ -61,6 +61,7 @@ typedef struct fs_handle { // is currently in use. (different from posix semantics !) // - the root node of a filesystem is created when the filesystem is created // - dispose() is not called on the root node when a filesystem is shutdown +// - delete() is not expected to delete recursively : it should fail on a non-empty directory typedef struct { bool (*open)(fs_node_ptr n, int mode, fs_handle_t *s); // open current node diff --git a/src/kernel/user/nullfs.c b/src/kernel/user/nullfs.c index 2f54137..c27f923 100644 --- a/src/kernel/user/nullfs.c +++ b/src/kernel/user/nullfs.c @@ -295,7 +295,46 @@ bool nullfs_d_walk(fs_node_ptr n, const char* file, struct fs_node *node_d) { } bool nullfs_d_delete(fs_node_ptr n, const char* file) { - return false; //TODO + nullfs_dir_t* d = (nullfs_dir_t*)n; + + if (!d->fs->can_delete) return false; + + nullfs_item_t *i = hashtbl_find(d->items_idx, file); + if (i == 0) return false; + + if (i->ops == &nullfs_d_ops) { + // if it is a subdirectory, check it is empty + nullfs_dir_t* sd = (nullfs_dir_t*)i->data; + if (sd->items_list != 0) return false; + + delete_hashtbl(sd->items_idx, 0); + free(sd); + } else if (i->ops == &nullfs_f_ops) { + nullfs_file_t* f = (nullfs_file_t*)i->data; + + if (f->own_data) free(f->data); + free(f); + } else { + return false; // special nodes (devices, ...) may not be deleted + } + + hashtbl_remove(d->items_idx, i->name); + + if (d->items_list == i) { + d->items_list = i->next; + } else { + for (nullfs_item_t* it = d->items_list; it != 0; it++) { + if (it->next == i) { + it->next = i->next; + break; + } + } + } + + free(i->name); + free(i); + + return true; } bool nullfs_d_move(fs_node_ptr n, const char* old_name, fs_node_t *new_parent, const char *new_name) { @@ -303,11 +342,82 @@ bool nullfs_d_move(fs_node_ptr n, const char* old_name, fs_node_t *new_parent, c } bool nullfs_d_create(fs_node_ptr n, const char* file, int type) { - return false; //TODO + nullfs_dir_t *d = (nullfs_dir_t*)n; + nullfs_item_t *i = 0; + + if (type == FT_REGULAR) { + nullfs_file_t *f = (nullfs_file_t*)malloc(sizeof(nullfs_file_t)); + if (f == 0) return false; + + f->ok_modes = FM_READ | FM_WRITE | FM_TRUNC | FM_APPEND; + f->data = 0; + f->size = 0; + f->own_data = false; + f->lock = MUTEX_UNLOCKED; + + i = (nullfs_item_t*)malloc(sizeof(nullfs_item_t)); + if (i == 0) goto f_error; + + i->name = strdup(file); + if (i->name == 0) goto f_error; + + i->ops = &nullfs_f_ops; + i->data = f; + + bool add_ok = hashtbl_add(d->items_idx, i->name, i); + if (!add_ok) goto f_error; + + i->next = d->items_list; + d->items_list = i; + + return true; + + f_error: + if (i != 0 && i->name != 0) free(i->name); + if (i != 0) free(i); + free(f); + return false; + } else if (type == FT_DIR) { + nullfs_dir_t *x = (nullfs_dir_t*)malloc(sizeof(nullfs_dir_t)); + if (x == 0) return false; + + x->items_idx = create_hashtbl(str_key_eq_fun, str_hash_fun, 0, 0); + if (x->items_idx == 0) goto d_error; + + x->items_list = 0; + x->lock = MUTEX_UNLOCKED; + x->fs = d->fs; + + i = (nullfs_item_t*)malloc(sizeof(nullfs_item_t)); + if (i == 0) goto d_error; + + i->name = strdup(file); + if (i->name == 0) goto d_error; + + i->ops = &nullfs_d_ops; + i->data = x; + + bool add_ok = hashtbl_add(d->items_idx, i->name, i); + if (!add_ok) goto d_error; + + i->next = d->items_list; + d->items_list = i; + + return true; + + d_error: + if (i != 0 && i->name != 0) free(i->name); + if (i != 0) free(i); + if (x->items_idx != 0) delete_hashtbl(x->items_idx, 0); + free(x); + return false; + } else { + return false; + } } void nullfs_d_dispose(fs_node_ptr n) { - //TODO + // nothing to do } @@ -349,6 +459,14 @@ bool nullfs_f_open(fs_node_ptr n, int mode, fs_handle_t *s) { if (mode & ~f->ok_modes) return false; mutex_lock(&f->lock); + + if (mode & FM_TRUNC) { + // truncate file + if (f->own_data) free(f->data); + f->size = 0; + f->own_data = false; + f->data = 0; + } s->mode = mode; s->data = f; @@ -358,21 +476,51 @@ bool nullfs_f_open(fs_node_ptr n, int mode, fs_handle_t *s) { } bool nullfs_f_stat(fs_node_ptr n, stat_t *st) { - return false; //TODO + nullfs_file_t *f = (nullfs_file_t*)n; + + st->type = FT_REGULAR; + st->access = f->ok_modes; + st->size = f->size; + + return true; } void nullfs_f_dispose(fs_node_ptr n) { - // TODO + // nothing to do } // -- File handle -- -static size_t nullfs_fh_read(fs_handle_ptr f, size_t offset, size_t len, char* buf) { - return 0; //TODO +static size_t nullfs_fh_read(fs_handle_ptr h, size_t offset, size_t len, char* buf) { + nullfs_file_t *f = (nullfs_file_t*)h; + + if (offset >= f->size) return 0; + if (offset + len > f->size) len = f->size - offset; + + memcpy(buf, f->data + offset, len); + return len; } -static size_t nullfs_fh_write(fs_handle_ptr f, size_t offset, size_t len, const char* buf) { - return 0; //TODO +static size_t nullfs_fh_write(fs_handle_ptr h, size_t offset, size_t len, const char* buf) { + nullfs_file_t *f = (nullfs_file_t*)h; + + if (offset + len > f->size) { + // resize buffer (zero out new portion) + void* new_buffer = malloc(offset + len); + if (new_buffer == 0) return 0; + + memcpy(new_buffer, f->data, f->size); + if (offset > f->size) + memset(new_buffer + f->size, 0, offset - f->size); + + if (f->own_data) free(f->data); + f->data = new_buffer; + f->own_data = true; + f->size = offset + len; + } + + memcpy(f->data + offset, buf, len); + return len; } static void nullfs_fh_close(fs_handle_ptr h) { diff --git a/src/kernel/user/vfs.c b/src/kernel/user/vfs.c index 5ba2064..0624a38 100644 --- a/src/kernel/user/vfs.c +++ b/src/kernel/user/vfs.c @@ -95,6 +95,7 @@ void unref_fs_node(fs_node_t *n) { unref_fs_node(n->parent); unref_fs(n->fs); + if (n->children != 0) delete_hashtbl(n->children, 0); free(n->name); free(n); } @@ -304,8 +305,15 @@ int fs_ioctl(fs_t *fs, const char* file, int command, void* data) { fs_handle_t* fs_open(fs_t *fs, const char* file, int mode) { fs_node_t *n = fs_walk_path(&fs->root, file); + if (n == 0 && (mode & FM_CREATE)) { + if (fs_create(fs, file, FT_REGULAR)) { + n = fs_walk_path(&fs->root, file); + } + } if (n == 0) return false; + mode &= ~FM_CREATE; + fs_handle_t *h = (fs_handle_t*)malloc(sizeof(fs_handle_t)); if (h == 0) { unref_fs_node(n); @@ -346,14 +354,14 @@ int file_get_mode(fs_handle_t *f) { } size_t file_read(fs_handle_t *f, size_t offset, size_t len, char* buf) { - if (!(f->mode && FM_READ)) return 0; + if (!(f->mode & FM_READ)) return 0; if (f->ops->read == 0) return 0; return f->ops->read(f->data, offset, len, buf); } size_t file_write(fs_handle_t *f, size_t offset, size_t len, const char* buf) { - if (!(f->mode && FM_WRITE)) return 0; + if (!(f->mode & FM_WRITE)) return 0; if (f->ops->write == 0) return 0; return f->ops->write(f->data, offset, len, buf); @@ -364,6 +372,8 @@ bool file_stat(fs_handle_t *f, stat_t *st) { } bool file_readdir(fs_handle_t *f, dirent_t *d) { + if (!(f->mode & FM_READDIR)) return 0; + return f->ops->readdir && f->ops->readdir(f->data, d); } diff --git a/src/rules.make b/src/rules.make index f107d89..acd1c62 100644 --- a/src/rules.make +++ b/src/rules.make @@ -1,3 +1,4 @@ +.PRECIOUS: %.o AS = nasm ASFLAGS = -felf -g |