LCOV - code coverage report
Current view: top level - plugins/rdma - test_api.c (source / functions) Hit Total Coverage
Test: coverage-filtered.info Lines: 0 127 0.0 %
Date: 2023-07-05 22:20:52 Functions: 0 10 0.0 %

          Line data    Source code
       1             : /*
       2             :  *------------------------------------------------------------------
       3             :  * Copyright (c) 2019 Cisco and/or its affiliates.
       4             :  * Licensed under the Apache License, Version 2.0 (the "License");
       5             :  * you may not use this file except in compliance with the License.
       6             :  * You may obtain a copy of the License at:
       7             :  *
       8             :  *     http://www.apache.org/licenses/LICENSE-2.0
       9             :  *
      10             :  * Unless required by applicable law or agreed to in writing, software
      11             :  * distributed under the License is distributed on an "AS IS" BASIS,
      12             :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      13             :  * See the License for the specific language governing permissions and
      14             :  * limitations under the License.
      15             :  *------------------------------------------------------------------
      16             :  */
      17             : 
      18             : #include <vlib/vlib.h>
      19             : #include <vlib/unix/unix.h>
      20             : #include <vlib/pci/pci.h>
      21             : #include <vnet/ethernet/ethernet.h>
      22             : 
      23             : #include <vat/vat.h>
      24             : #include <vlibapi/api.h>
      25             : #include <vlibmemory/api.h>
      26             : 
      27             : #include <vppinfra/error.h>
      28             : #include <rdma/rdma.h>
      29             : 
      30             : #define __plugin_msg_base rdma_test_main.msg_id_base
      31             : #include <vlibapi/vat_helper_macros.h>
      32             : 
      33             : /* declare message IDs */
      34             : #include <rdma/rdma.api_enum.h>
      35             : #include <rdma/rdma.api_types.h>
      36             : 
      37             : typedef struct
      38             : {
      39             :   /* API message ID base */
      40             :   u16 msg_id_base;
      41             :   vat_main_t *vat_main;
      42             : } rdma_test_main_t;
      43             : 
      44             : rdma_test_main_t rdma_test_main;
      45             : 
      46             : static vl_api_rdma_mode_t
      47           0 : api_rdma_mode (rdma_mode_t mode)
      48             : {
      49           0 :   switch (mode)
      50             :     {
      51           0 :     case RDMA_MODE_AUTO:
      52           0 :       return RDMA_API_MODE_AUTO;
      53           0 :     case RDMA_MODE_IBV:
      54           0 :       return RDMA_API_MODE_IBV;
      55           0 :     case RDMA_MODE_DV:
      56           0 :       return RDMA_API_MODE_DV;
      57             :     }
      58           0 :   return ~0;
      59             : }
      60             : 
      61             : static vl_api_rdma_rss4_t
      62           0 : api_rdma_rss4 (rdma_rss4_t rss4)
      63             : {
      64           0 :   switch (rss4)
      65             :     {
      66           0 :     case RDMA_RSS4_AUTO:
      67           0 :       return RDMA_API_RSS4_AUTO;
      68           0 :     case RDMA_RSS4_IP:
      69           0 :       return RDMA_API_RSS4_IP;
      70           0 :     case RDMA_RSS4_IP_UDP:
      71           0 :       return RDMA_API_RSS4_IP_UDP;
      72           0 :     case RDMA_RSS4_IP_TCP:
      73           0 :       return RDMA_API_RSS4_IP_TCP;
      74             :     }
      75           0 :   return ~0;
      76             : }
      77             : 
      78             : static vl_api_rdma_rss6_t
      79           0 : api_rdma_rss6 (rdma_rss6_t rss6)
      80             : {
      81           0 :   switch (rss6)
      82             :     {
      83           0 :     case RDMA_RSS6_AUTO:
      84           0 :       return RDMA_API_RSS6_AUTO;
      85           0 :     case RDMA_RSS6_IP:
      86           0 :       return RDMA_API_RSS6_IP;
      87           0 :     case RDMA_RSS6_IP_UDP:
      88           0 :       return RDMA_API_RSS6_IP_UDP;
      89           0 :     case RDMA_RSS6_IP_TCP:
      90           0 :       return RDMA_API_RSS6_IP_TCP;
      91             :     }
      92           0 :   return ~0;
      93             : }
      94             : 
      95             : /* rdma create API */
      96             : static int
      97           0 : api_rdma_create (vat_main_t * vam)
      98             : {
      99             :   vl_api_rdma_create_t *mp;
     100             :   rdma_create_if_args_t args;
     101             :   int ret;
     102             : 
     103           0 :   if (!unformat_user (vam->input, unformat_rdma_create_if_args, &args))
     104             :     {
     105           0 :       clib_warning ("unknown input `%U'", format_unformat_error, vam->input);
     106           0 :       return -99;
     107             :     }
     108             : 
     109           0 :   M (RDMA_CREATE, mp);
     110             : 
     111           0 :   snprintf ((char *) mp->host_if, sizeof (mp->host_if), "%s", args.ifname);
     112           0 :   snprintf ((char *) mp->name, sizeof (mp->name), "%s", args.name);
     113           0 :   mp->rxq_num = clib_host_to_net_u16 (args.rxq_num);
     114           0 :   mp->rxq_size = clib_host_to_net_u16 (args.rxq_size);
     115           0 :   mp->txq_size = clib_host_to_net_u16 (args.txq_size);
     116           0 :   mp->mode = api_rdma_mode (args.mode);
     117             : 
     118           0 :   S (mp);
     119           0 :   W (ret);
     120             : 
     121           0 :   return ret;
     122             : }
     123             : 
     124             : static int
     125           0 : api_rdma_create_v2 (vat_main_t * vam)
     126             : {
     127             :   vl_api_rdma_create_v2_t *mp;
     128             :   rdma_create_if_args_t args;
     129             :   int ret;
     130             : 
     131           0 :   if (!unformat_user (vam->input, unformat_rdma_create_if_args, &args))
     132             :     {
     133           0 :       clib_warning ("unknown input `%U'", format_unformat_error, vam->input);
     134           0 :       return -99;
     135             :     }
     136             : 
     137           0 :   M (RDMA_CREATE_V2, mp);
     138             : 
     139           0 :   snprintf ((char *) mp->host_if, sizeof (mp->host_if), "%s", args.ifname);
     140           0 :   if (args.name)
     141           0 :     snprintf ((char *) mp->name, sizeof (mp->name), "%s", args.name);
     142             :   else
     143           0 :     mp->name[0] = 0;
     144           0 :   mp->rxq_num = clib_host_to_net_u16 (args.rxq_num);
     145           0 :   mp->rxq_size = clib_host_to_net_u16 (args.rxq_size);
     146           0 :   mp->txq_size = clib_host_to_net_u16 (args.txq_size);
     147           0 :   mp->mode = api_rdma_mode (args.mode);
     148           0 :   mp->no_multi_seg = args.no_multi_seg;
     149           0 :   mp->max_pktlen = clib_host_to_net_u16 (args.max_pktlen);
     150             : 
     151           0 :   S (mp);
     152           0 :   W (ret);
     153             : 
     154           0 :   return ret;
     155             : }
     156             : 
     157             : static int
     158           0 : api_rdma_create_v3 (vat_main_t *vam)
     159             : {
     160             :   vl_api_rdma_create_v3_t *mp;
     161             :   rdma_create_if_args_t args;
     162             :   int ret;
     163             : 
     164           0 :   if (!unformat_user (vam->input, unformat_rdma_create_if_args, &args))
     165             :     {
     166           0 :       clib_warning ("unknown input `%U'", format_unformat_error, vam->input);
     167           0 :       return -99;
     168             :     }
     169             : 
     170           0 :   M (RDMA_CREATE_V3, mp);
     171             : 
     172           0 :   snprintf ((char *) mp->host_if, sizeof (mp->host_if), "%s", args.ifname);
     173           0 :   if (args.name)
     174           0 :     snprintf ((char *) mp->name, sizeof (mp->name), "%s", args.name);
     175             :   else
     176           0 :     mp->name[0] = 0;
     177           0 :   mp->rxq_num = clib_host_to_net_u16 (args.rxq_num);
     178           0 :   mp->rxq_size = clib_host_to_net_u16 (args.rxq_size);
     179           0 :   mp->txq_size = clib_host_to_net_u16 (args.txq_size);
     180           0 :   mp->mode = api_rdma_mode (args.mode);
     181           0 :   mp->no_multi_seg = args.no_multi_seg;
     182           0 :   mp->max_pktlen = clib_host_to_net_u16 (args.max_pktlen);
     183           0 :   mp->rss4 = api_rdma_rss4 (args.rss4);
     184           0 :   mp->rss6 = api_rdma_rss6 (args.rss6);
     185             : 
     186           0 :   S (mp);
     187           0 :   W (ret);
     188             : 
     189           0 :   return ret;
     190             : }
     191             : 
     192             : /* rdma-create reply handler */
     193             : static void
     194           0 : vl_api_rdma_create_reply_t_handler (vl_api_rdma_create_reply_t * mp)
     195             : {
     196           0 :   vat_main_t *vam = rdma_test_main.vat_main;
     197           0 :   i32 retval = ntohl (mp->retval);
     198             : 
     199           0 :   if (retval == 0)
     200             :     {
     201           0 :       fformat (vam->ofp, "created rdma with sw_if_index %d\n",
     202             :                ntohl (mp->sw_if_index));
     203             :     }
     204             : 
     205           0 :   vam->retval = retval;
     206           0 :   vam->result_ready = 1;
     207           0 :   vam->regenerate_interface_table = 1;
     208           0 : }
     209             : 
     210             : /* rdma-create reply handler */
     211             : static void
     212           0 : vl_api_rdma_create_v2_reply_t_handler (vl_api_rdma_create_v2_reply_t * mp)
     213             : {
     214           0 :   vat_main_t *vam = rdma_test_main.vat_main;
     215           0 :   i32 retval = ntohl (mp->retval);
     216             : 
     217           0 :   if (retval == 0)
     218             :     {
     219           0 :       fformat (vam->ofp, "created rdma with sw_if_index %d\n",
     220             :                ntohl (mp->sw_if_index));
     221             :     }
     222             : 
     223           0 :   vam->retval = retval;
     224           0 :   vam->result_ready = 1;
     225           0 :   vam->regenerate_interface_table = 1;
     226           0 : }
     227             : 
     228             : /* rdma-create reply handler v3 */
     229             : static void
     230           0 : vl_api_rdma_create_v3_reply_t_handler (vl_api_rdma_create_v3_reply_t *mp)
     231             : {
     232           0 :   vat_main_t *vam = rdma_test_main.vat_main;
     233           0 :   i32 retval = ntohl (mp->retval);
     234             : 
     235           0 :   if (retval == 0)
     236             :     {
     237           0 :       fformat (vam->ofp, "created rdma with sw_if_index %d\n",
     238             :                ntohl (mp->sw_if_index));
     239             :     }
     240             : 
     241           0 :   vam->retval = retval;
     242           0 :   vam->result_ready = 1;
     243           0 :   vam->regenerate_interface_table = 1;
     244           0 : }
     245             : 
     246             : /* rdma delete API */
     247             : static int
     248           0 : api_rdma_delete (vat_main_t * vam)
     249             : {
     250           0 :   unformat_input_t *i = vam->input;
     251             :   vl_api_rdma_delete_t *mp;
     252           0 :   u32 sw_if_index = 0;
     253           0 :   u8 index_defined = 0;
     254             :   int ret;
     255             : 
     256           0 :   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
     257             :     {
     258           0 :       if (unformat (i, "sw_if_index %u", &sw_if_index))
     259           0 :         index_defined = 1;
     260             :       else
     261             :         {
     262           0 :           clib_warning ("unknown input '%U'", format_unformat_error, i);
     263           0 :           return -99;
     264             :         }
     265             :     }
     266             : 
     267           0 :   if (!index_defined)
     268             :     {
     269           0 :       errmsg ("missing sw_if_index\n");
     270           0 :       return -99;
     271             :     }
     272             : 
     273           0 :   M (RDMA_DELETE, mp);
     274             : 
     275           0 :   mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
     276             : 
     277           0 :   S (mp);
     278           0 :   W (ret);
     279             : 
     280           0 :   return ret;
     281             : }
     282             : 
     283             : #include <rdma/rdma.api_test.c>
     284             : 
     285             : /*
     286             :  * fd.io coding-style-patch-verification: ON
     287             :  *
     288             :  * Local Variables:
     289             :  * eval: (c-set-style "gnu")
     290             :  * End:
     291             :  */

Generated by: LCOV version 1.14