mirror of
https://github.com/genodelabs/genode.git
synced 2024-12-21 06:33:31 +00:00
f330b55227
to be used for ref counting of Native_capabilities * similar as used for base-foc * will replace nova specific cap_sel_allocator interface Issue #905
130 lines
2.5 KiB
C++
130 lines
2.5 KiB
C++
/*
|
|
* \brief Mapping of Genode's capability names to capabilities selectors.
|
|
* \author Alexander Boettcher
|
|
* \date 2013-08-26
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2013-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 _INCLUDE__BASE__CAP_MAP_H_
|
|
#define _INCLUDE__BASE__CAP_MAP_H_
|
|
|
|
/* Genode includes */
|
|
#include <base/stdint.h>
|
|
|
|
#include <base/lock.h>
|
|
|
|
#include <util/avl_tree.h>
|
|
#include <util/noncopyable.h>
|
|
|
|
namespace Genode {
|
|
|
|
class Cap_range : public Avl_node<Cap_range> {
|
|
|
|
private:
|
|
|
|
Lock _lock;
|
|
addr_t _base;
|
|
addr_t _last;
|
|
|
|
enum {
|
|
HEADER = sizeof(_base) + sizeof(_lock) + sizeof(_last),
|
|
CAP_RANGE_SIZE = 4096,
|
|
WORDS = (CAP_RANGE_SIZE - HEADER - sizeof(Avl_node<Cap_range>)) / sizeof(addr_t),
|
|
};
|
|
|
|
uint8_t _cap_array[WORDS * sizeof(addr_t)];
|
|
|
|
bool _match(addr_t id) {
|
|
return _base <= id && id < _base + sizeof(_cap_array); };
|
|
|
|
public:
|
|
|
|
Cap_range(addr_t base) : _base(base), _last(0) {
|
|
|
|
static_assert(sizeof(*this) == CAP_RANGE_SIZE,
|
|
"Cap_range misconfigured");
|
|
|
|
for (unsigned i=0; i < sizeof(_cap_array); i++)
|
|
_cap_array[i] = 0;
|
|
}
|
|
|
|
addr_t const base() const { return _base; }
|
|
unsigned const elements() { return sizeof(_cap_array); }
|
|
|
|
Cap_range *find_by_id(addr_t);
|
|
|
|
void inc(unsigned id, bool inc_if_one = false);
|
|
void dec(unsigned id, bool revoke = true);
|
|
|
|
addr_t alloc(size_t const num_log2);
|
|
|
|
/************************
|
|
** Avl node interface **
|
|
************************/
|
|
|
|
bool higher(Cap_range *n) { return n->_base > _base; }
|
|
|
|
};
|
|
|
|
|
|
class Cap_index
|
|
{
|
|
private:
|
|
|
|
Cap_range * _range;
|
|
addr_t _local_name;
|
|
|
|
public:
|
|
|
|
Cap_index(Cap_range *range, addr_t local_name)
|
|
: _range(range), _local_name(local_name) {}
|
|
|
|
bool valid() const { return _range; }
|
|
|
|
inline void inc(bool inc_if_one = false)
|
|
{
|
|
if (_range)
|
|
_range->inc(_local_name - _range->base(), inc_if_one);
|
|
}
|
|
|
|
inline void dec()
|
|
{
|
|
if (_range)
|
|
_range->dec(_local_name - _range->base());
|
|
}
|
|
};
|
|
|
|
|
|
class Capability_map : Noncopyable
|
|
{
|
|
private:
|
|
|
|
Avl_tree<Cap_range> _tree;
|
|
|
|
public:
|
|
|
|
Cap_index find(addr_t local_sel);
|
|
|
|
void insert(Cap_range * range) { _tree.insert(range); }
|
|
|
|
addr_t insert(size_t num_log_2 = 0, addr_t cap = ~0UL);
|
|
|
|
void remove(addr_t sel, uint8_t num_log_2 = 0, bool revoke = true);
|
|
};
|
|
|
|
|
|
/**
|
|
* Get the global Capability_map of the process.
|
|
*/
|
|
Capability_map *cap_map();
|
|
}
|
|
|
|
#endif /* _INCLUDE__BASE__CAP_MAP_H_ */
|