Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Removed the fs_ prefix from the fs_calls.

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/trunk/current@1160 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler 2002-09-24 16:17:22 +00:00
parent ec152b4fff
commit 570b6eaeeb
2 changed files with 152 additions and 150 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

134
headers/os/kernel/fs_interface.h
View File

@ -40,98 +40,98 @@ extern "C" {
struct fs_calls {
/* general operations */
status_t (*fs_mount)(fs_id id, const char *device, void *args, fs_volume *_fs, vnode_id *_rootVnodeID);
status_t (*fs_unmount)(fs_volume fs);
status_t (*mount)(fs_id id, const char *device, void *args, fs_volume *_fs, vnode_id *_rootVnodeID);
status_t (*unmount)(fs_volume fs);
status_t (*fs_read_fs_info)(fs_volume fs, struct fs_info *info);
status_t (*fs_write_fs_info)(fs_volume fs, const struct fs_info *info, int mask);
status_t (*fs_sync)(fs_volume fs);
status_t (*read_fs_info)(fs_volume fs, struct fs_info *info);
status_t (*write_fs_info)(fs_volume fs, const struct fs_info *info, int mask);
status_t (*sync)(fs_volume fs);
/* vnode operations */
status_t (*fs_lookup)(fs_volume fs, fs_vnode dir, const char *name, vnode_id *_id, int *_type);
status_t (*fs_get_vnode_name)(fs_volume fs, fs_vnode vnode, char *buffer, size_t bufferSize);
status_t (*lookup)(fs_volume fs, fs_vnode dir, const char *name, vnode_id *_id, int *_type);
status_t (*get_vnode_name)(fs_volume fs, fs_vnode vnode, char *buffer, size_t bufferSize);
status_t (*fs_get_vnode)(fs_volume fs, vnode_id id, fs_vnode *_vnode, bool reenter);
status_t (*fs_put_vnode)(fs_volume fs, fs_vnode vnode, bool reenter);
status_t (*fs_remove_vnode)(fs_volume fs, fs_vnode vnode, bool reenter);
status_t (*get_vnode)(fs_volume fs, vnode_id id, fs_vnode *_vnode, bool reenter);
status_t (*put_vnode)(fs_volume fs, fs_vnode vnode, bool reenter);
status_t (*remove_vnode)(fs_volume fs, fs_vnode vnode, bool reenter);
/* VM file access */
status_t (*fs_can_page)(fs_volume fs, fs_vnode v);
ssize_t (*fs_read_page)(fs_volume fs, fs_vnode v, iovecs *vecs, off_t pos);
ssize_t (*fs_write_page)(fs_volume fs, fs_vnode v, iovecs *vecs, off_t pos);
status_t (*can_page)(fs_volume fs, fs_vnode v);
ssize_t (*read_page)(fs_volume fs, fs_vnode v, iovecs *vecs, off_t pos);
ssize_t (*write_page)(fs_volume fs, fs_vnode v, iovecs *vecs, off_t pos);
/* common operations */
status_t (*fs_ioctl)(fs_volume fs, fs_vnode v, fs_cookie cookie, ulong op, void *buffer, size_t length);
status_t (*fs_fsync)(fs_volume fs, fs_vnode v);
status_t (*ioctl)(fs_volume fs, fs_vnode v, fs_cookie cookie, ulong op, void *buffer, size_t length);
status_t (*fsync)(fs_volume fs, fs_vnode v);
status_t (*fs_read_link)(fs_volume fs, fs_vnode link, char *buffer, size_t bufferSize);
status_t (*fs_write_link)(fs_volume fs, fs_vnode link, char *toPath);
status_t (*fs_create_symlink)(fs_volume fs, fs_vnode dir, const char *name, const char *path, int mode);
status_t (*read_link)(fs_volume fs, fs_vnode link, char *buffer, size_t bufferSize);
status_t (*write_link)(fs_volume fs, fs_vnode link, char *toPath);
status_t (*create_symlink)(fs_volume fs, fs_vnode dir, const char *name, const char *path, int mode);
status_t (*fs_link)(fs_volume fs, fs_vnode dir, const char *name, fs_vnode vnode);
status_t (*fs_unlink)(fs_volume fs, fs_vnode dir, const char *name);
status_t (*fs_rename)(fs_volume fs, fs_vnode olddir, const char *oldname, fs_vnode newdir, const char *newname);
status_t (*link)(fs_volume fs, fs_vnode dir, const char *name, fs_vnode vnode);
status_t (*unlink)(fs_volume fs, fs_vnode dir, const char *name);
status_t (*rename)(fs_volume fs, fs_vnode olddir, const char *oldname, fs_vnode newdir, const char *newname);
status_t (*fs_access)(fs_volume fs, fs_vnode vnode, int mode);
status_t (*fs_read_stat)(fs_volume fs, fs_vnode vnode, struct stat *stat);
status_t (*fs_write_stat)(fs_volume fs, fs_vnode vnode, const struct stat *stat, int statMask);
status_t (*access)(fs_volume fs, fs_vnode vnode, int mode);
status_t (*read_stat)(fs_volume fs, fs_vnode vnode, struct stat *stat);
status_t (*write_stat)(fs_volume fs, fs_vnode vnode, const struct stat *stat, int statMask);
/* file operations */
status_t (*fs_create)(fs_volume fs, fs_vnode dir, const char *name, int omode, int perms, fs_cookie *_cookie, vnode_id *_newVnodeID);
status_t (*fs_open)(fs_volume fs, fs_vnode v, int oflags, fs_cookie *_cookie);
status_t (*fs_close)(fs_volume fs, fs_vnode v, fs_cookie cookie);
status_t (*fs_free_cookie)(fs_volume fs, fs_vnode v, fs_cookie cookie);
ssize_t (*fs_read)(fs_volume fs, fs_vnode v, fs_cookie cookie, off_t pos, void *buffer, size_t *length);
ssize_t (*fs_write)(fs_volume fs, fs_vnode v, fs_cookie cookie, off_t pos, const void *buffer, size_t *length);
off_t (*fs_seek)(fs_volume fs, fs_vnode v, fs_cookie cookie, off_t pos, int seekType);
status_t (*create)(fs_volume fs, fs_vnode dir, const char *name, int omode, int perms, fs_cookie *_cookie, vnode_id *_newVnodeID);
status_t (*open)(fs_volume fs, fs_vnode v, int oflags, fs_cookie *_cookie);
status_t (*close)(fs_volume fs, fs_vnode v, fs_cookie cookie);
status_t (*free_cookie)(fs_volume fs, fs_vnode v, fs_cookie cookie);
ssize_t (*read)(fs_volume fs, fs_vnode v, fs_cookie cookie, off_t pos, void *buffer, size_t *length);
ssize_t (*write)(fs_volume fs, fs_vnode v, fs_cookie cookie, off_t pos, const void *buffer, size_t *length);
off_t (*seek)(fs_volume fs, fs_vnode v, fs_cookie cookie, off_t pos, int seekType);
/* directory operations */
status_t (*fs_create_dir)(fs_volume fs, fs_vnode parent, const char *name, int perms, vnode_id *_newVnodeID);
status_t (*fs_remove_dir)(fs_volume fs, fs_vnode parent, const char *name);
status_t (*fs_open_dir)(fs_volume fs, fs_vnode vnode, fs_cookie *_cookie);
status_t (*fs_close_dir)(fs_volume fs, fs_vnode vnode, fs_cookie cookie);
status_t (*fs_free_dir_cookie)(fs_volume fs, fs_vnode vnode, fs_cookie cookie);
status_t (*fs_read_dir)(fs_volume fs, fs_vnode vnode, fs_cookie cookie, struct dirent *buffer, size_t bufferSize, uint32 *_num);
status_t (*fs_rewind_dir)(fs_volume fs, fs_vnode vnode, fs_cookie cookie);
status_t (*create_dir)(fs_volume fs, fs_vnode parent, const char *name, int perms, vnode_id *_newVnodeID);
status_t (*remove_dir)(fs_volume fs, fs_vnode parent, const char *name);
status_t (*open_dir)(fs_volume fs, fs_vnode vnode, fs_cookie *_cookie);
status_t (*close_dir)(fs_volume fs, fs_vnode vnode, fs_cookie cookie);
status_t (*free_dir_cookie)(fs_volume fs, fs_vnode vnode, fs_cookie cookie);
status_t (*read_dir)(fs_volume fs, fs_vnode vnode, fs_cookie cookie, struct dirent *buffer, size_t bufferSize, uint32 *_num);
status_t (*rewind_dir)(fs_volume fs, fs_vnode vnode, fs_cookie cookie);
/* attribute directory operations */
status_t (*fs_open_attr_dir)(fs_volume fs, fs_vnode vnode, fs_cookie *_cookie);
status_t (*fs_close_attr_dir)(fs_volume fs, fs_vnode vnode, fs_cookie cookie);
status_t (*fs_free_attr_dir_cookie)(fs_volume fs, fs_vnode vnode, fs_cookie cookie);
status_t (*fs_read_attr_dir)(fs_volume fs, fs_vnode vnode, fs_cookie cookie, struct dirent *buffer, size_t bufferSize, uint32 *_num);
status_t (*fs_rewind_attr_dir)(fs_volume fs, fs_vnode vnode, fs_cookie cookie);
status_t (*open_attr_dir)(fs_volume fs, fs_vnode vnode, fs_cookie *_cookie);
status_t (*close_attr_dir)(fs_volume fs, fs_vnode vnode, fs_cookie cookie);
status_t (*free_attr_dir_cookie)(fs_volume fs, fs_vnode vnode, fs_cookie cookie);
status_t (*read_attr_dir)(fs_volume fs, fs_vnode vnode, fs_cookie cookie, struct dirent *buffer, size_t bufferSize, uint32 *_num);
status_t (*rewind_attr_dir)(fs_volume fs, fs_vnode vnode, fs_cookie cookie);
/* attribute operations */
status_t (*fs_create_attr)(fs_volume fs, fs_vnode file, const char *name);
status_t (*fs_open_attr)(fs_volume fs, fs_vnode file, const char *name, int oflags, fs_cookie *_cookie, vnode_id *_attrID);
status_t (*fs_close_attr)(fs_volume fs, fs_vnode file, fs_cookie cookie);
status_t (*fs_free_attr_cookie)(fs_volume fs, fs_vnode file, fs_cookie cookie);
ssize_t (*fs_read_attr)(fs_volume fs, fs_vnode file, fs_cookie cookie, void *buffer, off_t pos, size_t *len);
ssize_t (*fs_write_attr)(fs_volume fs, fs_vnode file, fs_cookie cookie, const void *buffer, off_t pos, size_t *len);
status_t (*fs_seek_attr)(fs_volume fs, fs_vnode file, fs_cookie cookie, off_t pos, int seekType);
status_t (*create_attr)(fs_volume fs, fs_vnode file, const char *name);
status_t (*open_attr)(fs_volume fs, fs_vnode file, const char *name, int oflags, fs_cookie *_cookie, vnode_id *_attrID);
status_t (*close_attr)(fs_volume fs, fs_vnode file, fs_cookie cookie);
status_t (*free_attr_cookie)(fs_volume fs, fs_vnode file, fs_cookie cookie);
ssize_t (*read_attr)(fs_volume fs, fs_vnode file, fs_cookie cookie, void *buffer, off_t pos, size_t *len);
ssize_t (*write_attr)(fs_volume fs, fs_vnode file, fs_cookie cookie, const void *buffer, off_t pos, size_t *len);
status_t (*seek_attr)(fs_volume fs, fs_vnode file, fs_cookie cookie, off_t pos, int seekType);
status_t (*fs_rename_attr)(fs_volume fs, fs_vnode file, const char *oldName, const char *newName);
status_t (*fs_remove_attr)(fs_volume fs, fs_vnode file, const char *name);
status_t (*fs_read_attr_stat)(fs_volume fs, fs_vnode file, fs_cookie cookie, struct stat *stat);
status_t (*fs_write_attr_stat)(fs_volume fs, fs_vnode file, fs_cookie cookie, struct stat *stat, int statMask);
status_t (*rename_attr)(fs_volume fs, fs_vnode file, const char *oldName, const char *newName);
status_t (*remove_attr)(fs_volume fs, fs_vnode file, const char *name);
status_t (*read_attr_stat)(fs_volume fs, fs_vnode file, fs_cookie cookie, struct stat *stat);
status_t (*write_attr_stat)(fs_volume fs, fs_vnode file, fs_cookie cookie, struct stat *stat, int statMask);
/* index directory & index operations */
status_t (*fs_open_index_dir)(fs_volume fs, fs_vnode v, fs_cookie *cookie, int oflags);
status_t (*fs_close_index_dir)(fs_volume fs, fs_vnode v, fs_cookie cookie);
status_t (*fs_free_index_dir_cookie)(fs_volume fs, fs_vnode v, fs_cookie cookie);
status_t (*fs_read_index_dir)(fs_volume fs, fs_vnode v, fs_cookie cookie, struct dirent *buffer, size_t bufferSize, uint32 *_num);
status_t (*fs_rewind_index_dir)(fs_volume fs, fs_vnode v, fs_cookie cookie);
status_t (*open_index_dir)(fs_volume fs, fs_vnode v, fs_cookie *cookie, int oflags);
status_t (*close_index_dir)(fs_volume fs, fs_vnode v, fs_cookie cookie);
status_t (*free_index_dir_cookie)(fs_volume fs, fs_vnode v, fs_cookie cookie);
status_t (*read_index_dir)(fs_volume fs, fs_vnode v, fs_cookie cookie, struct dirent *buffer, size_t bufferSize, uint32 *_num);
status_t (*rewind_index_dir)(fs_volume fs, fs_vnode v, fs_cookie cookie);
status_t (*fs_create_index)(fs_volume fs, const char *name, uint32 type, int flags);
status_t (*fs_remove_index)(fs_volume fs, const char *name);
status_t (*fs_read_index_stat)(fs_volume fs, const char *name, struct stat *stat);
status_t (*create_index)(fs_volume fs, const char *name, uint32 type, int flags);
status_t (*remove_index)(fs_volume fs, const char *name);
status_t (*read_index_stat)(fs_volume fs, const char *name, struct stat *stat);
/* query operations */
status_t (*fs_open_query)(fs_volume fs, fs_vnode v, fs_cookie *cookie, int oflags);
status_t (*fs_close_query)(fs_volume fs, fs_vnode v, fs_cookie cookie);
status_t (*fs_free_query_cookie)(fs_volume fs, fs_vnode v, fs_cookie cookie);
status_t (*fs_read_query)(fs_volume fs, fs_vnode v, fs_cookie cookie, struct dirent *buffer, size_t bufferSize, uint32 *_num);
status_t (*fs_rewind_query)(fs_volume fs, fs_vnode v, fs_cookie cookie);
status_t (*open_query)(fs_volume fs, fs_vnode v, fs_cookie *cookie, int oflags);
status_t (*close_query)(fs_volume fs, fs_vnode v, fs_cookie cookie);
status_t (*free_query_cookie)(fs_volume fs, fs_vnode v, fs_cookie cookie);
status_t (*read_query)(fs_volume fs, fs_vnode v, fs_cookie cookie, struct dirent *buffer, size_t bufferSize, uint32 *_num);
status_t (*rewind_query)(fs_volume fs, fs_vnode v, fs_cookie cookie);
};
#ifdef __cplusplus

168
src/kernel/core/fs/vfs.c
View File

@ -327,9 +327,9 @@ dec_vnode_ref_count(struct vnode *vnode, bool reenter)
vnode->cache = NULL;
if (vnode->delete_me)
FS_CALL(vnode,fs_remove_vnode)(vnode->mount->cookie, vnode->private_node, reenter);
FS_CALL(vnode, remove_vnode)(vnode->mount->cookie, vnode->private_node, reenter);
else
FS_CALL(vnode,fs_put_vnode)(vnode->mount->cookie, vnode->private_node, reenter);
FS_CALL(vnode, put_vnode)(vnode->mount->cookie, vnode->private_node, reenter);
remove_vnode_from_mount_list(vnode, vnode->mount);
@ -414,7 +414,7 @@ get_vnode(fs_id fsID, vnode_id vnodeID, struct vnode **_vnode, int reenter)
add_vnode_to_mount_list(vnode, vnode->mount);
err = FS_CALL(vnode,fs_get_vnode)(vnode->mount->cookie, vnodeID, &vnode->private_node, reenter);
err = FS_CALL(vnode, get_vnode)(vnode->mount->cookie, vnodeID, &vnode->private_node, reenter);
if (err < 0 && vnode->private_node == NULL) {
remove_vnode_from_mount_list(vnode, vnode->mount);
if (vnode->private_node == NULL)
@ -476,7 +476,7 @@ file_free_fd(struct file_descriptor *descriptor)
struct vnode *vnode = descriptor->vnode;
if (vnode != NULL) {
FS_CALL(vnode,fs_free_cookie)(vnode->mount->cookie, vnode->private_node, descriptor->cookie);
FS_CALL(vnode, free_cookie)(vnode->mount->cookie, vnode->private_node, descriptor->cookie);
dec_vnode_ref_count(vnode, false);
}
}
@ -488,8 +488,8 @@ dir_free_fd(struct file_descriptor *descriptor)
struct vnode *vnode = descriptor->vnode;
if (vnode != NULL) {
//FS_CALL(vnode,fs_close_dir)(vnode->mount->cookie, vnode->private_node, descriptor->cookie);
FS_CALL(vnode,fs_free_dir_cookie)(vnode->mount->cookie, vnode->private_node, descriptor->cookie);
//FS_CALL(vnode, close_dir)(vnode->mount->cookie, vnode->private_node, descriptor->cookie);
FS_CALL(vnode, free_dir_cookie)(vnode->mount->cookie, vnode->private_node, descriptor->cookie);
dec_vnode_ref_count(vnode, false);
}
}
@ -541,7 +541,7 @@ entry_ref_to_vnode(fs_id fsID,vnode_id directoryID,const char *name,struct vnode
if (status < 0)
return status;
status = FS_CALL(directory,fs_lookup)(directory->mount->cookie,
status = FS_CALL(directory, lookup)(directory->mount->cookie,
directory->private_node, name, &id, &type);
put_vnode(directory);
@ -607,7 +607,7 @@ vnode_path_to_vnode(struct vnode *vnode, char *path, bool traverseLeafLink, stru
}
// tell the filesystem to get the vnode of this path component
status = FS_CALL(vnode,fs_lookup)(vnode->mount->cookie, vnode->private_node, path, &vnodeID, &type);
status = FS_CALL(vnode, lookup)(vnode->mount->cookie, vnode->private_node, path, &vnodeID, &type);
if (status < 0) {
put_vnode(vnode);
return status;
@ -643,7 +643,7 @@ vnode_path_to_vnode(struct vnode *vnode, char *path, bool traverseLeafLink, stru
goto resolve_link_error;
}
status = FS_CALL(nextVnode,fs_read_link)(nextVnode->mount->cookie, nextVnode->private_node, buffer, SYS_MAX_PATH_LEN);
status = FS_CALL(nextVnode, read_link)(nextVnode->mount->cookie, nextVnode->private_node, buffer, SYS_MAX_PATH_LEN);
if (status < B_OK) {
kfree(buffer);
@ -800,7 +800,7 @@ dir_vnode_to_path(struct vnode *vnode, char *buffer, size_t bufferSize)
int type;
// lookup the parent vnode
status = FS_CALL(vnode,fs_lookup)(vnode->mount->cookie,vnode->private_node,"..",&parentID,&type);
status = FS_CALL(vnode, lookup)(vnode->mount->cookie,vnode->private_node,"..",&parentID,&type);
if (status < B_OK)
goto out;
@ -816,8 +816,8 @@ dir_vnode_to_path(struct vnode *vnode, char *buffer, size_t bufferSize)
// Does the file system support getting the name of a vnode?
// If so, get it here...
if (status == B_OK && FS_CALL(vnode,fs_get_vnode_name))
status = FS_CALL(vnode,fs_get_vnode_name)(vnode->mount->cookie,vnode->private_node,name,B_FILE_NAME_LENGTH);
if (status == B_OK && FS_CALL(vnode, get_vnode_name))
status = FS_CALL(vnode, get_vnode_name)(vnode->mount->cookie,vnode->private_node,name,B_FILE_NAME_LENGTH);
// ... if not, find it out later (by iterating through
// the parent directory, searching for the id)
@ -845,17 +845,18 @@ dir_vnode_to_path(struct vnode *vnode, char *buffer, size_t bufferSize)
break;
}
if (!FS_CALL(vnode, fs_get_vnode_name)) {
if (!FS_CALL(vnode, get_vnode_name)) {
// If we don't got the vnode's name yet, we have to search for it
// in the parent directory now
fs_cookie cookie;
status = FS_CALL(vnode, fs_open_dir)(vnode->mount->cookie, vnode->private_node, &cookie);
status = FS_CALL(vnode, open_dir)(vnode->mount->cookie, vnode->private_node, &cookie);
if (status >= B_OK) {
struct dirent *dirent = (struct dirent *)nameBuffer;
while (true) {
uint32 num = 1;
status = FS_CALL(vnode,fs_read_dir)(vnode->mount->cookie,vnode->private_node,cookie,dirent,sizeof(nameBuffer),&num);
status = FS_CALL(vnode, read_dir)(vnode->mount->cookie, vnode->private_node,
cookie, dirent, sizeof(nameBuffer), &num);
if (status < B_OK)
break;
@ -863,7 +864,7 @@ dir_vnode_to_path(struct vnode *vnode, char *buffer, size_t bufferSize)
// found correct entry!
break;
}
FS_CALL(vnode,fs_close_dir)(vnode->mount->cookie,vnode->private_node,cookie);
FS_CALL(vnode, close_dir)(vnode->mount->cookie, vnode->private_node, cookie);
}
if (status < B_OK)
@ -1099,8 +1100,8 @@ vfs_can_page(void *_v)
FUNCTION(("vfs_canpage: vnode 0x%p\n", vnode));
if (FS_CALL(vnode,fs_can_page))
return FS_CALL(vnode,fs_can_page)(vnode->mount->cookie, vnode->private_node);
if (FS_CALL(vnode, can_page))
return FS_CALL(vnode, can_page)(vnode->mount->cookie, vnode->private_node);
return 0;
}
@ -1113,7 +1114,7 @@ vfs_read_page(void *_v, iovecs *vecs, off_t 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->private_node, vecs, pos);
return FS_CALL(vnode, read_page)(vnode->mount->cookie, vnode->private_node, vecs, pos);
}
@ -1124,7 +1125,7 @@ vfs_write_page(void *_v, iovecs *vecs, off_t 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->private_node, vecs, pos);
return FS_CALL(vnode, write_page)(vnode->mount->cookie, vnode->private_node, vecs, pos);
}
@ -1609,10 +1610,10 @@ create_vnode(struct vnode *directory, const char *name, int omode, int perms, bo
vnode_id newID;
int status;
if (FS_CALL(directory,fs_create) == NULL)
if (FS_CALL(directory, create) == NULL)
return EROFS;
status = FS_CALL(directory,fs_create)(directory->mount->cookie, directory->private_node, name, omode, perms, &cookie, &newID);
status = FS_CALL(directory, create)(directory->mount->cookie, directory->private_node, name, omode, perms, &cookie, &newID);
if (status < B_OK)
return status;
@ -1628,11 +1629,11 @@ create_vnode(struct vnode *directory, const char *name, int omode, int perms, bo
if ((status = new_file_fd(vnode,cookie,omode,kernel)) >= 0)
return status;
FS_CALL(vnode,fs_close)(vnode->mount->cookie, vnode->private_node, cookie);
FS_CALL(vnode,fs_free_cookie)(vnode->mount->cookie, vnode->private_node, cookie);
FS_CALL(vnode, close)(vnode->mount->cookie, vnode->private_node, cookie);
FS_CALL(vnode, free_cookie)(vnode->mount->cookie, vnode->private_node, cookie);
put_vnode(vnode);
FS_CALL(directory,fs_unlink)(directory->mount->cookie, directory->private_node, name);
FS_CALL(directory, unlink)(directory->mount->cookie, directory->private_node, name);
return status;
}
@ -1648,14 +1649,14 @@ open_vnode(struct vnode *vnode, int omode, bool kernel)
fs_cookie cookie;
int status;
status = FS_CALL(vnode,fs_open)(vnode->mount->cookie, vnode->private_node, omode, &cookie);
status = FS_CALL(vnode, open)(vnode->mount->cookie, vnode->private_node, omode, &cookie);
if (status < 0)
return status;
status = new_file_fd(vnode, cookie, omode, kernel);
if (status < 0) {
FS_CALL(vnode,fs_close)(vnode->mount->cookie, vnode->private_node, cookie);
FS_CALL(vnode,fs_free_cookie)(vnode->mount->cookie, vnode->private_node, cookie);
FS_CALL(vnode, close)(vnode->mount->cookie, vnode->private_node, cookie);
FS_CALL(vnode, free_cookie)(vnode->mount->cookie, vnode->private_node, cookie);
}
return status;
}
@ -1672,7 +1673,7 @@ open_dir_vnode(struct vnode *vnode, bool kernel)
fs_cookie cookie;
int status, fd;
status = FS_CALL(vnode,fs_open_dir)(vnode->mount->cookie, vnode->private_node, &cookie);
status = FS_CALL(vnode, open_dir)(vnode->mount->cookie, vnode->private_node, &cookie);
if (status < 0)
return status;
@ -1696,8 +1697,8 @@ err1:
kfree(descriptor);
err:
FS_CALL(vnode,fs_close_dir)(vnode->mount->cookie, vnode->private_node, cookie);
FS_CALL(vnode,fs_free_dir_cookie)(vnode->mount->cookie, vnode->private_node, cookie);
FS_CALL(vnode, close_dir)(vnode->mount->cookie, vnode->private_node, cookie);
FS_CALL(vnode, free_dir_cookie)(vnode->mount->cookie, vnode->private_node, cookie);
return status;
}
@ -1797,8 +1798,8 @@ file_close(struct file_descriptor *descriptor)
FUNCTION(("file_close(descriptor = %p)\n",descriptor));
if (FS_CALL(vnode,fs_close))
return FS_CALL(vnode,fs_close)(vnode->mount->cookie,vnode->private_node,descriptor->cookie);
if (FS_CALL(vnode, close))
return FS_CALL(vnode, close)(vnode->mount->cookie,vnode->private_node,descriptor->cookie);
return B_OK;
}
@ -1810,7 +1811,7 @@ file_read(struct file_descriptor *descriptor, off_t pos, void *buffer, size_t *l
struct vnode *vnode = descriptor->vnode;
FUNCTION(("file_read: buf %p, pos %Ld, len %p = %ld\n", buffer, pos, length, *length));
return FS_CALL(vnode,fs_read)(vnode->mount->cookie, vnode->private_node, descriptor->cookie, pos, buffer, length);
return FS_CALL(vnode, read)(vnode->mount->cookie, vnode->private_node, descriptor->cookie, pos, buffer, length);
}
@ -1820,7 +1821,7 @@ file_write(struct file_descriptor *descriptor, off_t pos, const void *buffer, si
struct vnode *vnode = descriptor->vnode;
FUNCTION(("file_write: buf %p, pos %Ld, len %p\n", buffer, pos, length));
return FS_CALL(vnode,fs_write)(vnode->mount->cookie, vnode->private_node, descriptor->cookie, pos, buffer, length);
return FS_CALL(vnode, write)(vnode->mount->cookie, vnode->private_node, descriptor->cookie, pos, buffer, length);
}
@ -1830,7 +1831,7 @@ file_seek(struct file_descriptor *descriptor, off_t pos, int seekType)
struct vnode *vnode = descriptor->vnode;
FUNCTION(("file_seek: pos 0x%Ld, seek_type %d\n", pos, seekType));
return FS_CALL(vnode,fs_seek)(vnode->mount->cookie, vnode->private_node, descriptor->cookie, pos, seekType);
return FS_CALL(vnode, seek)(vnode->mount->cookie, vnode->private_node, descriptor->cookie, pos, seekType);
}
@ -1847,8 +1848,8 @@ dir_create_entry_ref(fs_id fsID, vnode_id parentID, const char *name, int perms,
if (status < B_OK)
return status;
if (FS_CALL(vnode, fs_create_dir))
status = FS_CALL(vnode, fs_create_dir)(vnode->mount->cookie, vnode->private_node, name, perms, &newID);
if (FS_CALL(vnode, create_dir))
status = FS_CALL(vnode, create_dir)(vnode->mount->cookie, vnode->private_node, name, perms, &newID);
else
status = EROFS;
@ -1871,8 +1872,8 @@ dir_create(char *path, int perms, bool kernel)
if (status < 0)
return status;
if (FS_CALL(vnode,fs_create_dir))
status = FS_CALL(vnode,fs_create_dir)(vnode->mount->cookie, vnode->private_node, filename, perms, &newID);
if (FS_CALL(vnode, create_dir))
status = FS_CALL(vnode, create_dir)(vnode->mount->cookie, vnode->private_node, filename, perms, &newID);
else
status = EROFS;
@ -1948,8 +1949,8 @@ dir_read(struct file_descriptor *descriptor, struct dirent *buffer, size_t buffe
{
struct vnode *vnode = descriptor->vnode;
if (FS_CALL(vnode,fs_read_dir))
return FS_CALL(vnode,fs_read_dir)(vnode->mount->cookie,vnode->private_node,descriptor->cookie,buffer,bufferSize,_count);
if (FS_CALL(vnode, read_dir))
return FS_CALL(vnode, read_dir)(vnode->mount->cookie,vnode->private_node,descriptor->cookie,buffer,bufferSize,_count);
return EOPNOTSUPP;
}
@ -1960,8 +1961,8 @@ dir_rewind(struct file_descriptor *descriptor)
{
struct vnode *vnode = descriptor->vnode;
if (FS_CALL(vnode,fs_rewind_dir))
return FS_CALL(vnode,fs_rewind_dir)(vnode->mount->cookie,vnode->private_node,descriptor->cookie);
if (FS_CALL(vnode, rewind_dir))
return FS_CALL(vnode, rewind_dir)(vnode->mount->cookie,vnode->private_node,descriptor->cookie);
return EOPNOTSUPP;
}
@ -1974,8 +1975,8 @@ dir_close(struct file_descriptor *descriptor)
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->private_node,descriptor->cookie);
if (FS_CALL(vnode, close_dir))
return FS_CALL(vnode, close_dir)(vnode->mount->cookie,vnode->private_node,descriptor->cookie);
return B_OK;
}
@ -1992,8 +1993,8 @@ dir_remove(char *path, bool kernel)
if (status < B_OK)
return status;
if (FS_CALL(directory, fs_remove_dir))
status = FS_CALL(directory, fs_remove_dir)(directory->mount->cookie, directory->private_node, name);
if (FS_CALL(directory, remove_dir))
status = FS_CALL(directory, remove_dir)(directory->mount->cookie, directory->private_node, name);
else
status = EROFS;
@ -2008,7 +2009,7 @@ common_read_stat(struct file_descriptor *descriptor, struct stat *stat)
struct vnode *vnode = descriptor->vnode;
FUNCTION(("common_read_stat: stat 0x%p\n", stat));
return FS_CALL(vnode,fs_read_stat)(vnode->mount->cookie, vnode->private_node, stat);
return FS_CALL(vnode, read_stat)(vnode->mount->cookie, vnode->private_node, stat);
}
@ -2017,8 +2018,8 @@ common_ioctl(struct file_descriptor *descriptor, ulong op, void *buffer, size_t
{
struct vnode *vnode = descriptor->vnode;
if (FS_CALL(vnode,fs_ioctl))
return FS_CALL(vnode,fs_ioctl)(vnode->mount->cookie,vnode->private_node,descriptor->cookie,op,buffer,length);
if (FS_CALL(vnode, ioctl))
return FS_CALL(vnode, ioctl)(vnode->mount->cookie,vnode->private_node,descriptor->cookie,op,buffer,length);
return EOPNOTSUPP;
}
@ -2037,8 +2038,8 @@ common_sync(int fd, bool kernel)
if (descriptor == NULL)
return ERR_INVALID_HANDLE;
if (FS_CALL(vnode,fs_fsync) != NULL)
status = FS_CALL(vnode,fs_fsync)(vnode->mount->cookie, vnode->private_node);
if (FS_CALL(vnode, fsync) != NULL)
status = FS_CALL(vnode, fsync)(vnode->mount->cookie, vnode->private_node);
else
status = EOPNOTSUPP;
@ -2057,8 +2058,8 @@ common_read_link(char *path, char *buffer, size_t bufferSize, bool kernel)
if (status < B_OK)
return status;
if (FS_CALL(vnode,fs_read_link) != NULL)
status = FS_CALL(vnode,fs_read_link)(vnode->mount->cookie, vnode->private_node, buffer, bufferSize);
if (FS_CALL(vnode, read_link) != NULL)
status = FS_CALL(vnode, read_link)(vnode->mount->cookie, vnode->private_node, buffer, bufferSize);
else
status = B_BAD_VALUE;
@ -2078,8 +2079,8 @@ common_write_link(char *path, char *toPath, bool kernel)
if (status < B_OK)
return status;
if (FS_CALL(vnode,fs_write_link) != NULL)
status = FS_CALL(vnode,fs_write_link)(vnode->mount->cookie, vnode->private_node, toPath);
if (FS_CALL(vnode, write_link) != NULL)
status = FS_CALL(vnode, write_link)(vnode->mount->cookie, vnode->private_node, toPath);
else
status = EOPNOTSUPP;
@ -2103,8 +2104,8 @@ common_create_symlink(char *path, const char *toPath, int mode, bool kernel)
if (status < B_OK)
return status;
if (FS_CALL(vnode,fs_create_symlink) != NULL)
status = FS_CALL(vnode,fs_create_symlink)(vnode->mount->cookie, vnode->private_node, name, toPath, mode);
if (FS_CALL(vnode, create_symlink) != NULL)
status = FS_CALL(vnode, create_symlink)(vnode->mount->cookie, vnode->private_node, name, toPath, mode);
else
status = EROFS;
@ -2137,8 +2138,8 @@ common_create_link(char *path, char *toPath, bool kernel)
goto err1;
}
if (FS_CALL(vnode, fs_link) != NULL)
status = FS_CALL(vnode,fs_link)(directory->mount->cookie, directory->private_node, name, vnode->private_node);
if (FS_CALL(vnode, link) != NULL)
status = FS_CALL(vnode, link)(directory->mount->cookie, directory->private_node, name, vnode->private_node);
else
status = EROFS;
@ -2164,8 +2165,8 @@ common_unlink(char *path, bool kernel)
if (status < 0)
return status;
if (FS_CALL(vnode,fs_unlink) != NULL)
status = FS_CALL(vnode,fs_unlink)(vnode->mount->cookie, vnode->private_node, filename);
if (FS_CALL(vnode, unlink) != NULL)
status = FS_CALL(vnode, unlink)(vnode->mount->cookie, vnode->private_node, filename);
else
status = EROFS;
@ -2185,8 +2186,8 @@ common_access(char *path, int mode, bool kernel)
if (status < B_OK)
return status;
if (FS_CALL(vnode,fs_access) != NULL)
status = FS_CALL(vnode,fs_access)(vnode->mount->cookie, vnode->private_node, mode);
if (FS_CALL(vnode, access) != NULL)
status = FS_CALL(vnode, access)(vnode->mount->cookie, vnode->private_node, mode);
else
status = EOPNOTSUPP;
@ -2219,8 +2220,8 @@ common_rename(char *path, char *newPath, bool kernel)
goto err2;
}
if (FS_CALL(vnode1,fs_rename) != NULL)
status = FS_CALL(vnode1,fs_rename)(vnode1->mount->cookie, vnode1->private_node, filename1, vnode2->private_node, filename2);
if (FS_CALL(vnode1, rename) != NULL)
status = FS_CALL(vnode1, rename)(vnode1->mount->cookie, vnode1->private_node, filename1, vnode2->private_node, filename2);
else
status = EROFS;
@ -2245,8 +2246,8 @@ common_write_stat(int fd, char *path, bool traverseLeafLink, const struct stat *
if (status < 0)
return status;
if (FS_CALL(vnode,fs_write_stat))
status = FS_CALL(vnode,fs_write_stat)(vnode->mount->cookie, vnode->private_node, stat, statMask);
if (FS_CALL(vnode, write_stat))
status = FS_CALL(vnode, write_stat)(vnode->mount->cookie, vnode->private_node, stat, statMask);
else
status = EROFS;
@ -2303,7 +2304,7 @@ fs_mount(char *path, const char *device, const char *fs_name, void *args, bool k
goto err3;
}
err = mount->fs->calls->fs_mount(mount->id, device, NULL, &mount->cookie, &root_id);
err = mount->fs->calls->mount(mount->id, device, NULL, &mount->cookie, &root_id);
if (err < 0) {
err = ERR_VFS_GENERAL;
goto err3;
@ -2322,7 +2323,8 @@ fs_mount(char *path, const char *device, const char *fs_name, void *args, bool k
// XXX insert check to make sure covered_vnode is a DIR, or maybe it's okay for it not to be
if ((covered_vnode != root_vnode) && (covered_vnode->mount->root_vnode == covered_vnode)){
if (covered_vnode != root_vnode
&& covered_vnode->mount->root_vnode == covered_vnode) {
err = ERR_VFS_ALREADY_MOUNTPOINT;
goto err2;
}
@ -2330,7 +2332,7 @@ fs_mount(char *path, const char *device, const char *fs_name, void *args, bool k
mount->covers_vnode = covered_vnode;
// mount it
err = mount->fs->calls->fs_mount(mount->id, device, NULL, &mount->cookie, &root_id);
err = mount->fs->calls->mount(mount->id, device, NULL, &mount->cookie, &root_id);
if (err < 0)
goto err4;
}
@ -2358,7 +2360,7 @@ fs_mount(char *path, const char *device, const char *fs_name, void *args, bool k
return 0;
err5:
mount->fs->calls->fs_unmount(mount->cookie);
mount->fs->calls->unmount(mount->cookie);
err4:
if (mount->covers_vnode)
dec_vnode_ref_count(mount->covers_vnode, false);
@ -2447,7 +2449,7 @@ fs_unmount(char *path, bool kernel)
mutex_unlock(&gMountOpMutex);
mount->fs->calls->fs_unmount(mount->cookie);
mount->fs->calls->unmount(mount->cookie);
kfree(mount->mount_point);
kfree(mount);
@ -2474,7 +2476,7 @@ fs_sync(void)
hash_open(mounts_table, &iter);
while ((mount = hash_next(mounts_table, &iter))) {
mount->fs->calls->fs_sync(mount->cookie);
mount->fs->calls->sync(mount->cookie);
}
hash_close(mounts_table, &iter, false);
@ -2499,8 +2501,8 @@ fs_read_info(dev_t device, struct fs_info *info)
goto error;
}
if (mount->fs->calls->fs_read_fs_info)
status = mount->fs->calls->fs_read_fs_info(mount->cookie, info);
if (mount->fs->calls->read_fs_info)
status = mount->fs->calls->read_fs_info(mount->cookie, info);
else
status = EOPNOTSUPP;
@ -2528,8 +2530,8 @@ fs_write_info(dev_t device, const struct fs_info *info, int mask)
goto error;
}
if (mount->fs->calls->fs_write_fs_info)
status = mount->fs->calls->fs_write_fs_info(mount->cookie, info, mask);
if (mount->fs->calls->write_fs_info)
status = mount->fs->calls->write_fs_info(mount->cookie, info, mask);
else
status = EROFS;
@ -2576,7 +2578,7 @@ set_cwd(int fd, char *path, bool kernel)
if (rc < 0)
return rc;
rc = FS_CALL(vnode,fs_read_stat)(vnode->mount->cookie, vnode->private_node, &stat);
rc = FS_CALL(vnode, read_stat)(vnode->mount->cookie, vnode->private_node, &stat);
if (rc < 0)
goto err;
@ -2840,7 +2842,7 @@ sys_read_stat(const char *path, bool traverseLeafLink, struct stat *stat)
if (status < 0)
return status;
status = FS_CALL(vnode,fs_read_stat)(vnode->mount->cookie, vnode->private_node, stat);
status = FS_CALL(vnode, read_stat)(vnode->mount->cookie, vnode->private_node, stat);
put_vnode(vnode);
return status;
@ -3323,8 +3325,8 @@ user_read_stat(const char *userPath, bool traverseLink, struct stat *userStat)
if (rc < 0)
return rc;
if (FS_CALL(vnode,fs_read_stat))
rc = FS_CALL(vnode,fs_read_stat)(vnode->mount->cookie, vnode->private_node, &stat);
if (FS_CALL(vnode, read_stat))
rc = FS_CALL(vnode, read_stat)(vnode->mount->cookie, vnode->private_node, &stat);
put_vnode(vnode);