ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2025-02-20 17:52:52 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Vfs: File_system server backed by VFS library

Browse Source 
Test available at libc_vfs_fs.

Fixes #1648
This commit is contained in:
Emery Hemingway 2015-09-04 16:06:03 +02:00 committed by Christian Helmuth
parent 1c6164a0c5
commit b6c558dce9
7 changed files with 1444 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
repos/libports/run/libc_vfs_fs.run Normal file
View File

@ -0,0 +1,76 @@
#
# \brief Test for using the vfs server
# \author Emery Hemingway
# \date 2015-08-17
#
#
# Build
#
build { core init server/vfs test/libc_vfs }
create_boot_directory
#
# Generate config
#
install_config {
<config>
<parent-provides>
<service name="ROM"/>
<service name="RAM"/>
<service name="CAP"/>
<service name="PD"/>
<service name="RM"/>
<service name="CPU"/>
<service name="LOG"/>
<service name="SIGNAL"/>
</parent-provides>
<default-route>
<any-service> <parent/> <any-child/> </any-service>
</default-route>
<start name="vfs">
<resource name="RAM" quantum="4M"/>
<provides> <service name="File_system"/> </provides>
<config>
<vfs> <ram quota="1M"/> </vfs>
<policy label="" root="/" writeable="yes" />
</config>
</start>
<start name="test-libc_vfs">
<resource name="RAM" quantum="2M"/>
<config>
<iterations value="1"/>
<libc stdout="/dev/log" cwd="/tmp" >
<vfs>
<dir name="tmp" >
<fs/>
</dir>
<dir name="dev"> <log/> </dir>
</vfs>
</libc>
</config>
</start>
</config>
}
#
# Boot modules
#
build_boot_image {
core init vfs
ld.lib.so libc.lib.so
test-libc_vfs
}
#
# Execute test case
#
append qemu_args " -m 128 -nographic "
run_genode_until {.*child "test-libc_vfs" exited with exit value 0.*} 60
# vi: set ft=tcl :

110
repos/os/src/server/vfs/assert.h Normal file
View File

@ -0,0 +1,110 @@
/*
* \brief VFS result checks
* \author Emery Hemingway
* \date 2015-08-19
*/
/*
* Copyright (C) 2015 Genode Labs GmbH
*
* This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2.
*/
#ifndef _VFS__ASSERT_H_
#define _VFS__ASSERT_H_
/* Genode includes */
#include <vfs/directory_service.h>
#include <file_system_session/file_system_session.h>
namespace File_system {
using namespace Vfs;
static inline void assert_mkdir(Directory_service::Mkdir_result r)
{
typedef Directory_service::Mkdir_result Result;
switch (r) {
case Result::MKDIR_ERR_NAME_TOO_LONG: throw Name_too_long();
case Result::MKDIR_ERR_NO_ENTRY: throw Lookup_failed();
case Result::MKDIR_ERR_NO_SPACE: throw No_space();
case Result::MKDIR_ERR_NO_PERM: throw Permission_denied();
case Result::MKDIR_ERR_EXISTS: throw Node_already_exists();
case Result::MKDIR_OK: break;
}
}
static inline void assert_open(Directory_service::Open_result r)
{
typedef Directory_service::Open_result Result;
switch (r) {
case Result::OPEN_ERR_NAME_TOO_LONG: throw Invalid_name();
case Result::OPEN_ERR_UNACCESSIBLE: throw Lookup_failed();
case Result::OPEN_ERR_NO_SPACE: throw No_space();
case Result::OPEN_ERR_NO_PERM: throw Permission_denied();
case Result::OPEN_ERR_EXISTS: throw Node_already_exists();
case Result::OPEN_OK: break;
}
}
static inline void assert_symlink(Directory_service::Symlink_result r)
{
typedef Directory_service::Symlink_result Result;
switch (r) {
case Result::SYMLINK_ERR_NAME_TOO_LONG: throw Invalid_name();
case Result::SYMLINK_ERR_NO_ENTRY: throw Lookup_failed();
case Result::SYMLINK_ERR_NO_SPACE: throw No_space();
case Result::SYMLINK_ERR_NO_PERM: throw Permission_denied();
case Result::SYMLINK_ERR_EXISTS: throw Node_already_exists();
case Result::SYMLINK_OK: break;
}
}
static inline void assert_truncate(File_io_service::Ftruncate_result r)
{
typedef File_io_service::Ftruncate_result Result;
switch (r) {
case Result::FTRUNCATE_ERR_INTERRUPT: throw Invalid_handle();
case Result::FTRUNCATE_ERR_NO_SPACE: throw No_space();
case Result::FTRUNCATE_ERR_NO_PERM: throw Permission_denied();
case Result::FTRUNCATE_OK: break;
}
}
static inline void assert_unlink(Directory_service::Unlink_result r)
{
typedef Directory_service::Unlink_result Result;
switch (r) {
case Result::UNLINK_ERR_NO_ENTRY: throw Lookup_failed();
case Result::UNLINK_ERR_NO_PERM: throw Permission_denied();
case Result::UNLINK_OK: break;
}
}
static inline void assert_stat(Directory_service::Stat_result r)
{
typedef Directory_service::Stat_result Result;
switch (r) {
case Result::STAT_ERR_NO_ENTRY: throw Lookup_failed();
case Result::STAT_OK: break;
}
}
static inline void assert_rename(Directory_service::Rename_result r)
{
typedef Directory_service::Rename_result Result;
switch (r) {
case Result::RENAME_ERR_NO_ENTRY: throw Lookup_failed();
case Result::RENAME_ERR_CROSS_FS: throw Permission_denied();
case Result::RENAME_ERR_NO_PERM: throw Permission_denied();
case Result::RENAME_OK: break;
}
}
}
#endif

550
repos/os/src/server/vfs/main.cc Normal file
View File

@ -0,0 +1,550 @@
/*
* \brief VFS File_system server
* \author Emery Hemingway
* \date 2015-08-16
*/
/*
* Copyright (C) 2015 Genode Labs GmbH
*
* This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2.
*/
/* Genode includes */
#include <file_system_session/rpc_object.h>
#include <root/component.h>
#include <file_system/node.h>
#include <vfs/dir_file_system.h>
#include <os/server.h>
#include <os/session_policy.h>
#include <vfs/file_system_factory.h>
#include <os/config.h>
/* Local includes */
#include "assert.h"
#include "node_cache.h"
#include "node_handle_registry.h"
namespace File_system {
using namespace Genode;
using namespace Vfs;
class Session_component;
class Root;
struct Main;
typedef Genode::Path<MAX_PATH_LEN> Subpath;
Vfs::File_system *root()
{
static Vfs::Dir_file_system _root(config()->xml_node().sub_node("vfs"),
Vfs::global_file_system_factory());
return &_root;
}
};
class File_system::Session_component : public Session_rpc_object
{
private:
Node_handle_registry _handle_registry;
Subpath const _root_path;
Signal_rpc_member<Session_component> _process_packet_dispatcher;
bool _writable;
/******************************
** Packet-stream processing **
******************************/
/**
* Perform packet operation
*/
void _process_packet_op(Packet_descriptor &packet)
{
void * const content = tx_sink()->packet_content(packet);
size_t const length = packet.length();
seek_off_t const offset = packet.position();
if ((!(content && length)) || (packet.length() > packet.size())) {
packet.succeeded(false);
return;
}
/* resulting length */
size_t res_length = 0;
switch (packet.operation()) {
case Packet_descriptor::READ: {
Node *node = _handle_registry.lookup_read(packet.handle());
if (!node) return;
Node_lock_guard guard(node);
res_length = node->read((char *)content, length, offset);
break;
}
case Packet_descriptor::WRITE: {
Node *node = _handle_registry.lookup_write(packet.handle());
if (!node) return;
Node_lock_guard guard(node);
res_length = node->write((char const *)content, length, offset);
break;
}
}
if (res_length) {
packet.length(res_length);
packet.succeeded(true);
}
}
void _process_packet()
{
Packet_descriptor packet = tx_sink()->get_packet();
/* assume failure by default */
packet.succeeded(false);
_process_packet_op(packet);
/*
* The 'acknowledge_packet' function cannot block because we
* checked for 'ready_to_ack' in '_process_packets'.
*/
tx_sink()->acknowledge_packet(packet);
}
/**
* Called by signal dispatcher, executed in the context of the main
* thread (not serialized with the RPC functions)
*/
void _process_packets(unsigned)
{
while (tx_sink()->packet_avail()) {
/*
* Make sure that the '_process_packet' function does not
* block.
*
* If the acknowledgement queue is full, we defer packet
* processing until the client processed pending
* acknowledgements and thereby emitted a ready-to-ack
* signal. Otherwise, the call of 'acknowledge_packet()'
* in '_process_packet' would infinitely block the context
* of the main thread. The main thread is however needed
* for receiving any subsequent 'ready-to-ack' signals.
*/
if (!tx_sink()->ready_to_ack())
return;
_process_packet();
}
}
/**
* Check if string represents a valid path (must start with '/')
*/
static void _assert_valid_path(char const *path) {
if (!path || path[0] != '/') throw Lookup_failed(); }
/**
* Check if string represents a valid name (must not contain '/')
*/
static void _assert_valid_name(char const *name) {
for (char const *p = name; *p; ++p)
if (*p == '/')
throw Invalid_name(); }
public:
/**
* Constructor
* \param ep thead entrypoint for session
* \param cache node cache
* \param tx_buf_size shared transmission buffer size
* \param root_path path root of the session
* \param writable whether the session can modify files
*/
Session_component(Server::Entrypoint &ep,
Node_cache &cache,
size_t tx_buf_size,
Subpath const &root_path,
bool writable)
:
Session_rpc_object(env()->ram_session()->alloc(tx_buf_size), ep.rpc_ep()),
_handle_registry(cache),
_root_path(root_path.base()),
_process_packet_dispatcher(ep, *this, &Session_component::_process_packets),
_writable(writable)
{
/*
* Register '_process_packets' dispatch function as signal
* handler for packet-avail and ready-to-ack signals.
*/
_tx.sigh_packet_avail(_process_packet_dispatcher);
_tx.sigh_ready_to_ack(_process_packet_dispatcher);
}
/**
* Destructor
*/
~Session_component()
{
Dataspace_capability ds = tx_sink()->dataspace();
env()->ram_session()->free(static_cap_cast<Ram_dataspace>(ds));
}
/***************************
** File_system interface **
***************************/
Dir_handle dir(Path const &path, bool create) override
{
if ((!_writable) && create)
throw Permission_denied();
char const *path_str = path.string();
_assert_valid_path(path_str);
/* re-root the path */
Subpath dir_path(path_str+1, _root_path.base());
path_str = dir_path.base();
return _handle_registry.directory(path_str, create);
}
File_handle file(Dir_handle dir_handle, Name const &name,
Mode fs_mode, bool create) override
{
if ((!_writable) &&
(create || (fs_mode != STAT_ONLY && fs_mode != READ_ONLY)))
throw Permission_denied();
char const *name_str = name.string();
_assert_valid_name(name_str);
Directory *dir = _handle_registry.lookup_and_lock(dir_handle);
Node_lock_guard dir_guard(dir);
/* re-root the path */
Subpath subpath(name_str, dir->path());
char *path_str = subpath.base();
File_handle handle = _handle_registry.file(path_str, fs_mode, create);
if (create)
dir->mark_as_updated();
return handle;
}
Symlink_handle symlink(Dir_handle dir_handle, Name const &name, bool create) override
{
if (create && !_writable) throw Permission_denied();
char const *name_str = name.string();
_assert_valid_name(name_str);
Directory *dir = _handle_registry.lookup_and_lock(dir_handle);
Node_lock_guard dir_guard(dir);
/* re-root the path */
Subpath subpath(name_str, dir->path());
char *path_str = subpath.base();
Symlink_handle handle = _handle_registry.symlink(
path_str, (_writable ? READ_WRITE : READ_ONLY), create);
if (create)
dir->mark_as_updated();
return handle;
}
Node_handle node(Path const &path) override
{
char const *path_str = path.string();
_assert_valid_path(path_str);
/* re-root the path */
Subpath sub_path(path_str+1, _root_path.base());
path_str = sub_path.base();
return _handle_registry.node(path_str);
}
void close(Node_handle handle) { _handle_registry.free(handle); }
Status status(Node_handle node_handle)
{
Directory_service::Stat vfs_stat;
File_system::Status fs_stat;
Node *node;
try { node = _handle_registry.lookup_and_lock(node_handle); }
catch (Invalid_handle) { return fs_stat; }
Node_lock_guard guard(node);
char const *path_str = node->path();
if (root()->stat(path_str, vfs_stat) != Directory_service::STAT_OK)
return fs_stat;
fs_stat.inode = vfs_stat.inode;
switch (vfs_stat.mode & (
Directory_service::STAT_MODE_DIRECTORY |
Directory_service::STAT_MODE_SYMLINK |
File_system::Status::MODE_FILE)) {
case Directory_service::STAT_MODE_DIRECTORY:
fs_stat.mode = File_system::Status::MODE_DIRECTORY;
fs_stat.size = root()->num_dirent(path_str) * sizeof(Directory_entry);
return fs_stat;
case Directory_service::STAT_MODE_SYMLINK:
fs_stat.mode = File_system::Status::MODE_SYMLINK;
break;
default: /* Directory_service::STAT_MODE_FILE */
fs_stat.mode = File_system::Status::MODE_FILE;
break;
}
fs_stat.size = vfs_stat.size;
return fs_stat;
}
/**
* Set information about an open file or directory
*/
void control(Node_handle, Control) { }
/**
* Delete file or directory
*/
void unlink(Dir_handle dir_handle, Name const &name)
{
if (!_writable) throw Permission_denied();
char const *str = name.string();
_assert_valid_name(str);
Directory *dir = _handle_registry.lookup_and_lock(dir_handle);
Node_lock_guard guard(dir);
Subpath path(str, dir->path());
str = path.base();
/*
* If the file is open in any other session,
* unlinking is not allowed. This is to prevent
* dangling pointers in handle registries.
*/
if (_handle_registry.is_open(str))
throw Permission_denied();
assert_unlink(root()->unlink(str));
dir->mark_as_updated();
}
/**
* Truncate or grow file to specified size
*/
void truncate(File_handle file_handle, file_size_t size)
{
File *file = _handle_registry.lookup_and_lock(file_handle);
Node_lock_guard guard(file);
file->truncate(size);
file->mark_as_updated();
}
/**
* Move and rename directory entry
*/
void move(Dir_handle from_dir_handle, Name const &from_name,
Dir_handle to_dir_handle, Name const &to_name)
{
if (!_writable)
throw Permission_denied();
char const *from_str = from_name.string();
char const *to_str = to_name.string();
_assert_valid_name(from_str);
_assert_valid_name( to_str);
if (_handle_registry.refer_to_same_node(from_dir_handle, to_dir_handle)) {
Directory *dir = _handle_registry.lookup_and_lock(from_dir_handle);
Node_lock_guard from_guard(dir);
from_str = Subpath(from_str, dir->path()).base();
to_str = Subpath( to_str, dir->path()).base();
if (_handle_registry.is_open(to_str))
throw Permission_denied();
assert_rename(root()->rename(from_str, to_str));
_handle_registry.rename(from_str, to_str);
dir->mark_as_updated();
return;
}
Directory *from_dir = _handle_registry.lookup_and_lock(from_dir_handle);
Node_lock_guard from_guard(from_dir);
Directory *to_dir = _handle_registry.lookup_and_lock( to_dir_handle);
Node_lock_guard to_guard(to_dir);
from_str = Subpath(from_str, from_dir->path()).base();
to_str = Subpath( to_str, to_dir->path()).base();
if (_handle_registry.is_open(to_str))
throw Permission_denied();
assert_rename(root()->rename(from_str, to_str));
_handle_registry.rename(from_str, to_str);
from_dir->mark_as_updated();
to_dir->mark_as_updated();
}
void sigh(Node_handle node_handle, Signal_context_capability sigh) {
_handle_registry.sigh(node_handle, sigh); }
/**
* Sync the VFS and send any pending signal on the node.
*/
void sync(Node_handle handle)
{
Node *node;
try {
node = _handle_registry.lookup_and_lock(handle);
} catch (Invalid_handle) {
return;
}
Node_lock_guard guard(node);
root()->sync(node->path());
node->notify_listeners();
}
};
class File_system::Root : public Root_component<Session_component>
{
private:
Node_cache _cache;
Server::Entrypoint &_ep;
protected:
Session_component *_create_session(const char *args) override
{
Subpath session_root;
bool writeable = false;
Session_label const label(args);
try {
Session_policy policy(label);
char buf[MAX_PATH_LEN];
/* Determine the session root directory.
* Defaults to '/' if not specified by session
* policy or session arguments.
*/
try {
policy.attribute("root").value(buf, MAX_PATH_LEN);
session_root.append(buf);
} catch (Xml_node::Nonexistent_attribute) { }
Arg_string::find_arg(args, "root").string(buf, MAX_PATH_LEN, "/");
session_root.append(buf);
/* Determine if the session is writeable.
* Policy overrides arguments, both default to false.
*/
if (policy.attribute_value("writeable", false))
writeable = Arg_string::find_arg(args, "writeable").bool_value(false);
} catch (Session_policy::No_policy_defined) {
PERR("rejecting session request, no matching policy for %s", label.string());
throw Root::Unavailable();
}
size_t ram_quota = Arg_string::find_arg(args, "ram_quota" ).ulong_value(0);
size_t tx_buf_size = Arg_string::find_arg(args, "tx_buf_size").ulong_value(0);
if (!tx_buf_size)
throw Root::Invalid_args();
/*
* Check if donated ram quota suffices for session data,
* and communication buffer.
*/
size_t session_size = sizeof(Session_component) + tx_buf_size;
if (max((size_t)4096, session_size) > ram_quota) {
PERR("insufficient 'ram_quota' from %s, got %zd, need %zd",
label.string(), ram_quota, session_size);
throw Root::Quota_exceeded();
}
/* check if the session root exists */
if (!root()->is_directory(session_root.base())) {
PERR("session root '%s' not found for '%s'", session_root.base(), label.string());
throw Root::Unavailable();
}
Session_component *session = new(md_alloc())
Session_component(_ep, _cache, tx_buf_size, session_root, writeable);
PLOG("session opened for '%s' at '%s'", label.string(), session_root.base());
return session;
}
public:
/**
* Constructor
*
* \param ep entrypoint
* \param md_alloc meta-data allocator
*/
Root(Server::Entrypoint &ep, Allocator &md_alloc)
:
Root_component<Session_component>(&ep.rpc_ep(), &md_alloc),
_ep(ep)
{ }
};
struct File_system::Main
{
Server::Entrypoint &ep;
/*
* Initialize root interface
*/
Sliced_heap sliced_heap = { env()->ram_session(), env()->rm_session() };
Root fs_root = { ep, sliced_heap };
Main(Server::Entrypoint &ep) : ep(ep)
{
env()->parent()->announce(ep.manage(fs_root));
PLOG("virtual file system server started");
}
};
/**********************
** Server framework **
**********************/
char const * Server::name() { return "vfs_ep"; }
Genode::size_t Server::stack_size() { return 2*1024*sizeof(long); }
void Server::construct(Server::Entrypoint &ep) {
static File_system::Main inst(ep); }

386
repos/os/src/server/vfs/node_cache.h Normal file
View File

@ -0,0 +1,386 @@
/*
* \brief VFS server node cache
* \author Emery Hemingway
* \date 2015-09-02
*/
/*
* Copyright (C) 2015 Genode Labs GmbH
*
* This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2.
*/
#ifndef _VFS__NODE_CACHE_H_
#define _VFS__NODE_CACHE_H_
/* Genode includes */
#include <file_system/node.h>
#include <vfs/file_system.h>
#include <util/avl_string.h>
#include <util/noncopyable.h>
namespace File_system {
struct Node;
struct Directory;
class File;
struct Symlink;
class Node_cache;
typedef Avl_string<MAX_PATH_LEN> Avl_path_string;
Vfs::File_system *root();
}
/**
* Reference counted node object that can be inserted
* into an AVL tree.
*/
class File_system::Node : public Node_base, public Avl_node<Node>, private Noncopyable
{
friend class Node_cache;
private:
unsigned _ref_count;
char _path[Vfs::MAX_PATH_LEN];
protected:
void incr() { ++_ref_count; }
void decr() { --_ref_count; }
bool in_use() const { return _ref_count; }
public:
Node(char const *path)
: _ref_count(0) {
strncpy(_path, path, sizeof(_path)); }
char const *path() const { return _path; }
void path(char const *new_path) {
strncpy(_path, new_path, sizeof(_path)); }
virtual size_t read(char *dst, size_t len, seek_off_t) { return 0; }
virtual size_t write(char const *src, size_t len, seek_off_t) { return 0; }
/************************
** Avl node interface **
************************/
bool higher(Node *n) { return (strcmp(n->_path, _path) > 0); }
/**
* Find by path
*/
Node *find_by_path(const char *path)
{
if (strcmp(path, _path) == 0) return this;
Node *n = Avl_node<Node>::child(strcmp(path, _path) > 0);
return n ? n->find_by_path(path) : nullptr;
}
};
struct File_system::Directory : Node
{
Directory(char const *path, bool create)
: Node(path)
{
if (create)
assert_mkdir(root()->mkdir(path, 0777));
else if (strcmp("/", path, 2) == 0)
return;
else if (!root()->leaf_path(path))
throw Lookup_failed();
else if (!root()->is_directory(path))
throw Node_already_exists();
}
size_t read(char *dst, size_t len, seek_off_t seek_offset)
{
Directory_service::Dirent vfs_dirent;
size_t blocksize = sizeof(File_system::Directory_entry);
int index = (seek_offset / blocksize);
size_t remains = len;
while (remains >= blocksize) {
memset(&vfs_dirent, 0x00, sizeof(vfs_dirent));
if (root()->dirent(path(), index++, vfs_dirent)
!= Vfs::Directory_service::DIRENT_OK)
return len - remains;
File_system::Directory_entry *fs_dirent = (Directory_entry *)dst;
switch (vfs_dirent.type) {
case Vfs::Directory_service::DIRENT_TYPE_DIRECTORY:
fs_dirent->type = File_system::Directory_entry::TYPE_DIRECTORY;
break;
case Vfs::Directory_service::DIRENT_TYPE_SYMLINK:
fs_dirent->type = File_system::Directory_entry::TYPE_SYMLINK;
break;
case Vfs::Directory_service::DIRENT_TYPE_FILE:
default:
fs_dirent->type = File_system::Directory_entry::TYPE_FILE;
break;
}
strncpy(fs_dirent->name, vfs_dirent.name, MAX_NAME_LEN);
remains -= blocksize;
dst += blocksize;
}
return len - remains;
}
};
class File_system::File : public Node
{
private:
Vfs_handle *_handle;
unsigned _mode;
public:
File(char const *path, Mode fs_mode, bool create)
:
Node(path),
_handle(nullptr)
{
switch (fs_mode) {
case STAT_ONLY:
case READ_ONLY:
_mode = Directory_service::OPEN_MODE_RDONLY; break;
case WRITE_ONLY:
case READ_WRITE:
_mode = Directory_service::OPEN_MODE_RDWR; break;
}
unsigned mode = create ?
_mode | Directory_service::OPEN_MODE_CREATE : _mode;
assert_open(root()->open(path, mode, &_handle));
}
~File() { destroy(env()->heap(), _handle); }
void open(Mode fs_mode)
{
if (_mode & Directory_service::OPEN_MODE_RDWR) return;
unsigned mode;
switch (fs_mode) {
case WRITE_ONLY:
case READ_WRITE:
mode = Directory_service::OPEN_MODE_RDWR; break;
default:
return;
}
if (mode == _mode) return;
Vfs_handle *new_handle = nullptr;
assert_open(root()->open(path(), mode, &new_handle));
destroy(env()->heap(), _handle);
_handle = new_handle;
_mode = mode;
}
void truncate(file_size_t size) {
assert_truncate(_handle->fs().ftruncate(_handle, size)); }
size_t read(char *dst, size_t len, seek_off_t seek_offset)
{
Vfs::file_size res = 0;
_handle->seek(seek_offset);
_handle->fs().read(_handle, dst, len, res);
return res;
}
size_t write(char const *src, size_t len, seek_off_t seek_offset)
{
Vfs::file_size res = 0;
_handle->seek(seek_offset);
_handle->fs().write(_handle, src, len, res);
mark_as_updated();
return res;
}
};
struct File_system::Symlink : Node
{
Symlink(char const *path, bool create)
: Node(path)
{
if (create)
assert_symlink(root()->symlink("", path));
else if (!root()->leaf_path(path))
throw Lookup_failed();
else {
Vfs::Directory_service::Stat s;
assert_stat(root()->stat(path, s));
if (!(s.mode & Vfs::Directory_service::STAT_MODE_SYMLINK))
throw Node_already_exists();
}
}
size_t read(char *dst, size_t len, seek_off_t seek_offset)
{
Vfs::file_size res = 0;
root()->readlink(path(), dst, len, res);
return res;
}
size_t write(char const *src, size_t len, seek_off_t seek_offset)
{
root()->unlink(path());
size_t n = (root()->symlink(src, path()) == Directory_service::SYMLINK_OK)
? len : 0;
if (n) {
mark_as_updated();
notify_listeners();
}
return n;
}
};
/**
* This structure deduplicates nodes between sessions, without it
* the signal notifications would not propagate between sessions.
*/
struct File_system::Node_cache : Avl_tree<Node>
{
Node *find(char const *path) {
return first() ? (Node *)first()->find_by_path(path) : nullptr; }
void free(Node *node)
{
node->decr();
if (node->in_use())
return;
remove(node);
destroy(env()->heap(), node);
}
void remove_path(char const *path)
{
Node *node = find(path);
if (!node ) return;
remove(node);
destroy(env()->heap(), node);
}
void rename(char const *from, char const *to)
{
Node *node = find(to);
if (node)
throw Permission_denied();
node = find(from);
if (!node ) return;
remove(node);
node->path(to);
insert(node);
node->mark_as_updated();
}
/**
* Return an existing node or query the VFS
* and alloc a proper node.
*/
Node *node(char const *path)
{
Node *node = find(path);
if (!node) {
Directory_service::Stat stat;
assert_stat(root()->stat(path, stat));
switch (stat.mode & (
Directory_service::STAT_MODE_DIRECTORY |
Directory_service::STAT_MODE_SYMLINK |
File_system::Status::MODE_FILE)) {
case Directory_service::STAT_MODE_DIRECTORY:
node = new (env()->heap()) Directory(path, false);
break;
case Directory_service::STAT_MODE_SYMLINK:
node = new (env()->heap()) Symlink(path, false);
break;
default: /* Directory_service::STAT_MODE_FILE */
node = new (env()->heap()) File(path, READ_ONLY, false);
break;
}
insert(node);
}
node->incr();
return node;
}
Directory *directory(char const *path, bool create)
{
Directory *dir;
Node *node = find(path);
if (node) {
dir = dynamic_cast<Directory *>(node);
if (!dir)
throw Node_already_exists();
} else {
dir = new (env()->heap()) Directory(path, create);
insert(dir);
}
dir->incr();
return dir;
}
File *file(char const *path, Mode mode, bool create)
{
File *file;
Node *node = find(path);
if (node) {
file = dynamic_cast<File *>(node);
if (!file)
throw Node_already_exists();
file->open(mode);
} else {
file = new (env()->heap()) File(path, mode, create);
insert(file);
}
file->incr();
return file;
}
Symlink *symlink(char const *path, bool create)
{
Symlink *link;
Node *node = find(path);
if (node) {
link = dynamic_cast<Symlink *>(node);
if (!link)
throw Node_already_exists();
} else {
link = new (env()->heap()) Symlink(path, create);
insert(link);
}
link->incr();
return link;
}
};
#endif

316
repos/os/src/server/vfs/node_handle_registry.h Normal file
View File

@ -0,0 +1,316 @@
/*
* \brief Facility for managing the session-local node-handle namespace
* \author Norman Feske
* \date 2012-04-11
*
* This file is derived from os/include/file_system/node_handle_registry.h.
*/
#ifndef _VFS__NODE_HANDLE_REGISTRY_H_
#define _VFS__NODE_HANDLE_REGISTRY_H_
#include <file_system/node.h>
namespace File_system {
class Node;
class Directory;
class File;
class Symlink;
/**
* Type trait for determining the node type for a given handle type
*/
template<typename T> struct Node_type;
template<> struct Node_type<Node_handle> { typedef Node Type; };
template<> struct Node_type<Dir_handle> { typedef Directory Type; };
template<> struct Node_type<File_handle> { typedef File Type; };
template<> struct Node_type<Symlink_handle> { typedef Symlink Type; };
/**
* Type trait for determining the handle type for a given node type
*/
template<typename T> struct Handle_type;
template<> struct Handle_type<Node> { typedef Node_handle Type; };
template<> struct Handle_type<Directory> { typedef Dir_handle Type; };
template<> struct Handle_type<File> { typedef File_handle Type; };
template<> struct Handle_type<Symlink> { typedef Symlink_handle Type; };
class Node_handle_registry
{
private:
/* maximum number of open nodes per session */
enum { MAX_NODE_HANDLES = 128U };
Lock mutable _lock;
Node *_nodes[MAX_NODE_HANDLES];
/**
* Each open node handle can act as a listener to be informed about
* node changes.
*/
Listener _listeners[MAX_NODE_HANDLES];
/**
* Mode information is stored here for each open node.
*/
enum Mode _modes[MAX_NODE_HANDLES];
/**
* A cache of open nodes shared between sessions.
*/
Node_cache &_cache;
/**
* Allocate node handle
*
* \throw Out_of_node_handles
*/
int _alloc(Node *node, Mode mode)
{
Lock::Guard guard(_lock);
for (unsigned i = 0; i < MAX_NODE_HANDLES; i++)
if (!_nodes[i]) {
_nodes[i] = node;
_modes[i] = mode;
return i;
}
throw Out_of_node_handles();
}
bool _in_range(int handle) const
{
return ((handle >= 0) && (handle < MAX_NODE_HANDLES));
}
public:
Node_handle_registry(Node_cache &cache)
: _cache(cache)
{
for (unsigned i = 0; i < MAX_NODE_HANDLES; i++) {
_nodes[i] = 0;
_modes[i] = STAT_ONLY;
}
}
template <typename NODE_TYPE>
typename Handle_type<NODE_TYPE>::Type alloc(NODE_TYPE *node, Mode mode)
{
typedef typename Handle_type<NODE_TYPE>::Type Handle;
return Handle(_alloc(node, mode));
}
/**
* Request a file from the cache and allocate a handle.
*/
Dir_handle directory(char const *path, bool create)
{
Directory *dir = _cache.directory(path, create);
return alloc(dir, READ_ONLY);
}
/**
* Request a directory from the cache and allocate a handle.
*/
File_handle file(char const *path, Mode mode, bool create)
{
File *file = _cache.file(path, mode, create);
return alloc(file, mode);
}
/**
* Request a symlink from the cache and allocate a handle.
*/
Symlink_handle symlink(char const *path, Mode mode, bool create)
{
Symlink *link = _cache.symlink(path, create);
return alloc(link, mode);
}
/**
* Request a node from the cache and allocate a handle.
*/
Node_handle node(char const *path)
{
Node *node = _cache.node(path);
return alloc(node, STAT_ONLY);
}
/**
* Release node handle
*/
void free(Node_handle handle)
{
if (!_in_range(handle.value))
return;
Lock::Guard guard(_lock);
Node *node = dynamic_cast<Node *>(_nodes[handle.value]);
if (!node) { return; }
node->lock();
node->notify_listeners();
/*
* De-allocate handle
*/
Listener &listener = _listeners[handle.value];
if (listener.valid())
node->remove_listener(&listener);
_nodes[handle.value] = 0;
listener = Listener();
_modes[handle.value] = STAT_ONLY;
node->unlock();
_cache.free(node);
}
/**
* Lookup node using its handle as key
*
* The node returned by this function is in a locked state.
*
* \throw Invalid_handle
*/
template <typename HANDLE_TYPE>
typename Node_type<HANDLE_TYPE>::Type *lookup_and_lock(HANDLE_TYPE handle)
{
if (!_in_range(handle.value))
throw Invalid_handle();
Lock::Guard guard(_lock);
typedef typename Node_type<HANDLE_TYPE>::Type Node;
Node *node = dynamic_cast<Node *>(_nodes[handle.value]);
if (!node)
throw Invalid_handle();
node->lock();
return node;
}
/**
* Lookup a node for reading
*
* A node in a locked state or a null pointer is returned.
*/
Node *lookup_read(Node_handle handle)
{
if (!_in_range(handle.value))
return nullptr;
Lock::Guard guard(_lock);
switch (_modes[handle.value]) {
case READ_ONLY:
case READ_WRITE:
break;
default:
return nullptr;
}
Node *node = dynamic_cast<Node *>(_nodes[handle.value]);
if (node)
node->lock();
return node;
}
/**
* Lookup a node for writing
*
* A node in a locked state or a null pointer is returned.
*/
Node *lookup_write(Node_handle handle)
{
if (!_in_range(handle.value))
return nullptr;
Lock::Guard guard(_lock);
switch (_modes[handle.value]) {
case WRITE_ONLY:
case READ_WRITE:
break;
default:
return nullptr;
}
Node *node = dynamic_cast<Node *>(_nodes[handle.value]);
if (node)
node->lock();
return node;
}
bool refer_to_same_node(Node_handle h1, Node_handle h2) const
{
Lock::Guard guard(_lock);
if (!(_in_range(h1.value) && _in_range(h2.value)))
throw Invalid_handle();
return _nodes[h1.value] == _nodes[h2.value];
}
/**
* Register signal handler to be notified of node changes
*/
void sigh(Node_handle handle, Signal_context_capability sigh)
{
if (!_in_range(handle.value))
throw Invalid_handle();
Lock::Guard guard(_lock);
Node *node = dynamic_cast<Node *>(_nodes[handle.value]);
if (!node)
throw Invalid_handle();
node->lock();
Node_lock_guard node_lock_guard(node);
Listener &listener = _listeners[handle.value];
/*
* If there was already a handler registered for the node,
* remove the old handler.
*/
if (listener.valid())
node->remove_listener(&listener);
/*
* Register new handler
*/
listener = Listener(sigh);
node->add_listener(&listener);
}
/**
* Remove a path from the cache.
*/
void remove(char const *path) { _cache.remove_path(path); }
/**
* Rename a node in the cache.
*/
void rename(char const *from, char const *to) {
_cache.rename(from, to); }
/**
* Is the node open (present in the cache)?
*/
bool is_open(char const *path) {
return _cache.find(path); }
};
}
#endif /* _VFS__NODE_HANDLE_REGISTRY_H_ */

4
repos/os/src/server/vfs/target.mk Normal file
View File

@ -0,0 +1,4 @@
TARGET = vfs
SRC_CC = main.cc
LIBS = base config server vfs
INC_DIR += $(PRG_DIR)

2
tool/autopilot.list
View File

@ -9,6 +9,8 @@ noux
noux_net_netcat
libc_ffat
libc_vfs
libc_vfs_ram
libc_vfs_fs
timed_semaphore
signal
sub_rm