1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (C) 2018 Vincenzo Maffione 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 /* $FreeBSD$ */ 30 31 #if defined(__FreeBSD__) 32 #include <sys/cdefs.h> /* prerequisite */ 33 #include <sys/types.h> 34 #include <sys/param.h> /* defines used in kernel.h */ 35 #include <sys/filio.h> /* FIONBIO */ 36 #include <sys/malloc.h> 37 #include <sys/socketvar.h> /* struct socket */ 38 #include <sys/socket.h> /* sockaddrs */ 39 #include <sys/sysctl.h> 40 #include <net/if.h> 41 #include <net/if_var.h> 42 #include <net/bpf.h> /* BIOCIMMEDIATE */ 43 #include <machine/bus.h> /* bus_dmamap_* */ 44 #include <sys/endian.h> 45 #elif defined(linux) 46 #include "bsd_glue.h" 47 #elif defined(__APPLE__) 48 #warning OSX support is only partial 49 #include "osx_glue.h" 50 #elif defined (_WIN32) 51 #include "win_glue.h" 52 #endif 53 54 /* 55 * common headers 56 */ 57 #include <net/netmap.h> 58 #include <dev/netmap/netmap_kern.h> 59 #include <dev/netmap/netmap_bdg.h> 60 61 static int 62 nmreq_register_from_legacy(struct nmreq *nmr, struct nmreq_header *hdr, 63 struct nmreq_register *req) 64 { 65 req->nr_offset = nmr->nr_offset; 66 req->nr_memsize = nmr->nr_memsize; 67 req->nr_tx_slots = nmr->nr_tx_slots; 68 req->nr_rx_slots = nmr->nr_rx_slots; 69 req->nr_tx_rings = nmr->nr_tx_rings; 70 req->nr_rx_rings = nmr->nr_rx_rings; 71 req->nr_host_tx_rings = 0; 72 req->nr_host_rx_rings = 0; 73 req->nr_mem_id = nmr->nr_arg2; 74 req->nr_ringid = nmr->nr_ringid & NETMAP_RING_MASK; 75 if ((nmr->nr_flags & NR_REG_MASK) == NR_REG_DEFAULT) { 76 /* Convert the older nmr->nr_ringid (original 77 * netmap control API) to nmr->nr_flags. */ 78 u_int regmode = NR_REG_DEFAULT; 79 if (nmr->nr_ringid & NETMAP_SW_RING) { 80 regmode = NR_REG_SW; 81 } else if (nmr->nr_ringid & NETMAP_HW_RING) { 82 regmode = NR_REG_ONE_NIC; 83 } else { 84 regmode = NR_REG_ALL_NIC; 85 } 86 req->nr_mode = regmode; 87 } else { 88 req->nr_mode = nmr->nr_flags & NR_REG_MASK; 89 } 90 91 /* Fix nr_name, nr_mode and nr_ringid to handle pipe requests. */ 92 if (req->nr_mode == NR_REG_PIPE_MASTER || 93 req->nr_mode == NR_REG_PIPE_SLAVE) { 94 char suffix[10]; 95 snprintf(suffix, sizeof(suffix), "%c%d", 96 (req->nr_mode == NR_REG_PIPE_MASTER ? '{' : '}'), 97 req->nr_ringid); 98 if (strlen(hdr->nr_name) + strlen(suffix) 99 >= sizeof(hdr->nr_name)) { 100 /* No space for the pipe suffix. */ 101 return ENOBUFS; 102 } 103 strlcat(hdr->nr_name, suffix, sizeof(hdr->nr_name)); 104 req->nr_mode = NR_REG_ALL_NIC; 105 req->nr_ringid = 0; 106 } 107 req->nr_flags = nmr->nr_flags & (~NR_REG_MASK); 108 if (nmr->nr_ringid & NETMAP_NO_TX_POLL) { 109 req->nr_flags |= NR_NO_TX_POLL; 110 } 111 if (nmr->nr_ringid & NETMAP_DO_RX_POLL) { 112 req->nr_flags |= NR_DO_RX_POLL; 113 } 114 /* nmr->nr_arg1 (nr_pipes) ignored */ 115 req->nr_extra_bufs = nmr->nr_arg3; 116 117 return 0; 118 } 119 120 /* Convert the legacy 'nmr' struct into one of the nmreq_xyz structs 121 * (new API). The new struct is dynamically allocated. */ 122 static struct nmreq_header * 123 nmreq_from_legacy(struct nmreq *nmr, u_long ioctl_cmd) 124 { 125 struct nmreq_header *hdr = nm_os_malloc(sizeof(*hdr)); 126 127 if (hdr == NULL) { 128 goto oom; 129 } 130 131 /* Sanitize nmr->nr_name by adding the string terminator. */ 132 if (ioctl_cmd == NIOCGINFO || ioctl_cmd == NIOCREGIF) { 133 nmr->nr_name[sizeof(nmr->nr_name) - 1] = '\0'; 134 } 135 136 /* First prepare the request header. */ 137 hdr->nr_version = NETMAP_API; /* new API */ 138 strlcpy(hdr->nr_name, nmr->nr_name, sizeof(nmr->nr_name)); 139 hdr->nr_options = (uintptr_t)NULL; 140 hdr->nr_body = (uintptr_t)NULL; 141 142 switch (ioctl_cmd) { 143 case NIOCREGIF: { 144 switch (nmr->nr_cmd) { 145 case 0: { 146 /* Regular NIOCREGIF operation. */ 147 struct nmreq_register *req = nm_os_malloc(sizeof(*req)); 148 if (!req) { goto oom; } 149 hdr->nr_body = (uintptr_t)req; 150 hdr->nr_reqtype = NETMAP_REQ_REGISTER; 151 if (nmreq_register_from_legacy(nmr, hdr, req)) { 152 goto oom; 153 } 154 break; 155 } 156 case NETMAP_BDG_ATTACH: { 157 struct nmreq_vale_attach *req = nm_os_malloc(sizeof(*req)); 158 if (!req) { goto oom; } 159 hdr->nr_body = (uintptr_t)req; 160 hdr->nr_reqtype = NETMAP_REQ_VALE_ATTACH; 161 if (nmreq_register_from_legacy(nmr, hdr, &req->reg)) { 162 goto oom; 163 } 164 /* Fix nr_mode, starting from nr_arg1. */ 165 if (nmr->nr_arg1 & NETMAP_BDG_HOST) { 166 req->reg.nr_mode = NR_REG_NIC_SW; 167 } else { 168 req->reg.nr_mode = NR_REG_ALL_NIC; 169 } 170 break; 171 } 172 case NETMAP_BDG_DETACH: { 173 hdr->nr_reqtype = NETMAP_REQ_VALE_DETACH; 174 hdr->nr_body = (uintptr_t)nm_os_malloc(sizeof(struct nmreq_vale_detach)); 175 break; 176 } 177 case NETMAP_BDG_VNET_HDR: 178 case NETMAP_VNET_HDR_GET: { 179 struct nmreq_port_hdr *req = nm_os_malloc(sizeof(*req)); 180 if (!req) { goto oom; } 181 hdr->nr_body = (uintptr_t)req; 182 hdr->nr_reqtype = (nmr->nr_cmd == NETMAP_BDG_VNET_HDR) ? 183 NETMAP_REQ_PORT_HDR_SET : NETMAP_REQ_PORT_HDR_GET; 184 req->nr_hdr_len = nmr->nr_arg1; 185 break; 186 } 187 case NETMAP_BDG_NEWIF : { 188 struct nmreq_vale_newif *req = nm_os_malloc(sizeof(*req)); 189 if (!req) { goto oom; } 190 hdr->nr_body = (uintptr_t)req; 191 hdr->nr_reqtype = NETMAP_REQ_VALE_NEWIF; 192 req->nr_tx_slots = nmr->nr_tx_slots; 193 req->nr_rx_slots = nmr->nr_rx_slots; 194 req->nr_tx_rings = nmr->nr_tx_rings; 195 req->nr_rx_rings = nmr->nr_rx_rings; 196 req->nr_mem_id = nmr->nr_arg2; 197 break; 198 } 199 case NETMAP_BDG_DELIF: { 200 hdr->nr_reqtype = NETMAP_REQ_VALE_DELIF; 201 break; 202 } 203 case NETMAP_BDG_POLLING_ON: 204 case NETMAP_BDG_POLLING_OFF: { 205 struct nmreq_vale_polling *req = nm_os_malloc(sizeof(*req)); 206 if (!req) { goto oom; } 207 hdr->nr_body = (uintptr_t)req; 208 hdr->nr_reqtype = (nmr->nr_cmd == NETMAP_BDG_POLLING_ON) ? 209 NETMAP_REQ_VALE_POLLING_ENABLE : 210 NETMAP_REQ_VALE_POLLING_DISABLE; 211 switch (nmr->nr_flags & NR_REG_MASK) { 212 default: 213 req->nr_mode = 0; /* invalid */ 214 break; 215 case NR_REG_ONE_NIC: 216 req->nr_mode = NETMAP_POLLING_MODE_MULTI_CPU; 217 break; 218 case NR_REG_ALL_NIC: 219 req->nr_mode = NETMAP_POLLING_MODE_SINGLE_CPU; 220 break; 221 } 222 req->nr_first_cpu_id = nmr->nr_ringid & NETMAP_RING_MASK; 223 req->nr_num_polling_cpus = nmr->nr_arg1; 224 break; 225 } 226 case NETMAP_PT_HOST_CREATE: 227 case NETMAP_PT_HOST_DELETE: { 228 nm_prerr("Netmap passthrough not supported yet"); 229 return NULL; 230 break; 231 } 232 } 233 break; 234 } 235 case NIOCGINFO: { 236 if (nmr->nr_cmd == NETMAP_BDG_LIST) { 237 struct nmreq_vale_list *req = nm_os_malloc(sizeof(*req)); 238 if (!req) { goto oom; } 239 hdr->nr_body = (uintptr_t)req; 240 hdr->nr_reqtype = NETMAP_REQ_VALE_LIST; 241 req->nr_bridge_idx = nmr->nr_arg1; 242 req->nr_port_idx = nmr->nr_arg2; 243 } else { 244 /* Regular NIOCGINFO. */ 245 struct nmreq_port_info_get *req = nm_os_malloc(sizeof(*req)); 246 if (!req) { goto oom; } 247 hdr->nr_body = (uintptr_t)req; 248 hdr->nr_reqtype = NETMAP_REQ_PORT_INFO_GET; 249 req->nr_memsize = nmr->nr_memsize; 250 req->nr_tx_slots = nmr->nr_tx_slots; 251 req->nr_rx_slots = nmr->nr_rx_slots; 252 req->nr_tx_rings = nmr->nr_tx_rings; 253 req->nr_rx_rings = nmr->nr_rx_rings; 254 req->nr_host_tx_rings = 0; 255 req->nr_host_rx_rings = 0; 256 req->nr_mem_id = nmr->nr_arg2; 257 } 258 break; 259 } 260 } 261 262 return hdr; 263 oom: 264 if (hdr) { 265 if (hdr->nr_body) { 266 nm_os_free((void *)(uintptr_t)hdr->nr_body); 267 } 268 nm_os_free(hdr); 269 } 270 nm_prerr("Failed to allocate memory for nmreq_xyz struct"); 271 272 return NULL; 273 } 274 275 static void 276 nmreq_register_to_legacy(const struct nmreq_register *req, struct nmreq *nmr) 277 { 278 nmr->nr_offset = req->nr_offset; 279 nmr->nr_memsize = req->nr_memsize; 280 nmr->nr_tx_slots = req->nr_tx_slots; 281 nmr->nr_rx_slots = req->nr_rx_slots; 282 nmr->nr_tx_rings = req->nr_tx_rings; 283 nmr->nr_rx_rings = req->nr_rx_rings; 284 nmr->nr_arg2 = req->nr_mem_id; 285 nmr->nr_arg3 = req->nr_extra_bufs; 286 } 287 288 /* Convert a nmreq_xyz struct (new API) to the legacy 'nmr' struct. 289 * It also frees the nmreq_xyz struct, as it was allocated by 290 * nmreq_from_legacy(). */ 291 static int 292 nmreq_to_legacy(struct nmreq_header *hdr, struct nmreq *nmr) 293 { 294 int ret = 0; 295 296 /* We only write-back the fields that the user expects to be 297 * written back. */ 298 switch (hdr->nr_reqtype) { 299 case NETMAP_REQ_REGISTER: { 300 struct nmreq_register *req = 301 (struct nmreq_register *)(uintptr_t)hdr->nr_body; 302 nmreq_register_to_legacy(req, nmr); 303 break; 304 } 305 case NETMAP_REQ_PORT_INFO_GET: { 306 struct nmreq_port_info_get *req = 307 (struct nmreq_port_info_get *)(uintptr_t)hdr->nr_body; 308 nmr->nr_memsize = req->nr_memsize; 309 nmr->nr_tx_slots = req->nr_tx_slots; 310 nmr->nr_rx_slots = req->nr_rx_slots; 311 nmr->nr_tx_rings = req->nr_tx_rings; 312 nmr->nr_rx_rings = req->nr_rx_rings; 313 nmr->nr_arg2 = req->nr_mem_id; 314 break; 315 } 316 case NETMAP_REQ_VALE_ATTACH: { 317 struct nmreq_vale_attach *req = 318 (struct nmreq_vale_attach *)(uintptr_t)hdr->nr_body; 319 nmreq_register_to_legacy(&req->reg, nmr); 320 break; 321 } 322 case NETMAP_REQ_VALE_DETACH: { 323 break; 324 } 325 case NETMAP_REQ_VALE_LIST: { 326 struct nmreq_vale_list *req = 327 (struct nmreq_vale_list *)(uintptr_t)hdr->nr_body; 328 strlcpy(nmr->nr_name, hdr->nr_name, sizeof(nmr->nr_name)); 329 nmr->nr_arg1 = req->nr_bridge_idx; 330 nmr->nr_arg2 = req->nr_port_idx; 331 break; 332 } 333 case NETMAP_REQ_PORT_HDR_SET: 334 case NETMAP_REQ_PORT_HDR_GET: { 335 struct nmreq_port_hdr *req = 336 (struct nmreq_port_hdr *)(uintptr_t)hdr->nr_body; 337 nmr->nr_arg1 = req->nr_hdr_len; 338 break; 339 } 340 case NETMAP_REQ_VALE_NEWIF: { 341 struct nmreq_vale_newif *req = 342 (struct nmreq_vale_newif *)(uintptr_t)hdr->nr_body; 343 nmr->nr_tx_slots = req->nr_tx_slots; 344 nmr->nr_rx_slots = req->nr_rx_slots; 345 nmr->nr_tx_rings = req->nr_tx_rings; 346 nmr->nr_rx_rings = req->nr_rx_rings; 347 nmr->nr_arg2 = req->nr_mem_id; 348 break; 349 } 350 case NETMAP_REQ_VALE_DELIF: 351 case NETMAP_REQ_VALE_POLLING_ENABLE: 352 case NETMAP_REQ_VALE_POLLING_DISABLE: { 353 break; 354 } 355 } 356 357 return ret; 358 } 359 360 int 361 netmap_ioctl_legacy(struct netmap_priv_d *priv, u_long cmd, caddr_t data, 362 struct thread *td) 363 { 364 int error = 0; 365 366 switch (cmd) { 367 case NIOCGINFO: 368 case NIOCREGIF: { 369 /* Request for the legacy control API. Convert it to a 370 * NIOCCTRL request. */ 371 struct nmreq *nmr = (struct nmreq *) data; 372 struct nmreq_header *hdr; 373 374 if (nmr->nr_version < 14) { 375 nm_prerr("Minimum supported API is 14 (requested %u)", 376 nmr->nr_version); 377 return EINVAL; 378 } 379 hdr = nmreq_from_legacy(nmr, cmd); 380 if (hdr == NULL) { /* out of memory */ 381 return ENOMEM; 382 } 383 error = netmap_ioctl(priv, NIOCCTRL, (caddr_t)hdr, td, 384 /*nr_body_is_user=*/0); 385 if (error == 0) { 386 nmreq_to_legacy(hdr, nmr); 387 } 388 if (hdr->nr_body) { 389 nm_os_free((void *)(uintptr_t)hdr->nr_body); 390 } 391 nm_os_free(hdr); 392 break; 393 } 394 #ifdef WITH_VALE 395 case NIOCCONFIG: { 396 struct nm_ifreq *nr = (struct nm_ifreq *)data; 397 error = netmap_bdg_config(nr); 398 break; 399 } 400 #endif 401 #ifdef __FreeBSD__ 402 case FIONBIO: 403 case FIOASYNC: 404 /* FIONBIO/FIOASYNC are no-ops. */ 405 break; 406 407 case BIOCIMMEDIATE: 408 case BIOCGHDRCMPLT: 409 case BIOCSHDRCMPLT: 410 case BIOCSSEESENT: 411 /* Ignore these commands. */ 412 break; 413 414 default: /* allow device-specific ioctls */ 415 { 416 struct nmreq *nmr = (struct nmreq *)data; 417 struct ifnet *ifp = ifunit_ref(nmr->nr_name); 418 if (ifp == NULL) { 419 error = ENXIO; 420 } else { 421 struct socket so; 422 423 bzero(&so, sizeof(so)); 424 so.so_vnet = ifp->if_vnet; 425 // so->so_proto not null. 426 error = ifioctl(&so, cmd, data, td); 427 if_rele(ifp); 428 } 429 break; 430 } 431 432 #else /* linux */ 433 default: 434 error = EOPNOTSUPP; 435 #endif /* linux */ 436 } 437 438 return error; 439 } 440