xref: /freebsd/sys/net/if_clone.c (revision 74bf4e164ba5851606a27d4feff27717452583e5)
1 /*
2  * Copyright (c) 1980, 1986, 1993
3  *	The Regents of the University of California.  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  * 4. Neither the name of the University nor the names of its contributors
14  *    may be used to endorse or promote products derived from this software
15  *    without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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  *	@(#)if.c	8.5 (Berkeley) 1/9/95
30  * $FreeBSD$
31  */
32 
33 #include <sys/param.h>
34 #include <sys/malloc.h>
35 #include <sys/lock.h>
36 #include <sys/mutex.h>
37 #include <sys/kernel.h>
38 #include <sys/systm.h>
39 #include <sys/types.h>
40 #include <sys/socket.h>
41 
42 #include <net/if.h>
43 #include <net/if_clone.h>
44 #if 0
45 #include <net/if_dl.h>
46 #endif
47 #include <net/if_types.h>
48 #include <net/if_var.h>
49 #include <net/radix.h>
50 #include <net/route.h>
51 
52 static void		if_clone_free(struct if_clone *ifc);
53 
54 static struct mtx	if_cloners_mtx;
55 static int		if_cloners_count;
56 LIST_HEAD(, if_clone)	if_cloners = LIST_HEAD_INITIALIZER(if_cloners);
57 
58 #define IF_CLONERS_LOCK_INIT()		\
59     mtx_init(&if_cloners_mtx, "if_cloners lock", NULL, MTX_DEF)
60 #define IF_CLONERS_LOCK_ASSERT()	mtx_assert(&if_cloners_mtx, MA_OWNED)
61 #define IF_CLONERS_LOCK()		mtx_lock(&if_cloners_mtx)
62 #define IF_CLONERS_UNLOCK()		mtx_unlock(&if_cloners_mtx)
63 
64 #define IF_CLONE_LOCK_INIT(ifc)		\
65     mtx_init(&(ifc)->ifc_mtx, "if_clone lock", NULL, MTX_DEF)
66 #define IF_CLONE_LOCK_DESTROY(ifc)	mtx_destroy(&(ifc)->ifc_mtx)
67 #define IF_CLONE_LOCK_ASSERT(ifc)	mtx_assert(&(ifc)->ifc_mtx, MA_OWNED)
68 #define IF_CLONE_LOCK(ifc)		mtx_lock(&(ifc)->ifc_mtx)
69 #define IF_CLONE_UNLOCK(ifc)		mtx_unlock(&(ifc)->ifc_mtx)
70 
71 #define IF_CLONE_ADDREF(ifc)						\
72 	do {								\
73 		IF_CLONE_LOCK(ifc);					\
74 		IF_CLONE_ADDREF_LOCKED(ifc);				\
75 		IF_CLONE_UNLOCK(ifc);					\
76 	} while (0)
77 #define IF_CLONE_ADDREF_LOCKED(ifc)					\
78 	do {								\
79 		IF_CLONE_LOCK_ASSERT(ifc);				\
80 		KASSERT((ifc)->ifc_refcnt >= 0,				\
81 		    ("negative refcnt %ld", (ifc)->ifc_refcnt));	\
82 		(ifc)->ifc_refcnt++;					\
83 	} while (0)
84 #define IF_CLONE_REMREF(ifc)						\
85 	do {								\
86 		IF_CLONE_LOCK(ifc);					\
87 		IF_CLONE_REMREF_LOCKED(ifc);				\
88 	} while (0)
89 #define IF_CLONE_REMREF_LOCKED(ifc)					\
90 	do {								\
91 		IF_CLONE_LOCK_ASSERT(ifc);				\
92 		KASSERT((ifc)->ifc_refcnt > 0,				\
93 		    ("bogus refcnt %ld", (ifc)->ifc_refcnt));		\
94 		if (--(ifc)->ifc_refcnt == 0) {				\
95 			IF_CLONE_UNLOCK(ifc);				\
96 			if_clone_free(ifc);				\
97 		} else {						\
98 			/* silently free the lock */			\
99 			IF_CLONE_UNLOCK(ifc);				\
100 		}							\
101 	} while (0)
102 
103 MALLOC_DEFINE(M_CLONE, "clone", "interface cloning framework");
104 
105 void
106 if_clone_init(void)
107 {
108 	IF_CLONERS_LOCK_INIT();
109 }
110 
111 /*
112  * Create a clone network interface.
113  */
114 int
115 if_clone_create(char *name, size_t len)
116 {
117 	int err;
118 	struct if_clone *ifc;
119 
120 	if (ifunit(name) != NULL)
121 		return (EEXIST);
122 
123 	/* Try to find an applicable cloner for this request */
124 	IF_CLONERS_LOCK();
125 	LIST_FOREACH(ifc, &if_cloners, ifc_list) {
126 		if (ifc->ifc_match(ifc, name)) {
127 			IF_CLONE_ADDREF(ifc);
128 			break;
129 		}
130 	}
131 	IF_CLONERS_UNLOCK();
132 
133 	if (ifc == NULL)
134 		return (EINVAL);
135 
136 	err = (*ifc->ifc_create)(ifc, name, len);
137 	IF_CLONE_REMREF(ifc);
138 	return (err);
139 }
140 
141 /*
142  * Destroy a clone network interface.
143  */
144 int
145 if_clone_destroy(const char *name)
146 {
147 	int err;
148 	struct if_clone *ifc;
149 	struct ifnet *ifp;
150 
151 	ifp = ifunit(name);
152 	if (ifp == NULL)
153 		return (ENXIO);
154 
155 	/* Find the cloner for this interface */
156 	IF_CLONERS_LOCK();
157 	LIST_FOREACH(ifc, &if_cloners, ifc_list) {
158 		if (strcmp(ifc->ifc_name, ifp->if_dname) == 0) {
159 			IF_CLONE_ADDREF(ifc);
160 			break;
161 		}
162 	}
163 	IF_CLONERS_UNLOCK();
164 	if (ifc == NULL)
165 		return (EINVAL);
166 
167 	if (ifc->ifc_destroy == NULL) {
168 		err = EOPNOTSUPP;
169 		goto done;
170 	}
171 
172 	err =  (*ifc->ifc_destroy)(ifc, ifp);
173 
174 done:
175 	IF_CLONE_REMREF(ifc);
176 	return (err);
177 }
178 
179 /*
180  * Register a network interface cloner.
181  */
182 void
183 if_clone_attach(struct if_clone *ifc)
184 {
185 	int len, maxclone;
186 
187 	/*
188 	 * Compute bitmap size and allocate it.
189 	 */
190 	maxclone = ifc->ifc_maxunit + 1;
191 	len = maxclone >> 3;
192 	if ((len << 3) < maxclone)
193 		len++;
194 	ifc->ifc_units = malloc(len, M_CLONE, M_WAITOK | M_ZERO);
195 	ifc->ifc_bmlen = len;
196 	IF_CLONE_LOCK_INIT(ifc);
197 	IF_CLONE_ADDREF(ifc);
198 
199 	IF_CLONERS_LOCK();
200 	LIST_INSERT_HEAD(&if_cloners, ifc, ifc_list);
201 	if_cloners_count++;
202 	IF_CLONERS_UNLOCK();
203 
204 	if (ifc->ifc_attach != NULL)
205 		(*ifc->ifc_attach)(ifc);
206 	EVENTHANDLER_INVOKE(if_clone_event, ifc);
207 }
208 
209 /*
210  * Unregister a network interface cloner.
211  */
212 void
213 if_clone_detach(struct if_clone *ifc)
214 {
215 
216 	IF_CLONERS_LOCK();
217 	LIST_REMOVE(ifc, ifc_list);
218 	if_cloners_count--;
219 	IF_CLONERS_UNLOCK();
220 
221 	IF_CLONE_REMREF(ifc);
222 }
223 
224 static void
225 if_clone_free(struct if_clone *ifc)
226 {
227 
228 	IF_CLONE_LOCK_DESTROY(ifc);
229 	free(ifc->ifc_units, M_CLONE);
230 }
231 
232 /*
233  * Provide list of interface cloners to userspace.
234  */
235 int
236 if_clone_list(struct if_clonereq *ifcr)
237 {
238 	char outbuf[IFNAMSIZ], *dst;
239 	struct if_clone *ifc;
240 	int count, err = 0;
241 
242 	IF_CLONERS_LOCK();
243 
244 	ifcr->ifcr_total = if_cloners_count;
245 	if ((dst = ifcr->ifcr_buffer) == NULL) {
246 		/* Just asking how many there are. */
247 		goto done;
248 	}
249 
250 	if (ifcr->ifcr_count < 0) {
251 		err = EINVAL;
252 		goto done;
253 	}
254 
255 	count = (if_cloners_count < ifcr->ifcr_count) ?
256 	    if_cloners_count : ifcr->ifcr_count;
257 
258 	for (ifc = LIST_FIRST(&if_cloners); ifc != NULL && count != 0;
259 	     ifc = LIST_NEXT(ifc, ifc_list), count--, dst += IFNAMSIZ) {
260 		strlcpy(outbuf, ifc->ifc_name, IFNAMSIZ);
261 		err = copyout(outbuf, dst, IFNAMSIZ);
262 		if (err)
263 			break;
264 	}
265 
266 done:
267 	IF_CLONERS_UNLOCK();
268 	return (err);
269 }
270 
271 /*
272  * A utility function to extract unit numbers from interface names of
273  * the form name###.
274  *
275  * Returns 0 on success and an error on failure.
276  */
277 int
278 ifc_name2unit(const char *name, int *unit)
279 {
280 	const char	*cp;
281 
282 	for (cp = name; *cp != '\0' && (*cp < '0' || *cp > '9'); cp++);
283 	if (*cp == '\0') {
284 		*unit = -1;
285 	} else {
286 		for (*unit = 0; *cp != '\0'; cp++) {
287 			if (*cp < '0' || *cp > '9') {
288 				/* Bogus unit number. */
289 				return (EINVAL);
290 			}
291 			*unit = (*unit * 10) + (*cp - '0');
292 		}
293 	}
294 
295 	return (0);
296 }
297 
298 int
299 ifc_alloc_unit(struct if_clone *ifc, int *unit)
300 {
301 	int wildcard, bytoff, bitoff;
302 	int err = 0;
303 
304 	IF_CLONE_LOCK(ifc);
305 
306 	bytoff = bitoff = 0;
307 	wildcard = (*unit < 0);
308 	/*
309 	 * Find a free unit if none was given.
310 	 */
311 	if (wildcard) {
312 		while ((bytoff < ifc->ifc_bmlen)
313 		    && (ifc->ifc_units[bytoff] == 0xff))
314 			bytoff++;
315 		if (bytoff >= ifc->ifc_bmlen) {
316 			err = ENOSPC;
317 			goto done;
318 		}
319 		while ((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0)
320 			bitoff++;
321 		*unit = (bytoff << 3) + bitoff;
322 	}
323 
324 	if (*unit > ifc->ifc_maxunit) {
325 		err = ENOSPC;
326 		goto done;
327 	}
328 
329 	if (!wildcard) {
330 		bytoff = *unit >> 3;
331 		bitoff = *unit - (bytoff << 3);
332 	}
333 
334 	if((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0) {
335 		err = EEXIST;
336 		goto done;
337 	}
338 	/*
339 	 * Allocate the unit in the bitmap.
340 	 */
341 	ifc->ifc_units[bytoff] |= (1 << bitoff);
342 
343 done:
344 	IF_CLONE_UNLOCK(ifc);
345 	return (err);
346 }
347 
348 void
349 ifc_free_unit(struct if_clone *ifc, int unit)
350 {
351 	int bytoff, bitoff;
352 
353 
354 	/*
355 	 * Compute offset in the bitmap and deallocate the unit.
356 	 */
357 	bytoff = unit >> 3;
358 	bitoff = unit - (bytoff << 3);
359 
360 	IF_CLONE_LOCK(ifc);
361 	KASSERT((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0,
362 	    ("%s: bit is already cleared", __func__));
363 	ifc->ifc_units[bytoff] &= ~(1 << bitoff);
364 	IF_CLONE_UNLOCK(ifc);
365 }
366 
367 void
368 ifc_simple_attach(struct if_clone *ifc)
369 {
370 	int err;
371 	int unit;
372 	char name[IFNAMSIZ];
373 	struct ifc_simple_data *ifcs = ifc->ifc_data;
374 
375 	KASSERT(ifcs->ifcs_minifs - 1 <= ifc->ifc_maxunit,
376 	    ("%s: %s requested more units then allowed (%d > %d)",
377 	    __func__, ifc->ifc_name, ifcs->ifcs_minifs,
378 	    ifc->ifc_maxunit + 1));
379 
380 	for (unit = 0; unit < ifcs->ifcs_minifs; unit++) {
381 		snprintf(name, IFNAMSIZ, "%s%d", ifc->ifc_name, unit);
382 		err = (*ifc->ifc_create)(ifc, name, IFNAMSIZ);
383 		KASSERT(err == 0,
384 		    ("%s: failed to create required interface %s",
385 		    __func__, name));
386 	}
387 }
388 
389 int
390 ifc_simple_match(struct if_clone *ifc, const char *name)
391 {
392 	const char *cp;
393 	int i;
394 
395 	/* Match the name */
396 	for (cp = name, i = 0; i < strlen(ifc->ifc_name); i++, cp++) {
397 		if (ifc->ifc_name[i] != *cp)
398 			return (0);
399 	}
400 
401 	/* Make sure there's a unit number or nothing after the name */
402 	for (; *cp != '\0'; cp++) {
403 		if (*cp < '0' || *cp > '9')
404 			return (0);
405 	}
406 
407 	return (1);
408 }
409 
410 int
411 ifc_simple_create(struct if_clone *ifc, char *name, size_t len)
412 {
413 	char *dp;
414 	int wildcard;
415 	int unit;
416 	int err;
417 	struct ifc_simple_data *ifcs = ifc->ifc_data;
418 
419 	err = ifc_name2unit(name, &unit);
420 	if (err != 0)
421 		return (err);
422 
423 	wildcard = (unit < 0);
424 
425 	err = ifc_alloc_unit(ifc, &unit);
426 	if (err != 0)
427 		return (err);
428 
429 	err = ifcs->ifcs_create(ifc, unit);
430 	if (err != 0) {
431 		ifc_free_unit(ifc, unit);
432 		return (err);
433 	}
434 
435 	/* In the wildcard case, we need to update the name. */
436 	if (wildcard) {
437 		for (dp = name; *dp != '\0'; dp++);
438 		if (snprintf(dp, len - (dp-name), "%d", unit) >
439 		    len - (dp-name) - 1) {
440 			/*
441 			 * This can only be a programmer error and
442 			 * there's no straightforward way to recover if
443 			 * it happens.
444 			 */
445 			panic("if_clone_create(): interface name too long");
446 		}
447 
448 	}
449 
450 	return (0);
451 }
452 
453 int
454 ifc_simple_destroy(struct if_clone *ifc, struct ifnet *ifp)
455 {
456 	int unit;
457 	struct ifc_simple_data *ifcs = ifc->ifc_data;
458 
459 	unit = ifp->if_dunit;
460 
461 	if (unit < ifcs->ifcs_minifs)
462 		return (EINVAL);
463 
464 	ifcs->ifcs_destroy(ifp);
465 
466 	ifc_free_unit(ifc, unit);
467 
468 	return (0);
469 }
470