src/plugins/rdma/test_api.c

   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 api_rdma_mode (rdma_mode_t mode)
  48 {
  49   switch (mode)
  50     {
  51     case RDMA_MODE_AUTO:
  52       return RDMA_API_MODE_AUTO;
  53     case RDMA_MODE_IBV:
  54       return RDMA_API_MODE_IBV;
  55     case RDMA_MODE_DV:
  56       return RDMA_API_MODE_DV;
  57     }
  58   return ~0;
  59 }
  60
  61 static vl_api_rdma_rss4_t
  62 api_rdma_rss4 (rdma_rss4_t rss4)
  63 {
  64   switch (rss4)
  65     {
  66     case RDMA_RSS4_AUTO:
  67       return RDMA_API_RSS4_AUTO;
  68     case RDMA_RSS4_IP:
  69       return RDMA_API_RSS4_IP;
  70     case RDMA_RSS4_IP_UDP:
  71       return RDMA_API_RSS4_IP_UDP;
  72     case RDMA_RSS4_IP_TCP:
  73       return RDMA_API_RSS4_IP_TCP;
  74     }
  75   return ~0;
  76 }
  77
  78 static vl_api_rdma_rss6_t
  79 api_rdma_rss6 (rdma_rss6_t rss6)
  80 {
  81   switch (rss6)
  82     {
  83     case RDMA_RSS6_AUTO:
  84       return RDMA_API_RSS6_AUTO;
  85     case RDMA_RSS6_IP:
  86       return RDMA_API_RSS6_IP;
  87     case RDMA_RSS6_IP_UDP:
  88       return RDMA_API_RSS6_IP_UDP;
  89     case RDMA_RSS6_IP_TCP:
  90       return RDMA_API_RSS6_IP_TCP;
  91     }
  92   return ~0;
  93 }
  94
  95 /* rdma create API */
  96 static int
  97 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   if (!unformat_user (vam->input, unformat_rdma_create_if_args, &args))
 104     {
 105       clib_warning ("unknown input `%U'", format_unformat_error, vam->input);
 106       return -99;
 107     }
 108
 109   M (RDMA_CREATE, mp);
 110
 111   snprintf ((char *) mp->host_if, sizeof (mp->host_if), "%s", args.ifname);
 112   snprintf ((char *) mp->name, sizeof (mp->name), "%s", args.name);
 113   mp->rxq_num = clib_host_to_net_u16 (args.rxq_num);
 114   mp->rxq_size = clib_host_to_net_u16 (args.rxq_size);
 115   mp->txq_size = clib_host_to_net_u16 (args.txq_size);
 116   mp->mode = api_rdma_mode (args.mode);
 117
 118   S (mp);
 119   W (ret);
 120
 121   return ret;
 122 }
 123
 124 static int
 125 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   if (!unformat_user (vam->input, unformat_rdma_create_if_args, &args))
 132     {
 133       clib_warning ("unknown input `%U'", format_unformat_error, vam->input);
 134       return -99;
 135     }
 136
 137   M (RDMA_CREATE_V2, mp);
 138
 139   snprintf ((char *) mp->host_if, sizeof (mp->host_if), "%s", args.ifname);
 140   if (args.name)
 141     snprintf ((char *) mp->name, sizeof (mp->name), "%s", args.name);
 142   else
 143     mp->name[0] = 0;
 144   mp->rxq_num = clib_host_to_net_u16 (args.rxq_num);
 145   mp->rxq_size = clib_host_to_net_u16 (args.rxq_size);
 146   mp->txq_size = clib_host_to_net_u16 (args.txq_size);
 147   mp->mode = api_rdma_mode (args.mode);
 148   mp->no_multi_seg = args.no_multi_seg;
 149   mp->max_pktlen = clib_host_to_net_u16 (args.max_pktlen);
 150
 151   S (mp);
 152   W (ret);
 153
 154   return ret;
 155 }
 156
 157 static int
 158 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   if (!unformat_user (vam->input, unformat_rdma_create_if_args, &args))
 165     {
 166       clib_warning ("unknown input `%U'", format_unformat_error, vam->input);
 167       return -99;
 168     }
 169
 170   M (RDMA_CREATE_V3, mp);
 171
 172   snprintf ((char *) mp->host_if, sizeof (mp->host_if), "%s", args.ifname);
 173   if (args.name)
 174     snprintf ((char *) mp->name, sizeof (mp->name), "%s", args.name);
 175   else
 176     mp->name[0] = 0;
 177   mp->rxq_num = clib_host_to_net_u16 (args.rxq_num);
 178   mp->rxq_size = clib_host_to_net_u16 (args.rxq_size);
 179   mp->txq_size = clib_host_to_net_u16 (args.txq_size);
 180   mp->mode = api_rdma_mode (args.mode);
 181   mp->no_multi_seg = args.no_multi_seg;
 182   mp->max_pktlen = clib_host_to_net_u16 (args.max_pktlen);
 183   mp->rss4 = api_rdma_rss4 (args.rss4);
 184   mp->rss6 = api_rdma_rss6 (args.rss6);
 185
 186   S (mp);
 187   W (ret);
 188
 189   return ret;
 190 }
 191
 192 static int
 193 api_rdma_create_v4 (vat_main_t *vam)
 194 {
 195   vl_api_rdma_create_v4_t *mp;
 196   rdma_create_if_args_t args;
 197   int ret;
 198
 199   if (!unformat_user (vam->input, unformat_rdma_create_if_args, &args))
 200     {
 201       clib_warning ("unknown input `%U'", format_unformat_error, vam->input);
 202       return -99;
 203     }
 204
 205   M (RDMA_CREATE_V4, mp);
 206
 207   snprintf ((char *) mp->host_if, sizeof (mp->host_if), "%s", args.ifname);
 208   if (args.name)
 209     snprintf ((char *) mp->name, sizeof (mp->name), "%s", args.name);
 210   else
 211     mp->name[0] = 0;
 212   mp->rxq_num = args.rxq_num;
 213   mp->rxq_size = args.rxq_size;
 214   mp->txq_size = args.txq_size;
 215   mp->mode = api_rdma_mode (args.mode);
 216   mp->no_multi_seg = args.no_multi_seg;
 217   mp->max_pktlen = args.max_pktlen;
 218   mp->rss4 = api_rdma_rss4 (args.rss4);
 219   mp->rss6 = api_rdma_rss6 (args.rss6);
 220
 221   S (mp);
 222   W (ret);
 223
 224   return ret;
 225 }
 226
 227 /* rdma-create reply handler */
 228 static void
 229 vl_api_rdma_create_reply_t_handler (vl_api_rdma_create_reply_t * mp)
 230 {
 231   vat_main_t *vam = rdma_test_main.vat_main;
 232   i32 retval = ntohl (mp->retval);
 233
 234   if (retval == 0)
 235     {
 236       fformat (vam->ofp, "created rdma with sw_if_index %d\n",
 237                ntohl (mp->sw_if_index));
 238     }
 239
 240   vam->retval = retval;
 241   vam->result_ready = 1;
 242   vam->regenerate_interface_table = 1;
 243 }
 244
 245 /* rdma-create reply handler */
 246 static void
 247 vl_api_rdma_create_v2_reply_t_handler (vl_api_rdma_create_v2_reply_t * mp)
 248 {
 249   vat_main_t *vam = rdma_test_main.vat_main;
 250   i32 retval = ntohl (mp->retval);
 251
 252   if (retval == 0)
 253     {
 254       fformat (vam->ofp, "created rdma with sw_if_index %d\n",
 255                ntohl (mp->sw_if_index));
 256     }
 257
 258   vam->retval = retval;
 259   vam->result_ready = 1;
 260   vam->regenerate_interface_table = 1;
 261 }
 262
 263 /* rdma-create reply handler v3 */
 264 static void
 265 vl_api_rdma_create_v3_reply_t_handler (vl_api_rdma_create_v3_reply_t *mp)
 266 {
 267   vat_main_t *vam = rdma_test_main.vat_main;
 268   i32 retval = ntohl (mp->retval);
 269
 270   if (retval == 0)
 271     {
 272       fformat (vam->ofp, "created rdma with sw_if_index %d\n",
 273                ntohl (mp->sw_if_index));
 274     }
 275
 276   vam->retval = retval;
 277   vam->result_ready = 1;
 278   vam->regenerate_interface_table = 1;
 279 }
 280
 281 /* rdma-create reply handler v4 */
 282 static void
 283 vl_api_rdma_create_v4_reply_t_handler (vl_api_rdma_create_v4_reply_t *mp)
 284 {
 285   vat_main_t *vam = rdma_test_main.vat_main;
 286   i32 retval = mp->retval;
 287
 288   if (retval == 0)
 289     {
 290       fformat (vam->ofp, "created rdma with sw_if_index %d\n",
 291                ntohl (mp->sw_if_index));
 292     }
 293
 294   vam->retval = retval;
 295   vam->result_ready = 1;
 296   vam->regenerate_interface_table = 1;
 297 }
 298
 299 /* rdma delete API */
 300 static int
 301 api_rdma_delete (vat_main_t * vam)
 302 {
 303   unformat_input_t *i = vam->input;
 304   vl_api_rdma_delete_t *mp;
 305   u32 sw_if_index = 0;
 306   u8 index_defined = 0;
 307   int ret;
 308
 309   while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT)
 310     {
 311       if (unformat (i, "sw_if_index %u", &sw_if_index))
 312         index_defined = 1;
 313       else
 314         {
 315           clib_warning ("unknown input '%U'", format_unformat_error, i);
 316           return -99;
 317         }
 318     }
 319
 320   if (!index_defined)
 321     {
 322       errmsg ("missing sw_if_index\n");
 323       return -99;
 324     }
 325
 326   M (RDMA_DELETE, mp);
 327
 328   mp->sw_if_index = clib_host_to_net_u32 (sw_if_index);
 329
 330   S (mp);
 331   W (ret);
 332
 333   return ret;
 334 }
 335
 336 #include <rdma/rdma.api_test.c>
 337
 338 /*
 339  * fd.io coding-style-patch-verification: ON
 340  *
 341  * Local Variables:
 342  * eval: (c-set-style "gnu")
 343  * End:
 344  */