na->nm_krings_delete(na);
/* restore the default number of host tx and rx rings */
- na->num_host_tx_rings = 1;
- na->num_host_rx_rings = 1;
+ if (na->na_flags & NAF_HOST_RINGS) {
+ na->num_host_tx_rings = 1;
+ na->num_host_rx_rings = 1;
+ } else {
+ na->num_host_tx_rings = 0;
+ na->num_host_rx_rings = 0;
+ }
}
/* possibily decrement counter of tx_si/rx_si users */
}
#ifdef WITH_EXTMEM
- opt = nmreq_findoption((struct nmreq_option *)(uintptr_t)hdr->nr_options,
- NETMAP_REQ_OPT_EXTMEM);
+ opt = nmreq_getoption(hdr, NETMAP_REQ_OPT_EXTMEM);
if (opt != NULL) {
struct nmreq_opt_extmem *e =
(struct nmreq_opt_extmem *)opt;
- error = nmreq_checkduplicate(opt);
- if (error) {
- opt->nro_status = error;
- break;
- }
nmd = netmap_mem_ext_create(e->nro_usrptr,
&e->nro_info, &error);
opt->nro_status = error;
break;
}
- opt = nmreq_findoption((struct nmreq_option *)(uintptr_t)hdr->nr_options,
- NETMAP_REQ_OPT_CSB);
+ opt = nmreq_getoption(hdr, NETMAP_REQ_OPT_CSB);
if (opt != NULL) {
struct nmreq_opt_csb *csbo =
(struct nmreq_opt_csb *)opt;
- error = nmreq_checkduplicate(opt);
- if (!error) {
- error = netmap_csb_validate(priv, csbo);
- }
+ error = netmap_csb_validate(priv, csbo);
opt->nro_status = error;
if (error) {
netmap_do_unregif(priv);
case NETMAP_REQ_CSB_ENABLE: {
struct nmreq_option *opt;
- opt = nmreq_findoption((struct nmreq_option *)(uintptr_t)hdr->nr_options,
- NETMAP_REQ_OPT_CSB);
+ opt = nmreq_getoption(hdr, NETMAP_REQ_OPT_CSB);
if (opt == NULL) {
error = EINVAL;
} else {
struct nmreq_opt_csb *csbo =
(struct nmreq_opt_csb *)opt;
- error = nmreq_checkduplicate(opt);
- if (!error) {
- NMG_LOCK();
- error = netmap_csb_validate(priv, csbo);
- NMG_UNLOCK();
- }
+ NMG_LOCK();
+ error = netmap_csb_validate(priv, csbo);
+ NMG_UNLOCK();
opt->nro_status = error;
}
break;
return rv - sizeof(struct nmreq_option);
}
+/*
+ * nmreq_copyin: create an in-kernel version of the request.
+ *
+ * We build the following data structure:
+ *
+ * hdr -> +-------+ buf
+ * | | +---------------+
+ * +-------+ |usr body ptr |
+ * |options|-. +---------------+
+ * +-------+ | |usr options ptr|
+ * |body |--------->+---------------+
+ * +-------+ | | |
+ * | | copy of body |
+ * | | |
+ * | +---------------+
+ * | | NULL |
+ * | +---------------+
+ * | .---| |\
+ * | | +---------------+ |
+ * | .------| | |
+ * | | | +---------------+ \ option table
+ * | | | | ... | / indexed by option
+ * | | | +---------------+ | type
+ * | | | | | |
+ * | | | +---------------+/
+ * | | | |usr next ptr 1 |
+ * `-|----->+---------------+
+ * | | | copy of opt 1 |
+ * | | | |
+ * | | .-| nro_next |
+ * | | | +---------------+
+ * | | | |usr next ptr 2 |
+ * | `-`>+---------------+
+ * | | copy of opt 2 |
+ * | | |
+ * | .-| nro_next |
+ * | | +---------------+
+ * | | | |
+ * ~ ~ ~ ... ~
+ * | .-| |
+ * `----->+---------------+
+ * | |usr next ptr n |
+ * `>+---------------+
+ * | copy of opt n |
+ * | |
+ * | nro_next(NULL)|
+ * +---------------+
+ *
+ * The options and body fields of the hdr structure are overwritten
+ * with in-kernel valid pointers inside the buf. The original user
+ * pointers are saved in the buf and restored on copyout.
+ * The list of options is copied and the pointers adjusted. The
+ * original pointers are saved before the option they belonged.
+ *
+ * The option table has an entry for every availabe option. Entries
+ * for options that have not been passed contain NULL.
+ *
+ */
+
int
nmreq_copyin(struct nmreq_header *hdr, int nr_body_is_user)
{
size_t rqsz, optsz, bufsz;
- int error;
+ int error = 0;
char *ker = NULL, *p;
- struct nmreq_option **next, *src;
+ struct nmreq_option **next, *src, **opt_tab;
struct nmreq_option buf;
uint64_t *ptrs;
goto out_err;
}
- bufsz = 2 * sizeof(void *) + rqsz;
+ bufsz = 2 * sizeof(void *) + rqsz +
+ NETMAP_REQ_OPT_MAX * sizeof(opt_tab);
+ /* compute the size of the buf below the option table.
+ * It must contain a copy of every received option structure.
+ * For every option we also need to store a copy of the user
+ * list pointer.
+ */
optsz = 0;
for (src = (struct nmreq_option *)(uintptr_t)hdr->nr_options; src;
src = (struct nmreq_option *)(uintptr_t)buf.nro_next)
error = EMSGSIZE;
goto out_err;
}
- bufsz += optsz + sizeof(void *);
+ bufsz += sizeof(void *);
}
+ bufsz += optsz;
ker = nm_os_malloc(bufsz);
if (ker == NULL) {
error = ENOMEM;
goto out_err;
}
- p = ker;
+ p = ker; /* write pointer into the buffer */
/* make a copy of the user pointers */
ptrs = (uint64_t*)p;
/* overwrite the user pointer with the in-kernel one */
hdr->nr_body = (uintptr_t)p;
p += rqsz;
+ /* start of the options table */
+ opt_tab = (struct nmreq_option **)p;
+ p += sizeof(opt_tab) * NETMAP_REQ_OPT_MAX;
/* copy the options */
next = (struct nmreq_option **)&hdr->nr_options;
*/
opt->nro_status = EOPNOTSUPP;
+ /* check for invalid types */
+ if (opt->nro_reqtype < 1) {
+ if (netmap_verbose)
+ nm_prinf("invalid option type: %u", opt->nro_reqtype);
+ opt->nro_status = EINVAL;
+ error = EINVAL;
+ goto next;
+ }
+
+ if (opt->nro_reqtype >= NETMAP_REQ_OPT_MAX) {
+ /* opt->nro_status is already EOPNOTSUPP */
+ error = EOPNOTSUPP;
+ goto next;
+ }
+
+ /* if the type is valid, index the option in the table
+ * unless it is a duplicate.
+ */
+ if (opt_tab[opt->nro_reqtype] != NULL) {
+ if (netmap_verbose)
+ nm_prinf("duplicate option: %u", opt->nro_reqtype);
+ opt->nro_status = EINVAL;
+ opt_tab[opt->nro_reqtype]->nro_status = EINVAL;
+ error = EINVAL;
+ goto next;
+ }
+ opt_tab[opt->nro_reqtype] = opt;
+
p = (char *)(opt + 1);
/* copy the option body */
p += optsz;
}
+ next:
/* move to next option */
next = (struct nmreq_option **)&opt->nro_next;
src = *next;
}
- return 0;
+ if (error)
+ nmreq_copyout(hdr, error);
+ return error;
out_restore:
ptrs = (uint64_t *)ker;
}
struct nmreq_option *
-nmreq_findoption(struct nmreq_option *opt, uint16_t reqtype)
+nmreq_getoption(struct nmreq_header *hdr, uint16_t reqtype)
{
- for ( ; opt; opt = (struct nmreq_option *)(uintptr_t)opt->nro_next)
- if (opt->nro_reqtype == reqtype)
- return opt;
- return NULL;
-}
+ struct nmreq_option **opt_tab;
-int
-nmreq_checkduplicate(struct nmreq_option *opt) {
- uint16_t type = opt->nro_reqtype;
- int dup = 0;
-
- while ((opt = nmreq_findoption((struct nmreq_option *)(uintptr_t)opt->nro_next,
- type))) {
- dup++;
- opt->nro_status = EINVAL;
- }
- return (dup ? EINVAL : 0);
+ if (!hdr->nr_options)
+ return NULL;
+
+ opt_tab = (struct nmreq_option **)(hdr->nr_options) - (NETMAP_REQ_OPT_MAX + 1);
+ return opt_tab[reqtype];
}
static int
/* ---------------------------------------------------*/
/* these are only meaningful if the pool is finalized */
/* (see 'finalized' field in netmap_mem_d) */
- u_int objtotal; /* actual total number of objects. */
- u_int memtotal; /* actual total memory space */
- u_int numclusters; /* actual number of clusters */
-
- u_int objfree; /* number of free objects. */
+ size_t memtotal; /* actual total memory space */
struct lut_entry *lut; /* virt,phys addresses, objtotal entries */
uint32_t *bitmap; /* one bit per buffer, 1 means free */
uint32_t *invalid_bitmap;/* one bit per buffer, 1 means invalid */
uint32_t bitmap_slots; /* number of uint32 entries in bitmap */
+
+ u_int objtotal; /* actual total number of objects. */
+ u_int numclusters; /* actual number of clusters */
+ u_int objfree; /* number of free objects. */
+
int alloc_done; /* we have allocated the memory */
/* ---------------------------------------------------*/
struct netmap_mem_d {
NMA_LOCK_T nm_mtx; /* protect the allocator */
- u_int nm_totalsize; /* shorthand */
+ size_t nm_totalsize; /* shorthand */
u_int flags;
#define NETMAP_MEM_FINALIZED 0x1 /* preallocation done */
return pa;
}
/* this is only in case of errors */
- nm_prerr("invalid ofs 0x%x out of 0x%x 0x%x 0x%x", (u_int)o,
+ nm_prerr("invalid ofs 0x%x out of 0x%zx 0x%zx 0x%zx", (u_int)o,
p[NETMAP_IF_POOL].memtotal,
p[NETMAP_IF_POOL].memtotal
+ p[NETMAP_RING_POOL].memtotal,
*size = 0;
for (i = 0; i < NETMAP_POOLS_NR; i++) {
struct netmap_obj_pool *p = nmd->pools + i;
- *size += (p->_numclusters * p->_clustsize);
+ *size += ((size_t)p->_numclusters * (size_t)p->_clustsize);
}
}
}
#endif
}
}
- p->memtotal = p->numclusters * p->_clustsize;
+ p->memtotal = (size_t)p->numclusters * (size_t)p->_clustsize;
if (netmap_verbose)
- nm_prinf("Pre-allocated %d clusters (%d/%dKB) for '%s'",
+ nm_prinf("Pre-allocated %d clusters (%d/%zuKB) for '%s'",
p->numclusters, p->_clustsize >> 10,
p->memtotal >> 10, p->name);
nmd->flags |= NETMAP_MEM_FINALIZED;
if (netmap_verbose)
- nm_prinf("interfaces %d KB, rings %d KB, buffers %d MB",
+ nm_prinf("interfaces %zd KB, rings %zd KB, buffers %zd MB",
nmd->pools[NETMAP_IF_POOL].memtotal >> 10,
nmd->pools[NETMAP_RING_POOL].memtotal >> 10,
nmd->pools[NETMAP_BUF_POOL].memtotal >> 20);
}
p->objtotal = j;
p->numclusters = p->objtotal;
- p->memtotal = j * p->_objsize;
- nm_prdis("%d memtotal %u", j, p->memtotal);
+ p->memtotal = j * (size_t)p->_objsize;
+ nm_prdis("%d memtotal %zu", j, p->memtotal);
}
netmap_mem_ext_register(nme);
} else {
ptnmd->pt_ifs = curr->next;
}
- nm_prinf("removed (ifp=%s,nifp_offset=%u)",
- curr->ifp->if_xname, curr->nifp_offset);
+ nm_prinf("removed (ifp=%p,nifp_offset=%u)",
+ curr->ifp, curr->nifp_offset);
nm_os_free(curr);
ret = 0;
break;
ptnmd->buf_lut.objtotal = nbuffers;
ptnmd->buf_lut.objsize = bufsize;
- nmd->nm_totalsize = (unsigned int)mem_size;
+ nmd->nm_totalsize = mem_size;
/* Initialize these fields as are needed by
* netmap_mem_bufsize().
projects / freebsd.git / commitdiff