You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
356 lines
8.4 KiB
356 lines
8.4 KiB
#include <defs.h>
|
|
#include <string.h>
|
|
#include <vfs.h>
|
|
#include <proc.h>
|
|
#include <file.h>
|
|
#include <unistd.h>
|
|
#include <iobuf.h>
|
|
#include <inode.h>
|
|
#include <stat.h>
|
|
#include <dirent.h>
|
|
#include <error.h>
|
|
#include <assert.h>
|
|
|
|
#define testfd(fd) ((fd) >= 0 && (fd) < FILES_STRUCT_NENTRY)
|
|
|
|
// get_fd_array - get current process's open files table
|
|
static struct file *
|
|
get_fd_array(void) {
|
|
struct files_struct *filesp = current->filesp;
|
|
assert(filesp != NULL && files_count(filesp) > 0);
|
|
return filesp->fd_array;
|
|
}
|
|
|
|
// fd_array_init - initialize the open files table
|
|
void
|
|
fd_array_init(struct file *fd_array) {
|
|
int fd;
|
|
struct file *file = fd_array;
|
|
for (fd = 0; fd < FILES_STRUCT_NENTRY; fd ++, file ++) {
|
|
file->open_count = 0;
|
|
file->status = FD_NONE, file->fd = fd;
|
|
}
|
|
}
|
|
|
|
// fs_array_alloc - allocate a free file item (with FD_NONE status) in open files table
|
|
static int
|
|
fd_array_alloc(int fd, struct file **file_store) {
|
|
// panic("debug");
|
|
struct file *file = get_fd_array();
|
|
if (fd == NO_FD) {
|
|
for (fd = 0; fd < FILES_STRUCT_NENTRY; fd ++, file ++) {
|
|
if (file->status == FD_NONE) {
|
|
goto found;
|
|
}
|
|
}
|
|
return -E_MAX_OPEN;
|
|
}
|
|
else {
|
|
if (testfd(fd)) {
|
|
file += fd;
|
|
if (file->status == FD_NONE) {
|
|
goto found;
|
|
}
|
|
return -E_BUSY;
|
|
}
|
|
return -E_INVAL;
|
|
}
|
|
found:
|
|
assert(fopen_count(file) == 0);
|
|
file->status = FD_INIT, file->node = NULL;
|
|
*file_store = file;
|
|
return 0;
|
|
}
|
|
|
|
// fd_array_free - free a file item in open files table
|
|
static void
|
|
fd_array_free(struct file *file) {
|
|
assert(file->status == FD_INIT || file->status == FD_CLOSED);
|
|
assert(fopen_count(file) == 0);
|
|
if (file->status == FD_CLOSED) {
|
|
vfs_close(file->node);
|
|
}
|
|
file->status = FD_NONE;
|
|
}
|
|
|
|
static void
|
|
fd_array_acquire(struct file *file) {
|
|
assert(file->status == FD_OPENED);
|
|
fopen_count_inc(file);
|
|
}
|
|
|
|
// fd_array_release - file's open_count--; if file's open_count-- == 0 , then call fd_array_free to free this file item
|
|
static void
|
|
fd_array_release(struct file *file) {
|
|
assert(file->status == FD_OPENED || file->status == FD_CLOSED);
|
|
assert(fopen_count(file) > 0);
|
|
if (fopen_count_dec(file) == 0) {
|
|
fd_array_free(file);
|
|
}
|
|
}
|
|
|
|
// fd_array_open - file's open_count++, set status to FD_OPENED
|
|
void
|
|
fd_array_open(struct file *file) {
|
|
assert(file->status == FD_INIT && file->node != NULL);
|
|
file->status = FD_OPENED;
|
|
fopen_count_inc(file);
|
|
}
|
|
|
|
// fd_array_close - file's open_count--; if file's open_count-- == 0 , then call fd_array_free to free this file item
|
|
void
|
|
fd_array_close(struct file *file) {
|
|
assert(file->status == FD_OPENED);
|
|
assert(fopen_count(file) > 0);
|
|
file->status = FD_CLOSED;
|
|
if (fopen_count_dec(file) == 0) {
|
|
fd_array_free(file);
|
|
}
|
|
}
|
|
|
|
//fs_array_dup - duplicate file 'from' to file 'to'
|
|
void
|
|
fd_array_dup(struct file *to, struct file *from) {
|
|
//cprintf("[fd_array_dup]from fd=%d, to fd=%d\n",from->fd, to->fd);
|
|
assert(to->status == FD_INIT && from->status == FD_OPENED);
|
|
to->pos = from->pos;
|
|
to->readable = from->readable;
|
|
to->writable = from->writable;
|
|
struct inode *node = from->node;
|
|
vop_ref_inc(node), vop_open_inc(node);
|
|
to->node = node;
|
|
fd_array_open(to);
|
|
}
|
|
|
|
// fd2file - use fd as index of fd_array, return the array item (file)
|
|
static inline int
|
|
fd2file(int fd, struct file **file_store) {
|
|
if (testfd(fd)) {
|
|
struct file *file = get_fd_array() + fd;
|
|
if (file->status == FD_OPENED && file->fd == fd) {
|
|
*file_store = file;
|
|
return 0;
|
|
}
|
|
}
|
|
return -E_INVAL;
|
|
}
|
|
|
|
// file_testfd - test file is readble or writable?
|
|
bool
|
|
file_testfd(int fd, bool readable, bool writable) {
|
|
int ret;
|
|
struct file *file;
|
|
if ((ret = fd2file(fd, &file)) != 0) {
|
|
return 0;
|
|
}
|
|
if (readable && !file->readable) {
|
|
return 0;
|
|
}
|
|
if (writable && !file->writable) {
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
// open file
|
|
int
|
|
file_open(char *path, uint32_t open_flags) {
|
|
bool readable = 0, writable = 0;
|
|
switch (open_flags & O_ACCMODE) {
|
|
case O_RDONLY: readable = 1; break;
|
|
case O_WRONLY: writable = 1; break;
|
|
case O_RDWR:
|
|
readable = writable = 1;
|
|
break;
|
|
default:
|
|
return -E_INVAL;
|
|
}
|
|
|
|
int ret;
|
|
struct file *file;
|
|
if ((ret = fd_array_alloc(NO_FD, &file)) != 0) {
|
|
return ret;
|
|
}
|
|
|
|
struct inode *node;
|
|
if ((ret = vfs_open(path, open_flags, &node)) != 0) {
|
|
fd_array_free(file);
|
|
return ret;
|
|
}
|
|
|
|
file->pos = 0;
|
|
if (open_flags & O_APPEND) {
|
|
struct stat __stat, *stat = &__stat;
|
|
if ((ret = vop_fstat(node, stat)) != 0) {
|
|
vfs_close(node);
|
|
fd_array_free(file);
|
|
return ret;
|
|
}
|
|
file->pos = stat->st_size;
|
|
}
|
|
|
|
file->node = node;
|
|
file->readable = readable;
|
|
file->writable = writable;
|
|
fd_array_open(file);
|
|
return file->fd;
|
|
}
|
|
|
|
// close file
|
|
int
|
|
file_close(int fd) {
|
|
int ret;
|
|
struct file *file;
|
|
if ((ret = fd2file(fd, &file)) != 0) {
|
|
return ret;
|
|
}
|
|
fd_array_close(file);
|
|
return 0;
|
|
}
|
|
|
|
// read file
|
|
int
|
|
file_read(int fd, void *base, size_t len, size_t *copied_store) {
|
|
int ret;
|
|
struct file *file;
|
|
*copied_store = 0;
|
|
if ((ret = fd2file(fd, &file)) != 0) {
|
|
return ret;
|
|
}
|
|
if (!file->readable) {
|
|
return -E_INVAL;
|
|
}
|
|
fd_array_acquire(file);
|
|
|
|
struct iobuf __iob, *iob = iobuf_init(&__iob, base, len, file->pos);
|
|
ret = vop_read(file->node, iob);
|
|
|
|
size_t copied = iobuf_used(iob);
|
|
if (file->status == FD_OPENED) {
|
|
file->pos += copied;
|
|
}
|
|
*copied_store = copied;
|
|
fd_array_release(file);
|
|
return ret;
|
|
}
|
|
|
|
// write file
|
|
int
|
|
file_write(int fd, void *base, size_t len, size_t *copied_store) {
|
|
int ret;
|
|
struct file *file;
|
|
*copied_store = 0;
|
|
if ((ret = fd2file(fd, &file)) != 0) {
|
|
return ret;
|
|
}
|
|
if (!file->writable) {
|
|
return -E_INVAL;
|
|
}
|
|
fd_array_acquire(file);
|
|
|
|
struct iobuf __iob, *iob = iobuf_init(&__iob, base, len, file->pos);
|
|
ret = vop_write(file->node, iob);
|
|
|
|
size_t copied = iobuf_used(iob);
|
|
if (file->status == FD_OPENED) {
|
|
file->pos += copied;
|
|
}
|
|
*copied_store = copied;
|
|
fd_array_release(file);
|
|
return ret;
|
|
}
|
|
|
|
// seek file
|
|
int
|
|
file_seek(int fd, off_t pos, int whence) {
|
|
struct stat __stat, *stat = &__stat;
|
|
int ret;
|
|
struct file *file;
|
|
if ((ret = fd2file(fd, &file)) != 0) {
|
|
return ret;
|
|
}
|
|
fd_array_acquire(file);
|
|
|
|
switch (whence) {
|
|
case LSEEK_SET: break;
|
|
case LSEEK_CUR: pos += file->pos; break;
|
|
case LSEEK_END:
|
|
if ((ret = vop_fstat(file->node, stat)) == 0) {
|
|
pos += stat->st_size;
|
|
}
|
|
break;
|
|
default: ret = -E_INVAL;
|
|
}
|
|
|
|
if (ret == 0) {
|
|
if ((ret = vop_tryseek(file->node, pos)) == 0) {
|
|
file->pos = pos;
|
|
}
|
|
// cprintf("file_seek, pos=%d, whence=%d, ret=%d\n", pos, whence, ret);
|
|
}
|
|
fd_array_release(file);
|
|
return ret;
|
|
}
|
|
|
|
// stat file
|
|
int
|
|
file_fstat(int fd, struct stat *stat) {
|
|
int ret;
|
|
struct file *file;
|
|
if ((ret = fd2file(fd, &file)) != 0) {
|
|
return ret;
|
|
}
|
|
fd_array_acquire(file);
|
|
ret = vop_fstat(file->node, stat);
|
|
fd_array_release(file);
|
|
return ret;
|
|
}
|
|
|
|
// sync file
|
|
int
|
|
file_fsync(int fd) {
|
|
int ret;
|
|
struct file *file;
|
|
if ((ret = fd2file(fd, &file)) != 0) {
|
|
return ret;
|
|
}
|
|
fd_array_acquire(file);
|
|
ret = vop_fsync(file->node);
|
|
fd_array_release(file);
|
|
return ret;
|
|
}
|
|
|
|
// get file entry in DIR
|
|
int
|
|
file_getdirentry(int fd, struct dirent *direntp) {
|
|
int ret;
|
|
struct file *file;
|
|
if ((ret = fd2file(fd, &file)) != 0) {
|
|
return ret;
|
|
}
|
|
fd_array_acquire(file);
|
|
|
|
struct iobuf __iob, *iob = iobuf_init(&__iob, direntp->name, sizeof(direntp->name), direntp->offset);
|
|
if ((ret = vop_getdirentry(file->node, iob)) == 0) {
|
|
direntp->offset += iobuf_used(iob);
|
|
}
|
|
fd_array_release(file);
|
|
return ret;
|
|
}
|
|
|
|
// duplicate file
|
|
int
|
|
file_dup(int fd1, int fd2) {
|
|
int ret;
|
|
struct file *file1, *file2;
|
|
if ((ret = fd2file(fd1, &file1)) != 0) {
|
|
return ret;
|
|
}
|
|
if ((ret = fd_array_alloc(fd2, &file2)) != 0) {
|
|
return ret;
|
|
}
|
|
fd_array_dup(file2, file1);
|
|
return file2->fd;
|
|
}
|
|
|
|
|