denshooter/genode
1
0
Fork 0
mirror of https://github.com/mmueller41/genode.git synced 2026-01-21 12:32:56 +01:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:mmueller41/genode

Browse Source
This commit is contained in:
Michael Mueller
2022-10-14 14:31:37 +02:00
parent bdb1b222cd 9079a083d2
commit f38762f9f0
1561 changed files with 27337 additions and 15653 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
repos/os/include/audio_in_session/audio_in_session.h
View File

@@ -80,7 +80,7 @@ class Audio_in::Packet
Genode::memcpy(_data, data, (samples > PERIOD ? PERIOD : samples) * SAMPLE_SIZE);
if (samples < PERIOD)
Genode::memset(data + samples, 0, (PERIOD - samples) * SAMPLE_SIZE);
Genode::memset(_data + samples, 0, (PERIOD - samples) * SAMPLE_SIZE);
}
/**

4
repos/os/include/audio_out_session/audio_out_session.h
View File

@@ -252,8 +252,8 @@ class Audio_out::Stream
{
if (full())
throw Alloc_failed();
unsigned pos = _tail;
_tail = (_tail + 1) % QUEUE_SIZE;
Packet *p = get(pos);
@@ -267,7 +267,7 @@ class Audio_out::Stream
*
* This means that allocation will start at current queue position.
*/
void reset() { _tail = (_pos + 1) % QUEUE_SIZE; }
void reset() { _tail = _pos; }
/**

11
repos/os/include/block/component.h
View File

@@ -292,21 +292,14 @@ class Block::Root : public Genode::Root_component<Block::Session_component,
size_t tx_buf_size =
Arg_string::find_arg(args, "tx_buf_size").ulong_value(0);
/* delete ram quota by the memory needed for the session */
size_t session_size = max((size_t)4096,
sizeof(Session_component)
+ sizeof(Allocator_avl));
if (ram_quota < session_size)
throw Insufficient_ram_quota();
/*
* Check if donated ram quota suffices for both
* communication buffers. Also check both sizes separately
* to handle a possible overflow of the sum of both sizes.
*/
if (tx_buf_size > ram_quota - session_size) {
if (tx_buf_size > ram_quota) {
error("insufficient 'ram_quota', got ", ram_quota, ", need ",
tx_buf_size + session_size);
tx_buf_size);
throw Insufficient_ram_quota();
}

37
repos/os/include/decorator/xml_utils.h
View File

@@ -16,42 +16,7 @@
#include <decorator/types.h>
namespace Decorator {
static Point point_attribute(Xml_node const &);
static Area area_attribute(Xml_node const &);
static Rect rect_attribute(Xml_node const &);
static Color color(Xml_node const &);
}
/**
* Read point position from XML node
*/
static inline Decorator::Point Decorator::point_attribute(Genode::Xml_node const &point)
{
return Point((int)point.attribute_value("xpos", 0L),
(int)point.attribute_value("ypos", 0L)); }
/**
* Read area size from XML node
*/
static inline Decorator::Area Decorator::area_attribute(Genode::Xml_node const &area)
{
return Area(area.attribute_value("width", 0U),
area.attribute_value("height", 0U));
}
/**
* Read rectangle coordinates from XML node
*/
static inline Decorator::Rect Decorator::rect_attribute(Genode::Xml_node const &rect)
{
return Rect(point_attribute(rect), area_attribute(rect));
}
namespace Decorator { static Color color(Xml_node const &); }
/**

5
repos/os/include/file_system_session/client.h
View File

@@ -112,6 +112,11 @@ class File_system::Session_client : public Genode::Rpc_client<Session>
{
call<Rpc_move>(from_dir, from_name, to_dir, to_name);
}
unsigned num_entries(Dir_handle dir) override
{
return call<Rpc_num_entries>(dir);
}
};
#endif /* _INCLUDE__FILE_SYSTEM_SESSION__CLIENT_H_ */

15
repos/os/include/file_system_session/file_system_session.h
View File

@@ -474,6 +474,13 @@ struct File_system::Session : public Genode::Session
virtual void move(Dir_handle, Name const &from,
Dir_handle, Name const &to) = 0;
/**
* Return number of directory entries
*
* \throw Invalid_handle the directory handle is invalid
*/
virtual unsigned num_entries(Dir_handle) = 0;
/*******************
** RPC interface **
@@ -525,12 +532,14 @@ struct File_system::Session : public Genode::Session
GENODE_TYPE_LIST(Invalid_handle, Invalid_name,
Lookup_failed, Permission_denied, Unavailable),
Dir_handle, Name const &, Dir_handle, Name const &);
GENODE_RPC_THROW(Rpc_num_entries, unsigned, num_entries,
GENODE_TYPE_LIST(Invalid_handle),
Dir_handle);
GENODE_RPC_INTERFACE(Rpc_tx_cap,
Rpc_file, Rpc_symlink, Rpc_dir,
Rpc_node, Rpc_watch,
Rpc_file, Rpc_symlink, Rpc_dir, Rpc_node, Rpc_watch,
Rpc_close, Rpc_status, Rpc_control, Rpc_unlink,
Rpc_truncate, Rpc_move);
Rpc_truncate, Rpc_move, Rpc_num_entries);
};
#endif /* _INCLUDE__FILE_SYSTEM_SESSION__FILE_SYSTEM_SESSION_H_ */

8
repos/os/include/genode_c_api/event.h
View File

@@ -1,6 +1,7 @@
/*
* \brief C interface to Genode's event session
* \author Norman Feske
* \author Christian Helmuth
* \date 2021-09-29
*/
@@ -62,9 +63,16 @@ struct genode_event_submit;
/**
* Interface called by 'genode_event_generator_t' to submit events
*
* Note, keycode values must conform to os/include/input/keycodes.h.
*/
struct genode_event_submit
{
void (*press) (struct genode_event_submit *, unsigned keycode);
void (*release) (struct genode_event_submit *, unsigned keycode);
void (*rel_motion) (struct genode_event_submit *, int x, int y);
void (*touch) (struct genode_event_submit *,
struct genode_event_touch_args const *);

76
repos/os/include/genode_c_api/usb.h
View File

@@ -148,8 +148,6 @@ struct genode_usb_request_control
};
enum Iso { MAX_PACKETS = 32 };
enum Transfer { BULK, IRQ, ISOC };
typedef enum Transfer genode_usb_transfer_type_t;
struct genode_usb_request_transfer
{
@@ -161,6 +159,27 @@ struct genode_usb_request_transfer
unsigned long actual_packet_size[MAX_PACKETS];
};
enum Urb_type { CTRL, BULK, IRQ, ISOC, NONE };
typedef enum Urb_type genode_usb_urb_t;
struct genode_usb_request_urb
{
genode_usb_urb_t type;
void * req;
};
static inline struct genode_usb_request_control *
genode_usb_get_request_control(struct genode_usb_request_urb * urb)
{
return (urb->type == CTRL) ? (struct genode_usb_request_control*)urb->req : 0;
}
static inline struct genode_usb_request_transfer *
genode_usb_get_request_transfer(struct genode_usb_request_urb * urb)
{
return (urb->type != CTRL) ? (struct genode_usb_request_transfer*)urb->req : 0;
}
enum Request_return_error {
NO_ERROR,
INTERFACE_OR_ENDPOINT_ERROR,
@@ -174,43 +193,46 @@ enum Request_return_error {
};
typedef enum Request_return_error genode_usb_request_ret_t;
typedef genode_usb_request_ret_t (*genode_usb_req_ctrl_t)
(struct genode_usb_request_control * req,
void * payload,
unsigned long payload_size,
void * opaque_data);
typedef void (*genode_usb_req_urb_t)
(struct genode_usb_request_urb req,
genode_usb_session_handle_t session_handle,
genode_usb_request_handle_t request_handle,
void * payload,
unsigned long payload_size,
void * opaque_data);
typedef genode_usb_request_ret_t (*genode_usb_req_transfer_t)
(struct genode_usb_request_transfer * req,
genode_usb_transfer_type_t type,
genode_usb_session_handle_t session_handle,
genode_usb_request_handle_t request_handle,
void * payload,
unsigned long payload_size,
void * opaque_data);
typedef genode_usb_request_ret_t (*genode_usb_req_string_t)
typedef void (*genode_usb_req_string_t)
(struct genode_usb_request_string * req,
genode_usb_session_handle_t session_handle,
genode_usb_request_handle_t request_handle,
void * payload,
unsigned long payload_size,
void * opaque_data);
typedef genode_usb_request_ret_t (*genode_usb_req_altsetting_t)
(unsigned iface, unsigned alt_setting, void * opaque_data);
typedef void (*genode_usb_req_altsetting_t)
(unsigned iface, unsigned alt_setting,
genode_usb_session_handle_t session_handle,
genode_usb_request_handle_t request_handle,
void * opaque_data);
typedef genode_usb_request_ret_t (*genode_usb_req_config_t)
(unsigned config_idx, void * opaque_data);
typedef void (*genode_usb_req_config_t)
(unsigned config_idx,
genode_usb_session_handle_t session_handle,
genode_usb_request_handle_t request_handle,
void * opaque_data);
typedef genode_usb_request_ret_t (*genode_usb_req_flush_t)
(unsigned char ep, void * opaque_data);
typedef void (*genode_usb_req_flush_t)
(unsigned char ep,
genode_usb_session_handle_t session_handle,
genode_usb_request_handle_t request_handle,
void * opaque_data);
typedef genode_usb_request_ret_t (*genode_usb_response_t)
(struct genode_usb_request_transfer * req,
void * opaque_data);
(struct genode_usb_request_urb req,
void * opaque_data);
struct genode_usb_request_callbacks {
genode_usb_req_ctrl_t control_fn;
genode_usb_req_transfer_t transfer_fn;
genode_usb_req_urb_t urb_fn;
genode_usb_req_string_t string_fn;
genode_usb_req_altsetting_t altsetting_fn;
genode_usb_req_config_t config_fn;

43
repos/os/include/gpu/info_lima.h Normal file
View File

@@ -0,0 +1,43 @@
/*
* \brief Gpu Information Lima
* \author Josef Soentgen
* \date 2022-06-14
*/
/*
* Copyright (C) 2022 Genode Labs GmbH
*
* This file is part of the Genode OS framework, which is distributed
* under the terms of the GNU Affero General Public License version 3.
*/
#ifndef _INCLUDE__GPU_INFO_LIMA_H_
#define _INCLUDE__GPU_INFO_LIMA_H_
#include <base/output.h>
#include <session/session.h>
#include <gpu_session/gpu_session.h>
namespace Gpu {
struct Info_lima;
} /* namespace Gpu */
/*
* Gpu information
*
* Used to query information in the DRM backend
*/
struct Gpu::Info_lima
{
/*
* Size the array based on the list of params in
* lima_drm.h that allow for 1:1 access.
*/
enum { MAX_LIMA_PARAMS = 4, };
using Param = Genode::uint64_t;
Param param[MAX_LIMA_PARAMS] { };
};
#endif /* _INCLUDE__GPU_INFO_LIMA_H_ */

3
repos/os/include/gpu_session/client.h
View File

@@ -76,6 +76,9 @@ class Gpu::Session_client : public Genode::Rpc_client<Session>
void unmap_buffer_ppgtt(Buffer_id id, Gpu::addr_t va) override {
call<Rpc_unmap_buffer_ppgtt>(id, va); }
Gpu::addr_t query_buffer_ppgtt(Gpu::Buffer_id id) override {
return call<Rpc_query_buffer_ppgtt>(id); }
bool set_tiling(Buffer_id id, unsigned mode) override {
return call<Rpc_set_tiling>(id, mode); }
};

12
repos/os/include/gpu_session/gpu_session.h
View File

@@ -197,7 +197,14 @@ struct Gpu::Session : public Genode::Session
*
* \param id buffer id
*/
virtual void unmap_buffer_ppgtt(Buffer_id id, Gpu::addr_t) = 0;
virtual void unmap_buffer_ppgtt(Buffer_id id, Gpu::addr_t va) = 0;
/**
* Get virtual address of buffer in the PPGTT
*
* \param id buffer id to be associated with the buffer
*/
virtual Gpu::addr_t query_buffer_ppgtt(Buffer_id) = 0;
/**
* Set tiling for buffer
@@ -237,6 +244,7 @@ struct Gpu::Session : public Genode::Session
Gpu::Buffer_id, Gpu::addr_t);
GENODE_RPC(Rpc_unmap_buffer_ppgtt, void, unmap_buffer_ppgtt,
Gpu::Buffer_id, Gpu::addr_t);
GENODE_RPC(Rpc_query_buffer_ppgtt, Gpu::addr_t, query_buffer_ppgtt, Gpu::Buffer_id);
GENODE_RPC(Rpc_set_tiling, bool, set_tiling,
Gpu::Buffer_id, unsigned);
@@ -244,7 +252,7 @@ struct Gpu::Session : public Genode::Session
Rpc_complete, Rpc_completion_sigh, Rpc_alloc_buffer,
Rpc_free_buffer, Rpc_export_buffer, Rpc_import_buffer,
Rpc_map_buffer, Rpc_unmap_buffer,
Rpc_map_buffer_ppgtt, Rpc_unmap_buffer_ppgtt,
Rpc_map_buffer_ppgtt, Rpc_unmap_buffer_ppgtt, Rpc_query_buffer_ppgtt,
Rpc_set_tiling);
};

5
repos/os/include/legacy/x86/platform_device/platform_device.h
View File

@@ -1,6 +1,7 @@
/*
* \brief PCI-device interface
* \author Norman Feske
* \author Christian Helmuth
* \date 2008-01-28
*/
@@ -80,10 +81,10 @@ struct Platform::Device : Platform::Abstract_device
{
/*
* Mask out the resource-description bits of the base
* address register. I/O resources use the lowest 3
* address register. I/O resources use the lowest 2
* bits, memory resources use the lowest 4 bits.
*/
return _bar & ((type() == IO) ? ~7 : ~15);
return _bar & ((type() == IO) ? ~3 : ~15);
}
/**

5
repos/os/include/net/icmp.h
View File

@@ -114,6 +114,8 @@ class Net::Icmp_packet
void update_checksum(Genode::size_t data_sz);
void update_checksum(Internet_checksum_diff const &icd);
bool checksum_error(Genode::size_t data_sz) const;
@@ -157,6 +159,9 @@ class Net::Icmp_packet
void query_id(Genode::uint16_t v) { _rest_of_header_u16[0] = host_to_big_endian(v); }
void query_seq(Genode::uint16_t v) { _rest_of_header_u16[1] = host_to_big_endian(v); }
void type_and_code(Type t, Code c, Internet_checksum_diff &icd);
void query_id(Genode::uint16_t v, Internet_checksum_diff &icd);
/*********
** log **

52
repos/os/include/net/internet_checksum.h
View File

@@ -42,16 +42,50 @@ namespace Net {
} __attribute__((packed));
Genode::uint16_t internet_checksum(Packed_uint16 const *addr,
Genode::size_t size,
Genode::addr_t init_sum = 0);
Genode::uint16_t internet_checksum(Packed_uint16 const *data_ptr,
Genode::size_t data_sz);
Genode::uint16_t internet_checksum_pseudo_ip(Packed_uint16 const *addr,
Genode::size_t size,
Genode::uint16_t size_be,
Ipv4_packet::Protocol ip_prot,
Ipv4_address &ip_src,
Ipv4_address &ip_dst);
Genode::uint16_t
internet_checksum_pseudo_ip(Packed_uint16 const *data_ptr,
Genode::size_t data_sz,
Genode::uint16_t ip_data_sz_be,
Ipv4_packet::Protocol ip_prot,
Ipv4_address &ip_src,
Ipv4_address &ip_dst);
/**
* Accumulating modifier for incremental updates of internet checksums
*/
class Internet_checksum_diff
{
private:
signed long _value { 0 };
public:
/**
* Update modifier according to a data update in the target region
*
* PRECONDITIONS
*
* * The pointers must refer to data that is at an offset inside
* the checksum'd region that is a multiple of 2 bytes (16 bits).
*/
void add_up_diff(Packed_uint16 const *new_data_ptr,
Packed_uint16 const *old_data_ptr,
Genode::size_t data_sz);
/**
* Update this modifier by adding up another modifier
*/
void add_up_diff(Internet_checksum_diff const &icd);
/**
* Return the given checksum with this modifier applied
*/
Genode::uint16_t apply_to(signed long sum) const;
};
}
#endif /* _NET__INTERNET_CHECKSUM_H_ */

12
repos/os/include/net/ipv4.h
View File

@@ -27,8 +27,10 @@
namespace Genode { class Output; }
namespace Net {
enum { IPV4_ADDR_LEN = 4 };
class Internet_checksum_diff;
class Ipv4_address;
class Ipv4_packet;
@@ -54,6 +56,8 @@ struct Net::Ipv4_address : Network_address<IPV4_ADDR_LEN, '.', false>
bool is_in_range(Ipv4_address const &first,
Ipv4_address const &last) const;
bool is_multicast() const;
}
__attribute__((packed));
@@ -94,6 +98,11 @@ class Net::Ipv4_packet
void update_checksum();
void update_checksum(Internet_checksum_diff const &icd);
void update_checksum(Internet_checksum_diff const &icd,
Internet_checksum_diff &caused_icd);
bool checksum_error() const;
private:
@@ -237,6 +246,9 @@ class Net::Ipv4_packet
_offset_6_u16 = host_to_big_endian(be);
}
void src(Ipv4_address v, Internet_checksum_diff &icd);
void dst(Ipv4_address v, Internet_checksum_diff &icd);
/*********
** log **

5
repos/os/include/net/tcp.h
View File

@@ -72,6 +72,8 @@ class Net::Tcp_packet
Ipv4_address ip_dst,
size_t tcp_size);
void update_checksum(Internet_checksum_diff const &icd);
/***************
** Accessors **
@@ -99,6 +101,9 @@ class Net::Tcp_packet
void src_port(Port p) { _src_port = host_to_big_endian(p.value); }
void dst_port(Port p) { _dst_port = host_to_big_endian(p.value); }
void src_port(Port p, Internet_checksum_diff &icd);
void dst_port(Port p, Internet_checksum_diff &icd);
/*********
** log **

5
repos/os/include/net/udp.h
View File

@@ -84,6 +84,8 @@ class Net::Udp_packet
void update_checksum(Ipv4_address ip_src,
Ipv4_address ip_dst);
void update_checksum(Internet_checksum_diff const &icd);
bool checksum_error(Ipv4_address ip_src,
Ipv4_address ip_dst) const;
@@ -103,6 +105,9 @@ class Net::Udp_packet
void src_port_big_endian(Genode::uint16_t v) { _src_port = v; }
void dst_port_big_endian(Genode::uint16_t v) { _dst_port = v; }
void src_port(Port p, Internet_checksum_diff &icd);
void dst_port(Port p, Internet_checksum_diff &icd);
/*********
** log **

45
repos/os/include/os/packet_stream.h
View File

@@ -444,13 +444,13 @@ class Genode::Packet_descriptor_receiver
return packet;
}
bool rx_wakeup()
bool rx_wakeup(bool omit_signal)
{
Genode::Mutex::Guard mutex_guard(_rx_queue_mutex);
bool signal_submitted = false;
if (_rx_wakeup_needed) {
if (_rx_wakeup_needed && !omit_signal) {
_tx_ready.submit();
signal_submitted = true;
}
@@ -639,6 +639,10 @@ class Genode::Packet_stream_source : private Packet_stream_base
class Saturated_submit_queue : Exception { };
class Empty_ack_queue : Exception { };
enum class Alloc_packet_error { FAILED };
using Alloc_packet_result = Attempt<Packet_descriptor, Alloc_packet_error>;
/**
* Constructor
*
@@ -726,6 +730,29 @@ class Genode::Packet_stream_source : private Packet_stream_base
throw Packet_alloc_failed(); });
}
/**
* Allocate packet without throwing exceptions
*
* \param size size of packet in bytes
* \param align alignment of packet as log2 value, default is 1 byte
* \return an Attempt object that either contains an error or a
* packet descriptor with an assigned range within the
* bulk buffer shared between source and sink
*/
Alloc_packet_result alloc_packet_attempt(Genode::size_t size, unsigned align = PACKET_ALIGNMENT)
{
if (size == 0)
return Packet_descriptor(0, 0);
return _packet_alloc.alloc_aligned(size, align).convert<Alloc_packet_result>(
[&] (void *base) {
return Packet_descriptor((Genode::off_t)base, size); },
[&] (Allocator::Alloc_error) {
return Alloc_packet_error::FAILED; });
}
/**
* Get pointer to the content of the specified packet
*
@@ -772,12 +799,13 @@ class Genode::Packet_stream_source : private Packet_stream_base
* Wake up the packet sink if needed
*
* This method assumes that the same signal handler is used for
* the submit transmitter and the ack receiver.
* the submit transmitter and the ack receiver. The ack receiver is not
* signalled if the submit transmitter was already signalled.
*/
void wakeup()
{
/* submit only one signal */
_submit_transmitter.tx_wakeup() || _ack_receiver.rx_wakeup();
/* submit only one signal, prefer submit transmitter over ack receiver */
_ack_receiver.rx_wakeup(_submit_transmitter.tx_wakeup());
}
/**
@@ -930,12 +958,13 @@ class Genode::Packet_stream_sink : private Packet_stream_base
* Wake up the packet source if needed
*
* This method assumes that the same signal handler is used for
* the submit receiver and the ack transmitter.
* the submit receiver and the ack transmitter. The submit receiver
* is not signalled if the ack transmitter was already signalled.
*/
void wakeup()
{
/* submit only one signal */
_submit_receiver.rx_wakeup() || _ack_transmitter.tx_wakeup();
/* submit only one signal, prefer ack_avail signal over ready_to_submit */
_submit_receiver.rx_wakeup(_ack_transmitter.tx_wakeup());
}
/**

2
repos/os/include/os/session_policy.h
View File

@@ -193,7 +193,7 @@ void Genode::with_matching_policy(String<N> const &label,
/* fall back to default policy if no match exists */
if (best_match.has_type("none"))
policies.with_sub_node("default-policy", [&] (Xml_node const &policy) {
policies.with_optional_sub_node("default-policy", [&] (Xml_node const &policy) {
best_match = policy; });
if (best_match.has_type("none"))

135
repos/os/include/os/vfs.h
View File

@@ -27,6 +27,8 @@ namespace Genode {
struct File;
class Readonly_file;
class File_content;
class Writeable_file;
class Append_file;
class New_file;
class Watcher;
template <typename>
@@ -124,6 +126,8 @@ struct Genode::Directory : Noncopyable, Interface
friend class Readonly_file;
friend class Root_directory;
friend class Watcher;
friend class Writeable_file;
friend class Append_file;
friend class New_file;
/*
@@ -668,22 +672,21 @@ class Genode::File_content
/**
* Utility for writing data to a file via the Genode VFS library
* Base class of `New_file` and `Append_file` providing open for write, sync,
* and append functionality.
*/
class Genode::New_file : Noncopyable
class Genode::Writeable_file : Noncopyable
{
public:
struct Create_failed : Exception { };
private:
enum class Append_result { OK, WRITE_ERROR };
Entrypoint &_ep;
Allocator &_alloc;
Vfs::File_system &_fs;
Vfs::Vfs_handle &_handle;
protected:
Vfs::Vfs_handle &_init_handle(Directory &dir, Directory::Path const &rel_path)
static Vfs::Vfs_handle &_init_handle(Directory &dir,
Directory::Path const &rel_path)
{
/* create compound directory */
{
@@ -701,39 +704,24 @@ class Genode::New_file : Noncopyable
Vfs::Vfs_handle *handle_ptr = nullptr;
Vfs::Directory_service::Open_result const res =
_fs.open(path.string(), mode, &handle_ptr, _alloc);
dir._fs.open(path.string(), mode, &handle_ptr, dir._alloc);
if (res != Vfs::Directory_service::OPEN_OK || (handle_ptr == nullptr)) {
error("failed to create file '", path, "', res=", (int)res);
error("failed to create/open file '", path, "' for writing, res=", (int)res);
throw Create_failed();
}
handle_ptr->fs().ftruncate(handle_ptr, 0);
return *handle_ptr;
}
public:
/**
* Constructor
*
* \throw Create_failed
*/
New_file(Directory &dir, Directory::Path const &path)
:
_ep(dir._ep), _alloc(dir._alloc), _fs(dir._fs),
_handle(_init_handle(dir, path))
{ }
~New_file()
static void _sync(Vfs::Vfs_handle &handle, Entrypoint &ep)
{
while (_handle.fs().queue_sync(&_handle) == false)
_ep.wait_and_dispatch_one_io_signal();
while (handle.fs().queue_sync(&handle) == false)
ep.wait_and_dispatch_one_io_signal();
for (bool sync_done = false; !sync_done; ) {
switch (_handle.fs().complete_sync(&_handle)) {
switch (handle.fs().complete_sync(&handle)) {
case Vfs::File_io_service::SYNC_QUEUED:
break;
@@ -749,14 +737,12 @@ class Genode::New_file : Noncopyable
}
if (!sync_done)
_ep.wait_and_dispatch_one_io_signal();
ep.wait_and_dispatch_one_io_signal();
}
_handle.ds().close(&_handle);
}
enum class Append_result { OK, WRITE_ERROR };
Append_result append(char const *src, size_t size)
static Append_result _append(Vfs::Vfs_handle &handle, Entrypoint &ep,
char const *src, size_t size)
{
bool write_error = false;
@@ -771,7 +757,7 @@ class Genode::New_file : Noncopyable
using Write_result = Vfs::File_io_service::Write_result;
switch (_handle.fs().write(&_handle, src, remaining_bytes,
switch (handle.fs().write(&handle, src, remaining_bytes,
out_count)) {
case Write_result::WRITE_ERR_AGAIN:
@@ -789,7 +775,7 @@ class Genode::New_file : Noncopyable
out_count = min((Vfs::file_size)remaining_bytes, out_count);
remaining_bytes -= (size_t)out_count;
src += out_count;
_handle.advance_seek(out_count);
handle.advance_seek(out_count);
break;
};
}
@@ -797,7 +783,7 @@ class Genode::New_file : Noncopyable
stalled = true; }
if (stalled)
_ep.wait_and_dispatch_one_io_signal();
ep.wait_and_dispatch_one_io_signal();
}
return write_error ? Append_result::WRITE_ERROR
: Append_result::OK;
@@ -805,6 +791,81 @@ class Genode::New_file : Noncopyable
};
/**
* Utility for appending data to an existing file via the Genode VFS library
*/
class Genode::Append_file : public Writeable_file
{
private:
Entrypoint &_ep;
Vfs::Vfs_handle &_handle;
public:
/**
* Constructor
*
* \throw Create_failed
*/
Append_file(Directory &dir, Directory::Path const &path)
:
_ep(dir._ep),
_handle(_init_handle(dir, path))
{
Vfs::Directory_service::Stat stat { };
if (_handle.ds().stat(path.string(), stat) == Vfs::Directory_service::STAT_OK)
_handle.seek(stat.size);
}
~Append_file()
{
_sync(_handle, _ep);
_handle.ds().close(&_handle);
}
Append_result append(char const *src, size_t size) {
return _append(_handle, _ep, src, size); }
};
/**
* Utility for writing data to a new file via the Genode VFS library
*/
class Genode::New_file : public Writeable_file
{
private:
Entrypoint &_ep;
Vfs::Vfs_handle &_handle;
public:
using Writeable_file::Append_result;
using Writeable_file::Create_failed;
/**
* Constructor
*
* \throw Create_failed
*/
New_file(Directory &dir, Directory::Path const &path)
:
_ep(dir._ep),
_handle(_init_handle(dir, path))
{ _handle.fs().ftruncate(&_handle, 0); }
~New_file()
{
_sync(_handle, _ep);
_handle.ds().close(&_handle);
}
Append_result append(char const *src, size_t size) {
return _append(_handle, _ep, src, size); }
};
class Genode::Watcher
{
private:

231
repos/os/include/pci/config.h
View File

@@ -44,16 +44,17 @@ struct Pci::Config : Genode::Mmio
struct Command : Register<0x4, 16>
{
struct Io_space_enable : Bitfield<0, 1> {};
struct Memory_space_enable : Bitfield<1, 1> {};
struct Bus_master_enable : Bitfield<2, 1> {};
struct Special_cycle_enable : Bitfield<3, 1> {};
struct Memory_write_invalidate : Bitfield<4, 1> {};
struct Vga_palette_snoop : Bitfield<5, 1> {};
struct Parity_error_response : Bitfield<6, 1> {};
struct Idsel : Bitfield<7, 1> {};
struct Serror_enable : Bitfield<8, 1> {};
struct Interrupt_enable : Bitfield<10, 1> {};
struct Io_space_enable : Bitfield<0, 1> {};
struct Memory_space_enable : Bitfield<1, 1> {};
struct Bus_master_enable : Bitfield<2, 1> {};
struct Special_cycle_enable : Bitfield<3, 1> {};
struct Memory_write_invalidate : Bitfield<4, 1> {};
struct Vga_palette_snoop : Bitfield<5, 1> {};
struct Parity_error_response : Bitfield<6, 1> {};
struct Idsel : Bitfield<7, 1> {};
struct Serror_enable : Bitfield<8, 1> {};
struct Fast_back_to_back_enable : Bitfield<9, 1> {};
struct Interrupt_enable : Bitfield<10, 1> {};
};
struct Status : Register<0x6, 16>
@@ -64,6 +65,7 @@ struct Pci::Config : Genode::Mmio
struct Class_code_rev_id : Register<0x8, 32>
{
struct Revision : Bitfield<0, 8> {};
struct Class_code : Bitfield<8, 24> {};
};
@@ -94,43 +96,79 @@ struct Pci::Config : Genode::Mmio
enum { SIZE_32BIT = 0, SIZE_64BIT = 2 };
};
struct Memory_prefetchable : Bitfield<3,1> {};
struct Io_base : Bitfield<2, 30> {};
struct Memory_base : Bitfield<7, 25> {};
};
struct Upper_bits : Register<0x4, 32> { };
Bar_32bit::access_t _conf { 0 };
Bar_32bit::access_t _conf_value { 0 };
Base_address(Genode::addr_t base) : Mmio(base)
template <typename REG>
typename REG::access_t _get_and_set(typename REG::access_t value)
{
Bar_32bit::access_t v = read<Bar_32bit>();
write<Bar_32bit>(0xffffffff);
_conf = read<Bar_32bit>();
write<Bar_32bit>(v);
write<REG>(0xffffffff);
typename REG::access_t ret = read<REG>();
write<REG>(value);
return ret;
}
bool valid() { return _conf != 0; }
Bar_32bit::access_t _conf()
{
/*
* Initialize _conf_value on demand only to prevent read-write
* operations on BARs of invalid devices at construction time.
*/
if (!_conf_value)
_conf_value = _get_and_set<Bar_32bit>(read<Bar_32bit>());
return _conf_value;
}
Base_address(Genode::addr_t base) : Mmio(base) { }
bool valid() { return _conf() != 0; }
bool memory() {
return !Bar_32bit::Memory_space_indicator::get(_conf); }
return !Bar_32bit::Memory_space_indicator::get(_conf()); }
bool bit64()
{
return Bar_32bit::Memory_type::get(_conf) ==
return Bar_32bit::Memory_type::get(_conf()) ==
Bar_32bit::Memory_type::SIZE_64BIT;
}
bool prefetchable() {
return Bar_32bit::Memory_prefetchable::get(_conf()); }
Genode::size_t size()
{
return 1 + (memory() ? ~Bar_32bit::Memory_base::masked(_conf)
: ~Bar_32bit::Io_base::masked(_conf));
return 1 + (memory() ? ~Bar_32bit::Memory_base::masked(_conf())
: ~Bar_32bit::Io_base::masked(_conf()));
}
Genode::uint64_t addr()
{
return (bit64() ? ((Genode::uint64_t)read<Upper_bits>()<<32) : 0UL)
| Bar_32bit::Memory_base::masked(read<Bar_32bit>());
if (memory())
return (bit64()
? ((Genode::uint64_t)read<Upper_bits>()<<32) : 0UL)
| Bar_32bit::Memory_base::masked(read<Bar_32bit>());
else
return Bar_32bit::Io_base::masked(read<Bar_32bit>());
}
void set(Genode::uint64_t v)
{
if (!valid() || v == addr())
return;
if (memory()) {
if (bit64())
_get_and_set<Upper_bits>((Upper_bits::access_t)(v >> 32));
_get_and_set<Bar_32bit>(Bar_32bit::Memory_base::masked(v & ~0U));
} else
_get_and_set<Bar_32bit>(Bar_32bit::Io_base::masked(v & ~0U));
}
};
@@ -184,14 +222,53 @@ struct Pci::Config : Genode::Mmio
struct Power_management_capability : Pci_capability
{
struct Capabilities : Register<0x2, 16> {};
struct Capabilities : Register<0x2, 16> {};
struct Control_status : Register<0x4, 16>
{
struct Pme_status : Bitfield<15,1> {};
struct Power_state : Bitfield<0, 2>
{
enum { D0, D1, D2, D3 };
};
struct No_soft_reset : Bitfield<3, 1> {};
struct Pme_status : Bitfield<15,1> {};
};
struct Data : Register<0x7, 8> {};
struct Data : Register<0x7, 8> {};
using Pci_capability::Pci_capability;
bool power_on(Delayer & delayer)
{
using Reg = Control_status::Power_state;
if (read<Reg>() == Reg::D0)
return false;
write<Reg>(Reg::D0);
/*
* PCI Express 4.3 - 5.3.1.4. D3 State
*
* "Unless Readiness Notifications mechanisms are used ..."
* "a minimum recovery time following a D3 hot → D0 transition of"
* "at least 10 ms ..."
*/
delayer.usleep(10'000);
return true;
}
void power_off()
{
using Reg = Control_status::Power_state;
if (read<Reg>() != Reg::D3) write<Reg>(Reg::D3);
}
bool soft_reset()
{
return !read<Control_status::No_soft_reset>();
}
};
@@ -235,6 +312,7 @@ struct Pci::Config : Genode::Mmio
{
struct Control : Register<0x2, 16>
{
struct Slots : Bitfield<0, 10> {};
struct Size : Bitfield<0, 11> {};
struct Function_mask : Bitfield<14, 1> {};
struct Enable : Bitfield<15, 1> {};
@@ -254,6 +332,8 @@ struct Pci::Config : Genode::Mmio
struct Table_entry : Genode::Mmio
{
enum { SIZE = 16 };
struct Address_64_lower : Register<0x0, 32> { };
struct Address_64_upper : Register<0x4, 32> { };
struct Data : Register<0x8, 32> { };
@@ -266,16 +346,40 @@ struct Pci::Config : Genode::Mmio
};
using Pci_capability::Pci_capability;
Genode::uint8_t bar() {
return (Genode::uint8_t) read<Table::Bar_index>(); }
Genode::size_t table_offset() {
return read<Table::Offset>() << 3; }
unsigned slots() { return read<Control::Slots>(); }
void enable()
{
Control::access_t ctrl = read<Control>();
Control::Function_mask::set(ctrl, 0);
Control::Enable::set(ctrl, 1);
write<Control>(ctrl);
}
};
struct Pci_express_capability : Pci_capability
{
struct Capabilities : Register<0x2, 16> {};
struct Device_capabilities : Register<0x4, 32> {};
struct Device_control : Register<0x8, 16> {};
struct Capabilities : Register<0x2, 16> {};
struct Device_status : Register<0xa, 16>
struct Device_capabilities : Register<0x4, 32>
{
struct Function_level_reset : Bitfield<28,1> {};
};
struct Device_control : Register<0x8, 16>
{
struct Function_level_reset : Bitfield<15,1> {};
};
struct Device_status : Register<0xa, 16>
{
struct Correctable_error : Bitfield<0, 1> {};
struct Non_fatal_error : Bitfield<1, 1> {};
@@ -353,6 +457,17 @@ struct Pci::Config : Genode::Mmio
write<Link_status::Lbm_status>(1);
write<Link_control::Lbm_irq_enable>(1);
}
void reset(Delayer & delayer)
{
if (!read<Device_capabilities::Function_level_reset>())
return;
write<Device_control::Function_level_reset>(1);
try {
wait_for(Attempts(100), Microseconds(10000), delayer,
Device_status::Transactions_pending::Equal(0));
} catch(Polling_timeout) { }
}
};
@@ -364,7 +479,7 @@ struct Pci::Config : Genode::Mmio
struct Pci_express_extended_capability : Genode::Mmio
{
struct Id : Register<0,16>
struct Id : Register<0x0, 16>
{
enum {
INVALID = 0x0,
@@ -377,7 +492,7 @@ struct Pci::Config : Genode::Mmio
};
};
struct Next_and_version : Register<16, 8>
struct Next_and_version : Register<0x2, 16>
{
struct Offset : Bitfield<4, 12> {};
};
@@ -451,19 +566,8 @@ struct Pci::Config : Genode::Mmio
case Pci_capability::Id::PCI_E:
pci_e_cap.construct(base()+off); break;
case Pci_capability::Id::AGP:
case Pci_capability::Id::VITAL_PRODUCT:
case Pci_capability::Id::SATA:
case Pci_capability::Id::VENDOR:
case Pci_capability::Id::ADVANCED:
case Pci_capability::Id::BRIDGE_SUB:
case Pci_capability::Id::DEBUG:
break;
default:
warning("Found unhandled capability ",
cap.read<Pci_capability::Id>(),
" at offset ", Hex(base()+off));
/* ignore unhandled capability */ ;
}
off = cap.read<Pci_capability::Pointer>();
}
@@ -480,15 +584,8 @@ struct Pci::Config : Genode::Mmio
case Pci_express_extended_capability::Id::ADVANCED_ERROR_REPORTING:
adv_err_cap.construct(base() + off); break;
case Pci_express_extended_capability::Id::VENDOR:
case Pci_express_extended_capability::Id::VIRTUAL_CHANNEL:
case Pci_express_extended_capability::Id::MULTI_ROOT_IO_VIRT:
break;
default:
warning("Found unhandled extended capability ",
cap.read<Pci_express_extended_capability::Id>(),
" at offset ", Hex(base()+off));
/* ignore unhandled extended capability */ ;
}
off = cap.read<Pci_express_extended_capability::Next_and_version::Offset>();
}
@@ -518,12 +615,35 @@ struct Pci::Config : Genode::Mmio
if (!reg0.valid())
continue;
if (reg0.memory()) {
memory(reg0.addr(), reg0.size(), i, reg0.prefetchable());
if (reg0.bit64()) i++;
memory(reg0.addr(), reg0.size());
} else
io(reg0.addr(), reg0.size());
io(reg0.addr(), reg0.size(), i);
}
};
void set_bar_address(unsigned idx, Genode::uint64_t addr)
{
if (idx > 5 || (idx > 1 && bridge()))
return;
Base_address bar { base() + BASE_ADDRESS_0 + idx*0x4 };
bar.set(addr);
}
void power_on(Delayer & delayer)
{
if (!power_cap.constructed() || !power_cap->power_on(delayer))
return;
if (power_cap->soft_reset() && pci_e_cap.constructed())
pci_e_cap->reset(delayer);
}
void power_off()
{
if (power_cap.constructed()) power_cap->power_off();
}
};
@@ -537,6 +657,9 @@ struct Pci::Config_type0 : Pci::Config
Base_address bar3 { base() + BASE_ADDRESS_0 + 0xc };
Base_address bar4 { base() + BASE_ADDRESS_0 + 0x10 };
Base_address bar5 { base() + BASE_ADDRESS_0 + 0x14 };
struct Subsystem_vendor : Register<0x2c, 16> { };
struct Subsystem_device : Register<0x2e, 16> { };
};

2
repos/os/include/pci/types.h
View File

@@ -15,6 +15,7 @@
#define __INCLUDE__PCI__TYPES_H__
#include <base/stdint.h>
#include <util/register.h>
#include <util/string.h>
namespace Pci {
@@ -41,6 +42,7 @@ namespace Pci {
using vendor_t = Genode::uint16_t;
using device_t = Genode::uint16_t;
using class_t = Genode::uint32_t;
using rev_t = Genode::uint8_t;
}

28
repos/os/include/platform_session/connection.h
View File

@@ -39,10 +39,11 @@ class Platform::Connection : public Genode::Connection<Session>,
friend class Device;
friend class Dma_buffer;
Env &_env;
Rom_session_client _rom {devices_rom()};
Constructible<Attached_dataspace> _ds {};
Constructible<Io_signal_handler<Connection>> _handler {};
Env & _env;
Rom_session_client _rom { devices_rom() };
Constructible<Attached_dataspace> _ds {};
Io_signal_handler<Connection> _handler { _env.ep(), *this,
&Connection::_handle_io };
void _try_attach()
{
@@ -60,19 +61,8 @@ class Platform::Connection : public Genode::Connection<Session>,
for (;;) {
/* repeatedly check for availability of device */
Capability<Device_interface> cap = fn();
if (cap.valid()) {
if (_handler.constructed()) {
sigh(Signal_context_capability());
_handler.destruct();
}
if (cap.valid())
return cap;
}
if (!_handler.constructed()) {
_handler.construct(_env.ep(), *this,
&Connection::_handle_io);
sigh(*_handler);
}
_env.ep().wait_and_dispatch_one_io_signal();
}
@@ -89,6 +79,12 @@ class Platform::Connection : public Genode::Connection<Session>,
_env(env)
{
_try_attach();
/*
* Initially register dummy handler, to be able to receive signals
* if _wait_for_device probes for a valid devices rom
*/
sigh(_handler);
}
void update()

8
repos/os/include/platform_session/device.h
View File

@@ -49,9 +49,9 @@ class Platform::Device : Interface, Noncopyable
return _cap.call<Device_interface::Rpc_irq>(index);
}
Io_mem_session_capability _io_mem(unsigned index, Range &range, Cache cache)
Io_mem_session_capability _io_mem(unsigned index, Range &range)
{
return _cap.call<Device_interface::Rpc_io_mem>(index, range, cache);
return _cap.call<Device_interface::Rpc_io_mem>(index, range);
}
Io_port_session_capability _io_port_range(unsigned index)
@@ -92,7 +92,7 @@ class Platform::Device::Mmio : Range, Attached_dataspace, public Genode::Mmio
Dataspace_capability _ds_cap(Device &device, unsigned id)
{
Io_mem_session_client io_mem(device._io_mem(id, *this, UNCACHED));
Io_mem_session_client io_mem(device._io_mem(id, *this));
return io_mem.dataspace();
}
@@ -117,6 +117,8 @@ class Platform::Device::Mmio : Range, Attached_dataspace, public Genode::Mmio
template <typename T>
T *local_addr() { return reinterpret_cast<T *>(_local_addr()); }
Dataspace_capability cap() { return Attached_dataspace::cap(); }
};

2
repos/os/include/platform_session/platform_session.h
View File

@@ -42,7 +42,7 @@ struct Platform::Device_interface : Interface
GENODE_RPC(Rpc_irq, Irq_session_capability, irq, unsigned);
GENODE_RPC(Rpc_io_mem, Io_mem_session_capability, io_mem,
unsigned, Range &, Cache);
unsigned, Range &);
GENODE_RPC(Rpc_io_port_range, Io_port_session_capability, io_port_range,
unsigned);

5
repos/os/include/report_rom/report_service.h
View File

@@ -121,10 +121,7 @@ struct Report::Root : Genode::Root_component<Session_component>
size_t const buffer_size =
Arg_string::find_arg(args, "buffer_size").aligned_size();
size_t const session_size =
max(sizeof(Session_component), 4096U) + buffer_size;
if (ram_quota < session_size) {
if (ram_quota < buffer_size) {
Genode::error("insufficient ram donation from ", label.string());
throw Insufficient_ram_quota();
}

18
repos/os/include/trace/policy.h
View File

@@ -21,11 +21,13 @@ namespace Genode {
struct Signal_context;
}
extern "C" size_t max_event_size ();
extern "C" size_t log_output (char *dst, char const *log_message, size_t len);
extern "C" size_t rpc_call (char *dst, char const *rpc_name, Genode::Msgbuf_base const &);
extern "C" size_t rpc_returned (char *dst, char const *rpc_name, Genode::Msgbuf_base const &);
extern "C" size_t rpc_dispatch (char *dst, char const *rpc_name);
extern "C" size_t rpc_reply (char *dst, char const *rpc_name);
extern "C" size_t signal_submit (char *dst, unsigned const);
extern "C" size_t signal_receive (char *dst, Genode::Signal_context const &, unsigned);
extern "C" size_t max_event_size ();
extern "C" size_t trace_eth_packet (char *dst, char const *name, bool out, char *data, size_t len);
extern "C" size_t checkpoint (char *dst, char const *name, unsigned long, void *, unsigned char);
extern "C" size_t log_output (char *dst, char const *log_message, size_t len);
extern "C" size_t rpc_call (char *dst, char const *rpc_name, Genode::Msgbuf_base const &);
extern "C" size_t rpc_returned (char *dst, char const *rpc_name, Genode::Msgbuf_base const &);
extern "C" size_t rpc_dispatch (char *dst, char const *rpc_name);
extern "C" size_t rpc_reply (char *dst, char const *rpc_name);
extern "C" size_t signal_submit (char *dst, unsigned const);
extern "C" size_t signal_receive (char *dst, Genode::Signal_context const &, unsigned);

11
repos/os/include/usb_session/usb_session.h
View File

@@ -219,17 +219,18 @@ struct Usb::Session : public Genode::Session
GENODE_RPC(Rpc_tx_cap, Capability<Tx>, _tx_cap);
GENODE_RPC_THROW(Rpc_config_descr, void, config_descriptor, GENODE_TYPE_LIST(Device_not_found),
Device_descriptor *, Config_descriptor *);
GENODE_RPC(Rpc_alt_settings, unsigned, alt_settings, unsigned);
GENODE_RPC_THROW(Rpc_alt_settings, unsigned, alt_settings, GENODE_TYPE_LIST(Device_not_found,
Interface_not_found), unsigned);
GENODE_RPC_THROW(Rpc_iface_descr, void, interface_descriptor, GENODE_TYPE_LIST(Device_not_found,
Interface_not_found), unsigned, unsigned, Interface_descriptor *);
GENODE_RPC_THROW(Rpc_iface_extra, bool, interface_extra, GENODE_TYPE_LIST(Device_not_found,
Interface_not_found), unsigned, unsigned, Interface_extra *);
GENODE_RPC_THROW(Rpc_ep_descr, void, endpoint_descriptor, GENODE_TYPE_LIST(Device_not_found,
Interface_not_found), unsigned, unsigned, unsigned, Endpoint_descriptor *);
GENODE_RPC_THROW(Rpc_claim_interface, void, claim_interface, GENODE_TYPE_LIST(Interface_not_found,
Interface_already_claimed), unsigned);
GENODE_RPC_THROW(Rpc_release_interface, void, release_interface, GENODE_TYPE_LIST(Interface_not_found),
unsigned);
GENODE_RPC_THROW(Rpc_claim_interface, void, claim_interface, GENODE_TYPE_LIST(Device_not_found,
Interface_not_found, Interface_already_claimed), unsigned);
GENODE_RPC_THROW(Rpc_release_interface, void, release_interface, GENODE_TYPE_LIST(Device_not_found,
Interface_not_found), unsigned);
GENODE_RPC_INTERFACE(Rpc_plugged, Rpc_sigh_state_change, Rpc_tx_cap, Rpc_config_descr,
Rpc_iface_descr, Rpc_iface_extra, Rpc_ep_descr, Rpc_alt_settings,
Rpc_claim_interface, Rpc_release_interface);

38
repos/os/include/util/geometry.h
View File

@@ -15,6 +15,7 @@
#define _INCLUDE__UTIL__GEOMETRY_H_
#include <util/misc_math.h>
#include <util/xml_node.h>
#include <base/stdint.h>
#include <base/output.h>
@@ -68,6 +69,17 @@ class Genode::Point
Genode::print(out, _x >= 0 ? "+" : "-", abs(_x),
_y >= 0 ? "+" : "-", abs(_y));
}
/**
* Construct point from XML node attributes
*
* The XML node is expected to feature the attributes 'xpos' and 'ypos'.
*/
static Point from_xml(Xml_node const &node)
{
return Point((CT)node.attribute_value("xpos", (CT)0),
(CT)node.attribute_value("ypos", (CT)0));
}
};
@@ -104,6 +116,18 @@ class Genode::Area
bool operator == (Area const &a) const { return a.w() == _w && a.h() == _h; }
void print(Output &out) const { Genode::print(out, _w, "x", _h); }
/**
* Construct area from XML node attributes
*
* The XML node is expected to feature the attributes 'width' and
* 'height'.
*/
static Area from_xml(Xml_node const &node)
{
return Area((DT)node.attribute_value("width", (DT)0),
(DT)node.attribute_value("height", (DT)0));
}
};
@@ -210,9 +234,21 @@ class Genode::Rect
*
* The output has the form 'width' x 'height' +/- 'p1.x' +/- 'p1.y'.
* For example, a rectange of size 15x16 as position (-13, 14) is
* printed as "15x16-13+14"
* printed as "15x16-13+14".
*/
void print(Output &out) const { Genode::print(out, area(), p1()); }
/**
* Construct rectangle from XML node attributes
*
* The XML node is expected to feature the attributes 'xpos', 'ypos'.
* 'width', and 'height'. If an attribute is absent, the corresponding
* value is set to 0.
*/
static Rect from_xml(Xml_node const &node)
{
return Rect(Point<CT>::from_xml(node), Area<DT>::from_xml(node));
}
};
#endif /* _INCLUDE__UTIL__GEOMETRY_H_ */

203
repos/os/include/virtio/pci_device.h
View File

@@ -14,10 +14,7 @@
#ifndef _INCLUDE__VIRTIO__PCI_DEVICE_H_
#define _INCLUDE__VIRTIO__PCI_DEVICE_H_
#include <os/attached_mmio.h>
#include <irq_session/client.h>
#include <legacy/x86/platform_device/client.h>
#include <legacy/x86/platform_session/connection.h>
#include <platform_session/device.h>
#include <virtio/queue.h>
namespace Virtio {
@@ -26,7 +23,7 @@ namespace Virtio {
class Device;
}
struct Virtio::Device_mmio : public Attached_mmio
struct Virtio::Device_mmio : public Genode::Mmio
{
struct DeviceFeatureSelect : Register<0x00, 32> { };
struct DeviceFeature : Register<0x04, 32> { };
@@ -54,10 +51,7 @@ struct Virtio::Device_mmio : public Attached_mmio
struct IrqReason : Register<0x0, 32> { };
Device_mmio(Genode::Env &env,
Genode::addr_t base,
Genode::size_t size)
: Attached_mmio(env, base, size, false) { }
using Mmio::Mmio;
};
class Virtio::Device
@@ -93,133 +87,112 @@ class Virtio::Device
enum {
VIRTIO_PCI_BASE_ID = 0x1040,
VIRTIO_MSI_NO_VECTOR = 0xffff
VIRTIO_MSI_NO_VECTOR = 0xffff,
MMIO_MAX = 6U
};
Genode::Env &_env;
Platform::Device_client &_device;
Genode::Irq_session_client _irq { _device.irq(0) };
uint32_t _notify_offset_multiplier = 0;
Genode::Constructible<Device_mmio> _cfg_common { };
Genode::Constructible<Device_mmio> _dev_config { };
Genode::Constructible<Device_mmio> _notify { };
Genode::Constructible<Device_mmio> _isr { };
Env & _env;
Platform::Connection & _plat;
Platform::Device _device { _plat };
Platform::Device::Irq _irq { _device, { 0 } };
Constructible<Platform::Device::Mmio> _mmio[MMIO_MAX] { };
void _configure()
Mmio _cfg_common { _bar_offset("common") };
Mmio _dev_config { _bar_offset("device") };
Mmio _notify { _bar_offset("notify") };
Mmio _isr { _bar_offset("irq_status") };
size_t _notify_offset_multiplier { 0 };
template <typename FN>
void with_virtio_range(String<16> type, FN const & fn)
{
typedef Platform::Device Pdev;
_plat.update();
_plat.with_xml([&] (Xml_node xml) {
xml.with_optional_sub_node("device", [&] (Xml_node xml) {
xml.with_optional_sub_node("pci-config",
[&] (Xml_node xml) {
xml.for_each_sub_node("virtio_range",
[&] (Xml_node xml) {
if (xml.attribute_value("type", String<16>()) ==
type)
fn(xml);
});
});
});
});
}
enum { PCI_STATUS = 0x6, PCI_CAPABILITIES = 0x34, };
addr_t _bar_offset(String<16> type)
{
unsigned idx = MMIO_MAX;
addr_t off = ~0UL;
with_virtio_range(type, [&] (Xml_node xml) {
idx = xml.attribute_value<unsigned>("index", MMIO_MAX);
off = xml.attribute_value("offset", ~0UL);
});
auto status = _device.config_read(PCI_STATUS, Pdev::ACCESS_16BIT);
if (!(status & 0x10)) {
error("PCI capabilities missing according to device status!");
throw Configuration_failed();
}
auto addr = _device.config_read(PCI_CAPABILITIES, Pdev::ACCESS_8BIT);
addr &= 0xFC;
while (addr) {
enum { ID_VNDR = 0x09 };
enum { CAP_ID = 0, CAP_LIST_NEXT = 1 };
auto const cap_id = _device.config_read(addr + CAP_ID, Pdev::ACCESS_8BIT);
auto const cap_next = _device.config_read(addr + CAP_LIST_NEXT, Pdev::ACCESS_8BIT);
if (cap_id == ID_VNDR) {
enum { CFG_TYPE = 0x3, BAR = 0x4, OFFSET = 0x8,
LENGTH = 0xC, NOTIFY_OFFSET_MULT = 0x10 };
enum { COMMON_CFG = 1, NOTIFY_CFG = 2, ISR_CFG = 3,
DEVICE_CFG = 4, PCI_CFG = 5 };
auto const cfg_type = _device.config_read(addr + CFG_TYPE, Pdev::ACCESS_8BIT);
auto const bar = _device.config_read(addr + BAR, Pdev::ACCESS_8BIT);
auto const off = _device.config_read(addr + OFFSET, Pdev::ACCESS_32BIT);
auto const len = _device.config_read(addr + LENGTH, Pdev::ACCESS_32BIT);
if (cfg_type == COMMON_CFG) {
auto const r = _device.resource(bar);
_cfg_common.construct(_env, r.base() + off, len);
} else if (cfg_type == DEVICE_CFG) {
auto const r = _device.resource(bar);
_dev_config.construct(_env, r.base() + off, len);
} else if (cfg_type == NOTIFY_CFG) {
_notify_offset_multiplier = _device.config_read(
addr + NOTIFY_OFFSET_MULT, Pdev::ACCESS_32BIT);
auto const r = _device.resource(bar);
_notify.construct(_env, r.base() + off, len);
} else if (cfg_type == ISR_CFG) {
auto const r = _device.resource(bar);
_isr.construct(_env, r.base() + off, len);
}
}
addr = cap_next;
}
if (!_cfg_common.constructed() || !_dev_config.constructed() ||
!_notify.constructed() || !_isr.constructed()) {
error("Required VirtIO PCI capabilities not found!");
if (idx >= MMIO_MAX || off == ~0UL)
throw Configuration_failed();
}
_cfg_common->write<Device_mmio::MsiXConfig>(VIRTIO_MSI_NO_VECTOR);
if (!_mmio[idx].constructed())
_mmio[idx].construct(_device,
Platform::Device::Mmio::Index{idx});
return _mmio[idx]->base() + off;
}
public:
Device(Genode::Env &env,
Platform::Device_client device)
: _env(env), _device(device)
Device(Genode::Env & env,
Platform::Connection & plat)
: _env(env), _plat(plat)
{
_configure();
with_virtio_range("notify", [&] (Xml_node xml) {
_notify_offset_multiplier = xml.attribute_value("factor", 0UL);
});
_cfg_common.write<Device_mmio::MsiXConfig>(VIRTIO_MSI_NO_VECTOR);
}
uint32_t vendor_id() { return _device.vendor_id(); }
uint32_t device_id() {
return _device.device_id() - VIRTIO_PCI_BASE_ID; }
uint8_t get_status() {
return _cfg_common->read<Device_mmio::DeviceStatus>(); }
return _cfg_common.read<Device_mmio::DeviceStatus>(); }
bool set_status(uint8_t status)
{
_cfg_common->write<Device_mmio::DeviceStatus>(status);
return _cfg_common->read<Device_mmio::DeviceStatus>() == status;
_cfg_common.write<Device_mmio::DeviceStatus>(status);
return _cfg_common.read<Device_mmio::DeviceStatus>() == status;
}
uint32_t get_features(uint32_t selection)
{
_cfg_common->write<Device_mmio::DeviceFeatureSelect>(selection);
return _cfg_common->read<Device_mmio::DeviceFeature>();
_cfg_common.write<Device_mmio::DeviceFeatureSelect>(selection);
return _cfg_common.read<Device_mmio::DeviceFeature>();
}
void set_features(uint32_t selection, uint32_t features)
{
_cfg_common->write<Device_mmio::DriverFeatureSelect>(selection);
_cfg_common->write<Device_mmio::DriverFeature>(features);
_cfg_common.write<Device_mmio::DriverFeatureSelect>(selection);
_cfg_common.write<Device_mmio::DriverFeature>(features);
}
uint8_t get_config_generation() {
return _cfg_common->read<Device_mmio::ConfigGeneration>(); }
return _cfg_common.read<Device_mmio::ConfigGeneration>(); }
uint16_t get_max_queue_size(uint16_t queue_index)
{
_cfg_common->write<Device_mmio::QueueSelect>(queue_index);
return _cfg_common->read<Device_mmio::QueueSize>();
_cfg_common.write<Device_mmio::QueueSelect>(queue_index);
return _cfg_common.read<Device_mmio::QueueSize>();
}
uint32_t read_config(uint8_t offset, Access_size size)
{
switch (size) {
case Device::ACCESS_8BIT:
return _dev_config->read<Device_mmio::Config_8>(offset);
return _dev_config.read<Device_mmio::Config_8>(offset);
case Device::ACCESS_16BIT:
return _dev_config->read<Device_mmio::Config_16>(offset >> 1);
return _dev_config.read<Device_mmio::Config_16>(offset >> 1);
case Device::ACCESS_32BIT:
return _dev_config->read<Device_mmio::Config_32>(offset >> 2);
return _dev_config.read<Device_mmio::Config_32>(offset >> 2);
}
return 0;
}
@@ -228,63 +201,63 @@ class Virtio::Device
{
switch (size) {
case Device::ACCESS_8BIT:
_dev_config->write<Device_mmio::Config_8>(value, offset);
_dev_config.write<Device_mmio::Config_8>(value, offset);
break;
case Device::ACCESS_16BIT:
_dev_config->write<Device_mmio::Config_16>(value, offset >> 1);
_dev_config.write<Device_mmio::Config_16>(value, offset >> 1);
break;
case Device::ACCESS_32BIT:
_dev_config->write<Device_mmio::Config_32>(value, offset >> 2);
_dev_config.write<Device_mmio::Config_32>(value, offset >> 2);
break;
}
}
bool configure_queue(uint16_t queue_index, Virtio::Queue_description desc)
{
_cfg_common->write<Device_mmio::QueueSelect>(queue_index);
_cfg_common.write<Device_mmio::QueueSelect>(queue_index);
if (_cfg_common->read<Device_mmio::QueueEnable>()) {
if (_cfg_common.read<Device_mmio::QueueEnable>()) {
warning("VirtIO queues can't be re-configured after being enabled!");
return false;
}
_cfg_common->write<Device_mmio::QueueMsixVector>(VIRTIO_MSI_NO_VECTOR);
if (_cfg_common->read<Device_mmio::QueueMsixVector>() != VIRTIO_MSI_NO_VECTOR) {
_cfg_common.write<Device_mmio::QueueMsixVector>(VIRTIO_MSI_NO_VECTOR);
if (_cfg_common.read<Device_mmio::QueueMsixVector>() != VIRTIO_MSI_NO_VECTOR) {
error("Failed to disable MSI-X for queue ", queue_index);
return false;
}
_cfg_common->write<Device_mmio::QueueSize>(desc.size);
_cfg_common.write<Device_mmio::QueueSize>(desc.size);
uint64_t addr = desc.desc;
_cfg_common->write<Device_mmio::QueueDescLow>((uint32_t)addr);
_cfg_common->write<Device_mmio::QueueDescHigh>((uint32_t)(addr >> 32));
_cfg_common.write<Device_mmio::QueueDescLow>((uint32_t)addr);
_cfg_common.write<Device_mmio::QueueDescHigh>((uint32_t)(addr >> 32));
addr = desc.avail;
_cfg_common->write<Device_mmio::QueueAvailLow>((uint32_t)addr);
_cfg_common->write<Device_mmio::QueueAvailHigh>((uint32_t)(addr >> 32));
_cfg_common.write<Device_mmio::QueueAvailLow>((uint32_t)addr);
_cfg_common.write<Device_mmio::QueueAvailHigh>((uint32_t)(addr >> 32));
addr = desc.used;
_cfg_common->write<Device_mmio::QueueUsedLow>((uint32_t)addr);
_cfg_common->write<Device_mmio::QueueUsedHigh>((uint32_t)(addr >> 32));
_cfg_common->write<Device_mmio::QueueEnable>(1);
return _cfg_common->read<Device_mmio::QueueEnable>() != 0;
_cfg_common.write<Device_mmio::QueueUsedLow>((uint32_t)addr);
_cfg_common.write<Device_mmio::QueueUsedHigh>((uint32_t)(addr >> 32));
_cfg_common.write<Device_mmio::QueueEnable>(1);
return _cfg_common.read<Device_mmio::QueueEnable>() != 0;
}
void notify_buffers_available(uint16_t queue_index) {
_cfg_common->write<Device_mmio::QueueSelect>(queue_index);
auto const offset = _cfg_common->read<Device_mmio::QueueNotifyOff>();
_cfg_common.write<Device_mmio::QueueSelect>(queue_index);
auto const offset = _cfg_common.read<Device_mmio::QueueNotifyOff>();
auto const addr = (offset * _notify_offset_multiplier >> 1) + 1;
_notify->local_addr<uint16_t>()[addr] = queue_index;
*(uint16_t*)(_notify.base() + addr) = queue_index;
}
uint32_t read_isr() {
return _isr->read<Device_mmio::IrqReason>(); }
return _isr.read<Device_mmio::IrqReason>(); }
void irq_sigh(Signal_context_capability cap) {
_irq.sigh(cap); }
void irq_ack() { _irq.ack_irq(); }
void irq_ack() { _irq.ack(); }
};
#endif /* _INCLUDE__VIRTIO__PCI_DEVICE_H_ */

25
repos/os/include/virtio/queue.h
View File

@@ -14,9 +14,8 @@
#ifndef _INCLUDE__VIRTIO__QUEUE_H_
#define _INCLUDE__VIRTIO__QUEUE_H_
#include <base/attached_dataspace.h>
#include <platform_session/dma_buffer.h>
#include <base/stdint.h>
#include <dataspace/client.h>
#include <util/misc_math.h>
namespace Virtio
@@ -138,7 +137,7 @@ class Virtio::Queue
Buffer_pool(Buffer_pool const &) = delete;
Buffer_pool &operator = (Buffer_pool const &) = delete;
Attached_dataspace _ds;
Platform::Dma_buffer _ds;
uint16_t const _buffer_count;
uint16_t const _buffer_size;
addr_t const _phys_base;
@@ -156,16 +155,14 @@ class Virtio::Queue
};
Buffer_pool(Platform::Connection & plat,
Region_map & rm,
uint16_t const buffer_count,
uint16_t const buffer_size)
:
_ds(rm, plat.alloc_dma_buffer(buffer_count *
align_natural(buffer_size),
CACHED)),
_ds(plat, buffer_count * align_natural(buffer_size),
CACHED),
_buffer_count(buffer_count),
_buffer_size(buffer_size),
_phys_base(_dma_addr(plat, _ds.cap())) {}
_phys_base(_ds.dma_addr()) {}
const Buffer get(uint16_t descriptor_idx) const
{
@@ -211,7 +208,7 @@ class Virtio::Queue
uint16_t const _queue_size;
Attached_dataspace _ds;
Platform::Dma_buffer _ds;
Buffer_pool _buffers;
Avail volatile * const _avail;
Used volatile * const _used;
@@ -565,18 +562,16 @@ class Virtio::Queue
print(output, _queue_size);
}
Queue(Region_map & rm,
Platform::Connection & plat,
Queue(Platform::Connection & plat,
uint16_t queue_size,
uint16_t buffer_size)
: _queue_size(queue_size),
_ds(rm, plat.alloc_dma_buffer(_ds_size(queue_size), UNCACHED)),
_buffers(plat, rm, queue_size, _check_buffer_size(buffer_size)),
_ds(plat, _ds_size(queue_size), UNCACHED),
_buffers(plat, queue_size, _check_buffer_size(buffer_size)),
_avail(_init_avail(_ds.local_addr<uint8_t>(), queue_size)),
_used(_init_used(_ds.local_addr<uint8_t>(), queue_size)),
_descriptors(_ds.local_addr<uint8_t>(), queue_size),
_description(_init_description(queue_size,
_dma_addr(plat, _ds.cap())))
_description(_init_description(queue_size, _ds.dma_addr()))
{
_fill_descriptor_table();
}

2
repos/os/recipes/api/audio_in_session/hash
View File

@@ -1 +1 @@
2022-01-18 248c7dfdbd29bf3c4b117cd0d70973a00757718d
2022-08-16 2ef529898c2fcf111c474f468de106a48bc4ba1e

2
repos/os/recipes/api/audio_out_session/hash
View File

@@ -1 +1 @@
2022-01-18 7e8b0238ef01fa0e844a513d490f26e3a0d8df02
2022-09-20 367b89903fd6b510ad8c7aa429cd367361981e6b

2
repos/os/recipes/api/block_session/hash
View File

@@ -1 +1 @@
2022-04-27 e6220d7163d0212598b00d45f0755d56aa43575e
2022-08-16 79d59088effa972bdd9b0220a154f48c16f1f780

2
repos/os/recipes/api/file_system_session/hash
View File

@@ -1 +1 @@
2022-02-14 620c7c83e3285d08858d8a4e69894bf9d35d0dbd
2022-09-20 077fa78b70134123b3b5005eb7bd7d0dcc4d1d6c

2
repos/os/recipes/api/genode_c_api/hash
View File

@@ -1 +1 @@
2022-04-27 0a8bcdae6027d192c36195042c1e8a5c2a48d5a9
2022-09-20 a4488c152b5ff9071cdcd7d135f62efcaf53b6ac

2
repos/os/recipes/api/gpu_session/hash
View File

@@ -1 +1 @@
2022-02-14 e95cd305d2fde59948e1e1fb8ed4251f3d83653c
2022-08-16 7b3ada81f3f160f6ae0032f6d4e40a10793cbae9

2
repos/os/recipes/api/net/hash
View File

@@ -1 +1 @@
2022-05-24 b04cf4a45f75349c92b73773cff265f637f801fc
2022-10-13 e9d4eef65b30010955d36fdee8f346c44cae541f

2
repos/os/recipes/api/nic_session/hash
View File

@@ -1 +1 @@
2022-05-24 eebf0a6e36d56ecbbf4fb603bb969ea8a45e4c26
2022-08-30 e1de77019b959b55c45ac857cdc136796e59774c

4
repos/os/recipes/api/os/content.mk
View File

@@ -1,5 +1,5 @@
INCLUDE_SUB_DIRS := os util packet_stream_rx packet_stream_tx spec/x86_64/os \
spec/arm/os spec/x86_32/os spec/arm_64/os
INCLUDE_SUB_DIRS := os util packet_stream_rx packet_stream_tx pci \
spec/x86_64/os spec/arm/os spec/x86_32/os spec/arm_64/os
MIRRORED_FROM_REP_DIR := $(addprefix include/,$(INCLUDE_SUB_DIRS))

2
repos/os/recipes/api/os/hash
View File

@@ -1 +1 @@
2022-04-12 17ca6587c67923f25e0f7e004af991c213302828
2022-10-11 d2302f0d0fdb9b8f616461c5295d83ea0da48e36

2
repos/os/recipes/api/platform_session/hash
View File

@@ -1 +1 @@
2022-05-24 23561753de5a37868ae04d46d4f643f5deeddb06
2022-10-11 adcb54072a44c3bcd981b58ede26ab822fdbf328

2
repos/os/recipes/api/trace/hash
View File

@@ -1 +1 @@
2022-05-24 2e443e4291b530a90c91f2943b5bde7f1fa567fc
2022-08-16 88eda27c18c227cd2216501caaef1a45a6392f07

2
repos/os/recipes/api/uplink_session/hash
View File

@@ -1 +1 @@
2022-05-24 996ab9d103b7cafd48f0813bb474da789cefc895
2022-08-30 9b11856ee11375c27b0b647e67bf8797c25369e8

2
repos/os/recipes/api/usb_session/hash
View File

@@ -1 +1 @@
2022-04-12 b3aee50282918f3b8e28218ecce8fb94fc71802c
2022-08-30 63fbe4de4dc753a71f69abcc1079393284e11fee

2
repos/os/recipes/api/virtio/hash
View File

@@ -1 +1 @@
2022-02-14 ba487bac0db1f052bf39aeaf594e0fce0db77dde
2022-10-11 f07f668b4d84d0343a706aa296c2026a6a97736e

2
repos/os/recipes/pkg/black_hole/hash
View File

@@ -1 +1 @@
2022-05-24 9aca5262f6a13bd8bbf4f27f1e014abfc829035f
2022-10-11 aea241129878eba26a3b9d29ad03a0131b10a5f3

2
repos/os/recipes/pkg/chroot/hash
View File

@@ -1 +1 @@
2022-05-24 747ad1f302337ba23c934d737fdc5a28685f90af
2022-10-11 bb7ae9efbe99d15190ff498c32a8f0dd0597d8de

2
repos/os/recipes/pkg/clipboard/hash
View File

@@ -1 +1 @@
2022-05-24 7007b602b9f4761b57e5e9223b1f57f865914474
2022-10-11 3c99bdb273857e2988a2054330d59acdd5de7378

2
repos/os/recipes/pkg/cpu_balancer/hash
View File

@@ -1 +1 @@
2022-05-24 5aad956d8b98c81addea84313c88ac2299dd8d02
2022-10-11 723ea5fbde749abfe6ac49b8a8b8d9eb76a9f77c

2
repos/os/recipes/pkg/cpu_balancer_config/hash
View File

@@ -1 +1 @@
2022-05-24 140b0e88708dcd9acb0521024e1e7f0b0aa810d0
2022-10-11 daa7ac3ab6dfa7e8cc98b455b3aba13c0ecfbe0a

2
repos/os/recipes/pkg/drivers_interactive-linux/hash
View File

@@ -1 +1 @@
2022-05-24 35671e6b5193e75ed65695aaa82baccae3b89149
2022-10-11 d31991d2b17ff1cf82d6ef022ccbdf2f51560769

2
repos/os/recipes/pkg/drivers_interactive-pbxa9/hash
View File

@@ -1 +1 @@
2022-05-24 466f7e78b04661510969b8b1bd2977e528a2cc51
2022-10-11 29a8a43cc84a40b4e6f131d9b76532367fbadf2f

3
repos/os/recipes/pkg/drivers_interactive-pc/archives
View File

@@ -5,5 +5,8 @@ _/src/pc_usb_host_drv
_/src/usb_hid_drv
_/src/vesa_drv
_/src/report_rom
_/src/rom_filter
_/src/event_filter
_/src/pci_decode
_/raw/drivers_interactive-pc
_/raw/pc-devices

2
repos/os/recipes/pkg/drivers_interactive-pc/hash
View File

@@ -1 +1 @@
2022-05-30 a0cc3bb28e490b98435e434b40b8b7d177b65c09
2022-10-11 4cf6004aa40c9e7bf02b5e0d9c8776753ea7cd7d

1
repos/os/recipes/pkg/drivers_interactive-virt_qemu/hash
View File

@@ -1 +0,0 @@
2022-05-24 882323bc8a17974e55dcf61ddb6c39028d4481ef

0
repos/os/recipes/pkg/drivers_interactive-virt_qemu/README → repos/os/recipes/pkg/drivers_interactive-virt_qemu_arm_v7a/README
View File

2
repos/os/recipes/pkg/drivers_interactive-virt_qemu/archives → repos/os/recipes/pkg/drivers_interactive-virt_qemu_arm_v7a/archives
View File

@@ -3,4 +3,4 @@ _/src/virtio_input_drv
_/src/platform_drv
_/src/event_filter
_/src/virtdev_rom
_/raw/drivers_interactive-virt_qemu
_/raw/drivers_interactive-virt_qemu_arm

1
repos/os/recipes/pkg/drivers_interactive-virt_qemu_arm_v7a/hash Normal file
View File

@@ -0,0 +1 @@
2022-10-11 62e92d13e82a37bd498799e6fa5d06cb8ef930ed

3
repos/os/recipes/pkg/drivers_interactive-virt_qemu_arm_v8a/README Normal file
View File

@@ -0,0 +1,3 @@
Device drivers needed to run interactive
scenarios on the Virt platform as emulated by Qemu

6
repos/os/recipes/pkg/drivers_interactive-virt_qemu_arm_v8a/archives Normal file
View File

@@ -0,0 +1,6 @@
_/src/virtio_fb_drv
_/src/virtio_input_drv
_/src/platform_drv
_/src/event_filter
_/src/virtdev_rom
_/raw/drivers_interactive-virt_qemu_arm

1
repos/os/recipes/pkg/drivers_interactive-virt_qemu_arm_v8a/hash Normal file
View File

@@ -0,0 +1 @@
2022-10-11 62e92d13e82a37bd498799e6fa5d06cb8ef930ed

2
repos/os/recipes/pkg/drivers_nic-linux/hash
View File

@@ -1 +1 @@
2022-05-24 8761c075cfc4e7e6e2444426ba359351efdd6f75
2022-10-11 baf260966e8c88ecc60415016fa9144ccb51db04

2
repos/os/recipes/pkg/drivers_nic-pbxa9/hash
View File

@@ -1 +1 @@
2022-05-24 13b0147828f8273244d69b1d23ad4f9601f17d18
2022-10-11 c6c8e9464cffc6a7e467d534a2cc25b729ebb738

1
repos/os/recipes/pkg/drivers_nic-virt_qemu/hash
View File

@@ -1 +0,0 @@
2022-05-24 4ed87f751b0a53cba22cb8132bb18ac8d935228b

0
repos/os/recipes/pkg/drivers_nic-virt_qemu/README → repos/os/recipes/pkg/drivers_nic-virt_qemu_arm_v7a/README
View File

2
repos/os/recipes/pkg/drivers_nic-virt_qemu/archives → repos/os/recipes/pkg/drivers_nic-virt_qemu_arm_v7a/archives
View File

@@ -1,4 +1,4 @@
_/raw/drivers_nic-virt_qemu
_/raw/drivers_nic-virt_qemu_arm
_/src/virtdev_rom
_/src/platform_drv
_/src/virtio_nic_drv

1
repos/os/recipes/pkg/drivers_nic-virt_qemu_arm_v7a/hash Normal file
View File

@@ -0,0 +1 @@
2022-10-11 d86aa4f30cf763d57ff20df4d088d97dff64548a

3
repos/os/recipes/pkg/drivers_nic-virt_qemu_arm_v8a/README Normal file
View File

@@ -0,0 +1,3 @@
Device drivers needed for scenarios
using one network interface

4
repos/os/recipes/pkg/drivers_nic-virt_qemu_arm_v8a/archives Normal file
View File

@@ -0,0 +1,4 @@
_/raw/drivers_nic-virt_qemu_arm
_/src/virtdev_rom
_/src/platform_drv
_/src/virtio_nic_drv

1
repos/os/recipes/pkg/drivers_nic-virt_qemu_arm_v8a/hash Normal file
View File

@@ -0,0 +1 @@
2022-10-11 d86aa4f30cf763d57ff20df4d088d97dff64548a

2
repos/os/recipes/pkg/fs_report/hash
View File

@@ -1 +1 @@
2022-05-24 2a1ec14f9c409dc0a26f8397cb0314f4268b0191
2022-10-11 700987d4bfce4e0f84375e90519a2558fe7054cd

2
repos/os/recipes/pkg/fs_rom/hash
View File

@@ -1 +1 @@
2022-05-24 abaf3d0ab7b0620d23c9aa20de619f3059032302
2022-10-11 32048032d17845fac915a51d8010a658b2d135c7

2
repos/os/recipes/pkg/mixer/hash
View File

@@ -1 +1 @@
2022-05-24 1d3e4f5921f6aa3202d0f24d8e5bbe5f00aec39d
2022-10-11 d5c13f8da5e61dba061ffebb2bc8645c110acd48

2
repos/os/recipes/pkg/nic_router-nat/hash
View File

@@ -1 +1 @@
2022-05-24 b82ff7c385589028426c560dcd215e88f6a1dc32
2022-10-13 91cf27f8392f854540f919bb89bffa416d230903

2
repos/os/recipes/pkg/nit_focus/hash
View File

@@ -1 +1 @@
2022-05-24 b38e298c4ed31ae2d768fa2ca443b5cf7de6ccfd
2022-10-11 4246fb270937a5e17ac6e251c957d0a7623dc670

2
repos/os/recipes/pkg/part_block/README Normal file
View File

@@ -0,0 +1,2 @@
Runtime for deploying the part_block component from the depot

1
repos/os/recipes/pkg/part_block/archives Executable file
View File

@@ -0,0 +1 @@
_/src/part_block

1
repos/os/recipes/pkg/part_block/hash Normal file
View File

@@ -0,0 +1 @@
2022-10-11 a4317ecd68cfaff34eec8c70d90bed48ec92c5cd

24
repos/os/recipes/pkg/part_block/runtime Executable file
View File

@@ -0,0 +1,24 @@
<runtime ram="8M" caps="100" binary="part_block">
<requires> <block/> <report/> </requires>
<provides> <block/> </provides>
<config>
<report partitions="yes"/>
<policy label="1" partition="1" writeable="yes"/>
<policy label="2" partition="2" writeable="yes"/>
<policy label="3" partition="3" writeable="yes"/>
<policy label="4" partition="4" writeable="yes"/>
<policy label="5" partition="5" writeable="yes"/>
<policy label="6" partition="6" writeable="yes"/>
<policy label="7" partition="7" writeable="yes"/>
<policy label="8" partition="8" writeable="yes"/>
<policy label="9" partition="9" writeable="yes"/>
</config>
<content>
<rom label="ld.lib.so"/>
<rom label="part_block"/>
</content>
</runtime>

2
repos/os/recipes/pkg/recall_fs/hash
View File

@@ -1 +1 @@
2022-05-24 8082e0ae34aca5eb35270dbd5a81876e6175b2ab
2022-10-11 dfc16bacfcb776ca8232cb1072afdcde9232f206

2
repos/os/recipes/pkg/report_rom/hash
View File

@@ -1 +1 @@
2022-05-24 3c3466652c1f17c20d971de7baa1d390e53a6dd5
2022-10-11 5a392e0400332aa46243f87f3434143e5a1a3e31

2
repos/os/recipes/pkg/rom_filter/hash
View File

@@ -1 +1 @@
2022-05-24 ea344a29334a0ddaaabe1d09fcba08aec0356e07
2022-10-11 51081176262ccb5ed8d517138ea3da1440bf7d3b

2
repos/os/recipes/pkg/rom_reporter/hash
View File

@@ -1 +1 @@
2022-05-24 6427bbe49b53e5ee09af7780938a8202b6e10c49
2022-10-11 b4f86a6bdf4073a55edb47d0a68e02066d47b78f

2
repos/os/recipes/pkg/test-black_hole/hash
View File

@@ -1 +1 @@
2022-05-24 1e7dbf3094ab393d7e5ad2234eea13662e7967b9
2022-10-11 7ce1c14c911cc0a419045151504ff157f5d26b7d

2
repos/os/recipes/pkg/test-capture/hash
View File

@@ -1 +1 @@
2022-05-24 c882f21370f2d4786f49a7a8ed54b69add592051
2022-10-11 7d3945b9a8d6bfb01dea1e97b1256b566aaf0ef7

2
repos/os/recipes/pkg/test-clipboard/hash
View File

@@ -1 +1 @@
2022-05-24 5ed950f62ac45790f1a203274c53973d969fbc3a
2022-10-11 eee75418fdbaf99c4a426a611e8216daf6fda7ea

2
repos/os/recipes/pkg/test-dynamic_config/hash
View File

@@ -1 +1 @@
2022-05-24 41e91cc9e70f61afdc3751bb2fbc255562376f4a
2022-10-11 30054f67f3b1ddfe6688f4b8da7cacdf55b136a1

2
repos/os/recipes/pkg/test-dynamic_config_loader/hash
View File

@@ -1 +1 @@
2022-05-24 bf27e7dea892769078cb1e1f4aadb38b613a641d
2022-10-11 87ef09d7d73ceb319c965567f8ed356a10eb1b3e

2
repos/os/recipes/pkg/test-fault_detection/hash
View File

@@ -1 +1 @@
2022-05-24 e866a5508179797dc70e6ddfb690a37814514f88
2022-10-11 cf2cb45d256b1882fc55ec8b647beab0e3c71401

2
repos/os/recipes/pkg/test-fs_packet/hash
View File

@@ -1 +1 @@
2022-05-24 2fa8b8039815d81b80d72e0d04afc91b9a56d41f
2022-10-11 c8153a4ad7a626febc1a470f3873f94f56c0f4c4

2
repos/os/recipes/pkg/test-fs_report/hash
View File

@@ -1 +1 @@
2022-05-24 b6d52193cb7d1566d97edcd752c0e5884cc903c8
2022-10-11 7a4ed19dd9e3950d915e96dcd90d0e634d5055f6

2
repos/os/recipes/pkg/test-fs_rom_update/hash
View File

@@ -1 +1 @@
2022-05-24 f21b7216d3d58b969bd518fb44b00b9fc7f6ee42
2022-10-11 6e44b98ab57f654631bb885d2a59c4d2f7c62d94

2
repos/os/recipes/pkg/test-fs_rom_update_fs/hash
View File

@@ -1 +1 @@
2022-05-24 76a1d4a9c74fbabd3989644c1c0e6449c6a6cd8a
2022-10-11 3903f54c0be779846ac6d74cd022fef3281d1064

2
repos/os/recipes/pkg/test-fs_rom_update_ram/hash
View File

@@ -1 +1 @@
2022-05-24 86f6d13794611f414dd2d187db0e50978e419e38
2022-10-11 161dc221eda72a95b546a335bb1ab31ac8f42ad2

2
repos/os/recipes/pkg/test-init/hash
View File

@@ -1 +1 @@
2022-05-24 aca9ff105cbe1363c9b36a0d6051c8acf95fdbe0
2022-10-11 06b93fe3cddb656a2f0284262d364e8d2412c4a4

1
repos/os/recipes/pkg/test-init/runtime
View File

@@ -5,6 +5,7 @@
<events>
<timeout meaning="failed" sec="330" />
<log meaning="succeeded">child "test-init" exited with exit value 0</log>
<log meaning="failed">list model not empty at destruction time</log>
</events>
<content>

2
repos/os/recipes/pkg/test-init_loop/hash
View File

@@ -1 +1 @@
2022-05-24 b08b8290df42648e81a50900e47f36e358c8688a
2022-10-11 10de16fc39c7346d7827219b3a54469e1e9737f3

2
repos/os/recipes/pkg/test-lx_block/hash
View File

@@ -1 +1 @@
2022-05-24 0976a9790be7a938540eadb3ef6ce73a37f796b2
2022-10-11 90538e539505e44d772ec54b1a88444403978b5e

2
repos/os/recipes/pkg/test-nic_loopback/hash
View File

@@ -1 +1 @@
2022-05-24 c95057700a0425018a4283233b36bd463eda1491
2022-10-11 63b3c5d8b3b997daa201bb7de6066390d2201acc

Some files were not shown because too many files have changed in this diff Show More