Begin ajusting vfs.c

1 files changed, 144 insertions, 14 deletions

diff --git a/src/kernel/user/vfs.c b/src/kernel/user/vfs.c
index 32fcb03..81325dd 100644
--- a/src/kernel/user/vfs.c
+++ b/src/kernel/user/vfs.c
@@ -16,7 +16,7 @@ fs_driver_t *drivers = 0;
 
 void register_fs_driver(const char* name, fs_driver_ops_t *ops) {
 	fs_driver_t *d = (fs_driver_t*)malloc(sizeof(fs_driver_t));
-	ASSERT(d != 0); // should we fail in a more graceful manner ?
+	ASSERT(d != 0); // should we fail in a more graceful manner ? TODO
 
 	d->name = name;
 	d->ops = ops;
@@ -25,7 +25,7 @@ void register_fs_driver(const char* name, fs_driver_ops_t *ops) {
 }
 
 // ================================== //
-// CREATING AND DELETINF FILE SYSTEMS //
+// CREATING AND DELETING FILE SYSTEMS //
 // ================================== //
 
 fs_t *make_fs(const char* drv_name, fs_handle_t *source, char* opts) {
@@ -36,13 +36,18 @@ fs_t *make_fs(const char* drv_name, fs_handle_t *source, char* opts) {
 		if (drv_name == 0 && source != 0 && i->ops->detect && i->ops->detect(source)) d = i;
 		if (d != 0) break;
 	}
+	if (d == 0) return 0;		// driver not found
 
 	// Open file system
 	fs_t *fs = (fs_t*)malloc(sizeof(fs_t));
 	if (fs == 0) return 0;
 
+	fs->refs = 1;
+	fs->root.refs = 1;		// root node is never disposed of (done by fs->shutdown)
+	fs->root.fs = fs;
+	fs->root.parent = 0;
+
 	if (d->ops->make(source, opts, fs)) {
-		fs->refs = 1;
 		return fs;
 	} else {
 		free(fs);
@@ -61,27 +66,141 @@ void ref_fs(fs_t *fs) {
 void unref_fs(fs_t *fs) {
 	fs->refs--;
 	if (fs->refs == 0) {
+		// don't unref root node, don't call dispose on it
+		// (done by fs->shutdown)
 		fs->ops->shutdown(fs->data);
 		free(fs);
 	}
 }
 
+// ====================================================== //
+// WALKING IN THE FILE SYSTEM CREATING AND DELETING NODES //
+
+void ref_fs_node(fs_node_t *n) {
+	n->refs++;
+}
+
+void unref_fs_node(fs_node_t *n) {
+	n->refs--;
+	if (n->refs == 0) {
+		ASSERT(n != &n->fs->root);
+		ASSERT(n->parent != 0);
+
+		n->ops->dispose(n->data);
+		unref_fs_node(n->parent);
+		unref_fs(n->fs);
+		free(n);
+	}
+}
+
+fs_node_t* fs_walk_one(fs_node_t* from, const char* file) {
+	fs_node_t *n = (fs_node_t*)malloc(sizeof(fs_node_t));
+	if (n == 0) return 0;
+
+	n->fs = from->fs;
+	n->refs = 1;
+	n->parent = from;
+
+	if (from->ops->walk && from->ops->walk(from->data, file, n)) {
+		ref_fs_node(n->parent);
+		ref_fs(n->fs);
+		return n;
+	} else {
+		free(n);
+		return 0;
+	}
+}
+
+fs_node_t* fs_walk_path(fs_node_t* from, const char* path) {
+	fs_node_t *n = from;
+	ref_fs_node(n);
+
+	while (n && (*path)) {
+		const char* d = strchr(path, '/');
+		if (d == path) {
+			path++;
+		} else if (d == 0) {
+			fs_node_t *n2 = fs_walk_one(n, path);
+			unref_fs_node(n);
+
+			return n2;
+		} else {
+			size_t nlen = d - path;
+			if (nlen >= DIR_MAX - 1) {
+				unref_fs_node(n);
+				return 0;	// sorry, path item too long
+			}
+			char name_buf[DIR_MAX];
+			strncpy(name_buf, path, nlen);
+			name_buf[nlen] = 0;
+
+			fs_node_t *n2 = fs_walk_one(n, name_buf);
+			unref_fs_node(n);
+			n = n2;
+
+			path = d + 1;
+		}
+	}
+	return n;
+}
+
+fs_node_t* fs_walk_path_except_last(fs_node_t* from, const char* path, char* last_file_buf) {
+	// TODO : parse path, walk
+	// This function does NOT walk into the last component of the path (it may not even exist),
+	// instead it isolates it in the buffer last_file
+	// This buffer is expected to be of size DIR_MAX (defined in fs.h)
+	return 0;
+}
+
+// ========================== //
 // DOING THINGS IN FLESYSTEMS //
 
+bool fs_create(fs_t *fs, const char* file, int type) {
+	char name[DIR_MAX];
+	fs_node_t *n = fs_walk_path_except_last(&fs->root, file, name);
+	if (n == 0) return false;
+
+	bool ret = n->ops->create && n->ops->create(n->data, name, type);
+	unref_fs_node(n);
+	return ret;
+}
+
 bool fs_delete(fs_t *fs, const char* file) {
-	return fs->ops->delete && fs->ops->delete(fs->data, file);
+	fs_node_t* n = fs_walk_path(&fs->root, file);
+	if (n == 0) return false;
+
+	bool ret = n->ops->delete && n->ops->delete(n->data);
+	unref_fs_node(n);
+	return ret;
 }
 
-bool fs_rename(fs_t *fs, const char* from, const char* to) {
-	return fs->ops->rename && fs->ops->rename(fs->data, from, to);
+bool fs_move(fs_t *fs, const char* from, const char* to) {
+	fs_node_t *n = fs_walk_path(&fs->root, from);
+	if (n == 0) return false;
+
+	char new_name[DIR_MAX];
+	fs_node_t *new_parent = fs_walk_path_except_last(&fs->root, to, new_name);
+	if (new_parent == 0) return false;
+
+	return n->ops->move && n->ops->move(n->data, new_parent, new_name);
 }
 
-bool fs_stat(fs_t *fs, const char* name, stat_t *st) {
-	return fs->ops->stat && fs->ops->stat(fs->data, name, st);
+bool fs_stat(fs_t *fs, const char* file, stat_t *st) {
+	fs_node_t* n = fs_walk_path(&fs->root, file);
+	if (n == 0) return false;
+
+	bool ret = n->ops->stat && n->ops->stat(n->data, st);
+	unref_fs_node(n);
+	return ret;
 }
 
 int fs_ioctl(fs_t *fs, const char* file, int command, void* data) {
-	return fs->ops->ioctl && fs->ops->ioctl(fs->data, file, command, data);
+	fs_node_t* n = fs_walk_path(&fs->root, file);
+	if (n == 0) return false;
+
+	int ret = (n->ops->ioctl ? n->ops->ioctl(n->data, command, data) : -1);
+	unref_fs_node(n);
+	return ret;
 }
 
 // =================== //
@@ -89,15 +208,25 @@ 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) return false;
+
 	fs_handle_t *h = (fs_handle_t*)malloc(sizeof(fs_handle_t));
-	if (h == 0) return 0;
+	if (h == 0) {
+		unref_fs_node(n);
+		return 0;
+	}
+
+	h->refs = 1;
+	h->fs = fs;
+	h->n = n;
 
-	if (fs->ops->open(fs->data, file, mode, h)) {
-		h->refs = 1;
-		h->fs = fs;
+	if (n->ops->open(n->data, mode, h)) {
+		// our reference to node n is transferred to the file handle
 		ref_fs(fs);
 		return h;
 	} else {
+		unref_fs_node(n);
 		free(h);
 		return 0;
 	}
@@ -110,8 +239,9 @@ void ref_file(fs_handle_t *file) {
 void unref_file(fs_handle_t *file) {
 	file->refs--;
 	if (file->refs == 0) {
-		unref_fs(file->fs);
 		file->ops->close(file->data);
+		unref_fs_node(file->n);
+		unref_fs(file->fs);
 		free(file);
 	}
 }