i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

sys_seek() now returns the stream position as an off_t.

Browse Source 
Minor bug fixes.
fd_close() now doesn't have to call remove_fd() anymore - it's now called
in user|sys_close(), fd_close() is now only called in the last put_fd().
Cleanup, improved debug output (without any warnings).


git-svn-id: file:///srv/svn/repos/haiku/trunk/current@266 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
2002-07-17 07:55:51 +00:00
parent b46f99148e
commit 243d156e21
5 changed files with 404 additions and 433 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/kernel/core/fd.c
+54 -35
View File
@@ -23,12 +23,31 @@
return EINVAL; return EINVAL;
#define TRACE_FD 0
#if TRACE_FD
# define TRACE(x) dprintf x
# define PRINT(x) dprintf x # define PRINT(x) dprintf x
#else
# define TRACE(x)
# define PRINT(x)
#endif
/*** General fd routines ***/ /*** General fd routines ***/
#ifdef DEBUG
void dump_fd(int fd, struct file_descriptor *descriptor);
void
dump_fd(int fd,struct file_descriptor *descriptor)
{
dprintf("fd[%d] = %p: type = %d, ref_count = %d, ops = %p, vnode = %p, cookie = %p, dummy = %x\n",
fd,descriptor,descriptor->type,descriptor->ref_count,descriptor->ops,
descriptor->vnode,descriptor->cookie,descriptor->dummy);
}
#endif
/** Allocates and initializes a new file_descriptor */ /** Allocates and initializes a new file_descriptor */
struct file_descriptor * struct file_descriptor *
@@ -41,6 +60,7 @@ alloc_fd(void)
f->vnode = NULL; f->vnode = NULL;
f->cookie = NULL; f->cookie = NULL;
f->ref_count = 1; f->ref_count = 1;
f->dummy = 0xdeadbeef;
} }
return f; return f;
} }
@@ -76,15 +96,18 @@ err:
void void
put_fd(struct file_descriptor *f) put_fd(struct file_descriptor *descriptor)
{ {
/* Run a cleanup (fd_free) routine if there is one and free structure, but only /* Run a cleanup (fd_free) routine if there is one and free structure, but only
* if we've just removed the final reference to it :) * if we've just removed the final reference to it :)
*/ */
if (atomic_add(&f->ref_count, -1) == 1) { if (atomic_add(&descriptor->ref_count, -1) == 1) {
if (f->ops->fd_free) if (descriptor->ops->fd_close)
f->ops->fd_free(f); descriptor->ops->fd_close(descriptor);
kfree(f); if (descriptor->ops->fd_free)
descriptor->ops->fd_free(descriptor);
kfree(descriptor);
} }
} }
@@ -105,6 +128,7 @@ get_fd(struct io_context *ioctx, int fd)
} }
mutex_unlock(&ioctx->io_mutex); mutex_unlock(&ioctx->io_mutex);
return f; return f;
} }
@@ -185,23 +209,24 @@ user_write(int fd, const void *buffer, off_t pos, size_t length)
} }
int off_t
user_seek(int fd, off_t pos, int seek_type) user_seek(int fd, off_t pos, int seekType)
{ {
struct file_descriptor *descriptor; struct file_descriptor *descriptor;
int status;
descriptor = get_fd(get_current_io_context(false), fd); descriptor = get_fd(get_current_io_context(false), fd);
if (!descriptor) if (!descriptor)
return EBADF; return EBADF;
TRACE(("user_seek(descriptor = %p)\n",descriptor));
if (descriptor->ops->fd_seek) if (descriptor->ops->fd_seek)
status = descriptor->ops->fd_seek(descriptor, pos, seek_type); pos = descriptor->ops->fd_seek(descriptor, pos, seekType);
else else
status = EOPNOTSUPP; pos = ESPIPE;
put_fd(descriptor); put_fd(descriptor);
return status; return pos;
} }
@@ -291,6 +316,8 @@ user_fstat(int fd, struct stat *stat)
if (descriptor == NULL) if (descriptor == NULL)
return EBADF; return EBADF;
TRACE(("user_fstat(descriptor = %p)\n",descriptor));
if (descriptor->ops->fd_stat) { if (descriptor->ops->fd_stat) {
// we're using the stat buffer on the stack to not have to // we're using the stat buffer on the stack to not have to
// lock the given stat buffer in memory // lock the given stat buffer in memory
@@ -310,20 +337,18 @@ user_fstat(int fd, struct stat *stat)
int int
user_close(int fd) user_close(int fd)
{ {
struct io_context *ioContext = get_current_io_context(false); struct io_context *io = get_current_io_context(false);
struct file_descriptor *descriptor = get_fd(ioContext, fd); struct file_descriptor *descriptor = get_fd(io, fd);
int retval;
if (descriptor == NULL) if (descriptor == NULL)
return EBADF; return EBADF;
if (descriptor->ops->fd_close) TRACE(("user_close(descriptor = %p)\n",descriptor));
retval = descriptor->ops->fd_close(descriptor, fd, ioContext);
else remove_fd(io, fd);
retval = EOPNOTSUPP;
put_fd(descriptor); put_fd(descriptor);
return retval; return B_OK;
} }
@@ -364,7 +389,6 @@ sys_write(int fd, const void *buffer, off_t pos, size_t length)
struct file_descriptor *descriptor; struct file_descriptor *descriptor;
ssize_t retval; ssize_t retval;
// dprintf("sys_write: fd %d\n", fd);
// CHECK_SYS_ADDR(buffer) // CHECK_SYS_ADDR(buffer)
descriptor = get_fd(get_current_io_context(true), fd); descriptor = get_fd(get_current_io_context(true), fd);
@@ -385,23 +409,22 @@ sys_write(int fd, const void *buffer, off_t pos, size_t length)
} }
int off_t
sys_seek(int fd, off_t pos, int seek_type) sys_seek(int fd, off_t pos, int seekType)
{ {
struct file_descriptor *descriptor; struct file_descriptor *descriptor;
int status;
descriptor = get_fd(get_current_io_context(true), fd); descriptor = get_fd(get_current_io_context(true), fd);
if (!descriptor) if (!descriptor)
return EBADF; return EBADF;
if (descriptor->ops->fd_seek) if (descriptor->ops->fd_seek)
status = descriptor->ops->fd_seek(descriptor, pos, seek_type); pos = descriptor->ops->fd_seek(descriptor, pos, seekType);
else else
status = EOPNOTSUPP; pos = ESPIPE;
put_fd(descriptor); put_fd(descriptor);
return status; return pos;
} }
@@ -460,7 +483,7 @@ sys_rewind_dir(int fd)
struct file_descriptor *descriptor; struct file_descriptor *descriptor;
status_t status; status_t status;
PRINT(("user_rewind_dir(fd = %d)\n",fd)); PRINT(("sys_rewind_dir(fd = %d)\n",fd));
descriptor = get_fd(get_current_io_context(true), fd); descriptor = get_fd(get_current_io_context(true), fd);
if (descriptor == NULL) if (descriptor == NULL)
@@ -479,19 +502,15 @@ sys_rewind_dir(int fd)
int int
sys_close(int fd) sys_close(int fd)
{ {
struct io_context *ioContext = get_current_io_context(true); struct io_context *io = get_current_io_context(true);
struct file_descriptor *descriptor = get_fd(ioContext, fd); struct file_descriptor *descriptor = get_fd(io, fd);
int status;
if (descriptor == NULL) if (descriptor == NULL)
return EBADF; return EBADF;
if (descriptor->ops->fd_close) remove_fd(io, fd);
status = descriptor->ops->fd_close(descriptor, fd, ioContext);
else
status = EOPNOTSUPP;
put_fd(descriptor); put_fd(descriptor);
return status; return B_OK;
} }
src/kernel/core/fs/bootfs.c
+18 -34
View File
@@ -714,38 +714,22 @@ bootfs_write(fs_cookie fs, fs_vnode v, file_cookie cookie, const void *buf, off_
} }
static int static off_t
bootfs_seek(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, off_t pos, int st) bootfs_seek(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, off_t pos, int seekType)
{ {
struct bootfs *fs = _fs; struct bootfs *fs = _fs;
struct bootfs_vnode *v = _v; struct bootfs_vnode *v = _v;
struct bootfs_cookie *cookie = _cookie; struct bootfs_cookie *cookie = _cookie;
int err = 0; int err = B_OK;
TRACE(("bootfs_seek: vnode 0x%x, cookie 0x%x, pos 0x%x 0x%x, seek_type %d\n", v, cookie, pos, st)); TRACE(("bootfs_seek: vnode 0x%x, cookie 0x%x, pos 0x%x 0x%x, seek_type %d\n", v, cookie, pos, st));
if (cookie->s->type != STREAM_TYPE_FILE)
return EINVAL;
mutex_lock(&fs->lock); mutex_lock(&fs->lock);
switch(cookie->s->type) { switch (seekType) {
case STREAM_TYPE_DIR:
switch(st) {
// only valid args are seek_type SEEK_SET, pos 0.
// this rewinds to beginning of directory
case SEEK_SET:
if(pos == 0) {
cookie->u.dir.ptr = cookie->s->u.dir.dir_head;
} else {
err = ESPIPE;
}
break;
case SEEK_CUR:
case SEEK_END:
default:
err = ESPIPE;
}
break;
case STREAM_TYPE_FILE:
switch(st) {
case SEEK_SET: case SEEK_SET:
if (pos < 0) if (pos < 0)
pos = 0; pos = 0;
@@ -755,32 +739,32 @@ bootfs_seek(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, off_t pos, int st)
break; break;
case SEEK_CUR: case SEEK_CUR:
if (pos + cookie->u.file.pos > cookie->s->u.file.len) if (pos + cookie->u.file.pos > cookie->s->u.file.len)
cookie->u.file.pos = cookie->s->u.file.len; pos = cookie->s->u.file.len;
else if (pos + cookie->u.file.pos < 0) else if (pos + cookie->u.file.pos < 0)
cookie->u.file.pos = 0; pos = 0;
else else
cookie->u.file.pos += pos; pos += cookie->u.file.pos;
break; break;
case SEEK_END: case SEEK_END:
if (pos > 0) if (pos > 0)
cookie->u.file.pos = cookie->s->u.file.len; pos = cookie->s->u.file.len;
else if (pos + cookie->s->u.file.len < 0) else if (pos + cookie->s->u.file.len < 0)
cookie->u.file.pos = 0; pos = 0;
else else
cookie->u.file.pos = pos + cookie->s->u.file.len; pos += cookie->s->u.file.len;
break;
default:
err = EINVAL;
}
break; break;
default: default:
err = EINVAL; err = EINVAL;
} }
if (err == B_OK)
cookie->u.file.pos = pos;
mutex_unlock(&fs->lock); mutex_unlock(&fs->lock);
if (err < B_OK)
return err; return err;
return pos;
} }
src/kernel/core/fs/devfs.c
+127 -118
View File
@@ -28,8 +28,10 @@
#if DEVFS_TRACE #if DEVFS_TRACE
# define TRACE(x) dprintf x # define TRACE(x) dprintf x
# define INSANE(x) dprintf x
#else #else
# define TRACE(x) # define TRACE(x)
# define INSANE(x)
#endif #endif
struct devfs_part_map { struct devfs_part_map {
@@ -77,7 +79,7 @@ struct devfs {
}; };
struct devfs_cookie { struct devfs_cookie {
struct devfs_stream *s; struct devfs_stream *stream;
int oflags; int oflags;
union { union {
struct cookie_dir { struct cookie_dir {
@@ -92,7 +94,7 @@ struct devfs_cookie {
}; };
/* the one and only allowed devfs instance */ /* the one and only allowed devfs instance */
static struct devfs *thedevfs = NULL; static struct devfs *gDeviceFileSystem = NULL;
#define BOOTFS_HASH_SIZE 16 #define BOOTFS_HASH_SIZE 16
@@ -105,7 +107,7 @@ devfs_vnode_hash_func(void *_v, const void *_key, unsigned int range)
if (v != NULL) if (v != NULL)
return v->id % range; return v->id % range;
else
return (*key) % range; return (*key) % range;
} }
@@ -118,7 +120,7 @@ devfs_vnode_compare_func(void *_v, const void *_key)
if (v->id == *key) if (v->id == *key)
return 0; return 0;
else
return -1; return -1;
} }
@@ -150,9 +152,10 @@ devfs_delete_vnode(struct devfs *fs, struct devfs_vnode *v, bool force_delete)
{ {
// cant delete it if it's in a directory or is a directory // cant delete it if it's in a directory or is a directory
// and has children // and has children
if(!force_delete && ((v->stream.type == STREAM_TYPE_DIR && v->stream.u.dir.dir_head != NULL) || v->dir_next != NULL)) { if (!force_delete
&& ((v->stream.type == STREAM_TYPE_DIR && v->stream.u.dir.dir_head != NULL)
|| v->dir_next != NULL))
return EPERM; return EPERM;
}
// remove it from the global hash table // remove it from the global hash table
hash_remove(fs->vnode_list_hash, v); hash_remove(fs->vnode_list_hash, v);
@@ -199,11 +202,10 @@ update_dircookies(struct devfs_vnode *dir, struct devfs_vnode *v)
struct devfs_cookie *cookie; struct devfs_cookie *cookie;
for (cookie = dir->stream.u.dir.jar_head; cookie; cookie = cookie->u.dir.next) { for (cookie = dir->stream.u.dir.jar_head; cookie; cookie = cookie->u.dir.next) {
if(cookie->u.dir.ptr == v) { if (cookie->u.dir.ptr == v)
cookie->u.dir.ptr = v->dir_next; cookie->u.dir.ptr = v->dir_next;
} }
} }
}
static struct devfs_vnode * static struct devfs_vnode *
@@ -220,9 +222,9 @@ devfs_find_in_dir(struct devfs_vnode *dir, const char *path)
return dir->parent; return dir->parent;
for (v = dir->stream.u.dir.dir_head; v; v = v->dir_next) { for (v = dir->stream.u.dir.dir_head; v; v = v->dir_next) {
// dprintf("devfs_find_in_dir: looking at entry '%s'\n", v->name); INSANE(("devfs_find_in_dir: looking at entry '%s'\n", v->name));
if (strcmp(v->name, path) == 0) { if (strcmp(v->name, path) == 0) {
// dprintf("devfs_find_in_dir: found it at 0x%x\n", v); INSANE(("devfs_find_in_dir: found it at %p\n", v));
return v; return v;
} }
} }
@@ -272,6 +274,7 @@ devfs_is_dir_empty(struct devfs_vnode *dir)
{ {
if (dir->stream.type != STREAM_TYPE_DIR) if (dir->stream.type != STREAM_TYPE_DIR)
return false; return false;
return !dir->stream.u.dir.dir_head; return !dir->stream.u.dir.dir_head;
} }
@@ -334,7 +337,7 @@ static int devfs_set_partition( struct devfs *fs, struct devfs_vnode *v,
sprintf(part_name, "%i_%i", info.session, info.partition); sprintf(part_name, "%i_%i", info.session, info.partition);
mutex_lock(&thedevfs->lock); mutex_lock(&gDeviceFileSystem->lock);
// you cannot change a partition once set // you cannot change a partition once set
if (devfs_find_in_dir( v->parent, part_name)) { if (devfs_find_in_dir( v->parent, part_name)) {
@@ -366,20 +369,20 @@ static int devfs_set_partition( struct devfs *fs, struct devfs_vnode *v,
devfs_insert_in_dir(v->parent, part_node); devfs_insert_in_dir(v->parent, part_node);
mutex_unlock(&thedevfs->lock); mutex_unlock(&gDeviceFileSystem->lock);
dprintf( "SET_PARTITION: Added partition\n" ); TRACE(("SET_PARTITION: Added partition\n"));
return B_NO_ERROR; return B_NO_ERROR;
err1: err1:
mutex_unlock(&thedevfs->lock); mutex_unlock(&gDeviceFileSystem->lock);
kfree(part_map); kfree(part_map);
return res; return res;
err2: err2:
mutex_unlock(&thedevfs->lock); mutex_unlock(&gDeviceFileSystem->lock);
vfs_put_vnode(fs->id, v->id); vfs_put_vnode(fs->id, v->id);
kfree(part_map); kfree(part_map);
@@ -399,7 +402,7 @@ devfs_mount(fs_cookie *_fs, fs_id id, const char *devfs, void *args, vnode_id *r
TRACE(("devfs_mount: entry\n")); TRACE(("devfs_mount: entry\n"));
if (thedevfs) { if (gDeviceFileSystem) {
dprintf("double mount of devfs attempted\n"); dprintf("double mount of devfs attempted\n");
err = ERR_GENERAL; err = ERR_GENERAL;
goto err; goto err;
@@ -447,7 +450,7 @@ devfs_mount(fs_cookie *_fs, fs_id id, const char *devfs, void *args, vnode_id *r
*root_vnid = v->id; *root_vnid = v->id;
*_fs = fs; *_fs = fs;
thedevfs = fs; gDeviceFileSystem = fs;
return 0; return 0;
@@ -470,7 +473,7 @@ devfs_unmount(fs_cookie _fs)
struct devfs_vnode *v; struct devfs_vnode *v;
struct hash_iterator i; struct hash_iterator i;
TRACE(("devfs_unmount: entry fs = 0x%x\n", fs)); TRACE(("devfs_unmount: entry fs = %p\n", fs));
// delete all of the vnodes // delete all of the vnodes
hash_open(fs->vnode_list_hash, &i); hash_open(fs->vnode_list_hash, &i);
@@ -501,11 +504,11 @@ devfs_lookup(fs_cookie _fs, fs_vnode _dir, const char *name, vnode_id *id)
{ {
struct devfs *fs = (struct devfs *)_fs; struct devfs *fs = (struct devfs *)_fs;
struct devfs_vnode *dir = (struct devfs_vnode *)_dir; struct devfs_vnode *dir = (struct devfs_vnode *)_dir;
struct devfs_vnode *v; struct devfs_vnode *vnode;
struct devfs_vnode *v1; struct devfs_vnode *vdummy;
int err; int err;
TRACE(("devfs_lookup: entry dir 0x%x, name '%s'\n", dir, name)); TRACE(("devfs_lookup: entry dir %p, name '%s'\n", dir, name));
if (dir->stream.type != STREAM_TYPE_DIR) if (dir->stream.type != STREAM_TYPE_DIR)
return ENOTDIR; return ENOTDIR;
@@ -513,59 +516,57 @@ devfs_lookup(fs_cookie _fs, fs_vnode _dir, const char *name, vnode_id *id)
mutex_lock(&fs->lock); mutex_lock(&fs->lock);
// look it up // look it up
v = devfs_find_in_dir(dir, name); vnode = devfs_find_in_dir(dir, name);
if(!v) { if (!vnode) {
err = ERR_NOT_FOUND; err = ERR_NOT_FOUND;
goto err; goto err;
} }
err = vfs_get_vnode(fs->id, v->id, (fs_vnode *)&v1); err = vfs_get_vnode(fs->id, vnode->id, (fs_vnode *)&vdummy);
if(err < 0) { if (err < 0)
goto err; goto err;
}
*id = v->id; *id = vnode->id;
err = B_NO_ERROR;
err: err:
mutex_unlock(&fs->lock); mutex_unlock(&fs->lock);
INSANE(("--devfs_lookup: returns %d\n",err));
return err; return err;
} }
static int static int
devfs_get_vnode(fs_cookie _fs, vnode_id id, fs_vnode *v, bool r) devfs_get_vnode(fs_cookie _fs, vnode_id id, fs_vnode *_vnode, bool reenter)
{ {
struct devfs *fs = (struct devfs *)_fs; struct devfs *fs = (struct devfs *)_fs;
TRACE(("devfs_getvnode: asking for vnode 0x%x 0x%x, r %d\n", id, r)); TRACE(("devfs_get_vnode: asking for vnode id = %Ld, vnode = %p, r %d\n", id, _vnode, reenter));
if(!r) if (!reenter)
mutex_lock(&fs->lock); mutex_lock(&fs->lock);
*v = hash_lookup(fs->vnode_list_hash, &id); *_vnode = hash_lookup(fs->vnode_list_hash, &id);
if(!r) if (!reenter)
mutex_unlock(&fs->lock); mutex_unlock(&fs->lock);
TRACE(("devfs_getnvnode: looked it up at 0x%x\n", *v)); TRACE(("devfs_get_vnode: looked it up at %p\n", *_vnode));
if(*v) if (*_vnode)
return 0; return 0;
else
return ERR_NOT_FOUND; return ERR_NOT_FOUND;
} }
static int static int
devfs_put_vnode(fs_cookie _fs, fs_vnode _v, bool r) devfs_put_vnode(fs_cookie _fs, fs_vnode _v, bool reenter)
{ {
#if DEVFS_TRACE #if DEVFS_TRACE
struct devfs_vnode *v = (struct devfs_vnode *)_v; struct devfs_vnode *vnode = (struct devfs_vnode *)_v;
TRACE(("devfs_putvnode: entry on vnode 0x%x 0x%x, r %d\n", v->id, r)); TRACE(("devfs_put_vnode: entry on vnode %p, id = %Ld, reenter %d\n", vnode, vnode->id, reenter));
#endif #endif
return 0; // whatever return 0; // whatever
@@ -573,30 +574,27 @@ devfs_put_vnode(fs_cookie _fs, fs_vnode _v, bool r)
static int static int
devfs_remove_vnode(fs_cookie _fs, fs_vnode _v, bool r) devfs_remove_vnode(fs_cookie _fs, fs_vnode _v, bool reenter)
{ {
struct devfs *fs = (struct devfs *)_fs; struct devfs *fs = (struct devfs *)_fs;
struct devfs_vnode *v = (struct devfs_vnode *)_v; struct devfs_vnode *vnode = (struct devfs_vnode *)_v;
int err;
TRACE(("devfs_removevnode: remove 0x%x (0x%x 0x%x), r %d\n", v, v->id, r)); TRACE(("devfs_removevnode: remove %p (%Ld), reenter %d\n", vnode, vnode->id, reenter));
if(!r) if (!reenter)
mutex_lock(&fs->lock); mutex_lock(&fs->lock);
if(v->dir_next) { if (vnode->dir_next) {
// can't remove node if it's linked to the dir // can't remove node if it's linked to the dir
panic("devfs_removevnode: vnode %p asked to be removed is present in dir\n", v); panic("devfs_removevnode: vnode %p asked to be removed is present in dir\n", vnode);
} }
devfs_delete_vnode(fs, v, false); devfs_delete_vnode(fs, vnode, false);
err = 0; if (!reenter)
if(!r)
mutex_unlock(&fs->lock); mutex_unlock(&fs->lock);
return err; return B_OK;
} }
@@ -615,14 +613,25 @@ devfs_open(fs_cookie _fs, fs_vnode _v, file_cookie *_cookie, int oflags)
struct devfs_cookie *cookie; struct devfs_cookie *cookie;
int status = 0; int status = 0;
TRACE(("devfs_open: vnode 0x%x, oflags 0x%x\n", v, oflags)); TRACE(("devfs_open: vnode %p, oflags 0x%x\n", vnode, oflags));
cookie = kmalloc(sizeof(struct devfs_cookie)); cookie = kmalloc(sizeof(struct devfs_cookie));
if (cookie == NULL) if (cookie == NULL)
return ENOMEM; return ENOMEM;
INSANE(("zulu: calls = %p\n",vnode->stream.u.dev.calls));
if (vnode->stream.u.dev.calls)
INSANE(("hellacious: open = %p!\n",vnode->stream.u.dev.calls->open));
if (vnode->stream.type != STREAM_TYPE_DEVICE) {
INSANE(("bye bye!\n"));
return EINVAL;
}
INSANE(("got here.\n"));
status = vnode->stream.u.dev.calls->open(vnode->name, oflags, &cookie->u.dev.dcookie); status = vnode->stream.u.dev.calls->open(vnode->name, oflags, &cookie->u.dev.dcookie);
*_cookie = cookie; *_cookie = cookie;
INSANE(("cool!\n"));
return status; return status;
} }
@@ -634,7 +643,7 @@ devfs_close(fs_cookie _fs, fs_vnode _v, file_cookie _cookie)
struct devfs_vnode *vnode = _v; struct devfs_vnode *vnode = _v;
struct devfs_cookie *cookie = _cookie; struct devfs_cookie *cookie = _cookie;
TRACE(("devfs_close: entry vnode 0x%x, cookie 0x%x\n", v, cookie)); TRACE(("devfs_close: entry vnode %p, cookie %p\n", vnode, cookie));
if (vnode->stream.type == STREAM_TYPE_DEVICE) { if (vnode->stream.type == STREAM_TYPE_DEVICE) {
// pass the call through to the underlying device // pass the call through to the underlying device
@@ -651,7 +660,7 @@ devfs_free_cookie(fs_cookie _fs, fs_vnode _v, file_cookie _cookie)
struct devfs_vnode *vnode = _v; struct devfs_vnode *vnode = _v;
struct devfs_cookie *cookie = _cookie; struct devfs_cookie *cookie = _cookie;
TRACE(("devfs_freecookie: entry vnode 0x%x, cookie 0x%x\n", vnode, cookie)); TRACE(("devfs_freecookie: entry vnode %p, cookie %p\n", vnode, cookie));
if (vnode->stream.type == STREAM_TYPE_DEVICE) { if (vnode->stream.type == STREAM_TYPE_DEVICE) {
// pass the call through to the underlying device // pass the call through to the underlying device
@@ -679,12 +688,16 @@ devfs_read(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, void *buffer, off_t
struct devfs_vnode *vnode = _v; struct devfs_vnode *vnode = _v;
struct devfs_cookie *cookie = _cookie; struct devfs_cookie *cookie = _cookie;
struct devfs_part_map *part_map; struct devfs_part_map *part_map;
int status;
TRACE(("devfs_read: vnode 0x%x, cookie 0x%x, pos 0x%x 0x%x, len 0x%x\n", vnode, cookie, pos, len)); TRACE(("devfs_read: vnode %p, cookie %p, pos %Ld, len %p\n", vnode, cookie, pos, length));
if (cookie->s->type != STREAM_TYPE_DEVICE) INSANE(("juchu, buffer = %p!\n",buffer));
return EINVAL; // if (cookie->stream->type != STREAM_TYPE_DEVICE)
// return EINVAL;
INSANE((":%p:%p:%p:%p\n",vnode->all_next,vnode->name,vnode->redir_vnode,vnode->parent));
INSANE(("name = %s\n",vnode->name));
part_map = vnode->stream.u.dev.part_map; part_map = vnode->stream.u.dev.part_map;
if (part_map) { if (part_map) {
if (pos < 0) if (pos < 0)
@@ -698,7 +711,11 @@ devfs_read(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, void *buffer, off_t
} }
// pass the call through to the device // pass the call through to the device
return vnode->stream.u.dev.calls->read(cookie->u.dev.dcookie, pos, buffer, length); INSANE(("calls = %p\n",vnode->stream.u.dev.calls));
status = vnode->stream.u.dev.calls->read(cookie->u.dev.dcookie, pos, buffer, length);
INSANE(("hulu: calls = %p\n",vnode->stream.u.dev.calls));
INSANE((":%p:%p:%p:%p\n",vnode->all_next,vnode->name,vnode->redir_vnode,vnode->parent));
return status;
} }
@@ -706,13 +723,15 @@ static ssize_t
devfs_write(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, const void *buf, devfs_write(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, const void *buf,
off_t pos, size_t *len) off_t pos, size_t *len)
{ {
struct devfs_vnode *v = _v; struct devfs_vnode *vnode = _v;
struct devfs_cookie *cookie = _cookie; struct devfs_cookie *cookie = _cookie;
TRACE(("devfs_write: vnode 0x%x, cookie 0x%x, pos 0x%x 0x%x, len 0x%x\n", v, cookie, pos, len)); TRACE(("devfs_write: vnode %p, cookie %p, pos %Ld, len %p\n", vnode, cookie, pos, len));
INSANE((":%p:%p:%p:%p\n",vnode->all_next,vnode->name,vnode->redir_vnode,vnode->parent));
if (v->stream.type == STREAM_TYPE_DEVICE) { if (vnode->stream.type == STREAM_TYPE_DEVICE) {
struct devfs_part_map *part_map = v->stream.u.dev.part_map; struct devfs_part_map *part_map = vnode->stream.u.dev.part_map;
int written;
if (part_map) { if (part_map) {
if (pos < 0) if (pos < 0)
@@ -725,51 +744,28 @@ devfs_write(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, const void *buf,
pos += part_map->offset; pos += part_map->offset;
} }
return v->stream.u.dev.calls->write(cookie->u.dev.dcookie, pos, buf, len); INSANE(("hela: name = \"%s\", calls = %p\n",vnode->name,vnode->stream.u.dev.calls));
written = vnode->stream.u.dev.calls->write(cookie->u.dev.dcookie, pos, buf, len);
INSANE(("helu: calls = %p\n",vnode->stream.u.dev.calls));
INSANE((":%p:%p:%p:%p\n",vnode->all_next,vnode->name,vnode->redir_vnode,vnode->parent));
return written;
} }
return EROFS; return EINVAL;
} }
static int static off_t
devfs_seek(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, off_t pos, int st) devfs_seek(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, off_t pos, int seekType)
{ {
#ifdef DEBUG
struct devfs *fs = _fs; struct devfs *fs = _fs;
struct devfs_vnode *v = _v; struct devfs_vnode *vnode = _v;
struct devfs_cookie *cookie = _cookie; struct devfs_cookie *cookie = _cookie;
int err = 0;
TRACE(("devfs_seek: vnode 0x%x, cookie 0x%x, pos 0x%x 0x%x, seek_type %d\n", v, cookie, pos, st)); TRACE(("devfs_seek: vnode %p, cookie %p, pos %Ld, seekType %d\n", vnode, cookie, pos, seekType));
#endif
switch(cookie->s->type) { return ESPIPE;
case STREAM_TYPE_DIR:
mutex_lock(&fs->lock);
switch(st) {
// only valid args are seek_type SEEK_SET, pos 0.
// this rewinds to beginning of directory
case SEEK_SET:
if(pos == 0) {
cookie->u.dir.ptr = cookie->s->u.dir.dir_head;
} else {
err = ESPIPE;
}
break;
case SEEK_CUR:
case SEEK_END:
default:
err = EINVAL;
}
mutex_unlock(&fs->lock);
break;
case STREAM_TYPE_DEVICE:
dprintf("seek not supported!\n");
//err = v->stream.u.dev.calls->dev_seek(cookie->u.dev.dcookie, pos, st);
break;
default:
err = EINVAL;
}
return err;
} }
@@ -787,7 +783,7 @@ devfs_open_dir(fs_cookie _fs, fs_vnode _v, file_cookie *_cookie)
struct devfs_vnode *vnode = _v; struct devfs_vnode *vnode = _v;
struct devfs_cookie *cookie; struct devfs_cookie *cookie;
TRACE(("devfs_open: vnode 0x%x, oflags 0x%x\n", vnode, oflags)); TRACE(("devfs_open_dir: vnode %p\n", vnode));
if (vnode->stream.type != STREAM_TYPE_DIR) if (vnode->stream.type != STREAM_TYPE_DIR)
return EINVAL; return EINVAL;
@@ -798,7 +794,7 @@ devfs_open_dir(fs_cookie _fs, fs_vnode _v, file_cookie *_cookie)
mutex_lock(&fs->lock); mutex_lock(&fs->lock);
cookie->s = &vnode->stream; cookie->stream = &vnode->stream;
cookie->u.dir.ptr = vnode->stream.u.dir.dir_head; cookie->u.dir.ptr = vnode->stream.u.dir.dir_head;
*_cookie = cookie; *_cookie = cookie;
@@ -814,7 +810,10 @@ devfs_read_dir(fs_cookie _fs, fs_vnode _vnode, file_cookie _cookie, struct diren
struct devfs *fs = _fs; struct devfs *fs = _fs;
status_t status = 0; status_t status = 0;
TRACE(("devfs_read_dir: vnode 0x%x, cookie 0x%x, pos 0x%x 0x%x, len 0x%x\n", v, cookie, dirent, bufferSize)); TRACE(("devfs_read_dir: vnode %p, cookie %p, buffer %p, size %ld\n", _vnode, cookie, dirent, bufferSize));
if (cookie->stream->type != STREAM_TYPE_DIR)
return EINVAL;
mutex_lock(&fs->lock); mutex_lock(&fs->lock);
@@ -850,12 +849,16 @@ static int
devfs_rewind_dir(fs_cookie _fs, fs_vnode _vnode, file_cookie _cookie) devfs_rewind_dir(fs_cookie _fs, fs_vnode _vnode, file_cookie _cookie)
{ {
struct devfs *fs = _fs; struct devfs *fs = _fs;
struct devfs_vnode *vnode = _vnode;
struct devfs_cookie *cookie = _cookie; struct devfs_cookie *cookie = _cookie;
TRACE(("devfs_rewind_dir: vnode %p, cookie %p\n", _vnode, _cookie));
if (cookie->stream->type != STREAM_TYPE_DIR)
return EINVAL;
mutex_lock(&fs->lock); mutex_lock(&fs->lock);
cookie->u.dir.ptr = vnode->stream.u.dir.dir_head; cookie->u.dir.ptr = cookie->stream->u.dir.dir_head;
mutex_unlock(&fs->lock); mutex_unlock(&fs->lock);
return B_OK; return B_OK;
@@ -869,7 +872,7 @@ devfs_ioctl(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, ulong op, void *buf
struct devfs_vnode *v = _v; struct devfs_vnode *v = _v;
struct devfs_cookie *cookie = _cookie; struct devfs_cookie *cookie = _cookie;
TRACE(("devfs_ioctl: vnode 0x%x, cookie 0x%x, op %d, buf 0x%x, len 0x%x\n", _v, _cookie, op, buf, len)); TRACE(("devfs_ioctl: vnode %p, cookie %p, op %ld, buf %p, len %ld\n", _v, _cookie, op, buf, len));
if (v->stream.type == STREAM_TYPE_DEVICE) { if (v->stream.type == STREAM_TYPE_DEVICE) {
switch (op) { switch (op) {
@@ -1008,15 +1011,16 @@ devfs_rename(fs_cookie _fs, fs_vnode _olddir, const char *oldname, fs_vnode _new
static int static int
devfs_read_stat(fs_cookie _fs, fs_vnode _v, struct stat *stat) devfs_read_stat(fs_cookie _fs, fs_vnode _v, struct stat *stat)
{ {
struct devfs_vnode *v = _v; struct devfs_vnode *vnode = _v;
TRACE(("devfs_rstat: vnode 0x%x (0x%x 0x%x), stat 0x%x\n", v, v->id, stat)); TRACE(("devfs_rstat: vnode %p (%Ld), stat %p\n", vnode, vnode->id, stat));
INSANE(("-> calls = %p\n",vnode->stream.u.dev.calls));
stat->st_ino = v->id; stat->st_ino = vnode->id;
stat->st_mode = DEFFILEMODE; stat->st_mode = DEFFILEMODE;
stat->st_size = 0; stat->st_size = 0;
if (v->stream.type == STREAM_TYPE_DIR) if (vnode->stream.type == STREAM_TYPE_DIR)
stat->st_mode |= S_IFDIR; stat->st_mode |= S_IFDIR;
else else
stat->st_mode |= S_IFCHR; stat->st_mode |= S_IFCHR;
@@ -1031,7 +1035,7 @@ devfs_write_stat(fs_cookie _fs, fs_vnode _v, struct stat *stat, int stat_mask)
#if DEVFS_TRACE #if DEVFS_TRACE
struct devfs_vnode *v = _v; struct devfs_vnode *v = _v;
TRACE(("devfs_wstat: vnode 0x%x (0x%x 0x%x), stat 0x%x\n", v, v->id, stat)); TRACE(("devfs_wstat: vnode %p (%Ld), stat %p\n", v, v->id, stat));
#endif #endif
// cannot change anything // cannot change anything
return EPERM; return EPERM;
@@ -1089,7 +1093,7 @@ int
bootstrap_devfs(void) bootstrap_devfs(void)
{ {
dprintf("bootstrap_devfs: entry\n"); TRACE(("bootstrap_devfs: entry\n"));
return vfs_register_filesystem("devfs", &devfs_calls); return vfs_register_filesystem("devfs", &devfs_calls);
} }
@@ -1105,9 +1109,14 @@ devfs_publish_device(const char *path, void *ident, device_hooks *calls)
struct devfs_vnode *v; struct devfs_vnode *v;
bool at_leaf; bool at_leaf;
TRACE(("devfs_publish_device: entry path '%s', hooks 0x%x\n", path, calls)); TRACE(("devfs_publish_device: entry path '%s', ident %p, hooks %p\n", path, ident, calls));
if (!thedevfs) { if (calls == NULL || path == NULL) {
panic("devfs_publish_device called with NULL pointer!\n");
return EINVAL;
}
if (!gDeviceFileSystem) {
panic("devfs_publish_device called before devfs mounted\n"); panic("devfs_publish_device called before devfs mounted\n");
return ERR_GENERAL; return ERR_GENERAL;
} }
@@ -1116,11 +1125,11 @@ devfs_publish_device(const char *path, void *ident, device_hooks *calls)
strncpy(temp, path, SYS_MAX_PATH_LEN); strncpy(temp, path, SYS_MAX_PATH_LEN);
temp[SYS_MAX_PATH_LEN] = 0; temp[SYS_MAX_PATH_LEN] = 0;
mutex_lock(&thedevfs->lock); mutex_lock(&gDeviceFileSystem->lock);
// create the path leading to the device // create the path leading to the device
// parse the path passed in, stripping out '/' // parse the path passed in, stripping out '/'
dir = thedevfs->root_vnode; dir = gDeviceFileSystem->root_vnode;
v = NULL; v = NULL;
i = 0; i = 0;
last = 0; last = 0;
@@ -1156,7 +1165,7 @@ devfs_publish_device(const char *path, void *ident, device_hooks *calls)
err = ERR_VFS_ALREADY_EXISTS; err = ERR_VFS_ALREADY_EXISTS;
goto err; goto err;
} else { } else {
v = devfs_create_vnode(thedevfs, &temp[last]); v = devfs_create_vnode(gDeviceFileSystem, &temp[last]);
if (!v) { if (!v) {
err = ENOMEM; err = ENOMEM;
goto err; goto err;
@@ -1176,7 +1185,7 @@ devfs_publish_device(const char *path, void *ident, device_hooks *calls)
v->stream.u.dir.jar_head = NULL; v->stream.u.dir.jar_head = NULL;
} }
hash_insert(thedevfs->vnode_list_hash, v); hash_insert(gDeviceFileSystem->vnode_list_hash, v);
devfs_insert_in_dir(dir, v); devfs_insert_in_dir(dir, v);
@@ -1187,7 +1196,7 @@ devfs_publish_device(const char *path, void *ident, device_hooks *calls)
} }
err: err:
mutex_unlock(&thedevfs->lock); mutex_unlock(&gDeviceFileSystem->lock);
return err; return err;
} }
src/kernel/core/fs/rootfs.c
+13 -42
View File
@@ -112,7 +112,7 @@ rootfs_delete_vnode(struct rootfs *fs, struct rootfs_vnode *v, bool force_delete
// cant delete it if it's in a directory or is a directory // cant delete it if it's in a directory or is a directory
// and has children // and has children
if (!force_delete && (v->stream.dir.dir_head != NULL || v->dir_next != NULL)) if (!force_delete && (v->stream.dir.dir_head != NULL || v->dir_next != NULL))
return ERR_NOT_ALLOWED; return EPERM;
// remove it from the global hash table // remove it from the global hash table
hash_remove(fs->vnode_list_hash, v); hash_remove(fs->vnode_list_hash, v);
@@ -221,10 +221,8 @@ rootfs_mount(fs_cookie *_fs, fs_id id, const char *device, void *args, vnode_id
TRACE(("rootfs_mount: entry\n")); TRACE(("rootfs_mount: entry\n"));
fs = kmalloc(sizeof(struct rootfs)); fs = kmalloc(sizeof(struct rootfs));
if(fs == NULL) { if (fs == NULL)
err = ERR_NO_MEMORY; return ENOMEM;
goto err;
}
fs->id = id; fs->id = id;
fs->next_vnode_id = 0; fs->next_vnode_id = 0;
@@ -237,14 +235,14 @@ rootfs_mount(fs_cookie *_fs, fs_id id, const char *device, void *args, vnode_id
fs->vnode_list_hash = hash_init(ROOTFS_HASH_SIZE, (addr)&v->all_next - (addr)v, fs->vnode_list_hash = hash_init(ROOTFS_HASH_SIZE, (addr)&v->all_next - (addr)v,
&rootfs_vnode_compare_func, &rootfs_vnode_hash_func); &rootfs_vnode_compare_func, &rootfs_vnode_hash_func);
if (fs->vnode_list_hash == NULL) { if (fs->vnode_list_hash == NULL) {
err = ERR_NO_MEMORY; err = ENOMEM;
goto err2; goto err2;
} }
// create a vnode // create a vnode
v = rootfs_create_vnode(fs); v = rootfs_create_vnode(fs);
if (v == NULL) { if (v == NULL) {
err = ERR_NO_MEMORY; err = ENOMEM;
goto err3; goto err3;
} }
@@ -252,7 +250,7 @@ rootfs_mount(fs_cookie *_fs, fs_id id, const char *device, void *args, vnode_id
v->parent = v; v->parent = v;
v->name = kstrdup(""); v->name = kstrdup("");
if (v->name == NULL) { if (v->name == NULL) {
err = ERR_NO_MEMORY; err = ENOMEM;
goto err4; goto err4;
} }
@@ -273,7 +271,7 @@ err2:
mutex_destroy(&fs->lock); mutex_destroy(&fs->lock);
err1: err1:
kfree(fs); kfree(fs);
err:
return err; return err;
} }
@@ -368,9 +366,9 @@ rootfs_get_vnode(fs_cookie _fs, vnode_id id, fs_vnode *v, bool r)
TRACE(("rootfs_getnvnode: looked it up at 0x%x\n", *v)); TRACE(("rootfs_getnvnode: looked it up at 0x%x\n", *v));
if (*v) if (*v)
return 0; return B_NO_ERROR;
else
return ERR_NOT_FOUND; return ENOENT;
} }
@@ -477,41 +475,14 @@ rootfs_write(fs_cookie fs, fs_vnode v, file_cookie cookie, const void *buf, off_
{ {
TRACE(("rootfs_write: vnode 0x%x, cookie 0x%x, pos 0x%x 0x%x, len 0x%x\n", v, cookie, pos, *len)); TRACE(("rootfs_write: vnode 0x%x, cookie 0x%x, pos 0x%x 0x%x, len 0x%x\n", v, cookie, pos, *len));
return ERR_NOT_ALLOWED; return EPERM;
} }
static int static off_t
rootfs_seek(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, off_t pos, int st) rootfs_seek(fs_cookie _fs, fs_vnode _v, file_cookie _cookie, off_t pos, int st)
{ {
struct rootfs *fs = _fs; return ESPIPE;
struct rootfs_vnode *v = _v;
struct rootfs_cookie *cookie = _cookie;
int err = 0;
TRACE(("rootfs_seek: vnode 0x%x, cookie 0x%x, pos 0x%x 0x%x, seek_type %d\n", v, cookie, pos, st));
mutex_lock(&fs->lock);
switch(st) {
// only valid args are seek_type SEEK_SET, pos 0.
// this rewinds to beginning of directory
case SEEK_SET:
if(pos == 0) {
cookie->ptr = v->stream.dir.dir_head;
} else {
err = ESPIPE;
}
break;
case SEEK_CUR:
case SEEK_END:
default:
err = EINVAL;
}
mutex_unlock(&fs->lock);
return err;
} }
src/kernel/core/fs/vfs.c
+77 -89
View File
@@ -108,15 +108,16 @@ static int vfs_close(struct file_descriptor *, int, struct io_context *);
static int common_ioctl(struct file_descriptor *, ulong, void *buf, size_t len); static int common_ioctl(struct file_descriptor *, ulong, void *buf, size_t len);
static int common_read_stat(struct file_descriptor *, struct stat *); static int common_read_stat(struct file_descriptor *, struct stat *);
static int common_close(struct file_descriptor *, int, struct io_context *);
static ssize_t file_read(struct file_descriptor *, void *, off_t, size_t *); static ssize_t file_read(struct file_descriptor *, void *, off_t, size_t *);
static ssize_t file_write(struct file_descriptor *, const void *, off_t, size_t *); static ssize_t file_write(struct file_descriptor *, const void *, off_t, size_t *);
static int file_seek(struct file_descriptor *, off_t pos, int seek_type); static off_t file_seek(struct file_descriptor *, off_t pos, int seek_type);
static status_t dir_read(struct file_descriptor *,struct dirent *buffer,size_t bufferSize,uint32 *_count); static status_t dir_read(struct file_descriptor *,struct dirent *buffer,size_t bufferSize,uint32 *_count);
static status_t dir_rewind(struct file_descriptor *); static status_t dir_rewind(struct file_descriptor *);
static void file_free_fd(struct file_descriptor *); static void file_free_fd(struct file_descriptor *);
static int file_close(struct file_descriptor *);
static void dir_free_fd(struct file_descriptor *); static void dir_free_fd(struct file_descriptor *);
static int dir_close(struct file_descriptor *);
static int vfs_open(char *path, int omode, bool kernel); static int vfs_open(char *path, int omode, bool kernel);
static int vfs_open_dir(char *path, bool kernel); static int vfs_open_dir(char *path, bool kernel);
@@ -132,7 +133,7 @@ struct fd_ops file_ops = {
NULL, NULL,
NULL, NULL,
common_read_stat, common_read_stat,
common_close, file_close,
file_free_fd file_free_fd
}; };
@@ -145,7 +146,7 @@ struct fd_ops dir_ops = {
dir_read, dir_read,
dir_rewind, dir_rewind,
common_read_stat, common_read_stat,
common_close, dir_close,
dir_free_fd dir_free_fd
}; };
@@ -167,7 +168,7 @@ mount_compare(void *_m, const void *_key)
if (mount->id == *id) if (mount->id == *id)
return 0; return 0;
else
return -1; return -1;
} }
@@ -180,7 +181,7 @@ mount_hash(void *_m, const void *_key, unsigned int range)
if (mount) if (mount)
return mount->id % range; return mount->id % range;
else
return *id % range; return *id % range;
} }
@@ -312,7 +313,7 @@ dec_vnode_ref_count(struct vnode *v, bool free_mem, bool r)
old_ref = atomic_add(&v->ref_count, -1); old_ref = atomic_add(&v->ref_count, -1);
PRINT(("dec_vnode_ref_count: vnode 0x%x, ref now %d\n", v, v->ref_count)); PRINT(("dec_vnode_ref_count: vnode 0x%p, ref now %d\n", v, v->ref_count));
if (old_ref == 1) { if (old_ref == 1) {
v->busy = true; v->busy = true;
@@ -350,7 +351,7 @@ static int
inc_vnode_ref_count(struct vnode *v) inc_vnode_ref_count(struct vnode *v)
{ {
atomic_add(&v->ref_count, 1); atomic_add(&v->ref_count, 1);
PRINT(("inc_vnode_ref_count: vnode 0x%x, ref now %d\n", v, v->ref_count)); PRINT(("inc_vnode_ref_count: vnode 0x%p, ref now %d\n", v, v->ref_count));
return 0; return 0;
} }
@@ -373,7 +374,7 @@ get_vnode(fs_id fsid, vnode_id vnid, struct vnode **outv, int r)
struct vnode *v; struct vnode *v;
int err; int err;
FUNCTION(("get_vnode: fsid %d vnid 0x%x 0x%x\n", fsid, vnid)); FUNCTION(("get_vnode: fsid %d vnid 0x%Lx 0x%p\n", fsid, vnid,outv));
mutex_lock(&vfs_vnode_mutex); mutex_lock(&vfs_vnode_mutex);
@@ -389,7 +390,7 @@ get_vnode(fs_id fsid, vnode_id vnid, struct vnode **outv, int r)
} }
} while(0); } while(0);
PRINT(("get_vnode: tried to lookup vnode, got 0x%x\n", v)); PRINT(("get_vnode: tried to lookup vnode, got 0x%p\n", v));
if (v) { if (v) {
inc_vnode_ref_count(v); inc_vnode_ref_count(v);
@@ -428,7 +429,7 @@ get_vnode(fs_id fsid, vnode_id vnid, struct vnode **outv, int r)
mutex_unlock(&vfs_vnode_mutex); mutex_unlock(&vfs_vnode_mutex);
PRINT(("get_vnode: returning 0x%x\n", v)); PRINT(("get_vnode: returning 0x%p\n", v));
*outv = v; *outv = v;
return B_NO_ERROR; return B_NO_ERROR;
@@ -486,7 +487,7 @@ vfs_put_vnode(fs_id fsid, vnode_id vnid)
void void
vfs_vnode_acquire_ref(void *v) vfs_vnode_acquire_ref(void *v)
{ {
FUNCTION(("vfs_vnode_acquire_ref: vnode 0x%x\n", v)); FUNCTION(("vfs_vnode_acquire_ref: vnode 0x%p\n", v));
inc_vnode_ref_count((struct vnode *)v); inc_vnode_ref_count((struct vnode *)v);
} }
@@ -494,7 +495,7 @@ vfs_vnode_acquire_ref(void *v)
void void
vfs_vnode_release_ref(void *v) vfs_vnode_release_ref(void *v)
{ {
FUNCTION(("vfs_vnode_release_ref: vnode 0x%x\n", v)); FUNCTION(("vfs_vnode_release_ref: vnode 0x%p\n", v));
dec_vnode_ref_count((struct vnode *)v, true, false); dec_vnode_ref_count((struct vnode *)v, true, false);
} }
@@ -538,7 +539,7 @@ file_free_fd(struct file_descriptor *descriptor)
struct vnode *vnode = descriptor->vnode; struct vnode *vnode = descriptor->vnode;
if (vnode != NULL) { if (vnode != NULL) {
FS_CALL(vnode,fs_close)(vnode->mount->cookie, vnode->priv_vnode, descriptor->cookie); //FS_CALL(vnode,fs_close)(vnode->mount->cookie, vnode->priv_vnode, descriptor->cookie);
FS_CALL(vnode,fs_free_cookie)(vnode->mount->cookie, vnode->priv_vnode, descriptor->cookie); FS_CALL(vnode,fs_free_cookie)(vnode->mount->cookie, vnode->priv_vnode, descriptor->cookie);
dec_vnode_ref_count(vnode, true, false); dec_vnode_ref_count(vnode, true, false);
} }
@@ -551,7 +552,7 @@ dir_free_fd(struct file_descriptor *descriptor)
struct vnode *vnode = descriptor->vnode; struct vnode *vnode = descriptor->vnode;
if (vnode != NULL) { if (vnode != NULL) {
FS_CALL(vnode,fs_close_dir)(vnode->mount->cookie, vnode->priv_vnode, descriptor->cookie); //FS_CALL(vnode,fs_close_dir)(vnode->mount->cookie, vnode->priv_vnode, descriptor->cookie);
FS_CALL(vnode,fs_free_dir_cookie)(vnode->mount->cookie, vnode->priv_vnode, descriptor->cookie); FS_CALL(vnode,fs_free_dir_cookie)(vnode->mount->cookie, vnode->priv_vnode, descriptor->cookie);
dec_vnode_ref_count(vnode, true, false); dec_vnode_ref_count(vnode, true, false);
} }
@@ -942,9 +943,7 @@ vfs_mount(char *path, const char *device, const char *fs_name, void *args, bool
struct vnode *covered_vnode = NULL; struct vnode *covered_vnode = NULL;
vnode_id root_id; vnode_id root_id;
#if MAKE_NOIZE FUNCTION(("vfs_mount: entry. path = '%s', fs_name = '%s'\n", path, fs_name));
dprintf("vfs_mount: entry. path = '%s', fs_name = '%s'\n", path, fs_name);
#endif
mutex_lock(&vfs_mount_op_mutex); mutex_lock(&vfs_mount_op_mutex);
@@ -986,9 +985,8 @@ vfs_mount(char *path, const char *device, const char *fs_name, void *args, bool
mount->covers_vnode = NULL; // this is the root mount mount->covers_vnode = NULL; // this is the root mount
} else { } else {
err = path_to_vnode(path,&covered_vnode,kernel); err = path_to_vnode(path,&covered_vnode,kernel);
if(err < 0) { if (err < 0)
goto err2; goto err2;
}
if (!covered_vnode) { if (!covered_vnode) {
err = ERR_VFS_GENERAL; err = ERR_VFS_GENERAL;
@@ -1057,9 +1055,7 @@ vfs_unmount(char *path, bool kernel)
struct fs_mount *mount; struct fs_mount *mount;
int err; int err;
#if MAKE_NOIZE FUNCTION(("vfs_unmount: entry. path = '%s', kernel %d\n", path, kernel));
dprintf("vfs_unmount: entry. path = '%s', kernel %d\n", path, kernel);
#endif
err = path_to_vnode(path, &v, kernel); err = path_to_vnode(path, &v, kernel);
if (err < 0) { if (err < 0) {
@@ -1070,9 +1066,8 @@ vfs_unmount(char *path, bool kernel)
mutex_lock(&vfs_mount_op_mutex); mutex_lock(&vfs_mount_op_mutex);
mount = fsid_to_mount(v->fsid); mount = fsid_to_mount(v->fsid);
if(!mount) { if (!mount)
panic("vfs_unmount: fsid_to_mount failed on root vnode @%p of mount\n", v); panic("vfs_unmount: fsid_to_mount failed on root vnode @%p of mount\n", v);
}
if (mount->root_vnode != v) { if (mount->root_vnode != v) {
// not mountpoint // not mountpoint
@@ -1147,9 +1142,7 @@ vfs_sync(void)
struct hash_iterator iter; struct hash_iterator iter;
struct fs_mount *mount; struct fs_mount *mount;
#if MAKE_NOIZE FUNCTION(("vfs_sync: entry.\n"));
dprintf("vfs_sync: entry.\n");
#endif
/* cycle through and call sync on each mounted fs */ /* cycle through and call sync on each mounted fs */
mutex_lock(&vfs_mount_op_mutex); mutex_lock(&vfs_mount_op_mutex);
@@ -1200,7 +1193,7 @@ vfs_create(char *path, int omode, int perms, bool kernel)
vnode_id newID; vnode_id newID;
int status; int status;
FUNCTION(("vfs_create: path '%s', kernel %d\n", path, stream_type, args, kernel)); FUNCTION(("vfs_create: path '%s', omode %x, perms %d, kernel %d\n", path, omode, perms, kernel));
status = path_to_dir_vnode(path, &vnode, filename, kernel); status = path_to_dir_vnode(path, &vnode, filename, kernel);
if (status < 0) if (status < 0)
@@ -1270,13 +1263,30 @@ err:
static int static int
common_close(struct file_descriptor *descriptor, int fd, struct io_context *io) file_close(struct file_descriptor *descriptor)
{ {
// We don't call fs_close() here, because a forked team might struct vnode *vnode = descriptor->vnode;
// have access to the same fd - just remove it from our fd array
remove_fd(io, fd);
return 0; FUNCTION(("file_close(descriptor = %p)\n",descriptor));
if (FS_CALL(vnode,fs_close))
return FS_CALL(vnode,fs_close)(vnode->mount->cookie,vnode->priv_vnode,descriptor->cookie);
return B_OK;
}
static int
dir_close(struct file_descriptor *descriptor)
{
struct vnode *vnode = descriptor->vnode;
FUNCTION(("dir_close(descriptor = %p)\n",descriptor));
if (FS_CALL(vnode,fs_close_dir))
return FS_CALL(vnode,fs_close_dir)(vnode->mount->cookie,vnode->priv_vnode,descriptor->cookie);
return B_OK;
} }
@@ -1287,9 +1297,7 @@ vfs_fsync(int fd, bool kernel)
struct vnode *v; struct vnode *v;
int err; int err;
#if MAKE_NOIZE FUNCTION(("vfs_fsync: entry. fd %d kernel %d\n", fd, kernel));
dprintf("vfs_fsync: entry. fd %d kernel %d\n", fd, kernel);
#endif
f = get_fd(get_current_io_context(kernel), fd); f = get_fd(get_current_io_context(kernel), fd);
if (!f) if (!f)
@@ -1309,8 +1317,7 @@ file_read(struct file_descriptor *f, void *buffer, off_t pos, size_t *length)
{ {
struct vnode *v = f->vnode; struct vnode *v = f->vnode;
FUNCTION(("vfs_read: fd = %d, buf 0x%x, pos 0x%x 0x%x, len 0x%x, kernel %d\n", fd, buffer, pos, length, kernel)); FUNCTION(("file_read: buf %p, pos %Ld, len 0x%p\n", buffer, pos, length));
return v->mount->fs->calls->fs_read(v->mount->cookie, v->priv_vnode, f->cookie, buffer, pos, length); return v->mount->fs->calls->fs_read(v->mount->cookie, v->priv_vnode, f->cookie, buffer, pos, length);
} }
@@ -1320,20 +1327,19 @@ file_write(struct file_descriptor *f, const void *buffer, off_t pos, size_t *len
{ {
struct vnode *v = f->vnode; struct vnode *v = f->vnode;
FUNCTION(("vfs_write: fd = %d, buf 0x%x, pos 0x%x 0x%x, len 0x%x\n", fd, buffer, pos, length)); FUNCTION(("file_write: buf %p, pos %Ld, len 0x%p\n", buffer, pos, length));
return v->mount->fs->calls->fs_write(v->mount->cookie, v->priv_vnode, f->cookie, buffer, pos, length); return v->mount->fs->calls->fs_write(v->mount->cookie, v->priv_vnode, f->cookie, buffer, pos, length);
} }
static int static off_t
file_seek(struct file_descriptor *descriptor, off_t pos, int seek_type) file_seek(struct file_descriptor *descriptor, off_t pos, int seekType)
{ {
struct vnode *vnode = descriptor->vnode; struct vnode *vnode = descriptor->vnode;
FUNCTION(("file_seek: fd = %d, pos 0x%x 0x%x, seek_type %d, kernel %d\n", fd, pos, seek_type, kernel)); FUNCTION(("file_seek: pos 0x%Ld, seek_type %d\n", pos, seekType));
return FS_CALL(vnode,fs_seek)(vnode->mount->cookie, vnode->priv_vnode, descriptor->cookie, pos, seek_type); return FS_CALL(vnode,fs_seek)(vnode->mount->cookie, vnode->priv_vnode, descriptor->cookie, pos, seekType);
} }
@@ -1370,7 +1376,7 @@ vfs_open_dir(char *path, bool kernel)
int status; int status;
int fd; int fd;
FUNCTION(("vfs_open_dir: entry. path = '%s', omode %d, kernel %d\n", path, omode, kernel)); FUNCTION(("vfs_open_dir: path = '%s', kernel %d\n", path, kernel));
status = path_to_vnode(path, &vnode, kernel); status = path_to_vnode(path, &vnode, kernel);
if (status < 0) if (status < 0)
@@ -1396,7 +1402,6 @@ vfs_open_dir(char *path, bool kernel)
status = ERR_VFS_FD_TABLE_FULL; status = ERR_VFS_FD_TABLE_FULL;
goto err1; goto err1;
} }
return fd; return fd;
err1: err1:
@@ -1505,8 +1510,7 @@ common_read_stat(struct file_descriptor *descriptor, struct stat *stat)
{ {
struct vnode *vnode = descriptor->vnode; struct vnode *vnode = descriptor->vnode;
FUNCTION(("vfs_rstat: path '%s', stat 0x%x\n", path, stat)); FUNCTION(("common_read_stat: stat 0x%p\n", stat));
return FS_CALL(vnode,fs_read_stat)(vnode->mount->cookie, vnode->priv_vnode, stat); return FS_CALL(vnode,fs_read_stat)(vnode->mount->cookie, vnode->priv_vnode, stat);
} }
@@ -1517,7 +1521,7 @@ vfs_write_stat(char *path, struct stat *stat, int stat_mask, bool kernel)
struct vnode *vnode; struct vnode *vnode;
int status; int status;
FUNCTION(("vfs_wstat: path '%s', stat 0x%x, stat_mask %d, kernel %d\n", path, stat, stat_mask, kernel)); FUNCTION(("vfs_write_stat: path '%s', stat 0x%p, stat_mask %d, kernel %d\n", path, stat, stat_mask, kernel));
status = path_to_vnode(path, &vnode, kernel); status = path_to_vnode(path, &vnode, kernel);
if (status < 0) if (status < 0)
@@ -1556,9 +1560,7 @@ vfs_get_vnode_from_path(const char *path, bool kernel, void **vnode)
int err; int err;
char buf[SYS_MAX_PATH_LEN+1]; char buf[SYS_MAX_PATH_LEN+1];
#if MAKE_NOIZE PRINT(("vfs_get_vnode_from_path: entry. path = '%s', kernel %d\n", path, kernel));
dprintf("vfs_get_vnode_from_path: entry. path = '%s', kernel %d\n", path, kernel);
#endif
strncpy(buf, path, SYS_MAX_PATH_LEN); strncpy(buf, path, SYS_MAX_PATH_LEN);
buf[SYS_MAX_PATH_LEN] = 0; buf[SYS_MAX_PATH_LEN] = 0;
@@ -1590,7 +1592,7 @@ vfs_can_page(void *_v)
{ {
struct vnode *vnode = _v; struct vnode *vnode = _v;
FUNCTION(("vfs_canpage: vnode 0x%x\n", vnode)); FUNCTION(("vfs_canpage: vnode 0x%p\n", vnode));
if (FS_CALL(vnode,fs_can_page)) if (FS_CALL(vnode,fs_can_page))
return FS_CALL(vnode,fs_can_page)(vnode->mount->cookie, vnode->priv_vnode); return FS_CALL(vnode,fs_can_page)(vnode->mount->cookie, vnode->priv_vnode);
@@ -1604,7 +1606,7 @@ vfs_read_page(void *_v, iovecs *vecs, off_t pos)
{ {
struct vnode *vnode = _v; struct vnode *vnode = _v;
FUNCTION(("vfs_readpage: vnode 0x%x, vecs 0x%x, pos 0x%x 0x%x\n", vnode, vecs, pos)); FUNCTION(("vfs_readpage: vnode %p, vecs %p, pos %Ld\n", vnode, vecs, pos));
return FS_CALL(vnode,fs_read_page)(vnode->mount->cookie, vnode->priv_vnode, vecs, pos); return FS_CALL(vnode,fs_read_page)(vnode->mount->cookie, vnode->priv_vnode, vecs, pos);
} }
@@ -1615,7 +1617,7 @@ vfs_write_page(void *_v, iovecs *vecs, off_t pos)
{ {
struct vnode *vnode = _v; struct vnode *vnode = _v;
FUNCTION(("vfs_writepage: vnode 0x%x, vecs 0x%x, pos 0x%x 0x%x\n", vnode, vecs, pos)); FUNCTION(("vfs_writepage: vnode %p, vecs %p, pos %Ld\n", vnode, vecs, pos));
return FS_CALL(vnode,fs_write_page)(vnode->mount->cookie, vnode->priv_vnode, vecs, pos); return FS_CALL(vnode,fs_write_page)(vnode->mount->cookie, vnode->priv_vnode, vecs, pos);
} }
@@ -1631,7 +1633,7 @@ vfs_get_cwd(char *buffer, size_t size, bool kernel)
// Get current working directory from io context // Get current working directory from io context
struct vnode *cwd = get_current_io_context(kernel)->cwd; struct vnode *cwd = get_current_io_context(kernel)->cwd;
FUNCTION(("vfs_get_cwd: buf 0x%x, 0x%x\n", buffer, size)); FUNCTION(("vfs_get_cwd: buf %p, size %ld\n", buffer, size));
if (cwd) if (cwd)
// //
@@ -1707,9 +1709,7 @@ vfs_dup(int fd, bool kernel)
struct file_descriptor *f; struct file_descriptor *f;
int rc; int rc;
#if MAKE_NOIZE FUNCTION(("vfs_dup: fd = %d\n", fd));
dprintf("vfs_dup: fd=%d\n", fd);
#endif
// Try to get the fd structure // Try to get the fd structure
f = get_fd(io, fd); f = get_fd(io, fd);
@@ -1736,9 +1736,7 @@ vfs_dup2(int ofd, int nfd, bool kernel)
struct file_descriptor *evicted; struct file_descriptor *evicted;
int rc; int rc;
#if MAKE_NOIZE FUNCTION(("vfs_dup2: ofd = %d, nfd = %d\n", ofd, nfd));
dprintf("vfs_dup2: ofd=%d nfd=%d\n", ofd, nfd);
#endif
// quick check // quick check
if ((ofd < 0) || (nfd < 0)) { if ((ofd < 0) || (nfd < 0)) {
@@ -1919,7 +1917,7 @@ sys_read_stat(const char *path, struct stat *stat)
strncpy(buf, path, SYS_MAX_PATH_LEN); strncpy(buf, path, SYS_MAX_PATH_LEN);
buf[SYS_MAX_PATH_LEN] = 0; buf[SYS_MAX_PATH_LEN] = 0;
FUNCTION(("sys_rstat: path '%s', stat 0x%x,\n", path, stat)); FUNCTION(("sys_read_stat: path '%s', stat %p,\n", path, stat));
status = path_to_vnode(buf, &vnode, true); status = path_to_vnode(buf, &vnode, true);
if (status < 0) if (status < 0)
@@ -1950,9 +1948,7 @@ sys_getcwd(char *buf, size_t size)
char path[SYS_MAX_PATH_LEN]; char path[SYS_MAX_PATH_LEN];
int rc; int rc;
#if MAKE_NOIZE PRINT(("sys_getcwd: buf %p, %ld\n", buf, size));
dprintf("sys_getcwd: buf 0x%x, 0x%x\n", buf, size);
#endif
// Call vfs to get current working directory // Call vfs to get current working directory
rc = vfs_get_cwd(path,SYS_MAX_PATH_LEN-1,true); rc = vfs_get_cwd(path,SYS_MAX_PATH_LEN-1,true);
@@ -1971,9 +1967,7 @@ sys_setcwd(const char* _path)
{ {
char path[SYS_MAX_PATH_LEN]; char path[SYS_MAX_PATH_LEN];
#if MAKE_NOIZE PRINT(("sys_setcwd: path = %s\n", _path));
dprintf("sys_setcwd: path=0x%x\n", _path);
#endif
// Copy new path to kernel space // Copy new path to kernel space
strncpy(path, _path, SYS_MAX_PATH_LEN-1); strncpy(path, _path, SYS_MAX_PATH_LEN-1);
@@ -2259,9 +2253,7 @@ user_getcwd(char *buf, size_t size)
char path[SYS_MAX_PATH_LEN]; char path[SYS_MAX_PATH_LEN];
int rc, rc2; int rc, rc2;
#if MAKE_NOIZE PRINT(("user_getcwd: buf %p, %ld\n", buf, size));
dprintf("user_getcwd: buf 0x%x, 0x%x\n", buf, size);
#endif
// Check if userspace address is inside "shared" kernel space // Check if userspace address is inside "shared" kernel space
if((addr)buf >= KERNEL_BASE && (addr)buf <= KERNEL_TOP) if((addr)buf >= KERNEL_BASE && (addr)buf <= KERNEL_TOP)
@@ -2287,9 +2279,7 @@ user_setcwd(const char* upath)
char path[SYS_MAX_PATH_LEN]; char path[SYS_MAX_PATH_LEN];
int rc; int rc;
#if MAKE_NOIZE PRINT(("user_setcwd: path = %p\n", upath));
dprintf("user_setcwd: path=0x%x\n", upath);
#endif
// Check if userspace address is inside "shared" kernel space // Check if userspace address is inside "shared" kernel space
if((addr)upath >= KERNEL_BASE && (addr)upath <= KERNEL_TOP) if((addr)upath >= KERNEL_BASE && (addr)upath <= KERNEL_TOP)
@@ -2297,9 +2287,9 @@ user_setcwd(const char* upath)
// Copy new path to kernel space // Copy new path to kernel space
rc = user_strncpy(path, upath, SYS_MAX_PATH_LEN-1); rc = user_strncpy(path, upath, SYS_MAX_PATH_LEN-1);
if (rc < 0) { if (rc < 0)
return rc; return rc;
}
path[SYS_MAX_PATH_LEN-1] = 0; path[SYS_MAX_PATH_LEN-1] = 0;
// Call vfs to set new working directory // Call vfs to set new working directory
@@ -2458,8 +2448,6 @@ vfs_test(void)
sys_seek(fd, 0, SEEK_SET); sys_seek(fd, 0, SEEK_SET);
for (;;) { for (;;) {
len = sys_read(fd, buf, -1, sizeof(buf)); len = sys_read(fd, buf, -1, sizeof(buf));
// if(len <= 0)
// panic("readdir returned %Ld\n", (long long)len);
if (len > 0) if (len > 0)
dprintf("readdir returned name = '%s'\n", buf); dprintf("readdir returned name = '%s'\n", buf);
else { else {
@@ -2488,23 +2476,24 @@ vfs_test(void)
#endif #endif
#if 1 #if 1
fd = sys_open("/boot", STREAM_TYPE_DIR, 0); fd = sys_open_dir("/boot");
sys_close(fd); sys_close(fd);
fd = sys_open("/boot", STREAM_TYPE_DIR, 0); fd = sys_open_dir("/boot");
if (fd < 0) if (fd < 0)
panic("unable to open dir /boot\n"); panic("unable to open dir /boot\n");
{ {
char buf[64]; char buf[256];
struct dirent *dirent = (struct dirent *)buf;
ssize_t len; ssize_t len;
sys_seek(fd, 0, SEEK_SET); sys_rewind_dir(fd);
for (;;) { for (;;) {
len = sys_read(fd, buf, -1, sizeof(buf)); len = sys_read_dir(fd, dirent, sizeof(buf), 1);
// if(len < 0) // if(len < 0)
// panic("readdir returned %Ld\n", (long long)len); // panic("readdir returned %Ld\n", (long long)len);
if (len > 0) if (len > 0)
dprintf("sys_read returned name = '%s'\n", buf); dprintf("sys_read returned name = '%s'\n", dirent->d_name);
else { else {
dprintf("sys_read returned %s\n", strerror(len)); dprintf("sys_read returned %s\n", strerror(len));
break; break;
@@ -2513,7 +2502,7 @@ vfs_test(void)
} }
sys_close(fd); sys_close(fd);
fd = sys_open("/boot/kernel", STREAM_TYPE_FILE, 0); fd = sys_open("/boot/kernel", O_RDONLY);
if (fd < 0) if (fd < 0)
panic("unable to open kernel file '/boot/kernel'\n"); panic("unable to open kernel file '/boot/kernel'\n");
{ {
@@ -2529,7 +2518,7 @@ vfs_test(void)
{ {
struct stat stat; struct stat stat;
err = sys_rstat("/boot/kernel", &stat); err = sys_read_stat("/boot/kernel", &stat);
if (err < 0) if (err < 0)
panic("err stating '/boot/kernel'\n"); panic("err stating '/boot/kernel'\n");
dprintf("stat results:\n"); dprintf("stat results:\n");
@@ -2538,7 +2527,6 @@ vfs_test(void)
#endif #endif
dprintf("vfs_test() done\n"); dprintf("vfs_test() done\n");
// panic("foo\n");
return 0; return 0;
} }