ehmry/genode
ehmry
/
genode
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
genode/repos/os/src/server/trace_fs/main.cc

1070 lines
28 KiB
C++
Raw Blame History

/*
* \brief Trace file system
* \author Josef Soentgen
* \date 2014-01-15
*/
/*
* Copyright (C) 2014 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/node_handle_registry.h>
#include <cap_session/connection.h>
#include <file_system_session/rpc_object.h>
#include <os/attached_rom_dataspace.h>
#include <os/config.h>
#include <os/server.h>
#include <os/session_policy.h>
#include <root/component.h>
#include <timer_session/connection.h>
#include <trace_session/connection.h>
#include <util/list.h>
#include <util/string.h>
#include <util/xml_node.h>
/* local includes */
#include <buffer.h>
#include <directory.h>
#include <followed_subject.h>
#include <trace_files.h>
static bool const verbose = false;
#define PDBGV(...) if (verbose) PDBG(__VA_ARGS__)
/**
* Return true if 'str' is a valid file name
*/
static inline bool valid_filename(char const *str)
{
if (!str) return false;
/* must have at least one character */
if (str[0] == 0) return false;
/* must not contain '/' or '\' or ':' */
if (string_contains(str, '/') ||
string_contains(str, '\\') ||
string_contains(str, ':'))
return false;
return true;
}
/**
* This class updates the file system
*
* In this context updating means creating the files and directories if
* needed, refreshing their content or deleting them if they are no
* longer of any use.
*/
class Trace_file_system
{
private:
/* local abbreviations */
typedef Genode::size_t size_t;
typedef Genode::Trace::Subject_id Subject_id;
typedef Genode::Trace::Subject_info Subject_info;
typedef Genode::Trace::Connection Trace;
typedef Trace_fs::Followed_subject_registry Followed_subject_registry;
typedef Trace_fs::Followed_subject Followed_subject;
typedef File_system::Directory Directory;
typedef File_system::Node Node;
/**
* Simple node list
*
* This list is used to temporarily store pointers to all nodes
* needed for representing a trace subject in the file system when
* creating or cleaning up the file system hierachie.
*/
class Node_list
{
private:
/**
* Node list element class
*
* A element only contains a pointer to the actual node.
*/
struct Node_list_entry : public Genode::List<Node_list_entry>::Element
{
File_system::Node *node;
Node_list_entry(File_system::Node *n) : node(n) { }
};
Genode::Allocator &_md_alloc;
Genode::List<Node_list_entry> _list;
public:
Node_list(Genode::Allocator &md_alloc) : _md_alloc(md_alloc) { }
/**
* Free all memory automatically if the object goes out of
* scope or rather is deleted.
*/
~Node_list()
{
for (Node_list_entry *e = _list.first(); e; ) {
Node_list_entry *cur = e;
e = e->next();
_list.remove(cur);
destroy(&_md_alloc, cur);
}
}
/**
* Insert a node in the list
*
* \param node pointer to node
*/
void push(Node *node)
{
Node_list_entry *e = new (&_md_alloc) Node_list_entry(node);
_list.insert(e);
}
/**
* Remove the first node from the list
*
* The first element will be removed from the list and the node
* is returned.
*
* \return pointer to node or 0
*/
Node *pop()
{
Node_list_entry *e = _list.first();
if (e) {
Node *node = e->node;
_list.remove(e);
destroy(&_md_alloc, e);
return node;
}
return 0;
}
/**
* Return the node pointer of the first element in the list
*
* This method only returns the pointer but leaves the list
* element in good order.
*
* \return pointer to node of the first element or 0
*/
Node *first()
{
Node_list_entry *e = _list.first();
return e ? e->node : 0;
}
};
/**
* This class implements the Process_entry functor class
*
* It is needed by the Trace_buffer_manager to process a entry
* from the Trace::Buffer.
*/
template <size_t CAPACITY>
class Process_entry : public Followed_subject::Trace_buffer_manager::Process_entry
{
private:
char _buf[CAPACITY];
size_t _length;
public:
Process_entry() : _length(0) { _buf[0] = 0; }
/**
* Return capacity of the internal buffer
*
* \return capacity of the buffer in bytes
*/
size_t capacity() const { return CAPACITY; }
/**
* Return data of the processed Trace::Buffer::Entry
*
* \return pointer to data
*/
char const *data() const { return _buf; }
/**
* Functor for processing a Trace:Buffer::Entry
*
* \param entry reference of Trace::Buffer::Entry
*
* \return length of processed Trace::Buffer::Entry
*/
Genode::size_t operator()(Genode::Trace::Buffer::Entry &entry)
{
Genode::size_t len = Genode::min(entry.length() + 1, CAPACITY);
Genode::memcpy(_buf, entry.data(), len);
_buf[len - 1] = '\n';
_length = len;
return len;
}
};
Genode::Allocator &_alloc;
Genode::Trace::Connection &_trace;
Directory &_root_dir;
size_t _buffer_size;
size_t _buffer_size_max;
Followed_subject_registry _followed_subject_registry;
/**
* Cast Node pointer to Directory pointer
*
* \param node pointer to node
*/
Directory *_node_to_directory(Node *node)
{
return dynamic_cast<Directory*>(node);
}
/**
* Gather recent trace events
*
* \param subject pointer to subject
*/
void _gather_events(Followed_subject *subject)
{
Followed_subject::Trace_buffer_manager *manager = subject->trace_buffer_manager();
if (!manager)
return;
PDBGV("update events for subject:'%s'", subject->name());
Process_entry<512> process_entry;
while (!manager->last_entry()) {
size_t len = manager->dump_entry(process_entry);
if (len == 0)
continue;
try { subject->events_file.append(process_entry.data(), len); }
catch (...) { PERR("could not write entry"); }
}
if (manager->last_entry()) {
manager->rewind();
}
}
/**
* Disable tracing of a followed subject
*
* \param subject pointer to subject
*/
void _disable_tracing(Followed_subject *subject)
{
PDBGV("disable tracing of subject:'%s'", subject->name());
subject->active_file.set_inactive();
_trace.pause(subject->id());
_gather_events(subject);
try { subject->unmanage_trace_buffer(); }
catch (...) { PERR("trace buffer was not managed"); }
_trace.free(subject->id());
}
/**
* Enable tracing of a followed subject
*
* \param subject pointer to subject
*/
void _enable_tracing(Followed_subject *subject)
{
PDBGV("activate tracing of subject:'%s' with policy:'%u' and buffer_size:'%lu'",
subject->name(), subject->policy_id().id, subject->buffer_size_file.size());
try {
_trace.trace(subject->id().id, subject->policy_id().id,
subject->buffer_size_file.size());
try { subject->manage_trace_buffer(_trace.buffer(subject->id())); }
catch (...) { PERR("trace buffer is already managed"); }
subject->active_file.set_active();
} catch (...) { PERR("could not enable tracing"); }
}
/**
* Search recursively the parent node for the corresponding label
*
* \param list list of traversed nodes
* \param walker label walking object
* \param parent parent node of the current directory
*
* \return parent node for the given label
*/
Directory* _find_parent_node(Node_list &list, Util::Label_walker &walker,
Directory &parent)
{
char const *remainder = walker.next();
Directory *child;
PDBGV("parent '%s' num_entries '%zu' lookup '%s'", parent.name(),
parent.num_entries(), walker.element());
try { child = _node_to_directory(parent.lookup(walker.element())); }
catch (File_system::Lookup_failed) {
try {
child = new (&_alloc) Directory(walker.element());
parent.adopt_unsynchronized(child);
} catch (...) {
PERR("could not create '%s'", walker.element());
return 0;
}
}
list.push(child);
if (!*remainder) {
return child;
} else {
return _find_parent_node(list, walker, *child);
}
}
/**
* Remove unsused nodes and free the memory
*
* All nodes are removed from the list and discarded from their
* parent until we hit a node or rather a parent that still has
* child nodes. In this case we stop. The remaining entries in
* the node list are freed when the Node_list is deleted.
*
* \param list reference to list
*/
void _remove_nodes(Node_list &list)
{
while (Node *child = list.pop()) {
Node *parent = list.first();
Directory *dir = dynamic_cast<Directory*>(child);
if (dir->num_entries() == 0) {
if (parent) {
Directory *dir = dynamic_cast<Directory*>(parent);
if (!(Genode::strcmp(dir->name(), child->name()) == 0))
dir->discard_unsynchronized(child);
}
destroy(&_alloc, dir);
} else {
/* do not bother any further, node has other children */
break;
}
}
}
public:
/**
* Constructor
*/
Trace_file_system(Genode::Allocator &alloc,
Trace &trace,
Directory &root_dir,
size_t buffer_size,
size_t buffer_size_max)
:
_alloc(alloc), _trace(trace), _root_dir(root_dir),
_buffer_size(buffer_size), _buffer_size_max(buffer_size_max),
_followed_subject_registry(_alloc)
{ }
/**
* Handle the change of the content of a node
*
* XXX This method could be made much simpler if a Node would
* store the subject_id and could be used to make the lookup.
*/
void handle_changed_node(Node *node)
{
Followed_subject *subject = 0;
bool policy_changed = false;
using namespace File_system;
/**
* It is enough to invoke acknowledge_change() on the Cleanup_file.
* Therefore here is nothing to be done.
*/
Cleanup_file *cleanup_file = dynamic_cast<Cleanup_file*>(node);
if (cleanup_file) {
return;
}
Policy_file *policy_file = dynamic_cast<Policy_file*>(node);
if (policy_file) {
try {
subject = _followed_subject_registry.lookup(policy_file->id());
size_t policy_length = policy_file->length();
/* policy was changed, unload old one first */
if (subject->policy_valid()) {
_trace.unload_policy(subject->policy_id());
subject->invalidate_policy();
}
/**
* Copy the new policy only if it may containg something useful.
* XXX: It might be better to check for a more reaseonable length.
*/
if (policy_length > 0) {
try {
Genode::Trace::Policy_id id = _trace.alloc_policy(policy_length);
Genode::Dataspace_capability ds_cap = _trace.policy(id);
if (ds_cap.valid()) {
void *ram = Genode::env()->rm_session()->attach(ds_cap);
size_t n = policy_file->read((char *)ram, policy_length, 0UL);
if (n != policy_length) {
PERR("error while copying policy content");
} else { subject->policy_id(id); }
Genode::env()->rm_session()->detach(ram);
}
} catch (...) { PERR("could not allocate policy"); }
}
policy_changed = true;
} catch (Trace_fs::Followed_subject_registry::Invalid_subject) { }
}
Enable_file *enable_file = dynamic_cast<Enable_file*>(node);
if (enable_file) {
try { subject = _followed_subject_registry.lookup(enable_file->id()); }
catch (Trace_fs::Followed_subject_registry::Invalid_subject) { }
}
/**
* Perform the action which was originally intended. This is actually
* safe because at this point we got invoked by either the Enable_file
* or Policy_file file.
*/
Subject_info info = _trace.subject_info(subject->id());
Subject_info::State state = info.state();
/* tracing already enabled but policy has changed */
if (subject->enable_file.enabled() && policy_changed) {
/* disable tracing first */
if (state == Subject_info::State::TRACED)
_disable_tracing(subject);
/* reenable only if the policy is actually valid */
if (subject->policy_valid())
_enable_tracing(subject);
}
/* subject is untraced but tracing is now enabled */
else if (subject->enable_file.enabled() &&
(state == Subject_info::State::UNTRACED)) {
if (subject->policy_valid())
_enable_tracing(subject);
}
/* subject is traced but tracing is now disabled */
else if (!subject->enable_file.enabled() &&
(state == Subject_info::State::TRACED)) {
_disable_tracing(subject);
}
}
/**
* Update the trace subjects
*
* \param subject_limit limit the number of trace subjects
*/
void update(int subject_limit)
{
Genode::Trace::Subject_id subjects[subject_limit];
size_t num_subjects = _trace.subjects(subjects, subject_limit);
/* traverse current trace subjects */
for (size_t i = 0; i < num_subjects; i++) {
Subject_info info = _trace.subject_info(subjects[i]);
Subject_info::State state = info.state();
PDBGV("subject:'%s.%u' state:'%u'", info.thread_name().string(),
subjects[i].id, state);
/* opt-out early */
switch (state) {
case Subject_info::State::INVALID:
case Subject_info::State::FOREIGN:
case Subject_info::State::ERROR:
continue;
break; /* never reached */
default:
break;
}
Followed_subject *followed_subject;
try {
/* old subject found */
followed_subject = _followed_subject_registry.lookup(subjects[i]);
/**
* Update content of the corresponding events file
*/
if (state == Subject_info::State::TRACED) {
_gather_events(followed_subject);
continue;
}
/**
* The subject is either UNTRACED or DEAD in which case we want to remove
* the nodes if they are marked for deletion.
*/
if (followed_subject->marked_for_cleanup() ||
(!followed_subject->was_traced() && state == Subject_info::State::DEAD)) {
char const *label = info.session_label().string();
Node_list list(_alloc);
Util::Label_walker walker(label);
Directory *parent = _find_parent_node(list, walker, _root_dir);
if (!parent) {
PERR("could not find parent node for label:'%s'", label);
continue;
}
parent->discard_unsynchronized(followed_subject);
_remove_nodes(list);
_followed_subject_registry.free(followed_subject);
continue;
}
} catch (Trace_fs::Followed_subject_registry::Invalid_subject) {
/* ignore unknown but already dead subject */
if (state == Subject_info::State::DEAD)
continue;
/* new subject */
char const *label = info.session_label().string();
char const *name = info.thread_name().string();
Util::Buffer<64> subject_dir_name;
Genode::snprintf(subject_dir_name.data(), subject_dir_name.capacity(),
"%s.%d", name, subjects[i].id);
subject_dir_name.replace('/', '_');
followed_subject = _followed_subject_registry.alloc(subject_dir_name.data(),
subjects[i]);
/* set trace buffer size */
followed_subject->buffer_size_file.size_limit(_buffer_size_max);
followed_subject->buffer_size_file.size(_buffer_size);
Node_list list(_alloc);
Util::Label_walker walker(label);
Directory *parent = _find_parent_node(list, walker, _root_dir);
if (!parent) {
PERR("could not find parent node on creation");
continue;
}
parent->adopt_unsynchronized(followed_subject);
}
}
}
};
namespace File_system {
struct Main;
struct Session_component;
struct Root;
}
class File_system::Session_component : public Session_rpc_object
{
private:
Server::Entrypoint &_ep;
Allocator &_md_alloc;
Directory &_root_dir;
Node_handle_registry _handle_registry;
bool _writeable;
unsigned _subject_limit;
unsigned _poll_interval;
Timer::Connection _fs_update_timer;
Trace::Connection *_trace;
Trace_file_system *_trace_fs;
Signal_rpc_member<Session_component> _process_packet_dispatcher;
Signal_rpc_member<Session_component> _fs_update_dispatcher;
/**************************
** File system updating **
**************************/
/**
* Update the file system hierarchie and data of active trace subjects
*/
void _fs_update(unsigned)
{
PDBGV("trace_fs update, limit:%d", _subject_limit);
_trace_fs->update(_subject_limit);
}
/******************************
** Packet-stream processing **
******************************/
/**
* Perform packet operation
*/
void _process_packet_op(Packet_descriptor &packet, Node &node)
{
void * const content = tx_sink()->packet_content(packet);
size_t const length = packet.length();
seek_off_t const offset = packet.position();
if (!content || (packet.length() > packet.size())) {
packet.succeeded(false);
return;
}
/* resulting length */
size_t res_length = 0;
switch (packet.operation()) {
case Packet_descriptor::READ:
res_length = node.read((char *)content, length, offset);
break;
case Packet_descriptor::WRITE:
res_length = node.write((char const *)content, length, offset);
break;
}
packet.length(res_length);
packet.succeeded(res_length > 0);
}
void _process_packet()
{
Packet_descriptor packet = tx_sink()->get_packet();
/* assume failure by default */
packet.succeeded(false);
try {
Node *node = _handle_registry.lookup(packet.handle());
_process_packet_op(packet, *node);
}
catch (Invalid_handle) { PERR("Invalid_handle"); }
catch (Size_limit_reached) { PERR("Size_limit_reached"); }
/*
* 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] != '/') {
PWRN("malformed path '%s'", path);
throw Lookup_failed();
}
}
public:
/**
* Constructor
*/
Session_component(size_t tx_buf_size,
Server::Entrypoint &ep,
File_system::Directory &root_dir,
Allocator &md_alloc,
unsigned subject_limit,
unsigned poll_interval,
size_t trace_quota,
size_t trace_meta_quota,
size_t trace_parent_levels,
size_t buffer_size,
size_t buffer_size_max)
:
Session_rpc_object(env()->ram_session()->alloc(tx_buf_size), ep.rpc_ep()),
_ep(ep),
_md_alloc(md_alloc),
_root_dir(root_dir),
_subject_limit(subject_limit),
_poll_interval(poll_interval),
_trace(new (&_md_alloc) Genode::Trace::Connection(trace_quota, trace_meta_quota, trace_parent_levels)),
_trace_fs(new (&_md_alloc) Trace_file_system(_md_alloc, *_trace, _root_dir, buffer_size, buffer_size_max)),
_process_packet_dispatcher(_ep, *this, &Session_component::_process_packets),
_fs_update_dispatcher(_ep, *this, &Session_component::_fs_update)
{
_tx.sigh_packet_avail(_process_packet_dispatcher);
_tx.sigh_ready_to_ack(_process_packet_dispatcher);
/**
* Register '_fs_update' dispatch function as signal handler
* for polling the trace session.
*/
_fs_update_timer.sigh(_fs_update_dispatcher);
/**
* We need to scale _poll_interval because trigger_periodic()
* uses usec.
*/
_fs_update_timer.trigger_periodic(_poll_interval * 1000);
}
/**
* Destructor
*/
~Session_component()
{
destroy(&_md_alloc, _trace_fs);
destroy(&_md_alloc, _trace);
Dataspace_capability ds = tx_sink()->dataspace();
env()->ram_session()->free(static_cap_cast<Ram_dataspace>(ds));
}
/***************************
** File_system interface **
***************************/
File_handle file(Dir_handle dir_handle, Name const &name, Mode mode, bool create)
{
if (!valid_filename(name.string()))
throw Invalid_name();
Directory *dir = _handle_registry.lookup(dir_handle);
if (create)
throw Permission_denied();
File *file = dynamic_cast<File*>(dir->lookup(name.string()));
if (!file)
throw Invalid_name();
return _handle_registry.alloc(file);
}
Symlink_handle symlink(Dir_handle dir_handle, Name const &name, bool create)
{
PWRN("symlinks not supported");
return Symlink_handle();
}
Dir_handle dir(Path const &path, bool create)
{
char const *path_str = path.string();
_assert_valid_path(path_str);
if (create)
throw Permission_denied();
if (!path.is_valid_string())
throw Name_too_long();
Directory *dir = dynamic_cast<Directory*>(_root_dir.lookup(path_str + 1));
if (!dir)
throw Invalid_name();
return _handle_registry.alloc(dir);
}
Node_handle node(Path const &path)
{
char const *path_str = path.string();
_assert_valid_path(path_str);
Node *node = _root_dir.lookup(path_str + 1);
return _handle_registry.alloc(node);
}
void close(Node_handle handle)
{
Node *node;
try { node = _handle_registry.lookup(handle); }
catch (Invalid_handle) {
PERR("close() called with invalid handle");
return;
}
/**
* Acknowledge the change of the content of files which may be
* modified by the user of the file system.
*/
Changeable_content *changeable = dynamic_cast<Changeable_content*>(node);
if (changeable) {
if (changeable->changed()) {
changeable->acknowledge_change();
/* let the trace fs perform the provoked actions */
_trace_fs->handle_changed_node(node);
}
}
_handle_registry.free(handle);
}
Status status(Node_handle node_handle)
{
Node *node = _handle_registry.lookup(node_handle);
return node->status();
}
void control(Node_handle, Control) { }
void unlink(Dir_handle dir_handle, Name const &name) { }
void truncate(File_handle handle, file_size_t size)
{
Node *node;
try {
node = _handle_registry.lookup(handle);
File *file = dynamic_cast<File*>(node);
if (file) { file->truncate(size); }
} catch (Invalid_handle) { }
}
void move(Dir_handle, Name const &, Dir_handle, Name const &) { }
void sigh(Node_handle node_handle, Signal_context_capability sigh) {
_handle_registry.sigh(node_handle, sigh); }
void sync() { }
};
class File_system::Root : public Root_component<Session_component>
{
private:
Server::Entrypoint &_ep;
Directory &_root_dir;
protected:
Session_component *_create_session(const char *args)
{
/*
* Determine client-specific policy defined implicitly by
* the client's label.
*/
enum { ROOT_MAX_LEN = 256 };
char root[ROOT_MAX_LEN];
root[0] = 0;
/* default settings */
unsigned interval = 1000; /* 1 sec */
unsigned subject_limit = 128;
Genode::Number_of_bytes trace_quota = 32 * (1 << 20); /* 32 MiB */
Genode::Number_of_bytes trace_meta_quota = 256 * (1 << 10); /* 256 KiB */
Genode::Number_of_bytes buffer_size = 32 * (1 << 10); /* 32 KiB */
Genode::Number_of_bytes buffer_size_max = 1 * (1 << 20); /* 1 MiB */
unsigned trace_parent_levels = 0;
try {
Session_label label(args);
Session_policy policy(label);
/*
* Override default settings with specific session settings by
* evaluating the policy.
*/
try { policy.attribute("interval").value(&interval);
} catch (...) { }
try { policy.attribute("subject_limit").value(&subject_limit);
} catch (...) { }
try { policy.attribute("trace_quota").value(&trace_quota);
} catch (...) { }
try { policy.attribute("trace_meta_quota").value(&trace_meta_quota);
} catch (...) { }
try { policy.attribute("parent_levels").value(&trace_parent_levels);
} catch (...) { }
try { policy.attribute("buffer_size").value(&buffer_size);
} catch (...) { }
try { policy.attribute("buffer_size_max").value(&buffer_size_max);
} catch (...) { }
/*
* Determine directory that is used as root directory of
* the session.
*/
try {
policy.attribute("root").value(root, sizeof(root));
/*
* Make sure the root path is specified with a
* leading path delimiter. For performing the
* lookup, we skip the first character.
*/
if (root[0] != '/')
throw Lookup_failed();
} catch (Xml_node::Nonexistent_attribute) {
PERR("Missing \"root\" attribute in policy definition");
throw Root::Unavailable();
} catch (Lookup_failed) {
PERR("Session root directory \"%s\" does not exist", root);
throw Root::Unavailable();
}
} catch (Session_policy::No_policy_defined) {
PERR("Invalid session request, no matching policy");
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);
/*
* 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', got %zd, need %zd",
ram_quota, session_size);
throw Root::Quota_exceeded();
}
return new (md_alloc())
Session_component(tx_buf_size, _ep, _root_dir, *md_alloc(),
subject_limit, interval, trace_quota,
trace_meta_quota, trace_parent_levels,
buffer_size, buffer_size_max);
}
public:
/**
* Constructor
*
* \param ep entrypoint
* \param sig_rec signal receiver used for handling the
* data-flow signals of packet streams
* \param md_alloc meta-data allocator
*/
Root(Server::Entrypoint &ep, Allocator &md_alloc, Directory &root_dir)
:
Root_component<Session_component>(&ep.rpc_ep(), &md_alloc),
_ep(ep),
_root_dir(root_dir)
{ }
};
struct File_system::Main
{
Server::Entrypoint &ep;
Directory root_dir = { "/" };
/*
* Initialize root interface
*/
Sliced_heap sliced_heap = { env()->ram_session(), env()->rm_session() };
Root fs_root = { ep, sliced_heap, root_dir };
Main(Server::Entrypoint &ep) : ep(ep)
{
env()->parent()->announce(ep.manage(fs_root));
}
};
/**********************
** Server framework **
**********************/
char const * Server::name() { return "trace_fs_ep"; }
Genode::size_t Server::stack_size() { return 32 * 2048 * sizeof(long); }
void Server::construct(Server::Entrypoint &ep) { static File_system::Main inst(ep); }
Reference in New Issue View Git Blame Copy Permalink