This graph shows which files directly or indirectly include this file:

Functions
struct virtqueue *	vring_new_virtqueue_split (unsigned int index, unsigned int num, unsigned int vring_align, VirtIODevice vdev, void pages, void(notify)(struct virtqueue ), void *control)

struct virtqueue *	vring_new_virtqueue_packed (unsigned int index, unsigned int num, unsigned int vring_align, VirtIODevice vdev, void pages, void(notify)(struct virtqueue ), void *control)

unsigned int	vring_control_block_size (u16 qsize, bool packed)

unsigned int	vring_control_block_size_packed (u16 qsize)

unsigned long	vring_size_packed (unsigned int num, unsigned long align)

Function Documentation

◆ vring_control_block_size()

unsigned int vring_control_block_size	(	u16	qsize,
		bool	packed
	)

Definition at line 474 of file VirtIORing.c.

{
    unsigned int res;
    if (packed) {
        return vring_control_block_size_packed(qsize);
    }
    res = sizeof(struct virtqueue_split);
    res += sizeof(void *) * qsize;
    return res;
}

Referenced by vio_legacy_query_vq_alloc(), and vio_modern_query_vq_alloc().

◆ vring_control_block_size_packed()

unsigned int vring_control_block_size_packed ( u16 qsize )

Definition at line 157 of file VirtIORing-Packed.c.

{
    return sizeof(struct virtqueue_packed) + sizeof(struct vring_desc_state_packed) * qsize;
}

Referenced by vring_control_block_size().

◆ vring_new_virtqueue_packed()

struct virtqueue * vring_new_virtqueue_packed	(	unsigned int	index,
		unsigned int	num,
		unsigned int	vring_align,
		VirtIODevice *	vdev,
		void *	pages,
		void()(struct virtqueue )	notify,
		void *	control
	)

Definition at line 598 of file VirtIORing-Packed.c.

{
    struct virtqueue_packed *vq = packedvq(control);
    unsigned int i;
 
    vq->vq.vdev = vdev;
    vq->vq.notification_cb = notify;
    vq->vq.index = index;
 
    vq->vq.avail_va = (u8 *)pages + num * sizeof(struct vring_packed_desc);
    vq->vq.used_va = (u8 *)vq->vq.avail_va + sizeof(struct vring_packed_desc_event);
 
    /* initialize the ring */
    vq->packed.vring.num = num;
    vq->packed.vring.desc = pages;
    vq->packed.vring.driver = vq->vq.avail_va;
    vq->packed.vring.device = vq->vq.used_va;
 
    vq->num_free = num;
    vq->free_head = 0;
    vq->num_added = 0;
    vq->packed.avail_wrap_counter = 1;
    vq->packed.used_wrap_counter = 1;
    vq->last_used_idx = 0;
    vq->avail_used_flags = 1 << VRING_PACKED_DESC_F_AVAIL;
    vq->packed.next_avail_idx = 0;
    vq->packed.event_flags_shadow = 0;
    vq->packed.desc_state = vq->desc_states;
 
    RtlZeroMemory(vq->packed.desc_state, num * sizeof(*vq->packed.desc_state));
    for (i = 0; i < num - 1; i++) {
        vq->packed.desc_state[i].next = i + 1;
    }
 
    vq->vq.add_buf = virtqueue_add_buf_packed;
    vq->vq.detach_unused_buf = virtqueue_detach_unused_buf_packed;
    vq->vq.disable_cb = virtqueue_disable_cb_packed;
    vq->vq.enable_cb = virtqueue_enable_cb_packed;
    vq->vq.enable_cb_delayed = virtqueue_enable_cb_delayed_packed;
    vq->vq.get_buf = virtqueue_get_buf_packed;
    vq->vq.has_buf = virtqueue_has_buf_packed;
    vq->vq.is_interrupt_enabled = virtqueue_is_interrupt_enabled_packed;
    vq->vq.kick_always = virtqueue_kick_always_packed;
    vq->vq.kick_prepare = virtqueue_kick_prepare_packed;
    vq->vq.shutdown = virtqueue_shutdown_packed;
    return &vq->vq;
}

Referenced by vio_modern_setup_vq(), and virtqueue_shutdown_packed().

◆ vring_new_virtqueue_split()

struct virtqueue * vring_new_virtqueue_split	(	unsigned int	index,
		unsigned int	num,
		unsigned int	vring_align,
		VirtIODevice *	vdev,
		void *	pages,
		void()(struct virtqueue )	notify,
		void *	control
	)

Definition at line 486 of file VirtIORing.c.

{
    struct virtqueue_split *vq = splitvq(control);
    u16 i;
 
    if (DESC_INDEX(num, num) != 0) {
        DPrintf(0, "Virtqueue length %u is not a power of 2\n", num);
        return NULL;
    }
 
    RtlZeroMemory(vq, sizeof(*vq) + num * sizeof(void *));
 
    vring_init(&vq->vring, num, pages, vring_align);
    vq->vq.vdev = vdev;
    vq->vq.notification_cb = notify;
    vq->vq.index = index;
 
    /* Build a linked list of unused descriptors */
    vq->num_unused = num;
    vq->first_unused = 0;
    for (i = 0; i < num - 1; i++) {
        vq->vring.desc[i].flags = VIRTQ_DESC_F_NEXT;
        vq->vring.desc[i].next = i + 1;
    }
    vq->vq.avail_va = vq->vring.avail;
    vq->vq.used_va = vq->vring.used;
    vq->vq.add_buf = virtqueue_add_buf_split;
    vq->vq.detach_unused_buf = virtqueue_detach_unused_buf_split;
    vq->vq.disable_cb = virtqueue_disable_cb_split;
    vq->vq.enable_cb = virtqueue_enable_cb_split;
    vq->vq.enable_cb_delayed = virtqueue_enable_cb_delayed_split;
    vq->vq.get_buf = virtqueue_get_buf_split;
    vq->vq.has_buf = virtqueue_has_buf_split;
    vq->vq.is_interrupt_enabled = virtqueue_is_interrupt_enabled_split;
    vq->vq.kick_always = virtqueue_kick_always_split;
    vq->vq.kick_prepare = virtqueue_kick_prepare_split;
    vq->vq.shutdown = virtqueue_shutdown_split;
    return &vq->vq;
}

Referenced by vio_legacy_setup_vq(), vio_modern_setup_vq(), and virtqueue_shutdown_split().

◆ vring_size_packed()

unsigned long vring_size_packed	(	unsigned int	num,
		unsigned long	align
	)

Definition at line 162 of file VirtIORing-Packed.c.

{
    /* array of descriptors */
    unsigned long res = num * sizeof(struct vring_packed_desc);
    /* driver and device event */
    res += 2 * sizeof(struct vring_packed_desc_event);
    return res;
}