Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 1 | /* |
| 2 | *------------------------------------------------------------------ |
| 3 | * vhost-user_api.c - vhost-user api |
| 4 | * |
| 5 | * Copyright (c) 2016 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 <vnet/vnet.h> |
| 21 | #include <vlibmemory/api.h> |
| 22 | |
| 23 | #include <vnet/interface.h> |
| 24 | #include <vnet/api_errno.h> |
Mohsin Kazmi | e7cde31 | 2018-06-26 17:20:11 +0200 | [diff] [blame] | 25 | #include <vnet/devices/virtio/vhost_user.h> |
Jakub Grajciar | 5d4c99f | 2019-09-26 10:21:59 +0200 | [diff] [blame] | 26 | #include <vnet/ethernet/ethernet.h> |
| 27 | #include <vnet/ethernet/ethernet_types_api.h> |
| 28 | #include <vnet/devices/virtio/virtio_types_api.h> |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 29 | |
| 30 | #include <vnet/vnet_msg_enum.h> |
| 31 | |
| 32 | #define vl_typedefs /* define message structures */ |
| 33 | #include <vnet/vnet_all_api_h.h> |
| 34 | #undef vl_typedefs |
| 35 | |
| 36 | #define vl_endianfun /* define message structures */ |
| 37 | #include <vnet/vnet_all_api_h.h> |
| 38 | #undef vl_endianfun |
| 39 | |
| 40 | /* instantiate all the print functions we know about */ |
| 41 | #define vl_print(handle, ...) vlib_cli_output (handle, __VA_ARGS__) |
| 42 | #define vl_printfun |
| 43 | #include <vnet/vnet_all_api_h.h> |
| 44 | #undef vl_printfun |
| 45 | |
| 46 | #include <vlibapi/api_helper_macros.h> |
| 47 | |
| 48 | #define foreach_vpe_api_msg \ |
| 49 | _(CREATE_VHOST_USER_IF, create_vhost_user_if) \ |
| 50 | _(MODIFY_VHOST_USER_IF, modify_vhost_user_if) \ |
Steven Luong | 27ba500 | 2020-11-17 13:30:44 -0800 | [diff] [blame] | 51 | _(CREATE_VHOST_USER_IF_V2, create_vhost_user_if_v2) \ |
| 52 | _(MODIFY_VHOST_USER_IF_V2, modify_vhost_user_if_v2) \ |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 53 | _(DELETE_VHOST_USER_IF, delete_vhost_user_if) \ |
Dave Barach | a1a093d | 2017-03-02 13:13:23 -0500 | [diff] [blame] | 54 | _(SW_INTERFACE_VHOST_USER_DUMP, sw_interface_vhost_user_dump) |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 55 | |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 56 | static void |
| 57 | vl_api_create_vhost_user_if_t_handler (vl_api_create_vhost_user_if_t * mp) |
| 58 | { |
| 59 | int rv = 0; |
| 60 | vl_api_create_vhost_user_if_reply_t *rmp; |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 61 | vnet_main_t *vnm = vnet_get_main (); |
| 62 | vlib_main_t *vm = vlib_get_main (); |
Mohsin Kazmi | ee2e58f | 2018-08-21 16:07:03 +0200 | [diff] [blame] | 63 | u64 disabled_features = (u64) (0ULL); |
Steven Luong | 27ba500 | 2020-11-17 13:30:44 -0800 | [diff] [blame] | 64 | vhost_user_create_if_args_t args = { 0 }; |
Mohsin Kazmi | ee2e58f | 2018-08-21 16:07:03 +0200 | [diff] [blame] | 65 | |
Steven Luong | 27ba500 | 2020-11-17 13:30:44 -0800 | [diff] [blame] | 66 | args.sw_if_index = (u32) ~ 0; |
| 67 | args.feature_mask = (u64) ~ (0ULL); |
Mohsin Kazmi | ee2e58f | 2018-08-21 16:07:03 +0200 | [diff] [blame] | 68 | if (mp->disable_mrg_rxbuf) |
Mohsin Kazmi | a7a2281 | 2020-08-31 17:17:16 +0200 | [diff] [blame] | 69 | disabled_features = VIRTIO_FEATURE (VIRTIO_NET_F_MRG_RXBUF); |
Mohsin Kazmi | ee2e58f | 2018-08-21 16:07:03 +0200 | [diff] [blame] | 70 | |
| 71 | if (mp->disable_indirect_desc) |
Mohsin Kazmi | a7a2281 | 2020-08-31 17:17:16 +0200 | [diff] [blame] | 72 | disabled_features |= VIRTIO_FEATURE (VIRTIO_RING_F_INDIRECT_DESC); |
Mohsin Kazmi | ee2e58f | 2018-08-21 16:07:03 +0200 | [diff] [blame] | 73 | |
Steven Luong | 4208a4c | 2019-05-06 08:51:56 -0700 | [diff] [blame] | 74 | /* |
Steven Luong | bc0d9ff | 2020-03-23 09:34:59 -0700 | [diff] [blame] | 75 | * GSO and PACKED are not supported by feature mask via binary API. We |
| 76 | * disable GSO and PACKED feature in the feature mask. They may be enabled |
| 77 | * explicitly via enable_gso and enable_packed argument |
Steven Luong | 4208a4c | 2019-05-06 08:51:56 -0700 | [diff] [blame] | 78 | */ |
Steven Luong | bc0d9ff | 2020-03-23 09:34:59 -0700 | [diff] [blame] | 79 | disabled_features |= FEATURE_VIRTIO_NET_F_HOST_GUEST_TSO_FEATURE_BITS | |
Mohsin Kazmi | a7a2281 | 2020-08-31 17:17:16 +0200 | [diff] [blame] | 80 | VIRTIO_FEATURE (VIRTIO_F_RING_PACKED); |
Steven Luong | 27ba500 | 2020-11-17 13:30:44 -0800 | [diff] [blame] | 81 | |
| 82 | /* EVENT_IDX is disabled by default */ |
| 83 | disabled_features |= VIRTIO_FEATURE (VIRTIO_RING_F_EVENT_IDX); |
| 84 | args.feature_mask &= ~disabled_features; |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 85 | |
Jakub Grajciar | 5d4c99f | 2019-09-26 10:21:59 +0200 | [diff] [blame] | 86 | if (mp->use_custom_mac) |
Steven Luong | 27ba500 | 2020-11-17 13:30:44 -0800 | [diff] [blame] | 87 | mac_address_decode (mp->mac_address, (mac_address_t *) args.hwaddr); |
Jakub Grajciar | 5d4c99f | 2019-09-26 10:21:59 +0200 | [diff] [blame] | 88 | |
Steven Luong | 27ba500 | 2020-11-17 13:30:44 -0800 | [diff] [blame] | 89 | args.is_server = mp->is_server; |
| 90 | args.sock_filename = (char *) mp->sock_filename; |
| 91 | args.renumber = mp->renumber; |
| 92 | args.custom_dev_instance = ntohl (mp->custom_dev_instance); |
| 93 | args.enable_gso = mp->enable_gso; |
| 94 | args.enable_packed = mp->enable_packed; |
| 95 | rv = vhost_user_create_if (vnm, vm, &args); |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 96 | |
| 97 | /* Remember an interface tag for the new interface */ |
| 98 | if (rv == 0) |
| 99 | { |
| 100 | /* If a tag was supplied... */ |
| 101 | if (mp->tag[0]) |
| 102 | { |
| 103 | /* Make sure it's a proper C-string */ |
| 104 | mp->tag[ARRAY_LEN (mp->tag) - 1] = 0; |
| 105 | u8 *tag = format (0, "%s%c", mp->tag, 0); |
Steven Luong | 27ba500 | 2020-11-17 13:30:44 -0800 | [diff] [blame] | 106 | vnet_set_sw_interface_tag (vnm, tag, args.sw_if_index); |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 107 | } |
| 108 | } |
| 109 | |
| 110 | /* *INDENT-OFF* */ |
| 111 | REPLY_MACRO2(VL_API_CREATE_VHOST_USER_IF_REPLY, |
| 112 | ({ |
Steven Luong | 27ba500 | 2020-11-17 13:30:44 -0800 | [diff] [blame] | 113 | rmp->sw_if_index = ntohl (args.sw_if_index); |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 114 | })); |
| 115 | /* *INDENT-ON* */ |
| 116 | } |
| 117 | |
| 118 | static void |
| 119 | vl_api_modify_vhost_user_if_t_handler (vl_api_modify_vhost_user_if_t * mp) |
| 120 | { |
| 121 | int rv = 0; |
| 122 | vl_api_modify_vhost_user_if_reply_t *rmp; |
Steven Luong | 4208a4c | 2019-05-06 08:51:56 -0700 | [diff] [blame] | 123 | u64 disabled_features = (u64) (0ULL); |
Steven Luong | 27ba500 | 2020-11-17 13:30:44 -0800 | [diff] [blame] | 124 | vhost_user_create_if_args_t args = { 0 }; |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 125 | vnet_main_t *vnm = vnet_get_main (); |
| 126 | vlib_main_t *vm = vlib_get_main (); |
| 127 | |
Steven Luong | 27ba500 | 2020-11-17 13:30:44 -0800 | [diff] [blame] | 128 | args.feature_mask = (u64) ~ (0ULL); |
| 129 | /* |
| 130 | * GSO and PACKED are not supported by feature mask via binary API. We |
| 131 | * disable GSO and PACKED feature in the feature mask. They may be enabled |
| 132 | * explicitly via enable_gso and enable_packed argument |
| 133 | */ |
| 134 | disabled_features |= FEATURE_VIRTIO_NET_F_HOST_GUEST_TSO_FEATURE_BITS | |
| 135 | VIRTIO_FEATURE (VIRTIO_F_RING_PACKED); |
| 136 | |
| 137 | /* EVENT_IDX is disabled by default */ |
| 138 | disabled_features |= VIRTIO_FEATURE (VIRTIO_RING_F_EVENT_IDX); |
| 139 | args.feature_mask &= ~disabled_features; |
| 140 | |
| 141 | args.sw_if_index = ntohl (mp->sw_if_index); |
| 142 | args.sock_filename = (char *) mp->sock_filename; |
| 143 | args.is_server = mp->is_server; |
| 144 | args.renumber = mp->renumber; |
| 145 | args.custom_dev_instance = ntohl (mp->custom_dev_instance); |
| 146 | args.enable_gso = mp->enable_gso; |
| 147 | args.enable_packed = mp->enable_packed; |
| 148 | rv = vhost_user_modify_if (vnm, vm, &args); |
| 149 | |
| 150 | REPLY_MACRO (VL_API_MODIFY_VHOST_USER_IF_REPLY); |
| 151 | } |
| 152 | |
| 153 | static void |
| 154 | vl_api_create_vhost_user_if_v2_t_handler (vl_api_create_vhost_user_if_v2_t * |
| 155 | mp) |
| 156 | { |
| 157 | int rv = 0; |
| 158 | vl_api_create_vhost_user_if_v2_reply_t *rmp; |
| 159 | vnet_main_t *vnm = vnet_get_main (); |
| 160 | vlib_main_t *vm = vlib_get_main (); |
| 161 | u64 disabled_features = (u64) (0ULL); |
| 162 | vhost_user_create_if_args_t args = { 0 }; |
| 163 | |
| 164 | args.sw_if_index = (u32) ~ 0; |
| 165 | args.feature_mask = (u64) ~ (0ULL); |
| 166 | if (mp->disable_mrg_rxbuf) |
| 167 | disabled_features = VIRTIO_FEATURE (VIRTIO_NET_F_MRG_RXBUF); |
| 168 | |
| 169 | if (mp->disable_indirect_desc) |
| 170 | disabled_features |= VIRTIO_FEATURE (VIRTIO_RING_F_INDIRECT_DESC); |
| 171 | |
Steven Luong | 4208a4c | 2019-05-06 08:51:56 -0700 | [diff] [blame] | 172 | /* |
Steven Luong | bc0d9ff | 2020-03-23 09:34:59 -0700 | [diff] [blame] | 173 | * GSO and PACKED are not supported by feature mask via binary API. We |
| 174 | * disable GSO and PACKED feature in the feature mask. They may be enabled |
| 175 | * explicitly via enable_gso and enable_packed argument |
Steven Luong | 4208a4c | 2019-05-06 08:51:56 -0700 | [diff] [blame] | 176 | */ |
Steven Luong | bc0d9ff | 2020-03-23 09:34:59 -0700 | [diff] [blame] | 177 | disabled_features |= FEATURE_VIRTIO_NET_F_HOST_GUEST_TSO_FEATURE_BITS | |
Mohsin Kazmi | a7a2281 | 2020-08-31 17:17:16 +0200 | [diff] [blame] | 178 | VIRTIO_FEATURE (VIRTIO_F_RING_PACKED); |
Steven Luong | 4208a4c | 2019-05-06 08:51:56 -0700 | [diff] [blame] | 179 | |
Steven Luong | 27ba500 | 2020-11-17 13:30:44 -0800 | [diff] [blame] | 180 | /* EVENT_IDX is disabled by default */ |
| 181 | disabled_features |= VIRTIO_FEATURE (VIRTIO_RING_F_EVENT_IDX); |
| 182 | args.feature_mask &= ~disabled_features; |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 183 | |
Steven Luong | 27ba500 | 2020-11-17 13:30:44 -0800 | [diff] [blame] | 184 | if (mp->use_custom_mac) |
| 185 | mac_address_decode (mp->mac_address, (mac_address_t *) args.hwaddr); |
| 186 | |
| 187 | args.is_server = mp->is_server; |
| 188 | args.sock_filename = (char *) mp->sock_filename; |
| 189 | args.renumber = mp->renumber; |
| 190 | args.custom_dev_instance = ntohl (mp->custom_dev_instance); |
| 191 | args.enable_gso = mp->enable_gso; |
| 192 | args.enable_packed = mp->enable_packed; |
| 193 | args.enable_event_idx = mp->enable_event_idx; |
| 194 | rv = vhost_user_create_if (vnm, vm, &args); |
| 195 | |
| 196 | /* Remember an interface tag for the new interface */ |
| 197 | if (rv == 0) |
| 198 | { |
| 199 | /* If a tag was supplied... */ |
| 200 | if (mp->tag[0]) |
| 201 | { |
| 202 | /* Make sure it's a proper C-string */ |
| 203 | mp->tag[ARRAY_LEN (mp->tag) - 1] = 0; |
| 204 | u8 *tag = format (0, "%s%c", mp->tag, 0); |
| 205 | vnet_set_sw_interface_tag (vnm, tag, args.sw_if_index); |
| 206 | } |
| 207 | } |
| 208 | |
| 209 | /* *INDENT-OFF* */ |
| 210 | REPLY_MACRO2(VL_API_CREATE_VHOST_USER_IF_V2_REPLY, |
| 211 | ({ |
| 212 | rmp->sw_if_index = ntohl (args.sw_if_index); |
| 213 | })); |
| 214 | /* *INDENT-ON* */ |
| 215 | } |
| 216 | |
| 217 | static void |
| 218 | vl_api_modify_vhost_user_if_v2_t_handler (vl_api_modify_vhost_user_if_v2_t * |
| 219 | mp) |
| 220 | { |
| 221 | int rv = 0; |
| 222 | vl_api_modify_vhost_user_if_v2_reply_t *rmp; |
| 223 | u64 disabled_features = (u64) (0ULL); |
| 224 | vhost_user_create_if_args_t args = { 0 }; |
| 225 | vnet_main_t *vnm = vnet_get_main (); |
| 226 | vlib_main_t *vm = vlib_get_main (); |
| 227 | |
| 228 | args.feature_mask = (u64) ~ (0ULL); |
| 229 | /* |
| 230 | * GSO and PACKED are not supported by feature mask via binary API. We |
| 231 | * disable GSO and PACKED feature in the feature mask. They may be enabled |
| 232 | * explicitly via enable_gso and enable_packed argument |
| 233 | */ |
| 234 | disabled_features |= FEATURE_VIRTIO_NET_F_HOST_GUEST_TSO_FEATURE_BITS | |
| 235 | VIRTIO_FEATURE (VIRTIO_F_RING_PACKED); |
| 236 | |
| 237 | /* EVENT_IDX is disabled by default */ |
| 238 | disabled_features |= VIRTIO_FEATURE (VIRTIO_RING_F_EVENT_IDX); |
| 239 | args.feature_mask &= ~disabled_features; |
| 240 | |
| 241 | args.sw_if_index = ntohl (mp->sw_if_index); |
| 242 | args.sock_filename = (char *) mp->sock_filename; |
| 243 | args.is_server = mp->is_server; |
| 244 | args.renumber = mp->renumber; |
| 245 | args.custom_dev_instance = ntohl (mp->custom_dev_instance); |
| 246 | args.enable_gso = mp->enable_gso; |
| 247 | args.enable_packed = mp->enable_packed; |
| 248 | args.enable_event_idx = mp->enable_event_idx; |
| 249 | rv = vhost_user_modify_if (vnm, vm, &args); |
| 250 | |
| 251 | REPLY_MACRO (VL_API_MODIFY_VHOST_USER_IF_V2_REPLY); |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 252 | } |
| 253 | |
| 254 | static void |
| 255 | vl_api_delete_vhost_user_if_t_handler (vl_api_delete_vhost_user_if_t * mp) |
| 256 | { |
| 257 | int rv = 0; |
| 258 | vl_api_delete_vhost_user_if_reply_t *rmp; |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 259 | u32 sw_if_index = ntohl (mp->sw_if_index); |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 260 | vl_api_registration_t *reg; |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 261 | |
| 262 | vnet_main_t *vnm = vnet_get_main (); |
| 263 | vlib_main_t *vm = vlib_get_main (); |
| 264 | |
| 265 | rv = vhost_user_delete_if (vnm, vm, sw_if_index); |
| 266 | |
| 267 | REPLY_MACRO (VL_API_DELETE_VHOST_USER_IF_REPLY); |
| 268 | if (!rv) |
| 269 | { |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 270 | reg = vl_api_client_index_to_registration (mp->client_index); |
| 271 | if (!reg) |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 272 | return; |
| 273 | |
| 274 | vnet_clear_sw_interface_tag (vnm, sw_if_index); |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 275 | } |
| 276 | } |
| 277 | |
| 278 | static void |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 279 | send_sw_interface_vhost_user_details (vpe_api_main_t * am, |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 280 | vl_api_registration_t * reg, |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 281 | vhost_user_intf_details_t * vui, |
| 282 | u32 context) |
| 283 | { |
| 284 | vl_api_sw_interface_vhost_user_details_t *mp; |
| 285 | |
| 286 | mp = vl_msg_api_alloc (sizeof (*mp)); |
Dave Barach | b7b9299 | 2018-10-17 10:38:51 -0400 | [diff] [blame] | 287 | clib_memset (mp, 0, sizeof (*mp)); |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 288 | mp->_vl_msg_id = ntohs (VL_API_SW_INTERFACE_VHOST_USER_DETAILS); |
| 289 | mp->sw_if_index = ntohl (vui->sw_if_index); |
| 290 | mp->virtio_net_hdr_sz = ntohl (vui->virtio_net_hdr_sz); |
Jakub Grajciar | 5d4c99f | 2019-09-26 10:21:59 +0200 | [diff] [blame] | 291 | virtio_features_encode (vui->features, (u32 *) & mp->features_first_32, |
| 292 | (u32 *) & mp->features_last_32); |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 293 | mp->is_server = vui->is_server; |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 294 | mp->num_regions = ntohl (vui->num_regions); |
| 295 | mp->sock_errno = ntohl (vui->sock_errno); |
| 296 | mp->context = context; |
| 297 | |
| 298 | strncpy ((char *) mp->sock_filename, |
| 299 | (char *) vui->sock_filename, ARRAY_LEN (mp->sock_filename) - 1); |
| 300 | strncpy ((char *) mp->interface_name, |
| 301 | (char *) vui->if_name, ARRAY_LEN (mp->interface_name) - 1); |
| 302 | |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 303 | vl_api_send_msg (reg, (u8 *) mp); |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 304 | } |
| 305 | |
| 306 | static void |
| 307 | vl_api_sw_interface_vhost_user_dump_t_handler |
| 308 | (vl_api_sw_interface_vhost_user_dump_t * mp) |
| 309 | { |
| 310 | int rv = 0; |
| 311 | vpe_api_main_t *am = &vpe_api_main; |
| 312 | vnet_main_t *vnm = vnet_get_main (); |
| 313 | vlib_main_t *vm = vlib_get_main (); |
| 314 | vhost_user_intf_details_t *ifaces = NULL; |
| 315 | vhost_user_intf_details_t *vuid = NULL; |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 316 | vl_api_registration_t *reg; |
Jakub Grajciar | 5d4c99f | 2019-09-26 10:21:59 +0200 | [diff] [blame] | 317 | u32 filter_sw_if_index; |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 318 | |
Florin Coras | 6c4dae2 | 2018-01-09 06:39:23 -0800 | [diff] [blame] | 319 | reg = vl_api_client_index_to_registration (mp->client_index); |
| 320 | if (!reg) |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 321 | return; |
| 322 | |
Jakub Grajciar | 5d4c99f | 2019-09-26 10:21:59 +0200 | [diff] [blame] | 323 | filter_sw_if_index = htonl (mp->sw_if_index); |
| 324 | if (filter_sw_if_index != ~0) |
Steven Luong | a0e8d96 | 2020-05-18 17:12:56 -0700 | [diff] [blame] | 325 | VALIDATE_SW_IF_INDEX (mp); |
Jakub Grajciar | 5d4c99f | 2019-09-26 10:21:59 +0200 | [diff] [blame] | 326 | |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 327 | rv = vhost_user_dump_ifs (vnm, vm, &ifaces); |
| 328 | if (rv) |
| 329 | return; |
| 330 | |
| 331 | vec_foreach (vuid, ifaces) |
| 332 | { |
Steven Luong | a0e8d96 | 2020-05-18 17:12:56 -0700 | [diff] [blame] | 333 | if ((filter_sw_if_index == ~0) || |
| 334 | (vuid->sw_if_index == filter_sw_if_index)) |
| 335 | send_sw_interface_vhost_user_details (am, reg, vuid, mp->context); |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 336 | } |
Steven Luong | a0e8d96 | 2020-05-18 17:12:56 -0700 | [diff] [blame] | 337 | BAD_SW_IF_INDEX_LABEL; |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 338 | vec_free (ifaces); |
| 339 | } |
| 340 | |
| 341 | /* |
| 342 | * vhost-user_api_hookup |
| 343 | * Add vpe's API message handlers to the table. |
Jim Thompson | f324dec | 2019-04-08 03:22:21 -0500 | [diff] [blame] | 344 | * vlib has already mapped shared memory and |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 345 | * added the client registration handlers. |
| 346 | * See .../vlib-api/vlibmemory/memclnt_vlib.c:memclnt_process() |
| 347 | */ |
| 348 | #define vl_msg_name_crc_list |
| 349 | #include <vnet/vnet_all_api_h.h> |
| 350 | #undef vl_msg_name_crc_list |
| 351 | |
| 352 | static void |
| 353 | setup_message_id_table (api_main_t * am) |
| 354 | { |
| 355 | #define _(id,n,crc) vl_msg_api_add_msg_name_crc (am, #n "_" #crc, id); |
| 356 | foreach_vl_msg_name_crc_vhost_user; |
| 357 | #undef _ |
| 358 | } |
| 359 | |
| 360 | static clib_error_t * |
| 361 | vhost_user_api_hookup (vlib_main_t * vm) |
| 362 | { |
Dave Barach | 39d6911 | 2019-11-27 11:42:13 -0500 | [diff] [blame] | 363 | api_main_t *am = vlibapi_get_main (); |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 364 | |
| 365 | #define _(N,n) \ |
| 366 | vl_msg_api_set_handlers(VL_API_##N, #n, \ |
| 367 | vl_api_##n##_t_handler, \ |
| 368 | vl_noop_handler, \ |
| 369 | vl_api_##n##_t_endian, \ |
| 370 | vl_api_##n##_t_print, \ |
| 371 | sizeof(vl_api_##n##_t), 1); |
| 372 | foreach_vpe_api_msg; |
| 373 | #undef _ |
| 374 | |
Steven Luong | 67f935e | 2019-02-01 10:23:56 -0800 | [diff] [blame] | 375 | /* Mark CREATE_VHOST_USER_IF as mp safe */ |
| 376 | am->is_mp_safe[VL_API_CREATE_VHOST_USER_IF] = 1; |
Steven Luong | 27ba500 | 2020-11-17 13:30:44 -0800 | [diff] [blame] | 377 | am->is_mp_safe[VL_API_CREATE_VHOST_USER_IF_V2] = 1; |
Steven Luong | 67f935e | 2019-02-01 10:23:56 -0800 | [diff] [blame] | 378 | |
Pavel Kotucek | f07dc9e | 2016-12-20 12:17:37 +0100 | [diff] [blame] | 379 | /* |
| 380 | * Set up the (msg_name, crc, message-id) table |
| 381 | */ |
| 382 | setup_message_id_table (am); |
| 383 | |
| 384 | return 0; |
| 385 | } |
| 386 | |
| 387 | VLIB_API_INIT_FUNCTION (vhost_user_api_hookup); |
| 388 | |
| 389 | /* |
| 390 | * fd.io coding-style-patch-verification: ON |
| 391 | * |
| 392 | * Local Variables: |
| 393 | * eval: (c-set-style "gnu") |
| 394 | * End: |
| 395 | */ |