Line data    Source code

       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             : /*
      16             :  * pg_output.c: packet generator output
      17             :  *
      18             :  * Copyright (c) 2008 Eliot Dresselhaus
      19             :  *
      20             :  * Permission is hereby granted, free of charge, to any person obtaining
      21             :  * a copy of this software and associated documentation files (the
      22             :  * "Software"), to deal in the Software without restriction, including
      23             :  * without limitation the rights to use, copy, modify, merge, publish,
      24             :  * distribute, sublicense, and/or sell copies of the Software, and to
      25             :  * permit persons to whom the Software is furnished to do so, subject to
      26             :  * the following conditions:
      27             :  *
      28             :  * The above copyright notice and this permission notice shall be
      29             :  * included in all copies or substantial portions of the Software.
      30             :  *
      31             :  *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
      32             :  *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
      33             :  *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
      34             :  *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
      35             :  *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
      36             :  *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
      37             :  *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
      38             :  */
      39             : 
      40             : #include <vppinfra/string.h>
      41             : #include <vlib/vlib.h>
      42             : #include <vnet/vnet.h>
      43             : #include <vnet/pg/pg.h>
      44             : #include <vnet/ethernet/ethernet.h>
      45             : #include <vnet/gso/gro_func.h>
      46             : 
      47             : uword
      48       17496 : pg_output (vlib_main_t * vm, vlib_node_runtime_t * node, vlib_frame_t * frame)
      49       17496 : {
      50       17496 :   pg_main_t *pg = &pg_main;
      51       17496 :   u32 *buffers = vlib_frame_vector_args (frame);
      52       17496 :   uword n_buffers = frame->n_vectors;
      53       17496 :   uword n_left = n_buffers;
      54       17496 :   u32 to[GRO_TO_VECTOR_SIZE (n_buffers)];
      55       17496 :   uword n_to = 0;
      56       17496 :   vnet_interface_output_runtime_t *rd = (void *) node->runtime_data;
      57       17496 :   pg_interface_t *pif = pool_elt_at_index (pg->interfaces, rd->dev_instance);
      58             : 
      59       17496 :   if (PREDICT_FALSE (pif->lockp != 0))
      60      259307 :     while (clib_atomic_test_and_set (pif->lockp))
      61             :       ;
      62             : 
      63       17496 :   if (PREDICT_FALSE (pif->coalesce_enabled))
      64             :     {
      65          11 :       n_to = vnet_gro_inline (vm, pif->flow_table, buffers, n_left, to);
      66          11 :       buffers = to;
      67          11 :       n_left = n_to;
      68             :     }
      69             : 
      70      527672 :   while (n_left > 0)
      71             :     {
      72      510176 :       n_left--;
      73      510176 :       u32 bi0 = buffers[0];
      74      510176 :       vlib_buffer_t *b = vlib_get_buffer (vm, bi0);
      75      510176 :       buffers++;
      76             : 
      77      510176 :       if (b->flags & VLIB_BUFFER_IS_TRACED)
      78             :         {
      79      483518 :           pg_output_trace_t *t = vlib_add_trace (vm, node, b, sizeof (*t));
      80      483518 :           t->buffer_index = bi0;
      81      483518 :           clib_memcpy_fast (&t->buffer, b,
      82             :                             sizeof (b[0]) - sizeof (b->pre_data));
      83      483518 :           clib_memcpy_fast (t->buffer.pre_data, b->data + b->current_data,
      84             :                             sizeof (t->buffer.pre_data));
      85             :         }
      86             : 
      87      510176 :       if (pif->pcap_file_name != 0)
      88      509608 :         pcap_add_buffer (&pif->pcap_main, vm, bi0, ETHERNET_MAX_PACKET_BYTES);
      89             :     }
      90       17496 :   if (pif->pcap_file_name != 0)
      91       17380 :     pcap_write (&pif->pcap_main);
      92       17496 :   if ((pif->pcap_main.flags & PCAP_MAIN_INIT_DONE)
      93       17380 :       && pif->pcap_main.n_packets_captured >=
      94       17380 :       pif->pcap_main.n_packets_to_capture)
      95           0 :     pcap_close (&pif->pcap_main);
      96             : 
      97       17496 :   if (PREDICT_FALSE (pif->coalesce_enabled))
      98             :     {
      99          11 :       n_buffers = n_to;
     100          11 :       vlib_buffer_free (vm, to, n_to);
     101             :     }
     102             :   else
     103       17485 :     vlib_buffer_free (vm, vlib_frame_vector_args (frame), n_buffers);
     104       17496 :   if (PREDICT_FALSE (pif->lockp != 0))
     105         975 :     clib_atomic_release (pif->lockp);
     106             : 
     107       17496 :   return n_buffers;
     108             : }
     109             : 
     110             : /*
     111             :  * fd.io coding-style-patch-verification: ON
     112             :  *
     113             :  * Local Variables:
     114             :  * eval: (c-set-style "gnu")
     115             :  * End:
     116             :  */