rte_virtio_net.h

Go to the documentation of this file.

/*-
 *   BSD LICENSE
 *
 *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *     * Neither the name of Intel Corporation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _VIRTIO_NET_H_
#define _VIRTIO_NET_H_

#include <stdint.h>
#include <linux/vhost.h>
#include <linux/virtio_ring.h>
#include <linux/virtio_net.h>
#include <sys/eventfd.h>
#include <sys/socket.h>
#include <linux/if.h>

#include <rte_memory.h>
#include <rte_mempool.h>
#include <rte_ether.h>

struct rte_mbuf;

#define VHOST_MEMORY_MAX_NREGIONS 8

/* Used to indicate that the device is running on a data core */
#define VIRTIO_DEV_RUNNING 1

/* Backend value set by guest. */
#define VIRTIO_DEV_STOPPED -1


/* Enum for virtqueue management. */
enum {VIRTIO_RXQ, VIRTIO_TXQ, VIRTIO_QNUM};

#define BUF_VECTOR_MAX 256

struct buf_vector {
        uint64_t buf_addr;
        uint32_t buf_len;
        uint32_t desc_idx;
};

struct vhost_virtqueue {
        struct vring_desc       *desc;                  
        struct vring_avail      *avail;                 
        struct vring_used       *used;                  
        uint32_t                size;                   
        uint32_t                backend;                
        uint16_t                vhost_hlen;             
        volatile uint16_t       last_used_idx;          
        volatile uint16_t       last_used_idx_res;      
#define VIRTIO_INVALID_EVENTFD          (-1)
#define VIRTIO_UNINITIALIZED_EVENTFD    (-2)
        int                     callfd;                 
        int                     kickfd;                 
        int                     enabled;
        uint64_t                log_guest_addr;         
        uint64_t                reserved[15];           
        struct buf_vector       buf_vec[BUF_VECTOR_MAX];        
} __rte_cache_aligned;

/* Old kernels have no such macro defined */
#ifndef VIRTIO_NET_F_GUEST_ANNOUNCE
 #define VIRTIO_NET_F_GUEST_ANNOUNCE 21
#endif


/*
 * Make an extra wrapper for VIRTIO_NET_F_MQ and
 * VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX as they are
 * introduced since kernel v3.8. This makes our
 * code buildable for older kernel.
 */
#ifdef VIRTIO_NET_F_MQ
 #define VHOST_MAX_QUEUE_PAIRS  VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX
 #define VHOST_SUPPORTS_MQ      (1ULL << VIRTIO_NET_F_MQ)
#else
 #define VHOST_MAX_QUEUE_PAIRS  1
 #define VHOST_SUPPORTS_MQ      0
#endif

/*
 * Define virtio 1.0 for older kernels
 */
#ifndef VIRTIO_F_VERSION_1
 #define VIRTIO_F_VERSION_1 32
#endif

struct virtio_net {
        struct virtio_memory    *mem;           
        uint64_t                features;       
        uint64_t                protocol_features;      
        uint64_t                device_fh;      
        uint32_t                flags;          
#define IF_NAME_SZ (PATH_MAX > IFNAMSIZ ? PATH_MAX : IFNAMSIZ)
        char                    ifname[IF_NAME_SZ];     
        uint32_t                virt_qp_nb;     
        void                    *priv;          
        uint64_t                log_size;       
        uint64_t                log_base;       
        struct ether_addr       mac;            
        rte_atomic16_t          broadcast_rarp; 
        uint64_t                reserved[61];   
        struct vhost_virtqueue  *virtqueue[VHOST_MAX_QUEUE_PAIRS * 2];  
} __rte_cache_aligned;

struct virtio_memory_regions {
        uint64_t        guest_phys_address;     
        uint64_t        guest_phys_address_end; 
        uint64_t        memory_size;            
        uint64_t        userspace_address;      
        uint64_t        address_offset;         
};


struct virtio_memory {
        uint64_t        base_address;   
        uint64_t        mapped_address; 
        uint64_t        mapped_size;    
        uint32_t        nregions;       
        struct virtio_memory_regions      regions[0]; 
};

struct virtio_net_device_ops {
        int (*new_device)(struct virtio_net *); 
        void (*destroy_device)(volatile struct virtio_net *);   
        int (*vring_state_changed)(struct virtio_net *dev, uint16_t queue_id, int enable);      
};

static inline uint16_t __attribute__((always_inline))
rte_vring_available_entries(struct virtio_net *dev, uint16_t queue_id)
{
        struct vhost_virtqueue *vq = dev->virtqueue[queue_id];

        if (!vq->enabled)
                return 0;

        return *(volatile uint16_t *)&vq->avail->idx - vq->last_used_idx_res;
}

static inline uint64_t __attribute__((always_inline))
gpa_to_vva(struct virtio_net *dev, uint64_t guest_pa)
{
        struct virtio_memory_regions *region;
        uint32_t regionidx;
        uint64_t vhost_va = 0;

        for (regionidx = 0; regionidx < dev->mem->nregions; regionidx++) {
                region = &dev->mem->regions[regionidx];
                if ((guest_pa >= region->guest_phys_address) &&
                        (guest_pa <= region->guest_phys_address_end)) {
                        vhost_va = region->address_offset + guest_pa;
                        break;
                }
        }
        return vhost_va;
}


int rte_vhost_feature_disable(uint64_t feature_mask);

int rte_vhost_feature_enable(uint64_t feature_mask);

/* Returns currently supported vhost features */
uint64_t rte_vhost_feature_get(void);

int rte_vhost_enable_guest_notification(struct virtio_net *dev, uint16_t queue_id, int enable);

/* Register vhost driver. dev_name could be different for multiple instance support. */
int rte_vhost_driver_register(const char *dev_name);

/* Unregister vhost driver. This is only meaningful to vhost user. */
int rte_vhost_driver_unregister(const char *dev_name);

/* Register callbacks. */
int rte_vhost_driver_callback_register(struct virtio_net_device_ops const * const);
/* Start vhost driver session blocking loop. */
int rte_vhost_driver_session_start(void);

uint16_t rte_vhost_enqueue_burst(struct virtio_net *dev, uint16_t queue_id,
        struct rte_mbuf **pkts, uint16_t count);

uint16_t rte_vhost_dequeue_burst(struct virtio_net *dev, uint16_t queue_id,
        struct rte_mempool *mbuf_pool, struct rte_mbuf **pkts, uint16_t count);

#endif /* _VIRTIO_NET_H_ */