ehmry/genode
ehmry
/
genode
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

libc: unify use of namespaces 

This patch unifies the patterns of using the 'Genode' and 'Libc'
namespaces.

Types defined in the 'internal/' headers reside in the 'Libc'
namespace. The code in the headers does not need to use the
'Libc::' prefix.

Compilation units import the 'Libc' namespace after the definition of
local types. Local types reside in the 'Libc' namespace (and should
eventually move to an 'internal/' header).

Since the 'Libc' namespace imports the 'Genode' namespace, there is
no need to use the 'Genode::' prefix. Consequently, code in the
compilation units rarely need to qualify the 'Genode' or 'Libc'
namespaces.

There are a few cases where the 'Libc', the 'Genode', and the global
(libc) namespaces are ambigious. In these cases, an explicit
clarification is needed:

- 'Genode::Allocator' differs from 'Libc::Allocator'.
- 'Genode::Env' differs from 'Libc::Env'.
- Genode's string functions (strcmp, memcpy, strcpy) conflict
  with the names of the (global) libc functions.
- There exist both 'Genode::uint64_t' and the libc'c 'uint64_t'.

Issue #3497
This commit is contained in:
Norman Feske 2019-09-19 20:37:17 +02:00 committed by Christian Helmuth
parent bf92232698
commit 648bcd1505
41 changed files with 592 additions and 531 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
repos/libports/lib/symbols/libc
View File

@ -962,9 +962,9 @@ _ZN4Libc19Select_handler_baseD2Ev T
_ZN4Libc10resume_allEv T
_ZN4Libc7suspendERNS_15Suspend_functorEm T
_Z16pthread_registryv T
_ZN16Pthread_registry6insertEP7pthread T
_ZN16Pthread_registry6removeEP7pthread T
_ZN16Pthread_registry8containsEP7pthread T
_ZN4Libc16Pthread_registry6insertERNS_7PthreadE T
_ZN4Libc16Pthread_registry6removeERNS_7PthreadE T
_ZN4Libc16Pthread_registry8containsERNS_7PthreadE T
_ZN4Libc14pthread_createEPP7pthreadPFPvS3_ES3_mPKcPN6Genode11Cpu_sessionENS8_8Affinity8LocationE T
_ZN4Libc14pthread_createEPP7pthreadRN6Genode6ThreadE T

3
repos/libports/src/lib/libc/fd_alloc.cc
View File

@ -31,7 +31,6 @@
#include <internal/init.h>
using namespace Libc;
using namespace Genode;
static Allocator *_alloc_ptr;
@ -149,7 +148,7 @@ void File_descriptor::path(char const *newpath)
}
if (newpath) {
Genode::size_t const path_size = ::strlen(newpath) + 1;
size_t const path_size = ::strlen(newpath) + 1;
char *buf = (char*)_alloc_ptr->alloc(path_size);
if (!buf) {
error("could not allocate path buffer for libc_fd ", libc_fd);

47
repos/libports/src/lib/libc/file_operations.cc
View File

@ -56,7 +56,7 @@ using namespace Libc;
Libc::Mmap_registry *Libc::mmap_registry()
{
static Libc::Mmap_registry registry;
static Mmap_registry registry;
return &registry;
}
@ -86,7 +86,7 @@ struct Scanner_policy_path_element
}
};
typedef Genode::Token<Scanner_policy_path_element> Path_element_token;
typedef Token<Scanner_policy_path_element> Path_element_token;
/**
@ -126,7 +126,7 @@ void Libc::resolve_symlinks(char const *path, Absolute_path &resolved_path)
try {
next_iteration_working_path.append_element(path_element);
} catch (Genode::Path_base::Path_too_long) {
} catch (Path_base::Path_too_long) {
errno = ENAMETOOLONG;
throw Symlink_resolve_error();
}
@ -160,7 +160,7 @@ void Libc::resolve_symlinks(char const *path, Absolute_path &resolved_path)
next_iteration_working_path.strip_last_element();
try {
next_iteration_working_path.append_element(symlink_target);
} catch (Genode::Path_base::Path_too_long) {
} catch (Path_base::Path_too_long) {
errno = ENAMETOOLONG;
throw Symlink_resolve_error();
}
@ -191,7 +191,7 @@ static void resolve_symlinks_except_last_element(char const *path, Absolute_path
absolute_path_last_element.keep_only_last_element();
try {
resolved_path.append_element(absolute_path_last_element.base());
} catch (Genode::Path_base::Path_too_long) {
} catch (Path_base::Path_too_long) {
errno = ENAMETOOLONG;
throw Symlink_resolve_error();
}
@ -233,10 +233,9 @@ extern "C" int chdir(const char *path)
*/
__SYS_(int, close, (int libc_fd),
{
Libc::File_descriptor *fd =
Libc::file_descriptor_allocator()->find_by_libc_fd(libc_fd);
File_descriptor *fd = file_descriptor_allocator()->find_by_libc_fd(libc_fd);
return (!fd || !fd->plugin)
? Libc::Errno(EBADF)
? Errno(EBADF)
: fd->plugin->close(fd);
})
@ -317,14 +316,13 @@ __SYS_(int, fstatat, (int libc_fd, char const *path, struct stat *buf, int flags
return stat(path, buf);
}
Libc::Absolute_path abs_path;
Absolute_path abs_path;
if (libc_fd == AT_FDCWD) {
abs_path = cwd();
abs_path.append_element(path);
} else {
Libc::File_descriptor *fd =
Libc::file_descriptor_allocator()->find_by_libc_fd(libc_fd);
File_descriptor *fd = file_descriptor_allocator()->find_by_libc_fd(libc_fd);
if (!fd) {
errno = EBADF;
return -1;
@ -398,7 +396,7 @@ __SYS_(void *, mmap, (void *addr, ::size_t length,
/* handle requests for anonymous memory */
if (!addr && libc_fd == -1) {
bool const executable = prot & PROT_EXEC;
void *start = Libc::mem_alloc(executable)->alloc(length, PAGE_SHIFT);
void *start = mem_alloc(executable)->alloc(length, PAGE_SHIFT);
if (!start) {
errno = ENOMEM;
return MAP_FAILED;
@ -410,7 +408,7 @@ __SYS_(void *, mmap, (void *addr, ::size_t length,
/* lookup plugin responsible for file descriptor */
File_descriptor *fd = libc_fd_to_fd(libc_fd, "mmap");
if (!fd || !fd->plugin || !fd->plugin->supports_mmap()) {
Genode::warning("mmap not supported for file descriptor ", libc_fd);
warning("mmap not supported for file descriptor ", libc_fd);
errno = EBADF;
return MAP_FAILED;
}
@ -424,7 +422,7 @@ __SYS_(void *, mmap, (void *addr, ::size_t length,
extern "C" int munmap(void *start, ::size_t length)
{
if (!mmap_registry()->registered(start)) {
Genode::warning("munmap: could not lookup plugin for address ", start);
warning("munmap: could not lookup plugin for address ", start);
errno = EINVAL;
return -1;
}
@ -442,8 +440,8 @@ extern "C" int munmap(void *start, ::size_t length)
else {
bool const executable = true;
/* XXX another metadata handling required to track anonymous memory */
Libc::mem_alloc(!executable)->free(start);
Libc::mem_alloc(executable)->free(start);
mem_alloc(!executable)->free(start);
mem_alloc(executable)->free(start);
}
mmap_registry()->remove(start);
@ -454,7 +452,7 @@ extern "C" int munmap(void *start, ::size_t length)
__SYS_(int, msync, (void *start, ::size_t len, int flags),
{
if (!mmap_registry()->registered(start)) {
Genode::warning("munmap: could not lookup plugin for address ", start);
warning("munmap: could not lookup plugin for address ", start);
errno = EINVAL;
return -1;
}
@ -503,13 +501,13 @@ __SYS_(int, open, (const char *pathname, int flags, ...),
plugin = plugin_registry()->get_plugin_for_open(resolved_path.base(), flags);
if (!plugin) {
Genode::error("no plugin found for open(\"", pathname, "\", ", flags, ")");
error("no plugin found for open(\"", pathname, "\", ", flags, ")");
return -1;
}
new_fdo = plugin->open(resolved_path.base(), flags);
if (!new_fdo) {
Genode::error("plugin()->open(\"", pathname, "\") failed");
error("plugin()->open(\"", pathname, "\") failed");
return -1;
}
new_fdo->path(resolved_path.base());
@ -530,14 +528,13 @@ __SYS_(int, openat, (int libc_fd, const char *path, int flags, ...),
return open(path, flags, mode);
}
Libc::Absolute_path abs_path;
Absolute_path abs_path;
if (libc_fd == AT_FDCWD) {
abs_path = cwd();
abs_path.append_element(path);
} else {
Libc::File_descriptor *fd =
Libc::file_descriptor_allocator()->find_by_libc_fd(libc_fd);
File_descriptor *fd = file_descriptor_allocator()->find_by_libc_fd(libc_fd);
if (!fd) {
errno = EBADF;
return -1;
@ -561,12 +558,12 @@ extern "C" int pipe2(int pipefd[2], int flags)
plugin = plugin_registry()->get_plugin_for_pipe();
if (!plugin) {
Genode::error("no plugin found for pipe()");
error("no plugin found for pipe()");
return -1;
}
if (plugin->pipe(pipefdo) == -1) {
Genode::error("plugin()->pipe() failed");
error("plugin()->pipe() failed");
return -1;
}
@ -574,7 +571,7 @@ extern "C" int pipe2(int pipefd[2], int flags)
int err = plugin->fcntl(pipefdo[0], F_SETFL, O_NONBLOCK)
| plugin->fcntl(pipefdo[1], F_SETFL, O_NONBLOCK);
if (err != 0)
Genode::warning("pipe plugin does not support O_NONBLOCK");
warning("pipe plugin does not support O_NONBLOCK");
}
pipefd[0] = pipefdo[0]->libc_fd;

56
repos/libports/src/lib/libc/fork.cc
View File

@ -39,23 +39,22 @@
#include <internal/suspend.h>
#include <internal/resume.h>
using namespace Genode;
using namespace Libc;
static pid_t fork_result;
static Env *_env_ptr;
static Allocator *_alloc_ptr;
static Libc::Suspend *_suspend_ptr;
static Libc::Resume *_resume_ptr;
static Libc::Kernel_routine_scheduler *_kernel_routine_scheduler_ptr;
static Heap *_malloc_heap_ptr;
static void *_user_stack_base_ptr;
static size_t _user_stack_size;
static int _pid;
static int _pid_cnt;
static Libc::Config_accessor const *_config_accessor_ptr;
static Env *_env_ptr;
static Allocator *_alloc_ptr;
static Suspend *_suspend_ptr;
static Resume *_resume_ptr;
static Kernel_routine_scheduler *_kernel_routine_scheduler_ptr;
static Heap *_malloc_heap_ptr;
static void *_user_stack_base_ptr;
static size_t _user_stack_size;
static int _pid;
static int _pid_cnt;
static Config_accessor const *_config_accessor_ptr;
void Libc::init_fork(Env &env, Config_accessor const &config_accessor,
@ -420,18 +419,18 @@ struct Libc::Forked_child : Child_policy, Child_ready
void _handle_exit() { _resume.resume_all(); }
Libc::Child_config _child_config;
Child_config _child_config;
Parent_services &_parent_services;
Local_rom_services &_local_rom_services;
Local_clone_service _local_clone_service;
Local_rom_service _config_rom_service;
struct Wait_fork_ready : Libc::Kernel_routine
struct Wait_fork_ready : Kernel_routine
{
Libc::Forked_child const &child;
Forked_child const &child;
Wait_fork_ready(Libc::Forked_child const &child) : child(child) { }
Wait_fork_ready(Forked_child const &child) : child(child) { }
void execute_in_kernel() override
{
@ -562,9 +561,9 @@ static void fork_kernel_routine()
abort();
}
Env &env = *_env_ptr;
Allocator &alloc = *_alloc_ptr;
Libc::Resume &resume = *_resume_ptr;
Env &env = *_env_ptr;
Allocator &alloc = *_alloc_ptr;
Resume &resume = *_resume_ptr;
pid_t const child_pid = ++_pid_cnt;
@ -573,15 +572,15 @@ static void fork_kernel_routine()
static Libc::Parent_services parent_services(env, alloc);
static Libc::Local_rom_services local_rom_services(env, fork_ep, alloc);
static Local_rom_services local_rom_services(env, fork_ep, alloc);
static Forked_children forked_children { };
_forked_children_ptr = &forked_children;
Registered<Libc::Forked_child> &child = *new (alloc)
Registered<Libc::Forked_child>(forked_children, env, fork_ep, alloc, resume,
child_pid, *_config_accessor_ptr,
parent_services, local_rom_services);
Registered<Forked_child> &child = *new (alloc)
Registered<Forked_child>(forked_children, env, fork_ep, alloc, resume,
child_pid, *_config_accessor_ptr,
parent_services, local_rom_services);
fork_result = child_pid;
@ -607,7 +606,7 @@ extern "C" pid_t __sys_fork(void)
_user_stack_base_ptr = (void *)mystack.base;
_user_stack_size = mystack.top - mystack.base;
struct Fork_kernel_routine : Libc::Kernel_routine
struct Fork_kernel_routine : Kernel_routine
{
void execute_in_kernel() override { fork_kernel_routine(); }
@ -619,7 +618,7 @@ extern "C" pid_t __sys_fork(void)
_kernel_routine_scheduler_ptr->register_kernel_routine(kernel_routine);
struct Suspend_functor_impl : Libc::Suspend_functor
struct Suspend_functor_impl : Suspend_functor
{
bool suspend() override { return false; }
@ -695,7 +694,6 @@ extern "C" pid_t __sys_wait4(pid_t pid, int *status, int options, rusage *rusage
pid_t result = -1;
int exit_code = 0; /* code and status */
using namespace Genode;
using namespace Libc;
if (!_forked_children_ptr) {
@ -703,7 +701,7 @@ extern "C" pid_t __sys_wait4(pid_t pid, int *status, int options, rusage *rusage
return -1;
}
struct Missing_call_of_init_fork : Genode::Exception { };
struct Missing_call_of_init_fork : Exception { };
if (!_suspend_ptr)
throw Missing_call_of_init_fork();

13
repos/libports/src/lib/libc/getpwent.cc
View File

@ -25,7 +25,9 @@
#include <internal/legacy.h>
#include <internal/errno.h>
typedef Genode::String<128> Passwd_string;
using namespace Libc;
typedef String<128> Passwd_string;
struct Passwd_fields {
Passwd_string name { "root" };
@ -46,14 +48,13 @@ struct Passwd_fields {
static void _fill_passwd(struct passwd &db, Passwd_fields &fields)
{
using namespace Genode;
/* reset buffers */
Genode::memset(&db, 0x00, sizeof(struct passwd));
::memset(&db, 0x00, sizeof(struct passwd));
fields = Passwd_fields();
try {
Xml_node const passwd = Libc::libc_config().sub_node("passwd");
Xml_node const passwd = libc_config().sub_node("passwd");
fields.name = passwd.attribute_value("name", fields.name);
fields.uid = passwd.attribute_value("uid", 0UL);
@ -88,8 +89,8 @@ static int _fill_r(struct passwd *in,
char *buffer, size_t bufsize,
struct passwd **out)
{
if (!in || !buffer) return Libc::Errno(EINVAL);
if (bufsize < sizeof(Passwd_fields)) return Libc::Errno(ERANGE);
if (!in || !buffer) return Errno(EINVAL);
if (bufsize < sizeof(Passwd_fields)) return Errno(ERANGE);
Passwd_fields *fields = (Passwd_fields *)buffer;
_fill_passwd(*in, *fields);

26
repos/libports/src/lib/libc/getrandom.cc
View File

@ -22,6 +22,7 @@ extern "C" {
/* libc-internal includes */
#include <internal/errno.h>
#include <internal/types.h>
/* Genode includes */
#include <trace/timestamp.h>
@ -30,8 +31,9 @@ extern "C" {
namespace Libc { extern char const *config_rng(); }
static
ssize_t read_rng(char *buf, size_t buflen)
using namespace Libc;
static ssize_t read_rng(char *buf, size_t buflen)
{
static int rng_fd { -1 };
static bool fallback { false };
@ -41,27 +43,27 @@ ssize_t read_rng(char *buf, size_t buflen)
while (off < buflen) {
/* collect 31 bits of random */
unsigned const nonce = random();
size_t n = Genode::min(4U, buflen-off);
memcpy(buf+off, &nonce, n);
size_t n = min(4U, buflen-off);
::memcpy(buf+off, &nonce, n);
off += n;
}
return buflen;
}
if (rng_fd == -1) {
if (!Genode::strcmp(Libc::config_rng(), "")) {
Genode::warning("Libc RNG not configured");
if (!::strcmp(config_rng(), "")) {
warning("Libc RNG not configured");
/* initialize the FreeBSD random facility */
srandom(Genode::Trace::timestamp()|1);
srandom(Trace::timestamp()|1);
fallback = true;
return read_rng(buf, buflen);
}
rng_fd = open(Libc::config_rng(), O_RDONLY);
rng_fd = open(config_rng(), O_RDONLY);
if (rng_fd == -1) {
Genode::error("RNG device ", Genode::Cstring(Libc::config_rng()), " not readable!");
error("RNG device ", Cstring(config_rng()), " not readable!");
exit(~0);
}
}
@ -76,7 +78,7 @@ getrandom(void *buf, size_t buflen, unsigned int flags)
size_t off = 0;
while (off < buflen && off < 256) {
ssize_t n = read_rng((char*)buf+off, buflen-off);
if (n < 1) return Libc::Errno(EIO);
if (n < 1) return Errno(EIO);
off += n;
}
return off;
@ -87,12 +89,12 @@ extern "C" int __attribute__((weak))
getentropy(void *buf, size_t buflen)
{
/* maximum permitted value for the length argument is 256 */
if (256 < buflen) return Libc::Errno(EIO);
if (256 < buflen) return Errno(EIO);
size_t off = 0;
while (off < buflen) {
ssize_t n = read_rng((char*)buf+off, buflen-off);
if (n < 1) return Libc::Errno(EIO);
if (n < 1) return Errno(EIO);
off += n;
}
return 0;

22
repos/libports/src/lib/libc/internal/clone_session.h
View File

@ -29,7 +29,7 @@ namespace Libc {
}
struct Libc::Clone_session : Genode::Session
struct Libc::Clone_session : Session
{
static const char *service_name() { return "Clone"; }
@ -43,25 +43,25 @@ struct Libc::Clone_session : Genode::Session
size_t size;
};
GENODE_RPC(Rpc_dataspace, Genode::Dataspace_capability, dataspace);
GENODE_RPC(Rpc_dataspace, Dataspace_capability, dataspace);
GENODE_RPC(Rpc_memory_content, void, memory_content, Memory_range);
GENODE_RPC_INTERFACE(Rpc_dataspace, Rpc_memory_content);
};
struct Libc::Clone_connection : Genode::Connection<Clone_session>,
Genode::Rpc_client<Clone_session>
struct Libc::Clone_connection : Connection<Clone_session>,
Rpc_client<Clone_session>
{
Genode::Attached_dataspace const _buffer;
Attached_dataspace const _buffer;
Clone_connection(Genode::Env &env)
:
Genode::Connection<Clone_session>(env,
session(env.parent(),
"ram_quota=%ld, cap_quota=%ld",
RAM_QUOTA, CAP_QUOTA)),
Genode::Rpc_client<Clone_session>(cap()),
Connection<Clone_session>(env,
session(env.parent(),
"ram_quota=%ld, cap_quota=%ld",
RAM_QUOTA, CAP_QUOTA)),
Rpc_client<Clone_session>(cap()),
_buffer(env.rm(), call<Rpc_dataspace>())
{ }
@ -75,7 +75,7 @@ struct Libc::Clone_connection : Genode::Connection<Clone_session>,
while (remaining > 0) {
size_t const chunk_len = Genode::min((size_t)BUFFER_SIZE, remaining);
size_t const chunk_len = min((size_t)BUFFER_SIZE, remaining);
/* instruct server to fill shared buffer */
call<Rpc_memory_content>(Memory_range{ ptr, chunk_len });

8
repos/libports/src/lib/libc/internal/cloned_malloc_heap_range.h
View File

@ -25,15 +25,15 @@ namespace Libc { struct Cloned_malloc_heap_range; }
struct Libc::Cloned_malloc_heap_range
{
Genode::Ram_allocator &ram;
Genode::Region_map &rm;
Ram_allocator &ram;
Region_map &rm;
Genode::Ram_dataspace_capability ds;
Ram_dataspace_capability ds;
size_t const size;
addr_t const local_addr;
Cloned_malloc_heap_range(Genode::Ram_allocator &ram, Genode::Region_map &rm,
Cloned_malloc_heap_range(Ram_allocator &ram, Region_map &rm,
void *start, size_t size)
try :
ram(ram), rm(rm), ds(ram.alloc(size)), size(size),

29
repos/libports/src/lib/libc/internal/env.h
View File

@ -32,40 +32,39 @@ class Libc::Env_implementation : public Libc::Env, public Config_accessor
Genode::Env &_env;
Genode::Attached_rom_dataspace _config { _env, "config" };
Attached_rom_dataspace _config { _env, "config" };
Genode::Xml_node _vfs_config()
Xml_node _vfs_config()
{
try { return _config.xml().sub_node("vfs"); }
catch (Genode::Xml_node::Nonexistent_sub_node) { }
catch (Xml_node::Nonexistent_sub_node) { }
try {
Genode::Xml_node node =
_config.xml().sub_node("libc").sub_node("vfs");
Genode::warning("'<config> <libc> <vfs/>' is deprecated, "
"please move to '<config> <vfs/>'");
Xml_node node = _config.xml().sub_node("libc").sub_node("vfs");
warning("'<config> <libc> <vfs/>' is deprecated, "
"please move to '<config> <vfs/>'");
return node;
}
catch (Genode::Xml_node::Nonexistent_sub_node) { }
catch (Xml_node::Nonexistent_sub_node) { }
return Genode::Xml_node("<vfs/>");
return Xml_node("<vfs/>");
}
Genode::Xml_node _libc_config()
Xml_node _libc_config()
{
try { return _config.xml().sub_node("libc"); }
catch (Genode::Xml_node::Nonexistent_sub_node) { }
catch (Xml_node::Nonexistent_sub_node) { }
return Genode::Xml_node("<libc/>");
return Xml_node("<libc/>");
}
Vfs::Simple_env _vfs_env;
Genode::Xml_node _config_xml() const override {
Xml_node _config_xml() const override {
return _config.xml(); };
public:
Env_implementation(Genode::Env &env, Genode::Allocator &alloc)
Env_implementation(Genode::Env &env, Allocator &alloc)
: _env(env), _vfs_env(_env, alloc, _vfs_config()) { }
@ -76,7 +75,7 @@ class Libc::Env_implementation : public Libc::Env, public Config_accessor
Vfs::File_system &vfs() override {
return _vfs_env.root_dir(); }
Genode::Xml_node libc_config() override {
Xml_node libc_config() override {
return _libc_config(); }

10
repos/libports/src/lib/libc/internal/init.h
View File

@ -78,7 +78,7 @@ namespace Libc {
/**
* Set libc config node
*/
void libc_config_init(Genode::Xml_node node);
void libc_config_init(Xml_node node);
/**
* Malloc allocator
@ -106,19 +106,19 @@ namespace Libc {
*/
void init_pthread_support(Genode::Env &env, Suspend &, Resume &);
struct Config_accessor : Genode::Interface
struct Config_accessor : Interface
{
virtual Genode::Xml_node config() const = 0;
virtual Xml_node config() const = 0;
};
/**
* Fork mechanism
*/
void init_fork(Genode::Env &, Config_accessor const &,
Genode::Allocator &heap, Genode::Heap &malloc_heap, int pid,
Genode::Allocator &heap, Heap &malloc_heap, int pid,
Suspend &, Resume &, Kernel_routine_scheduler &);
struct Reset_malloc_heap : Genode::Interface
struct Reset_malloc_heap : Interface
{
virtual void reset_malloc_heap() = 0;
};

6
repos/libports/src/lib/libc/internal/kernel.h
View File

@ -203,7 +203,7 @@ struct Libc::Kernel final : Vfs::Io_response_handler,
*
* This function is called by the main thread.
*/
static void _user_entry(Libc::Kernel *kernel)
static void _user_entry(Kernel *kernel)
{
struct Check : Suspend_functor {
bool suspend() override { return true; }
@ -305,7 +305,7 @@ struct Libc::Kernel final : Vfs::Io_response_handler,
*
* This function is called by the component thread on with_libc().
*/
void run(Libc::Application_code &app_code)
void run(Application_code &app_code)
{
if (!_main_context() || _state != KERNEL) {
error(__PRETTY_FUNCTION__, " called from non-kernel context");
@ -496,7 +496,7 @@ struct Libc::Kernel final : Vfs::Io_response_handler,
/**
* Execute application code while already executing in run()
*/
void nested_execution(Libc::Application_code &app_code)
void nested_execution(Application_code &app_code)
{
_nested_app_code = &app_code;

2
repos/libports/src/lib/libc/internal/legacy.h
View File

@ -47,7 +47,7 @@ namespace Libc {
/**
* Access libc configuration Xml_node.
*/
Genode::Xml_node libc_config();
Xml_node libc_config();
}
#endif /* _LIBC__INTERNAL__LEGACY_H_ */

16
repos/libports/src/lib/libc/internal/malloc_ram_allocator.h
View File

@ -22,21 +22,23 @@
namespace Libc { struct Malloc_ram_allocator; }
struct Libc::Malloc_ram_allocator : Genode::Ram_allocator
struct Libc::Malloc_ram_allocator : Ram_allocator
{
Genode::Allocator &_md_alloc;
Genode::Ram_allocator &_ram;
typedef Genode::Allocator Allocator;
Allocator &_md_alloc;
Ram_allocator &_ram;
struct Dataspace
{
Genode::Ram_dataspace_capability cap;
Dataspace(Genode::Ram_dataspace_capability cap) : cap(cap) { }
Ram_dataspace_capability cap;
Dataspace(Ram_dataspace_capability cap) : cap(cap) { }
virtual ~Dataspace() { }
};
Genode::Registry<Genode::Registered<Dataspace> > _dataspaces { };
Registry<Registered<Dataspace> > _dataspaces { };
void _release(Genode::Registered<Dataspace> &ds)
void _release(Registered<Dataspace> &ds)
{
_ram.free(ds.cap);
destroy(_md_alloc, &ds);

46
repos/libports/src/lib/libc/internal/mem_alloc.h
View File

@ -21,13 +21,16 @@
#include <util/list.h>
#include <rm_session/rm_session.h>
/* libc-internal includes */
#include <internal/types.h>
namespace Libc {
struct Mem_alloc
{
virtual void *alloc(Genode::size_t size, Genode::size_t align_log2) = 0;
virtual void *alloc(size_t size, size_t align_log2) = 0;
virtual void free(void *ptr) = 0;
virtual Genode::size_t size_at(void const *ptr) const = 0;
virtual size_t size_at(void const *ptr) const = 0;
};
/**
@ -44,14 +47,14 @@ namespace Libc {
MAX_CHUNK_SIZE = 1024*1024
};
class Dataspace : public Genode::List<Dataspace>::Element
class Dataspace : public List<Dataspace>::Element
{
public:
Genode::Ram_dataspace_capability cap;
Ram_dataspace_capability cap;
void *local_addr;
Dataspace(Genode::Ram_dataspace_capability c, void *a)
Dataspace(Ram_dataspace_capability c, void *a)
: cap(c), local_addr(a) {}
inline void * operator new(__SIZE_TYPE__, void* addr) {
@ -60,21 +63,21 @@ namespace Libc {
inline void operator delete(void*) { }
};
class Dataspace_pool : public Genode::List<Dataspace>
class Dataspace_pool : public List<Dataspace>
{
private:
Genode::Ram_allocator *_ram; /* ram session for backing store */
Genode::Region_map *_region_map; /* region map of address space */
bool const _executable; /* whether to allocate executable dataspaces */
Ram_allocator *_ram; /* RAM session for backing store */
Region_map *_region_map; /* region map of address space */
bool const _executable; /* whether to allocate executable dataspaces */
public:
/**
* Constructor
*/
Dataspace_pool(Genode::Ram_allocator *ram,
Genode::Region_map *rm, bool executable) :
Dataspace_pool(Ram_allocator *ram,
Region_map *rm, bool executable) :
_ram(ram), _region_map(rm),
_executable(executable)
{ }
@ -95,16 +98,16 @@ namespace Libc {
* Region_map::Region_conflict
* \return 0 on success or negative error code
*/
int expand(Genode::size_t size, Genode::Range_allocator *alloc);
int expand(size_t size, Range_allocator *alloc);
void reassign_resources(Genode::Ram_allocator *ram, Genode::Region_map *rm) {
void reassign_resources(Ram_allocator *ram, Region_map *rm) {
_ram = ram, _region_map = rm; }
};
Genode::Lock mutable _lock;
Dataspace_pool _ds_pool; /* list of dataspaces */
Genode::Allocator_avl _alloc; /* local allocator */
Genode::size_t _chunk_size;
Lock mutable _lock;
Dataspace_pool _ds_pool; /* list of dataspaces */
Allocator_avl _alloc; /* local allocator */
size_t _chunk_size;
/**
* Try to allocate block at our local allocator
@ -114,12 +117,11 @@ namespace Libc {
* This function is a utility used by 'alloc' to avoid
* code duplication.
*/
bool _try_local_alloc(Genode::size_t size, void **out_addr);
bool _try_local_alloc(size_t size, void **out_addr);
public:
Mem_alloc_impl(Genode::Region_map &rm,
Genode::Ram_allocator &ram,
Mem_alloc_impl(Region_map &rm, Ram_allocator &ram,
bool executable = false)
:
_ds_pool(&ram, &rm, executable),
@ -127,9 +129,9 @@ namespace Libc {
_chunk_size(MIN_CHUNK_SIZE)
{ }
void *alloc(Genode::size_t size, Genode::size_t align_log2);
void *alloc(size_t size, size_t align_log2);
void free(void *ptr);
Genode::size_t size_at(void const *ptr) const;
size_t size_at(void const *ptr) const;
};
}

27
repos/libports/src/lib/libc/internal/mmap_registry.h
View File

@ -24,6 +24,9 @@
#include <errno.h>
#include <libc-plugin/plugin.h>
/* libc-internal includes */
#include <internal/types.h>
namespace Libc {
class Mmap_registry;
@ -39,7 +42,7 @@ class Libc::Mmap_registry
{
public:
struct Entry : Genode::List<Entry>::Element
struct Entry : List<Entry>::Element
{
void * const start;
Plugin * const plugin;
@ -52,9 +55,9 @@ class Libc::Mmap_registry
Libc::Allocator _md_alloc;
Genode::List<Mmap_registry::Entry> _list;
List<Mmap_registry::Entry> _list;
Genode::Lock mutable _lock;
Lock mutable _lock;
/*
* Common for both const and non-const lookup functions
@ -81,13 +84,13 @@ class Libc::Mmap_registry
public:
void insert(void *start, Genode::size_t len, Plugin *plugin)
void insert(void *start, size_t len, Plugin *plugin)
{
Genode::Lock::Guard guard(_lock);
Lock::Guard guard(_lock);
if (_lookup_by_addr_unsynchronized(start)) {
Genode::warning(__func__, ": mmap region at ", start, " "
"is already registered");
warning(__func__, ": mmap region at ", start, " "
"is already registered");
return;
}
@ -96,7 +99,7 @@ class Libc::Mmap_registry
Plugin *lookup_plugin_by_addr(void *start) const
{
Genode::Lock::Guard guard(_lock);
Lock::Guard guard(_lock);
Entry const * const e = _lookup_by_addr_unsynchronized(start);
return e ? e->plugin : 0;
@ -104,20 +107,20 @@ class Libc::Mmap_registry
bool registered(void *start) const
{
Genode::Lock::Guard guard(_lock);
Lock::Guard guard(_lock);
return _lookup_by_addr_unsynchronized(start) != 0;
}
void remove(void *start)
{
Genode::Lock::Guard guard(_lock);
Lock::Guard guard(_lock);
Entry *e = _lookup_by_addr_unsynchronized(start);
if (!e) {
Genode::warning("lookup for address ", start, " "
"in in mmap registry failed");
warning("lookup for address ", start, " "
"in in mmap registry failed");
return;
}

70
repos/libports/src/lib/libc/internal/pthread.h
View File

@ -23,29 +23,39 @@
/* libc includes */
#include <pthread.h>
/* libc-internal includes */
#include <internal/types.h>
namespace Libc {
struct Pthread;
struct Pthread_registry;
}
/*
* Used by 'pthread_self()' to find out if the current thread is an alien
* thread.
*/
class Pthread_registry
class Libc::Pthread_registry
{
private:
enum { MAX_NUM_PTHREADS = 128 };
pthread_t _array[MAX_NUM_PTHREADS] = { 0 };
Pthread *_array[MAX_NUM_PTHREADS] = { 0 };
public:
void insert(pthread_t thread);
void insert(Pthread &thread);
void remove(pthread_t thread);
void remove(Pthread &thread);
bool contains(pthread_t thread);
bool contains(Pthread &thread);
};
Pthread_registry &pthread_registry();
Libc::Pthread_registry &pthread_registry();
extern "C" {
@ -69,7 +79,7 @@ struct Genode::Thread::Tls::Base
/**
* Register thread-local-storage object at Genode thread
*/
static void tls(Genode::Thread &thread, Tls::Base &tls)
static void tls(Thread &thread, Tls::Base &tls)
{
thread._tls = Tls { &tls };
}
@ -93,13 +103,13 @@ struct Genode::Thread::Tls::Base
};
struct pthread : Genode::Noncopyable, Genode::Thread::Tls::Base
struct Libc::Pthread : Noncopyable, Thread::Tls::Base
{
typedef void *(*start_routine_t) (void *);
private:
struct Thread_object : Genode::Thread
struct Thread_object : Thread
{
start_routine_t _start_routine;
void *_arg;
@ -107,16 +117,16 @@ struct pthread : Genode::Noncopyable, Genode::Thread::Tls::Base
void *&_stack_addr;
size_t &_stack_size;
enum { WEIGHT = Genode::Cpu_session::Weight::DEFAULT_WEIGHT };
enum { WEIGHT = Cpu_session::Weight::DEFAULT_WEIGHT };
/* 'stack_addr_out' and 'stack_size_out' are written when the thread starts */
Thread_object(char const *name, size_t stack_size,
Genode::Cpu_session *cpu,
Genode::Affinity::Location location,
Cpu_session *cpu,
Affinity::Location location,
start_routine_t start_routine, void *arg,
void *&stack_addr_out, size_t &stack_size_out)
:
Genode::Thread(WEIGHT, name, stack_size, Type::NORMAL, cpu, location),
Thread(WEIGHT, name, stack_size, Type::NORMAL, cpu, location),
_start_routine(start_routine), _arg(arg),
_stack_addr(stack_addr_out), _stack_size(stack_size_out)
{ }
@ -124,27 +134,27 @@ struct pthread : Genode::Noncopyable, Genode::Thread::Tls::Base
void entry() override;
};
Genode::Constructible<Thread_object> _thread_object;
Constructible<Thread_object> _thread_object;
/*
* Helper to construct '_thread_object' in class initializer
*/
template <typename... ARGS>
Genode::Thread &_construct_thread_object(ARGS &&... args)
Thread &_construct_thread_object(ARGS &&... args)
{
_thread_object.construct(args...);
return *_thread_object;
}
/*
* Refers to '_thread_object' or an external 'Genode::Thread' object
* Refers to '_thread_object' or an external 'Thread' object
*/
Genode::Thread &_thread;
Thread &_thread;
void _associate_thread_with_pthread()
{
Genode::Thread::Tls::Base::tls(_thread, *this);
pthread_registry().insert(this);
Thread::Tls::Base::tls(_thread, *this);
pthread_registry().insert(*this);
}
bool _exiting = false;
@ -155,11 +165,11 @@ struct pthread : Genode::Noncopyable, Genode::Thread::Tls::Base
* capability, which needs to be released before the thread can be
* destroyed.
*
* Also, we cannot use 'Genode::Thread::join()', because it only
* Also, we cannot use 'Thread::join()', because it only
* returns when the thread entry function returns, which does not
* happen with 'pthread_cancel()'.
*/
Genode::Lock _join_lock { Genode::Lock::LOCKED };
Lock _join_lock { Lock::LOCKED };
/* return value for 'pthread_join()' */
void *_retval = PTHREAD_CANCELED;
@ -173,9 +183,9 @@ struct pthread : Genode::Noncopyable, Genode::Thread::Tls::Base
/**
* Constructor for threads created via 'pthread_create'
*/
pthread(start_routine_t start_routine,
Pthread(start_routine_t start_routine,
void *arg, size_t stack_size, char const * name,
Genode::Cpu_session * cpu, Genode::Affinity::Location location)
Cpu_session * cpu, Affinity::Location location)
:
_thread(_construct_thread_object(name, stack_size, cpu, location,
start_routine, arg,
@ -188,21 +198,21 @@ struct pthread : Genode::Noncopyable, Genode::Thread::Tls::Base
* Constructor to create pthread object out of existing thread,
* i.e., the main thread
*/
pthread(Genode::Thread &existing_thread)
Pthread(Thread &existing_thread)
:
_thread(existing_thread)
{
/* obtain stack attributes of main thread */
Genode::Thread::Stack_info info = Genode::Thread::mystack();
Thread::Stack_info info = Thread::mystack();
_stack_addr = (void *)info.base;
_stack_size = info.top - info.base;
_associate_thread_with_pthread();
}
~pthread()
~Pthread()
{
pthread_registry().remove(this);
pthread_registry().remove(*this);
}
void start() { _thread.start(); }
@ -226,6 +236,12 @@ struct pthread : Genode::Noncopyable, Genode::Thread::Tls::Base
};
struct pthread : Libc::Pthread
{
using Libc::Pthread::Pthread;
};
namespace Libc { void init_pthread_support(Env &env); }
#endif /* _LIBC__INTERNAL__PTHREAD_H_ */

18
repos/libports/src/lib/libc/internal/pthread_pool.h
View File

@ -26,8 +26,8 @@ struct Libc::Pthread_pool
{
struct Pthread : Timeout_handler
{
Genode::Lock lock { Genode::Lock::LOCKED };
Pthread *next { nullptr };
Lock lock { Lock::LOCKED };
Pthread *next { nullptr };
Timer_accessor &_timer_accessor;
Constructible<Timeout> _timeout;
@ -38,7 +38,7 @@ struct Libc::Pthread_pool
_timeout.construct(_timer_accessor, *this);
}
Pthread(Timer_accessor &timer_accessor, Genode::uint64_t timeout_ms)
Pthread(Timer_accessor &timer_accessor, uint64_t timeout_ms)
: _timer_accessor(timer_accessor)
{
if (timeout_ms > 0) {
@ -47,7 +47,7 @@ struct Libc::Pthread_pool
}
}
Genode::uint64_t duration_left()
uint64_t duration_left()
{
_construct_timeout_once();
return _timeout->duration_left();
@ -59,7 +59,7 @@ struct Libc::Pthread_pool
}
};
Genode::Lock mutex;
Lock mutex;
Pthread *pthreads = nullptr;
Timer_accessor &timer_accessor;
@ -69,17 +69,17 @@ struct Libc::Pthread_pool
void resume_all()
{
Genode::Lock::Guard g(mutex);
Lock::Guard g(mutex);
for (Pthread *p = pthreads; p; p = p->next)
p->lock.unlock();
}
Genode::uint64_t suspend_myself(Suspend_functor & check, Genode::uint64_t timeout_ms)
uint64_t suspend_myself(Suspend_functor & check, uint64_t timeout_ms)
{
Pthread myself { timer_accessor, timeout_ms };
{
Genode::Lock::Guard g(mutex);
Lock::Guard g(mutex);
myself.next = pthreads;
pthreads = &myself;
@ -89,7 +89,7 @@ struct Libc::Pthread_pool
myself.lock.lock();
{
Genode::Lock::Guard g(mutex);
Lock::Guard g(mutex);
/* address of pointer to next pthread allows to change the head */
for (Pthread **next = &pthreads; *next; next = &(*next)->next) {

2
repos/libports/src/lib/libc/internal/suspend.h
View File

@ -29,8 +29,6 @@ namespace Libc {
struct Suspend : Interface
{
typedef Genode::uint64_t uint64_t;
/**
* Suspend the execution of the calling user context
*

8
repos/libports/src/lib/libc/internal/thread_create.h
View File

@ -22,13 +22,17 @@
/* libc includes */
#include <pthread.h>
/* libc-internal includes */
#include <internal/types.h>
namespace Libc {
int pthread_create(pthread_t *thread,
void *(*start_routine) (void *), void *arg,
size_t stack_size, char const * name,
Genode::Cpu_session * cpu, Genode::Affinity::Location location);
Cpu_session * cpu, Affinity::Location location);
int pthread_create(pthread_t *, Genode::Thread &);
int pthread_create(pthread_t *, Thread &);
}
#endif /* _LIBC__INTERNAL__THREAD_CREATE_H_ */

16
repos/libports/src/lib/libc/internal/timer.h
View File

@ -31,17 +31,17 @@ struct Libc::Timer
Timer(Genode::Env &env) : _timer(env) { }
Genode::Duration curr_time()
Duration curr_time()
{
return _timer.curr_time();
}
static Microseconds microseconds(Genode::uint64_t timeout_ms)
static Microseconds microseconds(uint64_t timeout_ms)
{
return Microseconds(1000*timeout_ms);
}
static Genode::uint64_t max_timeout()
static uint64_t max_timeout()
{
return ~0UL/1000;
}
@ -72,12 +72,12 @@ struct Libc::Timeout_handler
*/
struct Libc::Timeout
{
Libc::Timer_accessor &_timer_accessor;
Timer_accessor &_timer_accessor;
Timeout_handler &_handler;
::Timer::One_shot_timeout<Timeout> _timeout;
bool _expired = true;
Genode::uint64_t _absolute_timeout_ms = 0;
bool _expired = true;
uint64_t _absolute_timeout_ms = 0;
void _handle(Duration now)
{
@ -93,7 +93,7 @@ struct Libc::Timeout
_timeout(_timer_accessor.timer()._timer, *this, &Timeout::_handle)
{ }
void start(Genode::uint64_t timeout_ms)
void start(uint64_t timeout_ms)
{
Milliseconds const now = _timer_accessor.timer().curr_time().trunc_to_plain_ms();
@ -103,7 +103,7 @@ struct Libc::Timeout
_timeout.schedule(_timer_accessor.timer().microseconds(timeout_ms));
}
Genode::uint64_t duration_left() const
uint64_t duration_left() const
{
Milliseconds const now = _timer_accessor.timer().curr_time().trunc_to_plain_ms();

7
repos/libports/src/lib/libc/internal/types.h
View File

@ -16,6 +16,11 @@
#include <base/log.h>
namespace Libc { using namespace Genode; }
namespace Libc {
using namespace Genode;
typedef Genode::uint64_t uint64_t;
}
#endif /* _LIBC__INTERNAL__TYPES_H_ */

34
repos/libports/src/lib/libc/internal/vfs_plugin.h
View File

@ -35,7 +35,7 @@
namespace Libc { class Vfs_plugin; }
class Libc::Vfs_plugin : public Libc::Plugin
class Libc::Vfs_plugin : public Plugin
{
private:
@ -77,35 +77,35 @@ class Libc::Vfs_plugin : public Libc::Plugin
fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
struct timeval *timeout) override;
Libc::File_descriptor *open(const char *, int, int libc_fd);
File_descriptor *open(const char *, int, int libc_fd);
Libc::File_descriptor *open(const char *path, int flags) override
File_descriptor *open(const char *path, int flags) override
{
return open(path, flags, Libc::ANY_FD);
return open(path, flags, ANY_FD);
}
int access(char const *, int) override;
int close(Libc::File_descriptor *) override;
int dup2(Libc::File_descriptor *, Libc::File_descriptor *) override;
int fcntl(Libc::File_descriptor *, int, long) override;
int fstat(Libc::File_descriptor *, struct stat *) override;
int fstatfs(Libc::File_descriptor *, struct statfs *) override;
int fsync(Libc::File_descriptor *fd) override;
int ftruncate(Libc::File_descriptor *, ::off_t) override;
ssize_t getdirentries(Libc::File_descriptor *, char *, ::size_t , ::off_t *) override;
int ioctl(Libc::File_descriptor *, int , char *) override;
::off_t lseek(Libc::File_descriptor *fd, ::off_t offset, int whence) override;
int close(File_descriptor *) override;
int dup2(File_descriptor *, File_descriptor *) override;
int fcntl(File_descriptor *, int, long) override;
int fstat(File_descriptor *, struct stat *) override;
int fstatfs(File_descriptor *, struct statfs *) override;
int fsync(File_descriptor *fd) override;
int ftruncate(File_descriptor *, ::off_t) override;
ssize_t getdirentries(File_descriptor *, char *, ::size_t , ::off_t *) override;
int ioctl(File_descriptor *, int , char *) override;
::off_t lseek(File_descriptor *fd, ::off_t offset, int whence) override;
int mkdir(const char *, mode_t) override;
bool poll(File_descriptor &fdo, struct pollfd &pfd) override;
ssize_t read(Libc::File_descriptor *, void *, ::size_t) override;
ssize_t read(File_descriptor *, void *, ::size_t) override;
ssize_t readlink(const char *, char *, ::size_t) override;
int rename(const char *, const char *) override;
int rmdir(const char *) override;
int stat(const char *, struct stat *) override;
int symlink(const char *, const char *) override;
int unlink(const char *) override;
ssize_t write(Libc::File_descriptor *, const void *, ::size_t ) override;
void *mmap(void *, ::size_t, int, int, Libc::File_descriptor *, ::off_t) override;
ssize_t write(File_descriptor *, const void *, ::size_t ) override;
void *mmap(void *, ::size_t, int, int, File_descriptor *, ::off_t) override;
int munmap(void *, ::size_t) override;
int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) override;
};

22
repos/libports/src/lib/libc/kernel.cc
View File

@ -57,7 +57,7 @@ size_t Libc::Kernel::_user_stack_size()
void Libc::Kernel::schedule_suspend(void(*original_suspended_callback) ())
{
if (_state != USER) {
Genode::error(__PRETTY_FUNCTION__, " called from non-user context");
error(__PRETTY_FUNCTION__, " called from non-user context");
return;
}
@ -87,7 +87,7 @@ void Libc::Kernel::reset_malloc_heap()
destroy(_heap, &r); });
Heap &raw_malloc_heap = *_malloc_heap;
Genode::construct_at<Heap>(&raw_malloc_heap, *_malloc_ram, _env.rm());
construct_at<Heap>(&raw_malloc_heap, *_malloc_ram, _env.rm());
reinit_malloc(raw_malloc_heap);
}
@ -95,23 +95,23 @@ void Libc::Kernel::reset_malloc_heap()
void Libc::Kernel::_init_file_descriptors()
{
auto init_fd = [&] (Genode::Xml_node const &node, char const *attr,
auto init_fd = [&] (Xml_node const &node, char const *attr,
int libc_fd, unsigned flags)
{
if (!node.has_attribute(attr))
return;
typedef Genode::String<Vfs::MAX_PATH_LEN> Path;
typedef String<Vfs::MAX_PATH_LEN> Path;
Path const path = node.attribute_value(attr, Path());
struct stat out_stat { };
if (stat(path.string(), &out_stat) != 0)
return;
Libc::File_descriptor *fd = _vfs.open(path.string(), flags, libc_fd);
File_descriptor *fd = _vfs.open(path.string(), flags, libc_fd);
if (fd->libc_fd != libc_fd) {
Genode::error("could not allocate fd ",libc_fd," for ",path,", "
"got fd ",fd->libc_fd);
error("could not allocate fd ",libc_fd," for ",path,", "
"got fd ",fd->libc_fd);
_vfs.close(fd);
return;
}
@ -122,7 +122,7 @@ void Libc::Kernel::_init_file_descriptors()
* because we want to explicitly specify the libc fd ID.
*/
if (fd->fd_path)
Genode::warning("may leak former FD path memory");
warning("may leak former FD path memory");
{
char *dst = (char *)_heap.alloc(path.length());
@ -139,7 +139,7 @@ void Libc::Kernel::_init_file_descriptors()
Xml_node const node = _libc_env.libc_config();
typedef Genode::String<Vfs::MAX_PATH_LEN> Path;
typedef String<Vfs::MAX_PATH_LEN> Path;
if (node.has_attribute("cwd"))
chdir(node.attribute_value("cwd", Path()).string());
@ -166,7 +166,7 @@ void Libc::Kernel::_init_file_descriptors()
/* prevent use of IDs of stdin, stdout, and stderr for other files */
for (unsigned fd = 0; fd <= 2; fd++)
Libc::file_descriptor_allocator()->preserve(fd);
file_descriptor_allocator()->preserve(fd);
}
}
@ -270,7 +270,7 @@ void Libc::Kernel::handle_io_progress()
}
void Libc::execute_in_application_context(Libc::Application_code &app_code)
void Libc::execute_in_application_context(Application_code &app_code)
{
/*
* The libc execution model builds on the main entrypoint, which handles

17
repos/libports/src/lib/libc/libc_mem_alloc.cc
View File

@ -72,7 +72,7 @@ int Libc::Mem_alloc_impl::Dataspace_pool::expand(size_t size, Range_allocator *a
/* now that we have new backing store, allocate Dataspace structure */
if (alloc->alloc_aligned(sizeof(Dataspace), &ds_addr, 2).error()) {
Genode::warning("libc: could not allocate meta data - this should never happen");
warning("libc: could not allocate meta data - this should never happen");
return -1;
}
@ -114,7 +114,7 @@ void *Libc::Mem_alloc_impl::alloc(size_t size, size_t align_log2)
}
if (_ds_pool.expand(align_addr(request_size, 12), &_alloc) < 0) {
Genode::warning("libc: could not expand dataspace pool");
warning("libc: could not expand dataspace pool");
return 0;
}
@ -133,7 +133,7 @@ void Libc::Mem_alloc_impl::free(void *addr)
}
Genode::size_t Libc::Mem_alloc_impl::size_at(void const *addr) const
size_t Libc::Mem_alloc_impl::size_at(void const *addr) const
{
/* serialize access of heap functions */
Lock::Guard lock_guard(_lock);
@ -147,7 +147,7 @@ static Libc::Mem_alloc *_libc_mem_alloc_rw = nullptr;
static Libc::Mem_alloc *_libc_mem_alloc_rwx = nullptr;
static void _init_mem_alloc(Genode::Region_map &rm, Genode::Ram_allocator &ram)
static void _init_mem_alloc(Region_map &rm, Ram_allocator &ram)
{
enum { MEMORY_EXECUTABLE = true };
@ -159,12 +159,9 @@ static void _init_mem_alloc(Genode::Region_map &rm, Genode::Ram_allocator &ram)
}
namespace Libc {
void init_mem_alloc(Genode::Env &env)
{
_init_mem_alloc(env.rm(), env.ram());
}
void Libc::init_mem_alloc(Genode::Env &env)
{
_init_mem_alloc(env.rm(), env.ram());
}

17
repos/libports/src/lib/libc/malloc.cc
View File

@ -37,8 +37,6 @@ extern "C" {
namespace Libc {
class Slab_alloc;
class Malloc;
using namespace Genode;
}
@ -226,7 +224,10 @@ class Libc::Malloc
};
static Libc::Malloc *mallocator;
using namespace Libc;
static Malloc *mallocator;
extern "C" void *malloc(size_t size)
@ -263,16 +264,16 @@ extern "C" void *realloc(void *ptr, size_t size)
}
static Genode::Constructible<Libc::Malloc> &constructible_malloc()
static Genode::Constructible<Malloc> &constructible_malloc()
{
return *unmanaged_singleton<Genode::Constructible<Libc::Malloc> >();
return *unmanaged_singleton<Genode::Constructible<Malloc> >();
}
void Libc::init_malloc(Genode::Allocator &heap)
{
Genode::Constructible<Libc::Malloc> &_malloc = constructible_malloc();
Constructible<Malloc> &_malloc = constructible_malloc();
_malloc.construct(heap);
@ -290,7 +291,7 @@ void Libc::init_malloc_cloned(Clone_connection &clone_connection)
void Libc::reinit_malloc(Genode::Allocator &heap)
{
Libc::Malloc &malloc = *constructible_malloc();
Malloc &malloc = *constructible_malloc();
Genode::construct_at<Libc::Malloc>(&malloc, heap);
construct_at<Malloc>(&malloc, heap);
}

5
repos/libports/src/lib/libc/plugin.cc
View File

@ -23,11 +23,10 @@
#include <internal/init.h>
#include <internal/resume.h>
using namespace Genode;
using namespace Libc;
static Libc::Resume *_resume_ptr;
static Resume *_resume_ptr;
void Libc::init_plugin(Resume &resume)
@ -156,7 +155,7 @@ bool Plugin::supports_mmap()
#define DUMMY(ret_type, ret_val, name, args) \
ret_type Plugin::name args \
{ \
Genode::error(__func__, ": " #name " not implemented"); \
error(__func__, ": " #name " not implemented"); \
return ret_val; \
}

14
repos/libports/src/lib/libc/poll.cc
View File

@ -23,8 +23,10 @@
#include <internal/init.h>
#include <internal/suspend.h>
using namespace Libc;
static Libc::Suspend *_suspend_ptr;
static Suspend *_suspend_ptr;
void Libc::init_poll(Suspend &suspend)
@ -36,11 +38,11 @@ void Libc::init_poll(Suspend &suspend)
extern "C" __attribute__((weak))
int poll(struct pollfd fds[], nfds_t nfds, int timeout_ms)
{
using namespace Libc;
using Genode::uint64_t;
if (!fds || nfds == 0) return Errno(EINVAL);
struct Check : Libc::Suspend_functor
struct Check : Suspend_functor
{
pollfd *_fds;
nfds_t const _nfds;
@ -65,7 +67,7 @@ int poll(struct pollfd fds[], nfds_t nfds, int timeout_ms)
}
if (!libc_fd->plugin || !libc_fd->plugin->supports_poll()) {
Genode::warning("poll not supported for file descriptor ", pfd.fd);
warning("poll not supported for file descriptor ", pfd.fd);
continue;
}
@ -84,7 +86,7 @@ int poll(struct pollfd fds[], nfds_t nfds, int timeout_ms)
return check.nready;
}
auto suspend = [&] (Genode::uint64_t timeout_ms)
auto suspend = [&] (uint64_t timeout_ms)
{
struct Missing_call_of_init_poll : Exception { };
if (!_suspend_ptr)
@ -98,7 +100,7 @@ int poll(struct pollfd fds[], nfds_t nfds, int timeout_ms)
suspend(0);
}
} else {
Genode::uint64_t remaining_ms = timeout_ms;
uint64_t remaining_ms = timeout_ms;
while (check.nready == 0 && remaining_ms > 0) {
remaining_ms = suspend(remaining_ms);
}

12
repos/libports/src/lib/libc/pread_pwrite.cc
View File

@ -20,6 +20,9 @@
#include <sys/uio.h>
#include <unistd.h>
/* libc-internal includes */
#include <internal/types.h>
struct Read
{
@ -39,16 +42,19 @@ struct Write
};
using namespace Libc;
template <typename Rw_func, typename Buf_type>
static ssize_t pread_pwrite_impl(Rw_func rw_func, int fd, Buf_type buf, ::size_t count, ::off_t offset)
{
Libc::File_descriptor *fdesc = Libc::file_descriptor_allocator()->find_by_libc_fd(fd);
File_descriptor *fdesc = file_descriptor_allocator()->find_by_libc_fd(fd);
if (fdesc == 0)
return -1;
Genode::Lock_guard<Genode::Lock> rw_lock_guard(fdesc->lock);
Lock_guard<Lock> rw_lock_guard(fdesc->lock);
off_t old_offset = lseek(fd, 0, SEEK_CUR);
::off_t old_offset = lseek(fd, 0, SEEK_CUR);
if (old_offset == -1)
return -1;

71
repos/libports/src/lib/libc/pthread.cc
View File

@ -31,16 +31,16 @@
#include <internal/suspend.h>
#include <internal/resume.h>
using namespace Genode;
using namespace Libc;
static Env *_env_ptr; /* solely needed to spawn the timeout thread for the
timed semaphore */
static Genode::Env *_env_ptr; /* solely needed to spawn the timeout thread for the
timed semaphore */
static Thread *_main_thread_ptr;
static Libc::Suspend *_suspend_ptr;
static Libc::Resume *_resume_ptr;
static Suspend *_suspend_ptr;
static Resume *_resume_ptr;
void Libc::init_pthread_support(Genode::Env &env, Suspend &suspend, Resume &resume)
@ -58,15 +58,16 @@ static Libc::Timeout_entrypoint &_global_timeout_ep()
if (!_env_ptr)
throw Missing_call_of_init_pthread_support();
static Libc::Timeout_entrypoint timeout_ep { *_env_ptr };
static Timeout_entrypoint timeout_ep { *_env_ptr };
return timeout_ep;
}
/*
* pthread
*/
void pthread::Thread_object::entry()
/*************
** Pthread **
*************/
void Libc::Pthread::Thread_object::entry()
{
/* obtain stack attributes of new thread */
Thread::Stack_info info = Thread::mystack();
@ -77,15 +78,15 @@ void pthread::Thread_object::entry()
}
void pthread::join(void **retval)
void Libc::Pthread::join(void **retval)
{
struct Check : Libc::Suspend_functor
struct Check : Suspend_functor
{
bool retry { false };
pthread &_thread;
Pthread &_thread;
Check(pthread &thread) : _thread(thread) { }
Check(Pthread &thread) : _thread(thread) { }
bool suspend() override
{
@ -109,7 +110,7 @@ void pthread::join(void **retval)
}
void pthread::cancel()
void Libc::Pthread::cancel()
{
_exiting = true;
@ -127,49 +128,49 @@ void pthread::cancel()
* Registry
*/
void Pthread_registry::insert(pthread_t thread)
void Libc::Pthread_registry::insert(Pthread &thread)
{
/* prevent multiple insertions at the same location */
static Genode::Lock insert_lock;
Genode::Lock::Guard insert_lock_guard(insert_lock);
static Lock insert_lock;
Lock::Guard insert_lock_guard(insert_lock);
for (unsigned int i = 0; i < MAX_NUM_PTHREADS; i++) {
if (_array[i] == 0) {
_array[i] = thread;
_array[i] = &thread;
return;
}
}
Genode::error("pthread registry overflow, pthread_self() might fail");
error("pthread registry overflow, pthread_self() might fail");
}
void Pthread_registry::remove(pthread_t thread)
void Libc::Pthread_registry::remove(Pthread &thread)
{
for (unsigned int i = 0; i < MAX_NUM_PTHREADS; i++) {
if (_array[i] == thread) {
if (_array[i] == &thread) {
_array[i] = 0;
return;
}
}
Genode::error("could not remove unknown pthread from registry");
error("could not remove unknown pthread from registry");
}
bool Pthread_registry::contains(pthread_t thread)
bool Libc::Pthread_registry::contains(Pthread &thread)
{
for (unsigned int i = 0; i < MAX_NUM_PTHREADS; i++)
if (_array[i] == thread)
if (_array[i] == &thread)
return true;
return false;
}
Pthread_registry &pthread_registry()
Libc::Pthread_registry &pthread_registry()
{
static Pthread_registry instance;
static Libc::Pthread_registry instance;
return instance;
}
@ -224,7 +225,7 @@ extern "C" {
void pthread_exit(void *value_ptr)
{
pthread_self()->exit(value_ptr);
Genode::sleep_forever();
sleep_forever();
}
@ -241,7 +242,7 @@ extern "C" {
pthread_t pthread_myself =
static_cast<pthread_t>(&Thread::Tls::Base::tls());
if (pthread_registry().contains(pthread_myself))
if (pthread_registry().contains(*pthread_myself))
return pthread_myself;
}
catch (Thread::Tls::Base::Undefined) { }
@ -290,7 +291,7 @@ extern "C" {
stacksize = max_stack;
}
(*attr)->stack_size = Genode::align_addr(stacksize, 12);
(*attr)->stack_size = align_addr(stacksize, 12);
return 0;
}
@ -622,7 +623,7 @@ extern "C" {
int num_waiters;
int num_signallers;
Lock counter_lock;
Libc::Timed_semaphore signal_sem { _global_timeout_ep() };
Timed_semaphore signal_sem { _global_timeout_ep() };
Semaphore handshake_sem;
pthread_cond() : num_waiters(0), num_signallers(0) { }
@ -666,13 +667,13 @@ extern "C" {
static int cond_init(pthread_cond_t *__restrict cond,
const pthread_condattr_t *__restrict attr)
{
static Genode::Lock cond_init_lock { };
static Lock cond_init_lock { };
if (!cond)
return EINVAL;
try {
Genode::Lock::Guard g(cond_init_lock);
Lock::Guard g(cond_init_lock);
Libc::Allocator alloc { };
*cond = new (alloc) pthread_cond;
return 0;
@ -771,9 +772,9 @@ extern "C" {
try {
c->signal_sem.down(timeout);
} catch (Libc::Timeout_exception) {
} catch (Timeout_exception) {
result = ETIMEDOUT;
} catch (Libc::Nonblocking_exception) {
} catch (Nonblocking_exception) {
errno = ETIMEDOUT;
result = ETIMEDOUT;
}

4
repos/libports/src/lib/libc/pthread_create.cc
View File

@ -26,7 +26,7 @@
int Libc::pthread_create(pthread_t *thread,
void *(*start_routine) (void *), void *arg,
size_t stack_size, char const * name,
Genode::Cpu_session * cpu, Genode::Affinity::Location location)
Cpu_session * cpu, Affinity::Location location)
{
Libc::Allocator alloc { };
pthread_t thread_obj = new (alloc)
@ -43,7 +43,7 @@ int Libc::pthread_create(pthread_t *thread,
}
int Libc::pthread_create(pthread_t *thread, Genode::Thread &t)
int Libc::pthread_create(pthread_t *thread, Thread &t)
{
Libc::Allocator alloc { };
pthread_t thread_obj = new (alloc) pthread(t);

27
repos/libports/src/lib/libc/readv_writev.cc
View File

@ -22,28 +22,33 @@
#include <errno.h>
#include <stdio.h>
/* libc-internal includes */
#include <internal/types.h>
using namespace Libc;
struct Read
{
ssize_t operator()(int fd, void *buf, size_t count)
{
return read(fd, buf, count);
}
ssize_t operator()(int fd, void *buf, size_t count)
{
return read(fd, buf, count);
}
};
struct Write
{
ssize_t operator()(int fd, const void *buf, size_t count)
{
return write(fd, buf, count);
}
ssize_t operator()(int fd, const void *buf, size_t count)
{
return write(fd, buf, count);
}
};
static Genode::Lock &rw_lock()
static Lock &rw_lock()
{
static Genode::Lock rw_lock;
static Lock rw_lock;
return rw_lock;
}
@ -51,7 +56,7 @@ static Genode::Lock &rw_lock()
template <typename Rw_func>
static ssize_t readv_writev_impl(Rw_func rw_func, int fd, const struct iovec *iov, int iovcnt)
{
Genode::Lock_guard<Genode::Lock> rw_lock_guard(rw_lock());
Lock_guard<Lock> rw_lock_guard(rw_lock());
char *v;
ssize_t bytes_transfered_total = 0;

28
repos/libports/src/lib/libc/rwlock.cc
View File

@ -2,7 +2,6 @@
* \brief POSIX readers/writer lock (rwlock) implementation
* \author Alexander Senier
* \date 2018-01-25
*
*/
/*
@ -19,10 +18,15 @@
#include <base/thread.h>
#include <libc/allocator.h>
/* Libc includes */
/* libc includes */
#include <errno.h>
#include <pthread.h>
/* libc-internal includes */
#include <internal/types.h>
using namespace Libc;
/*
* A reader-preferring implementation of a readers-writer lock as described
@ -40,16 +44,16 @@ extern "C" {
{
private:
Genode::Thread *_owner = nullptr;
Genode::Lock _nbr_mutex {};
Genode::Lock _global_mutex {};
Thread *_owner = nullptr;
Lock _nbr_mutex {};
Lock _global_mutex {};
int _nbr = 0;
public:
void rdlock()
{
Genode::Lock_guard<Genode::Lock> guard(_nbr_mutex);
Lock_guard<Lock> guard(_nbr_mutex);
++_nbr;
if (_nbr == 1) {
_global_mutex.lock();
@ -60,14 +64,14 @@ extern "C" {
void wrlock()
{
_global_mutex.lock();
_owner = Genode::Thread::myself();
_owner = Thread::myself();
}
int unlock()
{
/* Read lock */
if (_owner == nullptr) {
Genode::Lock_guard<Genode::Lock> guard(_nbr_mutex);
Lock_guard<Lock> guard(_nbr_mutex);
_nbr--;
if (_nbr == 0) {
_owner = nullptr;
@ -76,8 +80,8 @@ extern "C" {
return 0;
};
if (_owner != Genode::Thread::myself()) {
Genode::error("Unlocking writer lock owned by other thread");
if (_owner != Thread::myself()) {
error("Unlocking writer lock owned by other thread");
errno = EPERM;
return -1;
};
@ -95,13 +99,13 @@ extern "C" {
static int rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr)
{
static Genode::Lock rwlock_init_lock { };
static Lock rwlock_init_lock { };
if (!rwlock)
return EINVAL;
try {
Genode::Lock::Guard g(rwlock_init_lock);
Lock::Guard g(rwlock_init_lock);
Libc::Allocator alloc { };
*rwlock = new (alloc) struct pthread_rwlock();
return 0;

46
repos/libports/src/lib/libc/select.cc
View File

@ -45,10 +45,12 @@ namespace Libc {
struct Select_cb_list;
}
using namespace Libc;
static Libc::Suspend *_suspend_ptr;
static Libc::Resume *_resume_ptr;
static Libc::Select *_select_ptr;
static Suspend *_suspend_ptr;
static Resume *_resume_ptr;
static Select *_select_ptr;
void Libc::init_select(Suspend &suspend, Resume &resume, Select &select)
@ -82,14 +84,14 @@ struct Libc::Select_cb
struct Libc::Select_cb_list
{
Genode::Lock _mutex;
Select_cb *_first = nullptr;
Lock _mutex;
Select_cb *_first = nullptr;
struct Guard : Genode::Lock::Guard
struct Guard : Lock::Guard
{
Select_cb_list *l;
Guard(Select_cb_list &list) : Genode::Lock::Guard(list._mutex), l(&list) { }
Guard(Select_cb_list &list) : Lock::Guard(list._mutex), l(&list) { }
};
void unsynchronized_insert(Select_cb *scb)
@ -130,7 +132,7 @@ struct Libc::Select_cb_list
/** The global list of tasks waiting for select */
static Libc::Select_cb_list &select_cb_list()
{
static Libc::Select_cb_list inst;
static Select_cb_list inst;
return inst;
}
@ -162,7 +164,7 @@ static int selscan(int nfds,
if (out_writefds) FD_ZERO(out_writefds);
if (out_exceptfds) FD_ZERO(out_exceptfds);
for (Libc::Plugin *plugin = Libc::plugin_registry()->first();
for (Plugin *plugin = plugin_registry()->first();
plugin;
plugin = plugin->next()) {
if (plugin->supports_select(nfds, in_readfds, in_writefds, in_exceptfds, &tv_0)) {
@ -187,7 +189,7 @@ static int selscan(int nfds,
}
nready += plugin_nready;
} else if (plugin_nready < 0) {
Genode::error("plugin->select() returned error value ", plugin_nready);
error("plugin->select() returned error value ", plugin_nready);
}
}
}
@ -205,7 +207,7 @@ static void select_notify()
/* check for each waiting select() function if one of its fds is ready now
* and if so, wake all up */
select_cb_list().for_each([&] (Libc::Select_cb &scb) {
select_cb_list().for_each([&] (Select_cb &scb) {
scb.nready = selscan(scb.nfds,
&scb.readfds, &scb.writefds, &scb.exceptfds,
&tmp_readfds, &tmp_writefds, &tmp_exceptfds);
@ -219,7 +221,7 @@ static void select_notify()
});
if (resume_all) {
struct Missing_call_of_init_select : Genode::Exception { };
struct Missing_call_of_init_select : Exception { };
if (!_resume_ptr)
throw Missing_call_of_init_select();
@ -228,7 +230,7 @@ static void select_notify()
}
static inline void print(Genode::Output &output, timeval *tv)
static inline void print(Output &output, timeval *tv)
{
if (!tv) {
print(output, "nullptr");
@ -248,7 +250,7 @@ int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
{
fd_set in_readfds, in_writefds, in_exceptfds;
Genode::Constructible<Libc::Select_cb> select_cb;
Constructible<Select_cb> select_cb;
/* initialize the select notification function pointer */
if (!libc_select_notify)
@ -263,7 +265,7 @@ int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
* We use the guard directly to atomically check if any descripor is
* ready, but insert into select-callback list otherwise.
*/
Libc::Select_cb_list::Guard guard(select_cb_list());
Select_cb_list::Guard guard(select_cb_list());
int const nready = selscan(nfds,
&in_readfds, &in_writefds, &in_exceptfds,
@ -296,11 +298,12 @@ int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
Timeout(timeval *tv) : _tv(tv) { }
} timeout { tv };
struct Check : Libc::Suspend_functor {
struct Timeout *timeout;
Libc::Select_cb *select_cb;
struct Check : Suspend_functor
{
struct Timeout *timeout;
Select_cb *select_cb;
Check(Timeout *timeout, Libc::Select_cb * select_cb)
Check(Timeout *timeout, Select_cb * select_cb)
: timeout(timeout), select_cb(select_cb) { }
bool suspend() override {
@ -308,7 +311,7 @@ int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds,
} check ( &timeout, &*select_cb );
{
struct Missing_call_of_init_select : Genode::Exception { };
struct Missing_call_of_init_select : Exception { };
if (!_suspend_ptr)
throw Missing_call_of_init_select();
}
@ -392,7 +395,7 @@ int Libc::Select_handler_base::select(int nfds, fd_set &readfds,
* We use the guard directly to atomically check is any descripor is
* ready, and insert into select-callback list otherwise.
*/
Libc::Select_cb_list::Guard guard(select_cb_list());
Select_cb_list::Guard guard(select_cb_list());
int const nready = selscan(nfds,
&in_readfds, &in_writefds, &in_exceptfds,
@ -440,5 +443,6 @@ Libc::Select_handler_base::Select_handler_base()
_select_cb((Select_handler_cb*)malloc(sizeof(*_select_cb)))
{ }
Libc::Select_handler_base::~Select_handler_base()
{ }

5
repos/libports/src/lib/libc/semaphore.cc
View File

@ -20,7 +20,10 @@
/* libc includes */
#include <libc/allocator.h>
using namespace Genode;
/* libc-internal includes */
#include <internal/types.h>
using namespace Libc;
extern "C" {

7
repos/libports/src/lib/libc/signal.cc
View File

@ -24,6 +24,11 @@ extern "C" {
/* Genode includes */
#include <base/log.h>
/* libc-internal includes */
#include <internal/types.h>
using namespace Libc;
extern "C" __attribute__((weak))
int sigprocmask(int how, const sigset_t *set, sigset_t *old_set)
@ -78,7 +83,7 @@ extern "C" pid_t _waitpid(pid_t pid, int *istat, int options) {
extern "C" __attribute__((weak))
pid_t wait6(idtype_t, id_t, int*, int, struct __wrusage*, siginfo_t*)
{
Genode::warning(__func__, " not implemented");
warning(__func__, " not implemented");
errno = ENOSYS;
return -1;
}

12
repos/libports/src/lib/libc/sleep.cc
View File

@ -19,8 +19,10 @@
#include <internal/suspend.h>
#include <internal/init.h>
using namespace Libc;
static Libc::Suspend *_suspend_ptr;
static Suspend *_suspend_ptr;
void Libc::init_sleep(Suspend &suspend)
@ -33,7 +35,7 @@ static void millisleep(Genode::uint64_t timeout_ms)
{
Genode::uint64_t remaining_ms = timeout_ms;
struct Missing_call_of_init_sleep : Genode::Exception { };
struct Missing_call_of_init_sleep : Exception { };
if (!_suspend_ptr)
throw Missing_call_of_init_sleep();
@ -51,7 +53,7 @@ static void millisleep(Genode::uint64_t timeout_ms)
extern "C" __attribute__((weak))
int nanosleep(const struct timespec *req, struct timespec *rem)
{
Genode::uint64_t sleep_ms = (uint64_t)req->tv_sec*1000;
Genode::uint64_t sleep_ms = (Genode::uint64_t)req->tv_sec*1000;
if (req->tv_nsec)
sleep_ms += req->tv_nsec / 1000000;
millisleep(sleep_ms);
@ -74,7 +76,7 @@ int clock_nanosleep(clockid_t clock_id, int flags,
if (flags & TIMER_ABSTIME) {
struct timespec now_ts { 0 };
if (clock_gettime(clock_id, &now_ts) != 0) {
Genode::error(__func__, ": RTC device not configured");
error(__func__, ": RTC device not configured");
return -1;
}
@ -99,7 +101,7 @@ int __sys_clock_nanosleep(clockid_t clock_id, int flags,
extern "C" __attribute__((weak))
unsigned int sleep(unsigned int seconds)
{
Genode::uint64_t sleep_ms = 1000 * (Genode::uint64_t)seconds;
Genode::uint64_t const sleep_ms = 1000 * (Genode::uint64_t)seconds;
millisleep(sleep_ms);
return 0;
}

172
repos/libports/src/lib/libc/socket_fs_plugin.cc
View File

@ -45,7 +45,7 @@
namespace Libc {
extern char const *config_socket();
bool read_ready(Libc::File_descriptor *);
bool read_ready(File_descriptor *);
}
@ -62,9 +62,7 @@ void Libc::init_socket_fs(Suspend &suspend)
** Utilities **
***************/
namespace Socket_fs {
using Libc::Errno;
namespace Libc { namespace Socket_fs {
struct Absolute_path : Vfs::Absolute_path
{
@ -83,7 +81,6 @@ namespace Socket_fs {
typedef String<NI_MAXSERV> Port_string;
struct Sockaddr_string;
struct Exception { };
struct New_socket_failed : Exception { };
struct Address_conversion_failed : Exception { };
@ -96,13 +93,13 @@ namespace Socket_fs {
Plugin & plugin();
enum { MAX_CONTROL_PATH_LEN = 16 };
}
} }
using namespace Socket_fs;
using namespace Libc::Socket_fs;
struct Socket_fs::Context : Libc::Plugin_context
struct Libc::Socket_fs::Context : Plugin_context
{
private:
@ -129,7 +126,7 @@ struct Socket_fs::Context : Libc::Plugin_context
struct Inaccessible { }; /* exception */
Absolute_path const path {
_read_socket_path().base(), Libc::config_socket() };
_read_socket_path().base(), config_socket() };
private:
@ -139,9 +136,9 @@ struct Socket_fs::Context : Libc::Plugin_context
struct
{
char const *name;
int num;
Libc::File_descriptor *file;
char const *name;
int num;
File_descriptor *file;
} _fd[Fd::MAX] = {
{ "data", -1, nullptr },
{ "connect", -1, nullptr }, { "bind", -1, nullptr },
@ -169,11 +166,11 @@ struct Socket_fs::Context : Libc::Plugin_context
Absolute_path file(_fd[type].name, path.base());
int const fd = open(file.base(), flags|_fd_flags);
if (fd == -1) {
Genode::error(__func__, ": ", _fd[type].name, " file not accessible at ", file);
error(__func__, ": ", _fd[type].name, " file not accessible at ", file);
throw Inaccessible();
}
_fd[type].num = fd;
_fd[type].file = Libc::file_descriptor_allocator()->find_by_libc_fd(fd);
_fd[type].file = file_descriptor_allocator()->find_by_libc_fd(fd);
}
return _fd[type].num;
@ -252,10 +249,12 @@ struct Socket_fs::Context : Libc::Plugin_context
sizeof(connect_status));
if (connect_status_len <= 0) {
Genode::error("socket_fs: reading from the connect file failed");
error("socket_fs: reading from the connect file failed");
return -1;
}
using ::strcmp;
if (strcmp(connect_status, "connected") == 0)
return 0;
@ -265,13 +264,13 @@ struct Socket_fs::Context : Libc::Plugin_context
if (strcmp(connect_status, "not connected") == 0)
return Errno(ENOTCONN);
Genode::error("socket_fs: unhandled connection state");
error("socket_fs: unhandled connection state");
return Errno(ECONNREFUSED);
}
};
struct Socket_fs::Sockaddr_functor : Libc::Suspend_functor
struct Libc::Socket_fs::Sockaddr_functor : Suspend_functor
{
Socket_fs::Context &context;
bool const nonblocking;
@ -283,7 +282,7 @@ struct Socket_fs::Sockaddr_functor : Libc::Suspend_functor
};
struct Socket_fs::Remote_functor : Socket_fs::Sockaddr_functor
struct Libc::Socket_fs::Remote_functor : Sockaddr_functor
{
Remote_functor(Socket_fs::Context &context, bool nonblocking)
: Sockaddr_functor(context, nonblocking) { }
@ -293,9 +292,9 @@ struct Socket_fs::Remote_functor : Socket_fs::Sockaddr_functor
};
struct Socket_fs::Local_functor : Socket_fs::Sockaddr_functor
struct Libc::Socket_fs::Local_functor : Sockaddr_functor
{
Local_functor(Socket_fs::Context &context, bool nonblocking)
Local_functor(Context &context, bool nonblocking)
: Sockaddr_functor(context, nonblocking) { }
bool suspend() override { return !nonblocking && !context.local_read_ready(); }
@ -303,22 +302,22 @@ struct Socket_fs::Local_functor : Socket_fs::Sockaddr_functor
};
struct Socket_fs::Plugin : Libc::Plugin
struct Libc::Socket_fs::Plugin : Libc::Plugin
{
bool supports_poll() override { return true; }
bool supports_select(int, fd_set *, fd_set *, fd_set *, timeval *) override;
ssize_t read(Libc::File_descriptor *, void *, ::size_t) override;
ssize_t write(Libc::File_descriptor *, const void *, ::size_t) override;
int fcntl(Libc::File_descriptor *, int, long) override;
int close(Libc::File_descriptor *) override;
bool poll(Libc::File_descriptor &fd, struct pollfd &pfd) override;
ssize_t read(File_descriptor *, void *, ::size_t) override;
ssize_t write(File_descriptor *, const void *, ::size_t) override;
int fcntl(File_descriptor *, int, long) override;
int close(File_descriptor *) override;
bool poll(File_descriptor &fd, struct pollfd &pfd) override;
int select(int, fd_set *, fd_set *, fd_set *, timeval *) override;
int ioctl(Libc::File_descriptor *, int, char *) override;
int ioctl(File_descriptor *, int, char *) override;
};
template <int CAPACITY> class Socket_fs::String
template <int CAPACITY> class Libc::Socket_fs::String
{
private:
@ -349,7 +348,7 @@ template <int CAPACITY> class Socket_fs::String
* Both NI_MAXHOST and NI_MAXSERV include the terminating 0, which allows
* use to put ':' between host and port on concatenation.
*/
struct Socket_fs::Sockaddr_string : String<NI_MAXHOST + NI_MAXSERV>
struct Libc::Socket_fs::Sockaddr_string : String<NI_MAXHOST + NI_MAXSERV>
{
Sockaddr_string() { }
@ -389,6 +388,9 @@ struct Socket_fs::Sockaddr_string : String<NI_MAXHOST + NI_MAXSERV>
};
using namespace Libc;
static Port_string port_string(sockaddr_in const &addr)
{
Port_string port;
@ -422,7 +424,7 @@ static sockaddr_in sockaddr_in_struct(Host_string const &host, Port_string const
addrinfo hints;
addrinfo *info = nullptr;
memset(&hints, 0, sizeof(hints));
::memset(&hints, 0, sizeof(hints));
hints.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV;
if (getaddrinfo(host.base(), port.base(), &hints, &info))
@ -468,12 +470,12 @@ static int read_sockaddr_in(Socket_fs::Sockaddr_functor &func,
try {
/* convert the address but do not exceed the caller's buffer */
sockaddr_in saddr = sockaddr_in_struct(addr_string.host(), addr_string.port());
memcpy(addr, &saddr, *addrlen);
::memcpy(addr, &saddr, *addrlen);
*addrlen = sizeof(saddr);
return 0;
} catch (Address_conversion_failed) {
Genode::warning("IP address conversion failed");
warning("IP address conversion failed");
return Errno(ENOBUFS);
}
}
@ -485,7 +487,7 @@ static int read_sockaddr_in(Socket_fs::Sockaddr_functor &func,
extern "C" int socket_fs_getpeername(int libc_fd, sockaddr *addr, socklen_t *addrlen)
{
Libc::File_descriptor *fd = Libc::file_descriptor_allocator()->find_by_libc_fd(libc_fd);
File_descriptor *fd = file_descriptor_allocator()->find_by_libc_fd(libc_fd);
if (!fd) return Errno(EBADF);
Socket_fs::Context *context = dynamic_cast<Socket_fs::Context *>(fd->context);
@ -506,7 +508,7 @@ extern "C" int socket_fs_getpeername(int libc_fd, sockaddr *addr, socklen_t *add
extern "C" int socket_fs_getsockname(int libc_fd, sockaddr *addr, socklen_t *addrlen)
{
Libc::File_descriptor *fd = Libc::file_descriptor_allocator()->find_by_libc_fd(libc_fd);
File_descriptor *fd = file_descriptor_allocator()->find_by_libc_fd(libc_fd);
if (!fd) return Errno(EBADF);
Socket_fs::Context *context = dynamic_cast<Socket_fs::Context *>(fd->context);
@ -523,7 +525,7 @@ extern "C" int socket_fs_getsockname(int libc_fd, sockaddr *addr, socklen_t *add
extern "C" int socket_fs_accept(int libc_fd, sockaddr *addr, socklen_t *addrlen)
{
Libc::File_descriptor *fd = Libc::file_descriptor_allocator()->find_by_libc_fd(libc_fd);
File_descriptor *fd = file_descriptor_allocator()->find_by_libc_fd(libc_fd);
if (!fd) return Errno(EBADF);
Socket_fs::Context *listen_context = dynamic_cast<Socket_fs::Context *>(fd->context);
@ -545,12 +547,12 @@ extern "C" int socket_fs_accept(int libc_fd, sockaddr *addr, socklen_t *addrlen)
return Errno(EINVAL);
}
Absolute_path path = listen_context->path;
Socket_fs::Absolute_path path = listen_context->path;
path.append("/accept_socket");
int handle_fd = ::open(path.base(), O_RDONLY);
if (handle_fd < 0) {
Genode::error("failed to open accept socket at ", path);
error("failed to open accept socket at ", path);
return Errno(EACCES);
}
@ -561,8 +563,8 @@ extern "C" int socket_fs_accept(int libc_fd, sockaddr *addr, socklen_t *addrlen)
Socket_fs::Context(listen_context->proto(), handle_fd);
} catch (New_socket_failed) { return Errno(EACCES); }
Libc::File_descriptor *accept_fd =
Libc::file_descriptor_allocator()->alloc(&plugin(), accept_context);
File_descriptor *accept_fd =
file_descriptor_allocator()->alloc(&plugin(), accept_context);
/* inherit the O_NONBLOCK flag if set */
accept_context->fd_flags(listen_context->fd_flags());
@ -579,7 +581,7 @@ extern "C" int socket_fs_accept(int libc_fd, sockaddr *addr, socklen_t *addrlen)
extern "C" int socket_fs_bind(int libc_fd, sockaddr const *addr, socklen_t addrlen)
{
Libc::File_descriptor *fd = Libc::file_descriptor_allocator()->find_by_libc_fd(libc_fd);
File_descriptor *fd = file_descriptor_allocator()->find_by_libc_fd(libc_fd);
if (!fd) return Errno(EBADF);
Socket_fs::Context *context = dynamic_cast<Socket_fs::Context *>(fd->context);
@ -588,7 +590,7 @@ extern "C" int socket_fs_bind(int libc_fd, sockaddr const *addr, socklen_t addrl
if (!addr) return Errno(EFAULT);
if (addr->sa_family != AF_INET) {
Genode::error(__func__, ": family not supported");
error(__func__, ": family not supported");
return Errno(EAFNOSUPPORT);
}
@ -601,7 +603,7 @@ extern "C" int socket_fs_bind(int libc_fd, sockaddr const *addr, socklen_t addrl
catch (Address_conversion_failed) { return Errno(EINVAL); }
try {
int const len = strlen(addr_string.base());
int const len = ::strlen(addr_string.base());
int const n = write(context->bind_fd(), addr_string.base(), len);
if (n != len) return Errno(EACCES);
@ -615,7 +617,7 @@ extern "C" int socket_fs_bind(int libc_fd, sockaddr const *addr, socklen_t addrl
extern "C" int socket_fs_connect(int libc_fd, sockaddr const *addr, socklen_t addrlen)
{
Libc::File_descriptor *fd = Libc::file_descriptor_allocator()->find_by_libc_fd(libc_fd);
File_descriptor *fd = file_descriptor_allocator()->find_by_libc_fd(libc_fd);
if (!fd) return Errno(EBADF);
Socket_fs::Context *context = dynamic_cast<Socket_fs::Context *>(fd->context);
@ -643,7 +645,7 @@ extern "C" int socket_fs_connect(int libc_fd, sockaddr const *addr, socklen_t ad
context->state(Context::CONNECTING);
int const len = strlen(addr_string.base());
int const len = ::strlen(addr_string.base());
int const n = write(context->connect_fd(), addr_string.base(), len);
if (n != len) return Errno(ECONNREFUSED);
@ -711,14 +713,14 @@ extern "C" int socket_fs_connect(int libc_fd, sockaddr const *addr, socklen_t ad
extern "C" int socket_fs_listen(int libc_fd, int backlog)
{
Libc::File_descriptor *fd = Libc::file_descriptor_allocator()->find_by_libc_fd(libc_fd);
File_descriptor *fd = file_descriptor_allocator()->find_by_libc_fd(libc_fd);
if (!fd) return Errno(EBADF);
Socket_fs::Context *context = dynamic_cast<Socket_fs::Context *>(fd->context);
if (!context) return Errno(ENOTSOCK);
char buf[MAX_CONTROL_PATH_LEN];
int const len = snprintf(buf, sizeof(buf), "%d", backlog);
int const len = ::snprintf(buf, sizeof(buf), "%d", backlog);
int const n = write(context->listen_fd(), buf, len);
if (n != len) return Errno(EOPNOTSUPP);
@ -731,7 +733,7 @@ extern "C" int socket_fs_listen(int libc_fd, int backlog)
}
static ssize_t do_recvfrom(Libc::File_descriptor *fd,
static ssize_t do_recvfrom(File_descriptor *fd,
void *buf, ::size_t len, int flags,
struct sockaddr *src_addr, socklen_t *src_addrlen)
{
@ -762,7 +764,7 @@ static ssize_t do_recvfrom(Libc::File_descriptor *fd,
extern "C" ssize_t socket_fs_recvfrom(int libc_fd, void *buf, ::size_t len, int flags,
sockaddr *src_addr, socklen_t *src_addrlen)
{
Libc::File_descriptor *fd = Libc::file_descriptor_allocator()->find_by_libc_fd(libc_fd);
File_descriptor *fd = file_descriptor_allocator()->find_by_libc_fd(libc_fd);
if (!fd) return Errno(EBADF);
return do_recvfrom(fd, buf, len, flags, src_addr, src_addrlen);
@ -778,12 +780,12 @@ extern "C" ssize_t socket_fs_recv(int libc_fd, void *buf, ::size_t len, int flag
extern "C" ssize_t socket_fs_recvmsg(int libc_fd, msghdr *msg, int flags)
{
Genode::warning("########## TODO ########## ", __func__);
warning("########## TODO ########## ", __func__);
return 0;
}
static ssize_t do_sendto(Libc::File_descriptor *fd,
static ssize_t do_sendto(File_descriptor *fd,
void const *buf, ::size_t len, int flags,
sockaddr const *dest_addr, socklen_t dest_addrlen)
{
@ -801,7 +803,7 @@ static ssize_t do_sendto(Libc::File_descriptor *fd,
Sockaddr_string addr_string(host_string(*(sockaddr_in const *)dest_addr),
port_string(*(sockaddr_in const *)dest_addr));
int const len = strlen(addr_string.base());
int const len = ::strlen(addr_string.base());
int const n = write(context->remote_fd(), addr_string.base(), len);
if (n != len) return Errno(EIO);
}
@ -826,7 +828,7 @@ static ssize_t do_sendto(Libc::File_descriptor *fd,
extern "C" ssize_t socket_fs_sendto(int libc_fd, void const *buf, ::size_t len, int flags,
sockaddr const *dest_addr, socklen_t dest_addrlen)
{
Libc::File_descriptor *fd = Libc::file_descriptor_allocator()->find_by_libc_fd(libc_fd);
File_descriptor *fd = file_descriptor_allocator()->find_by_libc_fd(libc_fd);
if (!fd) return Errno(EBADF);
return do_sendto(fd, buf, len, flags, dest_addr, dest_addrlen);
@ -843,7 +845,7 @@ extern "C" ssize_t socket_fs_send(int libc_fd, void const *buf, ::size_t len, in
extern "C" int socket_fs_getsockopt(int libc_fd, int level, int optname,
void *optval, socklen_t *optlen)
{
Libc::File_descriptor *fd = Libc::file_descriptor_allocator()->find_by_libc_fd(libc_fd);
File_descriptor *fd = file_descriptor_allocator()->find_by_libc_fd(libc_fd);
if (!fd) return Errno(EBADF);
Socket_fs::Context *context = dynamic_cast<Socket_fs::Context *>(fd->context);
@ -894,7 +896,7 @@ extern "C" int socket_fs_getsockopt(int libc_fd, int level, int optname,
extern "C" int socket_fs_setsockopt(int libc_fd, int level, int optname,
void const *optval, socklen_t optlen)
{
Libc::File_descriptor *fd = Libc::file_descriptor_allocator()->find_by_libc_fd(libc_fd);
File_descriptor *fd = file_descriptor_allocator()->find_by_libc_fd(libc_fd);
if (!fd) return Errno(EBADF);
Socket_fs::Context *context = dynamic_cast<Socket_fs::Context *>(fd->context);
@ -930,7 +932,7 @@ extern "C" int socket_fs_setsockopt(int libc_fd, int level, int optname,
extern "C" int socket_fs_shutdown(int libc_fd, int how)
{
Libc::File_descriptor *fd = Libc::file_descriptor_allocator()->find_by_libc_fd(libc_fd);
File_descriptor *fd = file_descriptor_allocator()->find_by_libc_fd(libc_fd);
if (!fd) return Errno(EBADF);
Socket_fs::Context *context = dynamic_cast<Socket_fs::Context *>(fd->context);
@ -946,18 +948,18 @@ extern "C" int socket_fs_shutdown(int libc_fd, int how)
extern "C" int socket_fs_socket(int domain, int type, int protocol)
{
Absolute_path path(Libc::config_socket());
Socket_fs::Absolute_path path(config_socket());
if (path == "") {
Genode::error(__func__, ": socket fs not mounted");
error(__func__, ": socket fs not mounted");
return Errno(EACCES);
}
if (((type&7) != SOCK_STREAM || (protocol != 0 && protocol != IPPROTO_TCP))
&& ((type&7) != SOCK_DGRAM || (protocol != 0 && protocol != IPPROTO_UDP))) {
Genode::error(__func__,
": socket with type=", (Genode::Hex)type,
" protocol=", (Genode::Hex)protocol, " not supported");
error(__func__,
": socket with type=", (Hex)type,
" protocol=", (Hex)protocol, " not supported");
return Errno(EAFNOSUPPORT);
}
@ -974,7 +976,7 @@ extern "C" int socket_fs_socket(int domain, int type, int protocol)
path.append("/new_socket");
int handle_fd = ::open(path.base(), O_RDONLY);
if (handle_fd < 0) {
Genode::error("failed to open new socket at ", path);
error("failed to open new socket at ", path);
return Errno(EACCES);
}
Libc::Allocator alloc { };
@ -982,14 +984,13 @@ extern "C" int socket_fs_socket(int domain, int type, int protocol)
Socket_fs::Context(proto, handle_fd);
} catch (New_socket_failed) { return Errno(EACCES); }
Libc::File_descriptor *fd =
Libc::file_descriptor_allocator()->alloc(&plugin(), context);
File_descriptor *fd = file_descriptor_allocator()->alloc(&plugin(), context);
return fd->libc_fd;
}
static int read_ifaddr_file(sockaddr_in &sockaddr, Absolute_path const &path)
static int read_ifaddr_file(sockaddr_in &sockaddr, Socket_fs::Absolute_path const &path)
{
Host_string address;
Port_string service;
@ -1012,8 +1013,8 @@ static int read_ifaddr_file(sockaddr_in &sockaddr, Absolute_path const &path)
extern "C" int getifaddrs(struct ifaddrs **ifap)
{
static Genode::Lock lock;
Genode::Lock::Guard guard(lock);
static Lock lock;
Lock::Guard guard(lock);
// TODO: dual-stack / multi-homing
@ -1032,7 +1033,9 @@ extern "C" int getifaddrs(struct ifaddrs **ifap)
*ifap = &ifaddr;
Absolute_path const root(Libc::config_socket());
using Socket_fs::Absolute_path;
Absolute_path const root(config_socket());
if (read_ifaddr_file(address, Absolute_path("address", root.base())))
return -1;
@ -1049,7 +1052,7 @@ extern "C" void freeifaddrs(struct ifaddrs *) { }
** File-plugin operations **
****************************/
int Socket_fs::Plugin::fcntl(Libc::File_descriptor *fd, int cmd, long arg)
int Socket_fs::Plugin::fcntl(File_descriptor *fd, int cmd, long arg)
{
Socket_fs::Context *context = dynamic_cast<Socket_fs::Context *>(fd->context);
if (!context) return Errno(EBADF);
@ -1061,12 +1064,12 @@ int Socket_fs::Plugin::fcntl(Libc::File_descriptor *fd, int cmd, long arg)
context->fd_flags(arg);
return 0;
default:
Genode::error(__func__, " command ", cmd, " not supported on sockets");
error(__func__, " command ", cmd, " not supported on sockets");
return Errno(EINVAL);
}
}
ssize_t Socket_fs::Plugin::read(Libc::File_descriptor *fd, void *buf, ::size_t count)
ssize_t Socket_fs::Plugin::read(File_descriptor *fd, void *buf, ::size_t count)
{
ssize_t const ret = do_recvfrom(fd, buf, count, 0, nullptr, nullptr);
if (ret != -1) return ret;
@ -1078,7 +1081,7 @@ ssize_t Socket_fs::Plugin::read(Libc::File_descriptor *fd, void *buf, ::size_t c
}
ssize_t Socket_fs::Plugin::write(Libc::File_descriptor *fd, const void *buf, ::size_t count)
ssize_t Socket_fs::Plugin::write(File_descriptor *fd, const void *buf, ::size_t count)
{
ssize_t const ret = do_sendto(fd, buf, count, 0, nullptr, 0);
@ -1091,8 +1094,7 @@ ssize_t Socket_fs::Plugin::write(Libc::File_descriptor *fd, const void *buf, ::s
}
bool Socket_fs::Plugin::poll(Libc::File_descriptor &fdo,
struct pollfd &pfd)
bool Socket_fs::Plugin::poll(File_descriptor &fdo, struct pollfd &pfd)
{
if (fdo.plugin != this) return false;
Socket_fs::Context *context { nullptr };
@ -1135,8 +1137,7 @@ bool Socket_fs::Plugin::supports_select(int nfds,
for (int fd = 0; fd < nfds; ++fd) {
if (FD_ISSET(fd, readfds) || FD_ISSET(fd, writefds) || FD_ISSET(fd, exceptfds)) {
Libc::File_descriptor *fdo =
Libc::file_descriptor_allocator()->find_by_libc_fd(fd);
File_descriptor *fdo = file_descriptor_allocator()->find_by_libc_fd(fd);
if (fdo && (fdo->plugin == this))
return true;
@ -1164,8 +1165,7 @@ int Socket_fs::Plugin::select(int nfds,
for (int fd = 0; fd < nfds; ++fd) {
Libc::File_descriptor *fdo =
Libc::file_descriptor_allocator()->find_by_libc_fd(fd);
File_descriptor *fdo = file_descriptor_allocator()->find_by_libc_fd(fd);
/* handle only fds that belong to this plugin */
if (!fdo || (fdo->plugin != this))
@ -1200,14 +1200,14 @@ int Socket_fs::Plugin::select(int nfds,
}
int Socket_fs::Plugin::close(Libc::File_descriptor *fd)
int Socket_fs::Plugin::close(File_descriptor *fd)
{
Socket_fs::Context *context = dynamic_cast<Socket_fs::Context *>(fd->context);
if (!context) return Errno(EBADF);
Libc::Allocator alloc { };
Genode::destroy(alloc, context);
Libc::file_descriptor_allocator()->free(fd);
destroy(alloc, context);
file_descriptor_allocator()->free(fd);
/*
* the socket is freed when the initial handle
@ -1218,7 +1218,7 @@ int Socket_fs::Plugin::close(Libc::File_descriptor *fd)
}
int Socket_fs::Plugin::ioctl(Libc::File_descriptor *, int request, char*)
int Socket_fs::Plugin::ioctl(File_descriptor *, int request, char*)
{
if (request == FIONREAD) {
/*
@ -1227,20 +1227,20 @@ int Socket_fs::Plugin::ioctl(Libc::File_descriptor *, int request, char*)
*/
static bool print_fionread_error_message = true;
if (print_fionread_error_message) {
Genode::error(__func__, " request FIONREAD not supported on sockets"
" (this message will not be shown again)");
error(__func__, " request FIONREAD not supported on sockets"
" (this message will not be shown again)");
print_fionread_error_message = false;
}
return -1;
}
Genode::error(__func__, " request ", request, " not supported on sockets");
error(__func__, " request ", request, " not supported on sockets");
return -1;
}
Plugin & Socket_fs::plugin()
Libc::Socket_fs::Plugin &Libc::Socket_fs::plugin()
{
static Plugin inst;
static Socket_fs::Plugin inst;
return inst;
}

34
repos/libports/src/lib/libc/socket_operations.cc
View File

@ -49,7 +49,7 @@ namespace Libc { extern char const *config_socket(); }
extern "C" int getpeername(int libc_fd, sockaddr *addr, socklen_t *addrlen)
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_getpeername(libc_fd, addr, addrlen);
FD_FUNC_WRAPPER(getpeername, libc_fd, addr, addrlen);
@ -62,7 +62,7 @@ int _getpeername(int libc_fd, sockaddr *addr, socklen_t *addrlen);
extern "C" int getsockname(int libc_fd, sockaddr *addr, socklen_t *addrlen)
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_getsockname(libc_fd, addr, addrlen);
FD_FUNC_WRAPPER(getsockname, libc_fd, addr, addrlen);
@ -79,7 +79,7 @@ int _getsockname(int libc_fd, sockaddr *addr, socklen_t *addrlen);
__SYS_(int, accept, (int libc_fd, sockaddr *addr, socklen_t *addrlen),
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_accept(libc_fd, addr, addrlen);
File_descriptor *ret_fd;
@ -96,7 +96,7 @@ __SYS_(int, accept4, (int libc_fd, struct sockaddr *addr, socklen_t *addrlen, in
extern "C" int bind(int libc_fd, sockaddr const *addr, socklen_t addrlen)
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_bind(libc_fd, addr, addrlen);
FD_FUNC_WRAPPER(bind, libc_fd, addr, addrlen);
@ -109,7 +109,7 @@ int _bind(int libc_fd, sockaddr const *addr, socklen_t addrlen);
__SYS_(int, connect, (int libc_fd, sockaddr const *addr, socklen_t addrlen),
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_connect(libc_fd, addr, addrlen);
FD_FUNC_WRAPPER(connect, libc_fd, addr, addrlen);
@ -118,7 +118,7 @@ __SYS_(int, connect, (int libc_fd, sockaddr const *addr, socklen_t addrlen),
extern "C" int listen(int libc_fd, int backlog)
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_listen(libc_fd, backlog);
FD_FUNC_WRAPPER(listen, libc_fd, backlog);
@ -128,7 +128,7 @@ extern "C" int listen(int libc_fd, int backlog)
__SYS_(ssize_t, recvfrom, (int libc_fd, void *buf, ::size_t len, int flags,
sockaddr *src_addr, socklen_t *src_addrlen),
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_recvfrom(libc_fd, buf, len, flags, src_addr, src_addrlen);
FD_FUNC_WRAPPER(recvfrom, libc_fd, buf, len, flags, src_addr, src_addrlen);
@ -137,7 +137,7 @@ __SYS_(ssize_t, recvfrom, (int libc_fd, void *buf, ::size_t len, int flags,
__SYS_(ssize_t, recv, (int libc_fd, void *buf, ::size_t len, int flags),
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_recv(libc_fd, buf, len, flags);
FD_FUNC_WRAPPER(recv, libc_fd, buf, len, flags);
@ -146,7 +146,7 @@ __SYS_(ssize_t, recv, (int libc_fd, void *buf, ::size_t len, int flags),
__SYS_(ssize_t, recvmsg, (int libc_fd, msghdr *msg, int flags),
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_recvmsg(libc_fd, msg, flags);
FD_FUNC_WRAPPER(recvmsg, libc_fd, msg, flags);
@ -156,7 +156,7 @@ __SYS_(ssize_t, recvmsg, (int libc_fd, msghdr *msg, int flags),
__SYS_(ssize_t, sendto, (int libc_fd, void const *buf, ::size_t len, int flags,
sockaddr const *dest_addr, socklen_t dest_addrlen),
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_sendto(libc_fd, buf, len, flags, dest_addr, dest_addrlen);
FD_FUNC_WRAPPER(sendto, libc_fd, buf, len, flags, dest_addr, dest_addrlen);
@ -165,7 +165,7 @@ __SYS_(ssize_t, sendto, (int libc_fd, void const *buf, ::size_t len, int flags,
extern "C" ssize_t send(int libc_fd, void const *buf, ::size_t len, int flags)
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_send(libc_fd, buf, len, flags);
FD_FUNC_WRAPPER(send, libc_fd, buf, len, flags);
@ -175,7 +175,7 @@ extern "C" ssize_t send(int libc_fd, void const *buf, ::size_t len, int flags)
extern "C" int getsockopt(int libc_fd, int level, int optname,
void *optval, socklen_t *optlen)
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_getsockopt(libc_fd, level, optname, optval, optlen);
FD_FUNC_WRAPPER(getsockopt, libc_fd, level, optname, optval, optlen);
@ -190,7 +190,7 @@ int _getsockopt(int libc_fd, int level, int optname,
extern "C" int setsockopt(int libc_fd, int level, int optname,
void const *optval, socklen_t optlen)
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_setsockopt(libc_fd, level, optname, optval, optlen);
FD_FUNC_WRAPPER(setsockopt, libc_fd, level, optname, optval, optlen);
@ -204,7 +204,7 @@ int _setsockopt(int libc_fd, int level, int optname,
extern "C" int shutdown(int libc_fd, int how)
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_shutdown(libc_fd, how);
FD_FUNC_WRAPPER(shutdown, libc_fd, how);
@ -212,7 +212,7 @@ extern "C" int shutdown(int libc_fd, int how)
__SYS_(int, socket, (int domain, int type, int protocol),
{
if (*Libc::config_socket())
if (*config_socket())
return socket_fs_socket(domain, type, protocol);
Plugin *plugin;
@ -221,13 +221,13 @@ __SYS_(int, socket, (int domain, int type, int protocol),
plugin = plugin_registry()->get_plugin_for_socket(domain, type, protocol);
if (!plugin) {
Genode::error("no plugin found for socket()");
error("no plugin found for socket()");
return -1;
}
new_fdo = plugin->socket(domain, type, protocol);
if (!new_fdo) {
Genode::error("plugin()->socket() failed");
error("plugin()->socket() failed");
return -1;
}

15
repos/libports/src/lib/libc/sysctl.cc
View File

@ -30,6 +30,7 @@
#include <internal/errno.h>
#include <internal/init.h>
using namespace Libc;
enum { PAGESIZE = 4096 };
@ -55,8 +56,8 @@ extern "C" long sysconf(int name)
case _SC_PHYS_PAGES:
return _global_env->pd().ram_quota().value / PAGESIZE;
default:
Genode::warning(__func__, "(", name, ") not implemented");
return Libc::Errno(EINVAL);
warning(__func__, "(", name, ") not implemented");
return Errno(EINVAL);
}
}
@ -67,9 +68,9 @@ extern "C" int __sysctl(const int *name, u_int namelen,
{
/* read only */
if (!oldp) /* check for write attempt */
return Libc::Errno(newp ? EPERM : EINVAL);
return Errno(newp ? EPERM : EINVAL);
if (namelen != 2) return Libc::Errno(ENOENT);
if (namelen != 2) return Errno(ENOENT);
char *buf = (char*)oldp;
int index_a = name[0];
@ -93,7 +94,7 @@ extern "C" int __sysctl(const int *name, u_int namelen,
*(Genode::int64_t*)oldp = _global_env->pd().ram_quota().value;
break;
default:
return Libc::Errno(EINVAL);
return Errno(EINVAL);
}
return 0;
@ -163,6 +164,6 @@ extern "C" int __sysctl(const int *name, u_int namelen,
}
}
Genode::warning("missing sysctl for [", index_a, "][", index_b, "]");
return Libc::Errno(ENOENT);
warning("missing sysctl for [", index_a, "][", index_b, "]");
return Errno(ENOENT);
}

31
repos/libports/src/lib/libc/time.cc
View File

@ -61,11 +61,11 @@ struct Libc::Rtc : Vfs::Watch_response_handler
_rtc_path(rtc_path)
{
if (!_rtc_path_valid) {
Genode::warning("rtc not configured, returning ", _rtc_value);
warning("rtc not configured, returning ", _rtc_value);
return;
}
_watch_handle = Libc::watch(_rtc_path.string());
_watch_handle = watch(_rtc_path.string());
if (_watch_handle) {
_watch_handle->handler(this);
}
@ -91,7 +91,7 @@ struct Libc::Rtc : Vfs::Watch_response_handler
int fd = open(_rtc_path.string(), O_RDONLY);
if (fd == -1) {
Genode::warning(_rtc_path, " not readable, returning ", _rtc_value);
warning(_rtc_path, " not readable, returning ", _rtc_value);
return _rtc_value;
}
@ -100,7 +100,7 @@ struct Libc::Rtc : Vfs::Watch_response_handler
if (n > 0) {
buf[n - 1] = '\0';
struct tm tm;
Genode::memset(&tm, 0, sizeof(tm));
memset(&tm, 0, sizeof(tm));
if (strptime(buf, "%Y-%m-%d %R", &tm)) {
_rtc_value = mktime(&tm);
@ -115,7 +115,7 @@ struct Libc::Rtc : Vfs::Watch_response_handler
if (!_current_time_ptr)
throw Missing_call_of_init_time();
Genode::uint64_t const ts_value =
uint64_t const ts_value =
_current_time_ptr->current_time().trunc_to_plain_ms().value;
_rtc_value += (time_t)ts_value / 1000;
@ -124,14 +124,19 @@ struct Libc::Rtc : Vfs::Watch_response_handler
};
using namespace Libc;
extern "C" __attribute__((weak))
int clock_gettime(clockid_t clk_id, struct timespec *ts)
{
if (!ts) return Libc::Errno(EFAULT);
typedef Libc::uint64_t uint64_t;
if (!ts) return Errno(EFAULT);
auto current_time = [&] ()
{
struct Missing_call_of_init_time : Genode::Exception { };
struct Missing_call_of_init_time : Exception { };
if (!_current_time_ptr)
throw Missing_call_of_init_time();
@ -151,12 +156,12 @@ int clock_gettime(clockid_t clk_id, struct timespec *ts)
/*
* XXX move instance to Libc::Kernel
*/
static Libc::Rtc rtc(_rtc_path);
static Rtc rtc(_rtc_path);
time_t const rtc_value = rtc.read();
if (!rtc_value) return Libc::Errno(EINVAL);
if (!rtc_value) return Errno(EINVAL);
Genode::uint64_t const time = current_time().trunc_to_plain_ms().value;
uint64_t const time = current_time().trunc_to_plain_ms().value;
ts->tv_sec = rtc_value + time/1000;
ts->tv_nsec = (time % 1000) * (1000*1000);
@ -167,7 +172,7 @@ int clock_gettime(clockid_t clk_id, struct timespec *ts)
case CLOCK_MONOTONIC:
case CLOCK_UPTIME:
{
Genode::uint64_t us = current_time().trunc_to_plain_us().value;
uint64_t us = current_time().trunc_to_plain_us().value;
ts->tv_sec = us / (1000*1000);
ts->tv_nsec = (us % (1000*1000)) * 1000;
@ -175,7 +180,7 @@ int clock_gettime(clockid_t clk_id, struct timespec *ts)
}
default:
return Libc::Errno(EINVAL);
return Errno(EINVAL);
}
return 0;
@ -209,6 +214,6 @@ int __sys_gettimeofday(struct timeval *tv, struct timezone *);
extern "C"
clock_t clock()
{
Genode::error(__func__, " not implemented, use 'clock_gettime' instead");
error(__func__, " not implemented, use 'clock_gettime' instead");
return -1;
}

112
repos/libports/src/lib/libc/vfs_plugin.cc
View File

@ -118,8 +118,8 @@ char const *libc_resolv_path;
namespace Libc {
Genode::Xml_node config() __attribute__((weak));
Genode::Xml_node config()
Xml_node config() __attribute__((weak));
Xml_node config()
{
if (!_config_node) {
error("libc config not initialized - aborting");
@ -139,8 +139,8 @@ namespace Libc {
Config_attr(char const *attr_name, char const *default_value)
:
_value(Libc::config().attribute_value(attr_name,
Value(default_value)))
_value(config().attribute_value(attr_name,
Value(default_value)))
{ }
char const *string() const { return _value.string(); }
@ -168,9 +168,9 @@ namespace Libc {
return ns_file.string();
}
void libc_config_init(Genode::Xml_node node)
void libc_config_init(Xml_node node)
{
static Genode::Xml_node config = node;
static Xml_node config = node;
_config_node = &config;
libc_resolv_path = config_nameserver_file();
@ -187,7 +187,7 @@ namespace Libc {
VFS_THREAD_SAFE(handle->fs().notify_read_ready(handle));
}
bool read_ready(Libc::File_descriptor *fd)
bool read_ready(File_descriptor *fd)
{
Vfs::Vfs_handle *handle = vfs_handle(fd);
if (!handle) return false;
@ -238,8 +238,8 @@ Libc::File_descriptor *Libc::Vfs_plugin::open(char const *path, int flags,
/* the directory was successfully opened */
Libc::File_descriptor *fd =
Libc::file_descriptor_allocator()->alloc(this, vfs_context(handle), libc_fd);
File_descriptor *fd =
file_descriptor_allocator()->alloc(this, vfs_context(handle), libc_fd);
/* FIXME error cleanup code leaks resources! */
@ -319,8 +319,8 @@ Libc::File_descriptor *Libc::Vfs_plugin::open(char const *path, int flags,
/* the file was successfully opened */
Libc::File_descriptor *fd =
Libc::file_descriptor_allocator()->alloc(this, vfs_context(handle), libc_fd);
File_descriptor *fd =
file_descriptor_allocator()->alloc(this, vfs_context(handle), libc_fd);
/* FIXME error cleanup code leaks resources! */
@ -349,7 +349,7 @@ int Libc::Vfs_plugin::_vfs_sync(Vfs::Vfs_handle &vfs_handle)
Result result = Result::SYNC_QUEUED;
{
struct Check : Libc::Suspend_functor
struct Check : Suspend_functor
{
bool retry { false };
@ -377,7 +377,7 @@ int Libc::Vfs_plugin::_vfs_sync(Vfs::Vfs_handle &vfs_handle)
}
{
struct Check : Libc::Suspend_functor
struct Check : Suspend_functor
{
bool retry { false };
@ -407,30 +407,30 @@ int Libc::Vfs_plugin::_vfs_sync(Vfs::Vfs_handle &vfs_handle)
}
}
return result == Result::SYNC_OK ? 0 : Libc::Errno(EIO);
return result == Result::SYNC_OK ? 0 : Errno(EIO);
}
int Libc::Vfs_plugin::close(Libc::File_descriptor *fd)
int Libc::Vfs_plugin::close(File_descriptor *fd)
{
Vfs::Vfs_handle *handle = vfs_handle(fd);
/* XXX: mark the handle as requiring sync or not */
_vfs_sync(*handle);
VFS_THREAD_SAFE(handle->close());
Libc::file_descriptor_allocator()->free(fd);
file_descriptor_allocator()->free(fd);
return 0;
}
int Libc::Vfs_plugin::dup2(Libc::File_descriptor *fd,
Libc::File_descriptor *new_fd)
int Libc::Vfs_plugin::dup2(File_descriptor *fd,
File_descriptor *new_fd)
{
new_fd->context = fd->context;
return new_fd->libc_fd;
}
int Libc::Vfs_plugin::fstat(Libc::File_descriptor *fd, struct stat *buf)
int Libc::Vfs_plugin::fstat(File_descriptor *fd, struct stat *buf)
{
Vfs::Vfs_handle *handle = vfs_handle(fd);
_vfs_sync(*handle);
@ -438,10 +438,10 @@ int Libc::Vfs_plugin::fstat(Libc::File_descriptor *fd, struct stat *buf)
}
int Libc::Vfs_plugin::fstatfs(Libc::File_descriptor *fd, struct statfs *buf)
int Libc::Vfs_plugin::fstatfs(File_descriptor *fd, struct statfs *buf)
{
if (!fd || !buf)
return Libc::Errno(EFAULT);
return Errno(EFAULT);
Genode::memset(buf, 0, sizeof(*buf));
@ -500,7 +500,7 @@ int Libc::Vfs_plugin::stat(char const *path, struct stat *buf)
}
ssize_t Libc::Vfs_plugin::write(Libc::File_descriptor *fd, const void *buf,
ssize_t Libc::Vfs_plugin::write(File_descriptor *fd, const void *buf,
::size_t count)
{
typedef Vfs::File_io_service::Write_result Result;
@ -521,7 +521,7 @@ ssize_t Libc::Vfs_plugin::write(Libc::File_descriptor *fd, const void *buf,
} else {
struct Check : Libc::Suspend_functor
struct Check : Suspend_functor
{
bool retry { false };
@ -574,10 +574,10 @@ ssize_t Libc::Vfs_plugin::write(Libc::File_descriptor *fd, const void *buf,
}
ssize_t Libc::Vfs_plugin::read(Libc::File_descriptor *fd, void *buf,
ssize_t Libc::Vfs_plugin::read(File_descriptor *fd, void *buf,
::size_t count)
{
Libc::dispatch_pending_io_signals();
dispatch_pending_io_signals();
typedef Vfs::File_io_service::Read_result Result;
@ -586,11 +586,11 @@ ssize_t Libc::Vfs_plugin::read(Libc::File_descriptor *fd, void *buf,
if (fd->flags & O_DIRECTORY)
return Errno(EISDIR);
if (fd->flags & O_NONBLOCK && !Libc::read_ready(fd))
if (fd->flags & O_NONBLOCK && !read_ready(fd))
return Errno(EAGAIN);
{
struct Check : Libc::Suspend_functor
struct Check : Suspend_functor
{
bool retry { false };
@ -616,7 +616,7 @@ ssize_t Libc::Vfs_plugin::read(Libc::File_descriptor *fd, void *buf,
Result out_result;
{
struct Check : Libc::Suspend_functor
struct Check : Suspend_functor
{
bool retry { false };
@ -668,11 +668,11 @@ ssize_t Libc::Vfs_plugin::read(Libc::File_descriptor *fd, void *buf,
}
ssize_t Libc::Vfs_plugin::getdirentries(Libc::File_descriptor *fd, char *buf,
ssize_t Libc::Vfs_plugin::getdirentries(File_descriptor *fd, char *buf,
::size_t nbytes, ::off_t *basep)
{
if (nbytes < sizeof(struct dirent)) {
Genode::error("getdirentries: buffer too small");
error("getdirentries: buffer too small");
return -1;
}
@ -685,7 +685,7 @@ ssize_t Libc::Vfs_plugin::getdirentries(Libc::File_descriptor *fd, char *buf,
Dirent dirent_out;
{
struct Check : Libc::Suspend_functor
struct Check : Suspend_functor
{
bool retry { false };
@ -710,7 +710,7 @@ ssize_t Libc::Vfs_plugin::getdirentries(Libc::File_descriptor *fd, char *buf,
Vfs::file_size out_count;
{
struct Check : Libc::Suspend_functor
struct Check : Suspend_functor
{
bool retry { false };
@ -786,7 +786,7 @@ ssize_t Libc::Vfs_plugin::getdirentries(Libc::File_descriptor *fd, char *buf,
}
int Libc::Vfs_plugin::ioctl(Libc::File_descriptor *fd, int request, char *argp)
int Libc::Vfs_plugin::ioctl(File_descriptor *fd, int request, char *argp)
{
using ::off_t;
@ -881,7 +881,7 @@ int Libc::Vfs_plugin::ioctl(Libc::File_descriptor *fd, int request, char *argp)
}
default:
Genode::warning("unsupported ioctl (request=", Genode::Hex(request), ")");
warning("unsupported ioctl (request=", Hex(request), ")");
break;
}
@ -940,7 +940,7 @@ int Libc::Vfs_plugin::ioctl(Libc::File_descriptor *fd, int request, char *argp)
}
::off_t Libc::Vfs_plugin::lseek(Libc::File_descriptor *fd, ::off_t offset, int whence)
::off_t Libc::Vfs_plugin::lseek(File_descriptor *fd, ::off_t offset, int whence)
{
Vfs::Vfs_handle *handle = vfs_handle(fd);
@ -960,7 +960,7 @@ int Libc::Vfs_plugin::ioctl(Libc::File_descriptor *fd, int request, char *argp)
}
int Libc::Vfs_plugin::ftruncate(Libc::File_descriptor *fd, ::off_t length)
int Libc::Vfs_plugin::ftruncate(File_descriptor *fd, ::off_t length)
{
Vfs::Vfs_handle *handle = vfs_handle(fd);
_vfs_sync(*handle);
@ -977,7 +977,7 @@ int Libc::Vfs_plugin::ftruncate(Libc::File_descriptor *fd, ::off_t length)
}
int Libc::Vfs_plugin::fcntl(Libc::File_descriptor *fd, int cmd, long arg)
int Libc::Vfs_plugin::fcntl(File_descriptor *fd, int cmd, long arg)
{
switch (cmd) {
case F_DUPFD_CLOEXEC:
@ -986,8 +986,8 @@ int Libc::Vfs_plugin::fcntl(Libc::File_descriptor *fd, int cmd, long arg)
/*
* Allocate free file descriptor locally.
*/
Libc::File_descriptor *new_fd =
Libc::file_descriptor_allocator()->alloc(this, 0);
File_descriptor *new_fd =
file_descriptor_allocator()->alloc(this, 0);
if (!new_fd) return Errno(EMFILE);
new_fd->path(fd->fd_path);
@ -997,7 +997,7 @@ int Libc::Vfs_plugin::fcntl(Libc::File_descriptor *fd, int cmd, long arg)
* duplicate.
*/
if (dup2(fd, new_fd) == -1) {
Genode::error("Plugin::fcntl: dup2 unexpectedly failed");
error("Plugin::fcntl: dup2 unexpectedly failed");
return Errno(EINVAL);
}
@ -1013,12 +1013,12 @@ int Libc::Vfs_plugin::fcntl(Libc::File_descriptor *fd, int cmd, long arg)
break;
}
Genode::error("fcntl(): command ", cmd, " not supported - vfs");
error("fcntl(): command ", cmd, " not supported - vfs");
return Errno(EINVAL);
}
int Libc::Vfs_plugin::fsync(Libc::File_descriptor *fd)
int Libc::Vfs_plugin::fsync(File_descriptor *fd)
{
Vfs::Vfs_handle *handle = vfs_handle(fd);
return _vfs_sync(*handle);
@ -1058,7 +1058,7 @@ int Libc::Vfs_plugin::symlink(const char *oldpath, const char *newpath)
handle->handler(&_response_handler);
struct Check : Libc::Suspend_functor
struct Check : Suspend_functor
{
bool retry { false };
@ -1128,7 +1128,7 @@ ssize_t Libc::Vfs_plugin::readlink(const char *path, char *buf, ::size_t buf_siz
symlink_handle->handler(&_response_handler);
{
struct Check : Libc::Suspend_functor
struct Check : Suspend_functor
{
bool retry { false };
@ -1158,7 +1158,7 @@ ssize_t Libc::Vfs_plugin::readlink(const char *path, char *buf, ::size_t buf_siz
Vfs::file_size out_len = 0;
{
struct Check : Libc::Suspend_functor
struct Check : Suspend_functor
{
bool retry { false };
@ -1265,16 +1265,16 @@ int Libc::Vfs_plugin::rename(char const *from_path, char const *to_path)
void *Libc::Vfs_plugin::mmap(void *addr_in, ::size_t length, int prot, int flags,
Libc::File_descriptor *fd, ::off_t offset)
File_descriptor *fd, ::off_t offset)
{
if (prot != PROT_READ && !(prot == (PROT_READ | PROT_WRITE) && flags == MAP_PRIVATE)) {
Genode::error("mmap for prot=", Genode::Hex(prot), " not supported");
error("mmap for prot=", Hex(prot), " not supported");
errno = EACCES;
return (void *)-1;
}
if (addr_in != 0) {
Genode::error("mmap for predefined address not supported");
error("mmap for predefined address not supported");
errno = EINVAL;
return (void *)-1;
}
@ -1284,7 +1284,7 @@ void *Libc::Vfs_plugin::mmap(void *addr_in, ::size_t length, int prot, int flags
* 'Vfs::Directory_service::dataspace'.
*/
void *addr = Libc::mem_alloc()->alloc(length, PAGE_SHIFT);
void *addr = mem_alloc()->alloc(length, PAGE_SHIFT);
if (addr == (void *)-1) {
errno = ENOMEM;
return (void *)-1;
@ -1298,7 +1298,7 @@ void *Libc::Vfs_plugin::mmap(void *addr_in, ::size_t length, int prot, int flags
while (read_remain > 0) {
ssize_t length_read = ::pread(fd->libc_fd, read_addr, read_remain, read_offset);
if (length_read < 0) { /* error */
Genode::error("mmap could not obtain file content");
error("mmap could not obtain file content");
::munmap(addr, length);
errno = EACCES;
return (void *)-1;
@ -1315,7 +1315,7 @@ void *Libc::Vfs_plugin::mmap(void *addr_in, ::size_t length, int prot, int flags
int Libc::Vfs_plugin::munmap(void *addr, ::size_t)
{
Libc::mem_alloc()->free(addr);
mem_alloc()->free(addr);
return 0;
}
@ -1363,8 +1363,8 @@ bool Libc::Vfs_plugin::supports_select(int nfds,
if (FD_ISSET(fd, readfds) || FD_ISSET(fd, writefds) || FD_ISSET(fd, exceptfds)) {
Libc::File_descriptor *fdo =
Libc::file_descriptor_allocator()->find_by_libc_fd(fd);
File_descriptor *fdo =
file_descriptor_allocator()->find_by_libc_fd(fd);
if (fdo && (fdo->plugin == this))
return true;
@ -1391,8 +1391,8 @@ int Libc::Vfs_plugin::select(int nfds,
for (int fd = 0; fd < nfds; ++fd) {
Libc::File_descriptor *fdo =
Libc::file_descriptor_allocator()->find_by_libc_fd(fd);
File_descriptor *fdo =
file_descriptor_allocator()->find_by_libc_fd(fd);
/* handle only fds that belong to this plugin */
if (!fdo || (fdo->plugin != this))
@ -1406,7 +1406,7 @@ int Libc::Vfs_plugin::select(int nfds,
FD_SET(fd, readfds);
++nready;
} else {
Libc::notify_read_ready(handle);
notify_read_ready(handle);
}
}