xref: /netbsd-src/sys/net/if_media.c (revision 6ffff4f242a1d82be7e156c3b9b52202b2135ad8)
1 /*	$NetBSD: if_media.c,v 1.54 2022/09/03 02:47:59 thorpej Exp $	*/
2 
3 /*-
4  * Copyright (c) 1998, 2020 The NetBSD Foundation, Inc.
5  * All rights reserved.
6  *
7  * This code is derived from software contributed to The NetBSD Foundation
8  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
9  * NASA Ames Research Center.
10  *
11  * Redistribution and use in source and binary forms, with or without
12  * modification, are permitted provided that the following conditions
13  * are met:
14  * 1. Redistributions of source code must retain the above copyright
15  *    notice, this list of conditions and the following disclaimer.
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in the
18  *    documentation and/or other materials provided with the distribution.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30  * POSSIBILITY OF SUCH DAMAGE.
31  */
32 
33 /*
34  * Copyright (c) 1997
35  *	Jonathan Stone and Jason R. Thorpe.  All rights reserved.
36  *
37  * This software is derived from information provided by Matt Thomas.
38  *
39  * Redistribution and use in source and binary forms, with or without
40  * modification, are permitted provided that the following conditions
41  * are met:
42  * 1. Redistributions of source code must retain the above copyright
43  *    notice, this list of conditions and the following disclaimer.
44  * 2. Redistributions in binary form must reproduce the above copyright
45  *    notice, this list of conditions and the following disclaimer in the
46  *    documentation and/or other materials provided with the distribution.
47  * 3. All advertising materials mentioning features or use of this software
48  *    must display the following acknowledgement:
49  *      This product includes software developed by Jonathan Stone
50  *	and Jason R. Thorpe for the NetBSD Project.
51  * 4. The names of the authors may not be used to endorse or promote products
52  *    derived from this software without specific prior written permission.
53  *
54  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
55  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
56  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
57  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
58  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
59  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
60  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
61  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
62  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
63  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64  * SUCH DAMAGE.
65  */
66 
67 /*
68  * BSD/OS-compatible network interface media selection.
69  *
70  * Where it is safe to do so, this code strays slightly from the BSD/OS
71  * design.  Software which uses the API (device drivers, basically)
72  * shouldn't notice any difference.
73  *
74  * Many thanks to Matt Thomas for providing the information necessary
75  * to implement this interface.
76  */
77 
78 #include <sys/cdefs.h>
79 __KERNEL_RCSID(0, "$NetBSD: if_media.c,v 1.54 2022/09/03 02:47:59 thorpej Exp $");
80 
81 #define	__IFMEDIA_PRIVATE
82 
83 #include <sys/param.h>
84 #include <sys/systm.h>
85 #include <sys/errno.h>
86 #include <sys/ioctl.h>
87 #include <sys/socket.h>
88 #include <sys/kmem.h>
89 
90 #include <net/if.h>
91 #include <net/if_media.h>
92 
93 static void	ifmedia_status(struct ifmedia *, struct ifnet *,
94 		    struct ifmediareq *);
95 static struct ifmedia_entry *
96 		ifmedia_match_locked(struct ifmedia *, u_int, u_int);
97 
98 /*
99  * Compile-time options:
100  * IFMEDIA_DEBUG:
101  *	Turn on implementation-level debug printfs.
102  * 	Useful for debugging newly-ported drivers.
103  */
104 
105 #ifdef IFMEDIA_DEBUG
106 int	ifmedia_debug = 0;
107 static	void ifmedia_printword(int);
108 #endif
109 
110 /*
111  * We need to implement a recursive mutex to handle the un-converted
112  * driver case.  For a fully MP-safe driver, the media lock will be
113  * held before calling any of the entry points that require it.  However,
114  * this is not necessarily the case for a driver that hasn't yet been
115  * converted, and the entry point calls may be nested (for example
116  * mii_ifmedia_change -> ether_mediachange -> mii_mediachg).  Luckily,
117  * the nesting won't be very deep, and 4 nested holds should be plenty.
118  */
119 #define	IFM_L_OWNLOCK		0x01
120 #define	IFM_L_COUNT_MASK	0x3UL
121 #define	IFM_L_CPU_MASK		~(IFM_L_COUNT_MASK)
122 
123 void
ifmedia_lock_for_legacy(struct ifmedia * ifm)124 ifmedia_lock_for_legacy(struct ifmedia *ifm)
125 {
126 	uintptr_t cnt = IFM_L_OWNLOCK;
127 	uintptr_t ci;
128 
129 	if (mutex_tryenter(ifm->ifm_lock)) {
130 		goto gotit;
131 	}
132 
133 	kpreempt_disable();
134 	ci = (uintptr_t)curcpu();
135 	if ((ifm->ifm_legacy & IFM_L_CPU_MASK) == ci) {
136 		cnt = ifm->ifm_legacy & IFM_L_COUNT_MASK;
137 		KASSERT(cnt < IFM_L_COUNT_MASK);
138 		cnt++;
139 		kpreempt_enable();
140 		goto gotit;
141 	}
142 	kpreempt_enable();
143 
144 	mutex_enter(ifm->ifm_lock);
145  gotit:
146 	KASSERT(kpreempt_disabled());
147 	ci = (uintptr_t)curcpu();
148 	KASSERT((ci & IFM_L_CPU_MASK) == ci);
149 	ifm->ifm_legacy = ci | cnt;
150 }
151 
152 void
ifmedia_unlock_for_legacy(struct ifmedia * ifm)153 ifmedia_unlock_for_legacy(struct ifmedia *ifm)
154 {
155 	uintptr_t cnt;
156 	uintptr_t ci = (uintptr_t)curcpu();
157 
158 	KASSERT(kpreempt_disabled());
159 	KASSERT((ifm->ifm_legacy & IFM_L_CPU_MASK) == ci);
160 	cnt = ifm->ifm_legacy & IFM_L_COUNT_MASK;
161 	KASSERT(cnt != 0);
162 	if (cnt == IFM_L_OWNLOCK) {
163 		ifm->ifm_legacy = IFM_L_OWNLOCK;
164 		mutex_exit(ifm->ifm_lock);
165 		return;
166 	}
167 	cnt--;
168 	ifm->ifm_legacy = ci | cnt;
169 }
170 
171 /*
172  * Initialize if_media struct for a specific interface instance.
173  */
174 void
ifmedia_init_with_lock(struct ifmedia * ifm,int dontcare_mask,ifm_change_cb_t change_callback,ifm_stat_cb_t status_callback,kmutex_t * lock)175 ifmedia_init_with_lock(struct ifmedia *ifm, int dontcare_mask,
176     ifm_change_cb_t change_callback, ifm_stat_cb_t status_callback,
177     kmutex_t *lock)
178 {
179 
180 	/*
181 	 * XXX Would really like to assert:
182 	 *
183 	 *	!if_is_mpsafe(ifp) || ((if_is_mpsafe(ifp) && lock != NULL)
184 	 *
185 	 * ...but we don't have access to the ifnet here.
186 	 */
187 
188 	TAILQ_INIT(&ifm->ifm_list);
189 	ifm->ifm_cur = NULL;
190 	ifm->ifm_media = IFM_NONE;
191 	ifm->ifm_mask = dontcare_mask;		/* IF don't-care bits */
192 	ifm->ifm_change = change_callback;
193 	ifm->ifm_status = status_callback;
194 	ifm->ifm_legacy = 0;
195 
196 	if (lock == NULL) {
197 		/*
198 		 * This is to support drivers that are not yet MP-safe
199 		 * with regard to the ifmedia layer.  In these cases,
200 		 * we supply the lock and we ensure it's taken upon entry
201 		 * to various routines that expect it to be held.  When
202 		 * we do this, we expect that the driver is in general a
203 		 * non-MP-safe driver and has already gone to splnet().
204 		 */
205 		lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NET);
206 		ifm->ifm_legacy = IFM_L_OWNLOCK;
207 	}
208 	ifm->ifm_lock = lock;
209 }
210 
211 void
ifmedia_init(struct ifmedia * ifm,int dontcare_mask,ifm_change_cb_t change_callback,ifm_stat_cb_t status_callback)212 ifmedia_init(struct ifmedia *ifm, int dontcare_mask,
213     ifm_change_cb_t change_callback, ifm_stat_cb_t status_callback)
214 {
215 	ifmedia_init_with_lock(ifm, dontcare_mask, change_callback,
216 	    status_callback, NULL);
217 }
218 
219 /*
220  * Free resources associated with an ifmedia.
221  */
222 void
ifmedia_fini(struct ifmedia * ifm)223 ifmedia_fini(struct ifmedia *ifm)
224 {
225 
226 	ifmedia_removeall(ifm);
227 
228 	if (ifm->ifm_legacy) {
229 		KASSERT(ifm->ifm_legacy == IFM_L_OWNLOCK);
230 		mutex_obj_free(ifm->ifm_lock);
231 	}
232 	ifm->ifm_legacy = 0;
233 	ifm->ifm_lock = NULL;
234 }
235 
236 int
ifmedia_change(struct ifmedia * ifm,struct ifnet * ifp)237 ifmedia_change(struct ifmedia *ifm, struct ifnet *ifp)
238 {
239 	int rv;
240 
241 	IFMEDIA_LOCK_FOR_LEGACY(ifm);
242 	KASSERT(ifmedia_locked(ifm));
243 	if (ifm->ifm_change)
244 		rv = (*ifm->ifm_change)(ifp);
245 	else
246 		rv = -1;
247 	IFMEDIA_UNLOCK_FOR_LEGACY(ifm);
248 
249 	return rv;
250 }
251 
252 static void
ifmedia_status(struct ifmedia * ifm,struct ifnet * ifp,struct ifmediareq * ifmr)253 ifmedia_status(struct ifmedia *ifm, struct ifnet *ifp, struct ifmediareq *ifmr)
254 {
255 
256 	KASSERT(ifmedia_locked(ifm));
257 	if (ifm->ifm_status == NULL)
258 		return;
259 	(*ifm->ifm_status)(ifp, ifmr);
260 }
261 
262 /*
263  * Add a media configuration to the list of supported media
264  * for a specific interface instance.
265  */
266 static void
ifmedia_add_entry(struct ifmedia * ifm,int mword,int data,void * aux,struct ifmedia_entry * entry)267 ifmedia_add_entry(struct ifmedia *ifm, int mword, int data, void *aux,
268     struct ifmedia_entry *entry)
269 {
270 
271 #ifdef IFMEDIA_DEBUG
272 	if (ifmedia_debug) {
273 		if (ifm == NULL) {
274 			printf("ifmedia_add: null ifm\n");
275 			return;
276 		}
277 		printf("Adding entry for ");
278 		ifmedia_printword(mword);
279 	}
280 #endif
281 
282 	entry->ifm_media = mword;
283 	entry->ifm_data = data;
284 	entry->ifm_aux = aux;
285 	TAILQ_INSERT_TAIL(&ifm->ifm_list, entry, ifm_list);
286 }
287 
288 void
ifmedia_add(struct ifmedia * ifm,int mword,int data,void * aux)289 ifmedia_add(struct ifmedia *ifm, int mword, int data, void *aux)
290 {
291 	struct ifmedia_entry *entry;
292 
293 	entry = kmem_zalloc(sizeof(*entry), KM_SLEEP);
294 	ifmedia_lock(ifm);
295 	ifmedia_add_entry(ifm, mword, data, aux, entry);
296 	ifmedia_unlock(ifm);
297 }
298 
299 /*
300  * Add an array of media configurations to the list of
301  * supported media for a specific interface instance.
302  */
303 void
ifmedia_list_add(struct ifmedia * ifm,struct ifmedia_entry * lp,int count)304 ifmedia_list_add(struct ifmedia *ifm, struct ifmedia_entry *lp, int count)
305 {
306 	int i;
307 
308 	for (i = 0; i < count; i++)
309 		ifmedia_add(ifm, lp[i].ifm_media, lp[i].ifm_data,
310 		    lp[i].ifm_aux);
311 }
312 
313 /*
314  * Set the default active media.
315  *
316  * Called by device-specific code which is assumed to have already
317  * selected the default media in hardware.  We do _not_ call the
318  * media-change callback.
319  */
320 void
ifmedia_set(struct ifmedia * ifm,int target)321 ifmedia_set(struct ifmedia *ifm, int target)
322 {
323 	struct ifmedia_entry *match, *entry = NULL;
324 
325 	ifmedia_lock(ifm);
326 	match = ifmedia_match_locked(ifm, target, ifm->ifm_mask);
327 
328 	/*
329 	 * If we didn't find the requested media, then we try to fall
330 	 * back to target-type (IFM_ETHER, e.g.) | IFM_NONE.  If that's
331 	 * not on the list, then we add it and set the media to it.
332 	 *
333 	 * Since ifmedia_set is almost always called with IFM_AUTO or
334 	 * with a known-good media, this really should only occur if we:
335 	 *
336 	 * a) didn't find any PHYs, or
337 	 * b) didn't find an autoselect option on the PHY when the
338 	 *    parent ethernet driver expected to.
339 	 *
340 	 * In either case, it makes sense to select no media.
341 	 */
342 	if (match == NULL) {
343 		printf("ifmedia_set: no match for 0x%x/0x%x\n",
344 		    target, ~ifm->ifm_mask);
345 		target = (target & IFM_NMASK) | IFM_NONE;
346 		match = ifmedia_match_locked(ifm, target, ifm->ifm_mask);
347 		if (match == NULL) {
348 			ifmedia_unlock(ifm);
349 			entry = kmem_zalloc(sizeof(*entry), KM_SLEEP);
350 			ifmedia_lock(ifm);
351 			match = ifmedia_match_locked(ifm, target,
352 			    ifm->ifm_mask);
353 			if (match == NULL) {
354 				ifmedia_add_entry(ifm, target, 0, NULL, entry);
355 				entry = NULL;
356 			}
357 			match = ifmedia_match_locked(ifm, target,
358 			    ifm->ifm_mask);
359 			if (match == NULL)
360 				panic("ifmedia_set failed");
361 		}
362 	}
363 	ifm->ifm_cur = match;
364 	ifmedia_unlock(ifm);
365 
366 	if (entry)
367 		kmem_free(entry, sizeof(*entry));
368 
369 #ifdef IFMEDIA_DEBUG
370 	if (ifmedia_debug) {
371 		printf("ifmedia_set: target ");
372 		ifmedia_printword(target);
373 		printf("ifmedia_set: setting to ");
374 		ifmedia_printword(ifm->ifm_cur->ifm_media);
375 	}
376 #endif
377 }
378 
379 static int
ifmedia_getwords(struct ifmedia * const ifm,int * words,int maxwords)380 ifmedia_getwords(struct ifmedia * const ifm, int *words, int maxwords)
381 {
382 	struct ifmedia_entry *ep;
383 	int nwords = 0;
384 
385 	KASSERT(ifmedia_locked(ifm));
386 
387 	TAILQ_FOREACH(ep, &ifm->ifm_list, ifm_list) {
388 		if (words != NULL && nwords < maxwords) {
389 			words[nwords] = ep->ifm_media;
390 		}
391 		nwords++;
392 	}
393 
394 	return nwords;
395 }
396 
397 #define	IFMEDIA_IOCTL_LOCK(ifm)						\
398 do {									\
399 	if (ifmedia_islegacy(ifm))					\
400 		ifmedia_lock_for_legacy(ifm);				\
401 	else								\
402 		ifmedia_lock(ifm);					\
403 } while (/*CONSTCOND*/0)
404 
405 #define	IFMEDIA_IOCTL_UNLOCK(ifm)					\
406 do {									\
407 	if (ifmedia_islegacy(ifm))					\
408 		ifmedia_unlock_for_legacy(ifm);				\
409 	else								\
410 		ifmedia_unlock(ifm);					\
411 } while (/*CONSTCOND*/0)
412 
413 /*
414  * Device-independent media ioctl support function.
415  */
416 int
ifmedia_ioctl(struct ifnet * ifp,struct ifreq * ifr,struct ifmedia * ifm,u_long cmd)417 ifmedia_ioctl(struct ifnet *ifp, struct ifreq *ifr, struct ifmedia *ifm,
418     u_long cmd)
419 {
420 	struct ifmedia_entry *match;
421 	struct ifmediareq *ifmr = (struct ifmediareq *)ifr;
422 	int error = 0;
423 
424 	if (ifp == NULL || ifr == NULL || ifm == NULL)
425 		return EINVAL;
426 
427 	KERNEL_LOCK_UNLESS_IFP_MPSAFE(ifp);
428 
429 	switch (cmd) {
430 	case SIOCSIFMEDIA:	/* Set the current media. */
431 	{
432 		struct ifmedia_entry *oldentry;
433 		u_int oldmedia;
434 		u_int newmedia = ifr->ifr_media;
435 
436 		IFMEDIA_IOCTL_LOCK(ifm);
437 
438 		match = ifmedia_match_locked(ifm, newmedia, ifm->ifm_mask);
439 		if (match == NULL) {
440 #ifdef IFMEDIA_DEBUG
441 			if (ifmedia_debug) {
442 				printf("ifmedia_ioctl: no media found for "
443 				    "0x%08x\n", newmedia);
444 			}
445 #endif
446 			IFMEDIA_IOCTL_UNLOCK(ifm);
447 			error = EINVAL;
448 			break;
449 		}
450 
451 		/*
452 		 * If no change, we're done.
453 		 * XXX Automedia may involve software intervention.
454 		 *     Keep going in case the connected media changed.
455 		 *     Similarly, if best match changed (kernel debugger?).
456 		 */
457 		if ((IFM_SUBTYPE(newmedia) != IFM_AUTO) &&
458 		    (newmedia == ifm->ifm_media) && (match == ifm->ifm_cur)) {
459 			IFMEDIA_IOCTL_UNLOCK(ifm);
460 			break;
461 		}
462 
463 		/*
464 		 * We found a match, now make the driver switch to it.
465 		 * Make sure to preserve our old media type in case the
466 		 * driver can't switch.
467 		 */
468 #ifdef IFMEDIA_DEBUG
469 		if (ifmedia_debug) {
470 			printf("ifmedia_ioctl: switching %s to ",
471 			    ifp->if_xname);
472 			ifmedia_printword(match->ifm_media);
473 		}
474 #endif
475 		oldentry = ifm->ifm_cur;
476 		oldmedia = ifm->ifm_media;
477 		ifm->ifm_cur = match;
478 		ifm->ifm_media = newmedia;
479 		error = ifmedia_change(ifm, ifp);
480 		if (error) {
481 			ifm->ifm_cur = oldentry;
482 			ifm->ifm_media = oldmedia;
483 		}
484 		IFMEDIA_IOCTL_UNLOCK(ifm);
485 		break;
486 	}
487 
488 	/* Get list of available media and current media on interface. */
489 	case SIOCGIFMEDIA:
490 	{
491 		int nwords1, nwords2;
492 
493 		if (ifmr->ifm_count < 0) {
494 			error = EINVAL;
495 			break;
496 		}
497 
498 		IFMEDIA_IOCTL_LOCK(ifm);
499 		ifmr->ifm_active = ifmr->ifm_current = ifm->ifm_cur ?
500 		    ifm->ifm_cur->ifm_media : IFM_NONE;
501 		ifmr->ifm_mask = ifm->ifm_mask;
502 		ifmr->ifm_status = 0;
503 		ifmedia_status(ifm, ifp, ifmr);
504 
505 		/*
506 		 * Count them so we know how much is the max we'll
507 		 * need.
508 		 */
509 		nwords1 = nwords2 = ifmedia_getwords(ifm, NULL, 0);
510 		IFMEDIA_IOCTL_UNLOCK(ifm);
511 
512 		if (ifmr->ifm_count != 0) {
513 			int maxwords = MIN(nwords1, ifmr->ifm_count);
514 			int *kptr = kmem_zalloc(maxwords * sizeof(int),
515 			    KM_SLEEP);
516 
517 			ifmedia_lock(ifm);
518 			nwords2 = ifmedia_getwords(ifm, kptr, maxwords);
519 			ifmedia_unlock(ifm);
520 			error = copyout(kptr, ifmr->ifm_ulist,
521 			    maxwords * sizeof(int));
522 			if (error == 0 && nwords2 > nwords1)
523 				error = E2BIG;	/* oops! */
524 			kmem_free(kptr, maxwords * sizeof(int));
525 		}
526 		/* Update with the real number */
527 		ifmr->ifm_count = nwords2;
528 		break;
529 	}
530 
531 	default:
532 		error = EINVAL;
533 		break;
534 	}
535 
536 	KERNEL_UNLOCK_UNLESS_IFP_MPSAFE(ifp);
537 
538 	return error;
539 }
540 
541 /*
542  * Find media entry matching a given ifm word.
543  */
544 static struct ifmedia_entry *
ifmedia_match_locked(struct ifmedia * ifm,u_int target,u_int mask)545 ifmedia_match_locked(struct ifmedia *ifm, u_int target, u_int mask)
546 {
547 	struct ifmedia_entry *match, *next;
548 
549 	match = NULL;
550 	mask = ~mask;
551 
552 	TAILQ_FOREACH(next, &ifm->ifm_list, ifm_list) {
553 		if ((next->ifm_media & mask) == (target & mask)) {
554 			if (match) {
555 #if defined(IFMEDIA_DEBUG) || defined(DIAGNOSTIC)
556 				printf("ifmedia_match: multiple match for "
557 				    "0x%x/0x%x, selected instance %d\n",
558 				    target, mask, IFM_INST(match->ifm_media));
559 #endif
560 				break;
561 			}
562 			match = next;
563 		}
564 	}
565 
566 	return match;
567 }
568 
569 struct ifmedia_entry *
ifmedia_match(struct ifmedia * ifm,u_int target,u_int mask)570 ifmedia_match(struct ifmedia *ifm, u_int target, u_int mask)
571 {
572 	struct ifmedia_entry *match;
573 
574 	/*
575 	 * N.B. We expect the caller is responsible fot the lifecycle
576 	 * of the media entries.  Use with extreme caution.
577 	 */
578 
579 	ifmedia_lock(ifm);
580 	match = ifmedia_match_locked(ifm, target, mask);
581 	ifmedia_unlock(ifm);
582 	return match;
583 }
584 
585 /*
586  * Delete all media for a given instance.
587  */
588 void
ifmedia_delete_instance(struct ifmedia * ifm,u_int inst)589 ifmedia_delete_instance(struct ifmedia *ifm, u_int inst)
590 {
591 	struct ifmedia_entry *ife, *nife;
592 	TAILQ_HEAD(, ifmedia_entry) dead_entries;
593 
594 	TAILQ_INIT(&dead_entries);
595 
596 	ifmedia_lock(ifm);
597 	TAILQ_FOREACH_SAFE(ife, &ifm->ifm_list, ifm_list, nife) {
598 		if (inst == IFM_INST_ANY ||
599 		    inst == IFM_INST(ife->ifm_media)) {
600 			if (ifm->ifm_cur == ife) {
601 				ifm->ifm_cur = NULL;
602 				ifm->ifm_media = IFM_NONE;
603 			}
604 			TAILQ_REMOVE(&ifm->ifm_list, ife, ifm_list);
605 			TAILQ_INSERT_TAIL(&dead_entries, ife, ifm_list);
606 		}
607 	}
608 	ifmedia_unlock(ifm);
609 
610 	TAILQ_FOREACH_SAFE(ife, &dead_entries, ifm_list, nife) {
611 		TAILQ_REMOVE(&dead_entries, ife, ifm_list);
612 		kmem_free(ife, sizeof(*ife));
613 	}
614 }
615 
616 void
ifmedia_removeall(struct ifmedia * ifm)617 ifmedia_removeall(struct ifmedia *ifm)
618 {
619 
620 	ifmedia_delete_instance(ifm, IFM_INST_ANY);
621 }
622 
623 /*
624  * Compute the interface `baudrate' from the media, for the interface
625  * metrics (used by routing daemons).
626  */
627 static const struct ifmedia_baudrate ifmedia_baudrate_descriptions[] =
628     IFM_BAUDRATE_DESCRIPTIONS;
629 
630 uint64_t
ifmedia_baudrate(int mword)631 ifmedia_baudrate(int mword)
632 {
633 	int i;
634 
635 	for (i = 0; ifmedia_baudrate_descriptions[i].ifmb_word != 0; i++) {
636 		if (IFM_TYPE_SUBTYPE_MATCH(mword,
637 		    ifmedia_baudrate_descriptions[i].ifmb_word))
638 			return ifmedia_baudrate_descriptions[i].ifmb_baudrate;
639 	}
640 
641 	/* Not known. */
642 	return 0;
643 }
644 
645 #ifdef IFMEDIA_DEBUG
646 
647 static const struct ifmedia_description ifm_type_descriptions[] =
648     IFM_TYPE_DESCRIPTIONS;
649 
650 static const struct ifmedia_description ifm_subtype_descriptions[] =
651     IFM_SUBTYPE_DESCRIPTIONS;
652 
653 static const struct ifmedia_description ifm_option_descriptions[] =
654     IFM_OPTION_DESCRIPTIONS;
655 
656 /*
657  * print a media word.
658  */
659 static void
ifmedia_printword(int ifmw)660 ifmedia_printword(int ifmw)
661 {
662 	const struct ifmedia_description *desc;
663 	int seen_option = 0;
664 
665 	/* Print the top-level interface type. */
666 	for (desc = ifm_type_descriptions; desc->ifmt_string != NULL;
667 	     desc++) {
668 		if (IFM_TYPE(ifmw) == desc->ifmt_word)
669 			break;
670 	}
671 	if (desc->ifmt_string == NULL)
672 		printf("<unknown type> ");
673 	else
674 		printf("%s ", desc->ifmt_string);
675 
676 	/* Print the subtype. */
677 	for (desc = ifm_subtype_descriptions; desc->ifmt_string != NULL;
678 	     desc++) {
679 		if (IFM_TYPE_MATCH(desc->ifmt_word, ifmw) &&
680 		    IFM_SUBTYPE(desc->ifmt_word) == IFM_SUBTYPE(ifmw))
681 			break;
682 	}
683 	if (desc->ifmt_string == NULL)
684 		printf("<unknown subtype>");
685 	else
686 		printf("%s", desc->ifmt_string);
687 
688 	/* Print any options. */
689 	for (desc = ifm_option_descriptions; desc->ifmt_string != NULL;
690 	     desc++) {
691 		if (IFM_TYPE_MATCH(desc->ifmt_word, ifmw) &&
692 		    (ifmw & desc->ifmt_word) != 0 &&
693 		    (seen_option & IFM_OPTIONS(desc->ifmt_word)) == 0) {
694 			if (seen_option == 0)
695 				printf(" <");
696 			printf("%s%s", seen_option ? "," : "",
697 			    desc->ifmt_string);
698 			seen_option |= IFM_OPTIONS(desc->ifmt_word);
699 		}
700 	}
701 	printf("%s\n", seen_option ? ">" : "");
702 }
703 
704 #endif /* IFMEDIA_DEBUG */
705