 @@ -1,14 +1,14 @@
-/*	$NetBSD: if_media.c,v 1.49 2020/01/20 19:35:39 thorpej Exp $	*/
+/*	$NetBSD: if_media.c,v 1.50 2020/01/31 00:49:18 thorpej Exp $	*/
 /*-
  * Copyright (c) 1998 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
  * NASA Ames Research Center.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
 @@ -66,58 +66,56 @@
 /*
  * BSD/OS-compatible network interface media selection.
+ *
  * Where it is safe to do so, this code strays slightly from the BSD/OS
  * design.  Software which uses the API (device drivers, basically)
  * shouldn't notice any difference.
+ *
  * Many thanks to Matt Thomas for providing the information necessary
  * to implement this interface.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: if_media.c,v 1.49 2020/01/20 19:35:39 thorpej Exp $");
+__KERNEL_RCSID(0, "$NetBSD: if_media.c,v 1.50 2020/01/31 00:49:18 thorpej Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/errno.h>
 #include <sys/ioctl.h>
 #include <sys/socket.h>
-#include <sys/malloc.h>
+#include <sys/kmem.h>
 #include <net/if.h>
 #include <net/if_media.h>
 #include <net/netisr.h>
 static void	ifmedia_status(struct ifmedia *, struct ifnet *,
     struct ifmediareq *);
 static int	ifmedia_ioctl_locked(struct ifnet *, struct ifreq *,
     struct ifmedia *, u_long);
 /*
  * Compile-time options:
  * IFMEDIA_DEBUG:
  *	Turn on implementation-level debug printfs.
  * 	Useful for debugging newly-ported drivers.
  */
 #ifdef IFMEDIA_DEBUG
 int	ifmedia_debug = 0;
 static	void ifmedia_printword(int);
 #endif
 MALLOC_DEFINE(M_IFMEDIA, "ifmedia", "interface media state");
 /*
  * Initialize if_media struct for a specific interface instance.
  */
 void
 ifmedia_init(struct ifmedia *ifm, int dontcare_mask,
     ifm_change_cb_t change_callback, ifm_stat_cb_t status_callback)
+{
 	TAILQ_INIT(&ifm->ifm_list);
 	ifm->ifm_cur = NULL;
 	ifm->ifm_media = IFM_NONE;
 	ifm->ifm_mask = dontcare_mask;		/* IF don't-care bits */
 	ifm->ifm_change = change_callback;
 @@ -152,27 +150,27 @@ ifmedia_add(struct ifmedia *ifm, int mwo
 	struct ifmedia_entry *entry;
 #ifdef IFMEDIA_DEBUG
 	if (ifmedia_debug) {
 		if (ifm == NULL) {
 			printf("ifmedia_add: null ifm\n");
 			return;
+		}
 		printf("Adding entry for ");
 		ifmedia_printword(mword);
+	}
 #endif
-	entry = malloc(sizeof(*entry), M_IFMEDIA, M_WAITOK);
+	entry = kmem_zalloc(sizeof(*entry), KM_SLEEP);
 	entry->ifm_media = mword;
 	entry->ifm_data = data;
 	entry->ifm_aux = aux;
 	TAILQ_INSERT_TAIL(&ifm->ifm_list, entry, ifm_list);
+}
 /*
  * Add an array of media configurations to the list of
  * supported media for a specific interface instance.
  */
 void
 ifmedia_list_add(struct ifmedia *ifm, struct ifmedia_entry *lp, int count)
+{
 @@ -225,26 +223,42 @@ ifmedia_set(struct ifmedia *ifm, int tar
+	}
 	ifm->ifm_cur = match;
 #ifdef IFMEDIA_DEBUG
 	if (ifmedia_debug) {
 		printf("ifmedia_set: target ");
 		ifmedia_printword(target);
 		printf("ifmedia_set: setting to ");
 		ifmedia_printword(ifm->ifm_cur->ifm_media);
+	}
 #endif
+}
 static int
 ifmedia_getwords(struct ifmedia * const ifm, int *words, int maxwords)
+{
 	struct ifmedia_entry *ep;
 	int nwords = 0;
 	TAILQ_FOREACH(ep, &ifm->ifm_list, ifm_list) {
 		if (words != NULL && nwords < maxwords) {
 			words[nwords] = ep->ifm_media;
+		}
 		nwords++;
+	}
 	return nwords;
+}
 /*
  * Device-independent media ioctl support function.
  */
 static int
 ifmedia_ioctl_locked(struct ifnet *ifp, struct ifreq *ifr, struct ifmedia *ifm,
     u_long cmd)
+{
 	struct ifmedia_entry *match;
 	struct ifmediareq *ifmr = (struct ifmediareq *)ifr;
 	int error = 0;
 	if (ifp == NULL || ifr == NULL || ifm == NULL)
 		return EINVAL;
 @@ -294,67 +308,57 @@ ifmedia_ioctl_locked(struct ifnet *ifp,
 		ifm->ifm_cur = match;
 		ifm->ifm_media = newmedia;
 		error = ifmedia_change(ifm, ifp);
 		if (error) {
 			ifm->ifm_cur = oldentry;
 			ifm->ifm_media = oldmedia;
+		}
 		break;
+	}
 	/* Get list of available media and current media on interface. */
 	case SIOCGIFMEDIA:
+	{
-		struct ifmedia_entry *ep;
+		int nwords1, nwords2;
 		size_t nwords;
 		if (ifmr->ifm_count < 0)
 			return EINVAL;
 		ifmr->ifm_active = ifmr->ifm_current = ifm->ifm_cur ?
 		    ifm->ifm_cur->ifm_media : IFM_NONE;
 		ifmr->ifm_mask = ifm->ifm_mask;
 		ifmr->ifm_status = 0;
 		ifmedia_status(ifm, ifp, ifmr);
 		/*
 		 * Count them so we know a-priori how much is the max we'll
 		 * need.
 		 */
-		ep = TAILQ_FIRST(&ifm->ifm_list);
+		nwords1 = nwords2 = ifmedia_getwords(ifm, NULL, 0);
 		for (nwords = 0; ep != NULL; ep = TAILQ_NEXT(ep, ifm_list))
 			nwords++;
 		if (ifmr->ifm_count != 0) {
-			size_t count;
+			int maxwords = MIN(nwords1, ifmr->ifm_count);
-			size_t minwords = nwords > (size_t)ifmr->ifm_count
+			int *kptr = kmem_zalloc(maxwords * sizeof(int),
-			    ? (size_t)ifmr->ifm_count : nwords;
+			    KM_SLEEP);
 			int *kptr = malloc(minwords * sizeof(int), M_TEMP,
 			    M_WAITOK);
 			/* Get the media words from the interface's list. */
 			ep = TAILQ_FIRST(&ifm->ifm_list);
 			for (count = 0; ep != NULL && count < minwords;
 			    ep = TAILQ_NEXT(ep, ifm_list), count++)
 				kptr[count] = ep->ifm_media;
 			nwords2 = ifmedia_getwords(ifm, kptr, maxwords);
 			error = copyout(kptr, ifmr->ifm_ulist,
-			    minwords * sizeof(int));
+			    maxwords * sizeof(int));
-			if (error == 0 && ep != NULL)
+			if (error == 0 && nwords2 > nwords1)
 				error = E2BIG;	/* oops! */
-			free(kptr, M_TEMP);
+			kmem_free(kptr, maxwords * sizeof(int));
+		}
 		/* Update with the real number */
-		ifmr->ifm_count = nwords;
+		ifmr->ifm_count = nwords2;
 		break;
+	}
 	default:
 		return EINVAL;
+	}
 	return error;
+}
 int
 ifmedia_ioctl(struct ifnet *ifp, struct ifreq *ifr, struct ifmedia *ifm,
     u_long cmd)
 @@ -410,27 +414,27 @@ ifmedia_match(struct ifmedia *ifm, u_int
 /*
  * Delete all media for a given instance.
  */
 void
 ifmedia_delete_instance(struct ifmedia *ifm, u_int inst)
+{
 	struct ifmedia_entry *ife, *nife;
 	TAILQ_FOREACH_SAFE(ife, &ifm->ifm_list, ifm_list, nife) {
 		if (inst == IFM_INST_ANY ||
 		    inst == IFM_INST(ife->ifm_media)) {
 			TAILQ_REMOVE(&ifm->ifm_list, ife, ifm_list);
-			free(ife, M_IFMEDIA);
+			kmem_free(ife, sizeof(*ife));
+		}
+	}
 	if (inst == IFM_INST_ANY) {
 		ifm->ifm_cur = NULL;
 		ifm->ifm_media = IFM_NONE;
+	}
+}
 void
 ifmedia_removeall(struct ifmedia *ifm)
+{
 	ifmedia_delete_instance(ifm, IFM_INST_ANY);