310 lines
8.8 KiB
C++
310 lines
8.8 KiB
C++
/*
|
||
* \brief Capability
|
||
* \author Norman Feske
|
||
* \date 2011-05-22
|
||
*
|
||
* A typed capability is a capability tied to one specifiec RPC interface
|
||
*/
|
||
|
||
/*
|
||
* Copyright (C) 2011-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__CAPABILITY_H_
|
||
#define _INCLUDE__BASE__CAPABILITY_H_
|
||
|
||
#include <util/string.h>
|
||
#include <base/rpc.h>
|
||
#include <base/native_types.h>
|
||
|
||
namespace Genode {
|
||
|
||
/**
|
||
* Forward declaration needed for internal interfaces of 'Capability'
|
||
*/
|
||
class Ipc_client;
|
||
|
||
|
||
/**
|
||
* Capability that is not associated with a specific RPC interface
|
||
*/
|
||
typedef Native_capability Untyped_capability;
|
||
|
||
template <typename> class Capability;
|
||
|
||
template <typename RPC_INTERFACE>
|
||
Capability<RPC_INTERFACE> reinterpret_cap_cast(Untyped_capability const &);
|
||
|
||
template <typename TO_RPC_INTERFACE, typename FROM_RPC_INTERFACE>
|
||
Capability<TO_RPC_INTERFACE> static_cap_cast(Capability<FROM_RPC_INTERFACE>);
|
||
}
|
||
|
||
|
||
/**
|
||
* Capability referring to a specific RPC interface
|
||
*
|
||
* \param RPC_INTERFACE class containing the RPC interface declaration
|
||
*/
|
||
template <typename RPC_INTERFACE>
|
||
class Genode::Capability : public Untyped_capability
|
||
{
|
||
private:
|
||
|
||
/**
|
||
* Insert RPC arguments into the message buffer
|
||
*/
|
||
template <typename ATL>
|
||
void _marshal_args(Ipc_client &ipc_client, ATL &args) const;
|
||
|
||
void _marshal_args(Ipc_client &, Meta::Empty &) const { }
|
||
|
||
/**
|
||
* Unmarshal single RPC argument from the message buffer
|
||
*/
|
||
template <typename T>
|
||
void _unmarshal_result(Ipc_client &ipc_client, T &arg,
|
||
Meta::Overload_selector<Rpc_arg_out>) const;
|
||
|
||
template <typename T>
|
||
void _unmarshal_result(Ipc_client &ipc_client, T &arg,
|
||
Meta::Overload_selector<Rpc_arg_inout>) const;
|
||
|
||
template <typename T>
|
||
void _unmarshal_result(Ipc_client &, T &,
|
||
Meta::Overload_selector<Rpc_arg_in>) const { }
|
||
|
||
/**
|
||
* Read RPC results from the message buffer
|
||
*/
|
||
template <typename ATL>
|
||
void _unmarshal_results(Ipc_client &ipc_client, ATL &args) const;
|
||
|
||
void _unmarshal_results(Ipc_client &, Meta::Empty &) const { }
|
||
|
||
/**
|
||
* Check RPC return code for the occurrence of exceptions
|
||
*
|
||
* A server-side exception is indicated by a non-zero exception
|
||
* code. Each exception code corresponds to an entry in the
|
||
* exception type list specified in the RPC function declaration.
|
||
* The '_check_for_exception' method template throws the
|
||
* exception type belonging to the received exception code.
|
||
*/
|
||
template <typename EXC_TL>
|
||
void _check_for_exceptions(Rpc_exception_code const exc_code,
|
||
Meta::Overload_selector<EXC_TL>) const
|
||
{
|
||
enum { EXCEPTION_CODE = RPC_EXCEPTION_BASE - Meta::Length<EXC_TL>::Value };
|
||
|
||
if (exc_code == EXCEPTION_CODE)
|
||
throw typename EXC_TL::Head();
|
||
|
||
_check_for_exceptions(exc_code, Meta::Overload_selector<typename EXC_TL::Tail>());
|
||
}
|
||
|
||
void _check_for_exceptions(Rpc_exception_code const,
|
||
Meta::Overload_selector<Meta::Empty>) const
|
||
{ }
|
||
|
||
/**
|
||
* Perform RPC call, arguments passed a as nested 'Ref_tuple' object
|
||
*/
|
||
template <typename IF>
|
||
void _call(typename IF::Client_args &args,
|
||
typename IF::Ret_type &ret) const;
|
||
|
||
/**
|
||
* Shortcut for querying argument types used in 'call' methods
|
||
*/
|
||
template <typename IF, unsigned I>
|
||
struct Arg
|
||
{
|
||
typedef typename Meta::Type_at<typename IF::Client_args, I>::Type Type;
|
||
};
|
||
|
||
template <typename FROM_RPC_INTERFACE>
|
||
Untyped_capability
|
||
_check_compatibility(Capability<FROM_RPC_INTERFACE> const &cap) const
|
||
{
|
||
FROM_RPC_INTERFACE *from = 0;
|
||
RPC_INTERFACE *to = from;
|
||
(void)to;
|
||
return cap;
|
||
}
|
||
|
||
/**
|
||
* Wrapper for the return type instantiated by 'call' overloads
|
||
*
|
||
* Each 'call' overload creates an instance of the return value
|
||
* type as local variable. A reference to this variable is passed
|
||
* to the '_call' method, which will assign its value. Even
|
||
* though the variable does not need to be initialized prior the
|
||
* call of '_call', the GCC will still complain "warning: ‘ret’ may
|
||
* be used uninitialized in this function". Wrapping the return
|
||
* value in a struct silences the compiler.
|
||
*/
|
||
template <typename IF>
|
||
struct Return
|
||
{
|
||
typedef typename Trait::Call_return<typename IF::Ret_type>::Type
|
||
Return_type;
|
||
|
||
volatile Return_type _value;
|
||
Return_type &value() { return *(Return_type *)(&_value); }
|
||
};
|
||
|
||
public:
|
||
|
||
typedef RPC_INTERFACE Rpc_interface;
|
||
|
||
/**
|
||
* Constructor
|
||
*
|
||
* This implicit constructor checks at compile time for the
|
||
* compatibility of the source and target capability types. The
|
||
* construction is performed only if the target capability type is
|
||
* identical to or a base type of the source capability type.
|
||
*/
|
||
template <typename FROM_RPC_INTERFACE>
|
||
Capability(Capability<FROM_RPC_INTERFACE> const &cap)
|
||
: Untyped_capability(_check_compatibility(cap))
|
||
{ }
|
||
|
||
/**
|
||
* Default constructor creates invalid capability
|
||
*/
|
||
Capability() { }
|
||
|
||
template <typename IF>
|
||
typename Trait::Call_return<typename IF::Ret_type>::Type
|
||
call() const
|
||
{
|
||
Meta::Empty e;
|
||
Return<IF> ret;
|
||
_call<IF>(e, ret.value());
|
||
return ret.value();
|
||
}
|
||
|
||
template <typename IF>
|
||
typename Trait::Call_return<typename IF::Ret_type>::Type
|
||
call(typename Arg<IF, 0>::Type v1) const
|
||
{
|
||
Meta::Empty e;
|
||
typename IF::Client_args args(v1, e);
|
||
Return<IF> ret;
|
||
_call<IF>(args, ret.value());
|
||
return ret.value();
|
||
}
|
||
|
||
template <typename IF>
|
||
typename Trait::Call_return<typename IF::Ret_type>::Type
|
||
call(typename Arg<IF, 0>::Type v1, typename Arg<IF, 1>::Type v2) const
|
||
{
|
||
Meta::Empty e;
|
||
typename IF::Client_args args(v1, v2, e);
|
||
Return<IF> ret;
|
||
_call<IF>(args, ret.value());
|
||
return ret.value();
|
||
}
|
||
|
||
template <typename IF>
|
||
typename Trait::Call_return<typename IF::Ret_type>::Type
|
||
call(typename Arg<IF, 0>::Type v1, typename Arg<IF, 1>::Type v2,
|
||
typename Arg<IF, 2>::Type v3) const
|
||
{
|
||
Meta::Empty e;
|
||
typename IF::Client_args args(v1, v2, v3, e);
|
||
Return<IF> ret;
|
||
_call<IF>(args, ret.value());
|
||
return ret.value();
|
||
}
|
||
|
||
template <typename IF>
|
||
typename Trait::Call_return<typename IF::Ret_type>::Type
|
||
call(typename Arg<IF, 0>::Type v1, typename Arg<IF, 1>::Type v2,
|
||
typename Arg<IF, 2>::Type v3, typename Arg<IF, 3>::Type v4) const
|
||
{
|
||
Meta::Empty e;
|
||
typename IF::Client_args args(v1, v2, v3, v4, e);
|
||
Return<IF> ret;
|
||
_call<IF>(args, ret.value());
|
||
return ret.value();
|
||
}
|
||
|
||
template <typename IF>
|
||
typename Trait::Call_return<typename IF::Ret_type>::Type
|
||
call(typename Arg<IF, 0>::Type v1, typename Arg<IF, 1>::Type v2,
|
||
typename Arg<IF, 2>::Type v3, typename Arg<IF, 3>::Type v4,
|
||
typename Arg<IF, 4>::Type v5) const
|
||
{
|
||
Meta::Empty e;
|
||
typename IF::Client_args args(v1, v2, v3, v4, v5, e);
|
||
Return<IF> ret;
|
||
_call<IF>(args, ret.value());
|
||
return ret.value();
|
||
}
|
||
|
||
template <typename IF>
|
||
typename Trait::Call_return<typename IF::Ret_type>::Type
|
||
call(typename Arg<IF, 0>::Type v1, typename Arg<IF, 1>::Type v2,
|
||
typename Arg<IF, 2>::Type v3, typename Arg<IF, 3>::Type v4,
|
||
typename Arg<IF, 4>::Type v5, typename Arg<IF, 5>::Type v6) const
|
||
{
|
||
Meta::Empty e;
|
||
typename IF::Client_args args(v1, v2, v3, v4, v5, v6, e);
|
||
Return<IF> ret;
|
||
_call<IF>(args, ret.value());
|
||
return ret.value();
|
||
}
|
||
|
||
template <typename IF>
|
||
typename Trait::Call_return<typename IF::Ret_type>::Type
|
||
call(typename Arg<IF, 0>::Type v1, typename Arg<IF, 1>::Type v2,
|
||
typename Arg<IF, 2>::Type v3, typename Arg<IF, 3>::Type v4,
|
||
typename Arg<IF, 4>::Type v5, typename Arg<IF, 5>::Type v6,
|
||
typename Arg<IF, 6>::Type v7) const
|
||
{
|
||
Meta::Empty e;
|
||
typename IF::Client_args args(v1, v2, v3, v4, v5, v6, v7, e);
|
||
Return<IF> ret;
|
||
_call<IF>(args, ret.value());
|
||
return ret.value();
|
||
}
|
||
};
|
||
|
||
|
||
/**
|
||
* Convert an untyped capability to a typed capability
|
||
*/
|
||
template <typename RPC_INTERFACE>
|
||
Genode::Capability<RPC_INTERFACE>
|
||
Genode::reinterpret_cap_cast(Untyped_capability const &untyped_cap)
|
||
{
|
||
/*
|
||
* The object layout of untyped and typed capabilities is identical.
|
||
* Hence we can just use it's copy-constructors.
|
||
*/
|
||
Untyped_capability *ptr = const_cast<Untyped_capability*>(&untyped_cap);
|
||
return *static_cast<Capability<RPC_INTERFACE>*>(ptr);
|
||
}
|
||
|
||
|
||
/**
|
||
* Convert capability type from an interface base type to an inherited
|
||
* interface type
|
||
*/
|
||
template <typename TO_RPC_INTERFACE, typename FROM_RPC_INTERFACE>
|
||
Genode::Capability<TO_RPC_INTERFACE>
|
||
Genode::static_cap_cast(Capability<FROM_RPC_INTERFACE> cap)
|
||
{
|
||
/* check interface compatibility */
|
||
(void)static_cast<TO_RPC_INTERFACE *>((FROM_RPC_INTERFACE *)0);
|
||
|
||
return reinterpret_cap_cast<TO_RPC_INTERFACE>(cap);
|
||
}
|
||
|
||
#endif /* _INCLUDE__BASE__CAPABILITY_H_ */
|