include/linux/virtio.h

Source file repositories/reference/linux-study-clean/include/linux/virtio.h

File Facts

System
Linux kernel
Corpus path
include/linux/virtio.h
Extension
.h
Size
12278 bytes
Lines
352
Domain
Core OS
Bucket
Core Kernel Interface
Inferred role
Core OS: operation-table or driver-model contract
Status
pattern implementation candidate

Why This File Exists

Core operating-system implementation surface: boot, tasks, memory, VFS, syscall-facing interfaces, synchronization, credentials, and isolation.

Dependency Surface

Detected Declarations

Annotated Snippet

struct device_driver driver;
	const struct virtio_device_id *id_table;
	const unsigned int *feature_table;
	unsigned int feature_table_size;
	const unsigned int *feature_table_legacy;
	unsigned int feature_table_size_legacy;
	int (*validate)(struct virtio_device *dev);
	int (*probe)(struct virtio_device *dev);
	void (*scan)(struct virtio_device *dev);
	void (*remove)(struct virtio_device *dev);
	void (*config_changed)(struct virtio_device *dev);
	int (*freeze)(struct virtio_device *dev);
	int (*restore)(struct virtio_device *dev);
	int (*reset_prepare)(struct virtio_device *dev);
	int (*reset_done)(struct virtio_device *dev);
	void (*shutdown)(struct virtio_device *dev);
};

#define drv_to_virtio(__drv)	container_of_const(__drv, struct virtio_driver, driver)

/* use a macro to avoid include chaining to get THIS_MODULE */
#define register_virtio_driver(drv) \
	__register_virtio_driver(drv, THIS_MODULE)
int __register_virtio_driver(struct virtio_driver *drv, struct module *owner);
void unregister_virtio_driver(struct virtio_driver *drv);

/* module_virtio_driver() - Helper macro for drivers that don't do
 * anything special in module init/exit.  This eliminates a lot of
 * boilerplate.  Each module may only use this macro once, and
 * calling it replaces module_init() and module_exit()
 */
#define module_virtio_driver(__virtio_driver) \
	module_driver(__virtio_driver, register_virtio_driver, \
			unregister_virtio_driver)


void *virtqueue_map_alloc_coherent(struct virtio_device *vdev,
				   union virtio_map mapping_token,
				   size_t size, dma_addr_t *dma_handle,
				   gfp_t gfp);

void virtqueue_map_free_coherent(struct virtio_device *vdev,
				 union virtio_map mapping_token,
				 size_t size, void *vaddr,
				 dma_addr_t dma_handle);

dma_addr_t virtqueue_map_page_attrs(const struct virtqueue *_vq,
				    struct page *page,
				    unsigned long offset,
				    size_t size,
				    enum dma_data_direction dir,
				    unsigned long attrs);

void virtqueue_unmap_page_attrs(const struct virtqueue *_vq,
				dma_addr_t dma_handle,
				size_t size, enum dma_data_direction dir,
				unsigned long attrs);

dma_addr_t virtqueue_map_single_attrs(const struct virtqueue *_vq, void *ptr, size_t size,
					  enum dma_data_direction dir, unsigned long attrs);
void virtqueue_unmap_single_attrs(const struct virtqueue *_vq, dma_addr_t addr,
				      size_t size, enum dma_data_direction dir,
				      unsigned long attrs);
int virtqueue_map_mapping_error(const struct virtqueue *_vq, dma_addr_t addr);

bool virtqueue_map_need_sync(const struct virtqueue *_vq, dma_addr_t addr);
void virtqueue_map_sync_single_range_for_cpu(const struct virtqueue *_vq, dma_addr_t addr,
					     unsigned long offset, size_t size,
					     enum dma_data_direction dir);
void virtqueue_map_sync_single_range_for_device(const struct virtqueue *_vq, dma_addr_t addr,
						unsigned long offset, size_t size,
						enum dma_data_direction dir);

#ifdef CONFIG_VIRTIO_DEBUG
void virtio_debug_device_init(struct virtio_device *dev);
void virtio_debug_device_exit(struct virtio_device *dev);
void virtio_debug_device_filter_features(struct virtio_device *dev);
void virtio_debug_init(void);
void virtio_debug_exit(void);
#else
static inline void virtio_debug_device_init(struct virtio_device *dev)
{
}

static inline void virtio_debug_device_exit(struct virtio_device *dev)
{
}

static inline void virtio_debug_device_filter_features(struct virtio_device *dev)
{

Annotation

Implementation Notes