ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2025-06-19 15:43:56 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

dde_linux: remove usage of deprecated env()

Browse Source 
Fixes #2280.
This commit is contained in:
Josef Söntgen
2017-02-11 17:35:30 +01:00
committed by Christian Helmuth
parent 7d91b1d949
commit a2cff03539
44 changed files with 445 additions and 598 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
repos/dde_linux/run/wifi.run
View File

@ -137,7 +137,7 @@ set firmware_modules {
set boot_modules { set boot_modules {
core ld.lib.so init timer rtc_drv report_rom dynamic_rom core ld.lib.so init timer rtc_drv report_rom dynamic_rom
vfs_jitterentropy.lib.so vfs_jitterentropy.lib.so
libc.lib.so libcrypto.lib.so libssl.lib.so libc.lib.so libm.lib.so libcrypto.lib.so libssl.lib.so
wpa_driver_nl80211.lib.so wpa_supplicant.lib.so wpa_driver_nl80211.lib.so wpa_supplicant.lib.so
wifi.lib.so wifi.lib.so
wifi_drv wifi_drv

6
repos/dde_linux/src/drivers/framebuffer/intel/include/lx_emul.h
View File

@ -216,12 +216,6 @@ extern struct atomic_notifier_head panic_notifier_list;
(void) (&_min1 == &_min2); \ (void) (&_min1 == &_min2); \
_min1 < _min2 ? _min1 : _min2; }) _min1 < _min2 ? _min1 : _min2; })
#define max(x, y) ({ \
typeof(x) _max1 = (x); \
typeof(y) _max2 = (y); \
(void) (&_max1 == &_max2); \
_max1 > _max2 ? _max1 : _max2; })
#define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi) #define clamp(val, lo, hi) min((typeof(val))max(val, lo), hi)
/* linux/i2c.h */ /* linux/i2c.h */

3
repos/dde_linux/src/drivers/framebuffer/intel/lx_emul.cc
View File

@ -1021,7 +1021,8 @@ void __iomem __must_check *pci_map_rom(struct pci_dev *pdev, size_t *size)
{ {
enum { VIDEO_ROM_BASE = 0xC0000, VIDEO_ROM_SIZE = 0x20000 }; enum { VIDEO_ROM_BASE = 0xC0000, VIDEO_ROM_SIZE = 0x20000 };
static Genode::Attached_io_mem_dataspace vrom(VIDEO_ROM_BASE, VIDEO_ROM_SIZE); static Genode::Attached_io_mem_dataspace vrom(Lx_kit::env().env(),
VIDEO_ROM_BASE, VIDEO_ROM_SIZE);
*size = VIDEO_ROM_SIZE; *size = VIDEO_ROM_SIZE;
return vrom.local_addr<void*>(); return vrom.local_addr<void*>();
} }

45
repos/dde_linux/src/drivers/framebuffer/intel/main.cc
View File

@ -6,7 +6,7 @@
*/ */
/* /*
* Copyright (C) 2015 Genode Labs GmbH * Copyright (C) 2015-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -17,13 +17,14 @@
#include <base/component.h> #include <base/component.h>
#include <base/heap.h> #include <base/heap.h>
#include <base/attached_rom_dataspace.h> #include <base/attached_rom_dataspace.h>
#include <os/config.h>
/* Server related local includes */ /* Server related local includes */
#include <component.h> #include <component.h>
/* Linux emulation environment includes */ /* Linux emulation environment includes */
#include <lx_emul.h> #include <lx_emul.h>
#include <lx_kit/env.h>
#include <lx_kit/malloc.h>
#include <lx_kit/scheduler.h> #include <lx_kit/scheduler.h>
#include <lx_kit/timer.h> #include <lx_kit/timer.h>
#include <lx_kit/irq.h> #include <lx_kit/irq.h>
@ -48,39 +49,51 @@ struct Main
Genode::Heap heap { env.ram(), env.rm() }; Genode::Heap heap { env.ram(), env.rm() };
Framebuffer::Root root { env, heap, config }; Framebuffer::Root root { env, heap, config };
/* init singleton Lx::Timer */
Lx::Timer &timer = Lx::timer(&ep, &jiffies);
/* init singleton Lx::Irq */
Lx::Irq &irq = Lx::Irq::irq(&ep, &heap);
/* init singleton Lx::Work */
Lx::Work &work = Lx::Work::work_queue(&heap);
/* Linux task that handles the initialization */ /* Linux task that handles the initialization */
Lx::Task linux { run_linux, reinterpret_cast<void*>(this), "linux", Genode::Constructible<Lx::Task> linux;
Lx::Task::PRIORITY_0, Lx::scheduler() };
Main(Genode::Env &env) : env(env) Main(Genode::Env &env) : env(env)
{ {
Genode::log("--- intel framebuffer driver ---"); Genode::log("--- intel framebuffer driver ---");
Lx_kit::construct_env(env);
/* init singleton Lx::Scheduler */
Lx::scheduler(&env);
Lx::pci_init(env, env.ram(), heap);
Lx::malloc_init(env, heap);
/* init singleton Lx::Timer */
Lx::timer(&env, &ep, &heap, &jiffies);
/* init singleton Lx::Irq */
Lx::Irq::irq(&ep, &heap);
/* init singleton Lx::Work */
Lx::Work::work_queue(&heap);
linux.construct(run_linux, reinterpret_cast<void*>(this),
"linux", Lx::Task::PRIORITY_0, Lx::scheduler());
/* give all task a first kick before returning */ /* give all task a first kick before returning */
Lx::scheduler().schedule(); Lx::scheduler().schedule();
} }
void announce() { env.parent().announce(ep.manage(root)); } void announce() { env.parent().announce(ep.manage(root)); }
Lx::Task &linux_task() { return *linux; }
}; };
struct Policy_agent struct Policy_agent
{ {
Main &main; Main &main;
Genode::Signal_rpc_member<Policy_agent> sd; Genode::Signal_handler<Policy_agent> sd;
void handle(unsigned) void handle()
{ {
main.linux.unblock(); main.linux_task().unblock();
Lx::scheduler().schedule(); Lx::scheduler().schedule();
} }

3
repos/dde_linux/src/drivers/framebuffer/intel/target.mk
View File

@ -13,7 +13,8 @@ SRC_CC += irq.cc \
printf.cc \ printf.cc \
scheduler.cc \ scheduler.cc \
timer.cc \ timer.cc \
work.cc work.cc \
env.cc
INC_DIR += $(REP_DIR)/src/include INC_DIR += $(REP_DIR)/src/include

11
repos/dde_linux/src/drivers/wifi/main.cc
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -105,7 +105,7 @@ static int generatewpa_supplicant_conf(char const **p, Genode::size_t *len, char
struct Wlan_configration struct Wlan_configration
{ {
Genode::Attached_rom_dataspace config_rom { "wlan_configuration" }; Genode::Attached_rom_dataspace config_rom;
Genode::Signal_handler<Wlan_configration> dispatcher; Genode::Signal_handler<Wlan_configration> dispatcher;
Genode::Lock update_lock; Genode::Lock update_lock;
@ -208,9 +208,10 @@ struct Wlan_configration
void _handle_update() { _update_configuration(); } void _handle_update() { _update_configuration(); }
Wlan_configration(Genode::Entrypoint &ep) Wlan_configration(Genode::Env &env)
: :
dispatcher(ep, *this, &Wlan_configration::_handle_update) config_rom(env, "wlan_configuration"),
dispatcher(env.ep(), *this, &Wlan_configration::_handle_update)
{ {
config_rom.sigh(dispatcher); config_rom.sigh(dispatcher);
_update_configuration(); _update_configuration();
@ -244,7 +245,7 @@ struct Main
wpa->start(); wpa->start();
try { try {
wlan_config = new (&heap) Wlan_configration(env.ep()); wlan_config = new (&heap) Wlan_configration(env);
} catch (...) { } catch (...) {
Genode::warning("could not create Wlan_configration handler"); Genode::warning("could not create Wlan_configration handler");
} }

7
repos/dde_linux/src/drivers/wifi/wpa.h
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -19,6 +19,7 @@
/* entry function */ /* entry function */
extern "C" int wpa_main(int debug_msg, int connected_scan_interval); extern "C" int wpa_main(int debug_msg, int connected_scan_interval);
extern "C" void wpa_reporter_init(void *env);
extern "C" void wpa_conf_reload(void); extern "C" void wpa_conf_reload(void);
class Wpa_thread : public Genode::Thread class Wpa_thread : public Genode::Thread
@ -38,7 +39,9 @@ class Wpa_thread : public Genode::Thread
Thread(env, "wpa_supplicant", 8*1024*sizeof(long)), Thread(env, "wpa_supplicant", 8*1024*sizeof(long)),
_lock(lock), _exit(-1), _lock(lock), _exit(-1),
_debug_msg(debug_msg), _connected_scan_interval(connected_scan_interval) _debug_msg(debug_msg), _connected_scan_interval(connected_scan_interval)
{ } {
wpa_reporter_init(&env);
}
void entry() void entry()
{ {

16
repos/dde_linux/src/include/lx_emul/impl/completion.h
View File

@ -5,13 +5,14 @@
*/ */
/* /*
* Copyright (C) 2015-2016 Genode Labs GmbH * Copyright (C) 2015-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
*/ */
/* Linux kint includes */ /* Linux kint includes */
#include <lx_kit/env.h>
#include <lx_kit/internal/task.h> #include <lx_kit/internal/task.h>
typedef Lx::Task::List_element Wait_le; typedef Lx::Task::List_element Wait_le;
@ -20,25 +21,23 @@ typedef Lx::Task::List Wait_list;
void init_waitqueue_head(wait_queue_head_t *wq) void init_waitqueue_head(wait_queue_head_t *wq)
{ {
wq->list = new (Genode::env()->heap()) Wait_list; wq->list = new (&Lx_kit::env().heap()) Wait_list;
} }
void remove_wait_queue(wait_queue_head_t *wq, wait_queue_t *wait) void remove_wait_queue(wait_queue_head_t *wq, wait_queue_t *wait)
{ {
Wait_list *list = static_cast<Wait_list*>(wq->list); Wait_list *list = static_cast<Wait_list*>(wq->list);
if (!list) if (!list) { return; }
return;
destroy(Genode::env()->heap(), list); destroy(&Lx_kit::env().heap(), list);
} }
int waitqueue_active(wait_queue_head_t *wq) int waitqueue_active(wait_queue_head_t *wq)
{ {
Wait_list *list = static_cast<Wait_list*>(wq->list); Wait_list *list = static_cast<Wait_list*>(wq->list);
if (!list) if (!list) { return 0; }
return 0;
return list->first() ? 1 : 0; return list->first() ? 1 : 0;
} }
@ -55,8 +54,7 @@ void __wake_up(wait_queue_head_t *wq, bool all)
Wait_le *le = list->first(); Wait_le *le = list->first();
do { do {
if (!le) if (!le) { return; }
return;
le->object()->unblock(); le->object()->unblock();
} while (all && (le = le->next())); } while (all && (le = le->next()));

23
repos/dde_linux/src/include/lx_emul/impl/delay.h
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2015-2016 Genode Labs GmbH * Copyright (C) 2015-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -14,21 +14,32 @@
/* Genode includes */ /* Genode includes */
#include <timer_session/connection.h> #include <timer_session/connection.h>
#include <lx_kit/env.h>
#include <lx_kit/timer.h> #include <lx_kit/timer.h>
/* /*
* XXX We may consider to use the Lx::Timer instead of opening a dedicated * XXX "We may consider to use the Lx::Timer instead of opening a dedicated
* timer session. * timer session" which I tried during the deprecation warning removal
* but it did not work out. At least the intel_fb at that point got stuck
* because the workqueue task got mutex blocked.
*/ */
static Timer::Connection _delay_timer; static Genode::Constructible<Timer::Connection> _delay_timer;
static inline void __delay_timer(unsigned long usecs)
{
if (!_delay_timer.constructed()) {
_delay_timer.construct(Lx_kit::env().env());
}
void udelay(unsigned long usecs) { _delay_timer.usleep(usecs); } _delay_timer->usleep(usecs);
}
void udelay(unsigned long usecs) { __delay_timer(usecs); }
void msleep(unsigned int msecs) void msleep(unsigned int msecs)
{ {
_delay_timer.msleep(msecs); __delay_timer(1000 * msecs);
Lx::timer_update_jiffies(); Lx::timer_update_jiffies();
} }

3
repos/dde_linux/src/include/lx_emul/impl/gfp.h
View File

@ -15,6 +15,7 @@
#include <lx_kit/addr_to_page_mapping.h> #include <lx_kit/addr_to_page_mapping.h>
#include <lx_kit/backend_alloc.h> #include <lx_kit/backend_alloc.h>
#include <lx_kit/malloc.h> #include <lx_kit/malloc.h>
#include <lx_kit/env.h>
struct page *alloc_pages(gfp_t gfp_mask, unsigned int order) struct page *alloc_pages(gfp_t gfp_mask, unsigned int order)
@ -24,7 +25,7 @@ struct page *alloc_pages(gfp_t gfp_mask, unsigned int order)
size_t size = PAGE_SIZE << order; size_t size = PAGE_SIZE << order;
Genode::Ram_dataspace_capability ds_cap = Lx::backend_alloc(size, Genode::UNCACHED); Genode::Ram_dataspace_capability ds_cap = Lx::backend_alloc(size, Genode::UNCACHED);
page->addr = Genode::env()->rm_session()->attach(ds_cap); page->addr = Lx_kit::env().rm().attach(ds_cap);
page->paddr = Genode::Dataspace_client(ds_cap).phys_addr(); page->paddr = Genode::Dataspace_client(ds_cap).phys_addr();
if (!page->addr) { if (!page->addr) {

25
repos/dde_linux/src/include/lx_emul/impl/mutex.h
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2015-2016 Genode Labs GmbH * Copyright (C) 2015-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -13,7 +13,7 @@
/* Linux kit includes */ /* Linux kit includes */
#include <lx_kit/scheduler.h> #include <lx_kit/scheduler.h>
#include <lx_kit/env.h>
enum { MUTEX_UNLOCKED = 1, MUTEX_LOCKED = 0, MUTEX_WAITERS = -1 }; enum { MUTEX_UNLOCKED = 1, MUTEX_LOCKED = 0, MUTEX_WAITERS = -1 };
@ -23,7 +23,7 @@ void mutex_init(struct mutex *m)
m->state = MUTEX_UNLOCKED; m->state = MUTEX_UNLOCKED;
m->holder = nullptr; m->holder = nullptr;
m->waiters = new (Genode::env()->heap()) Lx::Task::List; m->waiters = nullptr;
m->id = ++id; m->id = ++id;
m->counter = 0; m->counter = 0;
} }
@ -31,9 +31,14 @@ void mutex_init(struct mutex *m)
void mutex_destroy(struct mutex *m) void mutex_destroy(struct mutex *m)
{ {
/* FIXME potentially blocked tasks are not unblocked */ Lx::Task::List *waiters = static_cast<Lx::Task::List *>(m->waiters);
Genode::destroy(Genode::env()->heap(), static_cast<Lx::Task::List *>(m->waiters)); /* FIXME potentially blocked tasks are not unblocked */
if (waiters->first()) {
Genode::error(__func__, "destroying non-empty waiters list");
}
Genode::destroy(&Lx_kit::env().heap(), waiters);
m->holder = nullptr; m->holder = nullptr;
m->waiters = nullptr; m->waiters = nullptr;
@ -42,8 +47,18 @@ void mutex_destroy(struct mutex *m)
} }
static inline void __check_or_initialize_mutex(struct mutex *m)
{
if (!m->waiters) {
m->waiters = new (&Lx_kit::env().heap()) Lx::Task::List;
}
}
void mutex_lock(struct mutex *m) void mutex_lock(struct mutex *m)
{ {
__check_or_initialize_mutex(m);
while (1) { while (1) {
if (m->state == MUTEX_UNLOCKED) { if (m->state == MUTEX_UNLOCKED) {
m->state = MUTEX_LOCKED; m->state = MUTEX_LOCKED;

5
repos/dde_linux/src/include/lx_emul/impl/pci.h
View File

@ -5,13 +5,14 @@
*/ */
/* /*
* Copyright (C) 2015-2016 Genode Labs GmbH * Copyright (C) 2015-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
*/ */
/* Linux kit includes */ /* Linux kit includes */
#include <lx_kit/env.h>
#include <lx_kit/pci_dev_registry.h> #include <lx_kit/pci_dev_registry.h>
#include <lx_kit/mapped_io_mem_range.h> #include <lx_kit/mapped_io_mem_range.h>
@ -49,7 +50,7 @@ extern "C" int pci_register_driver(struct pci_driver *driver)
return false; return false;
/* create 'pci_dev' struct for matching device */ /* create 'pci_dev' struct for matching device */
pci_dev = new (env()->heap()) Lx::Pci_dev(cap); pci_dev = new (&Lx_kit::env().heap()) Lx::Pci_dev(cap);
/* enable ioremap to work */ /* enable ioremap to work */
Lx::pci_dev_registry()->insert(pci_dev); Lx::pci_dev_registry()->insert(pci_dev);

5
repos/dde_linux/src/include/lx_kit/irq.h
View File

@ -7,7 +7,7 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -17,7 +17,6 @@
#define _LX_KIT__IRQ_H_ #define _LX_KIT__IRQ_H_
/* Genode includes */ /* Genode includes */
#include <os/server.h>
#include <platform_device/platform_device.h> #include <platform_device/platform_device.h>
@ -27,7 +26,7 @@ class Lx::Irq
{ {
public: public:
static Irq &irq(Server::Entrypoint *ep = nullptr, static Irq &irq(Genode::Entrypoint *ep = nullptr,
Genode::Allocator *alloc = nullptr); Genode::Allocator *alloc = nullptr);
/** /**

4
repos/dde_linux/src/include/lx_kit/malloc.h
View File

@ -7,7 +7,7 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -25,6 +25,8 @@
namespace Lx { namespace Lx {
class Malloc; class Malloc;
void malloc_init(Genode::Env &env, Genode::Allocator &md_alloc);
} }

26
repos/dde_linux/src/include/lx_kit/pci.h Normal file
View File

@ -0,0 +1,26 @@
/*
* \brief PCI backend
* \author Josef Soentgen
* \date 2017-02-12
*/
/*
* Copyright (C) 2017 Genode Labs GmbH
*
* This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2.
*/
#ifndef _LX_KIT__PCI_H_
#define _LX_KIT__PCI_H_
/* Genode includes */
#include <base/env.h>
namespace Lx {
void pci_init(Genode::Env&, Genode::Ram_session&, Genode::Allocator&);
}
#endif /* _LX_KIT__PCI_H_ */

3
repos/dde_linux/src/include/lx_kit/pci_dev_registry.h
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2015 Genode Labs GmbH * Copyright (C) 2015-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -15,6 +15,7 @@
#define _LX_KIT__PCI_DEV_REGISTRY_H_ #define _LX_KIT__PCI_DEV_REGISTRY_H_
/* Linux emulation environment includes */ /* Linux emulation environment includes */
#include <lx_kit/pci.h>
#include <lx_kit/internal/pci_dev.h> #include <lx_kit/internal/pci_dev.h>
namespace Lx { namespace Lx {

7
repos/dde_linux/src/include/lx_kit/scheduler.h
View File

@ -7,7 +7,7 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -16,6 +16,9 @@
#ifndef _LX_KIT__SCHEDULER_H_ #ifndef _LX_KIT__SCHEDULER_H_
#define _LX_KIT__SCHEDULER_H_ #define _LX_KIT__SCHEDULER_H_
/* Genode includes */
#include <base/env.h>
namespace Lx { namespace Lx {
class Task; class Task;
@ -26,7 +29,7 @@ namespace Lx {
* *
* Implementation must be provided by the driver. * Implementation must be provided by the driver.
*/ */
Scheduler &scheduler(); Scheduler &scheduler(Genode::Env *env = nullptr);
} }

14
repos/dde_linux/src/include/lx_kit/timer.h
View File

@ -7,7 +7,7 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -17,7 +17,7 @@
#define _LX_KIT__TIMER_H_ #define _LX_KIT__TIMER_H_
/* Genode includes */ /* Genode includes */
#include <os/server.h> #include <base/entrypoint.h>
namespace Lx { namespace Lx {
@ -32,7 +32,9 @@ namespace Lx {
* \param jiffies_ptr pointer to jiffies counter to be periodically * \param jiffies_ptr pointer to jiffies counter to be periodically
* updated * updated
*/ */
Timer &timer(Server::Entrypoint *ep = nullptr, Timer &timer(Genode::Env *env = nullptr,
Genode::Entrypoint *ep = nullptr,
Genode::Allocator *md_alloc = nullptr,
unsigned long *jiffies_ptr = nullptr); unsigned long *jiffies_ptr = nullptr);
void timer_update_jiffies(); void timer_update_jiffies();
@ -47,6 +49,7 @@ class Lx::Timer
public: public:
enum Type { LIST, HR }; enum Type { LIST, HR };
/** /**
* Add new linux timer * Add new linux timer
*/ */
@ -81,6 +84,11 @@ class Lx::Timer
* Update jiffie counter * Update jiffie counter
*/ */
virtual void update_jiffies() = 0; virtual void update_jiffies() = 0;
/**
* Suspend calling thread
*/
virtual void usleep(unsigned us) = 0;
}; };

324
repos/dde_linux/src/lib/libnl/lxcc_emul.cc
View File

@ -5,13 +5,13 @@
*/ */
/* /*
* Copyright (C) 2014 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
*/ */
/* Genode */ /* Genode includes */
#include <base/log.h> #include <base/log.h>
#include <util/string.h> #include <util/string.h>
@ -33,323 +33,3 @@ extern "C" char *getenv(const char *name)
return nullptr; return nullptr;
} }
#if 0
#include <base/env.h>
#include <base/log.h>
#include <base/snprintf.h>
#include <dataspace/client.h>
#include <timer_session/connection.h>
#include <rom_session/connection.h>
#include <util/string.h>
#include <lx_emul.h>
extern "C" {
/*************
** errno.h **
*************/
int errno;
/*************
** stdio.h **
*************/
FILE *stdout;
FILE *stderr;
void *malloc(size_t size)
{
/* align on pointer size */
size = size + ((sizeof(Genode::addr_t)-1) & ~(sizeof(Genode::addr_t)-1));
size_t rsize = size + sizeof (Genode::addr_t);
void *addr = 0;
if (!Genode::env()->heap()->alloc(size, &addr))
return 0;
*(Genode::addr_t*)addr = rsize;
return ((Genode::addr_t*)addr) + 1;
}
void *calloc(size_t nmemb, size_t size)
{
#define MUL_NO_OVERFLOW (1UL << (sizeof(size_t) * 4))
if ((nmemb >= MUL_NO_OVERFLOW || size >= MUL_NO_OVERFLOW) &&
nmemb > 0 && SIZE_MAX / nmemb < size) {
return NULL;
}
size *= nmemb;
void *addr = malloc(size);
Genode::memset(addr, 0, size);
return addr;
}
void free(void *ptr)
{
if (!ptr)
return;
Genode::addr_t *addr = ((Genode::addr_t*)ptr) - 1;
Genode::env()->heap()->free(addr, *addr);
}
void *realloc(void *ptr, Genode::size_t size)
{
if (!size)
free(ptr);
void *n = malloc(size);
size_t s = *((size_t *)ptr - 1);
Genode::memcpy(n, ptr, Genode::min(s, size));
free(ptr);
return n;
}
/**************
** stdlib.h **
**************/
static char getenv_HZ[] = "100";
static char getenv_TICKS_PER_USEC[] = "10000";
char *getenv(const char *name)
{
/* these values must match the ones of lx_emul wifi */
if (Genode::strcmp(name, "HZ") == 0) return getenv_HZ;
if (Genode::strcmp(name, "TICKS_PER_USEC") == 0) return getenv_TICKS_PER_USEC;
return nullptr;
}
long int strtol(const char *nptr, char **endptr, int base)
{
long res = 0;
if (base != 0 && base != 10) {
Genode::error("strtol: base of ", base, " is not supported");
return 0;
}
Genode::ascii_to(nptr, res);
return res;
}
double strtod(const char *nptr, char **endptr)
{
double res = 0;
Genode::ascii_to(nptr, res);
return res;
}
/********************
** linux/string.h **
********************/
size_t strcspn(const char *s, const char *reject)
{
for (char const *p = s; *p; p++) {
char c = *p;
for (char const *r = reject; *r; r++) {
char d = *r;
if (c == d)
return (p - 1 - s);
}
}
return 0;
}
char *strdup(const char *s)
{
size_t len = strlen(s);
char *p = (char *) malloc(len + 1);
return strncpy(p, s, len + 1);
}
size_t strlen(const char *s)
{
return Genode::strlen(s);
}
int strcasecmp(const char* s1, const char *s2)
{
return Genode::strcmp(s1, s2);
}
int strcmp(const char* s1, const char *s2)
{
return Genode::strcmp(s1, s2);
}
int strncmp(const char *s1, const char *s2, size_t len)
{
return Genode::strcmp(s1, s2, len);
}
char *strchr(const char *p, int ch)
{
char c;
c = ch;
for (;; ++p) {
if (*p == c)
return ((char *)p);
if (*p == '\0')
break;
}
return 0;
}
void *memchr(const void *s, int c, size_t n)
{
const unsigned char *p = reinterpret_cast<const unsigned char*>(s);
while (n-- != 0) {
if ((unsigned char)c == *p++) {
return (void *)(p - 1);
}
}
return NULL;
}
char *strnchr(const char *p, size_t count, int ch)
{
char c;
c = ch;
for (; count; ++p, count--) {
if (*p == c)
return ((char *)p);
if (*p == '\0')
break;
}
return 0;
}
char *strncat(char *dst, const char *src, size_t n)
{
char *p = dst;
while (*p++) ;
while ((*p = *src) && (n-- > 0)) {
++src;
++p;
}
return dst;
}
char *strcpy(char *dst, const char *src)
{
char *p = dst;
while ((*dst = *src)) {
++src;
++dst;
}
return p;
}
char *strncpy(char *dst, const char* src, size_t n)
{
return Genode::strncpy(dst, src, n);
}
int snprintf(char *str, size_t size, const char *format, ...)
{
va_list list;
va_start(list, format);
Genode::String_console sc(str, size);
sc.vprintf(format, list);
va_end(list);
return sc.len();
}
int vsnprintf(char *str, size_t size, const char *format, va_list args)
{
Genode::String_console sc(str, size);
sc.vprintf(format, args);
return sc.len();
}
int asprintf(char **strp, const char *fmt, ...)
{
/* XXX for now, let's hope strings are not getting longer than 256 bytes */
enum { MAX_STRING_LENGTH = 256 };
char *p = (char*)malloc(MAX_STRING_LENGTH);
if (!p)
return -1;
va_list args;
va_start(args, fmt);
Genode::String_console sc(p, MAX_STRING_LENGTH);
sc.vprintf(fmt, args);
va_end(args);
return strlen(p);
}
/**************
** unistd.h **
**************/
int getpagesize(void) {
return 4096; }
pid_t getpid(void) {
return 42; }
/************
** time.h **
************/
extern unsigned long jiffies;
time_t time(time_t *t)
{
return jiffies;
}
} /* extern "C" */
#endif

70
repos/dde_linux/src/lib/libnl/socket.cc
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2014 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -61,12 +61,10 @@ using namespace Wifi;
extern Socket_call socket_call; extern Socket_call socket_call;
struct Socket_fd : public Genode::List<Socket_fd>::Element struct Socket_fd
{ {
Socket *s; Socket *s;
int fd; int fd;
Socket_fd(Socket *s, int fd) : s(s), fd(fd) { }
}; };
@ -75,47 +73,77 @@ class Socket_registry
private : private :
/* abritary value (it goes to eleven!) */ /* abritary value (it goes to eleven!) */
enum { SOCKETS_INITIAL_VALUE = 11, }; enum {
SOCKETS_INITIAL_VALUE = 11,
MAX_SOCKETS = 7,
};
static Socket_fd _socket_fd[MAX_SOCKETS];
static unsigned _sockets; static unsigned _sockets;
static Genode::List<Socket_fd> *_list() /* XXX ptr array instead of list? */ template <typename FUNC>
static void _for_each_socket_fd(FUNC const & func)
{ {
static Genode::List<Socket_fd> _l; for (int i = 0; i < MAX_SOCKETS; i++) {
return &_l; if (func(_socket_fd[i])) { break; }
}
} }
public: public:
static int insert(Socket *s) static int insert(Socket *s)
{ {
Socket_fd *sfd = new (Genode::env()->heap()) Socket_fd(s, ++_sockets); int fd = -1;
_list()->insert(sfd); auto lambda = [&] (Socket_fd &sfd) {
if (sfd.s != nullptr) { return false; }
return sfd->fd; sfd.s = s;
sfd.fd = ++_sockets;
/* return fd */
fd = sfd.fd;
return true;
};
_for_each_socket_fd(lambda);
return fd;
} }
static void remove(Socket *s) static void remove(Socket *s)
{ {
for (Socket_fd *sfd = _list()->first(); sfd; sfd = sfd->next()) auto lambda = [&] (Socket_fd &sfd) {
if (sfd->s == s) { if (sfd.s != s) { return false; }
_list()->remove(sfd);
destroy(Genode::env()->heap(), sfd); sfd.s = nullptr;
break; sfd.fd = 0;
}
return true;
};
_for_each_socket_fd(lambda);
} }
static Socket *find(int fd) static Socket *find(int fd)
{ {
for (Socket_fd *sfd = _list()->first(); sfd; sfd = sfd->next()) Socket *s = nullptr;
if (sfd->fd == fd)
return sfd->s;
return 0; auto lambda = [&] (Socket_fd &sfd) {
if (sfd.fd != fd) { return false; }
/* return socket */
s = sfd.s;
return true;
};
_for_each_socket_fd(lambda);
return s;
} }
}; };
Socket_fd Socket_registry::_socket_fd[MAX_SOCKETS] = {};
unsigned Socket_registry::_sockets = Socket_registry::SOCKETS_INITIAL_VALUE; unsigned Socket_registry::_sockets = Socket_registry::SOCKETS_INITIAL_VALUE;

4
repos/dde_linux/src/lib/lxip/socket_handler.cc
View File

@ -24,6 +24,7 @@
/* Lx_kit */ /* Lx_kit */
#include <lx_kit/env.h> #include <lx_kit/env.h>
#include <lx_kit/malloc.h>
static const bool verbose = false; static const bool verbose = false;
@ -627,10 +628,11 @@ Lxip::Socketcall & Lxip::init(Genode::Env &env,
static Net::Socketcall socketcall(env); static Net::Socketcall socketcall(env);
Lx::lxcc_emul_init(lx_env);
Lx::malloc_init(env, lx_env.heap());
Lx::timer_init(env, socketcall, lx_env.heap(), ticker); Lx::timer_init(env, socketcall, lx_env.heap(), ticker);
Lx::event_init(env, socketcall, ticker); Lx::event_init(env, socketcall, ticker);
Lx::nic_client_init(env, socketcall, lx_env.heap(), ticker); Lx::nic_client_init(env, socketcall, lx_env.heap(), ticker);
Lx::lxcc_emul_init(lx_env);
lxip_init(); lxip_init();

5
repos/dde_linux/src/lib/usb/include/platform.h
View File

@ -7,7 +7,7 @@
*/ */
/* /*
* Copyright (C) 2012-2013 Genode Labs GmbH * Copyright (C) 2012-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -18,7 +18,6 @@
#include <base/log.h> #include <base/log.h>
#include <util/xml_node.h> #include <util/xml_node.h>
#include <os/signal_rpc_dispatcher.h>
#include <irq_session/capability.h> #include <irq_session/capability.h>
#include <lx_kit/env.h> #include <lx_kit/env.h>
@ -122,6 +121,8 @@ struct Services
} }
}; };
void backend_alloc_init(Genode::Env &env, Genode::Ram_session &ram, Genode::Allocator &alloc);
void platform_hcd_init(Services *services); void platform_hcd_init(Services *services);
Genode::Irq_session_capability platform_irq_activate(int irq); Genode::Irq_session_capability platform_irq_activate(int irq);

12
repos/dde_linux/src/lib/usb/include/spec/arm/platform_device/platform_device.h
View File

@ -8,7 +8,7 @@
*/ */
/* /*
* Copyright (C) 2016 Genode Labs GmbH * Copyright (C) 2016-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -34,17 +34,19 @@ namespace Platform { struct Device; }
struct Platform::Device : Platform::Abstract_device, Genode::List<Device>::Element struct Platform::Device : Platform::Abstract_device, Genode::List<Device>::Element
{ {
Genode::Env &env;
unsigned irq_num; unsigned irq_num;
Genode::Constructible<Genode::Irq_connection> irq_connection; Genode::Constructible<Genode::Irq_connection> irq_connection;
Device(unsigned irq) : irq_num(irq) { } Device(Genode::Env &env, unsigned irq) : env(env), irq_num(irq) { }
unsigned vendor_id() { return ~0U; } unsigned vendor_id() { return ~0U; }
unsigned device_id() { return ~0U; } unsigned device_id() { return ~0U; }
Genode::Irq_session_capability irq(Genode::uint8_t) override Genode::Irq_session_capability irq(Genode::uint8_t) override
{ {
irq_connection.construct(irq_num); irq_connection.construct(env, irq_num);
return irq_connection->cap(); return irq_connection->cap();
} }
@ -62,14 +64,14 @@ struct Platform::Device : Platform::Abstract_device, Genode::List<Device>::Eleme
return l; return l;
} }
static Device &create(unsigned irq_num) static Device &create(Genode::Env &env, unsigned irq_num)
{ {
Device *d; Device *d;
for (d = list().first(); d; d = d->next()) for (d = list().first(); d; d = d->next())
if (d->irq_num == irq_num) if (d->irq_num == irq_num)
return *d; return *d;
d = new (Lx::Malloc::mem()) Device(irq_num); d = new (Lx::Malloc::mem()) Device(env, irq_num);
list().insert(d); list().insert(d);
return *d; return *d;

29
repos/dde_linux/src/lib/usb/input/input_component.cc
View File

@ -7,7 +7,7 @@
*/ */
/* /*
* Copyright (C) 2011-2013 Genode Labs GmbH * Copyright (C) 2011-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -26,27 +26,15 @@ using namespace Genode;
/** /**
* Return singleton instance of input-session component * Singleton instance of input-session component
*/ */
static Input::Session_component &input_session() static Genode::Constructible<Input::Session_component> _input_session;
{
static Input::Session_component inst;
return inst;
}
/** /**
* Return singleton instance of input-root component * Singleton instance of input-root component
*
* On the first call (from 'start_input_service'), the 'ep' argument is
* specified. All subsequent calls (from 'input_callback') just return the
* reference to the singleton instance.
*/ */
static Input::Root_component &input_root(Rpc_entrypoint *ep = 0) static Genode::Constructible<Input::Root_component> _input_root;
{
static Input::Root_component root(*ep, input_session());
return root;
}
/** /**
@ -66,7 +54,7 @@ static void input_callback(enum input_event_type type,
case EVENT_TYPE_TOUCH: t = Input::Event::TOUCH; break; case EVENT_TYPE_TOUCH: t = Input::Event::TOUCH; break;
} }
input_session().submit(Input::Event(t, code, _input_session->submit(Input::Event(t, code,
absolute_x, absolute_y, absolute_x, absolute_y,
relative_x, relative_y)); relative_x, relative_y));
} }
@ -78,7 +66,10 @@ void start_input_service(void *ep_ptr, void * service_ptr)
Services *service = static_cast<Services *>(service_ptr); Services *service = static_cast<Services *>(service_ptr);
Env &env = service->env; Env &env = service->env;
env.parent().announce(ep->manage(&input_root(ep))); _input_session.construct(env, env.ram());
_input_root.construct(*ep, *_input_session);
env.parent().announce(ep->manage(&*_input_root));
genode_input_register(input_callback, service->screen_width, genode_input_register(input_callback, service->screen_width,
service->screen_height, service->multitouch); service->screen_height, service->multitouch);

4
repos/dde_linux/src/lib/usb/lx_emul.cc
View File

@ -6,7 +6,7 @@
*/ */
/* /*
* Copyright (C) 2012-2013 Genode Labs GmbH * Copyright (C) 2012-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -43,7 +43,7 @@ void backtrace() { }
void pci_dev_put(struct pci_dev *pci_dev) void pci_dev_put(struct pci_dev *pci_dev)
{ {
Genode::destroy(Genode::env()->heap(), pci_dev); Genode::destroy(&Lx_kit::env().heap(), pci_dev);
} }
/*********************** /***********************

14
repos/dde_linux/src/lib/usb/main.cc
View File

@ -7,7 +7,7 @@
*/ */
/* /*
* Copyright (C) 2012-2014 Genode Labs GmbH * Copyright (C) 2012-2017 Genode Labs GmbH
* Copyright (C) 2014 Ksys Labs LLC * Copyright (C) 2014 Ksys Labs LLC
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
@ -17,7 +17,6 @@
/* Genode */ /* Genode */
#include <base/sleep.h> #include <base/sleep.h>
#include <os/server.h>
#include <nic_session/nic_session.h> #include <nic_session/nic_session.h>
/* Local */ /* Local */
@ -25,6 +24,7 @@
#include <lx_emul.h> #include <lx_emul.h>
#include <lx_kit/env.h> #include <lx_kit/env.h>
#include <lx_kit/pci.h>
#include <lx_kit/irq.h> #include <lx_kit/irq.h>
#include <lx_kit/malloc.h> #include <lx_kit/malloc.h>
#include <lx_kit/scheduler.h> #include <lx_kit/scheduler.h>
@ -107,6 +107,12 @@ void start_usb_driver(Genode::Env &env)
{ {
/* initialize USB env */ /* initialize USB env */
Lx_kit::construct_env(env); Lx_kit::construct_env(env);
/* sets up backend alloc needed by malloc */
backend_alloc_init(env, env.ram(), Lx_kit::env().heap());
Lx::malloc_init(env, Lx_kit::env().heap());
static Services services(env); static Services services(env);
if (services.hid) if (services.hid)
@ -118,8 +124,8 @@ void start_usb_driver(Genode::Env &env)
if (services.raw) if (services.raw)
Raw::init(env, services.raw_report_device_list); Raw::init(env, services.raw_report_device_list);
Lx::Scheduler &sched = Lx::scheduler(); Lx::Scheduler &sched = Lx::scheduler(&env);
Lx::Timer &timer = Lx::timer(&env.ep(), &jiffies); Lx::Timer &timer = Lx::timer(&env, &env.ep(), &Lx_kit::env().heap(), &jiffies);
Lx::Irq::irq(&env.ep(), &Lx_kit::env().heap()); Lx::Irq::irq(&env.ep(), &Lx_kit::env().heap());
Lx::Work::work_queue(&Lx_kit::env().heap()); Lx::Work::work_queue(&Lx_kit::env().heap());

3
repos/dde_linux/src/lib/usb/nic/nic.cc
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2012-2013 Genode Labs GmbH * Copyright (C) 2012-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -14,7 +14,6 @@
#include <base/rpc_server.h> #include <base/rpc_server.h>
#include <base/snprintf.h> #include <base/snprintf.h>
#include <nic_session/nic_session.h> #include <nic_session/nic_session.h>
#include <cap_session/connection.h>
#include <nic/xml_node.h> #include <nic/xml_node.h>
#include <util/xml_node.h> #include <util/xml_node.h>

11
repos/dde_linux/src/lib/usb/spec/arm/platform_generic.cc
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2016 Genode Labs GmbH * Copyright (C) 2016-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -22,6 +22,13 @@
** lx_kit/backend_alloc.h ** ** lx_kit/backend_alloc.h **
****************************/ ****************************/
void backend_alloc_init(Genode::Env&, Genode::Ram_session&,
Genode::Allocator&)
{
/* intentionally left blank */
}
Genode::Ram_dataspace_capability Genode::Ram_dataspace_capability
Lx::backend_alloc(Genode::addr_t size, Genode::Cache_attribute cached) { Lx::backend_alloc(Genode::addr_t size, Genode::Cache_attribute cached) {
return Lx_kit::env().env().ram().alloc(size, cached); } return Lx_kit::env().env().ram().alloc(size, cached); }
@ -38,7 +45,7 @@ void Lx::backend_free(Genode::Ram_dataspace_capability cap) {
extern "C" int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, extern "C" int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
const char *name, void *dev) const char *name, void *dev)
{ {
Lx::Irq::irq().request_irq(Platform::Device::create(irq), handler, dev); Lx::Irq::irq().request_irq(Platform::Device::create(Lx_kit::env().env(), irq), handler, dev);
return 0; return 0;
} }

13
repos/dde_linux/src/lib/usb/spec/x86/pci_driver.cc
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2016 Genode Labs GmbH * Copyright (C) 2016-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -194,3 +194,14 @@ int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
return -ENODEV; return -ENODEV;
} }
/*********************************
** Platform backend alloc init **
*********************************/
void backend_alloc_init(Genode::Env &env, Genode::Ram_session &ram,
Genode::Allocator &alloc)
{
Lx::pci_init(env, ram, alloc);
}

6
repos/dde_linux/src/lib/usb/spec/x86/platform.cc
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2013 Genode Labs GmbH * Copyright (C) 2013-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -43,7 +43,3 @@ void platform_hcd_init(Services *s)
if (s->uhci) if (s->uhci)
module_uhci_hcd_init(); module_uhci_hcd_init();
} }

1
repos/dde_linux/src/lib/usb/storage/storage.cc
View File

@ -14,7 +14,6 @@
#include <base/log.h> #include <base/log.h>
#include <base/rpc_server.h> #include <base/rpc_server.h>
#include <block/component.h> #include <block/component.h>
#include <cap_session/connection.h>
#include <util/endian.h> #include <util/endian.h>
#include <util/list.h> #include <util/list.h>

11
repos/dde_linux/src/lib/wifi/init.cc
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -21,10 +21,12 @@
#include <lx_emul.h> #include <lx_emul.h>
#include <lx_kit/malloc.h>
#include <lx_kit/env.h> #include <lx_kit/env.h>
#include <lx_kit/irq.h> #include <lx_kit/irq.h>
#include <lx_kit/work.h> #include <lx_kit/work.h>
#include <lx_kit/timer.h> #include <lx_kit/timer.h>
#include <lx_kit/pci.h>
extern "C" void core_netlink_proto_init(void); extern "C" void core_netlink_proto_init(void);
@ -142,9 +144,9 @@ void wifi_init(Genode::Env &env, Genode::Lock &lock, bool disable_11n)
/* add init_net namespace to namespace list */ /* add init_net namespace to namespace list */
list_add_tail_rcu(&init_net.list, &net_namespace_list); list_add_tail_rcu(&init_net.list, &net_namespace_list);
Lx::scheduler(); Lx::scheduler(&env);
Lx::timer(&env.ep(), &jiffies); Lx::timer(&env, &env.ep(), &Lx_kit::env().heap(), &jiffies);
Lx::Irq::irq(&env.ep(), &Lx_kit::env().heap()); Lx::Irq::irq(&env.ep(), &Lx_kit::env().heap());
Lx::Work::work_queue(&Lx_kit::env().heap()); Lx::Work::work_queue(&Lx_kit::env().heap());
@ -152,6 +154,9 @@ void wifi_init(Genode::Env &env, Genode::Lock &lock, bool disable_11n)
Lx::socket_init(env.ep(), Lx_kit::env().heap()); Lx::socket_init(env.ep(), Lx_kit::env().heap());
Lx::nic_init(env, Lx_kit::env().heap()); Lx::nic_init(env, Lx_kit::env().heap());
Lx::pci_init(env, env.ram(), Lx_kit::env().heap());
Lx::malloc_init(env, Lx_kit::env().heap());
/* set IWL_DISABLE_HT_ALL if disable 11n is requested */ /* set IWL_DISABLE_HT_ALL if disable 11n is requested */
if (disable_11n) { if (disable_11n) {
Genode::log("Disable 11n mode"); Genode::log("Disable 11n mode");

5
repos/dde_linux/src/lib/wifi/lx.h
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2014 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -14,9 +14,6 @@
#ifndef _LX_H_ #ifndef _LX_H_
#define _LX_H_ #define _LX_H_
/* Genode includes */
#include <os/server.h>
/* local includes */ /* local includes */
#include <lx_kit/scheduler.h> #include <lx_kit/scheduler.h>

6
repos/dde_linux/src/lib/wifi/lxcc_emul.cc
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -723,7 +723,7 @@ int request_firmware_nowait(struct module *module, bool uevent,
char const *fw_name = fwl->available_name char const *fw_name = fwl->available_name
? fwl->available_name : fwl->requested_name; ? fwl->available_name : fwl->requested_name;
Genode::Rom_connection rom(fw_name); Genode::Rom_connection rom(Lx_kit::env().env(), fw_name);
Genode::Dataspace_capability ds_cap = rom.dataspace(); Genode::Dataspace_capability ds_cap = rom.dataspace();
if (!ds_cap.valid()) { if (!ds_cap.valid()) {
@ -1225,7 +1225,7 @@ int request_module(char const* format, ...)
* XXX We have to create the waiters list lazy because the way * XXX We have to create the waiters list lazy because the way
* DEFINE_MUTEX is currently implemented does not work w/o * DEFINE_MUTEX is currently implemented does not work w/o
* a global Env that was constructed before the static ctors * a global Env that was constructed before the static ctors
* are called. * are called
*/ */
static inline void __check_or_initialize_mutex(struct mutex *m) static inline void __check_or_initialize_mutex(struct mutex *m)
{ {

3
repos/dde_linux/src/lib/wifi/nic.cc
View File

@ -17,7 +17,6 @@
#include <base/rpc_server.h> #include <base/rpc_server.h>
#include <base/snprintf.h> #include <base/snprintf.h>
#include <base/tslab.h> #include <base/tslab.h>
#include <cap_session/connection.h>
#include <nic/xml_node.h> #include <nic/xml_node.h>
#include <nic/component.h> #include <nic/component.h>
#include <root/component.h> #include <root/component.h>
@ -93,7 +92,7 @@ class Wifi_session_component : public Nic::Session_component
Genode::Allocator &rx_block_md_alloc, Genode::Allocator &rx_block_md_alloc,
Genode::Ram_session &ram_session, Genode::Ram_session &ram_session,
Genode::Region_map &region_map, Genode::Region_map &region_map,
Server::Entrypoint &ep, net_device *ndev) Genode::Entrypoint &ep, net_device *ndev)
: Session_component(tx_buf_size, rx_buf_size, rx_block_md_alloc, : Session_component(tx_buf_size, rx_buf_size, rx_block_md_alloc,
ram_session, region_map, ep), ram_session, region_map, ep),
_ndev(ndev) _ndev(ndev)

6
repos/dde_linux/src/lib/wifi/socket_call.cc
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -128,7 +128,7 @@ class Lx::Socket
Genode::Signal_transmitter _sender; Genode::Signal_transmitter _sender;
Genode::Signal_rpc_member<Lx::Socket> _dispatcher; Genode::Signal_handler<Lx::Socket> _dispatcher;
Lx::Task _task; Lx::Task _task;
struct socket *_call_socket() struct socket *_call_socket()
@ -326,7 +326,7 @@ class Lx::Socket
_call.handle->non_block = _call.non_block.value; _call.handle->non_block = _call.non_block.value;
} }
void _handle(unsigned) void _handle()
{ {
_task.unblock(); _task.unblock();
Lx::scheduler().schedule(); Lx::scheduler().schedule();

28
repos/dde_linux/src/lib/wpa_supplicant/reporter.cc
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2014 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -29,8 +29,18 @@ extern "C" {
} }
static Genode::Reporter accesspoints_reporter = { "wlan_accesspoints" }; static Genode::Constructible<Genode::Reporter> accesspoints_reporter;
static Genode::Reporter state_reporter = { "wlan_state" }; static Genode::Constructible<Genode::Reporter> state_reporter;
extern "C" void wpa_reporter_init(void *env)
{
accesspoints_reporter.construct(*static_cast<Genode::Env*>(env), "wlan_accesspoints");
accesspoints_reporter->enabled(true);
state_reporter.construct(*static_cast<Genode::Env*>(env), "wlan_state");
state_reporter->enabled(true);
}
enum { SSID_MAX_LEN = 32 + 1, MAC_STR_LEN = 6*2 + 5 + 1}; enum { SSID_MAX_LEN = 32 + 1, MAC_STR_LEN = 6*2 + 5 + 1};
@ -45,10 +55,8 @@ static inline void mac2str(char *buf, u8 const *mac)
extern "C" void wpa_report_connect_event(struct wpa_supplicant *wpa_s) extern "C" void wpa_report_connect_event(struct wpa_supplicant *wpa_s)
{ {
state_reporter.enabled(true);
try { try {
Genode::Reporter::Xml_generator xml(state_reporter, [&]() { Genode::Reporter::Xml_generator xml(*state_reporter, [&]() {
struct wpa_ssid *wpa_ssid = wpa_s->current_ssid; struct wpa_ssid *wpa_ssid = wpa_s->current_ssid;
/* FIXME ssid may contain any characters, even NUL */ /* FIXME ssid may contain any characters, even NUL */
@ -70,10 +78,8 @@ extern "C" void wpa_report_connect_event(struct wpa_supplicant *wpa_s)
extern "C" void wpa_report_disconnect_event(struct wpa_supplicant *wpa_s) extern "C" void wpa_report_disconnect_event(struct wpa_supplicant *wpa_s)
{ {
state_reporter.enabled(true);
try { try {
Genode::Reporter::Xml_generator xml(state_reporter, [&]() { Genode::Reporter::Xml_generator xml(*state_reporter, [&]() {
struct wpa_ssid *wpa_ssid = wpa_s->current_ssid; struct wpa_ssid *wpa_ssid = wpa_s->current_ssid;
/* FIXME ssid may contain any characters, even NUL */ /* FIXME ssid may contain any characters, even NUL */
@ -113,10 +119,8 @@ static inline int approximate_quality(struct wpa_bss *bss)
extern "C" void wpa_report_scan_results(struct wpa_supplicant *wpa_s) extern "C" void wpa_report_scan_results(struct wpa_supplicant *wpa_s)
{ {
accesspoints_reporter.enabled(true);
try { try {
Genode::Reporter::Xml_generator xml(accesspoints_reporter, [&]() { Genode::Reporter::Xml_generator xml(*accesspoints_reporter, [&]() {
for (unsigned i = 0; i < wpa_s->last_scan_res_used; i++) { for (unsigned i = 0; i < wpa_s->last_scan_res_used; i++) {
struct wpa_bss *bss = wpa_s->last_scan_res[i]; struct wpa_bss *bss = wpa_s->last_scan_res[i];

1
repos/dde_linux/src/lib/wpa_supplicant/symbol.map
View File

@ -6,6 +6,7 @@
/* needed by wifi_drv */ /* needed by wifi_drv */
wpa_main; wpa_main;
wpa_reporter_init;
/* needed by wpa_driver_nl80211 */ /* needed by wpa_driver_nl80211 */
__hide_aliasing_typecast; __hide_aliasing_typecast;

12
repos/dde_linux/src/lx_kit/irq.cc
View File

@ -7,7 +7,7 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -113,7 +113,7 @@ class Lx_kit::Irq : public Lx::Irq
/** /**
* Constructor * Constructor
*/ */
Context(Server::Entrypoint &ep, Context(Genode::Entrypoint &ep,
Platform::Device &dev) Platform::Device &dev)
: :
_name(dev), _name(dev),
@ -166,7 +166,7 @@ class Lx_kit::Irq : public Lx::Irq
using Context_slab = Genode::Tslab<Context, 3 * sizeof(Context)>; using Context_slab = Genode::Tslab<Context, 3 * sizeof(Context)>;
using Handler_slab = Genode::Tslab<Handler, 3 * sizeof(Handler)>; using Handler_slab = Genode::Tslab<Handler, 3 * sizeof(Handler)>;
Server::Entrypoint &_ep; Genode::Entrypoint &_ep;
Lx_kit::List<Context> _list; Lx_kit::List<Context> _list;
Context_slab _context_alloc; Context_slab _context_alloc;
Handler_slab _handler_alloc; Handler_slab _handler_alloc;
@ -181,14 +181,14 @@ class Lx_kit::Irq : public Lx::Irq
return nullptr; return nullptr;
} }
Irq(Server::Entrypoint &ep, Genode::Allocator &alloc) Irq(Genode::Entrypoint &ep, Genode::Allocator &alloc)
: _ep(ep), : _ep(ep),
_context_alloc(&alloc), _context_alloc(&alloc),
_handler_alloc(&alloc) { } _handler_alloc(&alloc) { }
public: public:
static Irq &irq(Server::Entrypoint &ep, Genode::Allocator &alloc) static Irq &irq(Genode::Entrypoint &ep, Genode::Allocator &alloc)
{ {
static Irq inst(ep, alloc); static Irq inst(ep, alloc);
return inst; return inst;
@ -227,5 +227,5 @@ class Lx_kit::Irq : public Lx::Irq
** Lx::Irq implementation ** ** Lx::Irq implementation **
****************************/ ****************************/
Lx::Irq &Lx::Irq::irq(Server::Entrypoint *ep, Genode::Allocator *alloc) { Lx::Irq &Lx::Irq::irq(Genode::Entrypoint *ep, Genode::Allocator *alloc) {
return Lx_kit::Irq::irq(*ep, *alloc); } return Lx_kit::Irq::irq(*ep, *alloc); }

65
repos/dde_linux/src/lx_kit/malloc.cc
View File

@ -7,7 +7,7 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -80,26 +80,17 @@ class Lx_kit::Slab_backend_alloc : public Lx::Slab_backend_alloc,
public: public:
Slab_backend_alloc(Genode::Cache_attribute cached) Slab_backend_alloc(Genode::Env &env, Genode::Allocator &md_alloc,
Genode::Cache_attribute cached)
: :
Rm_connection(env),
Region_map_client(Rm_connection::create(VM_SIZE)), Region_map_client(Rm_connection::create(VM_SIZE)),
_cached(cached), _index(0), _range(Genode::env()->heap()) _cached(cached), _index(0), _range(&md_alloc)
{ {
/* reserver attach us, anywere */ /* reserver attach us, anywere */
_base = Genode::env()->rm_session()->attach(dataspace()); _base = env.rm().attach(dataspace());
} }
static Slab_backend_alloc &mem()
{
static Lx_kit::Slab_backend_alloc inst(Genode::CACHED);
return inst;
}
static Slab_backend_alloc &dma()
{
static Lx_kit::Slab_backend_alloc inst(Genode::UNCACHED);
return inst;
}
/************************************** /**************************************
** Lx::Slab_backend_alloc interface ** ** Lx::Slab_backend_alloc interface **
@ -178,7 +169,7 @@ class Lx_kit::Malloc : public Lx::Malloc
typedef Lx::Slab_backend_alloc Slab_backend_alloc; typedef Lx::Slab_backend_alloc Slab_backend_alloc;
Slab_backend_alloc &_back_allocator; Slab_backend_alloc &_back_allocator;
Slab_alloc *_allocator[NUM_SLABS]; Genode::Constructible<Slab_alloc> _allocator[NUM_SLABS];
Genode::Cache_attribute _cached; /* cached or un-cached memory */ Genode::Cache_attribute _cached; /* cached or un-cached memory */
addr_t _start; /* VM region of this allocator */ addr_t _start; /* VM region of this allocator */
addr_t _end; addr_t _end;
@ -233,21 +224,9 @@ class Lx_kit::Malloc : public Lx::Malloc
{ {
/* init slab allocators */ /* init slab allocators */
for (unsigned i = SLAB_START_LOG2; i <= SLAB_STOP_LOG2; i++) for (unsigned i = SLAB_START_LOG2; i <= SLAB_STOP_LOG2; i++)
_allocator[i - SLAB_START_LOG2] = new (Genode::env()->heap()) _allocator[i - SLAB_START_LOG2].construct(1U << i, alloc);
Slab_alloc(1U << i, alloc);
} }
static Malloc & mem()
{
static Malloc inst(Slab_backend_alloc::mem(), Genode::CACHED);
return inst;
}
static Malloc & dma()
{
static Malloc inst(Slab_backend_alloc::dma(), Genode::UNCACHED);
return inst;
}
/************************** /**************************
** Lx::Malloc interface ** ** Lx::Malloc interface **
@ -333,7 +312,6 @@ class Lx_kit::Malloc : public Lx::Malloc
_back_allocator.free(ptr); _back_allocator.free(ptr);
} }
size_t size(void const *a) size_t size(void const *a)
{ {
using namespace Genode; using namespace Genode;
@ -357,29 +335,42 @@ class Lx_kit::Malloc : public Lx::Malloc
** Lx::Malloc implementation ** ** Lx::Malloc implementation **
*******************************/ *******************************/
static Genode::Constructible<Lx_kit::Slab_backend_alloc> _mem_backend_alloc;
static Genode::Constructible<Lx_kit::Slab_backend_alloc> _dma_backend_alloc;
static Genode::Constructible<Lx_kit::Malloc> _mem_alloc;
static Genode::Constructible<Lx_kit::Malloc> _dma_alloc;
void Lx::malloc_init(Genode::Env &env, Genode::Allocator &md_alloc)
{
_mem_backend_alloc.construct(env, md_alloc, Genode::CACHED);
_dma_backend_alloc.construct(env, md_alloc, Genode::UNCACHED);
_mem_alloc.construct(*_mem_backend_alloc, Genode::CACHED);
_dma_alloc.construct(*_dma_backend_alloc, Genode::UNCACHED);
}
/** /**
* Cached memory backend allocator * Cached memory backend allocator
*/ */
Lx::Slab_backend_alloc &Lx::Slab_backend_alloc::mem() { Lx::Slab_backend_alloc &Lx::Slab_backend_alloc::mem() {
return Lx_kit::Slab_backend_alloc::mem(); } return *_mem_backend_alloc; }
/** /**
* DMA memory backend allocator * DMA memory backend allocator
*/ */
Lx::Slab_backend_alloc &Lx::Slab_backend_alloc::dma() { Lx::Slab_backend_alloc &Lx::Slab_backend_alloc::dma() {
return Lx_kit::Slab_backend_alloc::dma(); } return *_dma_backend_alloc; }
/** /**
* Cached memory allocator * Cached memory allocator
*/ */
Lx::Malloc &Lx::Malloc::mem() { Lx::Malloc &Lx::Malloc::mem() { return *_mem_alloc; }
return Lx_kit::Malloc::mem(); }
/** /**
* DMA memory allocator * DMA memory allocator
*/ */
Lx::Malloc &Lx::Malloc::dma() { Lx::Malloc &Lx::Malloc::dma() { return *_dma_alloc; }
return Lx_kit::Malloc::dma(); }

52
repos/dde_linux/src/lx_kit/mapped_io_mem_range.cc
View File

@ -5,7 +5,7 @@
*/ */
/* /*
* Copyright (C) 2015-2016 Genode Labs GmbH * Copyright (C) 2015-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -21,6 +21,7 @@
#include <lx_emul.h> #include <lx_emul.h>
/* Linux emulation environment includes */ /* Linux emulation environment includes */
#include <lx_kit/env.h>
#include <lx_kit/internal/list.h> #include <lx_kit/internal/list.h>
#include <lx_kit/mapped_io_mem_range.h> #include <lx_kit/mapped_io_mem_range.h>
#include <lx_kit/pci_dev_registry.h> #include <lx_kit/pci_dev_registry.h>
@ -34,8 +35,7 @@ namespace Lx_kit { class Mapped_io_mem_range; }
* *
* This class is supposed to be a private utility to support 'ioremap'. * This class is supposed to be a private utility to support 'ioremap'.
*/ */
class Lx_kit::Mapped_io_mem_range : public Lx_kit::List<Mapped_io_mem_range>::Element, class Lx_kit::Mapped_io_mem_range : public Lx_kit::List<Mapped_io_mem_range>::Element
public Genode::Rm_connection
{ {
private: private:
@ -47,15 +47,20 @@ class Lx_kit::Mapped_io_mem_range : public Lx_kit::List<Mapped_io_mem_range>::El
public: public:
Mapped_io_mem_range(Genode::addr_t phys, Genode::size_t size, Mapped_io_mem_range(Genode::Env &env,
Genode::Rm_connection &rm,
Genode::addr_t phys, Genode::size_t size,
Genode::Io_mem_dataspace_capability ds_cap, Genode::Io_mem_dataspace_capability ds_cap,
Genode::addr_t offset) Genode::addr_t offset)
: _size(size), :
_size(size),
_phys(phys), _phys(phys),
_region_map(Rm_connection::create(size)), _region_map(rm.create(size)),
_ds(_region_map.dataspace()), _ds(env.rm(), _region_map.dataspace()),
_virt((Genode::addr_t)_ds.local_addr<void>() | (phys &0xfffUL)) { _virt((Genode::addr_t)_ds.local_addr<void>() | (phys &0xfffUL))
_region_map.attach_at(ds_cap, 0, size, offset); } {
_region_map.attach_at(ds_cap, 0, size, offset);
}
Genode::addr_t phys() const { return _phys; } Genode::addr_t phys() const { return _phys; }
Genode::addr_t virt() const { return _virt; } Genode::addr_t virt() const { return _virt; }
@ -82,9 +87,12 @@ class Lx_kit::Mapped_io_mem_range : public Lx_kit::List<Mapped_io_mem_range>::El
static Lx_kit::List<Lx_kit::Mapped_io_mem_range> ranges; static Lx_kit::List<Lx_kit::Mapped_io_mem_range> ranges;
/******************************************** /************************************************
** Lx_kit::Mapped_io_mem_range implementation ** ** Lx_kit::Mapped_io_mem_range implementation **
********************************************/ ************************************************/
static Genode::Constructible<Genode::Rm_connection> _global_rm;
void *Lx::ioremap(addr_t phys_addr, unsigned long size, void *Lx::ioremap(addr_t phys_addr, unsigned long size,
Genode::Cache_attribute cache_attribute) Genode::Cache_attribute cache_attribute)
@ -113,9 +121,23 @@ void *Lx::ioremap(addr_t phys_addr, unsigned long size,
return nullptr; return nullptr;
} }
Lx_kit::Mapped_io_mem_range *io_mem = if (!_global_rm.constructed()) {
new (env()->heap()) Lx_kit::Mapped_io_mem_range(phys_addr, size, _global_rm.construct(Lx_kit::env().env());
ds_cap, offset); }
Lx_kit::Mapped_io_mem_range *io_mem = nullptr;
retry<Genode::Region_map::Out_of_metadata>(
[&] () {
io_mem = new (&Lx_kit::env().heap())
Lx_kit::Mapped_io_mem_range(Lx_kit::env().env(), *_global_rm,
phys_addr, size, ds_cap, offset);
},
[&] () {
_global_rm->upgrade_ram(16384);
},
10
);
ranges.insert(io_mem); ranges.insert(io_mem);
@ -134,7 +156,7 @@ void Lx::iounmap(volatile void * virt)
if (r->virt() == (addr_t)virt) { if (r->virt() == (addr_t)virt) {
ranges.remove(r); ranges.remove(r);
destroy(env()->heap(), r); destroy(&Lx_kit::env().heap(), r);
return; return;
} }
} }

92
repos/dde_linux/src/lx_kit/pci.cc
View File

@ -7,7 +7,7 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -53,22 +53,59 @@ struct Lx_kit::Memory_object_base : Genode::Object_pool<Memory_object_base>::Ent
struct Lx_kit::Ram_object : Memory_object_base struct Lx_kit::Ram_object : Memory_object_base
{ {
Ram_object(Genode::Ram_dataspace_capability cap) Genode::Ram_session &_ram;
: Memory_object_base(cap) {}
void free() { Genode::env()->ram_session()->free(ram_cap()); } Ram_object(Genode::Ram_session &ram,
Genode::Ram_dataspace_capability cap)
: Memory_object_base(cap), _ram(ram) {}
void free() { _ram.free(ram_cap()); }
}; };
struct Lx_kit::Dma_object : Memory_object_base struct Lx_kit::Dma_object : Memory_object_base
{ {
Dma_object(Genode::Ram_dataspace_capability cap) Platform::Connection &_pci;
: Memory_object_base(cap) {}
void free() { Lx::pci()->free_dma_buffer(ram_cap()); } Dma_object(Platform::Connection &pci,
Genode::Ram_dataspace_capability cap)
: Memory_object_base(cap), _pci(pci) {}
void free() { _pci.free_dma_buffer(ram_cap()); }
}; };
/********************
** Pci singletons **
********************/
static Genode::Constructible<Platform::Connection> _global_pci;
static Genode::Allocator *_global_md_alloc;
static Genode::Ram_session *_global_ram;
void Lx::pci_init(Genode::Env &env, Genode::Ram_session &ram,
Genode::Allocator &md_alloc)
{
_global_pci.construct(env);
_global_ram = &ram;
_global_md_alloc = &md_alloc;
}
Platform::Connection *Lx::pci()
{
return &*_global_pci;
}
Lx::Pci_dev_registry *Lx::pci_dev_registry()
{
static Lx::Pci_dev_registry _pci_dev_registry;
return &_pci_dev_registry;
}
/********************************* /*********************************
** Lx::Backend_alloc interface ** ** Lx::Backend_alloc interface **
*********************************/ *********************************/
@ -79,24 +116,24 @@ Lx::backend_alloc(Genode::addr_t size, Genode::Cache_attribute cached)
using namespace Genode; using namespace Genode;
using namespace Lx_kit; using namespace Lx_kit;
Memory_object_base *o; Memory_object_base *obj;
Genode::Ram_dataspace_capability cap; Genode::Ram_dataspace_capability cap;
if (cached == CACHED) { if (cached == CACHED) {
cap = env()->ram_session()->alloc(size); cap = _global_ram->alloc(size);
o = new (env()->heap()) Ram_object(cap); obj = new (_global_md_alloc) Ram_object(*_global_ram, cap);
} else { } else {
Genode::size_t donate = size; Genode::size_t donate = size;
cap = retry<Platform::Session::Out_of_metadata>( cap = retry<Platform::Session::Out_of_metadata>(
[&] () { return Lx::pci()->alloc_dma_buffer(size); }, [&] () { return _global_pci->alloc_dma_buffer(size); },
[&] () { [&] () {
Lx::pci()->upgrade_ram(donate); _global_pci->upgrade_ram(donate);
donate = donate * 2 > size ? 4096 : donate * 2; donate = donate * 2 > size ? 4096 : donate * 2;
}); });
o = new (env()->heap()) Dma_object(cap); obj = new (_global_md_alloc) Dma_object(*_global_pci, cap);
} }
memory_pool.insert(o); memory_pool.insert(obj);
return cap; return cap;
} }
@ -107,31 +144,12 @@ void Lx::backend_free(Genode::Ram_dataspace_capability cap)
using namespace Lx_kit; using namespace Lx_kit;
Memory_object_base *object; Memory_object_base *object;
memory_pool.apply(cap, [&] (Memory_object_base *o) { memory_pool.apply(cap, [&] (Memory_object_base *obj) {
object = o; object = obj;
if (!object) if (!object) { return; }
return;
object->free(); object->free();
memory_pool.remove(object); memory_pool.remove(object);
}); });
destroy(env()->heap(), object); destroy(_global_md_alloc, object);
}
/********************
** Pci singletons **
********************/
Platform::Connection *Lx::pci()
{
static Platform::Connection _pci;
return &_pci;
}
Lx::Pci_dev_registry *Lx::pci_dev_registry()
{
static Lx::Pci_dev_registry _pci_dev_registry;
return &_pci_dev_registry;
} }

23
repos/dde_linux/src/lx_kit/scheduler.cc
View File

@ -7,7 +7,7 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
@ -67,16 +67,18 @@ class Lx_kit::Scheduler : public Lx::Scheduler
return _ansi_esc_black(); return _ansi_esc_black();
} }
struct Logger : Genode::Thread_deprecated<0x4000> struct Logger : Genode::Thread
{ {
Timer::Connection _timer; Timer::Connection _timer;
Lx::Scheduler &_scheduler; Lx::Scheduler &_scheduler;
unsigned const _interval; unsigned const _interval;
Logger(Lx::Scheduler &scheduler, unsigned interval_seconds) Logger(Genode::Env &env, Lx::Scheduler &scheduler,
unsigned interval_seconds)
: :
Genode::Thread_deprecated<0x4000>("logger"), Genode::Thread(env, "logger", 0x4000),
_scheduler(scheduler), _interval(interval_seconds) _timer(env), _scheduler(scheduler),
_interval(interval_seconds)
{ {
start(); start();
} }
@ -91,12 +93,13 @@ class Lx_kit::Scheduler : public Lx::Scheduler
} }
}; };
Genode::Constructible<Logger> _logger;
public: public:
Scheduler() Scheduler(Genode::Env &env)
{ {
if (verbose) if (verbose) { _logger.construct(env, *this, 10); }
new (Genode::env()->heap()) Logger(*this, 10);
} }
/***************************** /*****************************
@ -220,8 +223,8 @@ Lx::Task::~Task()
** Lx::Scheduler implementation ** ** Lx::Scheduler implementation **
**********************************/ **********************************/
Lx::Scheduler &Lx::scheduler() Lx::Scheduler &Lx::scheduler(Genode::Env *env)
{ {
static Lx_kit::Scheduler inst; static Lx_kit::Scheduler inst { *env };
return inst; return inst;
} }

23
repos/dde_linux/src/lx_kit/timer.cc
View File

@ -7,14 +7,13 @@
*/ */
/* /*
* Copyright (C) 2014-2016 Genode Labs GmbH * Copyright (C) 2014-2017 Genode Labs GmbH
* *
* This file is part of the Genode OS framework, which is distributed * This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU General Public License version 2. * under the terms of the GNU General Public License version 2.
*/ */
/* Genode includes */ /* Genode includes */
#include <os/server.h>
#include <base/tslab.h> #include <base/tslab.h>
#include <timer_session/connection.h> #include <timer_session/connection.h>
@ -84,7 +83,7 @@ class Lx_kit::Timer : public Lx::Timer
::Timer::Connection _timer_conn; ::Timer::Connection _timer_conn;
Lx_kit::List<Context> _list; Lx_kit::List<Context> _list;
Lx::Task _timer_task; Lx::Task _timer_task;
Genode::Signal_rpc_member<Lx_kit::Timer> _dispatcher; Genode::Signal_handler<Lx_kit::Timer> _dispatcher;
Genode::Tslab<Context, 32 * sizeof(Context)> _timer_alloc; Genode::Tslab<Context, 32 * sizeof(Context)> _timer_alloc;
Lx::jiffies_update_func _jiffies_func = nullptr; Lx::jiffies_update_func _jiffies_func = nullptr;
@ -161,7 +160,7 @@ class Lx_kit::Timer : public Lx::Timer
/** /**
* Handle trigger_once signal * Handle trigger_once signal
*/ */
void _handle(unsigned) void _handle()
{ {
_timer_task.unblock(); _timer_task.unblock();
@ -173,13 +172,15 @@ class Lx_kit::Timer : public Lx::Timer
/** /**
* Constructor * Constructor
*/ */
Timer(Server::Entrypoint &ep, unsigned long &jiffies) Timer(Genode::Env &env, Genode::Entrypoint &ep,
Genode::Allocator &alloc, unsigned long &jiffies)
: :
_jiffies(jiffies), _jiffies(jiffies),
_timer_conn(env),
_timer_task(Timer::run_timer, reinterpret_cast<void*>(this), _timer_task(Timer::run_timer, reinterpret_cast<void*>(this),
"timer", Lx::Task::PRIORITY_2, Lx::scheduler()), "timer", Lx::Task::PRIORITY_2, Lx::scheduler()),
_dispatcher(ep, *this, &Lx_kit::Timer::_handle), _dispatcher(ep, *this, &Lx_kit::Timer::_handle),
_timer_alloc(Genode::env()->heap()) _timer_alloc(&alloc)
{ {
_timer_conn.sigh(_dispatcher); _timer_conn.sigh(_dispatcher);
} }
@ -215,6 +216,7 @@ class Lx_kit::Timer : public Lx::Timer
/************************* /*************************
** Lx::Timer interface ** ** Lx::Timer interface **
*************************/ *************************/
void add(void *timer, Type type) void add(void *timer, Type type)
{ {
Context *t = nullptr; Context *t = nullptr;
@ -294,6 +296,9 @@ class Lx_kit::Timer : public Lx::Timer
void register_jiffies_func(Lx::jiffies_update_func func) { void register_jiffies_func(Lx::jiffies_update_func func) {
_jiffies_func = func; } _jiffies_func = func; }
void usleep(unsigned us) {
_timer_conn.usleep(us); }
}; };
@ -301,9 +306,11 @@ class Lx_kit::Timer : public Lx::Timer
** Lx::Timer implementation ** ** Lx::Timer implementation **
******************************/ ******************************/
Lx::Timer &Lx::timer(Server::Entrypoint *ep, unsigned long *jiffies) Lx::Timer &Lx::timer(Genode::Env *env, Genode::Entrypoint *ep,
Genode::Allocator *md_alloc,
unsigned long *jiffies)
{ {
static Lx_kit::Timer inst(*ep, *jiffies); static Lx_kit::Timer inst(*env, *ep, *md_alloc, *jiffies);
return inst; return inst;
} }