diff options
Diffstat (limited to 'kernel/fs')
| -rw-r--r-- | kernel/fs/Submodules | 1 | ||||
| -rw-r--r-- | kernel/fs/file.c | 115 | ||||
| -rw-r--r-- | kernel/fs/namev.c | 263 | ||||
| -rw-r--r-- | kernel/fs/open.c | 67 | ||||
| -rw-r--r-- | kernel/fs/pipe.c | 256 | ||||
| -rw-r--r-- | kernel/fs/ramfs/ramfs.c | 852 | ||||
| -rw-r--r-- | kernel/fs/s5fs/s5fs.c | 860 | ||||
| -rw-r--r-- | kernel/fs/s5fs/s5fs_subr.c | 590 | ||||
| -rw-r--r-- | kernel/fs/vfs.c | 222 | ||||
| -rw-r--r-- | kernel/fs/vfs_syscall.c | 356 | ||||
| -rw-r--r-- | kernel/fs/vnode.c | 250 | ||||
| -rw-r--r-- | kernel/fs/vnode_specials.c | 176 |
12 files changed, 4008 insertions, 0 deletions
diff --git a/kernel/fs/Submodules b/kernel/fs/Submodules new file mode 100644 index 0000000..a6a93cb --- /dev/null +++ b/kernel/fs/Submodules @@ -0,0 +1 @@ +ramfs s5fs diff --git a/kernel/fs/file.c b/kernel/fs/file.c new file mode 100644 index 0000000..4e79a3d --- /dev/null +++ b/kernel/fs/file.c @@ -0,0 +1,115 @@ +#include "fs/file.h" +#include "fs/vfs.h" +#include "fs/vnode.h" +#include "kernel.h" +#include "mm/slab.h" +#include "util/debug.h" +#include "util/string.h" + +static slab_allocator_t *file_allocator; + +void file_init(void) +{ + file_allocator = slab_allocator_create("file", sizeof(file_t)); +} + +void fref(file_t *f) +{ + KASSERT(f->f_mode <= FMODE_MAX_VALUE && f->f_vnode); + + f->f_refcount++; + + if (f->f_vnode) + { + dbg(DBG_FREF, "fref: 0x%p, 0x%p ino %u, up to %lu\n", f, + f->f_vnode->vn_fs, f->f_vnode->vn_vno, f->f_refcount); + } + else + { + dbg(DBG_FREF, "fref: 0x%p up to %lu\n", f, f->f_refcount); + } +} + +/* + * Create a file, initialize its members, vref the vnode, call acquire() on the + * vnode if the function pointer is non-NULL, and set the file descriptor in + * curproc->p_files. + * + * On successful return, the vnode's refcount should be incremented by one, + * the file's refcount should be 1, and curproc->p_files[fd] should point to + * the file being returned. + */ +file_t *fcreate(int fd, vnode_t *vnode, unsigned int mode) +{ + KASSERT(!curproc->p_files[fd]); + file_t *file = slab_obj_alloc(file_allocator); + if (!file) + return NULL; + memset(file, 0, sizeof(file_t)); + file->f_mode = mode; + + vref(file->f_vnode = vnode); + if (vnode->vn_ops->acquire) + vnode->vn_ops->acquire(vnode, file); + + curproc->p_files[fd] = file; + fref(file); + return file; +} + +/* + * Perform bounds checking on the fd, use curproc->p_files to get the file, + * fref it if it exists, and return. + */ +file_t *fget(int fd) +{ + if (fd < 0 || fd >= NFILES) + return NULL; + file_t *file = curproc->p_files[fd]; + if (file) + fref(file); + return file; +} + +/* + * Decrement the refcount, and set *filep to NULL. + * + * If the refcount drops to 0, call release on the vnode if the function pointer + * is non-null, vput() file's vnode, and free the file memory. + * + * Regardless of the ending refcount, *filep == NULL on return. + */ +void fput(file_t **filep) +{ + file_t *file = *filep; + *filep = NULL; + + KASSERT(file && file->f_mode <= FMODE_MAX_VALUE); + KASSERT(file->f_refcount > 0); + if (file->f_refcount != 1) + KASSERT(file->f_vnode); + + file->f_refcount--; + + if (file->f_vnode) + { + dbg(DBG_FREF, "fput: 0x%p, 0x%p ino %u, down to %lu\n", file, + file->f_vnode->vn_fs, file->f_vnode->vn_vno, file->f_refcount); + } + else + { + dbg(DBG_FREF, "fput: 0x%p down to %lu\n", file, file->f_refcount); + } + + if (!file->f_refcount) + { + if (file->f_vnode) + { + vlock(file->f_vnode); + if (file->f_vnode->vn_ops->release) + file->f_vnode->vn_ops->release(file->f_vnode, file); + vput_locked(&file->f_vnode); + } + slab_obj_free(file_allocator, file); + } +} diff --git a/kernel/fs/namev.c b/kernel/fs/namev.c new file mode 100644 index 0000000..9e55892 --- /dev/null +++ b/kernel/fs/namev.c @@ -0,0 +1,263 @@ +#include "errno.h" +#include "globals.h" +#include "kernel.h" +#include <fs/dirent.h> + +#include "util/debug.h" +#include "util/string.h" + +#include "fs/fcntl.h" +#include "fs/stat.h" +#include "fs/vfs.h" +#include "fs/vnode.h" + +/* + * Get the parent of a directory. dir must not be locked. + */ +long namev_get_parent(vnode_t *dir, vnode_t **out) +{ + vlock(dir); + long ret = namev_lookup(dir, "..", 2, out); + vunlock(dir); + return ret; +} + +/* + * Determines if vnode a is a descendant of vnode b. + * Returns 1 if true, 0 otherwise. + */ +long namev_is_descendant(vnode_t *a, vnode_t *b) +{ + vref(a); + vnode_t *cur = a; + vnode_t *next = NULL; + while (cur != NULL) + { + if (cur->vn_vno == b->vn_vno) + { + vput(&cur); + return 1; + } + else if (cur->vn_vno == cur->vn_fs->fs_root->vn_vno) + { + /* we've reached the root node. */ + vput(&cur); + return 0; + } + + /* backup the filesystem tree */ + namev_get_parent(cur, &next); + vnode_t *tmp = cur; + cur = next; + vput(&tmp); + } + + return 0; +} + +/* Wrapper around dir's vnode operation lookup. dir must be locked on entry and + * upon return. + * + * Upon success, return 0 and return the found vnode using res_vnode, or: + * - ENOTDIR: dir does not have a lookup operation or is not a directory + * - Propagate errors from the vnode operation lookup + * + * Hints: + * Take a look at ramfs_lookup(), which adds a reference to res_vnode but does + * not touch any locks. In most cases, this means res_vnode will be unlocked + * upon return. However, there is a case where res_vnode would actually be + * locked after calling dir's lookup function (i.e. looking up '.'). You + * shouldn't deal with any locking in namev_lookup(), but you should be aware of + * this special case when writing other functions that use namev_lookup(). + * Because you are the one writing nearly all of the calls to namev_lookup(), it + * is up to you both how you handle all inputs (i.e. dir or name is null, + * namelen is 0), and whether namev_lookup() even gets called with a bad input. + */ +long namev_lookup(vnode_t *dir, const char *name, size_t namelen, + vnode_t **res_vnode) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return ret; +} + +/* + * Find the next meaningful token in a string representing a path. + * + * Returns the token and sets `len` to be the token's length. + * + * Once all tokens have been returned, the next char* returned is either NULL + * or "" (the empty string). In order to handle both, if you're calling + * this in a loop, we suggest terminating the loop once the value returned + * in len is 0 + * + * Example usage: + * - "/dev/null" + * ==> *search would point to the first character of "/null" + * ==> *len would be 3 (as "dev" is of length 3) + * ==> namev_tokenize would return a pointer to the + * first character of "dev/null" + * + * - "a/b/c" + * ==> *search would point to the first character of "/b/c" + * ==> *len would be 1 (as "a" is of length 1) + * ==> namev_tokenize would return a pointer to the first character + * of "a/b/c" + * + * We highly suggest testing this function outside of Weenix; for instance + * using an online compiler or compiling and testing locally to fully + * understand its behavior. See handout for an example. + */ +static const char *namev_tokenize(const char **search, size_t *len) +{ + const char *begin; + + if (*search == NULL) + { + *len = 0; + return NULL; + } + + KASSERT(NULL != *search); + + /* Skip initial '/' to find the beginning of the token. */ + while (**search == '/') + { + (*search)++; + } + + /* Determine the length of the token by searching for either the + * next '/' or the end of the path. */ + begin = *search; + *len = 0; + while (**search && **search != '/') + { + (*len)++; + (*search)++; + } + + if (!**search) + { + *search = NULL; + } + + return begin; +} + +/* + * Parse path and return in `res_vnode` the vnode corresponding to the directory + * containing the basename (last element) of path. `base` must not be locked on + * entry or on return. `res_vnode` must not be locked on return. Return via `name` + * and `namelen` the basename of path. + * + * Return 0 on success, or: + * - EINVAL: path refers to an empty string + * - Propagate errors from namev_lookup() + * + * Hints: + * - When *calling* namev_dir(), if it is unclear what to pass as the `base`, you + * should use `curproc->p_cwd` (think about why this makes sense). + * - `curproc` is a global variable that represents the current running process + * (a proc_t struct), which has a field called p_cwd. + * - The first parameter, base, is the vnode from which to start resolving + * path, unless path starts with a '/', in which case you should start at + * the root vnode, vfs_root_fs.fs_root. + * - Use namev_lookup() to handle each individual lookup. When looping, be + * careful about locking and refcounts, and make sure to clean up properly + * upon failure. + * - namev_lookup() should return with the found vnode unlocked, unless the + * found vnode is the same as the given directory (e.g. "/./."). Be mindful + * of this special case, and any locking/refcounting that comes with it. + * - When parsing the path, you do not need to implement hand-over-hand + * locking. That is, when calling `namev_lookup(dir, path, pathlen, &out)`, + * it is safe to put away and unlock dir before locking `out`. + * - You are encouraged to use namev_tokenize() to help parse path. + * - Whether you're using the provided base or the root vnode, you will have + * to explicitly lock and reference your starting vnode before using it. + * - Don't allocate memory to return name. Just set name to point into the + * correct part of path. + * + * Example usage: + * - "/a/.././//b/ccc/" ==> res_vnode = vnode for b, name = "ccc", namelen = 3 + * - "tmp/..//." ==> res_vnode = base, name = ".", namelen = 1 + * - "/dev/null" ==> rev_vnode = vnode for /dev, name = "null", namelen = 4 + * For more examples of expected behavior, you can try out the command line + * utilities `dirname` and `basename` on your virtual machine or a Brown + * department machine. + */ +long namev_dir(vnode_t *base, const char *path, vnode_t **res_vnode, + const char **name, size_t *namelen) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return 0; +} + +/* + * Open the file specified by `base` and `path`, or create it, if necessary. + * Return the file's vnode via `res_vnode`, which should be returned unlocked + * and with an added reference. + * + * Return 0 on success, or: + * - EINVAL: O_CREAT is specified but path implies a directory + * - ENAMETOOLONG: path basename is too long + * - ENOTDIR: Attempting to open a regular file as a directory + * - Propagate errors from namev_dir() and namev_lookup() + * + * Hints: + * - A path ending in '/' implies that the basename is a directory. + * - Use namev_dir() to get the directory containing the basename. + * - Use namev_lookup() to try to obtain the desired vnode. + * - If namev_lookup() fails and O_CREAT is specified in oflags, use + * the parent directory's vnode operation mknod to create the vnode. + * Use the basename info from namev_dir(), and the mode and devid + * provided to namev_open(). + * - Use the macro S_ISDIR() to check if a vnode actually is a directory. + * - Use the macro NAME_LEN to check the basename length. Check out + * ramfs_mknod() to confirm that the name should be null-terminated. + */ +long namev_open(vnode_t *base, const char *path, int oflags, int mode, + devid_t devid, struct vnode **res_vnode) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return 0; +} + +/* + * Wrapper around namev_open with O_RDONLY and 0 mode/devid + */ +long namev_resolve(vnode_t *base, const char *path, vnode_t **res_vnode) +{ + return namev_open(base, path, O_RDONLY, 0, 0, res_vnode); +} + +#ifdef __GETCWD__ +/* Finds the name of 'entry' in the directory 'dir'. The name is writen + * to the given buffer. On success 0 is returned. If 'dir' does not + * contain 'entry' then -ENOENT is returned. If the given buffer cannot + * hold the result then it is filled with as many characters as possible + * and a null terminator, -ERANGE is returned. + * + * Files can be uniquely identified within a file system by their + * inode numbers. */ +int lookup_name(vnode_t *dir, vnode_t *entry, char *buf, size_t size) +{ + NOT_YET_IMPLEMENTED("GETCWD: ***none***"); + return -ENOENT; +} + +NOT_YET_IMPLEMENTED("GETCWD: ***none***"); + +/* Used to find the absolute path of the directory 'dir'. Since + * directories cannot have more than one link there is always + * a unique solution. The path is writen to the given buffer. + * On success 0 is returned. On error this function returns a + * negative error code. See the man page for getcwd(3) for + * possible errors. Even if an error code is returned the buffer + * will be filled with a valid string which has some partial + * information about the wanted path. */ +ssize_t lookup_dirpath(vnode_t *dir, char *buf, size_t osize) +{ + NOT_YET_IMPLEMENTED("GETCWD: ***none***"); + + return -ENOENT; +} +#endif /* __GETCWD__ */ diff --git a/kernel/fs/open.c b/kernel/fs/open.c new file mode 100644 index 0000000..fa6fe12 --- /dev/null +++ b/kernel/fs/open.c @@ -0,0 +1,67 @@ +#include "errno.h" +#include "fs/fcntl.h" +#include "fs/file.h" +#include "fs/vfs.h" +#include "fs/vfs_syscall.h" +#include "fs/vnode.h" +#include "globals.h" +#include "util/debug.h" +#include <fs/vnode.h> + +// NOTE: IF DOING MULTI-THREADED PROCS, NEED TO SYNCHRONIZE ACCESS TO FILE +// DESCRIPTORS, AND, MORE GENERALLY SPEAKING, p_files, IN PARTICULAR IN THIS +// FUNCTION AND ITS CALLERS. +/* + * Go through curproc->p_files and find the first null entry. + * If one exists, set fd to that index and return 0. + * + * Error cases get_empty_fd is responsible for generating: + * - EMFILE: no empty file descriptor + */ +long get_empty_fd(int *fd) +{ + for (*fd = 0; *fd < NFILES; (*fd)++) + { + if (!curproc->p_files[*fd]) + { + return 0; + } + } + *fd = -1; + return -EMFILE; +} + +/* + * Open the file at the provided path with the specified flags. + * + * Returns the file descriptor on success, or error cases: + * - EINVAL: Invalid oflags + * - EISDIR: Trying to open a directory with write access + * - ENXIO: Blockdev or chardev vnode does not have an actual underlying device + * - ENOMEM: Not enough kernel memory (if fcreate() fails) + * + * Hints: + * 1) Use get_empty_fd() to get an available fd. + * 2) Use namev_open() with oflags, mode S_IFREG, and devid 0. + * 3) Check for EISDIR and ENXIO errors. + * 4) Convert oflags (O_RDONLY, O_WRONLY, O_RDWR, O_APPEND) into corresponding + * file access flags (FMODE_READ, FMODE_WRITE, FMODE_APPEND). + * 5) Use fcreate() to create and initialize the corresponding file descriptor + * with the vnode from 2) and the mode from 4). + * + * When checking oflags, you only need to check that the read and write + * permissions are consistent. However, because O_RDONLY is 0 and O_RDWR is 2, + * there's no way to tell if both were specified. So, you really only need + * to check if O_WRONLY and O_RDWR were specified. + * + * If O_TRUNC specified and the vnode represents a regular file, make sure to call the + * the vnode's truncate routine (to reduce the size of the file to 0). + * + * If a vnode represents a chardev or blockdev, then the appropriate field of + * the vnode->vn_dev union will point to the device. Otherwise, the union will be NULL. + */ +long do_open(const char *filename, int oflags) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} diff --git a/kernel/fs/pipe.c b/kernel/fs/pipe.c new file mode 100644 index 0000000..b1d365f --- /dev/null +++ b/kernel/fs/pipe.c @@ -0,0 +1,256 @@ +/* + * FILE: pipe.c + * AUTH: eric + * DESC: Implementation of pipe(2) system call. + * DATE: Thu Dec 26 17:08:34 2013 + */ + +#include "errno.h" +#include "globals.h" + +#include "fs/file.h" +#include "fs/pipe.h" +#include "fs/stat.h" +#include "fs/vfs.h" +#include "fs/vfs_syscall.h" +#include "fs/vnode.h" + +#include "mm/kmalloc.h" +#include "mm/slab.h" + +#include "util/debug.h" +#include "util/string.h" + +#define PIPE_BUF_SIZE 4096 + +static void pipe_read_vnode(fs_t *fs, vnode_t *vnode); + +static void pipe_delete_vnode(fs_t *fs, vnode_t *vnode); + +static fs_ops_t pipe_fsops = {.read_vnode = pipe_read_vnode, + .delete_vnode = pipe_delete_vnode, + .umount = NULL}; + +static fs_t pipe_fs = {.fs_dev = "pipe", + .fs_type = "pipe", + .fs_ops = &pipe_fsops, + .fs_root = NULL, + .fs_i = NULL}; + +static long pipe_read(vnode_t *vnode, size_t pos, void *buf, size_t count); + +static long pipe_write(vnode_t *vnode, size_t pos, const void *buf, + size_t count); + +static long pipe_stat(vnode_t *vnode, stat_t *ss); + +static long pipe_acquire(vnode_t *vnode, file_t *file); + +static long pipe_release(vnode_t *vnode, file_t *file); + +static vnode_ops_t pipe_vops = { + .read = pipe_read, + .write = pipe_write, + .mmap = NULL, + .mknod = NULL, + .lookup = NULL, + .link = NULL, + .unlink = NULL, + .mkdir = NULL, + .rmdir = NULL, + .readdir = NULL, + .stat = pipe_stat, + .acquire = pipe_acquire, + .release = pipe_release, + .get_pframe = NULL, + .fill_pframe = NULL, + .flush_pframe = NULL, +}; + +/* struct pipe defines some data specific to pipes. One of these + should be present in the vn_i field of each pipe vnode. */ +typedef struct pipe +{ + /* Buffer for data in the pipe, which has been written but not yet read. */ + char *pv_buf; + /* + * Position of the head and number of characters in the buffer. You can + * write in characters at position head so long as size does not grow beyond + * the pipe buffer size. + */ + off_t pv_head; + size_t pv_size; + /* Number of file descriptors using this pipe for read and write. */ + int pv_readers; + int pv_writers; + /* + * Mutexes for reading and writing. Without these, readers might get non- + * contiguous reads in a single call (for example, if they empty the buffer + * but still have more to read, then the writer continues writing, waking up + * a different thread first) and similarly for writers. + */ + kmutex_t pv_rdlock; + kmutex_t pv_wrlock; + /* + * Waitqueues for threads attempting to read from an empty buffer, or + * write to a full buffer. When the pipe becomes non-empty (or non-full) + * then the corresponding waitq should be broadcasted on to make sure all + * of the threads get a chance to go. + */ + ktqueue_t pv_read_waitq; + ktqueue_t pv_write_waitq; +} pipe_t; + +#define VNODE_TO_PIPE(vn) ((pipe_t *)((vn)->vn_i)) + +static slab_allocator_t *pipe_allocator = NULL; +static int next_pno = 0; + +void pipe_init(void) +{ + pipe_allocator = slab_allocator_create("pipe", sizeof(pipe_t)); + KASSERT(pipe_allocator); +} + +/* + * Create a pipe struct here. You are going to need to allocate all + * of the necessary structs and buffers, and then initialize all of + * the necessary fields (head, size, readers, writers, and the locks + * and queues.) + */ +static pipe_t *pipe_create(void) +{ + NOT_YET_IMPLEMENTED("PIPES: ***none***"); + return NULL; +} + +/* + * Free all necessary memory. + */ +static void pipe_destroy(pipe_t *pipe) +{ + NOT_YET_IMPLEMENTED("PIPES: ***none***"); +} + +/* pipefs vnode operations */ +static void pipe_read_vnode(fs_t *fs, vnode_t *vnode) +{ + vnode->vn_ops = &pipe_vops; + vnode->vn_mode = S_IFIFO; + vnode->vn_len = 0; + vnode->vn_i = NULL; +} + +static void pipe_delete_vnode(fs_t *fs, vnode_t *vnode) +{ + pipe_t *p = VNODE_TO_PIPE(vnode); + if (p) + { + pipe_destroy(p); + } +} + +/* + * Gets a new vnode representing a pipe. The reason + * why we don't just do this setup in pipe_read_vnode + * is that the creation of the pipe data might fail, since + * there is memory allocation going on in there. Thus, + * we split it into two steps, the first of which relies on + * pipe_read_vnode to do some setup, and then the pipe_create + * call, at which point we can safely vput the allocated + * vnode if pipe_create fails. + */ +static vnode_t *pget(void) +{ + NOT_YET_IMPLEMENTED("PIPES: ***none***"); + return NULL; +} + +/* + * An implementation of the pipe(2) system call. You really + * only have to worry about a few things: + * o Running out of memory when allocating the vnode, at which + * point you should fail with ENOMEM; + * o Running out of file descriptors, in which case you should + * fail with EMFILE. + * Once all of the structures are set up, just put the read-end + * file descriptor of the pipe into pipefd[0], and the write-end + * descriptor into pipefd[1]. + */ +int do_pipe(int pipefd[2]) +{ + NOT_YET_IMPLEMENTED("PIPES: ***none***"); + return -ENOTSUP; +} + +/* + * When reading from a pipe, you should make sure there are enough characters in + * the buffer to read. If there are, grab them and move up the tail by + * subtracting from size. offset is ignored. Also, remember to take the reader + * lock to prevent other threads from reading while you are waiting for more + * characters. + * + * This might block, e.g. if there are no or not enough characters to read. + * It might be the case that there are no more writers and we aren't done + * reading. However, in situations like this, there is no way to open the pipe + * for writing again so no more writers will ever put characters in the pipe. + * The reader should just take as much as it needs (or barring that, as much as + * it can get) and return with a partial buffer. + */ +static long pipe_read(vnode_t *vnode, size_t pos, void *buf, size_t count) +{ + NOT_YET_IMPLEMENTED("PIPES: ***none***"); + return -EINVAL; +} + +/* + * Writing to a pipe is the dual of reading: if there is room, we can write our + * data and go, but if not, we have to wait until there is more room and alert + * any potential readers. Like above, you should take the writer lock to make + * sure your write is contiguous. + * + * If there are no more readers, we have a broken pipe, and should fail with + * the EPIPE error number. + */ +static long pipe_write(vnode_t *vnode, size_t pos, const void *buf, + size_t count) +{ + NOT_YET_IMPLEMENTED("PIPES: ***none***"); + return -EINVAL; +} + +/* + * It's still possible to stat a pipe using the fstat call, which takes a file + * descriptor. Pipes don't have too much information, though. The only ones that + * matter here are st_mode and st_ino, though you want to zero out some of the + * others. + */ +static long pipe_stat(vnode_t *vnode, stat_t *ss) +{ + NOT_YET_IMPLEMENTED("PIPES: ***none***"); + return -EINVAL; +} + +/* + * If someone is opening the read end of the pipe, we need to increment + * the reader count, and the same for the writer count if a file open + * for writing is acquiring this vnode. This count needs to be accurate + * for correct reading and writing behavior. + */ +static long pipe_acquire(vnode_t *vnode, file_t *file) +{ + NOT_YET_IMPLEMENTED("PIPES: ***none***"); + return 0; +} + +/* + * Subtract from the reader or writer count as necessary here. If either + * count hits zero, you are going to need to wake up the other group of + * threads so they can either return with their partial read or notice + * the broken pipe. + */ +static long pipe_release(vnode_t *vnode, file_t *file) +{ + NOT_YET_IMPLEMENTED("PIPES: ***none***"); + return 0; +} diff --git a/kernel/fs/ramfs/ramfs.c b/kernel/fs/ramfs/ramfs.c new file mode 100644 index 0000000..72547c4 --- /dev/null +++ b/kernel/fs/ramfs/ramfs.c @@ -0,0 +1,852 @@ +/* + * This is a special filesystem designed to be a test filesystem before s5fs has + * been written. It is an in-memory filesystem that supports almost all of the + * vnode operations. It has the following restrictions: + * + * o File sizes are limited to a single page (4096 bytes) in order + * to keep the code simple. + * + * o There is no support for fill_pframe, etc. + * + * o There is a maximum directory size limit + * + * o There is a maximum number of files/directories limit + */ + +#include "fs/ramfs/ramfs.h" +#include "errno.h" +#include "fs/dirent.h" +#include "fs/stat.h" +#include "fs/vfs.h" +#include "fs/vnode.h" +#include "globals.h" +#include "kernel.h" +#include "mm/kmalloc.h" +#include "mm/slab.h" +#include "util/debug.h" +#include "util/string.h" + +/* + * Filesystem operations + */ +static void ramfs_read_vnode(fs_t *fs, vnode_t *vn); + +static void ramfs_delete_vnode(fs_t *fs, vnode_t *vn); + +static long ramfs_umount(fs_t *fs); + +static fs_ops_t ramfs_ops = {.read_vnode = ramfs_read_vnode, + .delete_vnode = ramfs_delete_vnode, + .umount = ramfs_umount}; + +/* + * vnode operations + */ +static ssize_t ramfs_read(vnode_t *file, size_t offset, void *buf, + size_t count); + +static ssize_t ramfs_write(vnode_t *file, size_t offset, const void *buf, + size_t count); + +/* getpage */ +static ssize_t ramfs_create(vnode_t *dir, const char *name, size_t name_len, + vnode_t **result); + +static ssize_t ramfs_mknod(struct vnode *dir, const char *name, size_t name_len, + int mode, devid_t devid, struct vnode **out); + +static ssize_t ramfs_lookup(vnode_t *dir, const char *name, size_t namelen, + vnode_t **out); + +static long ramfs_link(vnode_t *dir, const char *name, size_t namelen, + vnode_t *child); + +static ssize_t ramfs_unlink(vnode_t *dir, const char *name, size_t name_len); + +static ssize_t ramfs_rename(vnode_t *olddir, const char *oldname, + size_t oldnamelen, vnode_t *newdir, + const char *newname, size_t newnamelen); + +static ssize_t ramfs_mkdir(vnode_t *dir, const char *name, size_t name_len, + struct vnode **out); + +static ssize_t ramfs_rmdir(vnode_t *dir, const char *name, size_t name_len); + +static ssize_t ramfs_readdir(vnode_t *dir, size_t offset, struct dirent *d); + +static ssize_t ramfs_stat(vnode_t *file, stat_t *buf); + +static void ramfs_truncate_file(vnode_t *file); + +static vnode_ops_t ramfs_dir_vops = {.read = NULL, + .write = NULL, + .mmap = NULL, + .mknod = ramfs_mknod, + .lookup = ramfs_lookup, + .link = ramfs_link, + .unlink = ramfs_unlink, + .rename = ramfs_rename, + .mkdir = ramfs_mkdir, + .rmdir = ramfs_rmdir, + .readdir = ramfs_readdir, + .stat = ramfs_stat, + .acquire = NULL, + .release = NULL, + .get_pframe = NULL, + .fill_pframe = NULL, + .flush_pframe = NULL, + .truncate_file = NULL}; + +static vnode_ops_t ramfs_file_vops = {.read = ramfs_read, + .write = ramfs_write, + .mmap = NULL, + .mknod = NULL, + .lookup = NULL, + .link = NULL, + .unlink = NULL, + .mkdir = NULL, + .rmdir = NULL, + .stat = ramfs_stat, + .acquire = NULL, + .release = NULL, + .get_pframe = NULL, + .fill_pframe = NULL, + .flush_pframe = NULL, + .truncate_file = ramfs_truncate_file}; + +/* + * The ramfs 'inode' structure + */ +typedef struct ramfs_inode +{ + size_t rf_size; /* Total file size */ + ino_t rf_ino; /* Inode number */ + char *rf_mem; /* Memory for this file (1 page) */ + ssize_t rf_mode; /* Type of file */ + ssize_t rf_linkcount; /* Number of links to this file */ +} ramfs_inode_t; + +#define RAMFS_TYPE_DATA 0 +#define RAMFS_TYPE_DIR 1 +#define RAMFS_TYPE_CHR 2 +#define RAMFS_TYPE_BLK 3 + +#define VNODE_TO_RAMFSINODE(vn) ((ramfs_inode_t *)(vn)->vn_i) +#define VNODE_TO_RAMFS(vn) ((ramfs_t *)(vn)->vn_fs->fs_i) +#define VNODE_TO_DIRENT(vn) ((ramfs_dirent_t *)VNODE_TO_RAMFSINODE(vn)->rf_mem) + +/* + * ramfs filesystem structure + */ +#define RAMFS_MAX_FILES 64 + +typedef struct ramfs +{ + ramfs_inode_t *rfs_inodes[RAMFS_MAX_FILES]; /* Array of all files */ +} ramfs_t; + +/* + * For directories, we simply store an array of (ino, name) pairs in the + * memory portion of the inode. + */ +typedef struct ramfs_dirent +{ + ssize_t rd_ino; /* Inode number of this entry */ + char rd_name[NAME_LEN]; /* Name of this entry */ +} ramfs_dirent_t; + +#define RAMFS_MAX_DIRENT ((size_t)(PAGE_SIZE / sizeof(ramfs_dirent_t))) + +/* Helper functions */ +static ssize_t ramfs_alloc_inode(fs_t *fs, ssize_t type, devid_t devid) +{ + ramfs_t *rfs = (ramfs_t *)fs->fs_i; + KASSERT((RAMFS_TYPE_DATA == type) || (RAMFS_TYPE_DIR == type) || + (RAMFS_TYPE_CHR == type) || (RAMFS_TYPE_BLK == type)); + /* Find a free inode */ + ssize_t i; + for (i = 0; i < RAMFS_MAX_FILES; i++) + { + if (NULL == rfs->rfs_inodes[i]) + { + ramfs_inode_t *inode; + if (NULL == (inode = kmalloc(sizeof(ramfs_inode_t)))) + { + return -ENOSPC; + } + + if (RAMFS_TYPE_CHR == type || RAMFS_TYPE_BLK == type) + { + /* Don't need any space in memory, so put devid in here */ + inode->rf_mem = (char *)(uint64_t)devid; + } + else + { + /* We allocate space for the file's contents immediately */ + if (NULL == (inode->rf_mem = page_alloc())) + { + kfree(inode); + return -ENOSPC; + } + memset(inode->rf_mem, 0, PAGE_SIZE); + } + inode->rf_size = 0; + inode->rf_ino = i; + inode->rf_mode = type; + inode->rf_linkcount = 1; + + /* Install in table and return */ + rfs->rfs_inodes[i] = inode; + return i; + } + } + return -ENOSPC; +} + +/* + * Function implementations + */ + +long ramfs_mount(struct fs *fs) +{ + /* Allocate filesystem */ + ramfs_t *rfs = kmalloc(sizeof(ramfs_t)); + if (NULL == rfs) + { + return -ENOMEM; + } + + memset(rfs->rfs_inodes, 0, sizeof(rfs->rfs_inodes)); + + fs->fs_i = rfs; + fs->fs_ops = &ramfs_ops; + + /* Set up root inode */ + ssize_t root_ino; + if (0 > (root_ino = ramfs_alloc_inode(fs, RAMFS_TYPE_DIR, 0))) + { + return root_ino; + } + + slab_allocator_t *allocator = + slab_allocator_create("ramfs_node", sizeof(vnode_t)); + fs->fs_vnode_allocator = allocator; + KASSERT(allocator); + + KASSERT(0 == root_ino); + ramfs_inode_t *root = rfs->rfs_inodes[root_ino]; + + /* Set up '.' and '..' in the root directory */ + ramfs_dirent_t *rootdent = (ramfs_dirent_t *)root->rf_mem; + rootdent->rd_ino = 0; + strcpy(rootdent->rd_name, "."); + rootdent++; + rootdent->rd_ino = 0; + strcpy(rootdent->rd_name, ".."); + + /* Increase root inode size accordingly */ + root->rf_size = 2 * sizeof(ramfs_dirent_t); + + /* Put the root in the inode table */ + rfs->rfs_inodes[0] = root; + + /* And vget the root vnode */ + fs->fs_root = vget(fs, 0); + + return 0; +} + +static void ramfs_read_vnode(fs_t *fs, vnode_t *vn) +{ + ramfs_t *rfs = VNODE_TO_RAMFS(vn); + ramfs_inode_t *inode = rfs->rfs_inodes[vn->vn_vno]; + KASSERT(inode && inode->rf_ino == vn->vn_vno); + + inode->rf_linkcount++; + + vn->vn_i = inode; + vn->vn_len = inode->rf_size; + + switch (inode->rf_mode) + { + case RAMFS_TYPE_DATA: + vn->vn_mode = S_IFREG; + vn->vn_ops = &ramfs_file_vops; + break; + case RAMFS_TYPE_DIR: + vn->vn_mode = S_IFDIR; + vn->vn_ops = &ramfs_dir_vops; + break; + case RAMFS_TYPE_CHR: + vn->vn_mode = S_IFCHR; + vn->vn_ops = NULL; + vn->vn_devid = (devid_t)(uint64_t)(inode->rf_mem); + break; + case RAMFS_TYPE_BLK: + vn->vn_mode = S_IFBLK; + vn->vn_ops = NULL; + vn->vn_devid = (devid_t)(uint64_t)(inode->rf_mem); + break; + default: + panic("inode %ld has unknown/invalid type %ld!!\n", + (ssize_t)vn->vn_vno, (ssize_t)inode->rf_mode); + } +} + +static void ramfs_delete_vnode(fs_t *fs, vnode_t *vn) +{ + ramfs_inode_t *inode = VNODE_TO_RAMFSINODE(vn); + ramfs_t *rfs = VNODE_TO_RAMFS(vn); + + if (0 == --inode->rf_linkcount) + { + KASSERT(rfs->rfs_inodes[vn->vn_vno] == inode); + + rfs->rfs_inodes[vn->vn_vno] = NULL; + if (inode->rf_mode == RAMFS_TYPE_DATA || + inode->rf_mode == RAMFS_TYPE_DIR) + { + page_free(inode->rf_mem); + } + /* otherwise, inode->rf_mem is a devid */ + + kfree(inode); + } +} + +static ssize_t ramfs_umount(fs_t *fs) +{ + /* We don't need to do any flushing or anything as everything is in memory. + * Just free all of our allocated memory */ + ramfs_t *rfs = (ramfs_t *)fs->fs_i; + + vput(&fs->fs_root); + + /* Free all the inodes */ + ssize_t i; + for (i = 0; i < RAMFS_MAX_FILES; i++) + { + if (NULL != rfs->rfs_inodes[i]) + { + if (NULL != rfs->rfs_inodes[i]->rf_mem && + (rfs->rfs_inodes[i]->rf_mode == RAMFS_TYPE_DATA || + rfs->rfs_inodes[i]->rf_mode == RAMFS_TYPE_DIR)) + { + page_free(rfs->rfs_inodes[i]->rf_mem); + } + kfree(rfs->rfs_inodes[i]); + } + } + + return 0; +} + +static ssize_t ramfs_create(vnode_t *dir, const char *name, size_t name_len, + vnode_t **result) +{ + vnode_t *vn; + size_t i; + ramfs_dirent_t *entry; + + /* Look for space in the directory */ + entry = VNODE_TO_DIRENT(dir); + for (i = 0; i < RAMFS_MAX_DIRENT; i++, entry++) + { + if (!entry->rd_name[0]) + { + break; + } + } + + if (i == RAMFS_MAX_DIRENT) + { + return -ENOSPC; + } + + /* Allocate an inode */ + ssize_t ino; + if (0 > (ino = ramfs_alloc_inode(dir->vn_fs, RAMFS_TYPE_DATA, 0))) + { + return ino; + } + + /* Get a vnode, set entry in directory */ + vn = vget(dir->vn_fs, (ino_t)ino); + + entry->rd_ino = vn->vn_vno; + strncpy(entry->rd_name, name, MIN(name_len, NAME_LEN - 1)); + entry->rd_name[MIN(name_len, NAME_LEN - 1)] = '\0'; + + VNODE_TO_RAMFSINODE(dir)->rf_size += sizeof(ramfs_dirent_t); + + *result = vn; + + return 0; +} + +static ssize_t ramfs_mknod(struct vnode *dir, const char *name, size_t name_len, + int mode, devid_t devid, struct vnode **out) +{ + size_t i; + ramfs_dirent_t *entry; + + /* Look for space in the directory */ + entry = VNODE_TO_DIRENT(dir); + for (i = 0; i < RAMFS_MAX_DIRENT; i++, entry++) + { + if (!entry->rd_name[0]) + { + break; + } + } + + if (i == RAMFS_MAX_DIRENT) + { + return -ENOSPC; + } + + ssize_t ino; + if (S_ISCHR(mode)) + { + ino = ramfs_alloc_inode(dir->vn_fs, RAMFS_TYPE_CHR, devid); + } + else if (S_ISBLK(mode)) + { + ino = ramfs_alloc_inode(dir->vn_fs, RAMFS_TYPE_BLK, devid); + } + else if (S_ISREG(mode)) + { + ino = ramfs_alloc_inode(dir->vn_fs, RAMFS_TYPE_DATA, devid); + } + else + { + panic("Invalid mode!\n"); + } + + if (ino < 0) + { + return ino; + } + + /* Set entry in directory */ + entry->rd_ino = ino; + strncpy(entry->rd_name, name, MIN(name_len, NAME_LEN - 1)); + entry->rd_name[MIN(name_len, NAME_LEN - 1)] = '\0'; + + VNODE_TO_RAMFSINODE(dir)->rf_size += sizeof(ramfs_dirent_t); + + vnode_t *child = vget(dir->vn_fs, ino); + + dbg(DBG_VFS, "creating ino(%ld), vno(%d) with path: %s\n", ino, + child->vn_vno, entry->rd_name); + + KASSERT(child); + *out = child; + return 0; +} + +static ssize_t ramfs_lookup(vnode_t *dir, const char *name, size_t namelen, + vnode_t **out) +{ + size_t i; + ramfs_inode_t *inode = VNODE_TO_RAMFSINODE(dir); + ramfs_dirent_t *entry = (ramfs_dirent_t *)inode->rf_mem; + + for (i = 0; i < RAMFS_MAX_DIRENT; i++, entry++) + { + if (name_match(entry->rd_name, name, namelen)) + { + if (dir->vn_vno != entry->rd_ino) + { + fs_t *fs = (dir)->vn_fs; + *out = vget(fs, entry->rd_ino); + } + else + { + vref(dir); + *out = dir; + } + return 0; + } + } + + return -ENOENT; +} + +static ssize_t ramfs_find_dirent(vnode_t *dir, const char *name, + size_t namelen) +{ + size_t i; + ramfs_inode_t *inode = VNODE_TO_RAMFSINODE(dir); + ramfs_dirent_t *entry = (ramfs_dirent_t *)inode->rf_mem; + + for (i = 0; i < RAMFS_MAX_DIRENT; i++, entry++) + { + if (name_match(entry->rd_name, name, namelen)) + { + return entry->rd_ino; + } + } + + return -ENOENT; +} + +static ssize_t ramfs_append_dirent(vnode_t *dir, const char *name, + size_t namelen, vnode_t *child) +{ + vnode_t *vn; + size_t i; + ramfs_dirent_t *entry; + + KASSERT(child->vn_fs == dir->vn_fs); + + /* Look for space in the directory */ + entry = VNODE_TO_DIRENT(dir); + for (i = 0; i < RAMFS_MAX_DIRENT; i++, entry++) + { + if (name_match(entry->rd_name, name, namelen)) + { + return -EEXIST; + } + + if (!entry->rd_name[0]) + { + break; + } + } + + if (i == RAMFS_MAX_DIRENT) + { + return -ENOSPC; + } + + /* Set entry in parent */ + entry->rd_ino = child->vn_vno; + strncpy(entry->rd_name, name, MIN(namelen, NAME_LEN - 1)); + entry->rd_name[MIN(namelen, NAME_LEN - 1)] = '\0'; + + VNODE_TO_RAMFSINODE(dir)->rf_size += sizeof(ramfs_dirent_t); + + /* Increase linkcount */ + VNODE_TO_RAMFSINODE(child)->rf_linkcount++; + + return 0; +} + +static ssize_t ramfs_delete_dirent(vnode_t *dir, const char *name, + size_t namelen, vnode_t *child) +{ + int found = 0; + size_t i; + ramfs_dirent_t *entry = VNODE_TO_DIRENT(dir); + for (i = 0; i < RAMFS_MAX_DIRENT; i++, entry++) + { + if (name_match(entry->rd_name, name, namelen)) + { + found = 1; + entry->rd_name[0] = '\0'; + break; + } + } + + if (!found) + { + return -EEXIST; + } + + VNODE_TO_RAMFSINODE(dir)->rf_size -= sizeof(ramfs_dirent_t); + VNODE_TO_RAMFSINODE(child)->rf_linkcount--; + + return 0; +} + +static long ramfs_link(vnode_t *dir, const char *name, size_t namelen, + vnode_t *child) +{ + return ramfs_append_dirent(dir, name, namelen, child); +} + +static ssize_t ramfs_unlink(vnode_t *dir, const char *name, size_t namelen) +{ + ssize_t ret; + size_t i; + ramfs_dirent_t *entry; + + vnode_t *vn = dir; + + long ino = ramfs_find_dirent(dir, name, namelen); + if (ino < 0) + { + return ino; + } + + vnode_t *child = vget_locked(dir->vn_fs, (ino_t)ino); + KASSERT(!S_ISDIR(child->vn_mode) && "handled at VFS level"); + + ret = ramfs_delete_dirent(dir, name, namelen, child); + KASSERT(ret == 0); + + vput_locked(&child); + + return 0; +} + +static ssize_t ramfs_rename(vnode_t *olddir, const char *oldname, + size_t oldnamelen, vnode_t *newdir, + const char *newname, size_t newnamelen) +{ + long ino = ramfs_find_dirent(olddir, oldname, oldnamelen); + if (ino < 0) + { + return ino; + } + + vnode_t *oldvn = vget_locked(olddir->vn_fs, (ino_t)ino); + if (S_ISDIR(oldvn->vn_mode)) + { + vput_locked(&oldvn); + return -EPERM; + } + if (S_ISDIR(oldvn->vn_mode)) + { + vput_locked(&oldvn); + return -EISDIR; + } + + /* Determine if an entry corresponding to `newname` already exists */ + ino = ramfs_find_dirent(newdir, newname, newnamelen); + if (ino != -ENOENT) + { + if (ino < 0) + { + return ino; + } + return -EEXIST; + } + + ssize_t ret = ramfs_append_dirent(newdir, newname, newnamelen, oldvn); + if (ret < 0) + { + vput_locked(&oldvn); + return ret; + } + + ret = ramfs_delete_dirent(olddir, oldname, oldnamelen, oldvn); + vput_locked(&oldvn); + + return ret; +} + +static ssize_t ramfs_mkdir(vnode_t *dir, const char *name, size_t name_len, + struct vnode **out) +{ + vnode_t *vn; + size_t i; + ramfs_dirent_t *entry; + + /* Look for space in the directory */ + entry = VNODE_TO_DIRENT(dir); + for (i = 0; i < RAMFS_MAX_DIRENT; i++, entry++) + { + if (!entry->rd_name[0]) + { + break; + } + } + + if (i == RAMFS_MAX_DIRENT) + { + return -ENOSPC; + } + + /* Allocate an inode */ + ssize_t ino; + if (0 > (ino = ramfs_alloc_inode(dir->vn_fs, RAMFS_TYPE_DIR, 0))) + { + return ino; + } + + /* Set entry in parent */ + entry->rd_ino = ino; + strncpy(entry->rd_name, name, MIN(name_len, NAME_LEN - 1)); + entry->rd_name[MIN(name_len, NAME_LEN - 1)] = '\0'; + + VNODE_TO_RAMFSINODE(dir)->rf_size += sizeof(ramfs_dirent_t); + + /* Set up '.' and '..' in the directory */ + entry = (ramfs_dirent_t *)VNODE_TO_RAMFS(dir)->rfs_inodes[ino]->rf_mem; + entry->rd_ino = ino; + strcpy(entry->rd_name, "."); + entry++; + entry->rd_ino = dir->vn_vno; + strcpy(entry->rd_name, ".."); + + /* Increase inode size accordingly */ + VNODE_TO_RAMFS(dir)->rfs_inodes[ino]->rf_size = 2 * sizeof(ramfs_dirent_t); + + /* This probably can't fail... (unless OOM :/) */ + *out = vget(dir->vn_fs, ino); + + return 0; +} + +static ssize_t ramfs_rmdir(vnode_t *dir, const char *name, size_t name_len) +{ + ssize_t ret; + size_t i; + ramfs_dirent_t *entry; + + KASSERT(!name_match(".", name, name_len) && + !name_match("..", name, name_len)); + + long ino = ramfs_find_dirent(dir, name, name_len); + if (ino < 0) + { + return ino; + } + + vnode_t *child = vget_locked(dir->vn_fs, (ino_t)ino); + if (!S_ISDIR(child->vn_mode)) + { + vput_locked(&child); + return -ENOTDIR; + } + + /* We have to make sure that this directory is empty */ + entry = VNODE_TO_DIRENT(child); + for (i = 0; i < RAMFS_MAX_DIRENT; i++, entry++) + { + if (!strcmp(entry->rd_name, ".") || !strcmp(entry->rd_name, "..")) + { + continue; + } + + if (entry->rd_name[0]) + { + vput_locked(&child); + return -ENOTEMPTY; + } + } + + /* Finally, remove the entry from the parent directory */ + entry = VNODE_TO_DIRENT(dir); + for (i = 0; i < RAMFS_MAX_DIRENT; i++, entry++) + { + if (name_match(entry->rd_name, name, name_len)) + { + entry->rd_name[0] = '\0'; + break; + } + } + VNODE_TO_RAMFSINODE(dir)->rf_size -= sizeof(ramfs_dirent_t); + + VNODE_TO_RAMFSINODE(child)->rf_linkcount--; + vput_locked(&child); + + return 0; +} + +static ssize_t ramfs_read(vnode_t *file, size_t offset, void *buf, + size_t count) +{ + ssize_t ret; + ramfs_inode_t *inode = VNODE_TO_RAMFSINODE(file); + + KASSERT(!S_ISDIR(file->vn_mode)); + + if (offset > inode->rf_size) + { + ret = 0; + } + else if (offset + count > inode->rf_size) + { + ret = inode->rf_size - offset; + } + else + { + ret = count; + } + + memcpy(buf, inode->rf_mem + offset, ret); + return ret; +} + +static ssize_t ramfs_write(vnode_t *file, size_t offset, const void *buf, + size_t count) +{ + ssize_t ret; + ramfs_inode_t *inode = VNODE_TO_RAMFSINODE(file); + + KASSERT(!S_ISDIR(file->vn_mode)); + + ret = MIN((size_t)count, (size_t)PAGE_SIZE - offset); + memcpy(inode->rf_mem + offset, buf, ret); + + KASSERT(file->vn_len == inode->rf_size); + file->vn_len = MAX(file->vn_len, offset + ret); + inode->rf_size = file->vn_len; + + return ret; +} + +static ssize_t ramfs_readdir(vnode_t *dir, size_t offset, struct dirent *d) +{ + ssize_t ret = 0; + ramfs_dirent_t *dir_entry, *targ_entry; + + KASSERT(S_ISDIR(dir->vn_mode)); + KASSERT(0 == offset % sizeof(ramfs_dirent_t)); + + dir_entry = VNODE_TO_DIRENT(dir); + dir_entry = (ramfs_dirent_t *)(((char *)dir_entry) + offset); + targ_entry = dir_entry; + + while ((offset < (size_t)(RAMFS_MAX_DIRENT * sizeof(ramfs_dirent_t))) && + (!targ_entry->rd_name[0])) + { + ++targ_entry; + offset += sizeof(ramfs_dirent_t); + } + + if (offset >= (size_t)(RAMFS_MAX_DIRENT * sizeof(ramfs_dirent_t))) + { + return 0; + } + + ret = sizeof(ramfs_dirent_t) + + (targ_entry - dir_entry) * sizeof(ramfs_dirent_t); + + d->d_ino = targ_entry->rd_ino; + d->d_off = 0; /* unused */ + strncpy(d->d_name, targ_entry->rd_name, NAME_LEN - 1); + d->d_name[NAME_LEN - 1] = '\0'; + return ret; +} + +static ssize_t ramfs_stat(vnode_t *file, stat_t *buf) +{ + ramfs_inode_t *i = VNODE_TO_RAMFSINODE(file); + memset(buf, 0, sizeof(stat_t)); + buf->st_mode = file->vn_mode; + buf->st_ino = (ssize_t)file->vn_vno; + buf->st_dev = 0; + if (file->vn_mode == S_IFCHR || file->vn_mode == S_IFBLK) + { + buf->st_rdev = (ssize_t)i->rf_mem; + } + buf->st_nlink = i->rf_linkcount - 1; + buf->st_size = (ssize_t)i->rf_size; + buf->st_blksize = (ssize_t)PAGE_SIZE; + buf->st_blocks = 1; + + return 0; +} + +static void ramfs_truncate_file(vnode_t *file) +{ + KASSERT(S_ISREG(file->vn_mode) && "This routine should only be called for regular files"); + ramfs_inode_t *i = VNODE_TO_RAMFSINODE(file); + i->rf_size = 0; + file->vn_len = 0; + memset(i->rf_mem, 0, PAGE_SIZE); +}
\ No newline at end of file diff --git a/kernel/fs/s5fs/s5fs.c b/kernel/fs/s5fs/s5fs.c new file mode 100644 index 0000000..3790c1a --- /dev/null +++ b/kernel/fs/s5fs/s5fs.c @@ -0,0 +1,860 @@ +#include "errno.h" +#include "globals.h" +#include "kernel.h" +#include <mm/slab.h> + +#include "util/debug.h" +#include "util/printf.h" +#include "util/string.h" + +#include "proc/kmutex.h" + +#include "fs/dirent.h" +#include "fs/file.h" +#include "fs/s5fs/s5fs.h" +#include "fs/s5fs/s5fs_subr.h" +#include "fs/stat.h" + +#include "mm/kmalloc.h" + +static long s5_check_super(s5_super_t *super); + +static long s5fs_check_refcounts(fs_t *fs); + +static void s5fs_read_vnode(fs_t *fs, vnode_t *vn); + +static void s5fs_delete_vnode(fs_t *fs, vnode_t *vn); + +static long s5fs_umount(fs_t *fs); + +static void s5fs_sync(fs_t *fs); + +static ssize_t s5fs_read(vnode_t *vnode, size_t pos, void *buf, size_t len); + +static ssize_t s5fs_write(vnode_t *vnode, size_t pos, const void *buf, + size_t len); + +static long s5fs_mmap(vnode_t *file, mobj_t **ret); + +static long s5fs_mknod(struct vnode *dir, const char *name, size_t namelen, + int mode, devid_t devid, struct vnode **out); + +static long s5fs_lookup(vnode_t *dir, const char *name, size_t namelen, + vnode_t **out); + +static long s5fs_link(vnode_t *dir, const char *name, size_t namelen, + vnode_t *child); + +static long s5fs_unlink(vnode_t *vdir, const char *name, size_t namelen); + +static long s5fs_rename(vnode_t *olddir, const char *oldname, size_t oldnamelen, + vnode_t *newdir, const char *newname, + size_t newnamelen); + +static long s5fs_mkdir(vnode_t *dir, const char *name, size_t namelen, + struct vnode **out); + +static long s5fs_rmdir(vnode_t *parent, const char *name, size_t namelen); + +static long s5fs_readdir(vnode_t *vnode, size_t pos, struct dirent *d); + +static long s5fs_stat(vnode_t *vnode, stat_t *ss); + +static void s5fs_truncate_file(vnode_t *vnode); + +static long s5fs_release(vnode_t *vnode, file_t *file); + +static long s5fs_get_pframe(vnode_t *vnode, size_t pagenum, long forwrite, + pframe_t **pfp); + +static long s5fs_fill_pframe(vnode_t *vnode, pframe_t *pf); + +static long s5fs_flush_pframe(vnode_t *vnode, pframe_t *pf); + +fs_ops_t s5fs_fsops = {.read_vnode = s5fs_read_vnode, + .delete_vnode = s5fs_delete_vnode, + .umount = s5fs_umount, + .sync = s5fs_sync}; + +static vnode_ops_t s5fs_dir_vops = {.read = NULL, + .write = NULL, + .mmap = NULL, + .mknod = s5fs_mknod, + .lookup = s5fs_lookup, + .link = s5fs_link, + .unlink = s5fs_unlink, + .rename = s5fs_rename, + .mkdir = s5fs_mkdir, + .rmdir = s5fs_rmdir, + .readdir = s5fs_readdir, + .stat = s5fs_stat, + .acquire = NULL, + .release = NULL, + .get_pframe = s5fs_get_pframe, + .fill_pframe = s5fs_fill_pframe, + .flush_pframe = s5fs_flush_pframe, + .truncate_file = NULL}; + +static vnode_ops_t s5fs_file_vops = {.read = s5fs_read, + .write = s5fs_write, + .mmap = s5fs_mmap, + .mknod = NULL, + .lookup = NULL, + .link = NULL, + .unlink = NULL, + .mkdir = NULL, + .rmdir = NULL, + .readdir = NULL, + .stat = s5fs_stat, + .acquire = NULL, + .release = NULL, + .get_pframe = s5fs_get_pframe, + .fill_pframe = s5fs_fill_pframe, + .flush_pframe = s5fs_flush_pframe, + .truncate_file = s5fs_truncate_file}; + + +static mobj_ops_t s5fs_mobj_ops = {.get_pframe = NULL, + .fill_pframe = blockdev_fill_pframe, + .flush_pframe = blockdev_flush_pframe, + .destructor = NULL}; + +/* + * Initialize the passed-in fs_t. The only members of fs_t that are initialized + * before the call to s5fs_mount are fs_dev and fs_type ("s5fs"). You must + * initialize everything else: fs_vnode_allocator, fs_i, fs_ops, fs_root. + * + * Initialize the block device for the s5fs_t that is created, and copy + * the super block from disk into memory. + */ +long s5fs_mount(fs_t *fs) +{ + int num; + + KASSERT(fs); + + if (sscanf(fs->fs_dev, "disk%d", &num) != 1) + { + return -EINVAL; + } + + blockdev_t *dev = blockdev_lookup(MKDEVID(DISK_MAJOR, num)); + if (!dev) + return -EINVAL; + + slab_allocator_t *allocator = + slab_allocator_create("s5_node", sizeof(s5_node_t)); + fs->fs_vnode_allocator = allocator; + + s5fs_t *s5fs = (s5fs_t *)kmalloc(sizeof(s5fs_t)); + + if (!s5fs) + { + slab_allocator_destroy(fs->fs_vnode_allocator); + fs->fs_vnode_allocator = NULL; + return -ENOMEM; + } + + mobj_init(&s5fs->s5f_mobj, MOBJ_FS, &s5fs_mobj_ops); + s5fs->s5f_bdev = dev; + +#ifndef OLD + pframe_t *pf; + s5_get_meta_disk_block(s5fs, S5_SUPER_BLOCK, 0, &pf); + memcpy(&s5fs->s5f_super, pf->pf_addr, sizeof(s5_super_t)); + s5_release_disk_block(&pf); +#endif + + if (s5_check_super(&s5fs->s5f_super)) + { + kfree(s5fs); + slab_allocator_destroy(fs->fs_vnode_allocator); + fs->fs_vnode_allocator = NULL; + return -EINVAL; + } + + kmutex_init(&s5fs->s5f_mutex); + + s5fs->s5f_fs = fs; + + fs->fs_i = s5fs; + fs->fs_ops = &s5fs_fsops; + fs->fs_root = vget(fs, s5fs->s5f_super.s5s_root_inode); + // vunlock(fs->fs_root); + + return 0; +} + +/* Initialize a vnode and inode by reading its corresponding inode info from + * disk. + * + * Hints: + * - To read the inode from disk, you will need to use the following: + * - VNODE_TO_S5NODE to obtain the s5_node_t with the inode corresponding + * to the provided vnode + * - FS_TO_S5FS to obtain the s5fs object + * - S5_INODE_BLOCK(vn->v_vno) to determine the block number of the block that + * contains the inode info + * - s5_get_disk_block and s5_release_disk_block to handle the disk block + * - S5_INODE_OFFSET to find the desired inode within the disk block + * containing it (returns the offset that the inode is stored within the block) + * - You should initialize the s5_node_t's inode field by reading directly from + * the inode on disk by using the page frame returned from s5_get_disk_block. Also + * make sure to initialize the dirtied_inode field. + * - Using the inode info, you need to initialize the following vnode fields: + * vn_len, vn_mode, and vn_ops using the fields found in the s5_inode struct. + * - See stat.h for vn_mode values. + * - For character and block devices: + * 1) Initialize vn_devid by reading the inode's s5_indirect_block field. + * 2) Set vn_ops to NULL. + */ +static void s5fs_read_vnode(fs_t *fs, vnode_t *vn) +{ + NOT_YET_IMPLEMENTED("S5FS: ***none***"); +} + +/* Clean up the inode corresponding to the given vnode. + * + * Hints: + * - This function is called in the following way: + * mobj_put -> vnode_destructor -> s5fs_delete_vnode. + * - Cases to consider: + * 1) The inode is no longer in use (linkcount == 0), so free it using + * s5_free_inode. + * 2) The inode is dirty, so write it back to disk. + * 3) The inode is unchanged, so do nothing. + */ +static void s5fs_delete_vnode(fs_t *fs, vnode_t *vn) +{ + NOT_YET_IMPLEMENTED("S5FS: ***none***"); +} + +/* + * See umount in vfs.h + * + * Check reference counts and the super block. + * Put the fs_root. + * Write the super block out to disk. + * Flush the underlying memory object. + */ +static long s5fs_umount(fs_t *fs) +{ + s5fs_t *s5fs = FS_TO_S5FS(fs); + blockdev_t *bd = s5fs->s5f_bdev; + + if (s5fs_check_refcounts(fs)) + { + panic( + "s5fs_umount: WARNING: linkcount corruption " + "discovered in fs on block device with major %d " + "and minor %d!!\n", + MAJOR(bd->bd_id), MINOR(bd->bd_id)); + } + if (s5_check_super(&s5fs->s5f_super)) + { + panic( + "s5fs_umount: WARNING: corrupted superblock " + "discovered on fs on block device with major %d " + "and minor %d!!\n", + MAJOR(bd->bd_id), MINOR(bd->bd_id)); + } + + vput(&fs->fs_root); + + s5fs_sync(fs); + kfree(s5fs); + return 0; +} + +static void s5fs_sync(fs_t *fs) +{ +#ifdef FIXME + s5fs_t *s5fs = FS_TO_S5FS(fs); + #ifdef OLD + mobj_t *mobj = S5FS_TO_VMOBJ(s5fs); + #endif + mobj_t *mobj = 0; // XXX FIX ME + + mobj_lock(mobj); + + pframe_t *pf; + mobj_get_pframe(mobj, S5_SUPER_BLOCK, 1, &pf); + memcpy(pf->pf_addr, &s5fs->s5f_super, sizeof(s5_super_t)); + pframe_release(&pf); + + mobj_flush(S5FS_TO_VMOBJ(s5fs)); + mobj_unlock(S5FS_TO_VMOBJ(s5fs)); +#endif +} + +/* Wrapper around s5_read_file. */ +static ssize_t s5fs_read(vnode_t *vnode, size_t pos, void *buf, size_t len) +{ + KASSERT(!S_ISDIR(vnode->vn_mode) && "should be handled at the VFS level"); + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/* Wrapper around s5_write_file. */ +static ssize_t s5fs_write(vnode_t *vnode, size_t pos, const void *buf, + size_t len) +{ + KASSERT(!S_ISDIR(vnode->vn_mode) && "should be handled at the VFS level"); + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/* + * Any error handling should have been done before this function was called. + * Simply add a reference to the underlying mobj and return it through ret. + */ +static long s5fs_mmap(vnode_t *file, mobj_t **ret) +{ + NOT_YET_IMPLEMENTED("VM: ***none***"); + return 0; +} + +/* Allocate and initialize an inode and its corresponding vnode. + * + * dir - The directory in which to make the new inode + * name - The name of the new inode + * namelen - Name length + * mode - vn_mode of the new inode, see S_IF{} macros in stat.h + * devid - devid of the new inode for special devices + * out - Upon success, out must point to the newly created vnode + * Upon failure, out must be unchanged + * + * Return 0 on success, or: + * - ENOTSUP: mode is not S_IFCHR, S_BLK, or S_ISREG + * - Propagate errors from s5_alloc_inode and s5_link + * + * Hints: + * - Use mode to determine the S5_TYPE_{} for the inode. + * - Use s5_alloc_inode is allocate a new inode. + * - Use vget to obtain the vnode corresponding to the newly created inode. + * - Use s5_link to link the newly created inode/vnode to the parent directory. + * - You will need to clean up the vnode using vput in the case that + * the link operation fails. + */ +static long s5fs_mknod(struct vnode *dir, const char *name, size_t namelen, + int mode, devid_t devid, struct vnode **out) +{ + KASSERT(S_ISDIR(dir->vn_mode) && "should be handled at the VFS level"); + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/* Search for a given entry within a directory. + * + * dir - The directory in which to search + * name - The name to search for + * namelen - Name length + * ret - Upon success, ret must point to the found vnode + * + * Return 0 on success, or: + * - Propagate errors from s5_find_dirent + * + * Hints: + * - Use s5_find_dirent, vget, and vref. + * - vref can be used in the case where the vnode you're looking for happens + * to be dir itself. + */ +long s5fs_lookup(vnode_t *dir, const char *name, size_t namelen, + vnode_t **ret) +{ + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/* Wrapper around s5_link. + * + * Return whatever s5_link returns, or: + * - EISDIR: child is a directory + */ +static long s5fs_link(vnode_t *dir, const char *name, size_t namelen, + vnode_t *child) +{ + KASSERT(S_ISDIR(dir->vn_mode) && "should be handled at the VFS level"); + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/* Remove the directory entry in dir corresponding to name and namelen. + * + * Return 0 on success, or: + * - Propagate errors from s5_find_dirent + * + * Hints: + * - Use s5_find_dirent and s5_remove_dirent. + * - You will probably want to use vget_locked and vput_locked to protect the + * found vnode. Make sure your implementation of s5_remove_dirent knows what + * to expect. + */ +static long s5fs_unlink(vnode_t *dir, const char *name, size_t namelen) +{ + KASSERT(S_ISDIR(dir->vn_mode) && "should be handled at the VFS level"); + KASSERT(!name_match(".", name, namelen)); + KASSERT(!name_match("..", name, namelen)); + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/* Change the name or location of a file. + * + * olddir - The directory in which the file currently resides + * oldname - The old name of the file + * oldnamelen - Length of the old name + * newdir - The directory in which to place the file + * newname - The new name of the file + * newnamelen - Length of the new name + * + * Return 0 on success, or: + * - ENAMETOOLONG: newname is >= NAME_LEN + * - ENOTDIR: newdir is not a directory + * - EISDIR: newname is a directory + * - Propagate errors from s5_find_dirent and s5_link + * + * Steps: + * 1) Use s5_find_dirent and vget_locked to obtain the vnode corresponding to old name. + * 2) If newdir already contains an entry for newname: + * a) Compare node numbers and do nothing if old name and new name refer to the same inode + * b) Check if new-name is a directory + * c) Remove the previously existing entry for new name using s5_remove_dirent + * d) Link the new direct using s5_link + * 3) If there is no entry for newname, use s5_link to add a link to the old node at new name + * 4) Use s5_remove_dirent to remove old name’s entry in olddir + * + * + * Hints: + * - olddir and newdir should be locked on entry and not unlocked during the + * duration of this function. Any other vnodes locked should be unlocked and + * put before return. + * - Be careful with locking! Because you are making changes to the vnodes, + * you should always be using vget_locked and vput_locked. Be sure to clean + * up properly in error/special cases. + * - You DO NOT need to support renaming of directories in Weenix. If you were to support this + * in the s5fs layer (which is not extra credit), you can use the following routine: + * 1) Use s5_find_dirent and vget_locked to obtain the vnode corresponding to old name. + * 2) If newer already contains an entry for newname: + * a) Compare node numbers and do nothing if old name and new name refer to the same inode + * b) Check if new-name is a directory + * c) Remove the previously existing entry for new name using s5_remove_dirent + * d) Link the new direct using s5_link + * 3) If there is no entry for newname, use s5_link to add a link to the old node at new name + * 4) Use s5_remove_dirent to remove old name’s entry in olddir + */ +static long s5fs_rename(vnode_t *olddir, const char *oldname, size_t oldnamelen, + vnode_t *newdir, const char *newname, + size_t newnamelen) +{ + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/* Create a directory. + * + * dir - The directory in which to create the new directory + * name - The name of the new directory + * namelen - Name length of the new directory + * out - On success, must point to the new directory, unlocked + * On failure, must be unchanged + * + * Return 0 on success, or: + * - Propagate errors from s5_alloc_inode and s5_link + * + * Steps: + * 1) Allocate an inode. + * 2) Get the child directory vnode. + * 3) Create the "." entry. + * 4) Create the ".." entry. + * 5) Create the name/namelen entry in the parent (that corresponds + * to the new directory) + * + * Hints: + * - If you run into any errors, you must undo previous steps. + * - You may assume/assert that undo operations do not fail. + * - It may help to assert that linkcounts are correct. + */ +static long s5fs_mkdir(vnode_t *dir, const char *name, size_t namelen, + struct vnode **out) +{ + KASSERT(S_ISDIR((dir)->vn_mode) && "should be handled at the VFS level"); + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/* Remove a directory. + * + * Return 0 on success, or: + * - ENOTDIR: The specified entry is not a directory + * - ENOTEMPTY: The directory to be removed has entries besides "." and ".." + * - Propagate errors from s5_find_dirent + * + * Hints: + * - If you are confident you are managing directory entries properly, you can + * check for ENOTEMPTY by simply checking the length of the directory to be + * removed. An empty directory has two entries: "." and "..". + * - Remove the three entries created in s5fs_mkdir. + */ +static long s5fs_rmdir(vnode_t *parent, const char *name, size_t namelen) +{ + KASSERT(!name_match(".", name, namelen)); + KASSERT(!name_match("..", name, namelen)); + KASSERT(S_ISDIR(parent->vn_mode) && "should be handled at the VFS level"); + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/* Read a directory entry. + * + * vnode - The directory from which to read an entry + * pos - The position within the directory to start reading from + * d - Caller-allocated dirent that must be properly initialized on + * successful return + * + * Return bytes read on success, or: + * - Propagate errors from s5_read_file + * + * Hints: + * - Use s5_read_file to read an s5_dirent_t. To do so, you can create a local + * s5_dirent_t variable and use that as the buffer to pass into s5_read_file. + * - Be careful that you read into an s5_dirent_t and populate the provided + * dirent_t properly. + */ +static long s5fs_readdir(vnode_t *vnode, size_t pos, struct dirent *d) +{ + KASSERT(S_ISDIR(vnode->vn_mode) && "should be handled at the VFS level"); + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/* Get file status. + * + * vnode - The vnode of the file in question + * ss - Caller-allocated stat_t struct that must be initialized on success + * + * This function should not fail. + * + * Hint: + * - Initialize st_blocks using s5_inode_blocks. + * - Initialize st_mode using the corresponding vnode modes in stat.h. + * - Initialize st_rdev with the devid of special devices. + * - Initialize st_ino with the inode number. + * - Initialize st_nlink with the linkcount. + * - Initialize st_blksize with S5_BLOCK_SIZE. + * - Initialize st_size with the size of the file. + * - Initialize st_dev with the bd_id of the s5fs block device. + * - Set all other fields to 0. + */ +static long s5fs_stat(vnode_t *vnode, stat_t *ss) +{ + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/** + * Truncate the vnode and inode length to be 0. + * + * file - the vnode, whose size should be truncated + * + * This routine should only be called from do_open via + * vn_ops in the case that a regular file is opened with the + * O_TRUNC flag specified. + */ +static void s5fs_truncate_file(vnode_t *file) +{ + KASSERT(S_ISREG(file->vn_mode) && "This routine should only be called for regular files"); + file->vn_len = 0; + s5_node_t* s5_node = VNODE_TO_S5NODE(file); + s5_inode_t* s5_inode = &s5_node->inode; + // setting the size of the inode to be 0 as well + s5_inode->s5_un.s5_size = 0; + s5_node->dirtied_inode = 1; + + // Call subroutine to free the blocks that were used + vlock(file); + s5_remove_blocks(s5_node); + vunlock(file); +} + +#ifdef OLD +/* + * Wrapper around mobj_get_pframe. Remember to lock the memory object around + * the call to mobj_get_pframe. Assert that the get_pframe does not fail. + */ +inline void s5_get_disk_block(s5fs_t *s5fs, blocknum_t blocknum, long forwrite, + pframe_t **pfp) +{ + mobj_lock(S5FS_TO_VMOBJ(s5fs)); + long ret = mobj_get_pframe(S5FS_TO_VMOBJ(s5fs), blocknum, forwrite, pfp); + mobj_unlock(S5FS_TO_VMOBJ(s5fs)); + KASSERT(!ret && *pfp); +} +#endif + +/* + * Wrapper around device's read_block function; first looks up block in file-system cache. + * If not there, allocates and fills a page frame. + * Used for meta blocks, thus location is passed in. + */ +inline void s5_get_meta_disk_block(s5fs_t *s5fs, uint64_t blocknum, long forwrite, + pframe_t **pfp) +{ + mobj_lock(&s5fs->s5f_mobj); + mobj_find_pframe(&s5fs->s5f_mobj, blocknum, pfp); + if (*pfp) + { + // block is cached + mobj_unlock(&s5fs->s5f_mobj); + return; + } + mobj_create_pframe(&s5fs->s5f_mobj, blocknum, blocknum, pfp); + pframe_t *pf = *pfp; + pf->pf_addr = page_alloc(); + KASSERT(pf->pf_addr); + + blockdev_t *bd = s5fs->s5f_bdev; + long ret = bd->bd_ops->read_block(bd, pf->pf_addr, (blocknum_t)pf->pf_loc, 1); + pf->pf_dirty |= forwrite; // needed? + KASSERT (!ret); + mobj_unlock(&s5fs->s5f_mobj); + KASSERT(!ret && *pfp); +} + +/* + * Wrapper around device's read_block function; allocates and fills a page frame. + * Assumes cache has already been searched. + * Used for file blocks, thus file block number is supplied. + */ +static inline void s5_get_file_disk_block(vnode_t *vnode, uint64_t blocknum, uint64_t loc, long forwrite, + pframe_t **pfp) +{ + //mobj_lock(&vnode->vn_mobj); + mobj_create_pframe(&vnode->vn_mobj, blocknum, loc, pfp); + //mobj_unlock(&vnode->vn_mobj); + pframe_t *pf = *pfp; + pf->pf_addr = page_alloc(); + KASSERT(pf->pf_addr); + blockdev_t *bd = VNODE_TO_S5FS(vnode)->s5f_bdev; + long ret = bd->bd_ops->read_block(bd, pf->pf_addr, pf->pf_loc, 1); + pf->pf_dirty |= forwrite; // needed? + KASSERT (!ret); +} + +/* Wrapper around pframe_release. + * + * Note: All pframe_release does is unlock the pframe. Why aren't we actually + * writing anything back yet? Because the pframe remains associated with + * whatever mobj we provided when we originally called mobj_get_pframe. If + * anyone tries to access the pframe later, Weenix will just give them the + * cached page frame from the mobj. If the pframe is ever freed (most likely on + * shutdown), then it will be written back to disk: mobj_flush_pframe -> + * blockdev_flush_pframe. + */ +inline void s5_release_disk_block(pframe_t **pfp) { pframe_release(pfp); } + +/* + * This is where the abstraction of vnode file block/page --> disk block is + * finally implemented. Check that the requested page lies within vnode->vn_len. + * + * Of course, you will want to use s5_file_block_to_disk_block. Pay attention + * to what the forwrite argument to s5fs_get_pframe means for the alloc argument + * in s5_file_block_to_disk_block. + * + * If the disk block for the corresponding file block is sparse, you should use + * mobj_default_get_pframe on the vnode's own memory object. This will trickle + * down to s5fs_fill_pframe if the pframe is not already resident. + * + * Otherwise, if the disk block is NOT sparse, you will want to simply use + * s5_get_disk_block. NOTE: in this case, you also need to make sure you free + * the pframe that resides in the vnode itself for the requested pagenum. To + * do so, you will want to use mobj_find_pframe and mobj_free_pframe. + * + * Given the above design, we s5fs itself does not need to implement + * flush_pframe. Any pframe that will be written to (forwrite = 1) should always + * have a disk block backing it on successful return. Thus, the page frame will + * reside in the block device of the filesystem, where the flush_pframe is + * already implemented. We do, however, need to implement fill_pframe for sparse + * blocks. + */ +static long s5fs_get_pframe(vnode_t *vnode, uint64_t pagenum, long forwrite, + pframe_t **pfp) +{ +#ifdef OLD + if (vnode->vn_len <= pagenum * PAGE_SIZE) + return -EINVAL; + long loc = + s5_file_block_to_disk_block(VNODE_TO_S5NODE(vnode), pagenum, forwrite); + if (loc < 0) + return loc; + if (loc) + { + mobj_find_pframe(&vnode->vn_mobj, pagenum, pfp); + if (*pfp) + { + mobj_free_pframe(&vnode->vn_mobj, pfp); + } + s5_get_disk_block(VNODE_TO_S5FS(vnode), (blocknum_t)loc, forwrite, pfp); + return 0; + } + else + { + KASSERT(!forwrite); + return mobj_default_get_pframe(&vnode->vn_mobj, pagenum, forwrite, pfp); + } +#endif + + if (vnode->vn_len <= pagenum * PAGE_SIZE) + return -EINVAL; + mobj_find_pframe(&vnode->vn_mobj, pagenum, pfp); + if (*pfp) + { + // block is cached + return 0; + } + int new; + long loc = s5_file_block_to_disk_block(VNODE_TO_S5NODE(vnode), pagenum, forwrite, &new); + if (loc < 0) + return loc; + if (loc) { + // block is mapped + if (new) { + // block didn't previously exist, thus its current contents are meaningless + *pfp = s5_cache_and_clear_block(&vnode->vn_mobj, pagenum, loc); + } else { + // block must be read from disk + s5_get_file_disk_block(vnode, pagenum, loc, forwrite, pfp); + } + return 0; + } + else + { + // block is in a sparse region of the file + KASSERT(!forwrite); + return mobj_default_get_pframe(&vnode->vn_mobj, pagenum, forwrite, pfp); + } +} + +/* + * According the documentation for s5fs_get_pframe, this only gets called when + * the file block for a given page number is sparse. In other words, pf + * corresponds to a sparse block. + */ +static long s5fs_fill_pframe(vnode_t *vnode, pframe_t *pf) +{ + memset(pf->pf_addr, 0, PAGE_SIZE); + return 0; +} + +/* + * Verify the superblock. 0 on success; -1 on failure. + */ +static long s5_check_super(s5_super_t *super) +{ + if (!(super->s5s_magic == S5_MAGIC && + (super->s5s_free_inode < super->s5s_num_inodes || + super->s5s_free_inode == (uint32_t)-1) && + super->s5s_root_inode < super->s5s_num_inodes)) + { + return -1; + } + if (super->s5s_version != S5_CURRENT_VERSION) + { + dbg(DBG_PRINT, + "Filesystem is version %d; " + "only version %d is supported.\n", + super->s5s_version, S5_CURRENT_VERSION); + return -1; + } + return 0; +} + +/* + * Calculate refcounts on the filesystem. + */ +static void calculate_refcounts(int *counts, vnode_t *vnode) +{ + long ret; + + size_t pos = 0; + dirent_t dirent; + vnode_t *child; + + while ((ret = s5fs_readdir(vnode, pos, &dirent)) > 0) + { + counts[dirent.d_ino]++; + dbg(DBG_S5FS, "incrementing count of inode %d to %d\n", dirent.d_ino, + counts[dirent.d_ino]); + if (counts[dirent.d_ino] == 1) + { + child = vget_locked(vnode->vn_fs, dirent.d_ino); + if (S_ISDIR(child->vn_mode)) + { + calculate_refcounts(counts, child); + } + vput_locked(&child); + } + pos += ret; + } + + KASSERT(!ret); +} + +/* + * Verify refcounts on the filesystem. 0 on success; -1 on failure. + */ +long s5fs_check_refcounts(fs_t *fs) +{ + s5fs_t *s5fs = (s5fs_t *)fs->fs_i; + int *refcounts; + long ret = 0; + + refcounts = kmalloc(s5fs->s5f_super.s5s_num_inodes * sizeof(int)); + KASSERT(refcounts); + memset(refcounts, 0, s5fs->s5f_super.s5s_num_inodes * sizeof(int)); + + vlock(fs->fs_root); + refcounts[fs->fs_root->vn_vno]++; + calculate_refcounts(refcounts, fs->fs_root); + refcounts[fs->fs_root->vn_vno]--; + + vunlock(fs->fs_root); + + dbg(DBG_PRINT, + "Checking refcounts of s5fs filesystem on block " + "device with major %d, minor %d\n", + MAJOR(s5fs->s5f_bdev->bd_id), MINOR(s5fs->s5f_bdev->bd_id)); + + for (uint32_t i = 0; i < s5fs->s5f_super.s5s_num_inodes; i++) + { + if (!refcounts[i]) + { + continue; + } + + vnode_t *vn = vget(fs, i); + KASSERT(vn); + s5_node_t *sn = VNODE_TO_S5NODE(vn); + + if (refcounts[i] != sn->inode.s5_linkcount) + { + dbg(DBG_PRINT, " Inode %d, expecting %d, found %d\n", i, + refcounts[i], sn->inode.s5_linkcount); + ret = -1; + } + vput(&vn); + } + + dbg(DBG_PRINT, + "Refcount check of s5fs filesystem on block " + "device with major %d, minor %d completed %s.\n", + MAJOR(s5fs->s5f_bdev->bd_id), MINOR(s5fs->s5f_bdev->bd_id), + (ret ? "UNSUCCESSFULLY" : "successfully")); + + kfree(refcounts); + return ret; +} + +static long s5fs_flush_pframe(vnode_t *vnode, pframe_t *pf) { + return blockdev_flush_pframe(&((s5fs_t *)vnode->vn_fs->fs_i)->s5f_mobj, pf); +}
\ No newline at end of file diff --git a/kernel/fs/s5fs/s5fs_subr.c b/kernel/fs/s5fs/s5fs_subr.c new file mode 100644 index 0000000..c972d7c --- /dev/null +++ b/kernel/fs/s5fs/s5fs_subr.c @@ -0,0 +1,590 @@ +#include "fs/s5fs/s5fs_subr.h" +#include "drivers/blockdev.h" +#include "errno.h" +#include "fs/s5fs/s5fs.h" +#include "fs/stat.h" +#include "fs/vfs.h" +#include "fs/vnode.h" +#include "kernel.h" +#include "mm/pframe.h" +#include "proc/kmutex.h" +#include "util/debug.h" +#include "util/string.h" +#include <fs/s5fs/s5fs.h> + +static void s5_free_block(s5fs_t *s5fs, blocknum_t block); + +static long s5_alloc_block(s5fs_t *s5fs); + +static inline void s5_lock_super(s5fs_t *s5fs) +{ + kmutex_lock(&s5fs->s5f_mutex); +} + +static inline void s5_unlock_super(s5fs_t *s5fs) +{ + kmutex_unlock(&s5fs->s5f_mutex); +} + +/* Helper function to obtain inode info from disk given an inode number. + * + * s5fs - The file system (it will usually be obvious what to pass for this + * parameter) + * ino - Inode number to fetch + * forwrite - Set if you intend to write any fields in the s5_inode_t, clear + * if you only intend to read + * pfp - Return parameter for a page frame that will contain the disk + * block of the desired inode + * inodep - Return parameter for the s5_inode_t corresponding to the desired + * inode + */ +static inline void s5_get_inode(s5fs_t *s5fs, ino_t ino, long forwrite, + pframe_t **pfp, s5_inode_t **inodep) +{ + s5_get_meta_disk_block(s5fs, S5_INODE_BLOCK(ino), forwrite, pfp); + *inodep = (s5_inode_t *)(*pfp)->pf_addr + S5_INODE_OFFSET(ino); + KASSERT((*inodep)->s5_number == ino); +} + +/* Release an inode by releasing the page frame of the disk block containing the + * inode. See comments above s5_release_disk_block to see why we don't write + * anything back yet. + * + * pfp - The page frame containing the inode + * inodep - The inode to be released + * + * On return, pfp and inodep both point to NULL. + */ +static inline void s5_release_inode(pframe_t **pfp, s5_inode_t **inodep) +{ + KASSERT((s5_inode_t *)(*pfp)->pf_addr + + S5_INODE_OFFSET((*inodep)->s5_number) == + *inodep); + *inodep = NULL; + s5_release_disk_block(pfp); +} + +/* Helper function to obtain a specific block of a file. + * + * sn - The s5_node representing the file in question + * blocknum - The offset of the desired block relative to the beginning of the + * file, i.e. index 8000 is block 1 of the file, even though it may + * not be block 1 of the disk + * forwrite - Set if you intend to write to the block, clear if you only intend + * to read + * pfp - Return parameter for a page frame containing the block data + */ +static inline long s5_get_file_block(s5_node_t *sn, size_t blocknum, + long forwrite, pframe_t **pfp) +{ + return sn->vnode.vn_mobj.mo_ops.get_pframe(&sn->vnode.vn_mobj, blocknum, + forwrite, pfp); +} + +/* Release the page frame associated with a file block. See comments above + * s5_release_disk_block to see why we don't write anything back yet. + * + * On return, pfp points to NULL. + */ +static inline void s5_release_file_block(pframe_t **pfp) +{ + pframe_release(pfp); +} + +#ifdef OLD +/* Given a file and a file block number, return the disk block number of the + * desired file block. + * + * sn - The s5_node representing the file + * file_blocknum - The offset of the desired block relative to the beginning of + * the file + * alloc - If set, allocate the block / indirect block as necessary + * If clear, don't allocate sparse blocks + * + * Return a disk block number on success, or: + * - 0: The block is sparse, and alloc is clear, OR + * The indirect block would contain the block, but the indirect block is + * sparse, and alloc is clear + * - EINVAL: The specified block number is greater than or equal to + * S5_MAX_FILE_BLOCKS + * - Propagate errors from s5_alloc_block. + * + * Hints: + * - Use the file inode's s5_direct_blocks and s5_indirect_block to perform the + * translation. + * - Use s5_alloc_block to allocate blocks. + * - Be sure to mark the inode as dirty when appropriate, i.e. when you are + * making changes to the actual s5_inode_t struct. Hint: Does allocating a + * direct block dirty the inode? What about allocating the indirect block? + * Finally, what about allocating a block pointed to by the indirect block? + * - Cases to consider: + * 1) file_blocknum < S_NDIRECT_BLOCKS + * 2) Indirect block is not allocated but alloc is set. Be careful not to + * leak a block in an error case! + * 3) Indirect block is allocated. The desired block may be sparse, and you + * may have to allocate it. + * 4) The indirect block has not been allocated and alloc is clear. + */ +long s5_file_block_to_disk_block(s5_node_t *sn, size_t file_blocknum, + int alloc) +{ + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} +#endif + + +long s5_file_block_to_disk_block(s5_node_t *sn, size_t file_blocknum, + int alloc, int *newp) +{ + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +pframe_t *s5_cache_and_clear_block(mobj_t *mo, long block, long loc) { + pframe_t *pf; + mobj_create_pframe(mo, block, loc, &pf); + pf->pf_addr = page_alloc(); + memset(pf->pf_addr, 0, PAGE_SIZE); + pf->pf_dirty = 1; // XXX do this later + return pf; +} + +/* Read from a file. + * + * sn - The s5_node representing the file to read from + * pos - The position to start reading from + * buf - The buffer to read into + * len - The number of bytes to read + * + * Return the number of bytes read, or: + * - Propagate errors from s5_get_file_block (do not return a partial + * read). As in, if s5_get_file_block returns an error, + * the call to s5_read_file should fail. + * + * Hints: + * - Do not directly call s5_file_block_to_disk_block. To obtain pframes with + * the desired blocks, use s5_get_file_block and s5_release_file_block. + * - Be sure to handle all edge cases regarding pos and len relative to the + * length of the actual file. (If pos is greater than or equal to the length + * of the file, then s5_read_file should return 0). + */ +ssize_t s5_read_file(s5_node_t *sn, size_t pos, char *buf, size_t len) +{ + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/* Write to a file. + * + * sn - The s5_node representing the file to write to + * pos - The position to start writing to + * buf - The buffer to write from + * len - The number of bytes to write + * + * Return the number of bytes written, or: + * - EFBIG: pos was beyond S5_MAX_FILE_SIZE + * - Propagate errors from s5_get_file_block (that is, do not return a partial + * write) + * + * Hints: + * - You should return -EFBIG only if the provided pos was invalid. Otherwise, + * it is okay to make a partial write up to the maximum file size. + * - Use s5_get_file_block and s5_release_file_block to obtain pframes with + * the desired blocks. + * - Because s5_get_file_block calls s5fs_get_pframe, which checks the length + * of the vnode, you may have to update the vnode's length before you call + * s5_get_file_block. In this case, you should also update the inode's + * s5_size and mark the inode dirty. + * - If, midway through writing, you run into an error with s5_get_file_block, + * it is okay to merely undo your most recent changes while leaving behind + * writes you've already made to other blocks, before returning the error. + * That is, it is okay to make a partial write that the caller does not know + * about, as long as the file's length is consistent with what you've + * actually written so far. + * - You should maintain the vn_len of the vnode and the s5_un.s5_size field of the + * inode to be the same. + */ +ssize_t s5_write_file(s5_node_t *sn, size_t pos, const char *buf, size_t len) +{ + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +#ifdef OLD +/* Allocate one block from the filesystem. + * + * Return the block number of the newly allocated block, or: + * - ENOSPC: There are no more free blocks + * + * Hints: + * - Protect access to the super block using s5_lock_super and s5_unlock super. + * - Recall that the free block list is a linked list of blocks containing disk + * block numbers of free blocks. Each node contains S5_NBLKS_PER_FNODE block + * numbers, where the last entry is a pointer to the next node in the linked + * list, or -1 if there are no more free blocks remaining. The super block's + * s5s_free_blocks is the first node of this linked list. + * - The super block's s5s_nfree member is the number of blocks that are free + * within s5s_free_blocks. You could use it as an index into the + * s5s_free_blocks array. Be sure to update the field appropriately. + * - When s5s_free_blocks runs out (i.e. s5s_nfree == 0), refill it by + * collapsing the next node of the free list into the super block. Exactly + * when you do this is up to you. + * - You should initialize the block's contents to 0. Specifically, + * when you use s5_alloc_block to allocate an indirect block, + * as your implementation of s5_file_block_to_disk_block probably expects + * sparse blocks to be represented by a 0. + * - You may find it helpful to take a look at the implementation of + * s5_free_block below. + * - You may assume/assert that any pframe calls succeed. + */ +static long s5_alloc_block(s5fs_t *s5fs) +{ + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} +#endif + +static long s5_alloc_block(s5fs_t *s5fs) +{ + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/* + * The exact opposite of s5_alloc_block: add blockno to the free list of the + * filesystem. This should never fail. You may assert that any pframe calls + * succeed. + * + * Don't forget to protect access to the super block, update s5s_nfree, and + * expand the linked list correctly if the super block can no longer hold any + * more free blocks in its s5s_free_blocks array according to s5s_nfree. + */ +static void s5_free_block(s5fs_t *s5fs, blocknum_t blockno) +{ + s5_lock_super(s5fs); + s5_super_t *s = &s5fs->s5f_super; + dbg(DBG_S5FS, "freeing disk block %d\n", blockno); + KASSERT(blockno); + KASSERT(s->s5s_nfree < S5_NBLKS_PER_FNODE); + + if (s->s5s_nfree == S5_NBLKS_PER_FNODE - 1) + { + // FIX THIS! Don't need to read prior contents + pframe_t *pf; + s5_get_meta_disk_block(s5fs, blockno, 1, &pf); + memcpy(pf->pf_addr, s->s5s_free_blocks, sizeof(s->s5s_free_blocks)); + s5_release_disk_block(&pf); + + s->s5s_nfree = 0; + s->s5s_free_blocks[S5_NBLKS_PER_FNODE - 1] = blockno; + } + else + { + s->s5s_free_blocks[s->s5s_nfree++] = blockno; + } + s5_unlock_super(s5fs); +} + +/* + * Allocate one inode from the filesystem. You will need to use the super block + * s5s_free_inode member. You must initialize the on-disk contents of the + * allocated inode according to the arguments type and devid. + * + * Recall that the free inode list is a linked list. Each free inode contains a + * link to the next free inode. The super block s5s_free_inode must always point + * to the next free inode, or contain -1 to indicate no more inodes are + * available. + * + * Don't forget to protect access to the super block and update s5s_free_inode. + * + * You should use s5_get_inode and s5_release_inode. + * + * On success, return the newly allocated inode number. + * On failure, return -ENOSPC. + */ +long s5_alloc_inode(s5fs_t *s5fs, uint16_t type, devid_t devid) +{ + KASSERT((S5_TYPE_DATA == type) || (S5_TYPE_DIR == type) || + (S5_TYPE_CHR == type) || (S5_TYPE_BLK == type)); + + s5_lock_super(s5fs); + uint32_t new_ino = s5fs->s5f_super.s5s_free_inode; + if (new_ino == (uint32_t)-1) + { + s5_unlock_super(s5fs); + return -ENOSPC; + } + + pframe_t *pf; + s5_inode_t *inode; + s5_get_inode(s5fs, new_ino, 1, &pf, &inode); + + s5fs->s5f_super.s5s_free_inode = inode->s5_un.s5_next_free; + KASSERT(inode->s5_un.s5_next_free != inode->s5_number); + + inode->s5_un.s5_size = 0; + inode->s5_type = type; + inode->s5_linkcount = 0; + memset(inode->s5_direct_blocks, 0, sizeof(inode->s5_direct_blocks)); + inode->s5_indirect_block = + (S5_TYPE_CHR == type || S5_TYPE_BLK == type) ? devid : 0; + + s5_release_inode(&pf, &inode); + s5_unlock_super(s5fs); + + dbg(DBG_S5FS, "allocated inode %d\n", new_ino); + return new_ino; +} + +/* + * Free the inode by: + * 1) adding the inode to the free inode linked list (opposite of + * s5_alloc_inode), and 2) freeing all blocks being used by the inode. + * + * The suggested order of operations to avoid deadlock, is: + * 1) lock the super block + * 2) get the inode to be freed + * 3) update the free inode linked list + * 4) copy the blocks to be freed from the inode onto the stack + * 5) release the inode + * 6) unlock the super block + * 7) free all direct blocks + * 8) get the indirect block + * 9) copy the indirect block array onto the stack + * 10) release the indirect block + * 11) free the indirect blocks + * 12) free the indirect block itself + */ +void s5_free_inode(s5fs_t *s5fs, ino_t ino) +{ + pframe_t *pf; + s5_inode_t *inode; + s5_lock_super(s5fs); + s5_get_inode(s5fs, ino, 1, &pf, &inode); + + uint32_t direct_blocks_to_free[S5_NDIRECT_BLOCKS]; + uint32_t indirect_block_to_free; + if (inode->s5_type == S5_TYPE_DATA || inode->s5_type == S5_TYPE_DIR) + { + indirect_block_to_free = inode->s5_indirect_block; + memcpy(direct_blocks_to_free, inode->s5_direct_blocks, + sizeof(direct_blocks_to_free)); + } + else + { + KASSERT(inode->s5_type == S5_TYPE_BLK || inode->s5_type == S5_TYPE_CHR); + indirect_block_to_free = 0; + memset(direct_blocks_to_free, 0, sizeof(direct_blocks_to_free)); + } + + inode->s5_un.s5_next_free = s5fs->s5f_super.s5s_free_inode; + inode->s5_type = S5_TYPE_FREE; + s5fs->s5f_super.s5s_free_inode = inode->s5_number; + + s5_release_inode(&pf, &inode); + s5_unlock_super(s5fs); + + for (unsigned i = 0; i < S5_NDIRECT_BLOCKS; i++) + { + if (direct_blocks_to_free[i]) + { + s5_free_block(s5fs, direct_blocks_to_free[i]); + } + } + if (indirect_block_to_free) + { + uint32_t indirect_blocks_to_free[S5_NIDIRECT_BLOCKS]; + + s5_get_meta_disk_block(s5fs, indirect_block_to_free, 0, &pf); + KASSERT(S5_BLOCK_SIZE == PAGE_SIZE); + memcpy(indirect_blocks_to_free, pf->pf_addr, S5_BLOCK_SIZE); + s5_release_disk_block(&pf); + + for (unsigned i = 0; i < S5_NIDIRECT_BLOCKS; i++) + { + if (indirect_blocks_to_free[i]) + { + s5_free_block(s5fs, indirect_blocks_to_free[i]); + } + } + s5_free_block(s5fs, indirect_block_to_free); + } + dbg(DBG_S5FS, "freed inode %d\n", ino); +} + +/* Return the inode number corresponding to the directory entry specified by + * name and namelen within a given directory. + * + * sn - The directory to search in + * name - The name to search for + * namelen - Length of name + * filepos - If non-NULL, use filepos to return the starting position of the + * directory entry + * + * Return the desired inode number, or: + * - ENOENT: Could not find a directory entry with the specified name + * + * Hints: + * - Use s5_read_file in increments of sizeof(s5_dirent_t) to read successive + * directory entries and compare them against name and namelen. + * - To avoid reading beyond the end of the directory, check if the return + * value of s5_read_file is 0 + * - You could optimize this function by using s5_get_file_block (rather than + * s5_read_file) to ensure you do not read beyond the length of the file, + * but doing so is optional. + */ +long s5_find_dirent(s5_node_t *sn, const char *name, size_t namelen, + size_t *filepos) +{ + KASSERT(S_ISDIR(sn->vnode.vn_mode) && "should be handled at the VFS level"); + KASSERT(S5_BLOCK_SIZE == PAGE_SIZE && "be wary, thee"); + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/* Remove the directory entry specified by name and namelen from the directory + * sn. + * + * child - The found directory entry must correspond to the caller-provided + * child + * + * No return value. This function should never fail. You should assert that + * anything which could be incorrect is correct, and any function calls which + * could fail succeed. + * + * Hints: + * - Assert that the directory exists. + * - Assert that the found directory entry corresponds to child. + * - Ensure that the remaining directory entries in the file are contiguous. To + * do this, you should: + * - Overwrite the removed entry with the last directory entry. + * - Truncate the length of the directory by sizeof(s5_dirent_t). + * - Make sure you are only using s5_dirent_t, and not dirent_t structs. + * - Decrement the child's linkcount, because you have removed the directory's + * link to the child. + * - Mark the inodes as dirtied. + * - Use s5_find_dirent to find the position of the entry being removed. + */ +void s5_remove_dirent(s5_node_t *sn, const char *name, size_t namelen, + s5_node_t *child) +{ + vnode_t *dir = &sn->vnode; + s5_inode_t *inode = &sn->inode; + NOT_YET_IMPLEMENTED("S5FS: ***none***"); +} + +/* Replace a directory entry. + * + * sn - The directory to search within + * name - The name of the old directory entry + * namelen - Length of the old directory entry name + * old - The s5_node corresponding to the old directory entry + * new - The s5_node corresponding to the new directory entry + * + * No return value. Similar to s5_remove_dirent, this function should never + * fail. You should assert that everything behaves correctly. + * + * Hints: + * - Assert that the directory exists, that the directory entry exists, and + * that it corresponds to the old s5_node. + * - When forming the new directory entry, use the same name and namelen from + * before, but use the inode number from the new s5_node. + * - Update linkcounts and dirty inodes appropriately. + * + * s5_replace_dirent is NOT necessary to implement. It's only useful if + * you're planning on implementing the renaming of directories (which you shouldn't + * attempt until after the rest of S5FS is done). + */ +void s5_replace_dirent(s5_node_t *sn, const char *name, size_t namelen, + s5_node_t *old, s5_node_t *new) +{ + vnode_t *dir = &sn->vnode; + s5_inode_t *inode = &sn->inode; + NOT_YET_IMPLEMENTED("S5FS: ***none***"); +} + +/* Create a directory entry. + * + * dir - The directory within which to create a new entry + * name - The name of the new entry + * namelen - Length of the new entry name + * child - The s5_node holding the inode which the new entry should represent + * + * Return 0 on success, or: + * - EEXIST: The directory entry already exists + * - Propagate errors from s5_write_file + * + * Hints: + * - Update linkcounts and mark inodes dirty appropriately. + * - You may wish to assert at the end of s5_link that the directory entry + * exists and that its inode is, as expected, the inode of child. + */ +long s5_link(s5_node_t *dir, const char *name, size_t namelen, + s5_node_t *child) +{ + KASSERT(kmutex_owns_mutex(&dir->vnode.vn_mobj.mo_mutex)); + + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/* Return the number of file blocks allocated for sn. This means any + * file blocks that are not sparse, direct or indirect. If the indirect + * block itself is allocated, that must also count. This function should not + * fail. + * + * Hint: + * - You may wish to assert that the special character / block files do not + * have any blocks allocated to them. Remember, the s5_indirect_block for + * these special files is actually the device id. + */ +long s5_inode_blocks(s5_node_t *sn) +{ + NOT_YET_IMPLEMENTED("S5FS: ***none***"); + return -1; +} + +/** + * Given a s5_node_t, frees the associated direct blocks and + * the indirect blocks if they exist. + * + * Should only be called from the truncate_file routine. + */ +void s5_remove_blocks(s5_node_t *sn) +{ + // Free the blocks used by the node + // First, free the the direct blocks + s5fs_t* s5fs = VNODE_TO_S5FS(&sn->vnode); + s5_inode_t* s5_inode = &sn->inode; + for (unsigned i = 0; i < S5_NDIRECT_BLOCKS; i++) + { + if (s5_inode->s5_direct_blocks[i]) + { + s5_free_block(s5fs, s5_inode->s5_direct_blocks[i]); + } + } + + memset(s5_inode->s5_direct_blocks, 0, sizeof(s5_inode->s5_direct_blocks)); + + // Get the indirect blocks and free them, if they exist + if (s5_inode->s5_indirect_block) + { + pframe_t *pf; + s5_get_meta_disk_block(s5fs, s5_inode->s5_indirect_block, 0, &pf); + uint32_t *blocknum_ptr = pf->pf_addr; + + for (unsigned i = 0; i < S5_NIDIRECT_BLOCKS; i++) + { + if (blocknum_ptr[i]) + { + s5_free_block(s5fs, blocknum_ptr[i]); + } + } + + s5_release_disk_block(&pf); + // Free the indirect block itself + s5_free_block(s5fs, s5_inode->s5_indirect_block); + s5_inode->s5_indirect_block = 0; + } +} diff --git a/kernel/fs/vfs.c b/kernel/fs/vfs.c new file mode 100644 index 0000000..3f5ed15 --- /dev/null +++ b/kernel/fs/vfs.c @@ -0,0 +1,222 @@ +#include "errno.h" +#include "globals.h" +#include "kernel.h" +#include "util/string.h" +#include <fs/s5fs/s5fs.h> +#include <fs/vnode.h> + +#include "fs/file.h" +#include "fs/ramfs/ramfs.h" + +#include "mm/kmalloc.h" +#include "mm/slab.h" +#include "util/debug.h" + +#ifdef __S5FS__ +#include "fs/s5fs/s5fs.h" +#endif + +#ifdef __MOUNTING__ +/* The fs listed here are only the non-root file systems */ +list_t mounted_fs_list; + +/* + * Implementing this function is not required and strongly discouraged unless + * you are absolutley sure your Weenix is perfect. + * + * The purpose of this function is to set up the pointers between the file + * system struct and the vnode of the mount point. Remember to watch your + * reference counts. (The exception here is when the vnode's vn_mount field + * points to the mounted file system's root we do not increment the reference + * count on the file system's root vnode. The file system is already keeping + * a reference to the vnode which will not go away until the file system is + * unmounted. If we kept a second such reference it would conflict with the + * behavior of vfs_is_in_use(), make sure you understand why.) + * + * Once everything is set up add the file system to the list of mounted file + * systems. + * + * Remember proper error handling. + * + * This function is not meant to mount the root file system. + */ +int vfs_mount(struct vnode *mtpt, fs_t *fs) +{ + NOT_YET_IMPLEMENTED("MOUNTING: ***none***"); + return -EINVAL; +} + +/* + * Implementing this function is not required and strongly discouraged unless + * you are absolutley sure your Weenix is perfect. + * + * The purpose of this function is to undo the setup done in vfs_mount(). Also + * you should call the underlying file system's umount() function. Make sure + * to keep track of reference counts. You should also kfree the fs struct at + * the end of this method. + * + * Remember proper error handling. You might want to make sure that you do not + * try to call this function on the root file system (this function is not meant + * to unmount the root file system). + */ +int vfs_umount(fs_t *fs) +{ + NOT_YET_IMPLEMENTED("MOUNTING: ***none***"); + return -EINVAL; +} +#endif /* __MOUNTING__ */ + +fs_t vfs_root_fs = { + .fs_dev = VFS_ROOTFS_DEV, + .fs_type = VFS_ROOTFS_TYPE, + .vnode_list = LIST_INITIALIZER(vfs_root_fs.vnode_list), + .vnode_list_mutex = KMUTEX_INITIALIZER(vfs_root_fs.vnode_list_mutex), + .fs_vnode_allocator = NULL, + .fs_i = NULL, + .fs_ops = NULL, + .fs_root = NULL, +}; + +/* + * Call mountfunc on vfs_root_fs and set curproc->p_cwd (reference count!) + */ +void vfs_init() +{ + long err = mountfunc(&vfs_root_fs); + if (err) + { + panic( + "Failed to mount root fs of type \"%s\" on device " + "\"%s\" with errno of %ld\n", + vfs_root_fs.fs_type, vfs_root_fs.fs_dev, -err); + } + + vlock(vfs_root_fs.fs_root); + vref(curproc->p_cwd = vfs_root_fs.fs_root); + vunlock(vfs_root_fs.fs_root); + +#ifdef __MOUNTING__ + list_init(&mounted_fs_list); + fs->fs_mtpt = vfs_root_fs.fs_root; +#endif +} + +/* + * Wrapper around the sync call() to vfs_root_fs using fs_ops + */ +void do_sync() +{ + vfs_root_fs.fs_ops->sync(&vfs_root_fs); +#ifdef __MOUNTING__ + // if implementing mounting, just sync() all the mounted FS's as well +#endif +} + +/* + * + */ +long vfs_shutdown() +{ + dbg(DBG_VFS, "shutting down vfs\n"); + long ret = 0; + +#ifdef __MOUNTING__ + list_iterate(&mounted_fs_list, mtfs, fs_t, fs_link) + { + ret = vfs_umount(mtfs); + KASSERT(!ret); + } +#endif + + if (vfs_is_in_use(&vfs_root_fs)) + { + panic("vfs_shutdown: found active vnodes in root filesystem"); + } + + if (vfs_root_fs.fs_ops->umount) + { + ret = vfs_root_fs.fs_ops->umount(&vfs_root_fs); + } + else + { + // vlock(vfs_root_fs.fs_root); + vput(&vfs_root_fs.fs_root); + } + + if (vfs_count_active_vnodes(&vfs_root_fs)) + { + panic( + "vfs_shutdown: vnodes still in use after unmounting root " + "filesystem"); + } + return ret; +} + +long mountfunc(fs_t *fs) +{ + static const struct + { + char *fstype; + + long (*mountfunc)(fs_t *); + } types[] = { +#ifdef __S5FS__ + {"s5fs", s5fs_mount}, +#endif + {"ramfs", ramfs_mount}, + }; + + for (unsigned int i = 0; i < sizeof(types) / sizeof(types[0]); i++) + { + if (strcmp(fs->fs_type, types[i].fstype) == 0) + { + return types[i].mountfunc(fs); + } + } + + return -EINVAL; +} + +/* + * A filesystem is in use if the total number of vnode refcounts for that + * filesystem > 1. The singular refcount in a fs NOT in use comes from fs_root. + * + * Error cases vfs_is_in_use is responsible for generating: + * - EBUSY: if the filesystem is in use + */ +long vfs_is_in_use(fs_t *fs) +{ + long ret = 0; + // kmutex_lock(&fs->vnode_list_mutex); + list_iterate(&fs->vnode_list, vn, vnode_t, vn_link) + { + vlock(vn); + size_t expected_refcount = vn->vn_fs->fs_root == vn ? 1 : 0; + size_t refcount = vn->vn_mobj.mo_refcount; + vunlock(vn); + if (refcount != expected_refcount) + { + dbg(DBG_VFS, + "vnode %d still in use with %d references and %lu mobj " + "references (expected %lu)\n", + vn->vn_vno, vn->vn_mobj.mo_refcount, refcount, + expected_refcount); + ret = -EBUSY; + // break; + } + } + // kmutex_unlock(&fs->vnode_list_mutex); + return ret; +} + +/* + * Return the size of fs->vnode_list + */ +size_t vfs_count_active_vnodes(fs_t *fs) +{ + size_t count = 0; + kmutex_lock(&fs->vnode_list_mutex); + list_iterate(&fs->vnode_list, vn, vnode_t, vn_link) { count++; } + kmutex_unlock(&fs->vnode_list_mutex); + return count; +} diff --git a/kernel/fs/vfs_syscall.c b/kernel/fs/vfs_syscall.c new file mode 100644 index 0000000..d2f018c --- /dev/null +++ b/kernel/fs/vfs_syscall.c @@ -0,0 +1,356 @@ +#include "fs/vfs_syscall.h" +#include "errno.h" +#include "fs/fcntl.h" +#include "fs/file.h" +#include "fs/lseek.h" +#include "fs/vfs.h" +#include "fs/vnode.h" +#include "globals.h" +#include "kernel.h" +#include "util/debug.h" +#include "util/string.h" +#include <limits.h> + +/* + * Read len bytes into buf from the fd's file using the file's vnode operation + * read. + * + * Return the number of bytes read on success, or: + * - EBADF: fd is invalid or is not open for reading + * - EISDIR: fd refers to a directory + * - Propagate errors from the vnode operation read + * + * Hints: + * - Be sure to update the file's position appropriately. + * - Lock/unlock the file's vnode when calling its read operation. + */ +ssize_t do_read(int fd, void *buf, size_t len) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +/* + * Write len bytes from buf into the fd's file using the file's vnode operation + * write. + * + * Return the number of bytes written on success, or: + * - EBADF: fd is invalid or is not open for writing + * - Propagate errors from the vnode operation read + * + * Hints: + * - Check out `man 2 write` for details about how to handle the FMODE_APPEND + * flag. + * - Be sure to update the file's position appropriately. + * - Lock/unlock the file's vnode when calling its write operation. + */ +ssize_t do_write(int fd, const void *buf, size_t len) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +/* + * Close the file descriptor fd. + * + * Return 0 on success, or: + * - EBADF: fd is invalid or not open + * + * Hints: + * Check `proc.h` to see if there are any helpful fields in the + * proc_t struct for checking if the file associated with the fd is open. + * Consider what happens when we open a file and what counts as closing it + */ +long do_close(int fd) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +/* + * Duplicate the file descriptor fd. + * + * Return the new file descriptor on success, or: + * - EBADF: fd is invalid or not open + * - Propagate errors from get_empty_fd() + * + * Hint: Use get_empty_fd() to obtain an available file descriptor. + */ +long do_dup(int fd) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +/* + * Duplicate the file descriptor ofd using the new file descriptor nfd. If nfd + * was previously open, close it. + * + * Return nfd on success, or: + * - EBADF: ofd is invalid or not open, or nfd is invalid + * + * Hint: You don't need to do anything if ofd and nfd are the same. + * (If supporting MTP, this action must be atomic) + */ +long do_dup2(int ofd, int nfd) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +/* + * Create a file specified by mode and devid at the location specified by path. + * + * Return 0 on success, or: + * - EINVAL: Mode is not S_IFCHR, S_IFBLK, or S_IFREG + * - Propagate errors from namev_open() + * + * Hints: + * - Create the file by calling namev_open() with the O_CREAT flag. + * - Be careful about refcounts after calling namev_open(). The newly created + * vnode should have no references when do_mknod returns. The underlying + * filesystem is responsible for maintaining references to the inode, which + * will prevent it from being destroyed, even if the corresponding vnode is + * cleaned up. + * - You don't need to handle EEXIST (this would be handled within namev_open, + * but doing so would likely cause problems elsewhere) + */ +long do_mknod(const char *path, int mode, devid_t devid) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +/* + * Create a directory at the location specified by path. + * + * Return 0 on success, or: + * - ENAMETOOLONG: The last component of path is too long + * - ENOTDIR: The parent of the directory to be created is not a directory + * - EEXIST: A file located at path already exists + * - Propagate errors from namev_dir(), namev_lookup(), and the vnode + * operation mkdir + * + * Hints: + * 1) Use namev_dir() to find the parent of the directory to be created. + * 2) Use namev_lookup() to check that the directory does not already exist. + * 3) Use the vnode operation mkdir to create the directory. + * - Compare against NAME_LEN to determine if the basename is too long. + * Check out ramfs_mkdir() to confirm that the basename will be null- + * terminated. + * - Be careful about locking and refcounts after calling namev_dir() and + * namev_lookup(). + */ +long do_mkdir(const char *path) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +/* + * Delete a directory at path. + * + * Return 0 on success, or: + * - EINVAL: Attempting to rmdir with "." as the final component + * - ENOTEMPTY: Attempting to rmdir with ".." as the final component + * - ENOTDIR: The parent of the directory to be removed is not a directory + * - ENAMETOOLONG: the last component of path is too long + * - Propagate errors from namev_dir() and the vnode operation rmdir + * + * Hints: + * - Use namev_dir() to find the parent of the directory to be removed. + * - Be careful about refcounts from calling namev_dir(). + * - Use the parent directory's rmdir operation to remove the directory. + * - Lock/unlock the vnode when calling its rmdir operation. + */ +long do_rmdir(const char *path) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +/* + * Remove the link between path and the file it refers to. + * + * Return 0 on success, or: + * - ENOTDIR: the parent of the file to be unlinked is not a directory + * - ENAMETOOLONG: the last component of path is too long + * - Propagate errors from namev_dir() and the vnode operation unlink + * + * Hints: + * - Use namev_dir() and be careful about refcounts. + * - Lock/unlock the parent directory when calling its unlink operation. + */ +long do_unlink(const char *path) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +/* + * Create a hard link newpath that refers to the same file as oldpath. + * + * Return 0 on success, or: + * - EPERM: oldpath refers to a directory + * - ENAMETOOLONG: The last component of newpath is too long + * - ENOTDIR: The parent of the file to be linked is not a directory + * + * Hints: + * 1) Use namev_resolve() on oldpath to get the target vnode. + * 2) Use namev_dir() on newpath to get the directory vnode. + * 3) Use vlock_in_order() to lock the directory and target vnodes. + * 4) Use the directory vnode's link operation to create a link to the target. + * 5) Use vunlock_in_order() to unlock the vnodes. + * 6) Make sure to clean up references added from calling namev_resolve() and + * namev_dir(). + */ +long do_link(const char *oldpath, const char *newpath) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +/* Rename a file or directory. + * + * Return 0 on success, or: + * - ENOTDIR: the parent of either path is not a directory + * - ENAMETOOLONG: the last component of either path is too long + * - Propagate errors from namev_dir() and the vnode operation rename + * + * You DO NOT need to support renaming of directories. + * Steps: + * 1. namev_dir oldpath --> olddir vnode + * 2. namev_dir newpath --> newdir vnode + * 4. Lock the olddir and newdir in ancestor-first order (see `vlock_in_order`) + * 5. Use the `rename` vnode operation + * 6. Unlock the olddir and newdir + * 8. vput the olddir and newdir vnodes + * + * Alternatively, you can allow do_rename() to rename directories if + * __RENAMEDIR__ is set in Config.mk. As with all extra credit + * projects this is harder and you will get no extra credit (but you + * will get our admiration). Please make sure the normal version works first. + * Steps: + * 1. namev_dir oldpath --> olddir vnode + * 2. namev_dir newpath --> newdir vnode + * 3. Lock the global filesystem `vnode_rename_mutex` + * 4. Lock the olddir and newdir in ancestor-first order (see `vlock_in_order`) + * 5. Use the `rename` vnode operation + * 6. Unlock the olddir and newdir + * 7. Unlock the global filesystem `vnode_rename_mutex` + * 8. vput the olddir and newdir vnodes + * + * P.S. This scheme /probably/ works, but we're not 100% sure. + */ +long do_rename(const char *oldpath, const char *newpath) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +/* Set the current working directory to the directory represented by path. + * + * Returns 0 on success, or: + * - ENOTDIR: path does not refer to a directory + * - Propagate errors from namev_resolve() + * + * Hints: + * - Use namev_resolve() to get the vnode corresponding to path. + * - Pay attention to refcounts! + * - Remember that p_cwd should not be locked upon return from this function. + * - (If doing MTP, must protect access to p_cwd) + */ +long do_chdir(const char *path) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +/* + * Read a directory entry from the file specified by fd into dirp. + * + * Return sizeof(dirent_t) on success, or: + * - EBADF: fd is invalid or is not open + * - ENOTDIR: fd does not refer to a directory + * - Propagate errors from the vnode operation readdir + * + * Hints: + * - Use the vnode operation readdir. + * - Be sure to update file position according to readdir's return value. + * - On success (readdir return value is strictly positive), return + * sizeof(dirent_t). + */ +ssize_t do_getdent(int fd, struct dirent *dirp) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +/* + * Set the position of the file represented by fd according to offset and + * whence. + * + * Return the new file position, or: + * - EBADF: fd is invalid or is not open + * - EINVAL: whence is not one of SEEK_SET, SEEK_CUR, or SEEK_END; + * or, the resulting file offset would be negative + * + * Hints: + * - See `man 2 lseek` for details about whence. + * - Be sure to protect the vnode if you have to access its vn_len. + */ +off_t do_lseek(int fd, off_t offset, int whence) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +/* Use buf to return the status of the file represented by path. + * + * Return 0 on success, or: + * - Propagate errors from namev_resolve() and the vnode operation stat. + */ +long do_stat(const char *path, stat_t *buf) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return -1; +} + +#ifdef __MOUNTING__ +/* + * Implementing this function is not required and strongly discouraged unless + * you are absolutely sure your Weenix is perfect. + * + * This is the syscall entry point into vfs for mounting. You will need to + * create the fs_t struct and populate its fs_dev and fs_type fields before + * calling vfs's mountfunc(). mountfunc() will use the fields you populated + * in order to determine which underlying filesystem's mount function should + * be run, then it will finish setting up the fs_t struct. At this point you + * have a fully functioning file system, however it is not mounted on the + * virtual file system, you will need to call vfs_mount to do this. + * + * There are lots of things which can go wrong here. Make sure you have good + * error handling. Remember the fs_dev and fs_type buffers have limited size + * so you should not write arbitrary length strings to them. + */ +int do_mount(const char *source, const char *target, const char *type) +{ + NOT_YET_IMPLEMENTED("MOUNTING: ***none***"); + return -EINVAL; +} + +/* + * Implementing this function is not required and strongly discouraged unless + * you are absolutley sure your Weenix is perfect. + * + * This function delegates all of the real work to vfs_umount. You should not + * worry about freeing the fs_t struct here, that is done in vfs_umount. All + * this function does is figure out which file system to pass to vfs_umount and + * do good error checking. + */ +int do_umount(const char *target) +{ + NOT_YET_IMPLEMENTED("MOUNTING: ***none***"); + return -EINVAL; +} +#endif diff --git a/kernel/fs/vnode.c b/kernel/fs/vnode.c new file mode 100644 index 0000000..91fee09 --- /dev/null +++ b/kernel/fs/vnode.c @@ -0,0 +1,250 @@ +#include "fs/vnode.h" +#include "errno.h" +#include "fs/stat.h" +#include "fs/vfs.h" +#include "kernel.h" +#include "mm/slab.h" +#include "util/debug.h" +#include "util/string.h" +#include <fs/vnode_specials.h> + +#define MOBJ_TO_VNODE(o) CONTAINER_OF((o), vnode_t, vn_mobj) + +static long vnode_get_pframe(mobj_t *o, uint64_t pagenum, long forwrite, + pframe_t **pfp); +static long vnode_fill_pframe(mobj_t *o, pframe_t *pf); +static long vnode_flush_pframe(mobj_t *o, pframe_t *pf); +static void vnode_destructor(mobj_t *o); + +static mobj_ops_t vnode_mobj_ops = {.get_pframe = vnode_get_pframe, + .fill_pframe = vnode_fill_pframe, + .flush_pframe = vnode_flush_pframe, + .destructor = vnode_destructor}; + +/** + * locks the vnodes in the order of their inode number, + * in the case that they are the same vnode, then only one vnode is locked. + * + * this scheme prevents the A->B/B->A locking problem, but it only + * works only if the `vlock_in_order` function is used in all cases where 2 + * nodes must be locked. + */ +void vlock_in_order(vnode_t *a, vnode_t *b) +{ + /* these vnode's must be on the same filesystem */ + KASSERT(a->vn_fs == b->vn_fs); + + if (a->vn_vno == b->vn_vno) + { + vlock(a); + return; + } + + /* */ + if (S_ISDIR(a->vn_mode) && S_ISDIR(b->vn_mode)) + { + if (namev_is_descendant(a, b)) + { + vlock(b); + vlock(a); + return; + } + else if (namev_is_descendant(b, a)) + { + vlock(a); + vlock(b); + return; + } + } + else if (S_ISDIR(a->vn_mode)) + { + vlock(a); + vlock(b); + } + else if (S_ISDIR(b->vn_mode)) + { + vlock(b); + vlock(a); + } + else if (a->vn_vno < b->vn_vno) + { + vlock(a); + vlock(b); + } + else + { + vlock(b); + vlock(a); + } +} + +void vunlock_in_order(vnode_t *a, vnode_t *b) +{ + if (a->vn_vno == b->vn_vno) + { + vunlock(a); + return; + } + + vunlock(a); + vunlock(b); +} + +void await_vnode_loaded(vnode_t *vnode) +{ + /* blocks until the vnode's vn_state is loaded */ + while (vnode->vn_state != VNODE_LOADED) + { + sched_sleep_on(&vnode->vn_waitq); + } + KASSERT(vnode->vn_state == VNODE_LOADED); +} + +void notify_vnode_loaded(vnode_t *vn) +{ + /* set the state to loaded and release all waiters */ + vn->vn_state = VNODE_LOADED; + sched_broadcast_on(&vn->vn_waitq); +} + +void vnode_init(vnode_t *vn, fs_t *fs, ino_t ino, int state) +{ + vn->vn_state = VNODE_LOADING; + vn->vn_fs = fs; + vn->vn_vno = ino; + sched_queue_init(&vn->vn_waitq); + mobj_init(&vn->vn_mobj, MOBJ_VNODE, &vnode_mobj_ops); + KASSERT(vn->vn_mobj.mo_refcount); +} + +vnode_t *__vget(fs_t *fs, ino_t ino, int get_locked) +{ +find: + kmutex_lock(&fs->vnode_list_mutex); + list_iterate(&fs->vnode_list, vn, vnode_t, vn_link) + { + if (vn->vn_vno == ino) + { + if (atomic_inc_not_zero(&vn->vn_mobj.mo_refcount)) + { + /* reference acquired, we can release the per-FS list */ + kmutex_unlock(&fs->vnode_list_mutex); + await_vnode_loaded(vn); + if (get_locked) + { + vlock(vn); + } + return vn; + } + else + { + /* count must be 0, wait and try again later */ + kmutex_unlock(&fs->vnode_list_mutex); + sched_yield(); + goto find; + } + } + } + + /* vnode does not exist, must allocate one */ + dbg(DBG_VFS, "creating vnode %d\n", ino); + vnode_t *vn = slab_obj_alloc(fs->fs_vnode_allocator); + KASSERT(vn); + memset(vn, 0, sizeof(vnode_t)); + + /* initialize the vnode state */ + vnode_init(vn, fs, ino, VNODE_LOADING); + + /* add the vnode to the per-FS list, lock the vnode, and release the list + * (unblocking other `vget` calls) */ + list_insert_tail(&fs->vnode_list, &vn->vn_link); + vlock(vn); + kmutex_unlock(&fs->vnode_list_mutex); + + /* load the vnode */ + vn->vn_fs->fs_ops->read_vnode(vn->vn_fs, vn); + if (S_ISCHR(vn->vn_mode) || S_ISBLK(vn->vn_mode)) + { + init_special_vnode(vn); + } + + /* notify potential waiters that the vnode is ready for use and return */ + notify_vnode_loaded(vn); + if (!get_locked) + { + vunlock(vn); + } + return vn; +} + +inline vnode_t *vget(fs_t *fs, ino_t ino) { return __vget(fs, ino, 0); } + +inline vnode_t *vget_locked(fs_t *fs, ino_t ino) { return __vget(fs, ino, 1); } + +inline void vref(vnode_t *vn) { mobj_ref(&vn->vn_mobj); } + +inline void vlock(vnode_t *vn) { mobj_lock(&vn->vn_mobj); } + +inline void vunlock(vnode_t *vn) { mobj_unlock(&vn->vn_mobj); } + +inline void vput(struct vnode **vnp) +{ + vnode_t *vn = *vnp; + *vnp = NULL; + mobj_t *mobj = &vn->vn_mobj; + mobj_put(&mobj); +} + +inline void vput_locked(struct vnode **vnp) +{ + vunlock(*vnp); + vput(vnp); +} + +static long vnode_get_pframe(mobj_t *o, uint64_t pagenum, long forwrite, + pframe_t **pfp) +{ + vnode_t *vnode = MOBJ_TO_VNODE(o); + KASSERT(vnode->vn_ops->get_pframe); + return vnode->vn_ops->get_pframe(vnode, pagenum, forwrite, pfp); +} + +static long vnode_fill_pframe(mobj_t *o, pframe_t *pf) +{ + vnode_t *vnode = MOBJ_TO_VNODE(o); + KASSERT(vnode->vn_ops->fill_pframe); + return vnode->vn_ops->fill_pframe(vnode, pf); +} + +static long vnode_flush_pframe(mobj_t *o, pframe_t *pf) +{ + vnode_t *vnode = MOBJ_TO_VNODE(o); + KASSERT(vnode->vn_ops->flush_pframe); + return vnode->vn_ops->flush_pframe(vnode, pf); +} + +static void vnode_destructor(mobj_t *o) +{ + vnode_t *vn = MOBJ_TO_VNODE(o); + dbg(DBG_VFS, "destroying vnode %d\n", vn->vn_vno); + + /* lock, flush, and delete the vnode */ + KASSERT(!o->mo_refcount); + vlock(vn); + KASSERT(!o->mo_refcount); + KASSERT(!kmutex_has_waiters(&o->mo_mutex)); + mobj_flush(o); + if (vn->vn_fs->fs_ops->delete_vnode) + { + vn->vn_fs->fs_ops->delete_vnode(vn->vn_fs, vn); + } + KASSERT(!kmutex_has_waiters(&o->mo_mutex)); + vunlock(vn); + + /* remove the vnode from the list and free it*/ + kmutex_lock(&vn->vn_fs->vnode_list_mutex); + KASSERT(list_link_is_linked(&vn->vn_link)); + list_remove(&vn->vn_link); + kmutex_unlock(&vn->vn_fs->vnode_list_mutex); + slab_obj_free(vn->vn_fs->fs_vnode_allocator, vn); +} diff --git a/kernel/fs/vnode_specials.c b/kernel/fs/vnode_specials.c new file mode 100644 index 0000000..a6c38a3 --- /dev/null +++ b/kernel/fs/vnode_specials.c @@ -0,0 +1,176 @@ +#include <errno.h> +#include <fs/stat.h> +#include <fs/vfs.h> +#include <fs/vnode.h> +#include <util/debug.h> + +static long special_file_stat(vnode_t *file, stat_t *ss); + +static ssize_t chardev_file_read(vnode_t *file, size_t pos, void *buf, + size_t count); + +static ssize_t chardev_file_write(vnode_t *file, size_t pos, const void *buf, + size_t count); + +static long chardev_file_mmap(vnode_t *file, mobj_t **ret); + +static long chardev_file_fill_pframe(vnode_t *file, pframe_t *pf); + +static long chardev_file_flush_pframe(vnode_t *file, pframe_t *pf); + +static vnode_ops_t chardev_spec_vops = { + .read = chardev_file_read, + .write = chardev_file_write, + .mmap = chardev_file_mmap, + .mknod = NULL, + .lookup = NULL, + .link = NULL, + .unlink = NULL, + .mkdir = NULL, + .rmdir = NULL, + .readdir = NULL, + .stat = special_file_stat, + .get_pframe = NULL, + .fill_pframe = chardev_file_fill_pframe, + .flush_pframe = chardev_file_flush_pframe, +}; + +static ssize_t blockdev_file_read(vnode_t *file, size_t pos, void *buf, + size_t count); + +static ssize_t blockdev_file_write(vnode_t *file, size_t pos, const void *buf, + size_t count); + +static long blockdev_file_mmap(vnode_t *file, mobj_t **ret); + +static long blockdev_file_fill_pframe(vnode_t *file, pframe_t *pf); + +static long blockdev_file_flush_pframe(vnode_t *file, pframe_t *pf); + +static vnode_ops_t blockdev_spec_vops = { + .read = blockdev_file_read, + .write = blockdev_file_write, + .mmap = blockdev_file_mmap, + .mknod = NULL, + .lookup = NULL, + .link = NULL, + .unlink = NULL, + .mkdir = NULL, + .rmdir = NULL, + .readdir = NULL, + .stat = special_file_stat, + .get_pframe = NULL, + .fill_pframe = blockdev_file_fill_pframe, + .flush_pframe = blockdev_file_flush_pframe, +}; + +void init_special_vnode(vnode_t *vn) +{ + if (S_ISCHR(vn->vn_mode)) + { + vn->vn_ops = &chardev_spec_vops; + vn->vn_dev.chardev = chardev_lookup(vn->vn_devid); + } + else + { + KASSERT(S_ISBLK(vn->vn_mode)); + vn->vn_ops = &blockdev_spec_vops; + vn->vn_dev.blockdev = blockdev_lookup(vn->vn_devid); + } +} + +static long special_file_stat(vnode_t *file, stat_t *ss) +{ + KASSERT(file->vn_fs->fs_root->vn_ops->stat != NULL); + // call the containing file system's stat routine + return file->vn_fs->fs_root->vn_ops->stat(file, ss); +} + +/* + * Make a read by deferring to the underlying chardev and its read operation. + * + * Returns what the chardev's read returned. + * + * Hint: Watch out! chardev_file_read and chardev_file_write are indirectly + * called in do_read and do_write, respectively, as the read/write ops for + * chardev-type vnodes. This means that the vnode file should be locked + * upon entry to this function. + * + * However, tty_read and tty_write, the read/write ops for the tty chardev, + * are potentially blocking. To avoid deadlock, you should unlock the file + * before calling the chardev's read, and lock it again after. If you fail + * to do this, a shell reading from /dev/tty0 for instance, will block all + * access to the /dev/tty0 vnode. This means that if someone runs `ls /dev/`, + * while a shell is reading from `/dev/tty0`, the `ls` call will hang. + * + * Also, if a vnode represents a chardev, you can access the chardev using + * vnode->vn_dev.chardev. + * + */ +static ssize_t chardev_file_read(vnode_t *file, size_t pos, void *buf, + size_t count) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return 0; +} + +/* + * Make a write by deferring to the underlying chardev and its write operation. + * + * Return what the chardev's write returned. + * + * See the comments from chardev_file_read above for hints. + * + */ +static long chardev_file_write(vnode_t *file, size_t pos, const void *buf, + size_t count) +{ + NOT_YET_IMPLEMENTED("VFS: ***none***"); + return 0; +} + +/* + * For this and the following chardev functions, simply defer to the underlying + * chardev's corresponding operations. + */ +static long chardev_file_mmap(vnode_t *file, mobj_t **ret) +{ + NOT_YET_IMPLEMENTED("VM: ***none***"); + return 0; +} + +static long chardev_file_fill_pframe(vnode_t *file, pframe_t *pf) +{ + NOT_YET_IMPLEMENTED("VM: ***none***"); + return 0; +} + +static long chardev_file_flush_pframe(vnode_t *file, pframe_t *pf) +{ + NOT_YET_IMPLEMENTED("VM: ***none***"); + return 0; +} + +static ssize_t blockdev_file_read(vnode_t *file, size_t pos, void *buf, + size_t count) +{ + return -ENOTSUP; +} + +static long blockdev_file_write(vnode_t *file, size_t pos, const void *buf, + size_t count) +{ + return -ENOTSUP; +} + +static long blockdev_file_mmap(vnode_t *file, mobj_t **ret) { return -ENOTSUP; } + +static long blockdev_file_fill_pframe(vnode_t *file, pframe_t *pf) +{ + return -ENOTSUP; +} + +static long blockdev_file_flush_pframe(vnode_t *file, pframe_t *pf) +{ + return -ENOTSUP; +} |