1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (C) 2018 Universita` di Pisa 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 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 * $FreeBSD$ 30 */ 31 32 #include <sys/types.h> 33 #include <sys/stat.h> 34 #include <sys/ioctl.h> 35 #include <sys/mman.h> 36 #include <fcntl.h> 37 #include <inttypes.h> 38 #include <stdlib.h> 39 #include <stdio.h> 40 #include <stdarg.h> 41 #include <string.h> 42 #include <unistd.h> 43 #include <errno.h> 44 #include <net/netmap_user.h> 45 #define LIBNETMAP_NOTHREADSAFE 46 #include "libnetmap.h" 47 48 struct nmport_cleanup_d { 49 struct nmport_cleanup_d *next; 50 void (*cleanup)(struct nmport_cleanup_d *, struct nmport_d *); 51 }; 52 53 static void 54 nmport_push_cleanup(struct nmport_d *d, struct nmport_cleanup_d *c) 55 { 56 c->next = d->clist; 57 d->clist = c; 58 } 59 60 static void 61 nmport_pop_cleanup(struct nmport_d *d) 62 { 63 struct nmport_cleanup_d *top; 64 65 top = d->clist; 66 d->clist = d->clist->next; 67 (*top->cleanup)(top, d); 68 nmctx_free(d->ctx, top); 69 } 70 71 void nmport_do_cleanup(struct nmport_d *d) 72 { 73 while (d->clist != NULL) { 74 nmport_pop_cleanup(d); 75 } 76 } 77 78 static struct nmport_d * 79 nmport_new_with_ctx(struct nmctx *ctx) 80 { 81 struct nmport_d *d; 82 83 /* allocate a descriptor */ 84 d = nmctx_malloc(ctx, sizeof(*d)); 85 if (d == NULL) { 86 nmctx_ferror(ctx, "cannot allocate nmport descriptor"); 87 goto out; 88 } 89 memset(d, 0, sizeof(*d)); 90 91 nmreq_header_init(&d->hdr, NETMAP_REQ_REGISTER, &d->reg); 92 93 d->ctx = ctx; 94 d->fd = -1; 95 96 out: 97 return d; 98 } 99 100 struct nmport_d * 101 nmport_new(void) 102 { 103 struct nmctx *ctx = nmctx_get(); 104 return nmport_new_with_ctx(ctx); 105 } 106 107 108 void 109 nmport_delete(struct nmport_d *d) 110 { 111 nmctx_free(d->ctx, d); 112 } 113 114 void 115 nmport_extmem_cleanup(struct nmport_cleanup_d *c, struct nmport_d *d) 116 { 117 (void)c; 118 119 if (d->extmem == NULL) 120 return; 121 122 nmreq_remove_option(&d->hdr, &d->extmem->nro_opt); 123 nmctx_free(d->ctx, d->extmem); 124 d->extmem = NULL; 125 } 126 127 128 int 129 nmport_extmem(struct nmport_d *d, void *base, size_t size) 130 { 131 struct nmctx *ctx = d->ctx; 132 struct nmport_cleanup_d *clnup = NULL; 133 134 if (d->register_done) { 135 nmctx_ferror(ctx, "%s: cannot set extmem of an already registered port", d->hdr.nr_name); 136 errno = EINVAL; 137 return -1; 138 } 139 140 if (d->extmem != NULL) { 141 nmctx_ferror(ctx, "%s: extmem already in use", d->hdr.nr_name); 142 errno = EINVAL; 143 return -1; 144 } 145 146 clnup = (struct nmport_cleanup_d *)nmctx_malloc(ctx, sizeof(*clnup)); 147 if (clnup == NULL) { 148 nmctx_ferror(ctx, "failed to allocate cleanup descriptor"); 149 errno = ENOMEM; 150 return -1; 151 } 152 153 d->extmem = nmctx_malloc(ctx, sizeof(*d->extmem)); 154 if (d->extmem == NULL) { 155 nmctx_ferror(ctx, "%s: cannot allocate extmem option", d->hdr.nr_name); 156 nmctx_free(ctx, clnup); 157 errno = ENOMEM; 158 return -1; 159 } 160 memset(d->extmem, 0, sizeof(*d->extmem)); 161 d->extmem->nro_usrptr = (uintptr_t)base; 162 d->extmem->nro_opt.nro_reqtype = NETMAP_REQ_OPT_EXTMEM; 163 d->extmem->nro_info.nr_memsize = size; 164 nmreq_push_option(&d->hdr, &d->extmem->nro_opt); 165 166 clnup->cleanup = nmport_extmem_cleanup; 167 nmport_push_cleanup(d, clnup); 168 169 return 0; 170 } 171 172 struct nmport_extmem_from_file_cleanup_d { 173 struct nmport_cleanup_d up; 174 void *p; 175 size_t size; 176 }; 177 178 void nmport_extmem_from_file_cleanup(struct nmport_cleanup_d *c, 179 struct nmport_d *d) 180 { 181 (void)d; 182 struct nmport_extmem_from_file_cleanup_d *cc = 183 (struct nmport_extmem_from_file_cleanup_d *)c; 184 185 munmap(cc->p, cc->size); 186 } 187 188 int 189 nmport_extmem_from_file(struct nmport_d *d, const char *fname) 190 { 191 struct nmctx *ctx = d->ctx; 192 int fd = -1; 193 off_t mapsize; 194 void *p; 195 struct nmport_extmem_from_file_cleanup_d *clnup = NULL; 196 197 clnup = nmctx_malloc(ctx, sizeof(*clnup)); 198 if (clnup == NULL) { 199 nmctx_ferror(ctx, "cannot allocate cleanup descriptor"); 200 errno = ENOMEM; 201 goto fail; 202 } 203 204 fd = open(fname, O_RDWR); 205 if (fd < 0) { 206 nmctx_ferror(ctx, "cannot open '%s': %s", fname, strerror(errno)); 207 goto fail; 208 } 209 mapsize = lseek(fd, 0, SEEK_END); 210 if (mapsize < 0) { 211 nmctx_ferror(ctx, "failed to obtain filesize of '%s': %s", fname, strerror(errno)); 212 goto fail; 213 } 214 p = mmap(0, mapsize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); 215 if (p == MAP_FAILED) { 216 nmctx_ferror(ctx, "cannot mmap '%s': %s", fname, strerror(errno)); 217 goto fail; 218 } 219 close(fd); 220 221 clnup->p = p; 222 clnup->size = mapsize; 223 clnup->up.cleanup = nmport_extmem_from_file_cleanup; 224 nmport_push_cleanup(d, &clnup->up); 225 226 if (nmport_extmem(d, p, mapsize) < 0) 227 goto fail; 228 229 return 0; 230 231 fail: 232 if (fd >= 0) 233 close(fd); 234 if (clnup != NULL) { 235 if (clnup->p != MAP_FAILED) 236 nmport_pop_cleanup(d); 237 else 238 nmctx_free(ctx, clnup); 239 } 240 return -1; 241 } 242 243 struct nmreq_pools_info* 244 nmport_extmem_getinfo(struct nmport_d *d) 245 { 246 if (d->extmem == NULL) 247 return NULL; 248 return &d->extmem->nro_info; 249 } 250 251 struct nmport_offset_cleanup_d { 252 struct nmport_cleanup_d up; 253 struct nmreq_opt_offsets *opt; 254 }; 255 256 static void 257 nmport_offset_cleanup(struct nmport_cleanup_d *c, 258 struct nmport_d *d) 259 { 260 struct nmport_offset_cleanup_d *cc = 261 (struct nmport_offset_cleanup_d *)c; 262 263 nmreq_remove_option(&d->hdr, &cc->opt->nro_opt); 264 nmctx_free(d->ctx, cc->opt); 265 } 266 267 int 268 nmport_offset(struct nmport_d *d, uint64_t initial, 269 uint64_t maxoff, uint64_t bits, uint64_t mingap) 270 { 271 struct nmctx *ctx = d->ctx; 272 struct nmreq_opt_offsets *opt; 273 struct nmport_offset_cleanup_d *clnup = NULL; 274 275 clnup = nmctx_malloc(ctx, sizeof(*clnup)); 276 if (clnup == NULL) { 277 nmctx_ferror(ctx, "cannot allocate cleanup descriptor"); 278 errno = ENOMEM; 279 return -1; 280 } 281 282 opt = nmctx_malloc(ctx, sizeof(*opt)); 283 if (opt == NULL) { 284 nmctx_ferror(ctx, "%s: cannot allocate offset option", d->hdr.nr_name); 285 nmctx_free(ctx, clnup); 286 errno = ENOMEM; 287 return -1; 288 } 289 memset(opt, 0, sizeof(*opt)); 290 opt->nro_opt.nro_reqtype = NETMAP_REQ_OPT_OFFSETS; 291 opt->nro_offset_bits = bits; 292 opt->nro_initial_offset = initial; 293 opt->nro_max_offset = maxoff; 294 opt->nro_min_gap = mingap; 295 nmreq_push_option(&d->hdr, &opt->nro_opt); 296 297 clnup->up.cleanup = nmport_offset_cleanup; 298 clnup->opt = opt; 299 nmport_push_cleanup(d, &clnup->up); 300 301 return 0; 302 } 303 304 /* head of the list of options */ 305 static struct nmreq_opt_parser *nmport_opt_parsers; 306 307 #define NPOPT_PARSER(o) nmport_opt_##o##_parser 308 #define NPOPT_DESC(o) nmport_opt_##o##_desc 309 #define NPOPT_NRKEYS(o) (NPOPT_DESC(o).nr_keys) 310 #define NPOPT_DECL(o, f) \ 311 static int NPOPT_PARSER(o)(struct nmreq_parse_ctx *); \ 312 static struct nmreq_opt_parser NPOPT_DESC(o) = { \ 313 .prefix = #o, \ 314 .parse = NPOPT_PARSER(o), \ 315 .flags = (f), \ 316 .default_key = -1, \ 317 .nr_keys = 0, \ 318 .next = NULL, \ 319 }; \ 320 static void __attribute__((constructor)) \ 321 nmport_opt_##o##_ctor(void) \ 322 { \ 323 NPOPT_DESC(o).next = nmport_opt_parsers; \ 324 nmport_opt_parsers = &NPOPT_DESC(o); \ 325 } 326 struct nmport_key_desc { 327 struct nmreq_opt_parser *option; 328 const char *key; 329 unsigned int flags; 330 int id; 331 }; 332 static void 333 nmport_opt_key_ctor(struct nmport_key_desc *k) 334 { 335 struct nmreq_opt_parser *o = k->option; 336 struct nmreq_opt_key *ok; 337 338 k->id = o->nr_keys; 339 ok = &o->keys[k->id]; 340 ok->key = k->key; 341 ok->id = k->id; 342 ok->flags = k->flags; 343 o->nr_keys++; 344 if (ok->flags & NMREQ_OPTK_DEFAULT) 345 o->default_key = ok->id; 346 } 347 #define NPKEY_DESC(o, k) nmport_opt_##o##_key_##k##_desc 348 #define NPKEY_ID(o, k) (NPKEY_DESC(o, k).id) 349 #define NPKEY_DECL(o, k, f) \ 350 static struct nmport_key_desc NPKEY_DESC(o, k) = { \ 351 .option = &NPOPT_DESC(o), \ 352 .key = #k, \ 353 .flags = (f), \ 354 .id = -1, \ 355 }; \ 356 static void __attribute__((constructor)) \ 357 nmport_opt_##o##_key_##k##_ctor(void) \ 358 { \ 359 nmport_opt_key_ctor(&NPKEY_DESC(o, k)); \ 360 } 361 #define nmport_key(p, o, k) ((p)->keys[NPKEY_ID(o, k)]) 362 #define nmport_defkey(p, o) ((p)->keys[NPOPT_DESC(o).default_key]) 363 364 NPOPT_DECL(share, 0) 365 NPKEY_DECL(share, port, NMREQ_OPTK_DEFAULT|NMREQ_OPTK_MUSTSET) 366 NPOPT_DECL(extmem, 0) 367 NPKEY_DECL(extmem, file, NMREQ_OPTK_DEFAULT|NMREQ_OPTK_MUSTSET) 368 NPKEY_DECL(extmem, if_num, 0) 369 NPKEY_DECL(extmem, if_size, 0) 370 NPKEY_DECL(extmem, ring_num, 0) 371 NPKEY_DECL(extmem, ring_size, 0) 372 NPKEY_DECL(extmem, buf_num, 0) 373 NPKEY_DECL(extmem, buf_size, 0) 374 NPOPT_DECL(conf, 0) 375 NPKEY_DECL(conf, rings, 0) 376 NPKEY_DECL(conf, host_rings, 0) 377 NPKEY_DECL(conf, slots, 0) 378 NPKEY_DECL(conf, tx_rings, 0) 379 NPKEY_DECL(conf, rx_rings, 0) 380 NPKEY_DECL(conf, host_tx_rings, 0) 381 NPKEY_DECL(conf, host_rx_rings, 0) 382 NPKEY_DECL(conf, tx_slots, 0) 383 NPKEY_DECL(conf, rx_slots, 0) 384 NPOPT_DECL(offset, NMREQ_OPTF_DISABLED) 385 NPKEY_DECL(offset, initial, NMREQ_OPTK_DEFAULT|NMREQ_OPTK_MUSTSET) 386 NPKEY_DECL(offset, bits, 0) 387 388 389 static int 390 NPOPT_PARSER(share)(struct nmreq_parse_ctx *p) 391 { 392 struct nmctx *ctx = p->ctx; 393 struct nmport_d *d = p->token; 394 int32_t mem_id; 395 const char *v = nmport_defkey(p, share); 396 397 mem_id = nmreq_get_mem_id(&v, ctx); 398 if (mem_id < 0) 399 return -1; 400 if (d->reg.nr_mem_id && d->reg.nr_mem_id != mem_id) { 401 nmctx_ferror(ctx, "cannot set mem_id to %"PRId32", already set to %"PRIu16"", 402 mem_id, d->reg.nr_mem_id); 403 errno = EINVAL; 404 return -1; 405 } 406 d->reg.nr_mem_id = mem_id; 407 return 0; 408 } 409 410 static int 411 NPOPT_PARSER(extmem)(struct nmreq_parse_ctx *p) 412 { 413 struct nmport_d *d; 414 struct nmreq_pools_info *pi; 415 int i; 416 417 d = p->token; 418 419 if (nmport_extmem_from_file(d, nmport_key(p, extmem, file)) < 0) 420 return -1; 421 422 pi = &d->extmem->nro_info; 423 424 for (i = 0; i < NPOPT_NRKEYS(extmem); i++) { 425 const char *k = p->keys[i]; 426 uint32_t v; 427 428 if (k == NULL) 429 continue; 430 431 v = atoi(k); 432 if (i == NPKEY_ID(extmem, if_num)) { 433 pi->nr_if_pool_objtotal = v; 434 } else if (i == NPKEY_ID(extmem, if_size)) { 435 pi->nr_if_pool_objsize = v; 436 } else if (i == NPKEY_ID(extmem, ring_num)) { 437 pi->nr_ring_pool_objtotal = v; 438 } else if (i == NPKEY_ID(extmem, ring_size)) { 439 pi->nr_ring_pool_objsize = v; 440 } else if (i == NPKEY_ID(extmem, buf_num)) { 441 pi->nr_buf_pool_objtotal = v; 442 } else if (i == NPKEY_ID(extmem, buf_size)) { 443 pi->nr_buf_pool_objsize = v; 444 } 445 } 446 return 0; 447 } 448 449 static int 450 NPOPT_PARSER(conf)(struct nmreq_parse_ctx *p) 451 { 452 struct nmport_d *d; 453 454 d = p->token; 455 456 if (nmport_key(p, conf, rings) != NULL) { 457 uint16_t nr_rings = atoi(nmport_key(p, conf, rings)); 458 d->reg.nr_tx_rings = nr_rings; 459 d->reg.nr_rx_rings = nr_rings; 460 } 461 if (nmport_key(p, conf, host_rings) != NULL) { 462 uint16_t nr_rings = atoi(nmport_key(p, conf, host_rings)); 463 d->reg.nr_host_tx_rings = nr_rings; 464 d->reg.nr_host_rx_rings = nr_rings; 465 } 466 if (nmport_key(p, conf, slots) != NULL) { 467 uint32_t nr_slots = atoi(nmport_key(p, conf, slots)); 468 d->reg.nr_tx_slots = nr_slots; 469 d->reg.nr_rx_slots = nr_slots; 470 } 471 if (nmport_key(p, conf, tx_rings) != NULL) { 472 d->reg.nr_tx_rings = atoi(nmport_key(p, conf, tx_rings)); 473 } 474 if (nmport_key(p, conf, rx_rings) != NULL) { 475 d->reg.nr_rx_rings = atoi(nmport_key(p, conf, rx_rings)); 476 } 477 if (nmport_key(p, conf, host_tx_rings) != NULL) { 478 d->reg.nr_host_tx_rings = atoi(nmport_key(p, conf, host_tx_rings)); 479 } 480 if (nmport_key(p, conf, host_rx_rings) != NULL) { 481 d->reg.nr_host_rx_rings = atoi(nmport_key(p, conf, host_rx_rings)); 482 } 483 if (nmport_key(p, conf, tx_slots) != NULL) { 484 d->reg.nr_tx_slots = atoi(nmport_key(p, conf, tx_slots)); 485 } 486 if (nmport_key(p, conf, rx_slots) != NULL) { 487 d->reg.nr_rx_slots = atoi(nmport_key(p, conf, rx_slots)); 488 } 489 return 0; 490 } 491 492 static int 493 NPOPT_PARSER(offset)(struct nmreq_parse_ctx *p) 494 { 495 struct nmport_d *d; 496 uint64_t initial, bits; 497 498 d = p->token; 499 500 initial = atoi(nmport_key(p, offset, initial)); 501 bits = 0; 502 if (nmport_key(p, offset, bits) != NULL) 503 bits = atoi(nmport_key(p, offset, bits)); 504 505 return nmport_offset(d, initial, initial, bits, 0); 506 } 507 508 509 void 510 nmport_disable_option(const char *opt) 511 { 512 struct nmreq_opt_parser *p; 513 514 for (p = nmport_opt_parsers; p != NULL; p = p->next) { 515 if (!strcmp(p->prefix, opt)) { 516 p->flags |= NMREQ_OPTF_DISABLED; 517 } 518 } 519 } 520 521 int 522 nmport_enable_option(const char *opt) 523 { 524 struct nmreq_opt_parser *p; 525 526 for (p = nmport_opt_parsers; p != NULL; p = p->next) { 527 if (!strcmp(p->prefix, opt)) { 528 p->flags &= ~NMREQ_OPTF_DISABLED; 529 return 0; 530 } 531 } 532 errno = EOPNOTSUPP; 533 return -1; 534 } 535 536 537 int 538 nmport_parse(struct nmport_d *d, const char *ifname) 539 { 540 const char *scan = ifname; 541 542 if (nmreq_header_decode(&scan, &d->hdr, d->ctx) < 0) { 543 goto err; 544 } 545 546 /* parse the register request */ 547 if (nmreq_register_decode(&scan, &d->reg, d->ctx) < 0) { 548 goto err; 549 } 550 551 /* parse the options, if any */ 552 if (nmreq_options_decode(scan, nmport_opt_parsers, d, d->ctx) < 0) { 553 goto err; 554 } 555 return 0; 556 557 err: 558 nmport_undo_parse(d); 559 return -1; 560 } 561 562 void 563 nmport_undo_parse(struct nmport_d *d) 564 { 565 nmport_do_cleanup(d); 566 memset(&d->reg, 0, sizeof(d->reg)); 567 memset(&d->hdr, 0, sizeof(d->hdr)); 568 } 569 570 struct nmport_d * 571 nmport_prepare(const char *ifname) 572 { 573 struct nmport_d *d; 574 575 /* allocate a descriptor */ 576 d = nmport_new(); 577 if (d == NULL) 578 goto err; 579 580 /* parse the header */ 581 if (nmport_parse(d, ifname) < 0) 582 goto err; 583 584 return d; 585 586 err: 587 nmport_undo_prepare(d); 588 return NULL; 589 } 590 591 void 592 nmport_undo_prepare(struct nmport_d *d) 593 { 594 if (d == NULL) 595 return; 596 nmport_undo_parse(d); 597 nmport_delete(d); 598 } 599 600 int 601 nmport_register(struct nmport_d *d) 602 { 603 struct nmctx *ctx = d->ctx; 604 605 if (d->register_done) { 606 errno = EINVAL; 607 nmctx_ferror(ctx, "%s: already registered", d->hdr.nr_name); 608 return -1; 609 } 610 611 d->fd = open("/dev/netmap", O_RDWR); 612 if (d->fd < 0) { 613 nmctx_ferror(ctx, "/dev/netmap: %s", strerror(errno)); 614 goto err; 615 } 616 617 if (ioctl(d->fd, NIOCCTRL, &d->hdr) < 0) { 618 struct nmreq_option *o; 619 int option_errors = 0; 620 621 nmreq_foreach_option(&d->hdr, o) { 622 if (o->nro_status) { 623 nmctx_ferror(ctx, "%s: option %s: %s", 624 d->hdr.nr_name, 625 nmreq_option_name(o->nro_reqtype), 626 strerror(o->nro_status)); 627 option_errors++; 628 } 629 630 } 631 if (!option_errors) 632 nmctx_ferror(ctx, "%s: %s", d->hdr.nr_name, strerror(errno)); 633 goto err; 634 } 635 636 d->register_done = 1; 637 638 return 0; 639 640 err: 641 nmport_undo_register(d); 642 return -1; 643 } 644 645 void 646 nmport_undo_register(struct nmport_d *d) 647 { 648 if (d->fd >= 0) 649 close(d->fd); 650 d->fd = -1; 651 d->register_done = 0; 652 } 653 654 /* lookup the mem_id in the mem-list: do a new mmap() if 655 * not found, reuse existing otherwise 656 */ 657 int 658 nmport_mmap(struct nmport_d *d) 659 { 660 struct nmctx *ctx = d->ctx; 661 struct nmem_d *m = NULL; 662 u_int num_tx, num_rx; 663 unsigned int i; 664 665 if (d->mmap_done) { 666 errno = EINVAL; 667 nmctx_ferror(ctx, "%s: already mapped", d->hdr.nr_name); 668 return -1; 669 } 670 671 if (!d->register_done) { 672 errno = EINVAL; 673 nmctx_ferror(ctx, "cannot map unregistered port"); 674 return -1; 675 } 676 677 nmctx_lock(ctx); 678 679 for (m = ctx->mem_descs; m != NULL; m = m->next) 680 if (m->mem_id == d->reg.nr_mem_id) 681 break; 682 683 if (m == NULL) { 684 m = nmctx_malloc(ctx, sizeof(*m)); 685 if (m == NULL) { 686 nmctx_ferror(ctx, "cannot allocate memory descriptor"); 687 goto err; 688 } 689 memset(m, 0, sizeof(*m)); 690 if (d->extmem != NULL) { 691 m->mem = (void *)((uintptr_t)d->extmem->nro_usrptr); 692 m->size = d->extmem->nro_info.nr_memsize; 693 m->is_extmem = 1; 694 } else { 695 m->mem = mmap(NULL, d->reg.nr_memsize, PROT_READ|PROT_WRITE, 696 MAP_SHARED, d->fd, 0); 697 if (m->mem == MAP_FAILED) { 698 nmctx_ferror(ctx, "mmap: %s", strerror(errno)); 699 goto err; 700 } 701 m->size = d->reg.nr_memsize; 702 } 703 m->mem_id = d->reg.nr_mem_id; 704 m->next = ctx->mem_descs; 705 if (ctx->mem_descs != NULL) 706 ctx->mem_descs->prev = m; 707 ctx->mem_descs = m; 708 } 709 m->refcount++; 710 711 nmctx_unlock(ctx); 712 713 d->mem = m; 714 715 d->nifp = NETMAP_IF(m->mem, d->reg.nr_offset); 716 717 num_tx = d->reg.nr_tx_rings + d->nifp->ni_host_tx_rings; 718 for (i = 0; i < num_tx && !d->nifp->ring_ofs[i]; i++) 719 ; 720 d->cur_tx_ring = d->first_tx_ring = i; 721 for ( ; i < num_tx && d->nifp->ring_ofs[i]; i++) 722 ; 723 d->last_tx_ring = i - 1; 724 725 num_rx = d->reg.nr_rx_rings + d->nifp->ni_host_rx_rings; 726 for (i = 0; i < num_rx && !d->nifp->ring_ofs[i + num_tx]; i++) 727 ; 728 d->cur_rx_ring = d->first_rx_ring = i; 729 for ( ; i < num_rx && d->nifp->ring_ofs[i + num_tx]; i++) 730 ; 731 d->last_rx_ring = i - 1; 732 733 d->mmap_done = 1; 734 735 return 0; 736 737 err: 738 nmctx_unlock(ctx); 739 nmport_undo_mmap(d); 740 return -1; 741 } 742 743 void 744 nmport_undo_mmap(struct nmport_d *d) 745 { 746 struct nmem_d *m; 747 struct nmctx *ctx = d->ctx; 748 749 m = d->mem; 750 if (m == NULL) 751 return; 752 nmctx_lock(ctx); 753 m->refcount--; 754 if (m->refcount <= 0) { 755 if (!m->is_extmem && m->mem != MAP_FAILED) 756 munmap(m->mem, m->size); 757 /* extract from the list and free */ 758 if (m->next != NULL) 759 m->next->prev = m->prev; 760 if (m->prev != NULL) 761 m->prev->next = m->next; 762 else 763 ctx->mem_descs = m->next; 764 nmctx_free(ctx, m); 765 d->mem = NULL; 766 } 767 nmctx_unlock(ctx); 768 d->mmap_done = 0; 769 d->mem = NULL; 770 d->nifp = NULL; 771 d->first_tx_ring = 0; 772 d->last_tx_ring = 0; 773 d->first_rx_ring = 0; 774 d->last_rx_ring = 0; 775 d->cur_tx_ring = 0; 776 d->cur_rx_ring = 0; 777 } 778 779 int 780 nmport_open_desc(struct nmport_d *d) 781 { 782 if (nmport_register(d) < 0) 783 goto err; 784 785 if (nmport_mmap(d) < 0) 786 goto err; 787 788 return 0; 789 err: 790 nmport_undo_open_desc(d); 791 return -1; 792 } 793 794 void 795 nmport_undo_open_desc(struct nmport_d *d) 796 { 797 nmport_undo_mmap(d); 798 nmport_undo_register(d); 799 } 800 801 802 struct nmport_d * 803 nmport_open(const char *ifname) 804 { 805 struct nmport_d *d; 806 807 /* prepare the descriptor */ 808 d = nmport_prepare(ifname); 809 if (d == NULL) 810 goto err; 811 812 /* open netmap and register */ 813 if (nmport_open_desc(d) < 0) 814 goto err; 815 816 return d; 817 818 err: 819 nmport_close(d); 820 return NULL; 821 } 822 823 void 824 nmport_close(struct nmport_d *d) 825 { 826 if (d == NULL) 827 return; 828 nmport_undo_open_desc(d); 829 nmport_undo_prepare(d); 830 } 831 832 struct nmport_d * 833 nmport_clone(struct nmport_d *d) 834 { 835 struct nmport_d *c; 836 struct nmctx *ctx; 837 838 ctx = d->ctx; 839 840 if (d->extmem != NULL && !d->register_done) { 841 errno = EINVAL; 842 nmctx_ferror(ctx, "cannot clone unregistered port that is using extmem"); 843 return NULL; 844 } 845 846 c = nmport_new_with_ctx(ctx); 847 if (c == NULL) 848 return NULL; 849 /* copy the output of parse */ 850 c->hdr = d->hdr; 851 /* redirect the pointer to the body */ 852 c->hdr.nr_body = (uintptr_t)&c->reg; 853 /* options are not cloned */ 854 c->hdr.nr_options = 0; 855 c->reg = d->reg; /* this also copies the mem_id */ 856 /* put the new port in an un-registered, unmapped state */ 857 c->fd = -1; 858 c->nifp = NULL; 859 c->register_done = 0; 860 c->mem = NULL; 861 c->extmem = NULL; 862 c->mmap_done = 0; 863 c->first_tx_ring = 0; 864 c->last_tx_ring = 0; 865 c->first_rx_ring = 0; 866 c->last_rx_ring = 0; 867 c->cur_tx_ring = 0; 868 c->cur_rx_ring = 0; 869 870 return c; 871 } 872 873 int 874 nmport_inject(struct nmport_d *d, const void *buf, size_t size) 875 { 876 u_int c, n = d->last_tx_ring - d->first_tx_ring + 1, 877 ri = d->cur_tx_ring; 878 879 for (c = 0; c < n ; c++, ri++) { 880 /* compute current ring to use */ 881 struct netmap_ring *ring; 882 uint32_t i, j, idx; 883 size_t rem; 884 885 if (ri > d->last_tx_ring) 886 ri = d->first_tx_ring; 887 ring = NETMAP_TXRING(d->nifp, ri); 888 rem = size; 889 j = ring->cur; 890 while (rem > ring->nr_buf_size && j != ring->tail) { 891 rem -= ring->nr_buf_size; 892 j = nm_ring_next(ring, j); 893 } 894 if (j == ring->tail && rem > 0) 895 continue; 896 i = ring->cur; 897 while (i != j) { 898 idx = ring->slot[i].buf_idx; 899 ring->slot[i].len = ring->nr_buf_size; 900 ring->slot[i].flags = NS_MOREFRAG; 901 nm_pkt_copy(buf, NETMAP_BUF(ring, idx), ring->nr_buf_size); 902 i = nm_ring_next(ring, i); 903 buf = (char *)buf + ring->nr_buf_size; 904 } 905 idx = ring->slot[i].buf_idx; 906 ring->slot[i].len = rem; 907 ring->slot[i].flags = 0; 908 nm_pkt_copy(buf, NETMAP_BUF(ring, idx), rem); 909 ring->head = ring->cur = nm_ring_next(ring, i); 910 d->cur_tx_ring = ri; 911 return size; 912 } 913 return 0; /* fail */ 914 } 915