ExternalVendorCode/genode
1
0
Fork 0
mirror of https://github.com/genodelabs/genode.git synced 2025-03-24 13:05:18 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Avoid use of Connection::KEEP_OPEN feature

Browse Source 
This feature is not compatible with the forthcoming nonblocking parent
interface. The patch removes the use of feature in all places except for
the components of the demo repository, which will under go a redesign
anyway.

Issue #2120
Issue #2165
This commit is contained in:
Norman Feske 2016-11-06 14:19:47 +01:00 committed by Christian Helmuth
parent a085b4f536
commit d477a3e76d
14 changed files with 113 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
repos/dde_linux/src/lib/usb/spec/arndale/platform.cc
View File

@ -18,7 +18,6 @@
#include <regulator/consts.h>
#include <regulator_session/connection.h>
#include <timer_session/connection.h>
#include <irq_session/connection.h>
#include <util/mmio.h>
/* Emulation */
@ -356,15 +355,3 @@ void platform_hcd_init(Services *services)
if (services->xhci)
xhci_setup(services);
}
Genode::Irq_session_capability platform_irq_activate(int irq)
{
try {
Genode::Irq_connection conn(irq);
conn.on_destruction(Genode::Irq_connection::KEEP_OPEN);
return conn;
} catch (...) { }
return Genode::Irq_session_capability();
}

11
repos/dde_linux/src/lib/usb/spec/odroid_x2/platform.cc
View File

@ -21,7 +21,6 @@
#include <regulator/consts.h>
#include <regulator_session/connection.h>
#include <timer_session/connection.h>
#include <irq_session/connection.h>
#include <util/mmio.h>
#include <gpio_session/connection.h>
@ -216,13 +215,3 @@ void platform_hcd_init(Services *services)
ehci_setup(services);
}
Genode::Irq_session_capability platform_irq_activate(int irq)
{
try {
Genode::Irq_connection conn(irq);
conn.on_destruction(Genode::Irq_connection::KEEP_OPEN);
return conn;
} catch (...) { }
return Genode::Irq_session_capability();
}

13
repos/dde_linux/src/lib/usb/spec/panda/platform.cc
View File

@ -16,7 +16,6 @@
#include <drivers/board_base.h>
#include <gpio_session/connection.h>
#include <io_mem_session/connection.h>
#include <irq_session/connection.h>
#include <util/mmio.h>
#include <lx_emul.h>
@ -317,15 +316,3 @@ void platform_hcd_init(Services *services)
platform_device_register(pdev);
}
Genode::Irq_session_capability platform_irq_activate(int irq)
{
try {
Genode::Irq_connection conn(irq);
conn.on_destruction(Genode::Irq_connection::KEEP_OPEN);
return conn;
} catch (...) { }
return Genode::Irq_session_capability();
}

13
repos/dde_linux/src/lib/usb/spec/rpi/platform.cc
View File

@ -14,7 +14,6 @@
/* Genode includes */
#include <base/attached_io_mem_dataspace.h>
#include <io_mem_session/connection.h>
#include <irq_session/connection.h>
#include <util/mmio.h>
#include <platform_session/connection.h>
@ -325,15 +324,3 @@ void platform_hcd_init(Services *services)
platform_device_register(pdev);
}
Genode::Irq_session_capability platform_irq_activate(int irq)
{
try {
Genode::Irq_connection conn(irq);
conn.on_destruction(Genode::Irq_connection::KEEP_OPEN);
return conn;
} catch (...) { }
return Genode::Irq_session_capability();
}

6
repos/libports/src/drivers/framebuffer/vesa/framebuffer.cc
View File

@ -34,6 +34,7 @@ static Dataspace_capability io_mem_cap;
static const bool verbose = false;
/***************
** Utilities **
***************/
@ -152,8 +153,9 @@ int Framebuffer_drv::map_io_mem(addr_t base, size_t size, bool write_combined,
void **out_addr, addr_t addr,
Dataspace_capability *out_io_ds)
{
Io_mem_connection io_mem(base, size, write_combined);
io_mem.on_destruction(Io_mem_connection::KEEP_OPEN);
Io_mem_connection &io_mem = *new (env()->heap())
Io_mem_connection(base, size, write_combined);
Io_mem_dataspace_capability io_ds = io_mem.dataspace();
if (!io_ds.valid())
return -2;

39
repos/libports/src/lib/acpica/iomem.cc
View File

@ -39,17 +39,17 @@ class Acpica::Io_mem
{
private:
ACPI_PHYSICAL_ADDRESS _phys;
ACPI_SIZE _size;
Genode::uint8_t * _virt;
Genode::Io_mem_session_capability _io_mem;
unsigned _ref;
ACPI_PHYSICAL_ADDRESS _phys;
ACPI_SIZE _size;
Genode::uint8_t *_virt = nullptr;
Genode::Io_mem_connection *_io_mem = nullptr;
unsigned _ref;
static Acpica::Io_mem _ios[16];
public:
bool valid() const { return _io_mem.valid(); }
bool valid() const { return _io_mem != nullptr; }
bool refs() const { return _ref != ~0U; }
bool contains_virt (const Genode::uint8_t * v, const ACPI_SIZE s) const
{
@ -76,14 +76,14 @@ class Acpica::Io_mem
void invalidate(ACPI_SIZE s)
{
if (_io_mem.valid() && refs())
Genode::env()->parent()->close(_io_mem);
if (_io_mem && refs())
Genode::destroy(Genode::env()->heap(), _io_mem);
ACPI_PHYSICAL_ADDRESS const p = _phys;
_phys = _size = 0;
_virt = nullptr;
_io_mem = Genode::Io_mem_session_capability();
_phys = _size = 0;
_virt = nullptr;
_io_mem = nullptr;
if (refs())
return;
@ -139,9 +139,8 @@ class Acpica::Io_mem
io_mem._ref = r;
io_mem._virt = 0;
Genode::Io_mem_connection io(io_mem._phys, io_mem._size);
io.on_destruction(Genode::Io_mem_connection::KEEP_OPEN);
io_mem._io_mem = io;
io_mem._io_mem = new (Genode::env()->heap())
Genode::Io_mem_connection(io_mem._phys, io_mem._size);
return &io_mem;
});
@ -153,14 +152,17 @@ class Acpica::Io_mem
if (!io_mem)
return 0UL;
io_mem->_virt = Genode::env()->rm_session()->attach(Genode::Io_mem_session_client(io_mem->_io_mem).dataspace(), io_mem->_size);
io_mem->_virt = Genode::env()->rm_session()->attach(io_mem->_io_mem->dataspace(), io_mem->_size);
return reinterpret_cast<Genode::addr_t>(io_mem->_virt);
}
Genode::addr_t pre_expand(ACPI_PHYSICAL_ADDRESS p, ACPI_SIZE s)
{
Genode::env()->parent()->close(_io_mem);
if (_io_mem)
Genode::destroy(Genode::env()->heap(), _io_mem);
_io_mem = nullptr;
Genode::addr_t xsize = _phys - p + _size;
if (!allocate(p, xsize, _ref))
@ -171,7 +173,8 @@ class Acpica::Io_mem
Genode::addr_t post_expand(ACPI_PHYSICAL_ADDRESS p, ACPI_SIZE s)
{
Genode::env()->parent()->close(_io_mem);
if (_io_mem)
Genode::destroy(Genode::env()->heap(), _io_mem);
ACPI_SIZE xsize = p + s - _phys;
if (!allocate(_phys, xsize, _ref))
@ -191,7 +194,7 @@ class Acpica::Io_mem
!io_mem.contains_phys(p, s))
return 0UL;
Genode::Io_mem_dataspace_capability const io_ds = Genode::Io_mem_session_client(io_mem._io_mem).dataspace();
Genode::Io_mem_dataspace_capability const io_ds = io_mem._io_mem->dataspace();
/* re-attach mem of stale entries partially using this iomem */
unsigned stale_count = 0;

65
repos/os/src/drivers/acpi/acpi.cc
View File

@ -18,7 +18,7 @@
*/
/* base includes */
#include <io_mem_session/connection.h>
#include <base/attached_io_mem_dataspace.h>
#include <util/misc_math.h>
#include <util/mmio.h>
@ -1116,27 +1116,13 @@ class Acpi_table
{
private:
Genode::Env &env;
Genode::Allocator &alloc;
Genode::Env &_env;
Genode::Allocator &_alloc;
/* BIOS range to scan for RSDP */
enum { BIOS_BASE = 0xe0000, BIOS_SIZE = 0x20000 };
/**
* Map table and return address and session cap
*/
uint8_t *_map_io(addr_t base, size_t size, Io_mem_session_capability &cap)
{
Io_mem_connection io_mem(base, size);
io_mem.on_destruction(Io_mem_connection::KEEP_OPEN);
Io_mem_dataspace_capability io_ds = io_mem.dataspace();
if (!io_ds.valid())
throw -1;
uint8_t *ret = env.rm().attach(io_ds, size);
cap = io_mem.cap();
return ret;
}
Genode::Lazy_volatile_object<Genode::Attached_io_mem_dataspace> _mmio;
/**
* Search for RSDP pointer signature in area
@ -1152,30 +1138,33 @@ class Acpi_table
/**
* Return 'Root System Descriptor Pointer' (ACPI spec 5.2.5.1)
*
* As a side effect, the function initializes the '_mmio' member.
*/
uint8_t *_rsdp(Io_mem_session_capability &cap)
uint8_t *_rsdp()
{
uint8_t *area = 0;
/* try BIOS area (0xe0000 - 0xfffffh)*/
try {
area = _search_rsdp(_map_io(BIOS_BASE, BIOS_SIZE, cap));
return area;
} catch (...) { env.parent().close(cap); }
_mmio.construct(_env, BIOS_BASE, BIOS_SIZE);
return _search_rsdp(_mmio->local_addr<uint8_t>());
}
catch (...) { }
/* search EBDA (BIOS addr + 0x40e) */
try {
area = _map_io(0x0, 0x1000, cap);
if (area) {
unsigned short base = (*reinterpret_cast<unsigned short *>(area + 0x40e)) << 4;
env.parent().close(cap);
area = _map_io(base, 1024, cap);
area = _search_rsdp(area);
}
return area;
} catch (...) { env.parent().close(cap); }
/* read RSDP base address from EBDA */
return 0;
_mmio.construct(_env, 0x0, 0x1000);
uint8_t const * const ebda = _mmio->local_addr<uint8_t const>();
unsigned short const rsdp_phys =
(*reinterpret_cast<unsigned short const *>(ebda + 0x40e)) << 4;
_mmio.construct(_env, rsdp_phys, 0x1000);
return _search_rsdp(_mmio->local_addr<uint8_t>());
}
catch (...) { }
return nullptr;
}
template <typename T>
@ -1232,11 +1221,9 @@ class Acpi_table
public:
Acpi_table(Genode::Env &env, Genode::Allocator &alloc)
: env(env), alloc(alloc)
: _env(env), _alloc(alloc)
{
Io_mem_session_capability io_mem;
uint8_t * ptr_rsdp = _rsdp(io_mem);
uint8_t * ptr_rsdp = _rsdp();
struct rsdp {
char signature[8];
@ -1273,7 +1260,7 @@ class Acpi_table
addr_t const xsdt = rsdp->xsdt;
uint8_t const acpi_revision = rsdp->revision;
/* drop rsdp io_mem mapping since rsdt/xsdt may overlap */
env.parent().close(io_mem);
_mmio.destruct();
if (acpi_revision != 0 && xsdt && sizeof(addr_t) != sizeof(uint32_t)) {
/* running 64bit and xsdt is valid */

22
repos/os/src/drivers/platform/spec/x86/irq.cc
View File

@ -213,8 +213,7 @@ class Platform::Irq_component : public Proxy
void Platform::Irq_session_component::ack_irq()
{
if (msi()) {
Genode::Irq_session_client irq_msi(_irq_cap);
irq_msi.ack_irq();
_irq_conn->ack_irq();
return;
}
@ -246,16 +245,13 @@ Platform::Irq_session_component::Irq_session_component(unsigned irq,
try {
using namespace Genode;
Irq_connection conn(msi, Irq_session::TRIGGER_UNCHANGED,
_irq_conn.construct(msi, Irq_session::TRIGGER_UNCHANGED,
Irq_session::POLARITY_UNCHANGED,
pci_config_space);
_msi_info = conn.info();
_msi_info = _irq_conn->info();
if (_msi_info.type == Irq_session::Info::Type::MSI) {
_gsi = msi;
_irq_cap = conn;
conn.on_destruction(Irq_connection::KEEP_OPEN);
_gsi = msi;
return;
}
} catch (Genode::Parent::Service_denied) { }
@ -289,10 +285,7 @@ Platform::Irq_session_component::Irq_session_component(unsigned irq,
Platform::Irq_session_component::~Irq_session_component()
{
if (msi()) {
Genode::Irq_session_client irq_msi(_irq_cap);
irq_msi.sigh(Genode::Signal_context_capability());
Genode::env()->parent()->close(_irq_cap);
_irq_conn->sigh(Genode::Signal_context_capability());
irq_alloc.free_msi(_gsi);
return;
@ -309,10 +302,9 @@ Platform::Irq_session_component::~Irq_session_component()
void Platform::Irq_session_component::sigh(Genode::Signal_context_capability sigh)
{
if (msi()) {
if (_irq_conn.constructed()) {
/* register signal handler for msi directly at parent */
Genode::Irq_session_client irq_msi(_irq_cap);
irq_msi.sigh(sigh);
_irq_conn->sigh(sigh);
return;
}

16
repos/os/src/drivers/platform/spec/x86/irq.h
View File

@ -14,11 +14,8 @@
#pragma once
#include <base/rpc_server.h>
#include <util/list.h>
#include <irq_session/irq_session.h>
#include <irq_session/capability.h>
#include <irq_session/connection.h>
/* platform local includes */
#include <irq_proxy.h>
@ -36,10 +33,11 @@ class Platform::Irq_session_component : public Genode::Rpc_object<Genode::Irq_se
{
private:
unsigned _gsi;
Genode::Irq_sigh _irq_sigh;
Genode::Irq_session_capability _irq_cap;
Genode::Irq_session::Info _msi_info;
unsigned _gsi;
Genode::Irq_sigh _irq_sigh;
Genode::Irq_session::Info _msi_info;
Genode::Lazy_volatile_object<Genode::Irq_connection> _irq_conn;
public:
@ -50,7 +48,7 @@ class Platform::Irq_session_component : public Genode::Rpc_object<Genode::Irq_se
bool msi()
{
return _irq_cap.valid() &&
return _irq_conn.constructed() &&
_msi_info.type == Genode::Irq_session::Info::Type::MSI;
}

31
repos/os/src/drivers/platform/spec/x86/pci_device_component.h
View File

@ -34,14 +34,15 @@ class Platform::Device_component : public Genode::Rpc_object<Platform::Device>,
{
private:
Device_config _device_config;
Genode::addr_t _config_space;
Genode::Io_mem_session_capability _io_mem_config_extended;
Config_access _config_access;
Genode::Rpc_entrypoint *_ep;
Platform::Session_component *_session;
unsigned short _irq_line;
Irq_session_component *_irq_session;
Device_config _device_config;
Genode::addr_t _config_space;
Config_access _config_access;
Genode::Rpc_entrypoint *_ep;
Platform::Session_component *_session;
unsigned short _irq_line;
Irq_session_component *_irq_session;
Genode::Lazy_volatile_object<Genode::Io_mem_connection> _io_mem_config_extended;
class Io_mem : public Genode::Io_mem_connection,
public Genode::List<Io_mem>::Element
@ -243,9 +244,6 @@ class Platform::Device_component : public Genode::Rpc_object<Platform::Device>,
}
}
if (_io_mem_config_extended.valid())
Genode::env()->parent()->close(_io_mem_config_extended);
if (_device_config.valid())
_disable_bus_master_dma();
}
@ -261,21 +259,18 @@ class Platform::Device_component : public Genode::Rpc_object<Platform::Device>,
if (_config_space == ~0UL)
return Genode::Io_mem_dataspace_capability();
if (!_io_mem_config_extended.valid()) {
if (!_io_mem_config_extended.constructed()) {
try {
Genode::Io_mem_connection conn(_config_space, 0x1000);
conn.on_destruction(Genode::Io_mem_connection::KEEP_OPEN);
_io_mem_config_extended = conn;
_io_mem_config_extended.construct(_config_space, 0x1000);
} catch (...) {
_config_space = ~0UL;
}
}
if (!_io_mem_config_extended.valid())
if (!_io_mem_config_extended.constructed())
return Genode::Io_mem_dataspace_capability();
Genode::Io_mem_session_client client(_io_mem_config_extended);
return client.dataspace();
return _io_mem_config_extended->dataspace();
}
/**************************

16
repos/os/src/drivers/platform/spec/x86/pci_session_component.h
View File

@ -82,10 +82,11 @@ class Platform::Rmrr : public Genode::List<Platform::Rmrr>::Element
private:
Genode::uint64_t _start, _end;
Genode::Io_mem_dataspace_capability _cap;
Genode::uint64_t const _start, _end;
Genode::Io_mem_dataspace_capability _cap;
Genode::List<Bdf> _bdf_list;
Genode::List<Bdf> _bdf_list;
Genode::Lazy_volatile_object<Genode::Io_mem_connection> _io_mem;
public:
@ -93,7 +94,8 @@ class Platform::Rmrr : public Genode::List<Platform::Rmrr>::Element
: _start(start), _end(end)
{ }
Genode::Io_mem_dataspace_capability match(Device_config config) {
Genode::Io_mem_dataspace_capability match(Device_config config)
{
Genode::uint8_t bus = config.bus_number();
Genode::uint8_t device = config.device_number();
Genode::uint8_t function = config.function_number();
@ -105,10 +107,8 @@ class Platform::Rmrr : public Genode::List<Platform::Rmrr>::Element
if (_cap.valid())
return _cap;
Genode::Io_mem_connection io_mem(_start, _end - _start + 1);
io_mem.on_destruction(Genode::Io_mem_connection::KEEP_OPEN);
_cap = io_mem.dataspace();
_io_mem.construct(_start, _end - _start + 1);
_cap = _io_mem->dataspace();
return _cap;
}
return Genode::Io_mem_dataspace_capability();

49
repos/os/src/test/audio_out/main.cc
View File

@ -18,6 +18,7 @@
#include <audio_out_session/connection.h>
#include <base/log.h>
#include <base/sleep.h>
#include <base/attached_rom_dataspace.h>
#include <rom_session/connection.h>
#include <dataspace/client.h>
#include <os/config.h>
@ -46,44 +47,30 @@ class Track : Thread_deprecated<8192>
{
private:
const char *_file;
Audio_out::Connection *_audio_out[CHN_CNT];
Lazy_volatile_object<Audio_out::Connection> _audio_out[CHN_CNT];
String<64> const _name;
Attached_rom_dataspace _sample_ds { _name.string() };
char const * const _base = _sample_ds.local_addr<char const>();
size_t const _size = _sample_ds.size();
public:
Track(const char *file) : Thread_deprecated("track"), _file(file)
Track(const char *name) : Thread_deprecated("track"), _name(name)
{
for (int i = 0; i < CHN_CNT; ++i) {
/* allocation signal for first channel only */
_audio_out[i] = new (env()->heap())
Audio_out::Connection(channel_names[i],
i == 0 ? true : false);
_audio_out[i].construct(channel_names[i], i == 0);
}
}
void entry()
{
char *base;
Dataspace_capability ds_cap;
try {
Rom_connection rom(_file);
rom.on_destruction(Rom_connection::KEEP_OPEN);
ds_cap = rom.dataspace();
base = env()->rm_session()->attach(ds_cap);
}
catch (...) {
error("could not open: ", _file);
return;
}
Dataspace_client ds_client(ds_cap);
if (verbose)
log(_file, " size is ", ds_client.size(), " bytes "
"(attached to ", (void *)base, ")");
log(_name, " size is ", _size, " bytes "
"(attached to ", (void *)_base, ")");
size_t file_size = ds_client.size();
for (int i = 0; i < CHN_CNT; ++i)
_audio_out[i]->start();
@ -91,7 +78,7 @@ class Track : Thread_deprecated<8192>
while (1) {
for (size_t offset = 0, cnt = 1;
offset < file_size;
offset < _size;
offset += PERIOD_FSIZE, ++cnt) {
/*
@ -99,8 +86,8 @@ class Track : Thread_deprecated<8192>
* is the size of the period except at the end of the
* file.
*/
size_t chunk = (offset + PERIOD_FSIZE > file_size)
? (file_size - offset) / CHN_CNT / FRAME_SIZE
size_t chunk = (offset + PERIOD_FSIZE > _size)
? (_size - offset) / CHN_CNT / FRAME_SIZE
: PERIOD;
Packet *p[CHN_CNT];
@ -118,7 +105,7 @@ class Track : Thread_deprecated<8192>
p[chn] = _audio_out[chn]->stream()->get(pos);
/* copy channel contents into sessions */
float *content = (float *)(base + offset);
float *content = (float *)(_base + offset);
for (unsigned c = 0; c < CHN_CNT * chunk; c += CHN_CNT)
for (int i = 0; i < CHN_CNT; ++i)
p[i]->content()[c / 2] = content[c + i];
@ -131,14 +118,14 @@ class Track : Thread_deprecated<8192>
}
if (verbose)
log(_file, " submit packet ",
log(_name, " submit packet ",
_audio_out[0]->stream()->packet_position((p[0])));
for (int i = 0; i < CHN_CNT; i++)
_audio_out[i]->submit(p[i]);
}
log("played '", _file, "' ", ++cnt, " time(s)");
log("played '", _name, "' ", ++cnt, " time(s)");
}
}

30
repos/os/src/test/audio_out_click/main.cc
View File

@ -18,11 +18,11 @@
#include <audio_out_session/connection.h>
#include <base/log.h>
#include <base/sleep.h>
#include <base/attached_rom_dataspace.h>
#include <dataspace/client.h>
#include <input_session/connection.h>
#include <input/event.h>
#include <os/config.h>
#include <rom_session/connection.h>
using namespace Genode;
@ -45,35 +45,21 @@ class Click
{
private:
Audio_out::Connection *_audio_out[CHANNELS];
char const *_base;
Genode::size_t _size;
Lazy_volatile_object<Audio_out::Connection> _audio_out[CHANNELS];
Attached_rom_dataspace _sample_ds;
char const * const _base = _sample_ds.local_addr<char const>();
size_t const _size = _sample_ds.size();
public:
Click(char const *file)
Click(char const *file) : _sample_ds(file)
{
for (int i = 0; i < CHANNELS; ++i) {
/* allocation signal for first channel only */
_audio_out[i] = new (env()->heap())
Audio_out::Connection(channel_names[i], i == 0);
_audio_out[i].construct(channel_names[i], i == 0);
_audio_out[i]->start();
}
Dataspace_capability ds_cap;
try {
Rom_connection rom(file);
rom.on_destruction(Rom_connection::KEEP_OPEN);
ds_cap = rom.dataspace();
_base = env()->rm_session()->attach(ds_cap);
} catch (...) {
error("could not open: ", file);
return;
}
Dataspace_client ds_client(ds_cap);
_size = ds_client.size();
}
void play()

3
repos/ports-foc/src/lib/l4lx/startup.cc
View File

@ -83,8 +83,7 @@ static void map_kip()
using namespace Genode;
/* Open the KIP special file and keep it open */
Genode::Rom_connection kip_rom("kip");
kip_rom.on_destruction(Genode::Rom_connection::KEEP_OPEN);
static Genode::Rom_connection kip_rom("kip");
/* Attach and register dataspace */
l4lx_kinfo = L4lx::Env::env()->rm()->attach(kip_rom.dataspace(), "KIP");