FD.io VPP  v18.10-34-gcce845e
Vector Packet Processing
vhost_user_output.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * vhost-user-output
4  *
5  * Copyright (c) 2014-2018 Cisco and/or its affiliates.
6  * Licensed under the Apache License, Version 2.0 (the "License");
7  * you may not use this file except in compliance with the License.
8  * You may obtain a copy of the License at:
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  *------------------------------------------------------------------
18  */
19 
20 #include <fcntl.h> /* for open */
21 #include <sys/ioctl.h>
22 #include <sys/socket.h>
23 #include <sys/un.h>
24 #include <sys/stat.h>
25 #include <sys/types.h>
26 #include <sys/uio.h> /* for iovec */
27 #include <netinet/in.h>
28 #include <sys/vfs.h>
29 
30 #include <linux/if_arp.h>
31 #include <linux/if_tun.h>
32 
33 #include <vlib/vlib.h>
34 #include <vlib/unix/unix.h>
35 
36 #include <vnet/ip/ip.h>
37 
38 #include <vnet/ethernet/ethernet.h>
39 #include <vnet/devices/devices.h>
40 #include <vnet/feature/feature.h>
41 
44 
45 /*
46  * On the transmit side, we keep processing the buffers from vlib in the while
47  * loop and prepare the copy order to be executed later. However, the static
48  * array which we keep the copy order is limited to VHOST_USER_COPY_ARRAY_N
49  * entries. In order to not corrupt memory, we have to do the copy when the
50  * static array reaches the copy threshold. We subtract 40 in case the code
51  * goes into the inner loop for a maximum of 64k frames which may require
52  * more array entries.
53  */
54 #define VHOST_USER_TX_COPY_THRESHOLD (VHOST_USER_COPY_ARRAY_N - 40)
55 
57 
58 #define foreach_vhost_user_tx_func_error \
59  _(NONE, "no error") \
60  _(NOT_READY, "vhost vring not ready") \
61  _(DOWN, "vhost interface is down") \
62  _(PKT_DROP_NOBUF, "tx packet drops (no available descriptors)") \
63  _(PKT_DROP_NOMRG, "tx packet drops (cannot merge descriptors)") \
64  _(MMAP_FAIL, "mmap failure") \
65  _(INDIRECT_OVERFLOW, "indirect descriptor table overflow")
66 
67 typedef enum
68 {
69 #define _(f,s) VHOST_USER_TX_FUNC_ERROR_##f,
71 #undef _
74 
75 static __clib_unused char *vhost_user_tx_func_error_strings[] = {
76 #define _(n,s) s,
78 #undef _
79 };
80 
81 static __clib_unused u8 *
82 format_vhost_user_interface_name (u8 * s, va_list * args)
83 {
84  u32 i = va_arg (*args, u32);
85  u32 show_dev_instance = ~0;
87 
89  show_dev_instance = vum->show_dev_instance_by_real_dev_instance[i];
90 
91  if (show_dev_instance != ~0)
92  i = show_dev_instance;
93 
94  s = format (s, "VirtualEthernet0/0/%d", i);
95  return s;
96 }
97 
98 static __clib_unused int
100 {
101  // FIXME: check if the new dev instance is already used
104  hi->dev_instance);
105 
107  hi->dev_instance, ~0);
108 
110  new_dev_instance;
111 
112  vu_log_debug (vui, "renumbered vhost-user interface dev_instance %d to %d",
113  hi->dev_instance, new_dev_instance);
114 
115  return 0;
116 }
117 
118 /**
119  * @brief Try once to lock the vring
120  * @return 0 on success, non-zero on failure.
121  */
124 {
125  return __sync_lock_test_and_set (vui->vring_locks[qid], 1);
126 }
127 
128 /**
129  * @brief Spin until the vring is successfully locked
130  */
133 {
134  while (vhost_user_vring_try_lock (vui, qid))
135  ;
136 }
137 
138 /**
139  * @brief Unlock the vring lock
140  */
143 {
144  *vui->vring_locks[qid] = 0;
145 }
146 
149  vhost_user_intf_t * vui, u16 qid,
150  vlib_buffer_t * b, vhost_user_vring_t * rxvq)
151 {
153  u32 last_avail_idx = rxvq->last_avail_idx;
154  u32 desc_current = rxvq->avail->ring[last_avail_idx & rxvq->qsz_mask];
155  vring_desc_t *hdr_desc = 0;
156  u32 hint = 0;
157 
158  memset (t, 0, sizeof (*t));
159  t->device_index = vui - vum->vhost_user_interfaces;
160  t->qid = qid;
161 
162  hdr_desc = &rxvq->desc[desc_current];
163  if (rxvq->desc[desc_current].flags & VIRTQ_DESC_F_INDIRECT)
164  {
165  t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_INDIRECT;
166  /* Header is the first here */
167  hdr_desc = map_guest_mem (vui, rxvq->desc[desc_current].addr, &hint);
168  }
169  if (rxvq->desc[desc_current].flags & VIRTQ_DESC_F_NEXT)
170  {
171  t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_SIMPLE_CHAINED;
172  }
173  if (!(rxvq->desc[desc_current].flags & VIRTQ_DESC_F_NEXT) &&
174  !(rxvq->desc[desc_current].flags & VIRTQ_DESC_F_INDIRECT))
175  {
176  t->virtio_ring_flags |= 1 << VIRTIO_TRACE_F_SINGLE_DESC;
177  }
178 
179  t->first_desc_len = hdr_desc ? hdr_desc->len : 0;
180 }
181 
184  u16 copy_len, u32 * map_hint)
185 {
186  void *dst0, *dst1, *dst2, *dst3;
187  if (PREDICT_TRUE (copy_len >= 4))
188  {
189  if (PREDICT_FALSE (!(dst2 = map_guest_mem (vui, cpy[0].dst, map_hint))))
190  return 1;
191  if (PREDICT_FALSE (!(dst3 = map_guest_mem (vui, cpy[1].dst, map_hint))))
192  return 1;
193  while (PREDICT_TRUE (copy_len >= 4))
194  {
195  dst0 = dst2;
196  dst1 = dst3;
197 
198  if (PREDICT_FALSE
199  (!(dst2 = map_guest_mem (vui, cpy[2].dst, map_hint))))
200  return 1;
201  if (PREDICT_FALSE
202  (!(dst3 = map_guest_mem (vui, cpy[3].dst, map_hint))))
203  return 1;
204 
205  CLIB_PREFETCH ((void *) cpy[2].src, 64, LOAD);
206  CLIB_PREFETCH ((void *) cpy[3].src, 64, LOAD);
207 
208  clib_memcpy (dst0, (void *) cpy[0].src, cpy[0].len);
209  clib_memcpy (dst1, (void *) cpy[1].src, cpy[1].len);
210 
211  vhost_user_log_dirty_pages_2 (vui, cpy[0].dst, cpy[0].len, 1);
212  vhost_user_log_dirty_pages_2 (vui, cpy[1].dst, cpy[1].len, 1);
213  copy_len -= 2;
214  cpy += 2;
215  }
216  }
217  while (copy_len)
218  {
219  if (PREDICT_FALSE (!(dst0 = map_guest_mem (vui, cpy->dst, map_hint))))
220  return 1;
221  clib_memcpy (dst0, (void *) cpy->src, cpy->len);
222  vhost_user_log_dirty_pages_2 (vui, cpy->dst, cpy->len, 1);
223  copy_len -= 1;
224  cpy += 1;
225  }
226  return 0;
227 }
228 
231  node, vlib_frame_t * frame)
232 {
233  u32 *buffers = vlib_frame_args (frame);
234  u32 n_left = frame->n_vectors;
236  vnet_interface_output_runtime_t *rd = (void *) node->runtime_data;
237  vhost_user_intf_t *vui =
239  u32 qid = ~0;
240  vhost_user_vring_t *rxvq;
241  u8 error;
242  u32 thread_index = vm->thread_index;
243  u32 map_hint = 0;
244  u8 retry = 8;
245  u16 copy_len;
246  u16 tx_headers_len;
247 
248  if (PREDICT_FALSE (!vui->admin_up))
249  {
250  error = VHOST_USER_TX_FUNC_ERROR_DOWN;
251  goto done3;
252  }
253 
254  if (PREDICT_FALSE (!vui->is_ready))
255  {
256  error = VHOST_USER_TX_FUNC_ERROR_NOT_READY;
257  goto done3;
258  }
259 
260  qid =
262  (vui->per_cpu_tx_qid, thread_index));
263  rxvq = &vui->vrings[qid];
264  if (PREDICT_FALSE (vui->use_tx_spinlock))
265  vhost_user_vring_lock (vui, qid);
266 
267 retry:
268  error = VHOST_USER_TX_FUNC_ERROR_NONE;
269  tx_headers_len = 0;
270  copy_len = 0;
271  while (n_left > 0)
272  {
273  vlib_buffer_t *b0, *current_b0;
274  u16 desc_head, desc_index, desc_len;
275  vring_desc_t *desc_table;
276  uword buffer_map_addr;
277  u32 buffer_len;
278  u16 bytes_left;
279 
280  if (PREDICT_TRUE (n_left > 1))
281  vlib_prefetch_buffer_with_index (vm, buffers[1], LOAD);
282 
283  b0 = vlib_get_buffer (vm, buffers[0]);
284 
285  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
286  {
287  vum->cpus[thread_index].current_trace =
288  vlib_add_trace (vm, node, b0,
289  sizeof (*vum->cpus[thread_index].current_trace));
290  vhost_user_tx_trace (vum->cpus[thread_index].current_trace,
291  vui, qid / 2, b0, rxvq);
292  }
293 
294  if (PREDICT_FALSE (rxvq->last_avail_idx == rxvq->avail->idx))
295  {
296  error = VHOST_USER_TX_FUNC_ERROR_PKT_DROP_NOBUF;
297  goto done;
298  }
299 
300  desc_table = rxvq->desc;
301  desc_head = desc_index =
302  rxvq->avail->ring[rxvq->last_avail_idx & rxvq->qsz_mask];
303 
304  /* Go deeper in case of indirect descriptor
305  * I don't know of any driver providing indirect for RX. */
306  if (PREDICT_FALSE (rxvq->desc[desc_head].flags & VIRTQ_DESC_F_INDIRECT))
307  {
308  if (PREDICT_FALSE
309  (rxvq->desc[desc_head].len < sizeof (vring_desc_t)))
310  {
311  error = VHOST_USER_TX_FUNC_ERROR_INDIRECT_OVERFLOW;
312  goto done;
313  }
314  if (PREDICT_FALSE
315  (!(desc_table =
316  map_guest_mem (vui, rxvq->desc[desc_index].addr,
317  &map_hint))))
318  {
319  error = VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL;
320  goto done;
321  }
322  desc_index = 0;
323  }
324 
325  desc_len = vui->virtio_net_hdr_sz;
326  buffer_map_addr = desc_table[desc_index].addr;
327  buffer_len = desc_table[desc_index].len;
328 
329  {
330  // Get a header from the header array
331  virtio_net_hdr_mrg_rxbuf_t *hdr =
332  &vum->cpus[thread_index].tx_headers[tx_headers_len];
333  tx_headers_len++;
334  hdr->hdr.flags = 0;
335  hdr->hdr.gso_type = 0;
336  hdr->num_buffers = 1; //This is local, no need to check
337 
338  // Prepare a copy order executed later for the header
339  vhost_copy_t *cpy = &vum->cpus[thread_index].copy[copy_len];
340  copy_len++;
341  cpy->len = vui->virtio_net_hdr_sz;
342  cpy->dst = buffer_map_addr;
343  cpy->src = (uword) hdr;
344  }
345 
346  buffer_map_addr += vui->virtio_net_hdr_sz;
347  buffer_len -= vui->virtio_net_hdr_sz;
348  bytes_left = b0->current_length;
349  current_b0 = b0;
350  while (1)
351  {
352  if (buffer_len == 0)
353  { //Get new output
354  if (desc_table[desc_index].flags & VIRTQ_DESC_F_NEXT)
355  {
356  //Next one is chained
357  desc_index = desc_table[desc_index].next;
358  buffer_map_addr = desc_table[desc_index].addr;
359  buffer_len = desc_table[desc_index].len;
360  }
361  else if (vui->virtio_net_hdr_sz == 12) //MRG is available
362  {
363  virtio_net_hdr_mrg_rxbuf_t *hdr =
364  &vum->cpus[thread_index].tx_headers[tx_headers_len - 1];
365 
366  //Move from available to used buffer
367  rxvq->used->ring[rxvq->last_used_idx & rxvq->qsz_mask].id =
368  desc_head;
369  rxvq->used->ring[rxvq->last_used_idx & rxvq->qsz_mask].len =
370  desc_len;
371  vhost_user_log_dirty_ring (vui, rxvq,
372  ring[rxvq->last_used_idx &
373  rxvq->qsz_mask]);
374 
375  rxvq->last_avail_idx++;
376  rxvq->last_used_idx++;
377  hdr->num_buffers++;
378  desc_len = 0;
379 
380  if (PREDICT_FALSE
381  (rxvq->last_avail_idx == rxvq->avail->idx))
382  {
383  //Dequeue queued descriptors for this packet
384  rxvq->last_used_idx -= hdr->num_buffers - 1;
385  rxvq->last_avail_idx -= hdr->num_buffers - 1;
386  error = VHOST_USER_TX_FUNC_ERROR_PKT_DROP_NOBUF;
387  goto done;
388  }
389 
390  desc_table = rxvq->desc;
391  desc_head = desc_index =
392  rxvq->avail->ring[rxvq->last_avail_idx & rxvq->qsz_mask];
393  if (PREDICT_FALSE
394  (rxvq->desc[desc_head].flags & VIRTQ_DESC_F_INDIRECT))
395  {
396  //It is seriously unlikely that a driver will put indirect descriptor
397  //after non-indirect descriptor.
398  if (PREDICT_FALSE
399  (rxvq->desc[desc_head].len < sizeof (vring_desc_t)))
400  {
401  error = VHOST_USER_TX_FUNC_ERROR_INDIRECT_OVERFLOW;
402  goto done;
403  }
404  if (PREDICT_FALSE
405  (!(desc_table =
406  map_guest_mem (vui,
407  rxvq->desc[desc_index].addr,
408  &map_hint))))
409  {
410  error = VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL;
411  goto done;
412  }
413  desc_index = 0;
414  }
415  buffer_map_addr = desc_table[desc_index].addr;
416  buffer_len = desc_table[desc_index].len;
417  }
418  else
419  {
420  error = VHOST_USER_TX_FUNC_ERROR_PKT_DROP_NOMRG;
421  goto done;
422  }
423  }
424 
425  {
426  vhost_copy_t *cpy = &vum->cpus[thread_index].copy[copy_len];
427  copy_len++;
428  cpy->len = bytes_left;
429  cpy->len = (cpy->len > buffer_len) ? buffer_len : cpy->len;
430  cpy->dst = buffer_map_addr;
431  cpy->src = (uword) vlib_buffer_get_current (current_b0) +
432  current_b0->current_length - bytes_left;
433 
434  bytes_left -= cpy->len;
435  buffer_len -= cpy->len;
436  buffer_map_addr += cpy->len;
437  desc_len += cpy->len;
438 
439  CLIB_PREFETCH (&rxvq->desc, CLIB_CACHE_LINE_BYTES, LOAD);
440  }
441 
442  // Check if vlib buffer has more data. If not, get more or break.
443  if (PREDICT_TRUE (!bytes_left))
444  {
445  if (PREDICT_FALSE
446  (current_b0->flags & VLIB_BUFFER_NEXT_PRESENT))
447  {
448  current_b0 = vlib_get_buffer (vm, current_b0->next_buffer);
449  bytes_left = current_b0->current_length;
450  }
451  else
452  {
453  //End of packet
454  break;
455  }
456  }
457  }
458 
459  //Move from available to used ring
460  rxvq->used->ring[rxvq->last_used_idx & rxvq->qsz_mask].id = desc_head;
461  rxvq->used->ring[rxvq->last_used_idx & rxvq->qsz_mask].len = desc_len;
462  vhost_user_log_dirty_ring (vui, rxvq,
463  ring[rxvq->last_used_idx & rxvq->qsz_mask]);
464  rxvq->last_avail_idx++;
465  rxvq->last_used_idx++;
466 
467  if (PREDICT_FALSE (b0->flags & VLIB_BUFFER_IS_TRACED))
468  {
469  vum->cpus[thread_index].current_trace->hdr =
470  vum->cpus[thread_index].tx_headers[tx_headers_len - 1];
471  }
472 
473  n_left--; //At the end for error counting when 'goto done' is invoked
474 
475  /*
476  * Do the copy periodically to prevent
477  * vum->cpus[thread_index].copy array overflow and corrupt memory
478  */
480  {
481  if (PREDICT_FALSE
482  (vhost_user_tx_copy (vui, vum->cpus[thread_index].copy,
483  copy_len, &map_hint)))
484  {
485  vlib_error_count (vm, node->node_index,
486  VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL, 1);
487  }
488  copy_len = 0;
489 
490  /* give buffers back to driver */
492  rxvq->used->idx = rxvq->last_used_idx;
493  vhost_user_log_dirty_ring (vui, rxvq, idx);
494  }
495  buffers++;
496  }
497 
498 done:
499  //Do the memory copies
500  if (PREDICT_FALSE
501  (vhost_user_tx_copy (vui, vum->cpus[thread_index].copy,
502  copy_len, &map_hint)))
503  {
504  vlib_error_count (vm, node->node_index,
505  VHOST_USER_TX_FUNC_ERROR_MMAP_FAIL, 1);
506  }
507 
509  rxvq->used->idx = rxvq->last_used_idx;
510  vhost_user_log_dirty_ring (vui, rxvq, idx);
511 
512  /*
513  * When n_left is set, error is always set to something too.
514  * In case error is due to lack of remaining buffers, we go back up and
515  * retry.
516  * The idea is that it is better to waste some time on packets
517  * that have been processed already than dropping them and get
518  * more fresh packets with a good likelyhood that they will be dropped too.
519  * This technique also gives more time to VM driver to pick-up packets.
520  * In case the traffic flows from physical to virtual interfaces, this
521  * technique will end-up leveraging the physical NIC buffer in order to
522  * absorb the VM's CPU jitter.
523  */
524  if (n_left && (error == VHOST_USER_TX_FUNC_ERROR_PKT_DROP_NOBUF) && retry)
525  {
526  retry--;
527  goto retry;
528  }
529 
530  /* interrupt (call) handling */
531  if ((rxvq->callfd_idx != ~0) &&
532  !(rxvq->avail->flags & VRING_AVAIL_F_NO_INTERRUPT))
533  {
534  rxvq->n_since_last_int += frame->n_vectors - n_left;
535 
536  if (rxvq->n_since_last_int > vum->coalesce_frames)
537  vhost_user_send_call (vm, rxvq);
538  }
539 
540  vhost_user_vring_unlock (vui, qid);
541 
542 done3:
543  if (PREDICT_FALSE (n_left && error != VHOST_USER_TX_FUNC_ERROR_NONE))
544  {
545  vlib_error_count (vm, node->node_index, error, n_left);
549  thread_index, vui->sw_if_index, n_left);
550  }
551 
552  vlib_buffer_free (vm, vlib_frame_args (frame), frame->n_vectors);
553  return frame->n_vectors;
554 }
555 
556 static __clib_unused clib_error_t *
558  u32 qid, vnet_hw_interface_rx_mode mode)
559 {
560  vlib_main_t *vm = vnm->vlib_main;
561  vnet_hw_interface_t *hif = vnet_get_hw_interface (vnm, hw_if_index);
563  vhost_user_intf_t *vui =
565  vhost_user_vring_t *txvq = &vui->vrings[VHOST_VRING_IDX_TX (qid)];
566 
567  if ((mode == VNET_HW_INTERFACE_RX_MODE_INTERRUPT) ||
569  {
570  if (txvq->kickfd_idx == ~0)
571  {
572  // We cannot support interrupt mode if the driver opts out
573  return clib_error_return (0, "Driver does not support interrupt");
574  }
576  {
577  vum->ifq_count++;
578  // Start the timer if this is the first encounter on interrupt
579  // interface/queue
580  if ((vum->ifq_count == 1) &&
581  (vum->coalesce_time > 0.0) && (vum->coalesce_frames > 0))
585  }
586  }
587  else if (mode == VNET_HW_INTERFACE_RX_MODE_POLLING)
588  {
589  if (((txvq->mode == VNET_HW_INTERFACE_RX_MODE_INTERRUPT) ||
591  vum->ifq_count)
592  {
593  vum->ifq_count--;
594  // Stop the timer if there is no more interrupt interface/queue
595  if ((vum->ifq_count == 0) &&
596  (vum->coalesce_time > 0.0) && (vum->coalesce_frames > 0))
600  }
601  }
602 
603  txvq->mode = mode;
605  txvq->used->flags = VRING_USED_F_NO_NOTIFY;
606  else if ((mode == VNET_HW_INTERFACE_RX_MODE_ADAPTIVE) ||
608  txvq->used->flags = 0;
609  else
610  {
611  vu_log_err (vui, "unhandled mode %d changed for if %d queue %d", mode,
612  hw_if_index, qid);
613  return clib_error_return (0, "unsupported");
614  }
615 
616  return 0;
617 }
618 
619 static __clib_unused clib_error_t *
621  u32 flags)
622 {
623  vnet_hw_interface_t *hif = vnet_get_hw_interface (vnm, hw_if_index);
625  vhost_user_intf_t *vui =
627  u8 link_old, link_new;
628 
629  link_old = vui_is_link_up (vui);
630 
631  vui->admin_up = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0;
632 
633  link_new = vui_is_link_up (vui);
634 
635  if (link_old != link_new)
636  vnet_hw_interface_set_flags (vnm, vui->hw_if_index, link_new ?
638 
639  return /* no error */ 0;
640 }
641 
642 /* *INDENT-OFF* */
644  .name = "vhost-user",
645  .tx_function_n_errors = VHOST_USER_TX_FUNC_N_ERROR,
646  .tx_function_error_strings = vhost_user_tx_func_error_strings,
647  .format_device_name = format_vhost_user_interface_name,
648  .name_renumber = vhost_user_name_renumber,
649  .admin_up_down_function = vhost_user_interface_admin_up_down,
650  .rx_mode_change_function = vhost_user_interface_rx_mode_change,
651  .format_tx_trace = format_vhost_trace,
652 };
653 
654 /* *INDENT-ON* */
655 
656 /*
657  * fd.io coding-style-patch-verification: ON
658  *
659  * Local Variables:
660  * eval: (c-set-style "gnu")
661  * End:
662  */
static __clib_unused u8 * format_vhost_user_interface_name(u8 *s, va_list *args)
static __clib_unused int vhost_user_name_renumber(vnet_hw_interface_t *hi, u32 new_dev_instance)
vmrglw vmrglh hi
static __clib_unused clib_error_t * vhost_user_interface_admin_up_down(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
static_always_inline int vhost_user_vring_try_lock(vhost_user_intf_t *vui, u32 qid)
Try once to lock the vring.
vl_api_address_t src
Definition: vxlan_gbp.api:33
vring_desc_t * desc
Definition: vhost_user.h:237
u32 virtio_ring_flags
The device index.
Definition: vhost_user.h:317
virtio_net_hdr_mrg_rxbuf_t hdr
Length of the first data descriptor.
Definition: vhost_user.h:319
clib_error_t * vnet_hw_interface_set_flags(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: interface.c:469
vhost_cpu_t * cpus
Per-CPU data for vhost-user.
Definition: vhost_user.h:350
static void vlib_buffer_free(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Free buffers Frees the entire buffer chain for each buffer.
Definition: buffer_funcs.h:547
vhost_user_tx_func_error_t
#define foreach_vhost_user_tx_func_error
vnet_interface_main_t interface_main
Definition: vnet.h:56
#define PREDICT_TRUE(x)
Definition: clib.h:108
static __clib_unused char * vhost_user_tx_func_error_strings[]
static void vlib_error_count(vlib_main_t *vm, uword node_index, uword counter, uword increment)
Definition: error_funcs.h:57
#define VHOST_USER_TX_COPY_THRESHOLD
vhost_copy_t copy[VHOST_USER_COPY_ARRAY_N]
Definition: vhost_user.h:332
vring_avail_t * avail
Definition: vhost_user.h:238
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
u32 thread_index
Definition: main.h:179
int i
#define VHOST_USER_EVENT_START_TIMER
Definition: vhost_user.h:263
#define VRING_AVAIL_F_NO_INTERRUPT
Definition: vhost_user.h:46
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
static void vlib_increment_simple_counter(vlib_simple_counter_main_t *cm, u32 thread_index, u32 index, u64 increment)
Increment a simple counter.
Definition: counter.h:78
#define VNET_HW_INTERFACE_FLAG_LINK_UP
Definition: interface.h:494
static_always_inline void vhost_user_vring_lock(vhost_user_intf_t *vui, u32 qid)
Spin until the vring is successfully locked.
struct _vnet_device_class vnet_device_class_t
vring_used_t * used
Definition: vhost_user.h:239
vhost_trace_t * current_trace
Definition: vhost_user.h:336
unsigned char u8
Definition: types.h:56
#define vu_log_debug(dev, f,...)
Definition: vhost_user.h:48
vnet_hw_interface_rx_mode
Definition: interface.h:51
memset(h->entries, 0, sizeof(h->entries[0])*entries)
#define static_always_inline
Definition: clib.h:95
#define vlib_prefetch_buffer_with_index(vm, bi, type)
Prefetch buffer metadata by buffer index The first 64 bytes of buffer contains most header informatio...
Definition: buffer_funcs.h:337
static_always_inline u32 vhost_user_tx_copy(vhost_user_intf_t *vui, vhost_copy_t *cpy, u16 copy_len, u32 *map_hint)
static_always_inline void * map_guest_mem(vhost_user_intf_t *vui, uword addr, u32 *hint)
#define VHOST_VRING_IDX_TX(qid)
Definition: vhost_user.h:24
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
#define VRING_USED_F_NO_NOTIFY
Definition: vhost_user.h:45
#define clib_error_return(e, args...)
Definition: error.h:99
static_always_inline u8 * format_vhost_trace(u8 *s, va_list *va)
#define VNET_DEVICE_CLASS_TX_FN(devclass)
Definition: interface.h:286
unsigned int u32
Definition: types.h:88
VNET_DEVICE_CLASS(vhost_user_device_class)
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:464
vlib_main_t * vlib_main
Definition: vnet.h:80
u16 current_length
Nbytes between current data and the end of this buffer.
Definition: buffer.h:113
static void vlib_process_signal_event(vlib_main_t *vm, uword node_index, uword type_opaque, uword data)
Definition: node_funcs.h:960
unsigned short u16
Definition: types.h:57
#define VIRTQ_DESC_F_INDIRECT
Definition: vhost_user.h:28
static void * vlib_buffer_get_current(vlib_buffer_t *b)
Get pointer to current data to process.
Definition: buffer.h:205
#define PREDICT_FALSE(x)
Definition: clib.h:107
vhost_user_main_t vhost_user_main
Definition: vhost_user.c:56
vnet_main_t vnet_main
Definition: misc.c:43
vlib_simple_counter_main_t * sw_if_counters
Definition: interface.h:854
static_always_inline void vhost_user_vring_unlock(vhost_user_intf_t *vui, u32 qid)
Unlock the vring lock.
static_always_inline u8 vui_is_link_up(vhost_user_intf_t *vui)
u32 flags
Definition: vhost_user.h:115
#define VHOST_VRING_IDX_RX(qid)
Definition: vhost_user.h:23
vnet_device_class_t vhost_user_device_class
u32 * show_dev_instance_by_real_dev_instance
Definition: vhost_user.h:344
u16 device_index
The interface queue index (Not the virtio vring idx)
Definition: vhost_user.h:316
vhost_user_intf_t * vhost_user_interfaces
Definition: vhost_user.h:343
#define CLIB_PREFETCH(addr, size, type)
Definition: cache.h:79
vlib_main_t * vm
Definition: buffer.c:294
vl_api_address_t dst
Definition: vxlan_gbp.api:34
static __clib_unused clib_error_t * vhost_user_interface_rx_mode_change(vnet_main_t *vnm, u32 hw_if_index, u32 qid, vnet_hw_interface_rx_mode mode)
#define VHOST_USER_EVENT_STOP_TIMER
Definition: vhost_user.h:264
#define clib_memcpy(a, b, c)
Definition: string.h:75
u16 first_desc_len
Runtime queue flags.
Definition: vhost_user.h:318
#define vu_log_err(dev, f,...)
Definition: vhost_user.h:61
#define VIRTQ_DESC_F_NEXT
Definition: vhost_user.h:27
static_always_inline void vhost_user_send_call(vlib_main_t *vm, vhost_user_vring_t *vq)
u32 next_buffer
Next buffer for this linked-list of buffers.
Definition: buffer.h:129
volatile u32 * vring_locks[VHOST_VRING_MAX_N]
Definition: vhost_user.h:293
static void * vlib_frame_args(vlib_frame_t *f)
Get pointer to frame scalar data.
Definition: node_funcs.h:284
vlib_node_registration_t vhost_user_send_interrupt_node
(constructor) VLIB_REGISTER_NODE (vhost_user_send_interrupt_node)
Definition: vhost_user.c:53
static_always_inline void vhost_user_tx_trace(vhost_trace_t *t, vhost_user_intf_t *vui, u16 qid, vlib_buffer_t *b, vhost_user_vring_t *rxvq)
static void * vlib_add_trace(vlib_main_t *vm, vlib_node_runtime_t *r, vlib_buffer_t *b, u32 n_data_bytes)
Definition: trace_funcs.h:57
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
vhost_user_vring_t vrings[VHOST_VRING_MAX_N]
Definition: vhost_user.h:292
u64 uword
Definition: types.h:112
static_always_inline void vhost_user_log_dirty_pages_2(vhost_user_intf_t *vui, u64 addr, u64 len, u8 is_host_address)
#define vhost_user_log_dirty_ring(vui, vq, member)
#define CLIB_MEMORY_BARRIER()
Definition: clib.h:111
virtio_net_hdr_mrg_rxbuf_t tx_headers[VLIB_FRAME_SIZE]
Definition: vhost_user.h:331
#define vec_validate_init_empty(V, I, INIT)
Make sure vector is long enough for given index and initialize empty space (no header, unspecified alignment)
Definition: vec.h:486
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
u32 flags
buffer flags: VLIB_BUFFER_FREE_LIST_INDEX_MASK: bits used to store free list index, VLIB_BUFFER_IS_TRACED: trace this buffer.
Definition: buffer.h:116
static vlib_buffer_t * vlib_get_buffer(vlib_main_t *vm, u32 buffer_index)
Translate buffer index into buffer pointer.
Definition: buffer_funcs.h:58