Retire the MALLOC and FREE macros. They are an abomination unto style(9).

MFC after:	3 months

16 files changed, 71 insertions, 76 deletions

diff --git a/sys/kern/kern_descrip.c b/sys/kern/kern_descrip.c
index f3dd227f505e..4ccc37ee87bc 100644
--- a/sys/kern/kern_descrip.c
+++ b/sys/kern/kern_descrip.c
@@ -852,7 +852,7 @@ funsetown(struct sigio **sigiop)
 	}
 	SIGIO_UNLOCK();
 	crfree(sigio->sio_ucred);
-	FREE(sigio, M_SIGIO);
+	free(sigio, M_SIGIO);
 }
 
 /*
@@ -910,7 +910,7 @@ funsetownlst(struct sigiolst *sigiolst)
 		}
 		SIGIO_UNLOCK();
 		crfree(sigio->sio_ucred);
-		FREE(sigio, M_SIGIO);
+		free(sigio, M_SIGIO);
 		SIGIO_LOCK();
 	}
 	SIGIO_UNLOCK();
@@ -938,7 +938,7 @@ fsetown(pid_t pgid, struct sigio **sigiop)
 	ret = 0;
 
 	/* Allocate and fill in the new sigio out of locks. */
-	MALLOC(sigio, struct sigio *, sizeof(struct sigio), M_SIGIO, M_WAITOK);
+	sigio = malloc(sizeof(struct sigio), M_SIGIO, M_WAITOK);
 	sigio->sio_pgid = pgid;
 	sigio->sio_ucred = crhold(curthread->td_ucred);
 	sigio->sio_myref = sigiop;
@@ -1020,7 +1020,7 @@ fsetown(pid_t pgid, struct sigio **sigiop)
 fail:
 	sx_sunlock(&proctree_lock);
 	crfree(sigio->sio_ucred);
-	FREE(sigio, M_SIGIO);
+	free(sigio, M_SIGIO);
 	return (ret);
 }
 
@@ -1287,11 +1287,11 @@ fdgrowtable(struct filedesc *fdp, int nfd)
 
 	/* allocate a new table and (if required) new bitmaps */
 	FILEDESC_XUNLOCK(fdp);
-	MALLOC(ntable, struct file **, nnfiles * OFILESIZE,
+	ntable = malloc(nnfiles * OFILESIZE,
 	    M_FILEDESC, M_ZERO | M_WAITOK);
 	nfileflags = (char *)&ntable[nnfiles];
 	if (NDSLOTS(nnfiles) > NDSLOTS(onfiles))
-		MALLOC(nmap, NDSLOTTYPE *, NDSLOTS(nnfiles) * NDSLOTSIZE,
+		nmap = malloc(NDSLOTS(nnfiles) * NDSLOTSIZE,
 		    M_FILEDESC, M_ZERO | M_WAITOK);
 	else
 		nmap = NULL;
@@ -1521,7 +1521,7 @@ fddrop(struct filedesc *fdp)
 		return;
 
 	FILEDESC_LOCK_DESTROY(fdp);
-	FREE(fdp, M_FILEDESC);
+	free(fdp, M_FILEDESC);
 }
 
 /*
@@ -1696,7 +1696,7 @@ fdfree(struct thread *td)
 		td->td_proc->p_fdtol = NULL;
 		FILEDESC_XUNLOCK(fdp);
 		if (fdtol != NULL)
-			FREE(fdtol, M_FILEDESC_TO_LEADER);
+			free(fdtol, M_FILEDESC_TO_LEADER);
 	}
 	FILEDESC_XLOCK(fdp);
 	i = --fdp->fd_refcnt;
@@ -1720,9 +1720,9 @@ fdfree(struct thread *td)
 	mtx_unlock(&fdesc_mtx);
 
 	if (fdp->fd_nfiles > NDFILE)
-		FREE(fdp->fd_ofiles, M_FILEDESC);
+		free(fdp->fd_ofiles, M_FILEDESC);
 	if (NDSLOTS(fdp->fd_nfiles) > NDSLOTS(NDFILE))
-		FREE(fdp->fd_map, M_FILEDESC);
+		free(fdp->fd_map, M_FILEDESC);
 
 	fdp->fd_nfiles = 0;
 
@@ -2409,8 +2409,7 @@ filedesc_to_leader_alloc(struct filedesc_to_leader *old, struct filedesc *fdp, s
 {
 	struct filedesc_to_leader *fdtol;
 
-	MALLOC(fdtol, struct filedesc_to_leader *,
-	       sizeof(struct filedesc_to_leader),
+	fdtol = malloc(	       sizeof(struct filedesc_to_leader),
 	       M_FILEDESC_TO_LEADER,
 	       M_WAITOK);
 	fdtol->fdl_refcount = 1;
diff --git a/sys/kern/kern_event.c b/sys/kern/kern_event.c
index ab3cbb7abde0..6a631bef69c7 100644
--- a/sys/kern/kern_event.c
+++ b/sys/kern/kern_event.c
@@ -529,7 +529,7 @@ filt_timerattach(struct knote *kn)
 
 	kn->kn_flags |= EV_CLEAR;		/* automatically set */
 	kn->kn_status &= ~KN_DETACHED;		/* knlist_add usually sets it */
-	MALLOC(calloutp, struct callout *, sizeof(*calloutp),
+	calloutp = malloc(sizeof(*calloutp),
 	    M_KQUEUE, M_WAITOK);
 	callout_init(calloutp, CALLOUT_MPSAFE);
 	kn->kn_hook = calloutp;
@@ -547,7 +547,7 @@ filt_timerdetach(struct knote *kn)
 
 	calloutp = (struct callout *)kn->kn_hook;
 	callout_drain(calloutp);
-	FREE(calloutp, M_KQUEUE);
+	free(calloutp, M_KQUEUE);
 	atomic_add_int(&kq_ncallouts, -1);
 	kn->kn_status |= KN_DETACHED;	/* knlist_remove usually clears it */
 }
@@ -1109,19 +1109,18 @@ kqueue_expand(struct kqueue *kq, struct filterops *fops, uintptr_t ident,
 			size = kq->kq_knlistsize;
 			while (size <= fd)
 				size += KQEXTENT;
-			MALLOC(list, struct klist *,
-			    size * sizeof list, M_KQUEUE, mflag);
+			list = malloc(			    size * sizeof list, M_KQUEUE, mflag);
 			if (list == NULL)
 				return ENOMEM;
 			KQ_LOCK(kq);
 			if (kq->kq_knlistsize > fd) {
-				FREE(list, M_KQUEUE);
+				free(list, M_KQUEUE);
 				list = NULL;
 			} else {
 				if (kq->kq_knlist != NULL) {
 					bcopy(kq->kq_knlist, list,
 					    kq->kq_knlistsize * sizeof list);
-					FREE(kq->kq_knlist, M_KQUEUE);
+					free(kq->kq_knlist, M_KQUEUE);
 					kq->kq_knlist = NULL;
 				}
 				bzero((caddr_t)list +
diff --git a/sys/kern/kern_jail.c b/sys/kern/kern_jail.c
index 654b56f5dbbd..3afbc918be90 100644
--- a/sys/kern/kern_jail.c
+++ b/sys/kern/kern_jail.c
@@ -137,7 +137,7 @@ jail(struct thread *td, struct jail_args *uap)
 	if (j.version != 0)
 		return (EINVAL);
 
-	MALLOC(pr, struct prison *, sizeof(*pr), M_PRISON, M_WAITOK | M_ZERO);
+	pr = malloc(sizeof(*pr), M_PRISON, M_WAITOK | M_ZERO);
 	mtx_init(&pr->pr_mtx, "jail mutex", NULL, MTX_DEF);
 	pr->pr_ref = 1;
 	error = copyinstr(j.path, &pr->pr_path, sizeof(pr->pr_path), 0);
@@ -211,13 +211,13 @@ e_dropprref:
 	sx_sunlock(&allprison_lock);
 e_dropvnref:
 	if (pr->pr_slots != NULL)
-		FREE(pr->pr_slots, M_PRISON);
+		free(pr->pr_slots, M_PRISON);
 	vfslocked = VFS_LOCK_GIANT(pr->pr_root->v_mount);
 	vrele(pr->pr_root);
 	VFS_UNLOCK_GIANT(vfslocked);
 e_killmtx:
 	mtx_destroy(&pr->pr_mtx);
-	FREE(pr, M_PRISON);
+	free(pr, M_PRISON);
 	return (error);
 }
 
@@ -343,7 +343,7 @@ prison_complete(void *context, int pending)
 	}
 	sx_sunlock(&allprison_lock);
 	if (pr->pr_slots != NULL)
-		FREE(pr->pr_slots, M_PRISON);
+		free(pr->pr_slots, M_PRISON);
 
 	vfslocked = VFS_LOCK_GIANT(pr->pr_root->v_mount);
 	vrele(pr->pr_root);
@@ -351,8 +351,8 @@ prison_complete(void *context, int pending)
 
 	mtx_destroy(&pr->pr_mtx);
 	if (pr->pr_linux != NULL)
-		FREE(pr->pr_linux, M_PRISON);
-	FREE(pr, M_PRISON);
+		free(pr->pr_linux, M_PRISON);
+	free(pr, M_PRISON);
 }
 
 void
diff --git a/sys/kern/kern_linker.c b/sys/kern/kern_linker.c
index 9f322d791f69..6cc5d5d99f44 100644
--- a/sys/kern/kern_linker.c
+++ b/sys/kern/kern_linker.c
@@ -1893,14 +1893,13 @@ linker_hwpmc_list_objects(void)
 
  retry:
 	/* allocate nmappings+1 entries */
-	MALLOC(hc.kobase, struct pmckern_map_in *,
-	    (hc.nmappings + 1) * sizeof(struct pmckern_map_in), M_LINKER,
+	hc.kobase = malloc(	    (hc.nmappings + 1) * sizeof(struct pmckern_map_in), M_LINKER,
 	    M_WAITOK | M_ZERO);
 
 	hc.nobjects = 0;
 	if (linker_file_foreach(linker_hwpmc_list_object, &hc) != 0) {
 		hc.nmappings = hc.nobjects;
-		FREE(hc.kobase, M_LINKER);
+		free(hc.kobase, M_LINKER);
 		goto retry;
 	}
 
diff --git a/sys/kern/kern_mtxpool.c b/sys/kern/kern_mtxpool.c
index aab28b6fba40..6a98fea01745 100644
--- a/sys/kern/kern_mtxpool.c
+++ b/sys/kern/kern_mtxpool.c
@@ -146,8 +146,7 @@ mtx_pool_create(const char *mtx_name, int pool_size, int opts)
 		    mtx_name);
 		pool_size = 128;
 	}
-	MALLOC(pool, struct mtx_pool *,
-	    sizeof (struct mtx_pool) + ((pool_size - 1) * sizeof (struct mtx)),
+	pool = malloc(	    sizeof (struct mtx_pool) + ((pool_size - 1) * sizeof (struct mtx)),
 	    M_MTXPOOL, M_WAITOK | M_ZERO);
 	mtx_pool_initialize(pool, mtx_name, pool_size, opts);
 	return pool;
@@ -161,7 +160,7 @@ mtx_pool_destroy(struct mtx_pool **poolp)
 
 	for (i = pool->mtx_pool_size - 1; i >= 0; --i)
 		mtx_destroy(&pool->mtx_pool_ary[i]);
-	FREE(pool, M_MTXPOOL);
+	free(pool, M_MTXPOOL);
 	*poolp = NULL;
 }
 
@@ -208,7 +207,7 @@ mtx_pool_alloc(struct mtx_pool *pool)
  * memory allocator.  The lockmgr subsystem is initialized by
  * SYSINIT(..., SI_SUB_LOCKMGR, ...).
  *
- * We can't call MALLOC() to dynamically allocate the sleep pool
+ * We can't call malloc() to dynamically allocate the sleep pool
  * until after kmeminit() has been called, which is done by
  * SYSINIT(..., SI_SUB_KMEM, ...).
  */
diff --git a/sys/kern/kern_proc.c b/sys/kern/kern_proc.c
index e45a4890fbe1..02e6c41f27c3 100644
--- a/sys/kern/kern_proc.c
+++ b/sys/kern/kern_proc.c
@@ -509,7 +509,7 @@ pgdelete(pgrp)
 	}
 
 	mtx_destroy(&pgrp->pg_mtx);
-	FREE(pgrp, M_PGRP);
+	free(pgrp, M_PGRP);
 	sess_release(savesess);
 }
 
@@ -629,7 +629,7 @@ sess_release(struct session *s)
 			tty_rel_sess(s->s_ttyp, s);
 		}
 		mtx_destroy(&s->s_mtx);
-		FREE(s, M_SESSION);
+		free(s, M_SESSION);
 	}
 }
 
@@ -1173,7 +1173,7 @@ pargs_alloc(int len)
 {
 	struct pargs *pa;
 
-	MALLOC(pa, struct pargs *, sizeof(struct pargs) + len, M_PARGS,
+	pa = malloc(sizeof(struct pargs) + len, M_PARGS,
 		M_WAITOK);
 	refcount_init(&pa->ar_ref, 1);
 	pa->ar_length = len;
@@ -1184,7 +1184,7 @@ static void
 pargs_free(struct pargs *pa)
 {
 
-	FREE(pa, M_PARGS);
+	free(pa, M_PARGS);
 }
 
 void
diff --git a/sys/kern/kern_prot.c b/sys/kern/kern_prot.c
index bbd4fd5bf243..348acdf131a2 100644
--- a/sys/kern/kern_prot.c
+++ b/sys/kern/kern_prot.c
@@ -326,8 +326,8 @@ setsid(register struct thread *td, struct setsid_args *uap)
 	error = 0;
 	pgrp = NULL;
 
-	MALLOC(newpgrp, struct pgrp *, sizeof(struct pgrp), M_PGRP, M_WAITOK | M_ZERO);
-	MALLOC(newsess, struct session *, sizeof(struct session), M_SESSION, M_WAITOK | M_ZERO);
+	newpgrp = malloc(sizeof(struct pgrp), M_PGRP, M_WAITOK | M_ZERO);
+	newsess = malloc(sizeof(struct session), M_SESSION, M_WAITOK | M_ZERO);
 
 	sx_xlock(&proctree_lock);
 
@@ -345,9 +345,9 @@ setsid(register struct thread *td, struct setsid_args *uap)
 	sx_xunlock(&proctree_lock);
 
 	if (newpgrp != NULL)
-		FREE(newpgrp, M_PGRP);
+		free(newpgrp, M_PGRP);
 	if (newsess != NULL)
-		FREE(newsess, M_SESSION);
+		free(newsess, M_SESSION);
 
 	return (error);
 }
@@ -386,7 +386,7 @@ setpgid(struct thread *td, register struct setpgid_args *uap)
 
 	error = 0;
 
-	MALLOC(newpgrp, struct pgrp *, sizeof(struct pgrp), M_PGRP, M_WAITOK | M_ZERO);
+	newpgrp = malloc(sizeof(struct pgrp), M_PGRP, M_WAITOK | M_ZERO);
 
 	sx_xlock(&proctree_lock);
 	if (uap->pid != 0 && uap->pid != curp->p_pid) {
@@ -450,7 +450,7 @@ done:
 	KASSERT((error == 0) || (newpgrp != NULL),
 	    ("setpgid failed and newpgrp is NULL"));
 	if (newpgrp != NULL)
-		FREE(newpgrp, M_PGRP);
+		free(newpgrp, M_PGRP);
 	return (error);
 }
 
@@ -1778,7 +1778,7 @@ crget(void)
 {
 	register struct ucred *cr;
 
-	MALLOC(cr, struct ucred *, sizeof(*cr), M_CRED, M_WAITOK | M_ZERO);
+	cr = malloc(sizeof(*cr), M_CRED, M_WAITOK | M_ZERO);
 	refcount_init(&cr->cr_ref, 1);
 #ifdef AUDIT
 	audit_cred_init(cr);
@@ -1830,7 +1830,7 @@ crfree(struct ucred *cr)
 #ifdef MAC
 		mac_cred_destroy(cr);
 #endif
-		FREE(cr, M_CRED);
+		free(cr, M_CRED);
 	}
 }
 
diff --git a/sys/kern/kern_resource.c b/sys/kern/kern_resource.c
index 0a67a5bc9282..6e734776a2db 100644
--- a/sys/kern/kern_resource.c
+++ b/sys/kern/kern_resource.c
@@ -1268,7 +1268,7 @@ uifree(uip)
 		if (uip->ui_proccnt != 0)
 			printf("freeing uidinfo: uid = %d, proccnt = %ld\n",
 			    uip->ui_uid, uip->ui_proccnt);
-		FREE(uip, M_UIDINFO);
+		free(uip, M_UIDINFO);
 		return;
 	}
 	/*
diff --git a/sys/kern/subr_blist.c b/sys/kern/subr_blist.c
index 335764680dcb..d4459a20bf9c 100644
--- a/sys/kern/subr_blist.c
+++ b/sys/kern/subr_blist.c
@@ -554,7 +554,7 @@ blst_meta_free(
 	int next_skip = ((u_int)skip / BLIST_META_RADIX);
 
 #if 0
-	printf("FREE (%llx,%lld) FROM (%llx,%lld)\n",
+	printf("free (%llx,%lld) FROM (%llx,%lld)\n",
 	    (long long)freeBlk, (long long)count,
 	    (long long)blk, (long long)radix
 	);
diff --git a/sys/kern/subr_witness.c b/sys/kern/subr_witness.c
index 48c4b5c35b61..790e90fbe89f 100644
--- a/sys/kern/subr_witness.c
+++ b/sys/kern/subr_witness.c
@@ -708,8 +708,7 @@ witness_initialize(void *dummy __unused)
 	struct witness *w, *w1;
 	int i;
 
-	MALLOC(w_data, struct witness *,
-	    sizeof (struct witness) * WITNESS_COUNT, M_WITNESS,
+	w_data = malloc(	    sizeof (struct witness) * WITNESS_COUNT, M_WITNESS,
 	    M_NOWAIT | M_ZERO);
 
 	/*
diff --git a/sys/kern/uipc_accf.c b/sys/kern/uipc_accf.c
index 4449b5bc5c68..102c04f26630 100644
--- a/sys/kern/uipc_accf.c
+++ b/sys/kern/uipc_accf.c
@@ -84,7 +84,7 @@ accept_filt_add(struct accept_filter *filt)
 			} else {
 				p->accf_callback = filt->accf_callback;
 				ACCEPT_FILTER_UNLOCK();
-				FREE(filt, M_ACCF);
+				free(filt, M_ACCF);
 				return (0);
 			}
 		}
@@ -131,7 +131,7 @@ accept_filt_generic_mod_event(module_t mod, int event, void *data)
 
 	switch (event) {
 	case MOD_LOAD:
-		MALLOC(p, struct accept_filter *, sizeof(*p), M_ACCF,
+		p = malloc(sizeof(*p), M_ACCF,
 		    M_WAITOK);
 		bcopy(accfp, p, sizeof(*p));
 		error = accept_filt_add(p);
@@ -169,7 +169,7 @@ do_getopt_accept_filter(struct socket *so, struct sockopt *sopt)
 	int error;
 
 	error = 0;
-	MALLOC(afap, struct accept_filter_arg *, sizeof(*afap), M_TEMP,
+	afap = malloc(sizeof(*afap), M_TEMP,
 	    M_WAITOK | M_ZERO);
 	SOCK_LOCK(so);
 	if ((so->so_options & SO_ACCEPTCONN) == 0) {
@@ -187,7 +187,7 @@ out:
 	SOCK_UNLOCK(so);
 	if (error == 0)
 		error = sooptcopyout(sopt, afap, sizeof(*afap));
-	FREE(afap, M_TEMP);
+	free(afap, M_TEMP);
 	return (error);
 }
 
@@ -215,8 +215,8 @@ do_setopt_accept_filter(struct socket *so, struct sockopt *sopt)
 				af->so_accept_filter->accf_destroy(so);
 			}
 			if (af->so_accept_filter_str != NULL)
-				FREE(af->so_accept_filter_str, M_ACCF);
-			FREE(af, M_ACCF);
+				free(af->so_accept_filter_str, M_ACCF);
+			free(af, M_ACCF);
 			so->so_accf = NULL;
 		}
 		so->so_options &= ~SO_ACCEPTFILTER;
@@ -228,18 +228,18 @@ do_setopt_accept_filter(struct socket *so, struct sockopt *sopt)
 	 * Pre-allocate any memory we may need later to avoid blocking at
 	 * untimely moments.  This does not optimize for invalid arguments.
 	 */
-	MALLOC(afap, struct accept_filter_arg *, sizeof(*afap), M_TEMP,
+	afap = malloc(sizeof(*afap), M_TEMP,
 	    M_WAITOK);
 	error = sooptcopyin(sopt, afap, sizeof *afap, sizeof *afap);
 	afap->af_name[sizeof(afap->af_name)-1] = '\0';
 	afap->af_arg[sizeof(afap->af_arg)-1] = '\0';
 	if (error) {
-		FREE(afap, M_TEMP);
+		free(afap, M_TEMP);
 		return (error);
 	}
 	afp = accept_filt_get(afap->af_name);
 	if (afp == NULL) {
-		FREE(afap, M_TEMP);
+		free(afap, M_TEMP);
 		return (ENOENT);
 	}
 	/*
@@ -248,11 +248,11 @@ do_setopt_accept_filter(struct socket *so, struct sockopt *sopt)
 	 * attached properly, 'newaf' is NULLed to avoid a free()
 	 * while in use.
 	 */
-	MALLOC(newaf, struct so_accf *, sizeof(*newaf), M_ACCF, M_WAITOK |
+	newaf = malloc(sizeof(*newaf), M_ACCF, M_WAITOK |
 	    M_ZERO);
 	if (afp->accf_create != NULL && afap->af_name[0] != '\0') {
 		int len = strlen(afap->af_name) + 1;
-		MALLOC(newaf->so_accept_filter_str, char *, len, M_ACCF,
+		newaf->so_accept_filter_str = malloc(len, M_ACCF,
 		    M_WAITOK);
 		strcpy(newaf->so_accept_filter_str, afap->af_name);
 	}
@@ -289,10 +289,10 @@ out:
 	SOCK_UNLOCK(so);
 	if (newaf != NULL) {
 		if (newaf->so_accept_filter_str != NULL)
-			FREE(newaf->so_accept_filter_str, M_ACCF);
-		FREE(newaf, M_ACCF);
+			free(newaf->so_accept_filter_str, M_ACCF);
+		free(newaf, M_ACCF);
 	}
 	if (afap != NULL)
-		FREE(afap, M_TEMP);
+		free(afap, M_TEMP);
 	return (error);
 }
diff --git a/sys/kern/uipc_mqueue.c b/sys/kern/uipc_mqueue.c
index aa362cb8a3ca..123f6529b6f2 100644
--- a/sys/kern/uipc_mqueue.c
+++ b/sys/kern/uipc_mqueue.c
@@ -1545,7 +1545,7 @@ mqueue_free(struct mqueue *mq)
 
 	while ((msg = TAILQ_FIRST(&mq->mq_msgq)) != NULL) {
 		TAILQ_REMOVE(&mq->mq_msgq, msg, msg_link);
-		FREE(msg, M_MQUEUEDATA);
+		free(msg, M_MQUEUEDATA);
 	}
 
 	mtx_destroy(&mq->mq_mutex);
@@ -1566,11 +1566,11 @@ mqueue_loadmsg(const char *msg_ptr, size_t msg_size, int msg_prio)
 	int error;
 
 	len = sizeof(struct mqueue_msg) + msg_size;
-	MALLOC(msg, struct mqueue_msg *, len, M_MQUEUEDATA, M_WAITOK);
+	msg = malloc(len, M_MQUEUEDATA, M_WAITOK);
 	error = copyin(msg_ptr, ((char *)msg) + sizeof(struct mqueue_msg),
 	    msg_size);
 	if (error) {
-		FREE(msg, M_MQUEUEDATA);
+		free(msg, M_MQUEUEDATA);
 		msg = NULL;
 	} else {
 		msg->msg_size = msg_size;
@@ -1600,7 +1600,7 @@ mqueue_savemsg(struct mqueue_msg *msg, char *msg_ptr, int *msg_prio)
 static __inline void
 mqueue_freemsg(struct mqueue_msg *msg)
 {
-	FREE(msg, M_MQUEUEDATA);
+	free(msg, M_MQUEUEDATA);
 }
 
 /*
diff --git a/sys/kern/uipc_syscalls.c b/sys/kern/uipc_syscalls.c
index 994605b6eea0..2233e6540e39 100644
--- a/sys/kern/uipc_syscalls.c
+++ b/sys/kern/uipc_syscalls.c
@@ -457,7 +457,7 @@ kern_accept(struct thread *td, int s, struct sockaddr **name,
 	}
 noconnection:
 	if (sa)
-		FREE(sa, M_SONAME);
+		free(sa, M_SONAME);
 
 	/*
 	 * close the new descriptor, assuming someone hasn't ripped it
@@ -720,7 +720,7 @@ sendit(td, s, mp, flags)
 
 bad:
 	if (to)
-		FREE(to, M_SONAME);
+		free(to, M_SONAME);
 	return (error);
 }
 
@@ -1068,7 +1068,7 @@ out:
 		ktrsockaddr(fromsa);
 #endif
 	if (fromsa)
-		FREE(fromsa, M_SONAME);
+		free(fromsa, M_SONAME);
 
 	if (error == 0 && controlp != NULL)  
 		*controlp = control;
@@ -1661,10 +1661,10 @@ getsockaddr(namp, uaddr, len)
 		return (ENAMETOOLONG);
 	if (len < offsetof(struct sockaddr, sa_data[0]))
 		return (EINVAL);
-	MALLOC(sa, struct sockaddr *, len, M_SONAME, M_WAITOK);
+	sa = malloc(len, M_SONAME, M_WAITOK);
 	error = copyin(uaddr, sa, len);
 	if (error) {
-		FREE(sa, M_SONAME);
+		free(sa, M_SONAME);
 	} else {
 #if defined(COMPAT_OLDSOCK) && BYTE_ORDER != BIG_ENDIAN
 		if (sa->sa_family == 0 && sa->sa_len < AF_MAX)
diff --git a/sys/kern/uipc_usrreq.c b/sys/kern/uipc_usrreq.c
index 7ecd7ca7bb12..2e27bd4994bf 100644
--- a/sys/kern/uipc_usrreq.c
+++ b/sys/kern/uipc_usrreq.c
@@ -600,7 +600,7 @@ uipc_detach(struct socket *so)
 	unp->unp_refcount--;
 	freeunp = (unp->unp_refcount == 0);
 	if (saved_unp_addr != NULL)
-		FREE(saved_unp_addr, M_SONAME);
+		free(saved_unp_addr, M_SONAME);
 	if (freeunp) {
 		UNP_PCB_LOCK_DESTROY(unp);
 		uma_zfree(unp_zone, unp);
diff --git a/sys/kern/vfs_export.c b/sys/kern/vfs_export.c
index 439e84f748ad..775ed26686c9 100644
--- a/sys/kern/vfs_export.c
+++ b/sys/kern/vfs_export.c
@@ -330,7 +330,7 @@ vfs_setpublicfs(struct mount *mp, struct netexport *nep,
 		if (nfs_pub.np_valid) {
 			nfs_pub.np_valid = 0;
 			if (nfs_pub.np_index != NULL) {
-				FREE(nfs_pub.np_index, M_TEMP);
+				free(nfs_pub.np_index, M_TEMP);
 				nfs_pub.np_index = NULL;
 			}
 		}
@@ -361,7 +361,7 @@ vfs_setpublicfs(struct mount *mp, struct netexport *nep,
 	 * If an indexfile was specified, pull it in.
 	 */
 	if (argp->ex_indexfile != NULL) {
-		MALLOC(nfs_pub.np_index, char *, MAXNAMLEN + 1, M_TEMP,
+		nfs_pub.np_index = malloc(MAXNAMLEN + 1, M_TEMP,
 		    M_WAITOK);
 		error = copyinstr(argp->ex_indexfile, nfs_pub.np_index,
 		    MAXNAMLEN, (size_t *)0);
@@ -377,7 +377,7 @@ vfs_setpublicfs(struct mount *mp, struct netexport *nep,
 			}
 		}
 		if (error) {
-			FREE(nfs_pub.np_index, M_TEMP);
+			free(nfs_pub.np_index, M_TEMP);
 			return (error);
 		}
 	}
diff --git a/sys/kern/vfs_syscalls.c b/sys/kern/vfs_syscalls.c
index 94c9422cf61c..22c880ad5d63 100644
--- a/sys/kern/vfs_syscalls.c
+++ b/sys/kern/vfs_syscalls.c
@@ -3928,7 +3928,7 @@ unionread:
 		kuio.uio_iov = &kiov;
 		kuio.uio_segflg = UIO_SYSSPACE;
 		kiov.iov_len = uap->count;
-		MALLOC(dirbuf, caddr_t, uap->count, M_TEMP, M_WAITOK);
+		dirbuf = malloc(uap->count, M_TEMP, M_WAITOK);
 		kiov.iov_base = dirbuf;
 		error = VOP_READDIR(vp, &kuio, fp->f_cred, &eofflag,
 			    NULL, NULL);
@@ -3965,7 +3965,7 @@ unionread:
 			if (dp >= edp)
 				error = uiomove(dirbuf, readcnt, &auio);
 		}
-		FREE(dirbuf, M_TEMP);
+		free(dirbuf, M_TEMP);
 	}
 	if (error) {
 		VOP_UNLOCK(vp, 0);