lib/libnetmap/nmport.c

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