/* * \brief RM session implementation used by Noux processes * \author Norman Feske * \date 2012-02-22 * * The custom RM implementation is used for recording all RM regions attached * to the region-manager session. Using the recorded information, the address- * space layout can then be replayed onto a new process created via fork. */ /* * Copyright (C) 2012-2013 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 _NOUX__RM_SESSION_COMPONENT_H_ #define _NOUX__RM_SESSION_COMPONENT_H_ /* Genode includes */ #include #include namespace Noux { static bool verbose_attach = false; class Rm_session_component : public Rpc_object { private: /** * Record of an attached dataspace */ struct Region : List::Element, Dataspace_user { Rm_session_component &rm; Dataspace_capability ds; size_t size; off_t offset; addr_t local_addr; Region(Rm_session_component &rm, Dataspace_capability ds, size_t size, off_t offset, addr_t local_addr) : rm(rm), ds(ds), size(size), offset(offset), local_addr(local_addr) { } /** * Return true if region contains specified address */ bool contains(addr_t addr) const { return (addr >= local_addr) && (addr < local_addr + size); } Region *next_region() { return List::Element::next(); } inline void dissolve(Dataspace_info &ds); }; List _regions; Region *_lookup_region_by_addr(addr_t local_addr) { Region *curr = _regions.first(); for (; curr; curr = curr->next_region()) { if (curr->contains(local_addr)) return curr; } return 0; } /** * Wrapped RM session at core */ Rm_connection _rm; Dataspace_registry &_ds_registry; public: Rm_session_component(Dataspace_registry &ds_registry, addr_t start = ~0UL, size_t size = 0) : _rm(start, size), _ds_registry(ds_registry) { } ~Rm_session_component() { Region *curr; while ((curr = _regions.first())) detach(curr->local_addr); } /** * Replay attachments onto specified RM session * * \param dst_ram backing store used for allocating the * the copies of RAM dataspaces * \param ds_registry dataspace registry used for keeping track * of newly created dataspaces * \param ep entrypoint used to serve the RPC interface * of forked managed dataspaces */ void replay(Ram_session_capability dst_ram, Rm_session_capability dst_rm, Dataspace_registry &ds_registry, Rpc_entrypoint &ep) { for (Region *curr = _regions.first(); curr; curr = curr->next_region()) { Dataspace_capability ds; Object_pool::Guard info(_ds_registry.lookup_info(curr->ds)); if (info) { ds = info->fork(dst_ram, ds_registry, ep); /* * XXX We could detect dataspaces that are attached * more than once. For now, we create a new fork * for each attachment. */ } else { PERR("replay: missing ds_info for dataspace at addr 0x%lx", curr->local_addr); /* * If the dataspace is not a RAM dataspace, assume that * it's a ROM dataspace. * * XXX Handle ROM dataspaces explicitly. For once, we * need to make sure that they remain available * until the child process exits even if the parent * process exits earlier. Furthermore, we would * like to detect unexpected dataspaces. */ ds = curr->ds; } if (!ds.valid()) { PERR("replay: Error while forking dataspace"); continue; } Rm_session_client(dst_rm).attach(ds, curr->size, curr->offset, true, curr->local_addr); } } void poke(addr_t dst_addr, void const *src, size_t len) { Region *region = _lookup_region_by_addr(dst_addr); if (!region) { PERR("poke: no region at 0x%lx", dst_addr); return; } /* * Test if start and end address occupied by the object * type refers to the same region. */ if (region != _lookup_region_by_addr(dst_addr + len - 1)) { PERR("attempt to write beyond region boundary"); return; } Object_pool::Guard info(_ds_registry.lookup_info(region->ds)); if (!info) { PERR("attempt to write to unknown dataspace type"); for (;;); return; } if (region->offset) { PERR("poke: writing to region with offset is not supported"); return; } info->poke(dst_addr - region->local_addr, src, len); } /************************** ** RM session interface ** **************************/ Local_addr attach(Dataspace_capability ds, size_t size = 0, off_t offset = 0, bool use_local_addr = false, Local_addr local_addr = (addr_t)0, bool executable = false) { /* * Rm_session substracts offset from size if size is 0 */ if (size == 0) size = Dataspace_client(ds).size() - offset; local_addr = _rm.attach(ds, size, offset, use_local_addr, local_addr, executable); Region *region = new (env()->heap()) Region(*this, ds, size, offset, local_addr); /* register region as user of RAM dataspaces */ Object_pool::Guard info(_ds_registry.lookup_info(ds)); if (info) { info->register_user(*region); } else { if (verbose_attach) { PWRN("Trying to attach unknown dataspace type"); PWRN(" ds_info@%p at 0x%lx size=%zd offset=0x%lx", info.object(), (long)local_addr, Dataspace_client(ds).size(), (long)offset); } } /* * Record attachment for later replay (needed during * fork) */ _regions.insert(region); return local_addr; } void detach(Local_addr local_addr) { _rm.detach(local_addr); Region *region = _lookup_region_by_addr(local_addr); if (!region) { PWRN("Attempt to detach unknown region at 0x%p", (void *)local_addr); return; } _regions.remove(region); Object_pool::Guard info(_ds_registry.lookup_info(region->ds)); if (info) info->unregister_user(*region); destroy(env()->heap(), region); } Pager_capability add_client(Thread_capability thread) { return _rm.add_client(thread); } void remove_client(Pager_capability pager) { _rm.remove_client(pager); } void fault_handler(Signal_context_capability handler) { return _rm.fault_handler(handler); } State state() { return _rm.state(); } Dataspace_capability dataspace() { return _rm.dataspace(); } }; inline void Rm_session_component::Region::dissolve(Dataspace_info &ds) { /* * When this function is called, the 'ds' is already locked by the * caller. To prevent 'detach' from taking the lock twice * ('_ds_registry.lookup_info'), the temporarily release and re-acquire * the lock. */ ds.release(); rm.detach(local_addr); ds.acquire(); } } #endif /* _NOUX__RM_SESSION_COMPONENT_H_ */