xref: /freebsd/sys/dev/netmap/netmap_pipe.c (revision 63d1fd5970ec814904aa0f4580b10a0d302d08b2)
1 /*
2  * Copyright (C) 2014-2016 Giuseppe Lettieri
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *   1. Redistributions of source code must retain the above copyright
9  *      notice, this list of conditions and the following disclaimer.
10  *   2. Redistributions in binary form must reproduce the above copyright
11  *      notice, this list of conditions and the following disclaimer in the
12  *      documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  */
26 
27 /* $FreeBSD$ */
28 
29 #if defined(__FreeBSD__)
30 #include <sys/cdefs.h> /* prerequisite */
31 
32 #include <sys/types.h>
33 #include <sys/errno.h>
34 #include <sys/param.h>	/* defines used in kernel.h */
35 #include <sys/kernel.h>	/* types used in module initialization */
36 #include <sys/malloc.h>
37 #include <sys/poll.h>
38 #include <sys/lock.h>
39 #include <sys/rwlock.h>
40 #include <sys/selinfo.h>
41 #include <sys/sysctl.h>
42 #include <sys/socket.h> /* sockaddrs */
43 #include <net/if.h>
44 #include <net/if_var.h>
45 #include <machine/bus.h>	/* bus_dmamap_* */
46 #include <sys/refcount.h>
47 
48 
49 #elif defined(linux)
50 
51 #include "bsd_glue.h"
52 
53 #elif defined(__APPLE__)
54 
55 #warning OSX support is only partial
56 #include "osx_glue.h"
57 
58 #elif defined(_WIN32)
59 #include "win_glue.h"
60 
61 #else
62 
63 #error	Unsupported platform
64 
65 #endif /* unsupported */
66 
67 /*
68  * common headers
69  */
70 
71 #include <net/netmap.h>
72 #include <dev/netmap/netmap_kern.h>
73 #include <dev/netmap/netmap_mem2.h>
74 
75 #ifdef WITH_PIPES
76 
77 #define NM_PIPE_MAXSLOTS	4096
78 
79 static int netmap_default_pipes = 0; /* ignored, kept for compatibility */
80 SYSBEGIN(vars_pipes);
81 SYSCTL_DECL(_dev_netmap);
82 SYSCTL_INT(_dev_netmap, OID_AUTO, default_pipes, CTLFLAG_RW, &netmap_default_pipes, 0 , "");
83 SYSEND;
84 
85 /* allocate the pipe array in the parent adapter */
86 static int
87 nm_pipe_alloc(struct netmap_adapter *na, u_int npipes)
88 {
89 	size_t len;
90 	struct netmap_pipe_adapter **npa;
91 
92 	if (npipes <= na->na_max_pipes)
93 		/* we already have more entries that requested */
94 		return 0;
95 
96 	if (npipes < na->na_next_pipe || npipes > NM_MAXPIPES)
97 		return EINVAL;
98 
99         len = sizeof(struct netmap_pipe_adapter *) * npipes;
100 #ifndef _WIN32
101 	npa = realloc(na->na_pipes, len, M_DEVBUF, M_NOWAIT | M_ZERO);
102 #else
103 	npa = realloc(na->na_pipes, len, sizeof(struct netmap_pipe_adapter *)*na->na_max_pipes);
104 #endif
105 	if (npa == NULL)
106 		return ENOMEM;
107 
108 	na->na_pipes = npa;
109 	na->na_max_pipes = npipes;
110 
111 	return 0;
112 }
113 
114 /* deallocate the parent array in the parent adapter */
115 void
116 netmap_pipe_dealloc(struct netmap_adapter *na)
117 {
118 	if (na->na_pipes) {
119 		if (na->na_next_pipe > 0) {
120 			D("freeing not empty pipe array for %s (%d dangling pipes)!", na->name,
121 					na->na_next_pipe);
122 		}
123 		free(na->na_pipes, M_DEVBUF);
124 		na->na_pipes = NULL;
125 		na->na_max_pipes = 0;
126 		na->na_next_pipe = 0;
127 	}
128 }
129 
130 /* find a pipe endpoint with the given id among the parent's pipes */
131 static struct netmap_pipe_adapter *
132 netmap_pipe_find(struct netmap_adapter *parent, u_int pipe_id)
133 {
134 	int i;
135 	struct netmap_pipe_adapter *na;
136 
137 	for (i = 0; i < parent->na_next_pipe; i++) {
138 		na = parent->na_pipes[i];
139 		if (na->id == pipe_id) {
140 			return na;
141 		}
142 	}
143 	return NULL;
144 }
145 
146 /* add a new pipe endpoint to the parent array */
147 static int
148 netmap_pipe_add(struct netmap_adapter *parent, struct netmap_pipe_adapter *na)
149 {
150 	if (parent->na_next_pipe >= parent->na_max_pipes) {
151 		u_int npipes = parent->na_max_pipes ?  2*parent->na_max_pipes : 2;
152 		int error = nm_pipe_alloc(parent, npipes);
153 		if (error)
154 			return error;
155 	}
156 
157 	parent->na_pipes[parent->na_next_pipe] = na;
158 	na->parent_slot = parent->na_next_pipe;
159 	parent->na_next_pipe++;
160 	return 0;
161 }
162 
163 /* remove the given pipe endpoint from the parent array */
164 static void
165 netmap_pipe_remove(struct netmap_adapter *parent, struct netmap_pipe_adapter *na)
166 {
167 	u_int n;
168 	n = --parent->na_next_pipe;
169 	if (n != na->parent_slot) {
170 		struct netmap_pipe_adapter **p =
171 			&parent->na_pipes[na->parent_slot];
172 		*p = parent->na_pipes[n];
173 		(*p)->parent_slot = na->parent_slot;
174 	}
175 	parent->na_pipes[n] = NULL;
176 }
177 
178 static int
179 netmap_pipe_txsync(struct netmap_kring *txkring, int flags)
180 {
181         struct netmap_kring *rxkring = txkring->pipe;
182         u_int limit; /* slots to transfer */
183         u_int j, k, lim_tx = txkring->nkr_num_slots - 1,
184                 lim_rx = rxkring->nkr_num_slots - 1;
185         int m, busy;
186 
187         ND("%p: %s %x -> %s", txkring, txkring->name, flags, rxkring->name);
188         ND(2, "before: hwcur %d hwtail %d cur %d head %d tail %d", txkring->nr_hwcur, txkring->nr_hwtail,
189                 txkring->rcur, txkring->rhead, txkring->rtail);
190 
191         j = rxkring->nr_hwtail; /* RX */
192         k = txkring->nr_hwcur;  /* TX */
193         m = txkring->rhead - txkring->nr_hwcur; /* new slots */
194         if (m < 0)
195                 m += txkring->nkr_num_slots;
196         limit = m;
197         m = lim_rx; /* max avail space on destination */
198         busy = j - rxkring->nr_hwcur; /* busy slots */
199 	if (busy < 0)
200 		busy += rxkring->nkr_num_slots;
201 	m -= busy; /* subtract busy slots */
202         ND(2, "m %d limit %d", m, limit);
203         if (m < limit)
204                 limit = m;
205 
206 	if (limit == 0) {
207 		/* either the rxring is full, or nothing to send */
208 		return 0;
209 	}
210 
211         while (limit-- > 0) {
212                 struct netmap_slot *rs = &rxkring->ring->slot[j];
213                 struct netmap_slot *ts = &txkring->ring->slot[k];
214                 struct netmap_slot tmp;
215 
216                 /* swap the slots */
217                 tmp = *rs;
218                 *rs = *ts;
219                 *ts = tmp;
220 
221                 /* report the buffer change */
222 		ts->flags |= NS_BUF_CHANGED;
223 		rs->flags |= NS_BUF_CHANGED;
224 
225                 j = nm_next(j, lim_rx);
226                 k = nm_next(k, lim_tx);
227         }
228 
229         mb(); /* make sure the slots are updated before publishing them */
230         rxkring->nr_hwtail = j;
231         txkring->nr_hwcur = k;
232         txkring->nr_hwtail = nm_prev(k, lim_tx);
233 
234         ND(2, "after: hwcur %d hwtail %d cur %d head %d tail %d j %d", txkring->nr_hwcur, txkring->nr_hwtail,
235                 txkring->rcur, txkring->rhead, txkring->rtail, j);
236 
237         mb(); /* make sure rxkring->nr_hwtail is updated before notifying */
238         rxkring->nm_notify(rxkring, 0);
239 
240 	return 0;
241 }
242 
243 static int
244 netmap_pipe_rxsync(struct netmap_kring *rxkring, int flags)
245 {
246         struct netmap_kring *txkring = rxkring->pipe;
247 	uint32_t oldhwcur = rxkring->nr_hwcur;
248 
249         ND("%s %x <- %s", rxkring->name, flags, txkring->name);
250         rxkring->nr_hwcur = rxkring->rhead; /* recover user-relased slots */
251         ND(5, "hwcur %d hwtail %d cur %d head %d tail %d", rxkring->nr_hwcur, rxkring->nr_hwtail,
252                 rxkring->rcur, rxkring->rhead, rxkring->rtail);
253         mb(); /* paired with the first mb() in txsync */
254 
255 	if (oldhwcur != rxkring->nr_hwcur) {
256 		/* we have released some slots, notify the other end */
257 		mb(); /* make sure nr_hwcur is updated before notifying */
258 		txkring->nm_notify(txkring, 0);
259 	}
260         return 0;
261 }
262 
263 /* Pipe endpoints are created and destroyed together, so that endopoints do not
264  * have to check for the existence of their peer at each ?xsync.
265  *
266  * To play well with the existing netmap infrastructure (refcounts etc.), we
267  * adopt the following strategy:
268  *
269  * 1) The first endpoint that is created also creates the other endpoint and
270  * grabs a reference to it.
271  *
272  *    state A)  user1 --> endpoint1 --> endpoint2
273  *
274  * 2) If, starting from state A, endpoint2 is then registered, endpoint1 gives
275  * its reference to the user:
276  *
277  *    state B)  user1 --> endpoint1     endpoint2 <--- user2
278  *
279  * 3) Assume that, starting from state B endpoint2 is closed. In the unregister
280  * callback endpoint2 notes that endpoint1 is still active and adds a reference
281  * from endpoint1 to itself. When user2 then releases her own reference,
282  * endpoint2 is not destroyed and we are back to state A. A symmetrical state
283  * would be reached if endpoint1 were released instead.
284  *
285  * 4) If, starting from state A, endpoint1 is closed, the destructor notes that
286  * it owns a reference to endpoint2 and releases it.
287  *
288  * Something similar goes on for the creation and destruction of the krings.
289  */
290 
291 
292 /* netmap_pipe_krings_delete.
293  *
294  * There are two cases:
295  *
296  * 1) state is
297  *
298  *        usr1 --> e1 --> e2
299  *
300  *    and we are e1. We have to create both sets
301  *    of krings.
302  *
303  * 2) state is
304  *
305  *        usr1 --> e1 --> e2
306  *
307  *    and we are e2. e1 is certainly registered and our
308  *    krings already exist. Nothing to do.
309  */
310 static int
311 netmap_pipe_krings_create(struct netmap_adapter *na)
312 {
313 	struct netmap_pipe_adapter *pna =
314 		(struct netmap_pipe_adapter *)na;
315 	struct netmap_adapter *ona = &pna->peer->up;
316 	int error = 0;
317 	enum txrx t;
318 
319 	if (pna->peer_ref) {
320 		int i;
321 
322 		/* case 1) above */
323 		D("%p: case 1, create both ends", na);
324 		error = netmap_krings_create(na, 0);
325 		if (error)
326 			goto err;
327 
328 		/* create the krings of the other end */
329 		error = netmap_krings_create(ona, 0);
330 		if (error)
331 			goto del_krings1;
332 
333 		/* cross link the krings */
334 		for_rx_tx(t) {
335 			enum txrx r = nm_txrx_swap(t); /* swap NR_TX <-> NR_RX */
336 			for (i = 0; i < nma_get_nrings(na, t); i++) {
337 				NMR(na, t)[i].pipe = NMR(&pna->peer->up, r) + i;
338 				NMR(&pna->peer->up, r)[i].pipe = NMR(na, t) + i;
339 			}
340 		}
341 
342 	}
343 	return 0;
344 
345 del_krings1:
346 	netmap_krings_delete(na);
347 err:
348 	return error;
349 }
350 
351 /* netmap_pipe_reg.
352  *
353  * There are two cases on registration (onoff==1)
354  *
355  * 1.a) state is
356  *
357  *        usr1 --> e1 --> e2
358  *
359  *      and we are e1. Create the needed rings of the
360  *      other end.
361  *
362  * 1.b) state is
363  *
364  *        usr1 --> e1 --> e2 <-- usr2
365  *
366  *      and we are e2. Drop the ref e1 is holding.
367  *
368  *  There are two additional cases on unregister (onoff==0)
369  *
370  *  2.a) state is
371  *
372  *         usr1 --> e1 --> e2
373  *
374  *       and we are e1. Nothing special to do, e2 will
375  *       be cleaned up by the destructor of e1.
376  *
377  *  2.b) state is
378  *
379  *         usr1 --> e1     e2 <-- usr2
380  *
381  *       and we are either e1 or e2. Add a ref from the
382  *       other end and hide our rings.
383  */
384 static int
385 netmap_pipe_reg(struct netmap_adapter *na, int onoff)
386 {
387 	struct netmap_pipe_adapter *pna =
388 		(struct netmap_pipe_adapter *)na;
389 	struct netmap_adapter *ona = &pna->peer->up;
390 	int i, error = 0;
391 	enum txrx t;
392 
393 	ND("%p: onoff %d", na, onoff);
394 	if (onoff) {
395 		for_rx_tx(t) {
396 			for (i = 0; i < nma_get_nrings(na, t) + 1; i++) {
397 				struct netmap_kring *kring = &NMR(na, t)[i];
398 
399 				if (nm_kring_pending_on(kring)) {
400 					/* mark the partner ring as needed */
401 					kring->pipe->nr_kflags |= NKR_NEEDRING;
402 				}
403 			}
404 		}
405 
406 		/* create all missing needed rings on the other end */
407 		error = netmap_mem_rings_create(ona);
408 		if (error)
409 			return error;
410 
411 		/* In case of no error we put our rings in netmap mode */
412 		for_rx_tx(t) {
413 			for (i = 0; i < nma_get_nrings(na, t) + 1; i++) {
414 				struct netmap_kring *kring = &NMR(na, t)[i];
415 
416 				if (nm_kring_pending_on(kring)) {
417 					kring->nr_mode = NKR_NETMAP_ON;
418 				}
419 			}
420 		}
421 		if (na->active_fds == 0)
422 			na->na_flags |= NAF_NETMAP_ON;
423 	} else {
424 		if (na->active_fds == 0)
425 			na->na_flags &= ~NAF_NETMAP_ON;
426 		for_rx_tx(t) {
427 			for (i = 0; i < nma_get_nrings(na, t) + 1; i++) {
428 				struct netmap_kring *kring = &NMR(na, t)[i];
429 
430 				if (nm_kring_pending_off(kring)) {
431 					kring->nr_mode = NKR_NETMAP_OFF;
432 					/* mark the peer ring as no longer needed by us
433 					 * (it may still be kept if sombody else is using it)
434 					 */
435 					kring->pipe->nr_kflags &= ~NKR_NEEDRING;
436 				}
437 			}
438 		}
439 		/* delete all the peer rings that are no longer needed */
440 		netmap_mem_rings_delete(ona);
441 	}
442 
443 	if (na->active_fds) {
444 		D("active_fds %d", na->active_fds);
445 		return 0;
446 	}
447 
448 	if (pna->peer_ref) {
449 		ND("%p: case 1.a or 2.a, nothing to do", na);
450 		return 0;
451 	}
452 	if (onoff) {
453 		ND("%p: case 1.b, drop peer", na);
454 		pna->peer->peer_ref = 0;
455 		netmap_adapter_put(na);
456 	} else {
457 		ND("%p: case 2.b, grab peer", na);
458 		netmap_adapter_get(na);
459 		pna->peer->peer_ref = 1;
460 	}
461 	return error;
462 }
463 
464 /* netmap_pipe_krings_delete.
465  *
466  * There are two cases:
467  *
468  * 1) state is
469  *
470  *                usr1 --> e1 --> e2
471  *
472  *    and we are e1 (e2 is not registered, so krings_delete cannot be
473  *    called on it);
474  *
475  * 2) state is
476  *
477  *                usr1 --> e1     e2 <-- usr2
478  *
479  *    and we are either e1 or e2.
480  *
481  * In the former case we have to also delete the krings of e2;
482  * in the latter case we do nothing (note that our krings
483  * have already been hidden in the unregister callback).
484  */
485 static void
486 netmap_pipe_krings_delete(struct netmap_adapter *na)
487 {
488 	struct netmap_pipe_adapter *pna =
489 		(struct netmap_pipe_adapter *)na;
490 	struct netmap_adapter *ona; /* na of the other end */
491 
492 	if (!pna->peer_ref) {
493 		ND("%p: case 2, kept alive by peer",  na);
494 		return;
495 	}
496 	/* case 1) above */
497 	ND("%p: case 1, deleting everyhing", na);
498 	netmap_krings_delete(na); /* also zeroes tx_rings etc. */
499 	ona = &pna->peer->up;
500 	if (ona->tx_rings == NULL) {
501 		/* already deleted, we must be on an
502                  * cleanup-after-error path */
503 		return;
504 	}
505 	netmap_krings_delete(ona);
506 }
507 
508 
509 static void
510 netmap_pipe_dtor(struct netmap_adapter *na)
511 {
512 	struct netmap_pipe_adapter *pna =
513 		(struct netmap_pipe_adapter *)na;
514 	ND("%p", na);
515 	if (pna->peer_ref) {
516 		ND("%p: clean up peer", na);
517 		pna->peer_ref = 0;
518 		netmap_adapter_put(&pna->peer->up);
519 	}
520 	if (pna->role == NR_REG_PIPE_MASTER)
521 		netmap_pipe_remove(pna->parent, pna);
522 	netmap_adapter_put(pna->parent);
523 	pna->parent = NULL;
524 }
525 
526 int
527 netmap_get_pipe_na(struct nmreq *nmr, struct netmap_adapter **na, int create)
528 {
529 	struct nmreq pnmr;
530 	struct netmap_adapter *pna; /* parent adapter */
531 	struct netmap_pipe_adapter *mna, *sna, *req;
532 	struct ifnet *ifp = NULL;
533 	u_int pipe_id;
534 	int role = nmr->nr_flags & NR_REG_MASK;
535 	int error;
536 
537 	ND("flags %x", nmr->nr_flags);
538 
539 	if (role != NR_REG_PIPE_MASTER && role != NR_REG_PIPE_SLAVE) {
540 		ND("not a pipe");
541 		return 0;
542 	}
543 	role = nmr->nr_flags & NR_REG_MASK;
544 
545 	/* first, try to find the parent adapter */
546 	bzero(&pnmr, sizeof(pnmr));
547 	memcpy(&pnmr.nr_name, nmr->nr_name, IFNAMSIZ);
548 	/* pass to parent the requested number of pipes */
549 	pnmr.nr_arg1 = nmr->nr_arg1;
550 	error = netmap_get_na(&pnmr, &pna, &ifp, create);
551 	if (error) {
552 		ND("parent lookup failed: %d", error);
553 		return error;
554 	}
555 	ND("found parent: %s", na->name);
556 
557 	if (NETMAP_OWNED_BY_KERN(pna)) {
558 		ND("parent busy");
559 		error = EBUSY;
560 		goto put_out;
561 	}
562 
563 	/* next, lookup the pipe id in the parent list */
564 	req = NULL;
565 	pipe_id = nmr->nr_ringid & NETMAP_RING_MASK;
566 	mna = netmap_pipe_find(pna, pipe_id);
567 	if (mna) {
568 		if (mna->role == role) {
569 			ND("found %d directly at %d", pipe_id, mna->parent_slot);
570 			req = mna;
571 		} else {
572 			ND("found %d indirectly at %d", pipe_id, mna->parent_slot);
573 			req = mna->peer;
574 		}
575 		/* the pipe we have found already holds a ref to the parent,
576                  * so we need to drop the one we got from netmap_get_na()
577                  */
578 		netmap_adapter_put(pna);
579 		goto found;
580 	}
581 	ND("pipe %d not found, create %d", pipe_id, create);
582 	if (!create) {
583 		error = ENODEV;
584 		goto put_out;
585 	}
586 	/* we create both master and slave.
587          * The endpoint we were asked for holds a reference to
588          * the other one.
589          */
590 	mna = malloc(sizeof(*mna), M_DEVBUF, M_NOWAIT | M_ZERO);
591 	if (mna == NULL) {
592 		error = ENOMEM;
593 		goto put_out;
594 	}
595 	snprintf(mna->up.name, sizeof(mna->up.name), "%s{%d", pna->name, pipe_id);
596 
597 	mna->id = pipe_id;
598 	mna->role = NR_REG_PIPE_MASTER;
599 	mna->parent = pna;
600 
601 	mna->up.nm_txsync = netmap_pipe_txsync;
602 	mna->up.nm_rxsync = netmap_pipe_rxsync;
603 	mna->up.nm_register = netmap_pipe_reg;
604 	mna->up.nm_dtor = netmap_pipe_dtor;
605 	mna->up.nm_krings_create = netmap_pipe_krings_create;
606 	mna->up.nm_krings_delete = netmap_pipe_krings_delete;
607 	mna->up.nm_mem = pna->nm_mem;
608 	mna->up.na_lut = pna->na_lut;
609 
610 	mna->up.num_tx_rings = 1;
611 	mna->up.num_rx_rings = 1;
612 	mna->up.num_tx_desc = nmr->nr_tx_slots;
613 	nm_bound_var(&mna->up.num_tx_desc, pna->num_tx_desc,
614 			1, NM_PIPE_MAXSLOTS, NULL);
615 	mna->up.num_rx_desc = nmr->nr_rx_slots;
616 	nm_bound_var(&mna->up.num_rx_desc, pna->num_rx_desc,
617 			1, NM_PIPE_MAXSLOTS, NULL);
618 	error = netmap_attach_common(&mna->up);
619 	if (error)
620 		goto free_mna;
621 	/* register the master with the parent */
622 	error = netmap_pipe_add(pna, mna);
623 	if (error)
624 		goto free_mna;
625 
626 	/* create the slave */
627 	sna = malloc(sizeof(*mna), M_DEVBUF, M_NOWAIT | M_ZERO);
628 	if (sna == NULL) {
629 		error = ENOMEM;
630 		goto unregister_mna;
631 	}
632 	/* most fields are the same, copy from master and then fix */
633 	*sna = *mna;
634 	snprintf(sna->up.name, sizeof(sna->up.name), "%s}%d", pna->name, pipe_id);
635 	sna->role = NR_REG_PIPE_SLAVE;
636 	error = netmap_attach_common(&sna->up);
637 	if (error)
638 		goto free_sna;
639 
640 	/* join the two endpoints */
641 	mna->peer = sna;
642 	sna->peer = mna;
643 
644 	/* we already have a reference to the parent, but we
645          * need another one for the other endpoint we created
646          */
647 	netmap_adapter_get(pna);
648 
649 	if (role == NR_REG_PIPE_MASTER) {
650 		req = mna;
651 		mna->peer_ref = 1;
652 		netmap_adapter_get(&sna->up);
653 	} else {
654 		req = sna;
655 		sna->peer_ref = 1;
656 		netmap_adapter_get(&mna->up);
657 	}
658 	ND("created master %p and slave %p", mna, sna);
659 found:
660 
661 	ND("pipe %d %s at %p", pipe_id,
662 		(req->role == NR_REG_PIPE_MASTER ? "master" : "slave"), req);
663 	*na = &req->up;
664 	netmap_adapter_get(*na);
665 
666 	/* keep the reference to the parent.
667          * It will be released by the req destructor
668          */
669 
670 	/* drop the ifp reference, if any */
671 	if (ifp) {
672 		if_rele(ifp);
673 	}
674 
675 	return 0;
676 
677 free_sna:
678 	free(sna, M_DEVBUF);
679 unregister_mna:
680 	netmap_pipe_remove(pna, mna);
681 free_mna:
682 	free(mna, M_DEVBUF);
683 put_out:
684 	netmap_unget_na(pna, ifp);
685 	return error;
686 }
687 
688 
689 #endif /* WITH_PIPES */
690