src/vnet/devices/virtio/pci.c

   1 /*
   2  * Copyright (c) 2018 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
  16 #include <fcntl.h>
  17 #include <sys/ioctl.h>
  18
  19 #include <vppinfra/types.h>
  20 #include <vlib/vlib.h>
  21 #include <vlib/pci/pci.h>
  22 #include <vnet/ethernet/ethernet.h>
  23 #include <vnet/ip/ip4_packet.h>
  24 #include <vnet/ip/ip6_packet.h>
  25 #include <vnet/devices/virtio/virtio.h>
  26 #include <vnet/devices/virtio/pci.h>
  27
  28 #define PCI_VENDOR_ID_VIRTIO                            0x1af4
  29 #define PCI_DEVICE_ID_VIRTIO_NIC                        0x1000
  30 /* Doesn't support modern device */
  31 #define PCI_DEVICE_ID_VIRTIO_NIC_MODERN                 0x1041
  32
  33 #define PCI_CAPABILITY_LIST     0x34
  34 #define PCI_CAP_ID_VNDR         0x09
  35 #define PCI_CAP_ID_MSIX         0x11
  36
  37 #define PCI_MSIX_ENABLE 0x8000
  38
  39 #define PCI_CONFIG_SIZE(vif) ((vif->msix_enabled == VIRTIO_MSIX_ENABLED) ? \
  40   24 : 20)
  41
  42 static pci_device_id_t virtio_pci_device_ids[] = {
  43   {
  44    .vendor_id = PCI_VENDOR_ID_VIRTIO,
  45    .device_id = PCI_DEVICE_ID_VIRTIO_NIC},
  46   {
  47    .vendor_id = PCI_VENDOR_ID_VIRTIO,
  48    .device_id = PCI_DEVICE_ID_VIRTIO_NIC_MODERN},
  49   {0},
  50 };
  51
  52 static void
  53 virtio_pci_legacy_read_config (vlib_main_t * vm, virtio_if_t * vif, void *dst,
  54                                int len, u32 addr)
  55 {
  56   u32 size = 0;
  57   vlib_pci_dev_handle_t h = vif->pci_dev_handle;
  58
  59   while (len > 0)
  60     {
  61       if (len >= 4)
  62         {
  63           size = 4;
  64           vlib_pci_read_io_u32 (vm, h, PCI_CONFIG_SIZE (vif) + addr, dst);
  65         }
  66       else if (len >= 2)
  67         {
  68           size = 2;
  69           vlib_pci_read_io_u16 (vm, h, PCI_CONFIG_SIZE (vif) + addr, dst);
  70         }
  71       else
  72         {
  73           size = 1;
  74           vlib_pci_read_io_u8 (vm, h, PCI_CONFIG_SIZE (vif) + addr, dst);
  75         }
  76       dst = (u8 *) dst + size;
  77       addr += size;
  78       len -= size;
  79     }
  80 }
  81
  82 static void
  83 virtio_pci_legacy_write_config (vlib_main_t * vm, virtio_if_t * vif,
  84                                 void *src, int len, u32 addr)
  85 {
  86   u32 size = 0;
  87   vlib_pci_dev_handle_t h = vif->pci_dev_handle;
  88
  89   while (len > 0)
  90     {
  91       if (len >= 4)
  92         {
  93           size = 4;
  94           vlib_pci_write_io_u32 (vm, h, PCI_CONFIG_SIZE (vif) + addr, src);
  95         }
  96       else if (len >= 2)
  97         {
  98           size = 2;
  99           vlib_pci_write_io_u16 (vm, h, PCI_CONFIG_SIZE (vif) + addr, src);
 100         }
 101       else
 102         {
 103           size = 1;
 104           vlib_pci_write_io_u8 (vm, h, PCI_CONFIG_SIZE (vif) + addr, src);
 105         }
 106       src = (u8 *) src + size;
 107       addr += size;
 108       len -= size;
 109     }
 110 }
 111
 112 static u64
 113 virtio_pci_legacy_get_host_features (vlib_main_t * vm, virtio_if_t * vif)
 114 {
 115   u32 features;
 116   vlib_pci_read_io_u32 (vm, vif->pci_dev_handle, VIRTIO_PCI_HOST_FEATURES,
 117                         &features);
 118   return features;
 119 }
 120
 121 static u32
 122 virtio_pci_legacy_get_guest_features (vlib_main_t * vm, virtio_if_t * vif)
 123 {
 124   u32 feature = 0;
 125   vlib_pci_read_io_u32 (vm, vif->pci_dev_handle, VIRTIO_PCI_GUEST_FEATURES,
 126                         &feature);
 127   vif->features = feature;
 128   return feature;
 129 }
 130
 131 static u32
 132 virtio_pci_legacy_set_guest_features (vlib_main_t * vm, virtio_if_t * vif,
 133                                       u64 features)
 134 {
 135   if ((features >> 32) != 0)
 136     {
 137       clib_warning ("only 32 bit features are allowed for legacy virtio!");
 138     }
 139   u32 feature = 0, guest_features = (u32) features;
 140   vlib_pci_write_io_u32 (vm, vif->pci_dev_handle, VIRTIO_PCI_GUEST_FEATURES,
 141                          &guest_features);
 142   vlib_pci_read_io_u32 (vm, vif->pci_dev_handle, VIRTIO_PCI_GUEST_FEATURES,
 143                         &feature);
 144   return feature;
 145 }
 146
 147 static u8
 148 virtio_pci_legacy_get_status (vlib_main_t * vm, virtio_if_t * vif)
 149 {
 150   u8 status = 0;
 151   vlib_pci_read_io_u8 (vm, vif->pci_dev_handle, VIRTIO_PCI_STATUS, &status);
 152   return status;
 153 }
 154
 155 static void
 156 virtio_pci_legacy_set_status (vlib_main_t * vm, virtio_if_t * vif, u8 status)
 157 {
 158   if (status != VIRTIO_CONFIG_STATUS_RESET)
 159     status |= virtio_pci_legacy_get_status (vm, vif);
 160   vlib_pci_write_io_u8 (vm, vif->pci_dev_handle, VIRTIO_PCI_STATUS, &status);
 161 }
 162
 163 static u8
 164 virtio_pci_legacy_reset (vlib_main_t * vm, virtio_if_t * vif)
 165 {
 166   virtio_pci_legacy_set_status (vm, vif, VIRTIO_CONFIG_STATUS_RESET);
 167   return virtio_pci_legacy_get_status (vm, vif);
 168 }
 169
 170 static u8
 171 virtio_pci_legacy_get_isr (vlib_main_t * vm, virtio_if_t * vif)
 172 {
 173   u8 isr = 0;
 174   vlib_pci_read_io_u8 (vm, vif->pci_dev_handle, VIRTIO_PCI_ISR, &isr);
 175   return isr;
 176 }
 177
 178 static u16
 179 virtio_pci_legacy_get_queue_num (vlib_main_t * vm, virtio_if_t * vif,
 180                                  u16 queue_id)
 181 {
 182   u16 queue_num = 0;
 183   vlib_pci_write_io_u16 (vm, vif->pci_dev_handle, VIRTIO_PCI_QUEUE_SEL,
 184                          &queue_id);
 185   vlib_pci_read_io_u16 (vm, vif->pci_dev_handle, VIRTIO_PCI_QUEUE_NUM,
 186                         &queue_num);
 187   return queue_num;
 188 }
 189
 190 static int
 191 virtio_pci_legacy_setup_queue (vlib_main_t * vm, virtio_if_t * vif,
 192                                u16 queue_id, void *p)
 193 {
 194   u64 addr = vlib_physmem_get_pa (vm, p) >> VIRTIO_PCI_QUEUE_ADDR_SHIFT;
 195   u32 addr2 = 0;
 196   vlib_pci_write_io_u16 (vm, vif->pci_dev_handle, VIRTIO_PCI_QUEUE_SEL,
 197                          &queue_id);
 198   vlib_pci_write_io_u32 (vm, vif->pci_dev_handle, VIRTIO_PCI_QUEUE_PFN,
 199                          (u32 *) & addr);
 200   vlib_pci_read_io_u32 (vm, vif->pci_dev_handle, VIRTIO_PCI_QUEUE_PFN,
 201                         &addr2);
 202   if ((u32) addr == addr2)
 203     return 0;
 204   return 1;
 205 }
 206
 207 static void
 208 virtio_pci_legacy_del_queue (vlib_main_t * vm, virtio_if_t * vif,
 209                              u16 queue_id)
 210 {
 211   u32 src = 0;
 212   vlib_pci_write_io_u16 (vm, vif->pci_dev_handle, VIRTIO_PCI_QUEUE_SEL,
 213                          &queue_id);
 214   vlib_pci_write_io_u32 (vm, vif->pci_dev_handle, VIRTIO_PCI_QUEUE_PFN, &src);
 215 }
 216
 217 inline void
 218 virtio_pci_legacy_notify_queue (vlib_main_t * vm, virtio_if_t * vif,
 219                                 u16 queue_id)
 220 {
 221   vlib_pci_write_io_u16 (vm, vif->pci_dev_handle, VIRTIO_PCI_QUEUE_NOTIFY,
 222                          &queue_id);
 223 }
 224
 225 /* Enable one vector (0) for Link State Intrerrupt */
 226 static u16
 227 virtio_pci_legacy_set_config_irq (vlib_main_t * vm, virtio_if_t * vif,
 228                                   u16 vec)
 229 {
 230   vlib_pci_write_io_u16 (vm, vif->pci_dev_handle, VIRTIO_MSI_CONFIG_VECTOR,
 231                          &vec);
 232   vlib_pci_read_io_u16 (vm, vif->pci_dev_handle, VIRTIO_MSI_CONFIG_VECTOR,
 233                         &vec);
 234   return vec;
 235 }
 236
 237 static u16
 238 virtio_pci_legacy_set_queue_irq (vlib_main_t * vm, virtio_if_t * vif, u16 vec,
 239                                  u16 queue_id)
 240 {
 241   vlib_pci_write_io_u16 (vm, vif->pci_dev_handle, VIRTIO_PCI_QUEUE_SEL,
 242                          &queue_id);
 243   vlib_pci_write_io_u16 (vm, vif->pci_dev_handle, VIRTIO_MSI_QUEUE_VECTOR,
 244                          &vec);
 245   vlib_pci_read_io_u16 (vm, vif->pci_dev_handle, VIRTIO_MSI_QUEUE_VECTOR,
 246                         &vec);
 247   return vec;
 248 }
 249
 250 static u32
 251 virtio_pci_flag_change (vnet_main_t * vnm, vnet_hw_interface_t * hw,
 252                         u32 flags)
 253 {
 254   return 0;
 255 }
 256
 257 static clib_error_t *
 258 virtio_pci_get_max_virtqueue_pairs (vlib_main_t * vm, virtio_if_t * vif)
 259 {
 260   virtio_net_config_t config;
 261   clib_error_t *error = 0;
 262   u16 max_queue_pairs = 1;
 263
 264   if (vif->features & VIRTIO_FEATURE (VIRTIO_NET_F_MQ))
 265     {
 266       virtio_pci_legacy_read_config (vm, vif, &config.max_virtqueue_pairs,
 267                                      sizeof (config.max_virtqueue_pairs),
 268                                      STRUCT_OFFSET_OF (virtio_net_config_t,
 269                                                        max_virtqueue_pairs));
 270       max_queue_pairs = config.max_virtqueue_pairs;
 271     }
 272
 273   virtio_log_debug (vif, "max queue pair is %x", max_queue_pairs);
 274   if (max_queue_pairs < 1 || max_queue_pairs > 0x8000)
 275     return clib_error_return (error, "max queue pair is %x,"
 276                               " should be in range [1, 0x8000]",
 277                               max_queue_pairs);
 278
 279   vif->max_queue_pairs = max_queue_pairs;
 280   return error;
 281 }
 282
 283 static void
 284 virtio_pci_set_mac (vlib_main_t * vm, virtio_if_t * vif)
 285 {
 286   virtio_pci_legacy_write_config (vm, vif, vif->mac_addr,
 287                                   sizeof (vif->mac_addr), 0);
 288 }
 289
 290 static u32
 291 virtio_pci_get_mac (vlib_main_t * vm, virtio_if_t * vif)
 292 {
 293   if (vif->features & VIRTIO_FEATURE (VIRTIO_NET_F_MAC))
 294     {
 295       virtio_pci_legacy_read_config (vm, vif, vif->mac_addr,
 296                                      sizeof (vif->mac_addr), 0);
 297       return 0;
 298     }
 299   return 1;
 300 }
 301
 302 static u16
 303 virtio_pci_is_link_up (vlib_main_t * vm, virtio_if_t * vif)
 304 {
 305   /*
 306    * Minimal driver: assumes link is up
 307    */
 308   u16 status = 1;
 309   if (vif->features & VIRTIO_FEATURE (VIRTIO_NET_F_STATUS))
 310     virtio_pci_legacy_read_config (vm, vif, &status, sizeof (status),   /* mac */
 311                                    STRUCT_OFFSET_OF (virtio_net_config_t,
 312                                                      status));
 313   return status;
 314 }
 315
 316 static void
 317 virtio_pci_irq_0_handler (vlib_main_t * vm, vlib_pci_dev_handle_t h, u16 line)
 318 {
 319   vnet_main_t *vnm = vnet_get_main ();
 320   virtio_main_t *vim = &virtio_main;
 321   uword pd = vlib_pci_get_private_data (vm, h);
 322   virtio_if_t *vif = pool_elt_at_index (vim->interfaces, pd);
 323   u16 qid = line;
 324
 325   vnet_device_input_set_interrupt_pending (vnm, vif->hw_if_index, qid);
 326 }
 327
 328 static void
 329 virtio_pci_irq_1_handler (vlib_main_t * vm, vlib_pci_dev_handle_t h, u16 line)
 330 {
 331   vnet_main_t *vnm = vnet_get_main ();
 332   virtio_main_t *vim = &virtio_main;
 333   uword pd = vlib_pci_get_private_data (vm, h);
 334   virtio_if_t *vif = pool_elt_at_index (vim->interfaces, pd);
 335
 336   if (virtio_pci_is_link_up (vm, vif) & VIRTIO_NET_S_LINK_UP)
 337     {
 338       vif->flags |= VIRTIO_IF_FLAG_ADMIN_UP;
 339       vnet_hw_interface_set_flags (vnm, vif->hw_if_index,
 340                                    VNET_HW_INTERFACE_FLAG_LINK_UP);
 341     }
 342   else
 343     {
 344       vif->flags &= ~VIRTIO_IF_FLAG_ADMIN_UP;
 345       vnet_hw_interface_set_flags (vnm, vif->hw_if_index, 0);
 346     }
 347 }
 348
 349 static void
 350 virtio_pci_irq_handler (vlib_main_t * vm, vlib_pci_dev_handle_t h)
 351 {
 352   virtio_main_t *vim = &virtio_main;
 353   uword pd = vlib_pci_get_private_data (vm, h);
 354   virtio_if_t *vif = pool_elt_at_index (vim->interfaces, pd);
 355   u8 isr = 0;
 356   u16 line = 0;
 357
 358   isr = virtio_pci_legacy_get_isr (vm, vif);
 359
 360   /*
 361    * If the lower bit is set: look through the used rings of
 362    * all virtqueues for the device, to see if any progress has
 363    * been made by the device which requires servicing.
 364    */
 365   if (isr & VIRTIO_PCI_ISR_INTR)
 366     virtio_pci_irq_0_handler (vm, h, line);
 367
 368   if (isr & VIRTIO_PCI_ISR_CONFIG)
 369     virtio_pci_irq_1_handler (vm, h, line);
 370 }
 371
 372 inline void
 373 device_status (vlib_main_t * vm, virtio_if_t * vif)
 374 {
 375   struct status_struct
 376   {
 377     u8 bit;
 378     char *str;
 379   };
 380   struct status_struct *status_entry;
 381   static struct status_struct status_array[] = {
 382 #define _(s,b) { .str = #s, .bit = b, },
 383     foreach_virtio_config_status_flags
 384 #undef _
 385     {.str = NULL}
 386   };
 387
 388   vlib_cli_output (vm, "  status 0x%x", vif->status);
 389
 390   status_entry = (struct status_struct *) &status_array;
 391   while (status_entry->str)
 392     {
 393       if (vif->status & status_entry->bit)
 394         vlib_cli_output (vm, "    %s (%x)", status_entry->str,
 395                          status_entry->bit);
 396       status_entry++;
 397     }
 398 }
 399
 400 inline void
 401 debug_device_config_space (vlib_main_t * vm, virtio_if_t * vif)
 402 {
 403   u32 data_u32;
 404   u16 data_u16;
 405   u8 data_u8;
 406   vlib_pci_read_io_u32 (vm, vif->pci_dev_handle, VIRTIO_PCI_HOST_FEATURES,
 407                         &data_u32);
 408   vlib_cli_output (vm, "remote features 0x%lx", data_u32);
 409   vlib_pci_read_io_u32 (vm, vif->pci_dev_handle, VIRTIO_PCI_GUEST_FEATURES,
 410                         &data_u32);
 411   vlib_cli_output (vm, "guest features 0x%lx", data_u32);
 412   vlib_pci_read_io_u32 (vm, vif->pci_dev_handle, VIRTIO_PCI_QUEUE_PFN,
 413                         &data_u32);
 414   vlib_cli_output (vm, "queue address 0x%lx", data_u32);
 415   vlib_pci_read_io_u16 (vm, vif->pci_dev_handle, VIRTIO_PCI_QUEUE_NUM,
 416                         &data_u16);
 417   vlib_cli_output (vm, "queue size 0x%x", data_u16);
 418   vlib_pci_read_io_u16 (vm, vif->pci_dev_handle, VIRTIO_PCI_QUEUE_SEL,
 419                         &data_u16);
 420   vlib_cli_output (vm, "queue select 0x%x", data_u16);
 421   vlib_pci_read_io_u16 (vm, vif->pci_dev_handle, VIRTIO_PCI_QUEUE_NOTIFY,
 422                         &data_u16);
 423   vlib_cli_output (vm, "queue notify 0x%x", data_u16);
 424   vlib_pci_read_io_u8 (vm, vif->pci_dev_handle, VIRTIO_PCI_STATUS, &data_u8);
 425   vlib_cli_output (vm, "status 0x%x", data_u8);
 426   vlib_pci_read_io_u8 (vm, vif->pci_dev_handle, VIRTIO_PCI_ISR, &data_u8);
 427   vlib_cli_output (vm, "isr 0x%x", data_u8);
 428
 429   if (vif->msix_enabled == VIRTIO_MSIX_ENABLED)
 430     {
 431       vlib_pci_read_io_u16 (vm, vif->pci_dev_handle, VIRTIO_MSI_CONFIG_VECTOR,
 432                             &data_u16);
 433       vlib_cli_output (vm, "config vector 0x%x", data_u16);
 434       u16 queue_id = 0;
 435       vlib_pci_write_io_u16 (vm, vif->pci_dev_handle, VIRTIO_PCI_QUEUE_SEL,
 436                              &queue_id);
 437       vlib_pci_read_io_u16 (vm, vif->pci_dev_handle, VIRTIO_MSI_QUEUE_VECTOR,
 438                             &data_u16);
 439       vlib_cli_output (vm, "queue vector for queue (0) 0x%x", data_u16);
 440     }
 441
 442   u8 mac[6];
 443   virtio_pci_legacy_read_config (vm, vif, mac, sizeof (mac), 0);
 444   vlib_cli_output (vm, "mac %U", format_ethernet_address, mac);
 445   virtio_pci_legacy_read_config (vm, vif, &data_u16, sizeof (u16),      /* offset to status */
 446                                  6);
 447   vlib_cli_output (vm, "link up/down status 0x%x", data_u16);
 448   virtio_pci_legacy_read_config (vm, vif, &data_u16, sizeof (u16),
 449                                  /* offset to max_virtqueue */ 8);
 450   vlib_cli_output (vm, "num of virtqueue 0x%x", data_u16);
 451   virtio_pci_legacy_read_config (vm, vif, &data_u16, sizeof (u16),      /* offset to mtu */
 452                                  10);
 453   vlib_cli_output (vm, "mtu 0x%x", data_u16);
 454
 455   u32 i = PCI_CONFIG_SIZE (vif) + 12, a = 4;
 456   i += a;
 457   i &= ~a;
 458   for (; i < 64; i += 4)
 459     {
 460       u32 data = 0;
 461       vlib_pci_read_io_u32 (vm, vif->pci_dev_handle, i, &data);
 462       vlib_cli_output (vm, "0x%lx", data);
 463     }
 464 }
 465
 466 struct virtio_ctrl_msg
 467 {
 468   struct virtio_net_ctrl_hdr ctrl;
 469   virtio_net_ctrl_ack status;
 470   u8 data[1024];
 471 };
 472
 473 static int
 474 virtio_pci_send_ctrl_msg (vlib_main_t * vm, virtio_if_t * vif,
 475                           struct virtio_ctrl_msg *data, u32 len)
 476 {
 477   virtio_vring_t *vring = vif->cxq_vring;
 478   virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
 479   struct virtio_ctrl_msg result;
 480   u32 buffer_index;
 481   vlib_buffer_t *b;
 482   u16 used, next, avail;
 483   u16 sz = vring->size;
 484   u16 mask = sz - 1;
 485
 486   used = vring->desc_in_use;
 487   next = vring->desc_next;
 488   avail = vring->avail->idx;
 489   struct vring_desc *d = &vring->desc[next];
 490
 491   if (vlib_buffer_alloc (vm, &buffer_index, 1))
 492     b = vlib_get_buffer (vm, buffer_index);
 493   else
 494     return VIRTIO_NET_ERR;
 495   /*
 496    * current_data may not be initialized with 0 and may contain
 497    * previous offset.
 498    */
 499   b->current_data = 0;
 500   clib_memcpy (vlib_buffer_get_current (b), data,
 501                sizeof (struct virtio_ctrl_msg));
 502   d->flags = VRING_DESC_F_NEXT;
 503   d->addr = vlib_buffer_get_current_pa (vm, b);
 504   d->len = sizeof (struct virtio_net_ctrl_hdr);
 505   vring->avail->ring[avail & mask] = next;
 506   avail++;
 507   next = (next + 1) & mask;
 508   d->next = next;
 509   used++;
 510
 511   d = &vring->desc[next];
 512   d->flags = VRING_DESC_F_NEXT;
 513   d->addr = vlib_buffer_get_current_pa (vm, b) +
 514     STRUCT_OFFSET_OF (struct virtio_ctrl_msg, data);
 515   d->len = len;
 516   next = (next + 1) & mask;
 517   d->next = next;
 518   used++;
 519
 520   d = &vring->desc[next];
 521   d->flags = VRING_DESC_F_WRITE;
 522   d->addr = vlib_buffer_get_current_pa (vm, b) +
 523     STRUCT_OFFSET_OF (struct virtio_ctrl_msg, status);
 524   d->len = sizeof (data->status);
 525   next = (next + 1) & mask;
 526   used++;
 527
 528   CLIB_MEMORY_STORE_BARRIER ();
 529   vring->avail->idx = avail;
 530   vring->desc_next = next;
 531   vring->desc_in_use = used;
 532
 533   if ((vring->used->flags & VIRTIO_RING_FLAG_MASK_INT) == 0)
 534     {
 535       virtio_kick (vm, vring, vif);
 536     }
 537
 538   u16 last = vring->last_used_idx, n_left = 0;
 539   n_left = vring->used->idx - last;
 540
 541   while (n_left)
 542     {
 543       struct vring_used_elem *e = &vring->used->ring[last & mask];
 544       u16 slot = e->id;
 545
 546       d = &vring->desc[slot];
 547       while (d->flags & VRING_DESC_F_NEXT)
 548         {
 549           used--;
 550           slot = d->next;
 551           d = &vring->desc[slot];
 552         }
 553       used--;
 554       last++;
 555       n_left--;
 556     }
 557   vring->desc_in_use = used;
 558   vring->last_used_idx = last;
 559
 560   CLIB_MEMORY_BARRIER ();
 561   clib_memcpy (&result, vlib_buffer_get_current (b),
 562                sizeof (struct virtio_ctrl_msg));
 563   virtio_log_debug (vif, "ctrl-queue: status %u", result.status);
 564   status = result.status;
 565   vlib_buffer_free (vm, &buffer_index, 1);
 566   return status;
 567 }
 568
 569 static int
 570 virtio_pci_disable_offload (vlib_main_t * vm, virtio_if_t * vif)
 571 {
 572   struct virtio_ctrl_msg offload_hdr;
 573   virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
 574
 575   offload_hdr.ctrl.class = VIRTIO_NET_CTRL_GUEST_OFFLOADS;
 576   offload_hdr.ctrl.cmd = VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET;
 577   offload_hdr.status = VIRTIO_NET_ERR;
 578   u64 offloads = 0ULL;
 579   clib_memcpy (offload_hdr.data, &offloads, sizeof (offloads));
 580
 581   status =
 582     virtio_pci_send_ctrl_msg (vm, vif, &offload_hdr, sizeof (offloads));
 583   virtio_log_debug (vif, "disable offloads");
 584   vif->remote_features = virtio_pci_legacy_get_host_features (vm, vif);
 585   virtio_pci_legacy_get_guest_features (vm, vif);
 586   return status;
 587 }
 588
 589 static int
 590 virtio_pci_enable_checksum_offload (vlib_main_t * vm, virtio_if_t * vif)
 591 {
 592   struct virtio_ctrl_msg csum_offload_hdr;
 593   virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
 594
 595   csum_offload_hdr.ctrl.class = VIRTIO_NET_CTRL_GUEST_OFFLOADS;
 596   csum_offload_hdr.ctrl.cmd = VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET;
 597   csum_offload_hdr.status = VIRTIO_NET_ERR;
 598   u64 offloads = 0ULL;
 599   offloads |= VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_CSUM);
 600   clib_memcpy (csum_offload_hdr.data, &offloads, sizeof (offloads));
 601
 602   status =
 603     virtio_pci_send_ctrl_msg (vm, vif, &csum_offload_hdr, sizeof (offloads));
 604   virtio_log_debug (vif, "enable checksum offload");
 605   vif->remote_features = virtio_pci_legacy_get_host_features (vm, vif);
 606   virtio_pci_legacy_get_guest_features (vm, vif);
 607   return status;
 608 }
 609
 610 static int
 611 virtio_pci_enable_gso (vlib_main_t * vm, virtio_if_t * vif)
 612 {
 613   struct virtio_ctrl_msg gso_hdr;
 614   virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
 615
 616   gso_hdr.ctrl.class = VIRTIO_NET_CTRL_GUEST_OFFLOADS;
 617   gso_hdr.ctrl.cmd = VIRTIO_NET_CTRL_GUEST_OFFLOADS_SET;
 618   gso_hdr.status = VIRTIO_NET_ERR;
 619   u64 offloads = VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_CSUM)
 620     | VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_TSO4)
 621     | VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_TSO6);
 622   clib_memcpy (gso_hdr.data, &offloads, sizeof (offloads));
 623
 624   status = virtio_pci_send_ctrl_msg (vm, vif, &gso_hdr, sizeof (offloads));
 625   virtio_log_debug (vif, "enable gso");
 626   vif->remote_features = virtio_pci_legacy_get_host_features (vm, vif);
 627   virtio_pci_legacy_get_guest_features (vm, vif);
 628   return status;
 629 }
 630
 631 static int
 632 virtio_pci_offloads (vlib_main_t * vm, virtio_if_t * vif, int gso_enabled,
 633                      int csum_offload_enabled)
 634 {
 635   vnet_main_t *vnm = vnet_get_main ();
 636   vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, vif->hw_if_index);
 637
 638   if ((vif->features & VIRTIO_FEATURE (VIRTIO_NET_F_CTRL_VQ)) &&
 639       (vif->features & VIRTIO_FEATURE (VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)))
 640     {
 641       if (gso_enabled
 642           && (vif->features & (VIRTIO_FEATURE (VIRTIO_NET_F_HOST_TSO4) |
 643                                VIRTIO_FEATURE (VIRTIO_NET_F_HOST_TSO6))))
 644         {
 645           if (virtio_pci_enable_gso (vm, vif))
 646             {
 647               virtio_log_warning (vif, "gso is not enabled");
 648             }
 649           else
 650             {
 651               vif->gso_enabled = 1;
 652               vif->csum_offload_enabled = 0;
 653               hw->flags |= VNET_HW_INTERFACE_FLAG_SUPPORTS_GSO |
 654                 VNET_HW_INTERFACE_FLAG_SUPPORTS_TX_L4_CKSUM_OFFLOAD;
 655             }
 656         }
 657       else if (csum_offload_enabled
 658                && (vif->features & VIRTIO_FEATURE (VIRTIO_NET_F_CSUM)))
 659         {
 660           if (virtio_pci_enable_checksum_offload (vm, vif))
 661             {
 662               virtio_log_warning (vif, "checksum offload is not enabled");
 663             }
 664           else
 665             {
 666               vif->csum_offload_enabled = 1;
 667               vif->gso_enabled = 0;
 668               hw->flags &= ~VNET_HW_INTERFACE_FLAG_SUPPORTS_GSO;
 669               hw->flags |=
 670                 VNET_HW_INTERFACE_FLAG_SUPPORTS_TX_L4_CKSUM_OFFLOAD;
 671             }
 672         }
 673       else
 674         {
 675           if (virtio_pci_disable_offload (vm, vif))
 676             {
 677               virtio_log_warning (vif, "offloads are not disabled");
 678             }
 679           else
 680             {
 681               vif->csum_offload_enabled = 0;
 682               vif->gso_enabled = 0;
 683               hw->flags &= ~(VNET_HW_INTERFACE_FLAG_SUPPORTS_GSO |
 684                              VNET_HW_INTERFACE_FLAG_SUPPORTS_TX_L4_CKSUM_OFFLOAD);
 685             }
 686         }
 687     }
 688
 689   return 0;
 690 }
 691
 692 static int
 693 virtio_pci_enable_multiqueue (vlib_main_t * vm, virtio_if_t * vif,
 694                               u16 num_queues)
 695 {
 696   struct virtio_ctrl_msg mq_hdr;
 697   virtio_net_ctrl_ack status = VIRTIO_NET_ERR;
 698
 699   mq_hdr.ctrl.class = VIRTIO_NET_CTRL_MQ;
 700   mq_hdr.ctrl.cmd = VIRTIO_NET_CTRL_MQ_VQ_PAIRS_SET;
 701   mq_hdr.status = VIRTIO_NET_ERR;
 702   clib_memcpy (mq_hdr.data, &num_queues, sizeof (num_queues));
 703
 704   status = virtio_pci_send_ctrl_msg (vm, vif, &mq_hdr, sizeof (num_queues));
 705   virtio_log_debug (vif, "multi-queue enable %u queues", num_queues);
 706   return status;
 707 }
 708
 709 static u8
 710 virtio_pci_queue_size_valid (u16 qsz)
 711 {
 712   if (qsz < 64 || qsz > 4096)
 713     return 0;
 714   if ((qsz % 64) != 0)
 715     return 0;
 716   return 1;
 717 }
 718
 719 clib_error_t *
 720 virtio_pci_control_vring_init (vlib_main_t * vm, virtio_if_t * vif,
 721                                u16 queue_num)
 722 {
 723   clib_error_t *error = 0;
 724   u16 queue_size = 0;
 725   virtio_vring_t *vring;
 726   struct vring vr;
 727   u32 i = 0;
 728   void *ptr = NULL;
 729
 730   queue_size = virtio_pci_legacy_get_queue_num (vm, vif, queue_num);
 731   if (!virtio_pci_queue_size_valid (queue_size))
 732     clib_warning ("queue size is not valid");
 733
 734   if (!is_pow2 (queue_size))
 735     return clib_error_return (0, "ring size must be power of 2");
 736
 737   if (queue_size > 32768)
 738     return clib_error_return (0, "ring size must be 32768 or lower");
 739
 740   if (queue_size == 0)
 741     queue_size = 256;
 742
 743   vec_validate_aligned (vif->cxq_vring, 0, CLIB_CACHE_LINE_BYTES);
 744   vring = vec_elt_at_index (vif->cxq_vring, 0);
 745   i = vring_size (queue_size, VIRTIO_PCI_VRING_ALIGN);
 746   i = round_pow2 (i, VIRTIO_PCI_VRING_ALIGN);
 747   ptr =
 748     vlib_physmem_alloc_aligned_on_numa (vm, i, VIRTIO_PCI_VRING_ALIGN,
 749                                         vif->numa_node);
 750   if (!ptr)
 751     return vlib_physmem_last_error (vm);
 752   clib_memset (ptr, 0, i);
 753   vring_init (&vr, queue_size, ptr, VIRTIO_PCI_VRING_ALIGN);
 754   vring->desc = vr.desc;
 755   vring->avail = vr.avail;
 756   vring->used = vr.used;
 757   vring->queue_id = queue_num;
 758   vring->avail->flags = VIRTIO_RING_FLAG_MASK_INT;
 759
 760   ASSERT (vring->buffers == 0);
 761
 762   vring->size = queue_size;
 763   virtio_log_debug (vif, "control-queue: number %u, size %u", queue_num,
 764                     queue_size);
 765   virtio_pci_legacy_setup_queue (vm, vif, queue_num, ptr);
 766   vring->kick_fd = -1;
 767
 768   return error;
 769 }
 770
 771 clib_error_t *
 772 virtio_pci_vring_init (vlib_main_t * vm, virtio_if_t * vif, u16 queue_num)
 773 {
 774   clib_error_t *error = 0;
 775   u16 queue_size = 0;
 776   virtio_vring_t *vring;
 777   struct vring vr;
 778   u32 i = 0;
 779   void *ptr = NULL;
 780
 781   queue_size = virtio_pci_legacy_get_queue_num (vm, vif, queue_num);
 782   if (!virtio_pci_queue_size_valid (queue_size))
 783     clib_warning ("queue size is not valid");
 784
 785   if (!is_pow2 (queue_size))
 786     return clib_error_return (0, "ring size must be power of 2");
 787
 788   if (queue_size > 32768)
 789     return clib_error_return (0, "ring size must be 32768 or lower");
 790
 791   if (queue_size == 0)
 792     queue_size = 256;
 793
 794   if (queue_num % 2)
 795     {
 796       vec_validate_aligned (vif->txq_vrings, TX_QUEUE_ACCESS (queue_num),
 797                             CLIB_CACHE_LINE_BYTES);
 798       vring = vec_elt_at_index (vif->txq_vrings, TX_QUEUE_ACCESS (queue_num));
 799       clib_spinlock_init (&vring->lockp);
 800     }
 801   else
 802     {
 803       vec_validate_aligned (vif->rxq_vrings, RX_QUEUE_ACCESS (queue_num),
 804                             CLIB_CACHE_LINE_BYTES);
 805       vring = vec_elt_at_index (vif->rxq_vrings, RX_QUEUE_ACCESS (queue_num));
 806     }
 807   i = vring_size (queue_size, VIRTIO_PCI_VRING_ALIGN);
 808   i = round_pow2 (i, VIRTIO_PCI_VRING_ALIGN);
 809   ptr =
 810     vlib_physmem_alloc_aligned_on_numa (vm, i, VIRTIO_PCI_VRING_ALIGN,
 811                                         vif->numa_node);
 812   if (!ptr)
 813     return vlib_physmem_last_error (vm);
 814   clib_memset (ptr, 0, i);
 815   vring_init (&vr, queue_size, ptr, VIRTIO_PCI_VRING_ALIGN);
 816   vring->desc = vr.desc;
 817   vring->avail = vr.avail;
 818   vring->used = vr.used;
 819   vring->queue_id = queue_num;
 820   vring->avail->flags = VIRTIO_RING_FLAG_MASK_INT;
 821
 822   ASSERT (vring->buffers == 0);
 823   vec_validate_aligned (vring->buffers, queue_size, CLIB_CACHE_LINE_BYTES);
 824   if (queue_num % 2)
 825     {
 826       virtio_log_debug (vif, "tx-queue: number %u, size %u", queue_num,
 827                         queue_size);
 828       clib_memset_u32 (vring->buffers, ~0, queue_size);
 829     }
 830   else
 831     {
 832       virtio_log_debug (vif, "rx-queue: number %u, size %u", queue_num,
 833                         queue_size);
 834     }
 835   vring->size = queue_size;
 836   if (virtio_pci_legacy_setup_queue (vm, vif, queue_num, ptr))
 837     return clib_error_return (0, "error in queue address setup");
 838
 839   vring->kick_fd = -1;
 840   return error;
 841 }
 842
 843 static void
 844 virtio_negotiate_features (vlib_main_t * vm, virtio_if_t * vif,
 845                            u64 req_features)
 846 {
 847   /*
 848    * if features are not requested
 849    * default: all supported features
 850    */
 851   u64 supported_features = VIRTIO_FEATURE (VIRTIO_NET_F_CSUM)
 852     | VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_CSUM)
 853     | VIRTIO_FEATURE (VIRTIO_NET_F_CTRL_GUEST_OFFLOADS)
 854     | VIRTIO_FEATURE (VIRTIO_NET_F_MTU)
 855     | VIRTIO_FEATURE (VIRTIO_NET_F_MAC)
 856     | VIRTIO_FEATURE (VIRTIO_NET_F_GSO)
 857     | VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_TSO4)
 858     | VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_TSO6)
 859     | VIRTIO_FEATURE (VIRTIO_NET_F_GUEST_UFO)
 860     | VIRTIO_FEATURE (VIRTIO_NET_F_HOST_TSO4)
 861     | VIRTIO_FEATURE (VIRTIO_NET_F_HOST_TSO6)
 862     | VIRTIO_FEATURE (VIRTIO_NET_F_HOST_UFO)
 863     | VIRTIO_FEATURE (VIRTIO_NET_F_MRG_RXBUF)
 864     | VIRTIO_FEATURE (VIRTIO_NET_F_STATUS)
 865     | VIRTIO_FEATURE (VIRTIO_NET_F_CTRL_VQ)
 866     | VIRTIO_FEATURE (VIRTIO_NET_F_MQ)
 867     | VIRTIO_FEATURE (VIRTIO_F_NOTIFY_ON_EMPTY)
 868     | VIRTIO_FEATURE (VIRTIO_F_ANY_LAYOUT)
 869     | VIRTIO_FEATURE (VIRTIO_RING_F_INDIRECT_DESC);
 870
 871   if (req_features == 0)
 872     {
 873       req_features = supported_features;
 874     }
 875
 876   vif->features = req_features & vif->remote_features & supported_features;
 877
 878   if (vif->features & VIRTIO_FEATURE (VIRTIO_NET_F_MTU))
 879     {
 880       virtio_net_config_t config;
 881       virtio_pci_legacy_read_config (vm, vif, &config.mtu,
 882                                      sizeof (config.mtu),
 883                                      STRUCT_OFFSET_OF (virtio_net_config_t,
 884                                                        mtu));
 885       if (config.mtu < 64)
 886         vif->features &= ~VIRTIO_FEATURE (VIRTIO_NET_F_MTU);
 887     }
 888
 889   vif->features =
 890     virtio_pci_legacy_set_guest_features (vm, vif, vif->features);
 891 }
 892
 893 void
 894 virtio_pci_read_device_feature (vlib_main_t * vm, virtio_if_t * vif)
 895 {
 896   vif->remote_features = virtio_pci_legacy_get_host_features (vm, vif);
 897 }
 898
 899 int
 900 virtio_pci_reset_device (vlib_main_t * vm, virtio_if_t * vif)
 901 {
 902   u8 status = 0;
 903
 904   /*
 905    * Reset the device
 906    */
 907   status = virtio_pci_legacy_reset (vm, vif);
 908
 909   /*
 910    * Set the Acknowledge status bit
 911    */
 912   virtio_pci_legacy_set_status (vm, vif, VIRTIO_CONFIG_STATUS_ACK);
 913
 914   /*
 915    * Set the Driver status bit
 916    */
 917   virtio_pci_legacy_set_status (vm, vif, VIRTIO_CONFIG_STATUS_DRIVER);
 918
 919   /*
 920    * Read the status and verify it
 921    */
 922   status = virtio_pci_legacy_get_status (vm, vif);
 923   if (!
 924       ((status & VIRTIO_CONFIG_STATUS_ACK)
 925        && (status & VIRTIO_CONFIG_STATUS_DRIVER)))
 926     return -1;
 927   vif->status = status;
 928
 929   return 0;
 930 }
 931
 932 clib_error_t *
 933 virtio_pci_read_caps (vlib_main_t * vm, virtio_if_t * vif)
 934 {
 935   clib_error_t *error = 0;
 936   struct virtio_pci_cap cap;
 937   u8 pos, common_cfg = 0, notify_base = 0, dev_cfg = 0, isr = 0, pci_cfg = 0;
 938   vlib_pci_dev_handle_t h = vif->pci_dev_handle;
 939
 940   if ((error = vlib_pci_read_config_u8 (vm, h, PCI_CAPABILITY_LIST, &pos)))
 941     {
 942       virtio_log_error (vif, "error in reading capabilty list position");
 943       clib_error_return (error, "error in reading capabilty list position");
 944     }
 945   while (pos)
 946     {
 947       if ((error =
 948            vlib_pci_read_write_config (vm, h, VLIB_READ, pos, &cap,
 949                                        sizeof (cap))))
 950         {
 951           virtio_log_error (vif, "%s [%2x]",
 952                             "error in reading the capability at", pos);
 953           clib_error_return (error,
 954                              "error in reading the capability at [%2x]", pos);
 955         }
 956
 957       if (cap.cap_vndr == PCI_CAP_ID_MSIX)
 958         {
 959           u16 flags, table_size, table_size_mask = 0x07FF;
 960
 961           if ((error =
 962                vlib_pci_read_write_config (vm, h, VLIB_READ, pos + 2, &flags,
 963                                            sizeof (flags))))
 964             clib_error_return (error,
 965                                "error in reading the capability at [%2x]",
 966                                pos + 2);
 967
 968           table_size = flags & table_size_mask;
 969           virtio_log_debug (vif, "flags:0x%x %s 0x%x", flags,
 970                             "msix interrupt vector table-size", table_size);
 971
 972           if (flags & PCI_MSIX_ENABLE)
 973             {
 974               virtio_log_debug (vif, "msix interrupt enabled");
 975               vif->msix_enabled = VIRTIO_MSIX_ENABLED;
 976             }
 977           else
 978             {
 979               virtio_log_debug (vif, "msix interrupt disabled");
 980               vif->msix_enabled = VIRTIO_MSIX_DISABLED;
 981             }
 982         }
 983
 984       if (cap.cap_vndr != PCI_CAP_ID_VNDR)
 985         {
 986           virtio_log_debug (vif, "[%2x] %s %2x ", pos,
 987                             "skipping non VNDR cap id:", cap.cap_vndr);
 988           goto next;
 989         }
 990
 991       virtio_log_debug (vif,
 992                         "[%4x] cfg type: %u, bar: %u, offset: %04x, len: %u",
 993                         pos, cap.cfg_type, cap.bar, cap.offset, cap.length);
 994       switch (cap.cfg_type)
 995         {
 996         case VIRTIO_PCI_CAP_COMMON_CFG:
 997           common_cfg = 1;
 998           break;
 999         case VIRTIO_PCI_CAP_NOTIFY_CFG:
1000           notify_base = 1;
1001           break;
1002         case VIRTIO_PCI_CAP_DEVICE_CFG:
1003           dev_cfg = 1;
1004           break;
1005         case VIRTIO_PCI_CAP_ISR_CFG:
1006           isr = 1;
1007           break;
1008         case VIRTIO_PCI_CAP_PCI_CFG:
1009           if (cap.bar == 0)
1010             pci_cfg = 1;
1011           break;
1012         }
1013     next:
1014       pos = cap.cap_next;
1015     }
1016
1017   if (common_cfg == 0 || notify_base == 0 || dev_cfg == 0 || isr == 0)
1018     {
1019       virtio_log_debug (vif, "legacy virtio pci device found");
1020       return error;
1021     }
1022
1023   if (!pci_cfg)
1024     clib_error_return (error, "modern virtio pci device found");
1025
1026   virtio_log_debug (vif, "transitional virtio pci device found");
1027   return error;
1028 }
1029
1030 static clib_error_t *
1031 virtio_pci_device_init (vlib_main_t * vm, virtio_if_t * vif,
1032                         virtio_pci_create_if_args_t * args)
1033 {
1034   clib_error_t *error = 0;
1035   vlib_thread_main_t *vtm = vlib_get_thread_main ();
1036   u8 status = 0;
1037
1038   if ((error = virtio_pci_read_caps (vm, vif)))
1039     {
1040       args->rv = VNET_API_ERROR_UNSUPPORTED;
1041       virtio_log_error (vif, "Device is not supported");
1042       clib_error_return (error, "Device is not supported");
1043     }
1044
1045   if (virtio_pci_reset_device (vm, vif) < 0)
1046     {
1047       args->rv = VNET_API_ERROR_INIT_FAILED;
1048       virtio_log_error (vif, "Failed to reset the device");
1049       clib_error_return (error, "Failed to reset the device");
1050     }
1051   /*
1052    * read device features and negotiate (user) requested features
1053    */
1054   virtio_pci_read_device_feature (vm, vif);
1055   virtio_negotiate_features (vm, vif, args->features);
1056
1057   /*
1058    * After FEATURE_OK, driver should not accept new feature bits
1059    */
1060   virtio_pci_legacy_set_status (vm, vif, VIRTIO_CONFIG_STATUS_FEATURES_OK);
1061   status = virtio_pci_legacy_get_status (vm, vif);
1062   if (!(status & VIRTIO_CONFIG_STATUS_FEATURES_OK))
1063     {
1064       args->rv = VNET_API_ERROR_UNSUPPORTED;
1065       virtio_log_error (vif,
1066                         "error encountered: Device doesn't support requested features");
1067       clib_error_return (error, "Device doesn't support requested features");
1068     }
1069   vif->status = status;
1070
1071   /*
1072    * get or set the mac address
1073    */
1074   if (virtio_pci_get_mac (vm, vif))
1075     {
1076       f64 now = vlib_time_now (vm);
1077       u32 rnd;
1078       rnd = (u32) (now * 1e6);
1079       rnd = random_u32 (&rnd);
1080
1081       memcpy (vif->mac_addr + 2, &rnd, sizeof (rnd));
1082       vif->mac_addr[0] = 2;
1083       vif->mac_addr[1] = 0xfe;
1084       virtio_pci_set_mac (vm, vif);
1085     }
1086
1087   virtio_set_net_hdr_size (vif);
1088
1089   /*
1090    * Initialize the virtqueues
1091    */
1092   if ((error = virtio_pci_get_max_virtqueue_pairs (vm, vif)))
1093     {
1094       args->rv = VNET_API_ERROR_EXCEEDED_NUMBER_OF_RANGES_CAPACITY;
1095       goto err;
1096     }
1097
1098   for (int i = 0; i < vif->max_queue_pairs; i++)
1099     {
1100       if ((error = virtio_pci_vring_init (vm, vif, RX_QUEUE (i))))
1101         {
1102           args->rv = VNET_API_ERROR_INIT_FAILED;
1103           virtio_log_error (vif, "%s (%u) %s", "error in rxq-queue",
1104                             RX_QUEUE (i), "initialization");
1105           clib_error_return (error, "%s (%u) %s", "error in rxq-queue",
1106                              RX_QUEUE (i), "initialization");
1107         }
1108       else
1109         {
1110           vif->num_rxqs++;
1111         }
1112
1113       if (i >= vtm->n_vlib_mains)
1114         {
1115           /*
1116            * There is 1:1 mapping between tx queue and vpp worker thread.
1117            * tx queue 0 is bind with thread index 0, tx queue 1 on thread
1118            * index 1 and so on.
1119            * Multiple worker threads can poll same tx queue when number of
1120            * workers are more than tx queues. In this case, 1:N mapping
1121            * between tx queue and vpp worker thread.
1122            */
1123           virtio_log_debug (vif, "%s %u, %s", "tx-queue: number",
1124                             TX_QUEUE (i),
1125                             "no VPP worker thread is available");
1126           continue;
1127         }
1128
1129       if ((error = virtio_pci_vring_init (vm, vif, TX_QUEUE (i))))
1130         {
1131           args->rv = VNET_API_ERROR_INIT_FAILED;
1132           virtio_log_error (vif, "%s (%u) %s", "error in txq-queue",
1133                             TX_QUEUE (i), "initialization");
1134           clib_error_return (error, "%s (%u) %s", "error in txq-queue",
1135                              TX_QUEUE (i), "initialization");
1136         }
1137       else
1138         {
1139           vif->num_txqs++;
1140         }
1141     }
1142
1143   if (vif->features & VIRTIO_FEATURE (VIRTIO_NET_F_CTRL_VQ))
1144     {
1145       if ((error =
1146            virtio_pci_control_vring_init (vm, vif, vif->max_queue_pairs * 2)))
1147         {
1148           virtio_log_warning (vif, "%s (%u) %s", "error in control-queue",
1149                               vif->max_queue_pairs * 2, "initialization");
1150           if (vif->features & VIRTIO_FEATURE (VIRTIO_NET_F_MQ))
1151             vif->features &= ~VIRTIO_FEATURE (VIRTIO_NET_F_MQ);
1152         }
1153     }
1154   else
1155     {
1156       virtio_log_debug (vif, "control queue is not available");
1157       vif->cxq_vring = NULL;
1158     }
1159
1160   /*
1161    * set the msix interrupts
1162    */
1163   if (vif->msix_enabled == VIRTIO_MSIX_ENABLED)
1164     {
1165       if (virtio_pci_legacy_set_config_irq (vm, vif, 1) ==
1166           VIRTIO_MSI_NO_VECTOR)
1167         virtio_log_warning (vif, "config vector 1 is not set");
1168       if (virtio_pci_legacy_set_queue_irq (vm, vif, 0, 0) ==
1169           VIRTIO_MSI_NO_VECTOR)
1170         virtio_log_warning (vif, "queue vector 0 is not set");
1171     }
1172
1173   /*
1174    * set the driver status OK
1175    */
1176   virtio_pci_legacy_set_status (vm, vif, VIRTIO_CONFIG_STATUS_DRIVER_OK);
1177   vif->status = virtio_pci_legacy_get_status (vm, vif);
1178 err:
1179   return error;
1180 }
1181
1182 void
1183 virtio_pci_create_if (vlib_main_t * vm, virtio_pci_create_if_args_t * args)
1184 {
1185   vnet_main_t *vnm = vnet_get_main ();
1186   virtio_main_t *vim = &virtio_main;
1187   virtio_if_t *vif;
1188   vlib_pci_dev_handle_t h;
1189   clib_error_t *error = 0;
1190
1191   /* *INDENT-OFF* */
1192   pool_foreach (vif, vim->interfaces, ({
1193     if (vif->pci_addr.as_u32 == args->addr)
1194       {
1195         args->rv = VNET_API_ERROR_ADDRESS_IN_USE;
1196         args->error =
1197           clib_error_return (error, "PCI address in use");
1198           vlib_log (VLIB_LOG_LEVEL_ERR, vim->log_default, "%U: %s",
1199                 format_vlib_pci_addr, &args->addr,
1200                 " PCI address in use");
1201         return;
1202       }
1203   }));
1204   /* *INDENT-ON* */
1205
1206   pool_get (vim->interfaces, vif);
1207   vif->dev_instance = vif - vim->interfaces;
1208   vif->per_interface_next_index = ~0;
1209   vif->pci_addr.as_u32 = args->addr;
1210
1211   if ((error =
1212        vlib_pci_device_open (vm, (vlib_pci_addr_t *) & vif->pci_addr,
1213                              virtio_pci_device_ids, &h)))
1214     {
1215       args->rv = VNET_API_ERROR_INVALID_INTERFACE;
1216       args->error =
1217         clib_error_return (error, "pci-addr %U", format_vlib_pci_addr,
1218                            &vif->pci_addr);
1219       vlib_log (VLIB_LOG_LEVEL_ERR, vim->log_default, "%U: %s",
1220                 format_vlib_pci_addr, &vif->pci_addr,
1221                 "error encountered on pci device open");
1222       pool_put (vim->interfaces, vif);
1223       return;
1224     }
1225   vif->pci_dev_handle = h;
1226   vlib_pci_set_private_data (vm, h, vif->dev_instance);
1227   vif->numa_node = vlib_pci_get_numa_node (vm, h);
1228   vif->type = VIRTIO_IF_TYPE_PCI;
1229
1230   if ((error = vlib_pci_bus_master_enable (vm, h)))
1231     {
1232       virtio_log_error (vif, "error encountered on pci bus master enable");
1233       goto error;
1234     }
1235
1236   if ((error = vlib_pci_io_region (vm, h, 0)))
1237     {
1238       virtio_log_error (vif, "error encountered on pci io region");
1239       goto error;
1240     }
1241
1242   if (vlib_pci_get_num_msix_interrupts (vm, h) > 1)
1243     {
1244       if ((error = vlib_pci_register_msix_handler (vm, h, 0, 1,
1245                                                    &virtio_pci_irq_0_handler)))
1246         {
1247           args->rv = VNET_API_ERROR_INVALID_REGISTRATION;
1248           virtio_log_error (vif,
1249                             "error encountered on pci register msix handler 0");
1250           goto error;
1251         }
1252       if ((error = vlib_pci_register_msix_handler (vm, h, 1, 1,
1253                                                    &virtio_pci_irq_1_handler)))
1254         {
1255           args->rv = VNET_API_ERROR_INVALID_REGISTRATION;
1256           virtio_log_error (vif,
1257                             "error encountered on pci register msix handler 1");
1258           goto error;
1259         }
1260
1261       if ((error = vlib_pci_enable_msix_irq (vm, h, 0, 2)))
1262         {
1263           virtio_log_error (vif, "error encountered on pci enable msix irq");
1264           goto error;
1265         }
1266       vif->support_int_mode = 1;
1267       virtio_log_debug (vif, "device supports msix interrupts");
1268     }
1269   else if (vlib_pci_get_num_msix_interrupts (vm, h) == 1)
1270     {
1271       /*
1272        * if msix table-size is 1, fall back to intX.
1273        */
1274       if ((error =
1275            vlib_pci_register_intx_handler (vm, h, &virtio_pci_irq_handler)))
1276         {
1277           virtio_log_error (vif,
1278                             "error encountered on pci register interrupt handler");
1279           goto error;
1280         }
1281       vif->support_int_mode = 1;
1282       virtio_log_debug (vif, "pci register interrupt handler");
1283     }
1284   else
1285     {
1286       /*
1287        * WARN: intX is showing some weird behaviour.
1288        * Please don't use interrupt mode with UIO driver.
1289        */
1290       vif->support_int_mode = 0;
1291       virtio_log_debug (vif, "driver is configured in poll mode only");
1292     }
1293
1294   if ((error = vlib_pci_intr_enable (vm, h)))
1295     {
1296       virtio_log_error (vif, "error encountered on pci interrupt enable");
1297       goto error;
1298     }
1299
1300   if ((error = virtio_pci_device_init (vm, vif, args)))
1301     {
1302       virtio_log_error (vif, "error encountered on device init");
1303       goto error;
1304     }
1305
1306   /* create interface */
1307   error = ethernet_register_interface (vnm, virtio_device_class.index,
1308                                        vif->dev_instance, vif->mac_addr,
1309                                        &vif->hw_if_index,
1310                                        virtio_pci_flag_change);
1311
1312   if (error)
1313     {
1314       args->rv = VNET_API_ERROR_INVALID_REGISTRATION;
1315       virtio_log_error (vif,
1316                         "error encountered on ethernet register interface");
1317       goto error;
1318     }
1319
1320   vnet_sw_interface_t *sw = vnet_get_hw_sw_interface (vnm, vif->hw_if_index);
1321   vif->sw_if_index = sw->sw_if_index;
1322   args->sw_if_index = sw->sw_if_index;
1323
1324   vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, vif->hw_if_index);
1325   hw->flags |= VNET_HW_INTERFACE_FLAG_SUPPORTS_INT_MODE;
1326   vnet_hw_interface_set_input_node (vnm, vif->hw_if_index,
1327                                     virtio_input_node.index);
1328   u32 i = 0;
1329   vec_foreach_index (i, vif->rxq_vrings)
1330   {
1331     vnet_hw_interface_assign_rx_thread (vnm, vif->hw_if_index, i, ~0);
1332     virtio_vring_set_numa_node (vm, vif, RX_QUEUE (i));
1333     /* Set default rx mode to POLLING */
1334     vnet_hw_interface_set_rx_mode (vnm, vif->hw_if_index, i,
1335                                    VNET_HW_INTERFACE_RX_MODE_POLLING);
1336   }
1337   if (virtio_pci_is_link_up (vm, vif) & VIRTIO_NET_S_LINK_UP)
1338     {
1339       vif->flags |= VIRTIO_IF_FLAG_ADMIN_UP;
1340       vnet_hw_interface_set_flags (vnm, vif->hw_if_index,
1341                                    VNET_HW_INTERFACE_FLAG_LINK_UP);
1342     }
1343   else
1344     vnet_hw_interface_set_flags (vnm, vif->hw_if_index, 0);
1345
1346   virtio_pci_offloads (vm, vif, args->gso_enabled,
1347                        args->checksum_offload_enabled);
1348
1349   if ((vif->features & VIRTIO_FEATURE (VIRTIO_NET_F_CTRL_VQ)) &&
1350       (vif->features & VIRTIO_FEATURE (VIRTIO_NET_F_MQ)))
1351     {
1352       if (virtio_pci_enable_multiqueue (vm, vif, vif->max_queue_pairs))
1353         virtio_log_warning (vif, "multiqueue is not set");
1354     }
1355   return;
1356
1357 error:
1358   virtio_pci_delete_if (vm, vif);
1359   if (args->rv == 0)
1360     args->rv = VNET_API_ERROR_INVALID_INTERFACE;
1361   args->error = error;
1362 }
1363
1364 int
1365 virtio_pci_delete_if (vlib_main_t * vm, virtio_if_t * vif)
1366 {
1367   vnet_main_t *vnm = vnet_get_main ();
1368   virtio_main_t *vim = &virtio_main;
1369   u32 i = 0;
1370
1371   if (vif->type != VIRTIO_IF_TYPE_PCI)
1372     return VNET_API_ERROR_INVALID_INTERFACE;
1373
1374   vlib_pci_intr_disable (vm, vif->pci_dev_handle);
1375
1376   for (i = 0; i < vif->max_queue_pairs; i++)
1377     {
1378       virtio_pci_legacy_del_queue (vm, vif, RX_QUEUE (i));
1379       virtio_pci_legacy_del_queue (vm, vif, TX_QUEUE (i));
1380     }
1381
1382   if (vif->features & VIRTIO_FEATURE (VIRTIO_NET_F_CTRL_VQ))
1383     virtio_pci_legacy_del_queue (vm, vif, vif->max_queue_pairs * 2);
1384
1385   virtio_pci_legacy_reset (vm, vif);
1386
1387   if (vif->hw_if_index)
1388     {
1389       vnet_hw_interface_set_flags (vnm, vif->hw_if_index, 0);
1390       vec_foreach_index (i, vif->rxq_vrings)
1391       {
1392         vnet_hw_interface_unassign_rx_thread (vnm, vif->hw_if_index, i);
1393       }
1394       ethernet_delete_interface (vnm, vif->hw_if_index);
1395     }
1396
1397   vlib_pci_device_close (vm, vif->pci_dev_handle);
1398
1399   vec_foreach_index (i, vif->rxq_vrings)
1400   {
1401     virtio_vring_t *vring = vec_elt_at_index (vif->rxq_vrings, i);
1402     if (vring->kick_fd != -1)
1403       close (vring->kick_fd);
1404     if (vring->used)
1405       {
1406         virtio_free_rx_buffers (vm, vring);
1407       }
1408     vec_free (vring->buffers);
1409     vlib_physmem_free (vm, vring->desc);
1410   }
1411
1412   vec_foreach_index (i, vif->txq_vrings)
1413   {
1414     virtio_vring_t *vring = vec_elt_at_index (vif->txq_vrings, i);
1415     if (vring->kick_fd != -1)
1416       close (vring->kick_fd);
1417     if (vring->used)
1418       {
1419         virtio_free_used_desc (vm, vring);
1420       }
1421     vec_free (vring->buffers);
1422     clib_spinlock_free (&vring->lockp);
1423     vlib_physmem_free (vm, vring->desc);
1424   }
1425
1426   if (vif->cxq_vring != NULL)
1427     {
1428       u16 last = vif->cxq_vring->last_used_idx;
1429       u16 n_left = vif->cxq_vring->used->idx - last;
1430       while (n_left)
1431         {
1432           last++;
1433           n_left--;
1434         }
1435
1436       vif->cxq_vring->last_used_idx = last;
1437       vlib_physmem_free (vm, vif->cxq_vring->desc);
1438     }
1439
1440   vec_free (vif->rxq_vrings);
1441   vec_free (vif->txq_vrings);
1442   vec_free (vif->cxq_vring);
1443
1444   clib_error_free (vif->error);
1445   memset (vif, 0, sizeof (*vif));
1446   pool_put (vim->interfaces, vif);
1447
1448   return 0;
1449 }
1450
1451 int
1452 virtio_pci_enable_disable_offloads (vlib_main_t * vm, virtio_if_t * vif,
1453                                     int gso_enabled,
1454                                     int checksum_offload_enabled,
1455                                     int offloads_disabled)
1456 {
1457   if (vif->type != VIRTIO_IF_TYPE_PCI)
1458     return VNET_API_ERROR_INVALID_INTERFACE;
1459
1460   if (gso_enabled)
1461     virtio_pci_offloads (vm, vif, 1, 0);
1462   else if (checksum_offload_enabled)
1463     virtio_pci_offloads (vm, vif, 0, 1);
1464   else if (offloads_disabled)
1465     virtio_pci_offloads (vm, vif, 0, 0);
1466
1467   return 0;
1468 }
1469
1470 /*
1471  * fd.io coding-style-patch-verification: ON
1472  *
1473  * Local Variables:
1474  * eval: (c-set-style "gnu")
1475  * End:
1476  */