2007-07-05 18:48:16 +04:00
|
|
|
/*
|
2010-05-25 01:04:22 +04:00
|
|
|
* Copyright 2004-2010, Haiku Inc. All Rights Reserved.
|
2004-11-12 20:02:55 +03:00
|
|
|
* Distributed under the terms of the MIT License.
|
|
|
|
|
*/
|
2003-01-17 20:52:33 +03:00
|
|
|
#ifndef _FS_INTERFACE_H
|
|
|
|
|
#define _FS_INTERFACE_H
|
|
|
|
|
|
2007-07-05 18:48:16 +04:00
|
|
|
/*! File System Interface Layer Definition */
|
|
|
|
|
|
2004-09-04 21:13:45 +04:00
|
|
|
|
2003-08-02 12:33:05 +04:00
|
|
|
#include <OS.h>
|
2004-10-01 04:28:57 +04:00
|
|
|
#include <Select.h>
|
2004-06-07 21:14:17 +04:00
|
|
|
#include <module.h>
|
2005-05-23 21:15:56 +04:00
|
|
|
#include <disk_device_manager.h>
|
2004-10-01 04:28:57 +04:00
|
|
|
|
|
|
|
|
#include <sys/uio.h>
|
2003-01-17 20:52:33 +03:00
|
|
|
|
2004-09-04 21:13:45 +04:00
|
|
|
|
2003-01-17 20:52:33 +03:00
|
|
|
struct dirent;
|
|
|
|
|
struct stat;
|
|
|
|
|
struct fs_info;
|
2005-03-18 00:04:25 +03:00
|
|
|
struct select_sync;
|
2003-01-17 20:52:33 +03:00
|
|
|
|
2008-07-28 06:07:20 +04:00
|
|
|
typedef struct IORequest io_request;
|
|
|
|
|
|
|
|
|
|
|
2008-03-24 15:04:47 +03:00
|
|
|
/* additional flags passed to write_stat() (see NodeMonitor.h for the others) */
|
2008-03-24 16:39:02 +03:00
|
|
|
// NOTE: Changing the constants here or in NodeMonitor.h will break
|
|
|
|
|
// src/kits/storage/LibBeAdapter.cpp:_kern_write_stat().
|
|
|
|
|
#define B_STAT_SIZE_INSECURE 0x2000
|
|
|
|
|
// TODO: this should be faded out once BFS supports sparse files
|
2003-01-17 20:52:33 +03:00
|
|
|
|
|
|
|
|
/* passed to write_fs_info() */
|
|
|
|
|
#define FS_WRITE_FSINFO_NAME 0x0001
|
|
|
|
|
|
2004-09-04 21:13:45 +04:00
|
|
|
struct file_io_vec {
|
|
|
|
|
off_t offset;
|
|
|
|
|
off_t length;
|
|
|
|
|
};
|
|
|
|
|
|
2004-06-07 21:14:17 +04:00
|
|
|
#define B_CURRENT_FS_API_VERSION "/v1"
|
2003-01-17 20:52:33 +03:00
|
|
|
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
// flags for publish_vnode() and fs_volume_ops::get_vnode()
|
|
|
|
|
#define B_VNODE_PUBLISH_REMOVED 0x01
|
|
|
|
|
#define B_VNODE_DONT_CREATE_SPECIAL_SUB_NODE 0x02
|
|
|
|
|
|
|
|
|
|
|
2003-01-17 20:52:33 +03:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
extern "C" {
|
2008-03-24 15:04:47 +03:00
|
|
|
#endif
|
2003-01-17 20:52:33 +03:00
|
|
|
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
typedef struct fs_volume fs_volume;
|
|
|
|
|
typedef struct fs_volume_ops fs_volume_ops;
|
|
|
|
|
typedef struct fs_vnode fs_vnode;
|
|
|
|
|
typedef struct fs_vnode_ops fs_vnode_ops;
|
2009-02-14 23:30:49 +03:00
|
|
|
typedef struct file_system_module_info file_system_module_info;
|
2004-06-07 21:14:17 +04:00
|
|
|
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
struct fs_volume {
|
2009-02-14 23:30:49 +03:00
|
|
|
dev_t id;
|
|
|
|
|
partition_id partition;
|
|
|
|
|
int32 layer;
|
|
|
|
|
void* private_volume;
|
|
|
|
|
fs_volume_ops* ops;
|
|
|
|
|
fs_volume* sub_volume;
|
|
|
|
|
fs_volume* super_volume;
|
|
|
|
|
file_system_module_info* file_system;
|
|
|
|
|
char* file_system_name;
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct fs_vnode {
|
|
|
|
|
void* private_node;
|
|
|
|
|
fs_vnode_ops* ops;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct fs_volume_ops {
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*unmount)(fs_volume* volume);
|
2003-01-17 20:52:33 +03:00
|
|
|
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*read_fs_info)(fs_volume* volume, struct fs_info* info);
|
|
|
|
|
status_t (*write_fs_info)(fs_volume* volume, const struct fs_info* info,
|
2007-02-25 02:05:18 +03:00
|
|
|
uint32 mask);
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*sync)(fs_volume* volume);
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*get_vnode)(fs_volume* volume, ino_t id, fs_vnode* vnode,
|
|
|
|
|
int* _type, uint32* _flags, bool reenter);
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
|
|
|
|
|
/* index directory & index operations */
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*open_index_dir)(fs_volume* volume, void** _cookie);
|
|
|
|
|
status_t (*close_index_dir)(fs_volume* volume, void* cookie);
|
|
|
|
|
status_t (*free_index_dir_cookie)(fs_volume* volume, void* cookie);
|
|
|
|
|
status_t (*read_index_dir)(fs_volume* volume, void* cookie,
|
|
|
|
|
struct dirent* buffer, size_t bufferSize, uint32* _num);
|
|
|
|
|
status_t (*rewind_index_dir)(fs_volume* volume, void* cookie);
|
|
|
|
|
|
|
|
|
|
status_t (*create_index)(fs_volume* volume, const char* name, uint32 type,
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
uint32 flags);
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*remove_index)(fs_volume* volume, const char* name);
|
|
|
|
|
status_t (*read_index_stat)(fs_volume* volume, const char* name,
|
|
|
|
|
struct stat* stat);
|
2003-01-17 20:52:33 +03:00
|
|
|
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
/* query operations */
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*open_query)(fs_volume* volume, const char* query, uint32 flags,
|
|
|
|
|
port_id port, uint32 token, void** _cookie);
|
|
|
|
|
status_t (*close_query)(fs_volume* volume, void* cookie);
|
|
|
|
|
status_t (*free_query_cookie)(fs_volume* volume, void* cookie);
|
|
|
|
|
status_t (*read_query)(fs_volume* volume, void* cookie,
|
|
|
|
|
struct dirent* buffer, size_t bufferSize, uint32* _num);
|
|
|
|
|
status_t (*rewind_query)(fs_volume* volume, void* cookie);
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
|
|
|
|
|
/* support for FS layers */
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*all_layers_mounted)(fs_volume* volume);
|
|
|
|
|
status_t (*create_sub_vnode)(fs_volume* volume, ino_t id, fs_vnode* vnode);
|
|
|
|
|
status_t (*delete_sub_vnode)(fs_volume* volume, fs_vnode* vnode);
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct fs_vnode_ops {
|
2003-01-17 20:52:33 +03:00
|
|
|
/* vnode operations */
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*lookup)(fs_volume* volume, fs_vnode* dir, const char* name,
|
|
|
|
|
ino_t* _id);
|
|
|
|
|
status_t (*get_vnode_name)(fs_volume* volume, fs_vnode* vnode, char* buffer,
|
2007-02-25 02:05:18 +03:00
|
|
|
size_t bufferSize);
|
2003-01-17 20:52:33 +03:00
|
|
|
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*put_vnode)(fs_volume* volume, fs_vnode* vnode, bool reenter);
|
|
|
|
|
status_t (*remove_vnode)(fs_volume* volume, fs_vnode* vnode, bool reenter);
|
2003-01-17 20:52:33 +03:00
|
|
|
|
|
|
|
|
/* VM file access */
|
2009-04-15 20:14:04 +04:00
|
|
|
bool (*can_page)(fs_volume* volume, fs_vnode* vnode, void* cookie);
|
|
|
|
|
status_t (*read_pages)(fs_volume* volume, fs_vnode* vnode, void* cookie,
|
|
|
|
|
off_t pos, const iovec* vecs, size_t count, size_t* _numBytes);
|
|
|
|
|
status_t (*write_pages)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
void* cookie, off_t pos, const iovec* vecs, size_t count,
|
|
|
|
|
size_t* _numBytes);
|
2004-09-04 21:13:45 +04:00
|
|
|
|
2008-07-28 06:07:20 +04:00
|
|
|
/* asynchronous I/O */
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*io)(fs_volume* volume, fs_vnode* vnode, void* cookie,
|
|
|
|
|
io_request* request);
|
|
|
|
|
status_t (*cancel_io)(fs_volume* volume, fs_vnode* vnode, void* cookie,
|
|
|
|
|
io_request* request);
|
2008-07-28 06:07:20 +04:00
|
|
|
|
2004-09-04 21:13:45 +04:00
|
|
|
/* cache file access */
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*get_file_map)(fs_volume* volume, fs_vnode* vnode, off_t offset,
|
|
|
|
|
size_t size, struct file_io_vec* vecs, size_t* _count);
|
2003-01-17 20:52:33 +03:00
|
|
|
|
|
|
|
|
/* common operations */
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*ioctl)(fs_volume* volume, fs_vnode* vnode, void* cookie,
|
2010-05-25 01:04:22 +04:00
|
|
|
uint32 op, void* buffer, size_t length);
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*set_flags)(fs_volume* volume, fs_vnode* vnode, void* cookie,
|
2007-02-25 02:05:18 +03:00
|
|
|
int flags);
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*select)(fs_volume* volume, fs_vnode* vnode, void* cookie,
|
|
|
|
|
uint8 event, selectsync* sync);
|
|
|
|
|
status_t (*deselect)(fs_volume* volume, fs_vnode* vnode, void* cookie,
|
|
|
|
|
uint8 event, selectsync* sync);
|
|
|
|
|
status_t (*fsync)(fs_volume* volume, fs_vnode* vnode);
|
|
|
|
|
|
|
|
|
|
status_t (*read_symlink)(fs_volume* volume, fs_vnode* link, char* buffer,
|
|
|
|
|
size_t* _bufferSize);
|
|
|
|
|
status_t (*create_symlink)(fs_volume* volume, fs_vnode* dir,
|
|
|
|
|
const char* name, const char* path, int mode);
|
|
|
|
|
|
|
|
|
|
status_t (*link)(fs_volume* volume, fs_vnode* dir, const char* name,
|
|
|
|
|
fs_vnode* vnode);
|
|
|
|
|
status_t (*unlink)(fs_volume* volume, fs_vnode* dir, const char* name);
|
|
|
|
|
status_t (*rename)(fs_volume* volume, fs_vnode* fromDir,
|
|
|
|
|
const char* fromName, fs_vnode* toDir, const char* toName);
|
|
|
|
|
|
|
|
|
|
status_t (*access)(fs_volume* volume, fs_vnode* vnode, int mode);
|
|
|
|
|
status_t (*read_stat)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
struct stat* stat);
|
|
|
|
|
status_t (*write_stat)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
const struct stat* stat, uint32 statMask);
|
2003-01-17 20:52:33 +03:00
|
|
|
|
|
|
|
|
/* file operations */
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*create)(fs_volume* volume, fs_vnode* dir, const char* name,
|
|
|
|
|
int openMode, int perms, void** _cookie,
|
|
|
|
|
ino_t* _newVnodeID);
|
|
|
|
|
status_t (*open)(fs_volume* volume, fs_vnode* vnode, int openMode,
|
|
|
|
|
void** _cookie);
|
|
|
|
|
status_t (*close)(fs_volume* volume, fs_vnode* vnode, void* cookie);
|
|
|
|
|
status_t (*free_cookie)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
void* cookie);
|
|
|
|
|
status_t (*read)(fs_volume* volume, fs_vnode* vnode, void* cookie,
|
|
|
|
|
off_t pos, void* buffer, size_t* length);
|
|
|
|
|
status_t (*write)(fs_volume* volume, fs_vnode* vnode, void* cookie,
|
|
|
|
|
off_t pos, const void* buffer, size_t* length);
|
2003-01-17 20:52:33 +03:00
|
|
|
|
|
|
|
|
/* directory operations */
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*create_dir)(fs_volume* volume, fs_vnode* parent,
|
|
|
|
|
const char* name, int perms);
|
|
|
|
|
status_t (*remove_dir)(fs_volume* volume, fs_vnode* parent,
|
|
|
|
|
const char* name);
|
|
|
|
|
status_t (*open_dir)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
void** _cookie);
|
|
|
|
|
status_t (*close_dir)(fs_volume* volume, fs_vnode* vnode, void* cookie);
|
|
|
|
|
status_t (*free_dir_cookie)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
void* cookie);
|
|
|
|
|
status_t (*read_dir)(fs_volume* volume, fs_vnode* vnode, void* cookie,
|
|
|
|
|
struct dirent* buffer, size_t bufferSize, uint32* _num);
|
|
|
|
|
status_t (*rewind_dir)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
void* cookie);
|
2003-01-17 20:52:33 +03:00
|
|
|
|
|
|
|
|
/* attribute directory operations */
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*open_attr_dir)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
void** _cookie);
|
|
|
|
|
status_t (*close_attr_dir)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
void* cookie);
|
|
|
|
|
status_t (*free_attr_dir_cookie)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
void* cookie);
|
|
|
|
|
status_t (*read_attr_dir)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
void* cookie, struct dirent* buffer, size_t bufferSize,
|
|
|
|
|
uint32* _num);
|
|
|
|
|
status_t (*rewind_attr_dir)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
void* cookie);
|
2003-01-17 20:52:33 +03:00
|
|
|
|
|
|
|
|
/* attribute operations */
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*create_attr)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
const char* name, uint32 type, int openMode,
|
|
|
|
|
void** _cookie);
|
|
|
|
|
status_t (*open_attr)(fs_volume* volume, fs_vnode* vnode, const char* name,
|
|
|
|
|
int openMode, void** _cookie);
|
|
|
|
|
status_t (*close_attr)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
void* cookie);
|
|
|
|
|
status_t (*free_attr_cookie)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
void* cookie);
|
|
|
|
|
status_t (*read_attr)(fs_volume* volume, fs_vnode* vnode, void* cookie,
|
|
|
|
|
off_t pos, void* buffer, size_t* length);
|
|
|
|
|
status_t (*write_attr)(fs_volume* volume, fs_vnode* vnode, void* cookie,
|
|
|
|
|
off_t pos, const void* buffer, size_t* length);
|
|
|
|
|
|
|
|
|
|
status_t (*read_attr_stat)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
void* cookie, struct stat* stat);
|
|
|
|
|
status_t (*write_attr_stat)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
void* cookie, const struct stat* stat, int statMask);
|
|
|
|
|
status_t (*rename_attr)(fs_volume* volume, fs_vnode* fromVnode,
|
|
|
|
|
const char* fromName, fs_vnode* toVnode, const char* toName);
|
|
|
|
|
status_t (*remove_attr)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
const char* name);
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
|
|
|
|
|
/* support for node and FS layers */
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*create_special_node)(fs_volume* volume, fs_vnode* dir,
|
|
|
|
|
const char* name, fs_vnode* subVnode, mode_t mode, uint32 flags,
|
|
|
|
|
fs_vnode* _superVnode, ino_t* _nodeID);
|
|
|
|
|
status_t (*get_super_vnode)(fs_volume* volume, fs_vnode* vnode,
|
|
|
|
|
fs_volume* superVolume, fs_vnode* superVnode);
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
};
|
2003-01-17 20:52:33 +03:00
|
|
|
|
2009-02-14 23:30:49 +03:00
|
|
|
struct file_system_module_info {
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
struct module_info info;
|
2008-05-10 15:44:00 +04:00
|
|
|
const char* short_name;
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
const char* pretty_name;
|
|
|
|
|
uint32 flags; // DDM flags
|
2003-01-17 20:52:33 +03:00
|
|
|
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
/* scanning (the device is write locked) */
|
2009-04-15 20:14:04 +04:00
|
|
|
float (*identify_partition)(int fd, partition_data* partition,
|
|
|
|
|
void** _cookie);
|
|
|
|
|
status_t (*scan_partition)(int fd, partition_data* partition,
|
|
|
|
|
void* cookie);
|
|
|
|
|
void (*free_identify_partition_cookie)(partition_data* partition,
|
|
|
|
|
void* cookie);
|
|
|
|
|
void (*free_partition_content_cookie)(partition_data* partition);
|
2003-01-17 20:52:33 +03:00
|
|
|
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
/* general operations */
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*mount)(fs_volume* volume, const char* device, uint32 flags,
|
|
|
|
|
const char* args, ino_t* _rootVnodeID);
|
2005-05-23 21:15:56 +04:00
|
|
|
|
|
|
|
|
/* capability querying (the device is read locked) */
|
2007-08-23 01:21:30 +04:00
|
|
|
uint32 (*get_supported_operations)(partition_data* partition, uint32 mask);
|
2005-05-23 21:15:56 +04:00
|
|
|
|
2009-04-15 20:14:04 +04:00
|
|
|
bool (*validate_resize)(partition_data* partition, off_t* size);
|
|
|
|
|
bool (*validate_move)(partition_data* partition, off_t* start);
|
|
|
|
|
bool (*validate_set_content_name)(partition_data* partition,
|
|
|
|
|
char* name);
|
|
|
|
|
bool (*validate_set_content_parameters)(partition_data* partition,
|
|
|
|
|
const char* parameters);
|
|
|
|
|
bool (*validate_initialize)(partition_data* partition, char* name,
|
|
|
|
|
const char* parameters);
|
2005-05-23 21:15:56 +04:00
|
|
|
|
|
|
|
|
/* shadow partition modification (device is write locked) */
|
2009-04-15 20:14:04 +04:00
|
|
|
status_t (*shadow_changed)(partition_data* partition,
|
|
|
|
|
partition_data* child, uint32 operation);
|
2005-05-23 21:15:56 +04:00
|
|
|
|
|
|
|
|
/* writing (the device is NOT locked) */
|
|
|
|
|
status_t (*defragment)(int fd, partition_id partition,
|
|
|
|
|
disk_job_id job);
|
|
|
|
|
status_t (*repair)(int fd, partition_id partition, bool checkOnly,
|
|
|
|
|
disk_job_id job);
|
|
|
|
|
status_t (*resize)(int fd, partition_id partition, off_t size,
|
|
|
|
|
disk_job_id job);
|
|
|
|
|
status_t (*move)(int fd, partition_id partition, off_t offset,
|
|
|
|
|
disk_job_id job);
|
|
|
|
|
status_t (*set_content_name)(int fd, partition_id partition,
|
2009-04-15 20:14:04 +04:00
|
|
|
const char* name, disk_job_id job);
|
2005-05-23 21:15:56 +04:00
|
|
|
status_t (*set_content_parameters)(int fd, partition_id partition,
|
2009-04-15 20:14:04 +04:00
|
|
|
const char* parameters, disk_job_id job);
|
|
|
|
|
status_t (*initialize)(int fd, partition_id partition, const char* name,
|
|
|
|
|
const char* parameters, off_t partitionSize, disk_job_id job);
|
2009-02-14 23:30:49 +03:00
|
|
|
};
|
2003-01-17 20:52:33 +03:00
|
|
|
|
|
|
|
|
|
2003-01-18 17:05:58 +03:00
|
|
|
/* file system add-ons only prototypes */
|
2008-07-28 06:07:20 +04:00
|
|
|
|
|
|
|
|
// callbacks for do_iterative_fd_io()
|
2009-04-15 20:14:04 +04:00
|
|
|
typedef status_t (*iterative_io_get_vecs)(void* cookie, io_request* request,
|
|
|
|
|
off_t offset, size_t size, struct file_io_vec* vecs,
|
|
|
|
|
size_t* _count);
|
2008-07-28 06:07:20 +04:00
|
|
|
typedef status_t (*iterative_io_finished)(void* cookie, io_request* request,
|
2008-07-31 03:34:10 +04:00
|
|
|
status_t status, bool partialTransfer, size_t bytesTransferred);
|
2008-07-28 06:07:20 +04:00
|
|
|
|
2009-04-15 20:14:04 +04:00
|
|
|
extern status_t new_vnode(fs_volume* volume, ino_t vnodeID, void* privateNode,
|
|
|
|
|
fs_vnode_ops* ops);
|
|
|
|
|
extern status_t publish_vnode(fs_volume* volume, ino_t vnodeID,
|
|
|
|
|
void* privateNode, fs_vnode_ops* ops, int type,
|
* Reorganized the FS interface a little:
- Moved most file_system_module_info hooks into separate structures.
Those that operate on mounted volumes to fs_volume_ops, those
operating on a vnode to fs_vnode_ops.
- Got rid of the fs_volume, fs_cookie, fs_vnode typedefs. We use void*
again.
- Instead of a void* volume and node cookie hooks are passed a
fs_volume and fs_vnode structure pointer, which contain the cookie
and an ops pointer (fs_volume a few more things).
- The VFS {new,publish,get,...}_vnode() functions take a fs_volume*
instead of the volume ID. So does vfs_get_fs_node_from_path().
- Added type and flags arguments to publish_vnode() and the
get_vnode() hook and removed the type argument from lookup() hook.
Added vnode::type using formerly unused bits to store the node type.
Simplified a few things in the VFS due to the now always available
node type.
- Added fs_volume_ops::{create,delete}_sub_vnode() and
fs_vnode_ops::get_super_vnode() hooks. They are used to support file
system layers, e.g. allowing to extend an FS not supporting BeOS
attribute with attribute support. Needs some more work in the VFS.
- Added fs_vnode_ops::create_special_node() hook for creating special
nodes (e.g. FIFOs).
* Adjusted the built-in file systems and BFS according to the interface
changes. Removed all other FSs from the image for the time being.
We'll see whether further API changes are necessary before porting
them.
* Adjusted the bfs_shell accordingly.
* Implemented create_special_node() in rootfs to support special nodes.
* Added support for FIFOs:
- Added syscall _kern_create_fifo() (used by mkfifo()), which creates
a special node (type S_IFIFO) in the respective file system.
- When a special node is published the VFS creates a respective sub
node. Currently only FIFOs are supported.
- Added a little support for FIFO subnodes by using functionality from
the pipefs.
- Added mkfifo to the image. It can create FIFOs in the rootfs, but
the FIFOs aren't really usable ATM, since they still work like
pipes, i.e. readers and writers need to have them open at the same
time.
* Some smaller changes in the VFS:
- Made the *_CALL macros nicer to use (vargs).
- Refactored FS entry lookup into new function lookup_dir_entry().
- create_vnode() no longer just calls the FS create() hook. First it
looks up the entry and uses open_vnode(), if it already exists. This
is necessary for two reasons: 1) The FS might not support create()
while still allowing to open() entries. 2) When the FS has other
layers on to of it (or the respective node) it might not be
responsible for opening the node.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24816 a95241bf-73f2-0310-859d-f6bbb57e9c96
2008-04-06 03:05:16 +04:00
|
|
|
uint32 flags);
|
2009-04-15 20:14:04 +04:00
|
|
|
extern status_t get_vnode(fs_volume* volume, ino_t vnodeID,
|
|
|
|
|
void** _privateNode);
|
|
|
|
|
extern status_t put_vnode(fs_volume* volume, ino_t vnodeID);
|
|
|
|
|
extern status_t acquire_vnode(fs_volume* volume, ino_t vnodeID);
|
|
|
|
|
extern status_t remove_vnode(fs_volume* volume, ino_t vnodeID);
|
|
|
|
|
extern status_t unremove_vnode(fs_volume* volume, ino_t vnodeID);
|
|
|
|
|
extern status_t get_vnode_removed(fs_volume* volume, ino_t vnodeID,
|
|
|
|
|
bool* _removed);
|
|
|
|
|
extern fs_volume* volume_for_vnode(fs_vnode* vnode);
|
|
|
|
|
|
|
|
|
|
extern status_t read_pages(int fd, off_t pos, const struct iovec* vecs,
|
|
|
|
|
size_t count, size_t* _numBytes);
|
|
|
|
|
extern status_t write_pages(int fd, off_t pos, const struct iovec* vecs,
|
|
|
|
|
size_t count, size_t* _numBytes);
|
* Extracted file_map API out of the file cache - it's now an optional service
that can be used by file systems.
* Changed the way the file cache works: instead of reading/writing to the
underlying device directly, it can now be used for any data source, ie.
also network file systems.
* As a result, the former pages_io() moved to the VFS layer, and can now be
called by a file system via {read|write}_file_io_vec_pages() (naming
suggestions are always welcomed :-)). It now gets an FD, and uses that to
communicate with the device (via its fs_{read|write}_pages() hooks).
* The file_cache_{read|write}() functions must now be called without holding
an I/O relevant file system lock. That allows the file cache to prepare the
pages without colliding with the page writer, IOW the "mayBlock" flag can
go into the attic again (yay!).
* This also results in a much better performance when the system does I/O and
is low on memory, as the page writer can now finally write back some pages,
and that even without maxing out the CPU :)
* The API changes put slightly more burden on the fs_{read|write}_pages()
hooks, but in combination with the file_map it's still pretty straight
forward. It just will have to dispatch the call to the underlying device
directly, usually it will just call its fs_{read|write}_pages() hooks
via the above mentioned calls.
* Ported BFS and FAT to the new API, the latter has not been tested, though.
* Also ported the API changes to the fs_shell. I also completely removed its
file cache level page handling - the downside is that device access is no
longer cached (ie. depends on the host OS now), the upside is that the code
is greatly simplified.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22886 a95241bf-73f2-0310-859d-f6bbb57e9c96
2007-11-11 00:19:52 +03:00
|
|
|
extern status_t read_file_io_vec_pages(int fd,
|
2009-04-15 20:14:04 +04:00
|
|
|
const struct file_io_vec* fileVecs, size_t fileVecCount,
|
|
|
|
|
const struct iovec* vecs, size_t vecCount,
|
|
|
|
|
uint32* _vecIndex, size_t* _vecOffset, size_t* _bytes);
|
* Extracted file_map API out of the file cache - it's now an optional service
that can be used by file systems.
* Changed the way the file cache works: instead of reading/writing to the
underlying device directly, it can now be used for any data source, ie.
also network file systems.
* As a result, the former pages_io() moved to the VFS layer, and can now be
called by a file system via {read|write}_file_io_vec_pages() (naming
suggestions are always welcomed :-)). It now gets an FD, and uses that to
communicate with the device (via its fs_{read|write}_pages() hooks).
* The file_cache_{read|write}() functions must now be called without holding
an I/O relevant file system lock. That allows the file cache to prepare the
pages without colliding with the page writer, IOW the "mayBlock" flag can
go into the attic again (yay!).
* This also results in a much better performance when the system does I/O and
is low on memory, as the page writer can now finally write back some pages,
and that even without maxing out the CPU :)
* The API changes put slightly more burden on the fs_{read|write}_pages()
hooks, but in combination with the file_map it's still pretty straight
forward. It just will have to dispatch the call to the underlying device
directly, usually it will just call its fs_{read|write}_pages() hooks
via the above mentioned calls.
* Ported BFS and FAT to the new API, the latter has not been tested, though.
* Also ported the API changes to the fs_shell. I also completely removed its
file cache level page handling - the downside is that device access is no
longer cached (ie. depends on the host OS now), the upside is that the code
is greatly simplified.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@22886 a95241bf-73f2-0310-859d-f6bbb57e9c96
2007-11-11 00:19:52 +03:00
|
|
|
extern status_t write_file_io_vec_pages(int fd,
|
2009-04-15 20:14:04 +04:00
|
|
|
const struct file_io_vec* fileVecs, size_t fileVecCount,
|
|
|
|
|
const struct iovec* vecs, size_t vecCount,
|
|
|
|
|
uint32* _vecIndex, size_t* _vecOffset, size_t* _bytes);
|
|
|
|
|
extern status_t do_fd_io(int fd, io_request* request);
|
|
|
|
|
extern status_t do_iterative_fd_io(int fd, io_request* request,
|
2008-07-28 06:07:20 +04:00
|
|
|
iterative_io_get_vecs getVecs,
|
2009-04-15 20:14:04 +04:00
|
|
|
iterative_io_finished finished, void* cookie);
|
2004-06-07 18:23:48 +04:00
|
|
|
|
2007-07-05 18:48:16 +04:00
|
|
|
extern status_t notify_entry_created(dev_t device, ino_t directory,
|
2009-04-15 20:14:04 +04:00
|
|
|
const char* name, ino_t node);
|
2007-07-05 18:48:16 +04:00
|
|
|
extern status_t notify_entry_removed(dev_t device, ino_t directory,
|
2009-04-15 20:14:04 +04:00
|
|
|
const char* name, ino_t node);
|
2007-07-05 18:48:16 +04:00
|
|
|
extern status_t notify_entry_moved(dev_t device, ino_t fromDirectory,
|
2009-04-15 20:14:04 +04:00
|
|
|
const char* fromName, ino_t toDirectory,
|
|
|
|
|
const char* toName, ino_t node);
|
2007-07-05 18:48:16 +04:00
|
|
|
extern status_t notify_stat_changed(dev_t device, ino_t node,
|
2005-02-02 18:17:54 +03:00
|
|
|
uint32 statFields);
|
2007-07-05 18:48:16 +04:00
|
|
|
extern status_t notify_attribute_changed(dev_t device, ino_t node,
|
2009-04-15 20:14:04 +04:00
|
|
|
const char* attribute, int32 cause);
|
2005-01-30 04:53:37 +03:00
|
|
|
|
|
|
|
|
extern status_t notify_query_entry_created(port_id port, int32 token,
|
2009-04-15 20:14:04 +04:00
|
|
|
dev_t device, ino_t directory, const char* name,
|
2007-07-05 18:48:16 +04:00
|
|
|
ino_t node);
|
2005-01-30 04:53:37 +03:00
|
|
|
extern status_t notify_query_entry_removed(port_id port, int32 token,
|
2009-04-15 20:14:04 +04:00
|
|
|
dev_t device, ino_t directory, const char* name,
|
2007-07-05 18:48:16 +04:00
|
|
|
ino_t node);
|
2005-01-30 04:53:37 +03:00
|
|
|
|
2003-06-27 06:24:02 +04:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
2003-01-17 20:52:33 +03:00
|
|
|
#endif /* _FS_INTERFACE_H */
|