src/vnet/devices/virtio/vhost_user.h

   1 /*
   2  * Copyright (c) 2015 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15 #ifndef __VIRTIO_VHOST_USER_H__
  16 #define __VIRTIO_VHOST_USER_H__
  17 /* vhost-user data structures */
  18
  19 #define VHOST_MEMORY_MAX_NREGIONS       8
  20 #define VHOST_USER_MSG_HDR_SZ           12
  21 #define VHOST_VRING_MAX_SIZE            32768
  22 #define VHOST_VRING_MAX_N               16      //8TX + 8RX
  23 #define VHOST_VRING_IDX_RX(qid)         (2*qid)
  24 #define VHOST_VRING_IDX_TX(qid)         (2*qid + 1)
  25
  26 #define VHOST_USER_VRING_NOFD_MASK      0x100
  27 #define VIRTQ_DESC_F_NEXT               1
  28 #define VIRTQ_DESC_F_INDIRECT           4
  29 #define VHOST_USER_REPLY_MASK       (0x1 << 2)
  30
  31 #define VHOST_USER_PROTOCOL_F_MQ   0
  32 #define VHOST_USER_PROTOCOL_F_LOG_SHMFD 1
  33 #define VHOST_VRING_F_LOG 0
  34
  35 #define VHOST_USER_F_PROTOCOL_FEATURES  30
  36 #define VHOST_USER_PROTOCOL_FEATURES   ((1ULL << VHOST_USER_PROTOCOL_F_MQ) |    \
  37                                         (1ULL << VHOST_USER_PROTOCOL_F_LOG_SHMFD))
  38
  39 /* If multiqueue is provided by host, then we suppport it. */
  40 #define VIRTIO_NET_CTRL_MQ   4
  41 #define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET        0
  42 #define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MIN        1
  43 #define VIRTIO_NET_CTRL_MQ_VQ_PAIRS_MAX        0x8000
  44
  45 #define VRING_USED_F_NO_NOTIFY  1
  46 #define VRING_AVAIL_F_NO_INTERRUPT 1
  47
  48 #define vu_log_debug(dev, f, ...) \
  49 {                                                                             \
  50   vlib_log(VLIB_LOG_LEVEL_DEBUG, vhost_user_main.log_default, "%U: " f,       \
  51            format_vnet_hw_if_index_name, vnet_get_main(),                     \
  52            dev->hw_if_index, ##__VA_ARGS__);                                  \
  53 };
  54
  55 #define vu_log_warn(dev, f, ...) \
  56 {                                                                             \
  57   vlib_log(VLIB_LOG_LEVEL_WARNING, vhost_user_main.log_default, "%U: " f,     \
  58            format_vnet_hw_if_index_name, vnet_get_main(),                     \
  59            dev->hw_if_index, ##__VA_ARGS__);                                  \
  60 };
  61 #define vu_log_err(dev, f, ...) \
  62 {                                                                             \
  63   vlib_log(VLIB_LOG_LEVEL_ERR, vhost_user_main.log_default, "%U: " f,         \
  64            format_vnet_hw_if_index_name, vnet_get_main(),                     \
  65            dev->hw_if_index, ##__VA_ARGS__);                                  \
  66 };
  67
  68 #define UNIX_GET_FD(unixfd_idx) ({ \
  69     typeof(unixfd_idx) __unixfd_idx = (unixfd_idx); \
  70     (__unixfd_idx != ~0) ? \
  71         pool_elt_at_index (file_main.file_pool, \
  72                            __unixfd_idx)->file_descriptor : -1; })
  73
  74 #define foreach_virtio_trace_flags \
  75   _ (SIMPLE_CHAINED, 0, "Simple descriptor chaining") \
  76   _ (SINGLE_DESC,  1, "Single descriptor packet") \
  77   _ (INDIRECT, 2, "Indirect descriptor") \
  78   _ (MAP_ERROR, 4, "Memory mapping error")
  79
  80 typedef enum
  81 {
  82 #define _(n,i,s) VIRTIO_TRACE_F_##n,
  83   foreach_virtio_trace_flags
  84 #undef _
  85 } virtio_trace_flag_t;
  86
  87 #define foreach_virtio_net_feature      \
  88  _ (VIRTIO_NET_F_MRG_RXBUF, 15)         \
  89  _ (VIRTIO_NET_F_CTRL_VQ, 17)           \
  90  _ (VIRTIO_NET_F_GUEST_ANNOUNCE, 21)    \
  91  _ (VIRTIO_NET_F_MQ, 22)                \
  92  _ (VHOST_F_LOG_ALL, 26)                \
  93  _ (VIRTIO_F_ANY_LAYOUT, 27)            \
  94  _ (VIRTIO_F_INDIRECT_DESC, 28)         \
  95  _ (VHOST_USER_F_PROTOCOL_FEATURES, 30) \
  96  _ (VIRTIO_F_VERSION_1, 32)
  97
  98 typedef enum
  99 {
 100 #define _(f,n) FEAT_##f = (n),
 101   foreach_virtio_net_feature
 102 #undef _
 103 } virtio_net_feature_t;
 104
 105 int vhost_user_create_if (vnet_main_t * vnm, vlib_main_t * vm,
 106                           const char *sock_filename, u8 is_server,
 107                           u32 * sw_if_index, u64 feature_mask,
 108                           u8 renumber, u32 custom_dev_instance, u8 * hwaddr);
 109 int vhost_user_modify_if (vnet_main_t * vnm, vlib_main_t * vm,
 110                           const char *sock_filename, u8 is_server,
 111                           u32 sw_if_index, u64 feature_mask,
 112                           u8 renumber, u32 custom_dev_instance);
 113 int vhost_user_delete_if (vnet_main_t * vnm, vlib_main_t * vm,
 114                           u32 sw_if_index);
 115
 116 /* *INDENT-OFF* */
 117 typedef struct vhost_user_memory_region
 118 {
 119   u64 guest_phys_addr;
 120   u64 memory_size;
 121   u64 userspace_addr;
 122   u64 mmap_offset;
 123 } __attribute ((packed)) vhost_user_memory_region_t;
 124
 125 typedef struct vhost_user_memory
 126 {
 127   u32 nregions;
 128   u32 padding;
 129   vhost_user_memory_region_t regions[VHOST_MEMORY_MAX_NREGIONS];
 130 } __attribute ((packed)) vhost_user_memory_t;
 131
 132 typedef struct
 133 {
 134   u32 index, num;
 135 } __attribute ((packed)) vhost_vring_state_t;
 136
 137 typedef struct
 138 {
 139   u32 index, flags;
 140   u64 desc_user_addr, used_user_addr, avail_user_addr, log_guest_addr;
 141 } __attribute ((packed)) vhost_vring_addr_t;
 142
 143 typedef struct vhost_user_log
 144 {
 145   u64 size;
 146   u64 offset;
 147 } __attribute ((packed)) vhost_user_log_t;
 148
 149 typedef enum vhost_user_req
 150 {
 151   VHOST_USER_NONE = 0,
 152   VHOST_USER_GET_FEATURES = 1,
 153   VHOST_USER_SET_FEATURES = 2,
 154   VHOST_USER_SET_OWNER = 3,
 155   VHOST_USER_RESET_OWNER = 4,
 156   VHOST_USER_SET_MEM_TABLE = 5,
 157   VHOST_USER_SET_LOG_BASE = 6,
 158   VHOST_USER_SET_LOG_FD = 7,
 159   VHOST_USER_SET_VRING_NUM = 8,
 160   VHOST_USER_SET_VRING_ADDR = 9,
 161   VHOST_USER_SET_VRING_BASE = 10,
 162   VHOST_USER_GET_VRING_BASE = 11,
 163   VHOST_USER_SET_VRING_KICK = 12,
 164   VHOST_USER_SET_VRING_CALL = 13,
 165   VHOST_USER_SET_VRING_ERR = 14,
 166   VHOST_USER_GET_PROTOCOL_FEATURES = 15,
 167   VHOST_USER_SET_PROTOCOL_FEATURES = 16,
 168   VHOST_USER_GET_QUEUE_NUM = 17,
 169   VHOST_USER_SET_VRING_ENABLE = 18,
 170   VHOST_USER_MAX
 171 } vhost_user_req_t;
 172
 173 // vring_desc I/O buffer descriptor
 174 typedef struct
 175 {
 176   uint64_t addr;  // packet data buffer address
 177   uint32_t len;   // packet data buffer size
 178   uint16_t flags; // (see below)
 179   uint16_t next;  // optional index next descriptor in chain
 180 } __attribute ((packed)) vring_desc_t;
 181
 182 typedef struct
 183 {
 184   uint16_t flags;
 185   volatile uint16_t idx;
 186   uint16_t ring[VHOST_VRING_MAX_SIZE];
 187 } __attribute ((packed)) vring_avail_t;
 188
 189 typedef struct
 190 {
 191   uint16_t flags;
 192   uint16_t idx;
 193   struct /* vring_used_elem */
 194     {
 195       uint32_t id;
 196       uint32_t len;
 197     } ring[VHOST_VRING_MAX_SIZE];
 198 } __attribute ((packed)) vring_used_t;
 199
 200 typedef struct
 201 {
 202   u8 flags;
 203   u8 gso_type;
 204   u16 hdr_len;
 205   u16 gso_size;
 206   u16 csum_start;
 207   u16 csum_offset;
 208 } __attribute ((packed)) virtio_net_hdr_t;
 209
 210 typedef struct  {
 211   virtio_net_hdr_t hdr;
 212   u16 num_buffers;
 213 } __attribute ((packed)) virtio_net_hdr_mrg_rxbuf_t;
 214
 215 typedef struct vhost_user_msg {
 216   vhost_user_req_t request;
 217   u32 flags;
 218   u32 size;
 219   union
 220     {
 221       u64 u64;
 222       vhost_vring_state_t state;
 223       vhost_vring_addr_t addr;
 224       vhost_user_memory_t memory;
 225       vhost_user_log_t log;
 226     };
 227 } __attribute ((packed)) vhost_user_msg_t;
 228 /* *INDENT-ON* */
 229
 230 typedef struct
 231 {
 232   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
 233   u16 qsz_mask;
 234   u16 last_avail_idx;
 235   u16 last_used_idx;
 236   u16 n_since_last_int;
 237   vring_desc_t *desc;
 238   vring_avail_t *avail;
 239   vring_used_t *used;
 240   f64 int_deadline;
 241   u8 started;
 242   u8 enabled;
 243   u8 log_used;
 244   //Put non-runtime in a different cache line
 245     CLIB_CACHE_LINE_ALIGN_MARK (cacheline1);
 246   int errfd;
 247   u32 callfd_idx;
 248   u32 kickfd_idx;
 249   u64 log_guest_addr;
 250
 251   /* The rx queue policy (interrupt/adaptive/polling) for this queue */
 252   u32 mode;
 253 } vhost_user_vring_t;
 254
 255 #define VHOST_USER_EVENT_START_TIMER 1
 256 #define VHOST_USER_EVENT_STOP_TIMER  2
 257
 258 typedef struct
 259 {
 260   CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
 261   u32 is_ready;
 262   u32 admin_up;
 263   u32 unix_server_index;
 264   u32 clib_file_index;
 265   char sock_filename[256];
 266   int sock_errno;
 267   uword if_index;
 268   u32 hw_if_index, sw_if_index;
 269
 270   //Feature negotiation
 271   u64 features;
 272   u64 feature_mask;
 273   u64 protocol_features;
 274
 275   //Memory region information
 276   u32 nregions;
 277   vhost_user_memory_region_t regions[VHOST_MEMORY_MAX_NREGIONS];
 278   void *region_mmap_addr[VHOST_MEMORY_MAX_NREGIONS];
 279   u64 region_guest_addr_lo[VHOST_MEMORY_MAX_NREGIONS];
 280   u64 region_guest_addr_hi[VHOST_MEMORY_MAX_NREGIONS];
 281   u32 region_mmap_fd[VHOST_MEMORY_MAX_NREGIONS];
 282
 283   //Virtual rings
 284   vhost_user_vring_t vrings[VHOST_VRING_MAX_N];
 285   volatile u32 *vring_locks[VHOST_VRING_MAX_N];
 286
 287   int virtio_net_hdr_sz;
 288   int is_any_layout;
 289
 290   void *log_base_addr;
 291   u64 log_size;
 292
 293   /* Whether to use spinlock or per_cpu_tx_qid assignment */
 294   u8 use_tx_spinlock;
 295   u16 *per_cpu_tx_qid;
 296
 297   /* Vector of active rx queues for this interface */
 298   u16 *rx_queues;
 299 } vhost_user_intf_t;
 300
 301 typedef struct
 302 {
 303   uword dst;
 304   uword src;
 305   u32 len;
 306 } vhost_copy_t;
 307
 308 typedef struct
 309 {
 310   u16 qid; /** The interface queue index (Not the virtio vring idx) */
 311   u16 device_index; /** The device index */
 312   u32 virtio_ring_flags; /** Runtime queue flags  **/
 313   u16 first_desc_len; /** Length of the first data descriptor **/
 314   virtio_net_hdr_mrg_rxbuf_t hdr; /** Virtio header **/
 315 } vhost_trace_t;
 316
 317
 318 #define VHOST_USER_RX_BUFFERS_N (2 * VLIB_FRAME_SIZE + 2)
 319 #define VHOST_USER_COPY_ARRAY_N (4 * VLIB_FRAME_SIZE)
 320
 321 typedef struct
 322 {
 323   u32 rx_buffers_len;
 324   u32 rx_buffers[VHOST_USER_RX_BUFFERS_N];
 325
 326   virtio_net_hdr_mrg_rxbuf_t tx_headers[VLIB_FRAME_SIZE];
 327   vhost_copy_t copy[VHOST_USER_COPY_ARRAY_N];
 328
 329   /* This is here so it doesn't end-up
 330    * using stack or registers. */
 331   vhost_trace_t *current_trace;
 332 } vhost_cpu_t;
 333
 334 typedef struct
 335 {
 336   mhash_t if_index_by_sock_name;
 337   u32 mtu_bytes;
 338   vhost_user_intf_t *vhost_user_interfaces;
 339   u32 *show_dev_instance_by_real_dev_instance;
 340   u32 coalesce_frames;
 341   f64 coalesce_time;
 342   int dont_dump_vhost_user_memory;
 343
 344   /** Per-CPU data for vhost-user */
 345   vhost_cpu_t *cpus;
 346
 347   /** Pseudo random iterator */
 348   u32 random;
 349
 350   /* The number of rx interface/queue pairs in interrupt mode */
 351   u32 ifq_count;
 352
 353   /* logging */
 354   vlib_log_class_t log_default;
 355 } vhost_user_main_t;
 356
 357 typedef struct
 358 {
 359   u8 if_name[64];
 360   u32 sw_if_index;
 361   u32 virtio_net_hdr_sz;
 362   u64 features;
 363   u8 is_server;
 364   u8 sock_filename[256];
 365   u32 num_regions;
 366   int sock_errno;
 367 } vhost_user_intf_details_t;
 368
 369 int vhost_user_dump_ifs (vnet_main_t * vnm, vlib_main_t * vm,
 370                          vhost_user_intf_details_t ** out_vuids);
 371
 372 extern vlib_node_registration_t vhost_user_send_interrupt_node;
 373 extern vnet_device_class_t vhost_user_device_class;
 374 extern vlib_node_registration_t vhost_user_input_node;
 375 extern vhost_user_main_t vhost_user_main;
 376
 377 #endif
 378
 379 /*
 380  * fd.io coding-style-patch-verification: ON
 381  *
 382  * Local Variables:
 383  * eval: (c-set-style "gnu")
 384  * End:
 385  */