154 lines
4.2 KiB
C++
154 lines
4.2 KiB
C++
/*
|
|
* \brief Block session interface.
|
|
* \author Stefan Kalkowski
|
|
* \date 2010-07-06
|
|
*
|
|
* A block session corresponds to a block device, that can be used to read
|
|
* or store data. Payload is communicated over the packet-stream interface
|
|
* set up between 'Session_client' and 'Session_server'.
|
|
*
|
|
* Even though the functions 'tx' and 'tx_channel' are specific for the client
|
|
* side of the block session interface, they are part of the abstract 'Session'
|
|
* class to enable the client-side use of the block interface via a pointer to
|
|
* the abstract 'Session' class. This way, we can transparently co-locate the
|
|
* packet-stream server with the client in same program.
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2010-2012 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__BLOCK_SESSION__BLOCK_SESSION_H_
|
|
#define _INCLUDE__BLOCK_SESSION__BLOCK_SESSION_H_
|
|
|
|
#include <os/packet_stream.h>
|
|
#include <packet_stream_tx/packet_stream_tx.h>
|
|
#include <session/session.h>
|
|
|
|
namespace Block {
|
|
|
|
/**
|
|
* Sector type for block session
|
|
*/
|
|
typedef Genode::uint64_t sector_t;
|
|
|
|
/**
|
|
* Represents an operation request with respect to a block,
|
|
* the data associated with the 'Packet_descriptor' is either
|
|
* the data read from or written to the block indicated by
|
|
* its number.
|
|
*/
|
|
class Packet_descriptor : public ::Packet_descriptor
|
|
{
|
|
public:
|
|
|
|
enum Opcode { READ, WRITE, END };
|
|
enum Alignment { PACKET_ALIGNMENT = 11 };
|
|
|
|
private:
|
|
|
|
Opcode _op; /* requested operation */
|
|
Genode::size_t _block_number; /* requested block number */
|
|
Genode::size_t _block_count; /* number of blocks to transfer */
|
|
unsigned _success :1; /* indicates success of operation */
|
|
|
|
public:
|
|
|
|
/**
|
|
* Constructor
|
|
*/
|
|
Packet_descriptor(Genode::off_t offset=0, Genode::size_t size=0)
|
|
: ::Packet_descriptor(offset, size),
|
|
_op(READ), _block_number(0), _block_count(0), _success(false) { }
|
|
|
|
/**
|
|
* Constructor
|
|
*/
|
|
Packet_descriptor(Packet_descriptor p, Opcode op,
|
|
Genode::size_t blk_nr, Genode::size_t blk_count = 1)
|
|
: ::Packet_descriptor(p.offset(), p.size()),
|
|
_op(op), _block_number(blk_nr),
|
|
_block_count(blk_count), _success(false) { }
|
|
|
|
Opcode operation() const { return _op; }
|
|
Genode::size_t block_number() const { return _block_number; }
|
|
Genode::size_t block_count() const { return _block_count; }
|
|
bool succeeded() const { return _success; }
|
|
|
|
void succeeded(bool b) { _success = b ? 1 : 0; }
|
|
};
|
|
|
|
|
|
struct Session : public Genode::Session
|
|
{
|
|
enum { TX_QUEUE_SIZE = 256 };
|
|
|
|
|
|
/**
|
|
* This class represents supported operations on a block device
|
|
*/
|
|
class Operations
|
|
{
|
|
private:
|
|
|
|
unsigned _ops :Packet_descriptor::END; /* bitfield of ops */
|
|
|
|
public:
|
|
|
|
Operations() : _ops(0) { }
|
|
|
|
bool supported(Packet_descriptor::Opcode op) {
|
|
return (_ops & (1 << op)); }
|
|
|
|
void set_operation(Packet_descriptor::Opcode op) {
|
|
_ops |= (1 << op); }
|
|
};
|
|
|
|
|
|
typedef Packet_stream_policy<Block::Packet_descriptor,
|
|
TX_QUEUE_SIZE, TX_QUEUE_SIZE,
|
|
char> Tx_policy;
|
|
|
|
typedef Packet_stream_tx::Channel<Tx_policy> Tx;
|
|
|
|
static const char *service_name() { return "Block"; }
|
|
|
|
virtual ~Session() { }
|
|
|
|
/**
|
|
* Request information about the metrics of the block device
|
|
*
|
|
* \param blk_count will contain total number of blocks
|
|
* \param blk_size will contain total size in bytes
|
|
* \param ops supported operations
|
|
*/
|
|
virtual void info(Genode::size_t *blk_count,
|
|
Genode::size_t *blk_size,
|
|
Operations *ops) = 0;
|
|
|
|
/**
|
|
* Request packet-transmission channel
|
|
*/
|
|
virtual Tx *tx_channel() { return 0; }
|
|
|
|
/**
|
|
* Request client-side packet-stream interface of tx channel
|
|
*/
|
|
virtual Tx::Source *tx() { return 0; }
|
|
|
|
|
|
/*******************
|
|
** RPC interface **
|
|
*******************/
|
|
|
|
GENODE_RPC(Rpc_info, void, info, Genode::size_t *, Genode::size_t *, Operations *);
|
|
GENODE_RPC(Rpc_tx_cap, Genode::Capability<Tx>, _tx_cap);
|
|
GENODE_RPC_INTERFACE(Rpc_info, Rpc_tx_cap);
|
|
};
|
|
}
|
|
|
|
#endif /* _INCLUDE__BLOCK_SESSION__BLOCK_SESSION_H_ */
|