virtio_ring.c File Reference

#include <linux/virtio.h>
#include <linux/virtio_ring.h>
#include <linux/virtio_config.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/hrtimer.h>

Go to the source code of this file.

Data Structures
struct	vring_virtqueue

Macros
#define	virtio_mb(vq)   mb()
#define	virtio_rmb(vq)   rmb()
#define	virtio_wmb(vq)   wmb()
#define	BAD_RING(_vq, fmt, args...)
#define	START_USE(vq)
#define	END_USE(vq)
#define	to_vvq(_vq)   container_of(_vq, struct vring_virtqueue, vq)

Functions
int	virtqueue_get_queue_index (struct virtqueue *_vq)
	EXPORT_SYMBOL_GPL (virtqueue_get_queue_index)
int	virtqueue_add_buf (struct virtqueue *_vq, struct scatterlist sg[], unsigned int out, unsigned int in, void *data, gfp_t gfp)
	EXPORT_SYMBOL_GPL (virtqueue_add_buf)
bool	virtqueue_kick_prepare (struct virtqueue *_vq)
	EXPORT_SYMBOL_GPL (virtqueue_kick_prepare)
void	virtqueue_notify (struct virtqueue *_vq)
	EXPORT_SYMBOL_GPL (virtqueue_notify)
void	virtqueue_kick (struct virtqueue *vq)
	EXPORT_SYMBOL_GPL (virtqueue_kick)
void *	virtqueue_get_buf (struct virtqueue *_vq, unsigned int *len)
	EXPORT_SYMBOL_GPL (virtqueue_get_buf)
void	virtqueue_disable_cb (struct virtqueue *_vq)
	EXPORT_SYMBOL_GPL (virtqueue_disable_cb)
bool	virtqueue_enable_cb (struct virtqueue *_vq)
	EXPORT_SYMBOL_GPL (virtqueue_enable_cb)
bool	virtqueue_enable_cb_delayed (struct virtqueue *_vq)
	EXPORT_SYMBOL_GPL (virtqueue_enable_cb_delayed)
void *	virtqueue_detach_unused_buf (struct virtqueue *_vq)
	EXPORT_SYMBOL_GPL (virtqueue_detach_unused_buf)
irqreturn_t	vring_interrupt (int irq, void *_vq)
	EXPORT_SYMBOL_GPL (vring_interrupt)
struct virtqueue *	vring_new_virtqueue (unsigned int index, unsigned int num, unsigned int vring_align, struct virtio_device *vdev, bool weak_barriers, void *pages, void(*notify)(struct virtqueue *), void(*callback)(struct virtqueue *), const char *name)
	EXPORT_SYMBOL_GPL (vring_new_virtqueue)
void	vring_del_virtqueue (struct virtqueue *vq)
	EXPORT_SYMBOL_GPL (vring_del_virtqueue)
void	vring_transport_features (struct virtio_device *vdev)
	EXPORT_SYMBOL_GPL (vring_transport_features)
unsigned int	virtqueue_get_vring_size (struct virtqueue *_vq)
	EXPORT_SYMBOL_GPL (virtqueue_get_vring_size)
	MODULE_LICENSE ("GPL")

Macro Definition Documentation

#define BAD_RING	(		_vq,
			fmt,
			args...
	)

Value:

do {                            \
        dev_err(&_vq->vq.vdev->dev,         \
            "%s:"fmt, (_vq)->vq.name, ##args);  \
        (_vq)->broken = true;               \
    } while (0)

Definition at line 67 of file virtio_ring.c.

#define END_USE

(

vq

)

Definition at line 74 of file virtio_ring.c.

#define START_USE

(

vq

)

Definition at line 73 of file virtio_ring.c.

#define to_vvq

(

_vq

)

container_of(_vq, struct vring_virtqueue, vq)

Definition at line 125 of file virtio_ring.c.

#define virtio_mb

(

vq

)

mb()

Definition at line 43 of file virtio_ring.c.

#define virtio_rmb

(

vq

)

rmb()

Definition at line 44 of file virtio_ring.c.

#define virtio_wmb

(

vq

)

wmb()

Definition at line 45 of file virtio_ring.c.

Function Documentation

EXPORT_SYMBOL_GPL

(

virtqueue_get_queue_index

)

EXPORT_SYMBOL_GPL

(

virtqueue_add_buf

)

EXPORT_SYMBOL_GPL

(

virtqueue_kick_prepare

)

EXPORT_SYMBOL_GPL

(

virtqueue_notify

)

EXPORT_SYMBOL_GPL

(

virtqueue_kick

)

EXPORT_SYMBOL_GPL

(

virtqueue_get_buf

)

EXPORT_SYMBOL_GPL

(

virtqueue_disable_cb

)

EXPORT_SYMBOL_GPL

(

virtqueue_enable_cb

)

EXPORT_SYMBOL_GPL

(

virtqueue_enable_cb_delayed

)

EXPORT_SYMBOL_GPL

(

virtqueue_detach_unused_buf

)

EXPORT_SYMBOL_GPL

(

vring_interrupt

)

EXPORT_SYMBOL_GPL

(

vring_new_virtqueue

)

EXPORT_SYMBOL_GPL

(

vring_del_virtqueue

)

EXPORT_SYMBOL_GPL

(

vring_transport_features

)

EXPORT_SYMBOL_GPL

(

virtqueue_get_vring_size

)

MODULE_LICENSE

(

"GPL"

)

int virtqueue_add_buf	(	struct virtqueue *	_vq,
		struct scatterlist	sg[],
		unsigned int	out,
		unsigned int	in,
		void *	data,
		gfp_t	gfp
	)

virtqueue_add_buf - expose buffer to other end : the struct virtqueue we're talking about. : the description of the buffer(s). : the number of sg readable by other side : the number of sg which are writable (after readable ones) : the token identifying the buffer. : how to do memory allocations (if necessary).

Caller must ensure we don't call this with other virtqueue operations at the same time (except where noted).

Returns remaining capacity of queue or a negative error (ie. ENOSPC). Note that it only really makes sense to treat all positive return values as "available": indirect buffers mean that we can put an entire sg[] array inside a single queue entry.

Definition at line 201 of file virtio_ring.c.

void* virtqueue_detach_unused_buf

(

struct virtqueue *

_vq

)

virtqueue_detach_unused_buf - detach first unused buffer : the struct virtqueue we're talking about.

Returns NULL or the "data" token handed to virtqueue_add_buf(). This is not valid on an active queue; it is useful only for device shutdown.

Definition at line 583 of file virtio_ring.c.

void virtqueue_disable_cb

(

struct virtqueue *

_vq

)

virtqueue_disable_cb - disable callbacks : the struct virtqueue we're talking about.

Note that this is not necessarily synchronous, hence unreliable and only useful as an optimization.

Unlike other operations, this need not be serialized.

Definition at line 492 of file virtio_ring.c.

bool virtqueue_enable_cb

(

struct virtqueue *

_vq

)

virtqueue_enable_cb - restart callbacks after disable_cb. : the struct virtqueue we're talking about.

This re-enables callbacks; it returns "false" if there are pending buffers in the queue, to detect a possible race between the driver checking for more work, and enabling callbacks.

Caller must ensure we don't call this with other virtqueue operations at the same time (except where noted).

Definition at line 511 of file virtio_ring.c.

bool virtqueue_enable_cb_delayed

(

struct virtqueue *

_vq

)

virtqueue_enable_cb_delayed - restart callbacks after disable_cb. : the struct virtqueue we're talking about.

This re-enables callbacks but hints to the other side to delay interrupts until most of the available buffers have been processed; it returns "false" if there are many pending buffers in the queue, to detect a possible race between the driver checking for more work, and enabling callbacks.

Caller must ensure we don't call this with other virtqueue operations at the same time (except where noted).

Definition at line 548 of file virtio_ring.c.

void* virtqueue_get_buf	(	struct virtqueue *	_vq,
		unsigned int *	len
	)

virtqueue_get_buf - get the next used buffer : the struct virtqueue we're talking about. : the length written into the buffer

If the driver wrote data into the buffer, will be set to the amount written. This means you don't need to clear the buffer beforehand to ensure there's no data leakage in the case of short writes.

Caller must ensure we don't call this with other virtqueue operations at the same time (except where noted).

Returns NULL if there are no used buffers, or the "data" token handed to virtqueue_add_buf().

Definition at line 426 of file virtio_ring.c.

int virtqueue_get_queue_index

(

struct virtqueue *

_vq

)

Definition at line 177 of file virtio_ring.c.

unsigned int virtqueue_get_vring_size

(

struct virtqueue *

_vq

)

virtqueue_get_vring_size - return the size of the virtqueue's vring : the struct virtqueue containing the vring of interest.

Returns the size of the vring. This is mainly used for boasting to userspace. Unlike other operations, this need not be serialized.

Definition at line 721 of file virtio_ring.c.

void virtqueue_kick

(

struct virtqueue *

vq

)

virtqueue_kick - update after add_buf : the struct virtqueue

After one or more virtqueue_add_buf calls, invoke this to kick the other side.

Caller must ensure we don't call this with other virtqueue operations at the same time (except where noted).

Definition at line 373 of file virtio_ring.c.

bool virtqueue_kick_prepare

(

struct virtqueue *

_vq

)

virtqueue_kick_prepare - first half of split virtqueue_kick call. : the struct virtqueue

Instead of virtqueue_kick(), you can do: if (virtqueue_kick_prepare(vq)) virtqueue_notify(vq);

This is sometimes useful because the virtqueue_kick_prepare() needs to be serialized, but the actual virtqueue_notify() call does not.

Definition at line 314 of file virtio_ring.c.

void virtqueue_notify

(

struct virtqueue *

_vq

)

virtqueue_notify - second half of split virtqueue_kick call. : the struct virtqueue

This does not need to be serialized.

Definition at line 354 of file virtio_ring.c.

void vring_del_virtqueue

(

struct virtqueue *

vq

)

Definition at line 688 of file virtio_ring.c.

irqreturn_t vring_interrupt	(	int	irq,
		void *	_vq
	)

Definition at line 609 of file virtio_ring.c.

struct virtqueue* vring_new_virtqueue ( unsigned int  index, unsigned int  num, unsigned int  vring_align, struct virtio_device *  vdev, bool  weak_barriers, void *  pages, void(*)(struct virtqueue *)  notify, void(*)(struct virtqueue *)  callback, const char *  name  )

read

Definition at line 629 of file virtio_ring.c.

void vring_transport_features

(

struct virtio_device *

vdev

)

Definition at line 696 of file virtio_ring.c.