Back out M_* changes, per decision of the TRB.

Approved by: trb

63 files changed, 306 insertions, 306 deletions

diff --git a/sys/kern/imgact_aout.c b/sys/kern/imgact_aout.c
index a11c17d..e96054a 100644
--- a/sys/kern/imgact_aout.c
+++ b/sys/kern/imgact_aout.c
@@ -276,7 +276,7 @@ aout_coredump(td, vp, limit)
 	    + vm->vm_dsize + vm->vm_ssize) >= limit)
 		return (EFAULT);
 	tempuser = malloc(ctob(uarea_pages + kstack_pages), M_TEMP,
-	    M_ZERO);
+	    M_WAITOK | M_ZERO);
 	if (tempuser == NULL)
 		return (ENOMEM);
 	PROC_LOCK(p);
diff --git a/sys/kern/imgact_elf.c b/sys/kern/imgact_elf.c
index e0d49d4..f6b0cb2 100644
--- a/sys/kern/imgact_elf.c
+++ b/sys/kern/imgact_elf.c
@@ -516,7 +516,7 @@ __elfN(load_file)(struct proc *p, const char *file, u_long *addr,
 	if (curthread->td_proc != p)
 		panic("elf_load_file - thread");	/* XXXKSE DIAGNOSTIC */
 
-	tempdata = malloc(sizeof(*tempdata), M_TEMP, 0);
+	tempdata = malloc(sizeof(*tempdata), M_TEMP, M_WAITOK);
 	nd = &tempdata->nd;
 	attr = &tempdata->attr;
 	imgp = &tempdata->image_params;
@@ -812,7 +812,7 @@ __CONCAT(exec_, __elfN(imgact))(struct image_params *imgp)
 
 	imgp->proc->p_sysent = sv;
 	if (interp != NULL) {
-		path = malloc(MAXPATHLEN, M_TEMP, 0);
+		path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 		snprintf(path, MAXPATHLEN, "%s%s", brand_info->emul_path,
 		    interp);
 		if ((error = __elfN(load_file)(imgp->proc, path, &addr,
@@ -831,7 +831,7 @@ __CONCAT(exec_, __elfN(imgact))(struct image_params *imgp)
 	/*
 	 * Construct auxargs table (used by the fixup routine)
 	 */
-	elf_auxargs = malloc(sizeof(Elf_Auxargs), M_TEMP, 0);
+	elf_auxargs = malloc(sizeof(Elf_Auxargs), M_TEMP, M_WAITOK);
 	elf_auxargs->execfd = -1;
 	elf_auxargs->phdr = proghdr;
 	elf_auxargs->phent = hdr->e_phentsize;
@@ -951,7 +951,7 @@ __elfN(coredump)(td, vp, limit)
 	 * Allocate memory for building the header, fill it up,
 	 * and write it out.
 	 */
-	hdr = malloc(hdrsize, M_TEMP, 0);
+	hdr = malloc(hdrsize, M_TEMP, M_WAITOK);
 	if (hdr == NULL) {
 		return (EINVAL);
 	}
@@ -1113,7 +1113,7 @@ __elfN(corehdr)(td, vp, cred, numsegs, hdr, hdrsize)
 	prfpregset_t *fpregset;
 	prpsinfo_t *psinfo;
 
-	tempdata = malloc(sizeof(*tempdata), M_TEMP, M_ZERO | 0);
+	tempdata = malloc(sizeof(*tempdata), M_TEMP, M_ZERO | M_WAITOK);
 	status = &tempdata->status;
 	fpregset = &tempdata->fpregset;
 	psinfo = &tempdata->psinfo;
diff --git a/sys/kern/inflate.c b/sys/kern/inflate.c
index e814294..2a16ba2 100644
--- a/sys/kern/inflate.c
+++ b/sys/kern/inflate.c
@@ -551,7 +551,7 @@ huft_build(glbl, b, n, s, d, e, t, m)
 				l[h] = j;	/* set table size in stack */
 
 				/* allocate and link in new table */
-				if ((q = (struct huft *) malloc((z + 1) * sizeof(struct huft), M_GZIP, 0)) ==
+				if ((q = (struct huft *) malloc((z + 1) * sizeof(struct huft), M_GZIP, M_WAITOK)) ==
 				    (struct huft *) NULL) {
 					if (h)
 						huft_free(glbl, u[0]);
@@ -1049,7 +1049,7 @@ inflate(glbl)
 	u_char		*p = NULL;
 
 	if (!glbl->gz_slide)
-		p = glbl->gz_slide = malloc(GZ_WSIZE, M_GZIP, 0);
+		p = glbl->gz_slide = malloc(GZ_WSIZE, M_GZIP, M_WAITOK);
 #endif
 	if (!glbl->gz_slide)
 #ifdef _KERNEL
diff --git a/sys/kern/kern_alq.c b/sys/kern/kern_alq.c
index 7e86b55..7ddacc8 100644
--- a/sys/kern/kern_alq.c
+++ b/sys/kern/kern_alq.c
@@ -352,9 +352,9 @@ alq_open(struct alq **alqp, const char *file, int size, int count)
 	/* We just unlock so we hold a reference */
 	VOP_UNLOCK(nd.ni_vp, 0, td);
 
-	alq = malloc(sizeof(*alq), M_ALD, M_ZERO);
-	alq->aq_entbuf = malloc(count * size, M_ALD, M_ZERO);
-	alq->aq_first = malloc(sizeof(*ale) * count, M_ALD, M_ZERO);
+	alq = malloc(sizeof(*alq), M_ALD, M_WAITOK|M_ZERO);
+	alq->aq_entbuf = malloc(count * size, M_ALD, M_WAITOK|M_ZERO);
+	alq->aq_first = malloc(sizeof(*ale) * count, M_ALD, M_WAITOK|M_ZERO);
 	alq->aq_vp = nd.ni_vp;
 	alq->aq_cred = crhold(td->td_ucred);
 	alq->aq_entmax = count;
diff --git a/sys/kern/kern_descrip.c b/sys/kern/kern_descrip.c
index 342673e..97298d59 100644
--- a/sys/kern/kern_descrip.c
+++ b/sys/kern/kern_descrip.c
@@ -697,7 +697,7 @@ fsetown(pgid, sigiop)
 	ret = 0;
 
 	/* Allocate and fill in the new sigio out of locks. */
-	MALLOC(sigio, struct sigio *, sizeof(struct sigio), M_SIGIO, 0);
+	MALLOC(sigio, struct sigio *, sizeof(struct sigio), M_SIGIO, M_WAITOK);
 	sigio->sio_pgid = pgid;
 	sigio->sio_ucred = crhold(curthread->td_ucred);
 	sigio->sio_myref = sigiop;
@@ -1082,7 +1082,7 @@ fdalloc(td, want, result)
 		 * than KMEM_ZMAX bytes. uma_large_malloc() requires Giant.
 		 */
 		mtx_lock(&Giant);
-		newofile = malloc(nfiles * OFILESIZE, M_FILEDESC, 0);
+		newofile = malloc(nfiles * OFILESIZE, M_FILEDESC, M_WAITOK);
 		mtx_unlock(&Giant);
 
 		/*
@@ -1173,7 +1173,7 @@ falloc(td, resultfp, resultfd)
 	struct file *fp, *fq;
 	int error, i;
 
-	fp = uma_zalloc(file_zone, M_ZERO);
+	fp = uma_zalloc(file_zone, M_WAITOK | M_ZERO);
 	sx_xlock(&filelist_lock);
 	if (nfiles >= maxfiles) {
 		sx_xunlock(&filelist_lock);
@@ -1243,7 +1243,7 @@ fdinit(fdp)
 	struct filedesc0 *newfdp;
 
 	MALLOC(newfdp, struct filedesc0 *, sizeof(struct filedesc0),
-	    M_FILEDESC, M_ZERO);
+	    M_FILEDESC, M_WAITOK | M_ZERO);
 	mtx_init(&newfdp->fd_fd.fd_mtx, FILEDESC_LOCK_DESC, NULL, MTX_DEF);
 	newfdp->fd_fd.fd_cdir = fdp->fd_cdir;
 	if (newfdp->fd_fd.fd_cdir)
@@ -1299,7 +1299,7 @@ fdcopy(fdp)
 
 	FILEDESC_UNLOCK(fdp);
 	MALLOC(newfdp, struct filedesc *, sizeof(struct filedesc0),
-	    M_FILEDESC, 0);
+	    M_FILEDESC, M_WAITOK);
 	FILEDESC_LOCK(fdp);
 	bcopy(fdp, newfdp, sizeof(struct filedesc));
 	FILEDESC_UNLOCK(fdp);
@@ -1339,7 +1339,7 @@ retry:
 			i /= 2;
 		FILEDESC_UNLOCK(fdp);
 		MALLOC(newfdp->fd_ofiles, struct file **, i * OFILESIZE,
-		    M_FILEDESC, 0);
+		    M_FILEDESC, M_WAITOK);
 		FILEDESC_LOCK(fdp);
 		newfdp->fd_lastfile = fdp->fd_lastfile;
 		newfdp->fd_nfiles = fdp->fd_nfiles;
diff --git a/sys/kern/kern_environment.c b/sys/kern/kern_environment.c
index 70ba635..98f5fc6 100644
--- a/sys/kern/kern_environment.c
+++ b/sys/kern/kern_environment.c
@@ -131,7 +131,7 @@ kenv(td, uap)
 			return (error);
 	}
 
-	name = malloc(KENV_MNAMELEN, M_TEMP, 0);
+	name = malloc(KENV_MNAMELEN, M_TEMP, M_WAITOK);
 
 	error = copyinstr(uap->name, name, KENV_MNAMELEN, NULL);
 	if (error)
@@ -166,7 +166,7 @@ kenv(td, uap)
 		}
 		if (len > KENV_MVALLEN)
 			len = KENV_MVALLEN;
-		value = malloc(len, M_TEMP, 0);
+		value = malloc(len, M_TEMP, M_WAITOK);
 		error = copyinstr(uap->value, value, len, NULL);
 		if (error) {
 			free(value, M_TEMP);
@@ -207,11 +207,11 @@ init_dynamic_kenv(void *data __unused)
 	char *cp;
 	int len, i;
 
-	kenvp = malloc(KENV_SIZE * sizeof(char *), M_KENV, M_ZERO);
+	kenvp = malloc(KENV_SIZE * sizeof(char *), M_KENV, M_WAITOK | M_ZERO);
 	i = 0;
 	for (cp = kern_envp; cp != NULL; cp = kernenv_next(cp)) {
 		len = strlen(cp) + 1;
-		kenvp[i] = malloc(len, M_KENV, 0);
+		kenvp[i] = malloc(len, M_KENV, M_WAITOK);
 		strcpy(kenvp[i++], cp);
 	}
 	kenvp[i] = NULL;
@@ -290,7 +290,7 @@ getenv(const char *name)
 			strcpy(buf, cp);
 			sx_sunlock(&kenv_lock);
 			len = strlen(buf) + 1;
-			ret = malloc(len, M_KENV, 0);
+			ret = malloc(len, M_KENV, M_WAITOK);
 			strcpy(ret, buf);
 		} else {
 			sx_sunlock(&kenv_lock);
@@ -337,7 +337,7 @@ setenv(const char *name, const char *value)
 	vallen = strlen(value) + 1;
 	if (vallen > KENV_MVALLEN)
 		return (-1);
-	buf = malloc(namelen + vallen, M_KENV, 0);
+	buf = malloc(namelen + vallen, M_KENV, M_WAITOK);
 	sprintf(buf, "%s=%s", name, value);
 
 	sx_xlock(&kenv_lock);
diff --git a/sys/kern/kern_event.c b/sys/kern/kern_event.c
index 4910b7e..8c552d1 100644
--- a/sys/kern/kern_event.c
+++ b/sys/kern/kern_event.c
@@ -330,7 +330,7 @@ filt_timerattach(struct knote *kn)
 
 	kn->kn_flags |= EV_CLEAR;		/* automatically set */
 	MALLOC(calloutp, struct callout *, sizeof(*calloutp),
-	    M_KQUEUE, 0);
+	    M_KQUEUE, M_WAITOK);
 	callout_init(calloutp, 0);
 	callout_reset(calloutp, tticks, filt_timerexpire, kn);
 	kn->kn_hook = calloutp;
@@ -372,7 +372,7 @@ kqueue(struct thread *td, struct kqueue_args *uap)
 	error = falloc(td, &fp, &fd);
 	if (error)
 		goto done2;
-	kq = malloc(sizeof(struct kqueue), M_KQUEUE, M_ZERO);
+	kq = malloc(sizeof(struct kqueue), M_KQUEUE, M_WAITOK | M_ZERO);
 	TAILQ_INIT(&kq->kq_head);
 	FILE_LOCK(fp);
 	fp->f_flag = FREAD | FWRITE;
@@ -980,7 +980,7 @@ knote_attach(struct knote *kn, struct filedesc *fdp)
 			size += KQEXTENT;
 		FILEDESC_UNLOCK(fdp);
 		MALLOC(list, struct klist *,
-		    size * sizeof(struct klist *), M_KQUEUE, 0);
+		    size * sizeof(struct klist *), M_KQUEUE, M_WAITOK);
 		FILEDESC_LOCK(fdp);
 		if (fdp->fd_knlistsize > kn->kn_id) {
 			FREE(list, M_KQUEUE);
@@ -1074,7 +1074,7 @@ SYSINIT(knote, SI_SUB_PSEUDO, SI_ORDER_ANY, knote_init, NULL)
 static struct knote *
 knote_alloc(void)
 {
-	return ((struct knote *)uma_zalloc(knote_zone, 0));
+	return ((struct knote *)uma_zalloc(knote_zone, M_WAITOK));
 }
 
 static void
diff --git a/sys/kern/kern_exec.c b/sys/kern/kern_exec.c
index b6d77d2..f239ab7 100644
--- a/sys/kern/kern_exec.c
+++ b/sys/kern/kern_exec.c
@@ -425,7 +425,7 @@ interpret:
 		oldprocsig = p->p_procsig;
 		PROC_UNLOCK(p);
 		MALLOC(newprocsig, struct procsig *, sizeof(struct procsig),
-		    M_SUBPROC, 0);
+		    M_SUBPROC, M_WAITOK);
 		bcopy(oldprocsig, newprocsig, sizeof(*newprocsig));
 		newprocsig->ps_refcnt = 1;
 		oldprocsig->ps_refcnt--;
@@ -1171,7 +1171,7 @@ exec_register(execsw_arg)
 	if (execsw)
 		for (es = execsw; *es; es++)
 			count++;
-	newexecsw = malloc(count * sizeof(*es), M_TEMP, 0);
+	newexecsw = malloc(count * sizeof(*es), M_TEMP, M_WAITOK);
 	if (newexecsw == NULL)
 		return (ENOMEM);
 	xs = newexecsw;
@@ -1205,7 +1205,7 @@ exec_unregister(execsw_arg)
 	for (es = execsw; *es; es++)
 		if (*es != execsw_arg)
 			count++;
-	newexecsw = malloc(count * sizeof(*es), M_TEMP, 0);
+	newexecsw = malloc(count * sizeof(*es), M_TEMP, M_WAITOK);
 	if (newexecsw == NULL)
 		return (ENOMEM);
 	xs = newexecsw;
diff --git a/sys/kern/kern_exit.c b/sys/kern/kern_exit.c
index abf9025..2e0e709 100644
--- a/sys/kern/kern_exit.c
+++ b/sys/kern/kern_exit.c
@@ -228,7 +228,7 @@ exit1(td, rv)
 
 
 	MALLOC(p->p_ru, struct rusage *, sizeof(struct rusage),
-		M_ZOMBIE, 0);
+		M_ZOMBIE, M_WAITOK);
 	/*
 	 * If parent is waiting for us to exit or exec,
 	 * P_PPWAIT is set; we will wakeup the parent below.
diff --git a/sys/kern/kern_fork.c b/sys/kern/kern_fork.c
index 6089c92..5c36a24 100644
--- a/sys/kern/kern_fork.c
+++ b/sys/kern/kern_fork.c
@@ -313,7 +313,7 @@ fork1(td, flags, pages, procp)
 	}
 
 	/* Allocate new proc. */
-	newproc = uma_zalloc(proc_zone, 0);
+	newproc = uma_zalloc(proc_zone, M_WAITOK);
 #ifdef MAC
 	mac_init_proc(newproc);
 #endif
@@ -438,12 +438,12 @@ again:
 	 */
 	if (flags & RFSIGSHARE) {
 		MALLOC(newsigacts, struct sigacts *,
-		    sizeof(struct sigacts), M_SUBPROC, 0);
+		    sizeof(struct sigacts), M_SUBPROC, M_WAITOK);
 		newprocsig = NULL;
 	} else {
 		newsigacts = NULL;
 		MALLOC(newprocsig, struct procsig *, sizeof(struct procsig),
-		    M_SUBPROC, 0);
+		    M_SUBPROC, M_WAITOK);
 	}
 
 	/*
diff --git a/sys/kern/kern_intr.c b/sys/kern/kern_intr.c
index 5330868..a0a7e0d 100644
--- a/sys/kern/kern_intr.c
+++ b/sys/kern/kern_intr.c
@@ -177,7 +177,7 @@ ithread_create(struct ithd **ithread, int vector, int flags,
 	if ((flags & ~IT_SOFT) != 0)
 		return (EINVAL);
 
-	ithd = malloc(sizeof(struct ithd), M_ITHREAD, M_ZERO);
+	ithd = malloc(sizeof(struct ithd), M_ITHREAD, M_WAITOK | M_ZERO);
 	ithd->it_vector = vector;
 	ithd->it_disable = disable;
 	ithd->it_enable = enable;
@@ -249,7 +249,7 @@ ithread_add_handler(struct ithd* ithread, const char *name,
 	if ((flags & INTR_FAST) !=0)
 		flags |= INTR_EXCL;
 
-	ih = malloc(sizeof(struct intrhand), M_ITHREAD, M_ZERO);
+	ih = malloc(sizeof(struct intrhand), M_ITHREAD, M_WAITOK | M_ZERO);
 	ih->ih_handler = handler;
 	ih->ih_argument = arg;
 	ih->ih_name = name;
diff --git a/sys/kern/kern_jail.c b/sys/kern/kern_jail.c
index f367d4f..15f4b36 100644
--- a/sys/kern/kern_jail.c
+++ b/sys/kern/kern_jail.c
@@ -72,7 +72,7 @@ jail(td, uap)
 	if (j.version != 0)
 		return (EINVAL);
 
-	MALLOC(pr, struct prison *, sizeof *pr , M_PRISON, M_ZERO);
+	MALLOC(pr, struct prison *, sizeof *pr , M_PRISON, M_WAITOK | M_ZERO);
 	mtx_init(&pr->pr_mtx, "jail mutex", NULL, MTX_DEF);
 	pr->pr_securelevel = securelevel;
 	error = copyinstr(j.hostname, &pr->pr_host, sizeof pr->pr_host, 0);
diff --git a/sys/kern/kern_kse.c b/sys/kern/kern_kse.c
index b3017d0..55b0f24 100644
--- a/sys/kern/kern_kse.c
+++ b/sys/kern/kern_kse.c
@@ -899,7 +899,7 @@ thread_reap(void)
 struct ksegrp *
 ksegrp_alloc(void)
 {
-	return (uma_zalloc(ksegrp_zone, 0));
+	return (uma_zalloc(ksegrp_zone, M_WAITOK));
 }
 
 /*
@@ -908,7 +908,7 @@ ksegrp_alloc(void)
 struct kse *
 kse_alloc(void)
 {
-	return (uma_zalloc(kse_zone, 0));
+	return (uma_zalloc(kse_zone, M_WAITOK));
 }
 
 /*
@@ -918,7 +918,7 @@ struct thread *
 thread_alloc(void)
 {
 	thread_reap(); /* check if any zombies to get */
-	return (uma_zalloc(thread_zone, 0));
+	return (uma_zalloc(thread_zone, M_WAITOK));
 }
 
 /*
diff --git a/sys/kern/kern_ktrace.c b/sys/kern/kern_ktrace.c
index 23f6f7b..bb4642c 100644
--- a/sys/kern/kern_ktrace.c
+++ b/sys/kern/kern_ktrace.c
@@ -131,7 +131,7 @@ ktrace_init(void *dummy)
 	STAILQ_INIT(&ktr_todo);
 	STAILQ_INIT(&ktr_free);
 	for (i = 0; i < ktr_requestpool; i++) {
-		req = malloc(sizeof(struct ktr_request), M_KTRACE, 0);
+		req = malloc(sizeof(struct ktr_request), M_KTRACE, M_WAITOK);
 		STAILQ_INSERT_HEAD(&ktr_free, req, ktr_list);
 	}
 	kthread_create(ktr_loop, NULL, NULL, RFHIGHPID, 0, "ktrace");
@@ -199,7 +199,7 @@ ktrace_resize_pool(uint newsize)
 		while (ktr_requestpool < newsize) {
 			mtx_unlock(&ktrace_mtx);
 			req = malloc(sizeof(struct ktr_request), M_KTRACE,
-			    0);
+			    M_WAITOK);
 			mtx_lock(&ktrace_mtx);
 			STAILQ_INSERT_HEAD(&ktr_free, req, ktr_list);
 			ktr_requestpool++;
@@ -321,7 +321,7 @@ ktrsyscall(code, narg, args)
 
 	buflen = sizeof(register_t) * narg;
 	if (buflen > 0) {
-		buf = malloc(buflen, M_KTRACE, 0);
+		buf = malloc(buflen, M_KTRACE, M_WAITOK);
 		bcopy(args, buf, buflen);
 	}
 	req = ktr_getrequest(KTR_SYSCALL);
@@ -371,7 +371,7 @@ ktrnamei(path)
 
 	namelen = strlen(path);
 	if (namelen > 0) {
-		buf = malloc(namelen, M_KTRACE, 0);
+		buf = malloc(namelen, M_KTRACE, M_WAITOK);
 		bcopy(path, buf, namelen);
 	}
 	req = ktr_getrequest(KTR_NAMEI);
@@ -413,7 +413,7 @@ ktrgenio(fd, rw, uio, error)
 	uio->uio_offset = 0;
 	uio->uio_rw = UIO_WRITE;
 	datalen = imin(uio->uio_resid, ktr_geniosize);
-	buf = malloc(datalen, M_KTRACE, 0);
+	buf = malloc(datalen, M_KTRACE, M_WAITOK);
 	if (uiomove(buf, datalen, uio)) {
 		free(buf, M_KTRACE);
 		return;
@@ -625,7 +625,7 @@ utrace(td, uap)
 		return (0);
 	if (uap->len > KTR_USER_MAXLEN)
 		return (EINVAL);
-	cp = malloc(uap->len, M_KTRACE, 0);
+	cp = malloc(uap->len, M_KTRACE, M_WAITOK);
 	error = copyin(uap->addr, cp, uap->len);
 	if (error) {
 		free(cp, M_KTRACE);
diff --git a/sys/kern/kern_linker.c b/sys/kern/kern_linker.c
index fcecdd9..3c38bac 100644
--- a/sys/kern/kern_linker.c
+++ b/sys/kern/kern_linker.c
@@ -110,7 +110,7 @@ linker_strdup(const char *str)
 {
 	char *result;
 
-	if ((result = malloc((strlen(str) + 1), M_LINKER, 0)) != NULL)
+	if ((result = malloc((strlen(str) + 1), M_LINKER, M_WAITOK)) != NULL)
 		strcpy(result, str);
 	return (result);
 }
@@ -402,7 +402,7 @@ linker_find_file_by_name(const char *filename)
 	linker_file_t lf = 0;
 	char *koname;
 
-	koname = malloc(strlen(filename) + 4, M_LINKER, 0);
+	koname = malloc(strlen(filename) + 4, M_LINKER, M_WAITOK);
 	if (koname == NULL)
 		goto out;
 	sprintf(koname, "%s.ko", filename);
@@ -444,7 +444,7 @@ linker_make_file(const char *pathname, linker_class_t lc)
 	filename = linker_basename(pathname);
 
 	KLD_DPF(FILE, ("linker_make_file: new file, filename=%s\n", filename));
-	lf = (linker_file_t)kobj_create((kobj_class_t)lc, M_LINKER, 0);
+	lf = (linker_file_t)kobj_create((kobj_class_t)lc, M_LINKER, M_WAITOK);
 	if (lf == NULL)
 		goto out;
 	lf->refs = 1;
@@ -558,7 +558,7 @@ linker_file_add_dependency(linker_file_t file, linker_file_t dep)
 	linker_file_t *newdeps;
 
 	newdeps = malloc((file->ndeps + 1) * sizeof(linker_file_t *),
-	    M_LINKER, M_ZERO);
+	    M_LINKER, M_WAITOK | M_ZERO);
 	if (newdeps == NULL)
 		return (ENOMEM);
 
@@ -644,7 +644,7 @@ linker_file_lookup_symbol(linker_file_t file, const char *name, int deps)
 		common_size = (common_size + sizeof(int) - 1) & -sizeof(int);
 		cp = malloc(sizeof(struct common_symbol)
 		    + common_size + strlen(name) + 1, M_LINKER,
-		    M_ZERO);
+		    M_WAITOK | M_ZERO);
 		if (cp == NULL) {
 			KLD_DPF(SYM, ("linker_file_lookup_symbol: nomem\n"));
 			return (0);
@@ -753,7 +753,7 @@ kldload(struct thread *td, struct kldload_args *uap)
 	if ((error = suser(td)) != 0)
 		goto out;
 
-	pathname = malloc(MAXPATHLEN, M_TEMP, 0);
+	pathname = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 	if ((error = copyinstr(uap->file, pathname, MAXPATHLEN, NULL)) != 0)
 		goto out;
 
@@ -839,7 +839,7 @@ kldfind(struct thread *td, struct kldfind_args *uap)
 	mtx_lock(&Giant);
 	td->td_retval[0] = -1;
 
-	pathname = malloc(MAXPATHLEN, M_TEMP, 0);
+	pathname = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 	if ((error = copyinstr(uap->file, pathname, MAXPATHLEN, NULL)) != 0)
 		goto out;
 
@@ -1011,7 +1011,7 @@ kldsym(struct thread *td, struct kldsym_args *uap)
 		error = EINVAL;
 		goto out;
 	}
-	symstr = malloc(MAXPATHLEN, M_TEMP, 0);
+	symstr = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 	if ((error = copyinstr(lookup.symname, symstr, MAXPATHLEN, NULL)) != 0)
 		goto out;
 	if (uap->fileid != 0) {
@@ -1381,7 +1381,7 @@ linker_lookup_file(const char *path, int pathlen, const char *name,
 	sep = (path[pathlen - 1] != '/') ? "/" : "";
 
 	reclen = pathlen + strlen(sep) + namelen + extlen + 1;
-	result = malloc(reclen, M_LINKER, 0);
+	result = malloc(reclen, M_LINKER, M_WAITOK);
 	for (cpp = linker_ext_list; *cpp; cpp++) {
 		snprintf(result, reclen, "%.*s%s%.*s%s", pathlen, path, sep,
 		    namelen, name, *cpp);
@@ -1433,7 +1433,7 @@ linker_hints_lookup(const char *path, int pathlen, const char *modname,
 	sep = (path[pathlen - 1] != '/') ? "/" : "";
 	reclen = imax(modnamelen, strlen(linker_hintfile)) + pathlen +
 	    strlen(sep) + 1;
-	pathbuf = malloc(reclen, M_LINKER, 0);
+	pathbuf = malloc(reclen, M_LINKER, M_WAITOK);
 	snprintf(pathbuf, reclen, "%.*s%s%s", pathlen, path, sep,
 	    linker_hintfile);
 
@@ -1456,7 +1456,7 @@ linker_hints_lookup(const char *path, int pathlen, const char *modname,
 		printf("hints file too large %ld\n", (long)vattr.va_size);
 		goto bad;
 	}
-	hints = malloc(vattr.va_size, M_TEMP, 0);
+	hints = malloc(vattr.va_size, M_TEMP, M_WAITOK);
 	if (hints == NULL)
 		goto bad;
 	error = vn_rdwr(UIO_READ, nd.ni_vp, (caddr_t)hints, vattr.va_size, 0,
diff --git a/sys/kern/kern_lockf.c b/sys/kern/kern_lockf.c
index b5d4204..cb1fad4 100644
--- a/sys/kern/kern_lockf.c
+++ b/sys/kern/kern_lockf.c
@@ -160,7 +160,7 @@ lf_advlock(ap, head, size)
 	/*
 	 * Create the lockf structure
 	 */
-	MALLOC(lock, struct lockf *, sizeof *lock, M_LOCKF, 0);
+	MALLOC(lock, struct lockf *, sizeof *lock, M_LOCKF, M_WAITOK);
 	lock->lf_start = start;
 	lock->lf_end = end;
 	lock->lf_id = ap->a_id;
@@ -726,7 +726,7 @@ lf_split(lock1, lock2)
 	 * Make a new lock consisting of the last part of
 	 * the encompassing lock
 	 */
-	MALLOC(splitlock, struct lockf *, sizeof *splitlock, M_LOCKF, 0);
+	MALLOC(splitlock, struct lockf *, sizeof *splitlock, M_LOCKF, M_WAITOK);
 	bcopy(lock1, splitlock, sizeof *splitlock);
 	splitlock->lf_start = lock2->lf_end + 1;
 	TAILQ_INIT(&splitlock->lf_blkhd);
diff --git a/sys/kern/kern_mac.c b/sys/kern/kern_mac.c
index b4df06f..e9d9eeb 100644
--- a/sys/kern/kern_mac.c
+++ b/sys/kern/kern_mac.c
@@ -758,7 +758,7 @@ mac_init_pipe(struct pipe *pipe)
 {
 	struct label *label;
 
-	label = malloc(sizeof(struct label), M_MACPIPELABEL, M_ZERO);
+	label = malloc(sizeof(struct label), M_MACPIPELABEL, M_ZERO|M_WAITOK);
 	pipe->pipe_label = label;
 	pipe->pipe_peer->pipe_label = label;
 	mac_init_pipe_label(label);
@@ -1323,7 +1323,7 @@ mac_execve_enter(struct image_params *imgp, struct mac *mac_p,
 	if (error)
 		return (error);
 
-	buffer = malloc(mac.m_buflen, M_MACTEMP, 0);
+	buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac.m_string, buffer, mac.m_buflen, NULL);
 	if (error) {
 		free(buffer, M_MACTEMP);
@@ -2727,16 +2727,16 @@ mac_ioctl_ifnet_get(struct ucred *cred, struct ifreq *ifr,
 	if (error)
 		return (error);
 
-	elements = malloc(mac.m_buflen, M_MACTEMP, 0);
+	elements = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac.m_string, elements, mac.m_buflen, NULL);
 	if (error) {
 		free(elements, M_MACTEMP);
 		return (error);
 	}
 
-	buffer = malloc(mac.m_buflen, M_MACTEMP, M_ZERO);
+	buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK | M_ZERO);
 	error = mac_externalize_ifnet_label(&ifnet->if_label, elements,
-	    buffer, mac.m_buflen, 0);
+	    buffer, mac.m_buflen, M_WAITOK);
 	if (error == 0)
 		error = copyout(buffer, mac.m_string, strlen(buffer)+1);
 
@@ -2763,7 +2763,7 @@ mac_ioctl_ifnet_set(struct ucred *cred, struct ifreq *ifr,
 	if (error)
 		return (error);
 
-	buffer = malloc(mac.m_buflen, M_MACTEMP, 0);
+	buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac.m_string, buffer, mac.m_buflen, NULL);
 	if (error) {
 		free(buffer, M_MACTEMP);
@@ -2839,14 +2839,14 @@ mac_setsockopt_label_set(struct ucred *cred, struct socket *so,
 	if (error)
 		return (error);
 
-	buffer = malloc(mac->m_buflen, M_MACTEMP, 0);
+	buffer = malloc(mac->m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac->m_string, buffer, mac->m_buflen, NULL);
 	if (error) {
 		free(buffer, M_MACTEMP);
 		return (error);
 	}
 
-	mac_init_socket_label(&intlabel, 0);
+	mac_init_socket_label(&intlabel, M_WAITOK);
 	error = mac_internalize_socket_label(&intlabel, buffer);
 	free(buffer, M_MACTEMP);
 	if (error) {
@@ -2893,16 +2893,16 @@ mac_getsockopt_label_get(struct ucred *cred, struct socket *so,
 	if (error)
 		return (error);
 
-	elements = malloc(mac->m_buflen, M_MACTEMP, 0);
+	elements = malloc(mac->m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac->m_string, elements, mac->m_buflen, NULL);
 	if (error) {
 		free(elements, M_MACTEMP);
 		return (error);
 	}
 
-	buffer = malloc(mac->m_buflen, M_MACTEMP, M_ZERO);
+	buffer = malloc(mac->m_buflen, M_MACTEMP, M_WAITOK | M_ZERO);
 	error = mac_externalize_socket_label(&so->so_label, elements,
-	    buffer, mac->m_buflen, 0);
+	    buffer, mac->m_buflen, M_WAITOK);
 	if (error == 0)
 		error = copyout(buffer, mac->m_string, strlen(buffer)+1);
 
@@ -2923,16 +2923,16 @@ mac_getsockopt_peerlabel_get(struct ucred *cred, struct socket *so,
 	if (error)
 		return (error);
 
-	elements = malloc(mac->m_buflen, M_MACTEMP, 0);
+	elements = malloc(mac->m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac->m_string, elements, mac->m_buflen, NULL);
 	if (error) {
 		free(elements, M_MACTEMP);
 		return (error);
 	}
 
-	buffer = malloc(mac->m_buflen, M_MACTEMP, M_ZERO);
+	buffer = malloc(mac->m_buflen, M_MACTEMP, M_WAITOK | M_ZERO);
 	error = mac_externalize_socket_peer_label(&so->so_peerlabel,
-	    elements, buffer, mac->m_buflen, 0);
+	    elements, buffer, mac->m_buflen, M_WAITOK);
 	if (error == 0)
 		error = copyout(buffer, mac->m_string, strlen(buffer)+1);
 
@@ -3040,7 +3040,7 @@ __mac_get_pid(struct thread *td, struct __mac_get_pid_args *uap)
 	if (error)
 		return (error);
 
-	elements = malloc(mac.m_buflen, M_MACTEMP, 0);
+	elements = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac.m_string, elements, mac.m_buflen, NULL);
 	if (error) {
 		free(elements, M_MACTEMP);
@@ -3048,9 +3048,9 @@ __mac_get_pid(struct thread *td, struct __mac_get_pid_args *uap)
 		return (error);
 	}
 
-	buffer = malloc(mac.m_buflen, M_MACTEMP, M_ZERO);
+	buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK | M_ZERO);
 	error = mac_externalize_cred_label(&tcred->cr_label, elements,
-	    buffer, mac.m_buflen, 0);
+	    buffer, mac.m_buflen, M_WAITOK);
 	if (error == 0)
 		error = copyout(buffer, mac.m_string, strlen(buffer)+1);
 
@@ -3078,16 +3078,16 @@ __mac_get_proc(struct thread *td, struct __mac_get_proc_args *uap)
 	if (error)
 		return (error);
 
-	elements = malloc(mac.m_buflen, M_MACTEMP, 0);
+	elements = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac.m_string, elements, mac.m_buflen, NULL);
 	if (error) {
 		free(elements, M_MACTEMP);
 		return (error);
 	}
 
-	buffer = malloc(mac.m_buflen, M_MACTEMP, M_ZERO);
+	buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK | M_ZERO);
 	error = mac_externalize_cred_label(&td->td_ucred->cr_label,
-	    elements, buffer, mac.m_buflen, 0);
+	    elements, buffer, mac.m_buflen, M_WAITOK);
 	if (error == 0)
 		error = copyout(buffer, mac.m_string, strlen(buffer)+1);
 
@@ -3117,7 +3117,7 @@ __mac_set_proc(struct thread *td, struct __mac_set_proc_args *uap)
 	if (error)
 		return (error);
 
-	buffer = malloc(mac.m_buflen, M_MACTEMP, 0);
+	buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac.m_string, buffer, mac.m_buflen, NULL);
 	if (error) {
 		free(buffer, M_MACTEMP);
@@ -3194,14 +3194,14 @@ __mac_get_fd(struct thread *td, struct __mac_get_fd_args *uap)
 	if (error)
 		return (error);
 
-	elements = malloc(mac.m_buflen, M_MACTEMP, 0);
+	elements = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac.m_string, elements, mac.m_buflen, NULL);
 	if (error) {
 		free(elements, M_MACTEMP);
 		return (error);
 	}
 
-	buffer = malloc(mac.m_buflen, M_MACTEMP, M_ZERO);
+	buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK | M_ZERO);
 	mtx_lock(&Giant);				/* VFS */
 	error = fget(td, uap->fd, &fp);
 	if (error)
@@ -3241,12 +3241,12 @@ __mac_get_fd(struct thread *td, struct __mac_get_fd_args *uap)
 	case DTYPE_VNODE:
 		if (error == 0)
 			error = mac_externalize_vnode_label(&intlabel,
-			    elements, buffer, mac.m_buflen, 0);
+			    elements, buffer, mac.m_buflen, M_WAITOK);
 		mac_destroy_vnode_label(&intlabel);
 		break;
 	case DTYPE_PIPE:
 		error = mac_externalize_pipe_label(&intlabel, elements,
-		    buffer, mac.m_buflen, 0);
+		    buffer, mac.m_buflen, M_WAITOK);
 		mac_destroy_pipe_label(&intlabel);
 		break;
 	default:
@@ -3284,14 +3284,14 @@ __mac_get_file(struct thread *td, struct __mac_get_file_args *uap)
 	if (error)
 		return (error);
 
-	elements = malloc(mac.m_buflen, M_MACTEMP, 0);
+	elements = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac.m_string, elements, mac.m_buflen, NULL);
 	if (error) {
 		free(elements, M_MACTEMP);
 		return (error);
 	}
 
-	buffer = malloc(mac.m_buflen, M_MACTEMP, M_ZERO);
+	buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK | M_ZERO);
 	mtx_lock(&Giant);				/* VFS */
 	NDINIT(&nd, LOOKUP, LOCKLEAF | FOLLOW, UIO_USERSPACE, uap->path_p,
 	    td);
@@ -3302,7 +3302,7 @@ __mac_get_file(struct thread *td, struct __mac_get_file_args *uap)
 	mac_init_vnode_label(&intlabel);
 	mac_copy_vnode_label(&nd.ni_vp->v_label, &intlabel);
 	error = mac_externalize_vnode_label(&intlabel, elements, buffer,
-	    mac.m_buflen, 0);
+	    mac.m_buflen, M_WAITOK);
 
 	NDFREE(&nd, 0);
 	mac_destroy_vnode_label(&intlabel);
@@ -3339,14 +3339,14 @@ __mac_get_link(struct thread *td, struct __mac_get_link_args *uap)
 	if (error)
 		return (error);
 
-	elements = malloc(mac.m_buflen, M_MACTEMP, 0);
+	elements = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac.m_string, elements, mac.m_buflen, NULL);
 	if (error) {
 		free(elements, M_MACTEMP);
 		return (error);
 	}
 
-	buffer = malloc(mac.m_buflen, M_MACTEMP, M_ZERO);
+	buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK | M_ZERO);
 	mtx_lock(&Giant);				/* VFS */
 	NDINIT(&nd, LOOKUP, LOCKLEAF | NOFOLLOW, UIO_USERSPACE, uap->path_p,
 	    td);
@@ -3357,7 +3357,7 @@ __mac_get_link(struct thread *td, struct __mac_get_link_args *uap)
 	mac_init_vnode_label(&intlabel);
 	mac_copy_vnode_label(&nd.ni_vp->v_label, &intlabel);
 	error = mac_externalize_vnode_label(&intlabel, elements, buffer,
-	    mac.m_buflen, 0);
+	    mac.m_buflen, M_WAITOK);
 	NDFREE(&nd, 0);
 	mac_destroy_vnode_label(&intlabel);
 
@@ -3396,7 +3396,7 @@ __mac_set_fd(struct thread *td, struct __mac_set_fd_args *uap)
 	if (error)
 		return (error);
 
-	buffer = malloc(mac.m_buflen, M_MACTEMP, 0);
+	buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac.m_string, buffer, mac.m_buflen, NULL);
 	if (error) {
 		free(buffer, M_MACTEMP);
@@ -3482,7 +3482,7 @@ __mac_set_file(struct thread *td, struct __mac_set_file_args *uap)
 	if (error)
 		return (error);
 
-	buffer = malloc(mac.m_buflen, M_MACTEMP, 0);
+	buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac.m_string, buffer, mac.m_buflen, NULL);
 	if (error) {
 		free(buffer, M_MACTEMP);
@@ -3538,7 +3538,7 @@ __mac_set_link(struct thread *td, struct __mac_set_link_args *uap)
 	if (error)
 		return (error);
 
-	buffer = malloc(mac.m_buflen, M_MACTEMP, 0);
+	buffer = malloc(mac.m_buflen, M_MACTEMP, M_WAITOK);
 	error = copyinstr(mac.m_string, buffer, mac.m_buflen, NULL);
 	if (error) {
 		free(buffer, M_MACTEMP);
diff --git a/sys/kern/kern_malloc.c b/sys/kern/kern_malloc.c
index 33d23f1..c182120 100644
--- a/sys/kern/kern_malloc.c
+++ b/sys/kern/kern_malloc.c
@@ -173,7 +173,7 @@ malloc(size, type, flags)
 #endif
 	if (!(flags & M_NOWAIT))
 		KASSERT(curthread->td_intr_nesting_level == 0,
-		   ("malloc() without M_NOWAIT in interrupt context"));
+		   ("malloc(M_WAITOK) in interrupt context"));
 	if (size <= KMEM_ZMAX) {
 		if (size & KMEM_ZMASK)
 			size = (size & ~KMEM_ZMASK) + KMEM_ZBASE;
@@ -206,7 +206,7 @@ out:
 
 	mtx_unlock(&ksp->ks_mtx);
 	if (!(flags & M_NOWAIT))
-		KASSERT(va != NULL, ("malloc() without M_NOWAIT returned NULL"));
+		KASSERT(va != NULL, ("malloc(M_WAITOK) returned NULL"));
 	if (va == NULL) {
 		t_malloc_fail = time_uptime;
 	}
@@ -501,7 +501,7 @@ sysctl_kern_malloc(SYSCTL_HANDLER_ARGS)
 
 	mtx_unlock(&malloc_mtx);
 	bufsize = linesize * (cnt + 1);
-	p = buf = (char *)malloc(bufsize, M_TEMP, M_ZERO);
+	p = buf = (char *)malloc(bufsize, M_TEMP, M_WAITOK|M_ZERO);
 	mtx_lock(&malloc_mtx);
 
 	len = snprintf(p, linesize,
@@ -581,7 +581,7 @@ sysctl_kern_mprof(SYSCTL_HANDLER_ARGS)
 	waste = 0;
 	mem = 0;
 
-	p = buf = (char *)malloc(bufsize, M_TEMP, M_ZERO);
+	p = buf = (char *)malloc(bufsize, M_TEMP, M_WAITOK|M_ZERO);
 	len = snprintf(p, bufsize,
 	    "\n  Size                    Requests  Real Size\n");
 	bufsize -= len;
diff --git a/sys/kern/kern_module.c b/sys/kern/kern_module.c
index 84ad1c6..677d9f1 100644
--- a/sys/kern/kern_module.c
+++ b/sys/kern/kern_module.c
@@ -132,7 +132,7 @@ module_register(const moduledata_t *data, linker_file_t container)
 	}
 	MOD_SUNLOCK;
 	namelen = strlen(data->name) + 1;
-	newmod = malloc(sizeof(struct module) + namelen, M_MODULE, 0);
+	newmod = malloc(sizeof(struct module) + namelen, M_MODULE, M_WAITOK);
 	if (newmod == NULL)
 		return (ENOMEM);
 	MOD_XLOCK;
diff --git a/sys/kern/kern_proc.c b/sys/kern/kern_proc.c
index 73062c2..00f6186 100644
--- a/sys/kern/kern_proc.c
+++ b/sys/kern/kern_proc.c
@@ -975,7 +975,7 @@ pargs_alloc(int len)
 	struct pargs *pa;
 
 	MALLOC(pa, struct pargs *, sizeof(struct pargs) + len, M_PARGS,
-		0);
+		M_WAITOK);
 	pa->ar_ref = 1;
 	pa->ar_length = len;
 	return (pa);
diff --git a/sys/kern/kern_prot.c b/sys/kern/kern_prot.c
index e89f342..0279137 100644
--- a/sys/kern/kern_prot.c
+++ b/sys/kern/kern_prot.c
@@ -336,8 +336,8 @@ setsid(register struct thread *td, struct setsid_args *uap)
 	error = 0;
 	pgrp = NULL;
 
-	MALLOC(newpgrp, struct pgrp *, sizeof(struct pgrp), M_PGRP, M_ZERO);
-	MALLOC(newsess, struct session *, sizeof(struct session), M_SESSION, M_ZERO);
+	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);
 
 	sx_xlock(&proctree_lock);
 
@@ -399,7 +399,7 @@ setpgid(struct thread *td, register struct setpgid_args *uap)
 
 	error = 0;
 
-	MALLOC(newpgrp, struct pgrp *, sizeof(struct pgrp), M_PGRP, M_ZERO);
+	MALLOC(newpgrp, struct pgrp *, sizeof(struct pgrp), M_PGRP, M_WAITOK | M_ZERO);
 
 	sx_xlock(&proctree_lock);
 	if (uap->pid != 0 && uap->pid != curp->p_pid) {
@@ -1678,7 +1678,7 @@ crget(void)
 {
 	register struct ucred *cr;
 
-	MALLOC(cr, struct ucred *, sizeof(*cr), M_CRED, M_ZERO);
+	MALLOC(cr, struct ucred *, sizeof(*cr), M_CRED, M_WAITOK | M_ZERO);
 	cr->cr_ref = 1;
 	cr->cr_mtxp = mtx_pool_find(cr);
 #ifdef MAC
diff --git a/sys/kern/kern_resource.c b/sys/kern/kern_resource.c
index d0892e1..5b3920c 100644
--- a/sys/kern/kern_resource.c
+++ b/sys/kern/kern_resource.c
@@ -826,7 +826,7 @@ limcopy(lim)
 	register struct plimit *copy;
 
 	MALLOC(copy, struct plimit *, sizeof(struct plimit),
-	    M_SUBPROC, 0);
+	    M_SUBPROC, M_WAITOK);
 	bcopy(lim->pl_rlimit, copy->pl_rlimit, sizeof(struct plimit));
 	copy->p_lflags = 0;
 	copy->p_refcnt = 1;
@@ -883,7 +883,7 @@ uifind(uid)
 		struct  uidinfo *old_uip;
 
 		mtx_unlock(&uihashtbl_mtx);
-		uip = malloc(sizeof(*uip), M_UIDINFO, M_ZERO);
+		uip = malloc(sizeof(*uip), M_UIDINFO, M_WAITOK | M_ZERO);
 		mtx_lock(&uihashtbl_mtx);
 		/*
 		 * There's a chance someone created our uidinfo while we
diff --git a/sys/kern/kern_subr.c b/sys/kern/kern_subr.c
index dca389f..154b6e03 100644
--- a/sys/kern/kern_subr.c
+++ b/sys/kern/kern_subr.c
@@ -490,7 +490,7 @@ hashinit(elements, type, hashmask)
 	for (hashsize = 1; hashsize <= elements; hashsize <<= 1)
 		continue;
 	hashsize >>= 1;
-	hashtbl = malloc((u_long)hashsize * sizeof(*hashtbl), type, 0);
+	hashtbl = malloc((u_long)hashsize * sizeof(*hashtbl), type, M_WAITOK);
 	for (i = 0; i < hashsize; i++)
 		LIST_INIT(&hashtbl[i]);
 	*hashmask = hashsize - 1;
@@ -539,7 +539,7 @@ phashinit(elements, type, nentries)
 		hashsize = primes[i];
 	}
 	hashsize = primes[i - 1];
-	hashtbl = malloc((u_long)hashsize * sizeof(*hashtbl), type, 0);
+	hashtbl = malloc((u_long)hashsize * sizeof(*hashtbl), type, M_WAITOK);
 	for (i = 0; i < hashsize; i++)
 		LIST_INIT(&hashtbl[i]);
 	*nentries = hashsize;
diff --git a/sys/kern/kern_sysctl.c b/sys/kern/kern_sysctl.c
index 0a0d94c..08d1f80 100644
--- a/sys/kern/kern_sysctl.c
+++ b/sys/kern/kern_sysctl.c
@@ -224,7 +224,7 @@ sysctl_ctx_entry_add(struct sysctl_ctx_list *clist, struct sysctl_oid *oidp)
 
 	if (clist == NULL || oidp == NULL)
 		return(NULL);
-	e = malloc(sizeof(struct sysctl_ctx_entry), M_SYSCTLOID, 0);
+	e = malloc(sizeof(struct sysctl_ctx_entry), M_SYSCTLOID, M_WAITOK);
 	e->entry = oidp;
 	TAILQ_INSERT_HEAD(clist, e, link);
 	return (e);
@@ -354,13 +354,13 @@ sysctl_add_oid(struct sysctl_ctx_list *clist, struct sysctl_oid_list *parent,
 			return (NULL);
 		}
 	}
-	oidp = malloc(sizeof(struct sysctl_oid), M_SYSCTLOID, M_ZERO);
+	oidp = malloc(sizeof(struct sysctl_oid), M_SYSCTLOID, M_WAITOK|M_ZERO);
 	oidp->oid_parent = parent;
 	SLIST_NEXT(oidp, oid_link) = NULL;
 	oidp->oid_number = number;
 	oidp->oid_refcnt = 1;
 	len = strlen(name);
-	newname = malloc(len + 1, M_SYSCTLOID, 0);
+	newname = malloc(len + 1, M_SYSCTLOID, M_WAITOK);
 	bcopy(name, newname, len + 1);
 	newname[len] = '\0';
 	oidp->oid_name = newname;
@@ -369,7 +369,7 @@ sysctl_add_oid(struct sysctl_ctx_list *clist, struct sysctl_oid_list *parent,
 	if ((kind & CTLTYPE) == CTLTYPE_NODE) {
 		/* Allocate space for children */
 		SYSCTL_CHILDREN(oidp) = malloc(sizeof(struct sysctl_oid_list),
-		    M_SYSCTLOID, 0);
+		    M_SYSCTLOID, M_WAITOK);
 		SLIST_INIT(SYSCTL_CHILDREN(oidp));
 	} else {
 		oidp->oid_arg1 = arg1;
@@ -378,7 +378,7 @@ sysctl_add_oid(struct sysctl_ctx_list *clist, struct sysctl_oid_list *parent,
 	oidp->oid_fmt = fmt;
 	if (descr) {
 		int len = strlen(descr) + 1;
-		oidp->descr = malloc(len, M_SYSCTLOID, 0);
+		oidp->descr = malloc(len, M_SYSCTLOID, M_WAITOK);
 		if (oidp->descr)
 			strcpy((char *)(uintptr_t)(const void *)oidp->descr, descr);
 	}
@@ -679,7 +679,7 @@ sysctl_sysctl_name2oid(SYSCTL_HANDLER_ARGS)
 	if (req->newlen >= MAXPATHLEN)	/* XXX arbitrary, undocumented */
 		return (ENAMETOOLONG);
 
-	p = malloc(req->newlen+1, M_SYSCTL, 0);
+	p = malloc(req->newlen+1, M_SYSCTL, M_WAITOK);
 
 	error = SYSCTL_IN(req, p, req->newlen);
 	if (error) {
@@ -823,7 +823,7 @@ sysctl_handle_string(SYSCTL_HANDLER_ARGS)
 	 */
 retry:
 	outlen = strlen((char *)arg1)+1;
-	tmparg = malloc(outlen, M_SYSCTLTMP, 0);
+	tmparg = malloc(outlen, M_SYSCTLTMP, M_WAITOK);
 
 	if (strlcpy(tmparg, (char *)arg1, outlen) >= outlen) {
 		free(tmparg, M_SYSCTLTMP);
@@ -867,7 +867,7 @@ sysctl_handle_opaque(SYSCTL_HANDLER_ARGS)
 		sysctl_wire_old_buffer(req, arg2);
 		error = SYSCTL_OUT(req, arg1, arg2);
 	} else {
-		tmparg = malloc(arg2, M_SYSCTLTMP, 0);
+		tmparg = malloc(arg2, M_SYSCTLTMP, M_WAITOK);
 		bcopy(arg1, tmparg, arg2);
 		error = SYSCTL_OUT(req, tmparg, arg2);
 		free(tmparg, M_SYSCTLTMP);
diff --git a/sys/kern/kern_thread.c b/sys/kern/kern_thread.c
index b3017d0..55b0f24 100644
--- a/sys/kern/kern_thread.c
+++ b/sys/kern/kern_thread.c
@@ -899,7 +899,7 @@ thread_reap(void)
 struct ksegrp *
 ksegrp_alloc(void)
 {
-	return (uma_zalloc(ksegrp_zone, 0));
+	return (uma_zalloc(ksegrp_zone, M_WAITOK));
 }
 
 /*
@@ -908,7 +908,7 @@ ksegrp_alloc(void)
 struct kse *
 kse_alloc(void)
 {
-	return (uma_zalloc(kse_zone, 0));
+	return (uma_zalloc(kse_zone, M_WAITOK));
 }
 
 /*
@@ -918,7 +918,7 @@ struct thread *
 thread_alloc(void)
 {
 	thread_reap(); /* check if any zombies to get */
-	return (uma_zalloc(thread_zone, 0));
+	return (uma_zalloc(thread_zone, M_WAITOK));
 }
 
 /*
diff --git a/sys/kern/link_elf.c b/sys/kern/link_elf.c
index 6c3e4d4..f15803f 100644
--- a/sys/kern/link_elf.c
+++ b/sys/kern/link_elf.c
@@ -235,7 +235,7 @@ link_elf_link_common_finish(linker_file_t lf)
 #ifdef DDB
     GDB_STATE(RT_ADD);
     ef->gdb.l_addr = lf->address;
-    newfilename = malloc(strlen(lf->filename) + 1, M_LINKER, 0);
+    newfilename = malloc(strlen(lf->filename) + 1, M_LINKER, M_WAITOK);
     strcpy(newfilename, lf->filename);
     ef->gdb.l_name = newfilename;
     ef->gdb.l_ld = ef->dynamic;
@@ -571,7 +571,7 @@ link_elf_load_file(linker_class_t cls, const char* filename,
     /*
      * Read the elf header from the file.
      */
-    firstpage = malloc(PAGE_SIZE, M_LINKER, 0);
+    firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK);
     if (firstpage == NULL) {
 	error = ENOMEM;
 	goto out;
@@ -702,7 +702,7 @@ link_elf_load_file(linker_class_t cls, const char* filename,
 	goto out;
     }
 #else
-    ef->address = malloc(mapsize, M_LINKER, 0);
+    ef->address = malloc(mapsize, M_LINKER, M_WAITOK);
     if (!ef->address) {
 	error = ENOMEM;
 	goto out;
@@ -773,7 +773,7 @@ link_elf_load_file(linker_class_t cls, const char* filename,
     nbytes = hdr->e_shnum * hdr->e_shentsize;
     if (nbytes == 0 || hdr->e_shoff == 0)
 	goto nosyms;
-    shdr = malloc(nbytes, M_LINKER, M_ZERO);
+    shdr = malloc(nbytes, M_LINKER, M_WAITOK | M_ZERO);
     if (shdr == NULL) {
 	error = ENOMEM;
 	goto out;
@@ -796,9 +796,9 @@ link_elf_load_file(linker_class_t cls, const char* filename,
 	goto nosyms;
 
     symcnt = shdr[symtabindex].sh_size;
-    ef->symbase = malloc(symcnt, M_LINKER, 0);
+    ef->symbase = malloc(symcnt, M_LINKER, M_WAITOK);
     strcnt = shdr[symstrindex].sh_size;
-    ef->strbase = malloc(strcnt, M_LINKER, 0);
+    ef->strbase = malloc(strcnt, M_LINKER, M_WAITOK);
 
     if (ef->symbase == NULL || ef->strbase == NULL) {
 	error = ENOMEM;
@@ -1124,7 +1124,7 @@ link_elf_lookup_set(linker_file_t lf, const char *name,
 	int len, error = 0, count;
 
 	len = strlen(name) + sizeof("__start_set_"); /* sizeof includes \0 */
-	setsym = malloc(len, M_LINKER, 0);
+	setsym = malloc(len, M_LINKER, M_WAITOK);
 	if (setsym == NULL)
 		return ENOMEM;
 
diff --git a/sys/kern/link_elf_obj.c b/sys/kern/link_elf_obj.c
index 6c3e4d4..f15803f 100644
--- a/sys/kern/link_elf_obj.c
+++ b/sys/kern/link_elf_obj.c
@@ -235,7 +235,7 @@ link_elf_link_common_finish(linker_file_t lf)
 #ifdef DDB
     GDB_STATE(RT_ADD);
     ef->gdb.l_addr = lf->address;
-    newfilename = malloc(strlen(lf->filename) + 1, M_LINKER, 0);
+    newfilename = malloc(strlen(lf->filename) + 1, M_LINKER, M_WAITOK);
     strcpy(newfilename, lf->filename);
     ef->gdb.l_name = newfilename;
     ef->gdb.l_ld = ef->dynamic;
@@ -571,7 +571,7 @@ link_elf_load_file(linker_class_t cls, const char* filename,
     /*
      * Read the elf header from the file.
      */
-    firstpage = malloc(PAGE_SIZE, M_LINKER, 0);
+    firstpage = malloc(PAGE_SIZE, M_LINKER, M_WAITOK);
     if (firstpage == NULL) {
 	error = ENOMEM;
 	goto out;
@@ -702,7 +702,7 @@ link_elf_load_file(linker_class_t cls, const char* filename,
 	goto out;
     }
 #else
-    ef->address = malloc(mapsize, M_LINKER, 0);
+    ef->address = malloc(mapsize, M_LINKER, M_WAITOK);
     if (!ef->address) {
 	error = ENOMEM;
 	goto out;
@@ -773,7 +773,7 @@ link_elf_load_file(linker_class_t cls, const char* filename,
     nbytes = hdr->e_shnum * hdr->e_shentsize;
     if (nbytes == 0 || hdr->e_shoff == 0)
 	goto nosyms;
-    shdr = malloc(nbytes, M_LINKER, M_ZERO);
+    shdr = malloc(nbytes, M_LINKER, M_WAITOK | M_ZERO);
     if (shdr == NULL) {
 	error = ENOMEM;
 	goto out;
@@ -796,9 +796,9 @@ link_elf_load_file(linker_class_t cls, const char* filename,
 	goto nosyms;
 
     symcnt = shdr[symtabindex].sh_size;
-    ef->symbase = malloc(symcnt, M_LINKER, 0);
+    ef->symbase = malloc(symcnt, M_LINKER, M_WAITOK);
     strcnt = shdr[symstrindex].sh_size;
-    ef->strbase = malloc(strcnt, M_LINKER, 0);
+    ef->strbase = malloc(strcnt, M_LINKER, M_WAITOK);
 
     if (ef->symbase == NULL || ef->strbase == NULL) {
 	error = ENOMEM;
@@ -1124,7 +1124,7 @@ link_elf_lookup_set(linker_file_t lf, const char *name,
 	int len, error = 0, count;
 
 	len = strlen(name) + sizeof("__start_set_"); /* sizeof includes \0 */
-	setsym = malloc(len, M_LINKER, 0);
+	setsym = malloc(len, M_LINKER, M_WAITOK);
 	if (setsym == NULL)
 		return ENOMEM;
 
diff --git a/sys/kern/subr_blist.c b/sys/kern/subr_blist.c
index 8acf5f5..a58e548 100644
--- a/sys/kern/subr_blist.c
+++ b/sys/kern/subr_blist.c
@@ -157,14 +157,14 @@ blist_create(daddr_t blocks)
 		skip = (skip + 1) * BLIST_META_RADIX;
 	}
 
-	bl = malloc(sizeof(struct blist), M_SWAP, M_ZERO);
+	bl = malloc(sizeof(struct blist), M_SWAP, M_WAITOK | M_ZERO);
 
 	bl->bl_blocks = blocks;
 	bl->bl_radix = radix;
 	bl->bl_skip = skip;
 	bl->bl_rootblks = 1 +
 	    blst_radix_init(NULL, bl->bl_radix, bl->bl_skip, blocks);
-	bl->bl_root = malloc(sizeof(blmeta_t) * bl->bl_rootblks, M_SWAP, 0);
+	bl->bl_root = malloc(sizeof(blmeta_t) * bl->bl_rootblks, M_SWAP, M_WAITOK);
 
 #if defined(BLIST_DEBUG)
 	printf(
diff --git a/sys/kern/subr_clist.c b/sys/kern/subr_clist.c
index e4da151..165f628 100644
--- a/sys/kern/subr_clist.c
+++ b/sys/kern/subr_clist.c
@@ -135,8 +135,8 @@ cblock_alloc_cblocks(number)
 		cbp = malloc(sizeof *cbp, M_TTYS, M_NOWAIT);
 		if (cbp == NULL) {
 			printf(
-"cblock_alloc_cblocks: M_NOWAIT malloc failed, trying blocking malloc\n");
-			cbp = malloc(sizeof *cbp, M_TTYS, 0);
+"cblock_alloc_cblocks: M_NOWAIT malloc failed, trying M_WAITOK\n");
+			cbp = malloc(sizeof *cbp, M_TTYS, M_WAITOK);
 		}
 		/*
 		 * Freed cblocks have zero quotes and garbage elsewhere.
diff --git a/sys/kern/subr_mbuf.c b/sys/kern/subr_mbuf.c
index 97944ec..0713b7b 100644
--- a/sys/kern/subr_mbuf.c
+++ b/sys/kern/subr_mbuf.c
@@ -478,7 +478,7 @@ mbuf_init(void *dummy)
 		pcpu_cnt = MB_GET_PCPU_LIST_NUM(&mb_list_mbuf, i);
 		MB_LOCK_CONT(pcpu_cnt);
 		for (j = 0; j < NMB_MBUF_INIT; j++) {
-			if (mb_pop_cont(&mb_list_mbuf, M_NOWAIT, pcpu_cnt)
+			if (mb_pop_cont(&mb_list_mbuf, M_DONTWAIT, pcpu_cnt)
 			    == NULL)
 				goto bad;
 		}
@@ -487,7 +487,7 @@ mbuf_init(void *dummy)
 		pcpu_cnt = MB_GET_PCPU_LIST_NUM(&mb_list_clust, i);
 		MB_LOCK_CONT(pcpu_cnt);
 		for (j = 0; j < NMB_CLUST_INIT; j++) {
-			if (mb_pop_cont(&mb_list_clust, M_NOWAIT, pcpu_cnt)
+			if (mb_pop_cont(&mb_list_clust, M_DONTWAIT, pcpu_cnt)
 			    == NULL)
 				goto bad;
 		}
@@ -528,15 +528,15 @@ mb_pop_cont(struct mb_lstmngr *mb_list, int how, struct mb_pcpu_list *cnt_lst)
 
 	bucket = malloc(sizeof(struct mb_bucket) +
 	    PAGE_SIZE / mb_list->ml_objsize * sizeof(void *), M_MBUF,
-	    how == 0 ? 0 : M_NOWAIT);
+	    how == M_TRYWAIT ? M_WAITOK : M_NOWAIT);
 	if (bucket == NULL)
 		return (NULL);
 
 	p = (caddr_t)kmem_malloc(mb_list->ml_map, PAGE_SIZE,
-	    how == 0 ? 0 : M_NOWAIT);
+	    how == M_TRYWAIT ? M_WAITOK : M_NOWAIT);
 	if (p == NULL) {
 		free(bucket, M_MBUF);
-		if (how == 0)
+		if (how == M_TRYWAIT)
 			mb_list->ml_mapfull = 1;
 		return (NULL);
 	}
@@ -563,7 +563,7 @@ mb_pop_cont(struct mb_lstmngr *mb_list, int how, struct mb_pcpu_list *cnt_lst)
  * The general case is very easy.  Complications only arise if our PCPU
  * container is empty.  Things get worse if the PCPU container is empty,
  * the general container is empty, and we've run out of address space
- * in our map; then we try to block if we're willing to wait.
+ * in our map; then we try to block if we're willing to (M_TRYWAIT).
  */
 static __inline
 void *
@@ -667,7 +667,7 @@ mb_alloc(struct mb_lstmngr *mb_list, int how, short type, short persist,
 				else
 					*pers_list=cnt_lst->mb_cont.mc_numowner;
 			} else {
-				if (how == 0) {
+				if (how == M_TRYWAIT) {
 					/*
 				 	 * Absolute worst-case scenario.
 					 * We block if we're willing to, but
@@ -701,7 +701,7 @@ mb_alloc(struct mb_lstmngr *mb_list, int how, short type, short persist,
 
 /*
  * This is the worst-case scenario called only if we're allocating with
- * 0.  We first drain all the protocols, then try to find an mbuf
+ * M_TRYWAIT.  We first drain all the protocols, then try to find an mbuf
  * by looking in every PCPU container.  If we're still unsuccesful, we
  * try the general container one last time and possibly block on our
  * starved cv.
@@ -1128,8 +1128,8 @@ _mgetm_internal(int how, short type, short persist, int cchnum)
  * Allocate and return a single (normal) mbuf.  NULL is returned on failure.
  *
  * Arguments:
- *  - how: 0 to try to block for kern.ipc.mbuf_wait number of ticks
- *    if really starved for memory.  M_NOWAIT to never block.
+ *  - how: M_TRYWAIT to try to block for kern.ipc.mbuf_wait number of ticks
+ *    if really starved for memory.  M_DONTWAIT to never block.
  *  - type: the type of the mbuf being allocated.
  */
 struct mbuf *
@@ -1156,8 +1156,8 @@ m_get(int how, short type)
  *  - m: existing chain to which to append new chain (optional).
  *  - len: total length of data to append, either in mbufs or clusters
  *    (we allocate whatever combination yields the best fit).
- *  - how: 0 to try to block for kern.ipc.mbuf_wait number of ticks
- *    if really starved for memory.  M_NOWAIT to never block.
+ *  - how: M_TRYWAIT to try to block for kern.ipc.mbuf_wait number of ticks
+ *    if really starved for memory.  M_DONTWAIT to never block.
  *  - type: the type of the mbuf being allocated.
  */
 struct mbuf *
@@ -1246,8 +1246,8 @@ failed:
  * Allocate and return a single M_PKTHDR mbuf.  NULL is returned on failure.
  *
  * Arguments:
- *  - how: 0 to try to block for kern.ipc.mbuf_wait number of ticks
- *    if really starved for memory.  M_NOWAIT to never block.
+ *  - how: M_TRYWAIT to try to block for kern.ipc.mbuf_wait number of ticks
+ *    if really starved for memory.  M_DONTWAIT to never block.
  *  - type: the type of the mbuf being allocated.
  */
 struct mbuf *
@@ -1273,8 +1273,8 @@ m_gethdr(int how, short type)
  * returned on failure.
  *
  * Arguments:
- *  - how: 0 to try to block for kern.ipc.mbuf_wait number of ticks
- *    if really starved for memory.  M_NOWAIT to never block.
+ *  - how: M_TRYWAIT to try to block for kern.ipc.mbuf_wait number of ticks
+ *    if really starved for memory.  M_DONTWAIT to never block.
  *  - type: the type of the mbuf being allocated.
  */
 struct mbuf *
@@ -1295,8 +1295,8 @@ m_get_clrd(int how, short type)
  * returned on failure.
  *
  * Arguments:
- *  - how: 0 to try to block for kern.ipc.mbuf_wait number of ticks
- *    if really starved for memory.  M_NOWAIT to never block.
+ *  - how: M_TRYWAIT to try to block for kern.ipc.mbuf_wait number of ticks
+ *    if really starved for memory.  M_DONTWAIT to never block.
  *  - type: the type of the mbuf being allocated.
  */
 struct mbuf *
@@ -1419,8 +1419,8 @@ m_freem(struct mbuf *mb)
  * NULL on failure. 
  *
  * Arguments:
- *  - how: 0 to try to block for kern.ipc.mbuf_wait number of ticks
- *    if really starved for memory.  M_NOWAIT to never block.
+ *  - how: M_TRYWAIT to try to block for kern.ipc.mbuf_wait number of ticks
+ *    if really starved for memory.  M_DONTWAIT to never block.
  *  - type: the type of the mbuf being allocated.
  *  - flags: any flags to pass to the mbuf being allocated; if this includes
  *    the M_PKTHDR bit, then the mbuf is configured as a M_PKTHDR mbuf.
@@ -1471,8 +1471,8 @@ m_getcl(int how, short type, int flags)
  *
  * Arguments:
  *  - mb: the existing mbuf to which to attach the allocated cluster.
- *  - how: 0 to try to block for kern.ipc.mbuf_wait number of ticks
- *    if really starved for memory.  M_NOWAIT to never block.
+ *  - how: M_TRYWAIT to try to block for kern.ipc.mbuf_wait number of ticks
+ *    if really starved for memory.  M_DONTWAIT to never block.
  */
 void
 m_clget(struct mbuf *mb, int how)
diff --git a/sys/kern/subr_mchain.c b/sys/kern/subr_mchain.c
index 2125004..ed231ba 100644
--- a/sys/kern/subr_mchain.c
+++ b/sys/kern/subr_mchain.c
@@ -58,7 +58,7 @@ mb_init(struct mbchain *mbp)
 {
 	struct mbuf *m;
 
-	m = m_gethdr(0, MT_DATA);
+	m = m_gethdr(M_TRYWAIT, MT_DATA);
 	if (m == NULL) 
 		return ENOBUFS;
 	m->m_len = 0;
@@ -115,7 +115,7 @@ mb_reserve(struct mbchain *mbp, int size)
 		panic("mb_reserve: size = %d\n", size);
 	m = mbp->mb_cur;
 	if (mbp->mb_mleft < size) {
-		mn = m_get(0, MT_DATA);
+		mn = m_get(M_TRYWAIT, MT_DATA);
 		if (mn == NULL)
 			return NULL;
 		mbp->mb_cur = m->m_next = mn;
@@ -192,7 +192,7 @@ mb_put_mem(struct mbchain *mbp, c_caddr_t source, int size, int type)
 	while (size > 0) {
 		if (mleft == 0) {
 			if (m->m_next == NULL) {
-				m = m_getm(m, size, 0, MT_DATA);
+				m = m_getm(m, size, M_TRYWAIT, MT_DATA);
 				if (m == NULL)
 					return ENOBUFS;
 			}
@@ -292,7 +292,7 @@ md_init(struct mdchain *mdp)
 {
 	struct mbuf *m;
 
-	m = m_gethdr(0, MT_DATA);
+	m = m_gethdr(M_TRYWAIT, MT_DATA);
 	if (m == NULL) 
 		return ENOBUFS;
 	m->m_len = 0;
@@ -500,7 +500,7 @@ md_get_mbuf(struct mdchain *mdp, int size, struct mbuf **ret)
 {
 	struct mbuf *m = mdp->md_cur, *rm;
 
-	rm = m_copym(m, mdp->md_pos - mtod(m, u_char*), size, 0);
+	rm = m_copym(m, mdp->md_pos - mtod(m, u_char*), size, M_TRYWAIT);
 	if (rm == NULL)
 		return EBADRPC;
 	md_get_mem(mdp, NULL, size, MB_MZERO);
diff --git a/sys/kern/subr_prf.c b/sys/kern/subr_prf.c
index abe059bf7..5a298ac 100644
--- a/sys/kern/subr_prf.c
+++ b/sys/kern/subr_prf.c
@@ -260,8 +260,8 @@ log_console(struct uio *uio)
 	pri = LOG_INFO | LOG_CONSOLE;
 	muio = *uio;
 	iovlen = uio->uio_iovcnt * sizeof (struct iovec);
-	MALLOC(miov, struct iovec *, iovlen, M_TEMP, 0);
-	MALLOC(consbuffer, char *, CONSCHUNK, M_TEMP, 0);
+	MALLOC(miov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
+	MALLOC(consbuffer, char *, CONSCHUNK, M_TEMP, M_WAITOK);
 	bcopy(muio.uio_iov, miov, iovlen);
 	muio.uio_iov = miov;
 	uio = &muio;
diff --git a/sys/kern/subr_prof.c b/sys/kern/subr_prof.c
index 894309d..cf4a6e9 100644
--- a/sys/kern/subr_prof.c
+++ b/sys/kern/subr_prof.c
@@ -107,7 +107,7 @@ kmupetext(uintfptr_t nhighpc)
 		np.tolimit = MAXARCS;
 	np.tossize = np.tolimit * sizeof(struct tostruct);
 	cp = malloc(np.kcountsize + np.fromssize + np.tossize,
-	    M_GPROF, 0);
+	    M_GPROF, M_WAITOK);
 	/*
 	 * Check for something else extending highpc while we slept.
 	 */
@@ -176,7 +176,7 @@ kmstartup(dummy)
 		p->tolimit = MAXARCS;
 	p->tossize = p->tolimit * sizeof(struct tostruct);
 	cp = (char *)malloc(p->kcountsize + p->fromssize + p->tossize,
-	    M_GPROF, M_ZERO);
+	    M_GPROF, M_WAITOK | M_ZERO);
 	p->tos = (struct tostruct *)cp;
 	cp += p->tossize;
 	p->kcount = (HISTCOUNTER *)cp;
diff --git a/sys/kern/subr_sbuf.c b/sys/kern/subr_sbuf.c
index f4ec519..9e63e8e 100644
--- a/sys/kern/subr_sbuf.c
+++ b/sys/kern/subr_sbuf.c
@@ -49,7 +49,7 @@
 
 #ifdef _KERNEL
 MALLOC_DEFINE(M_SBUF, "sbuf", "string buffers");
-#define	SBMALLOC(size)		malloc(size, M_SBUF, 0)
+#define	SBMALLOC(size)		malloc(size, M_SBUF, M_WAITOK)
 #define	SBFREE(buf)		free(buf, M_SBUF)
 #else /* _KERNEL */
 #define	KASSERT(e, m)
diff --git a/sys/kern/sys_generic.c b/sys/kern/sys_generic.c
index 9e3ccff..c26cf47 100644
--- a/sys/kern/sys_generic.c
+++ b/sys/kern/sys_generic.c
@@ -248,7 +248,7 @@ readv(td, uap)
 			error = EINVAL;
 			goto done;
 		}
-		MALLOC(iov, struct iovec *, iovlen, M_IOV, 0);
+		MALLOC(iov, struct iovec *, iovlen, M_IOV, M_WAITOK);
 		needfree = iov;
 	} else
 		iov = aiov;
@@ -274,7 +274,7 @@ readv(td, uap)
 	 * if tracing, save a copy of iovec
 	 */
 	if (KTRPOINT(td, KTR_GENIO))  {
-		MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, 0);
+		MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
 		bcopy(auio.uio_iov, ktriov, iovlen);
 		ktruio = auio;
 	}
@@ -480,7 +480,7 @@ writev(td, uap)
 			error = EINVAL;
 			goto done;
 		}
-		MALLOC(iov, struct iovec *, iovlen, M_IOV, 0);
+		MALLOC(iov, struct iovec *, iovlen, M_IOV, M_WAITOK);
 		needfree = iov;
 	} else {
 		iov = aiov;
@@ -508,7 +508,7 @@ writev(td, uap)
 	 * if tracing, save a copy of iovec and uio
 	 */
 	if (KTRPOINT(td, KTR_GENIO))  {
-		MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, 0);
+		MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
 		bcopy(auio.uio_iov, ktriov, iovlen);
 		ktruio = auio;
 	}
@@ -618,7 +618,7 @@ ioctl(td, uap)
 
 	memp = NULL;
 	if (size > sizeof (ubuf.stkbuf)) {
-		memp = malloc((u_long)size, M_IOCTLOPS, 0);
+		memp = malloc((u_long)size, M_IOCTLOPS, M_WAITOK);
 		data = memp;
 	} else {
 		data = ubuf.stkbuf;
@@ -768,7 +768,7 @@ kern_select(struct thread *td, int nd, fd_set *fd_in, fd_set *fd_ou,
 	if (nbufbytes <= sizeof s_selbits)
 		selbits = &s_selbits[0];
 	else
-		selbits = malloc(nbufbytes, M_SELECT, 0);
+		selbits = malloc(nbufbytes, M_SELECT, M_WAITOK);
 
 	/*
 	 * Assign pointers into the bit buffers and fetch the input bits.
@@ -968,7 +968,7 @@ poll(td, uap)
 	}
 	ni = nfds * sizeof(struct pollfd);
 	if (ni > sizeof(smallbits))
-		bits = malloc(ni, M_TEMP, 0);
+		bits = malloc(ni, M_TEMP, M_WAITOK);
 	else
 		bits = smallbits;
 	error = copyin(uap->fds, bits, ni);
diff --git a/sys/kern/sys_pipe.c b/sys/kern/sys_pipe.c
index 2612101..32c9384 100644
--- a/sys/kern/sys_pipe.c
+++ b/sys/kern/sys_pipe.c
@@ -206,7 +206,7 @@ pipe(td, uap)
 	
 	KASSERT(pipe_zone != NULL, ("pipe_zone not initialized"));
 
-	pmtx = malloc(sizeof(*pmtx), M_TEMP, M_ZERO);
+	pmtx = malloc(sizeof(*pmtx), M_TEMP, M_WAITOK | M_ZERO);
 	
 	rpipe = wpipe = NULL;
 	if (pipe_create(&rpipe) || pipe_create(&wpipe)) {
@@ -346,7 +346,7 @@ pipe_create(cpipep)
 	struct pipe *cpipe;
 	int error;
 
-	*cpipep = uma_zalloc(pipe_zone, 0);
+	*cpipep = uma_zalloc(pipe_zone, M_WAITOK);
 	if (*cpipep == NULL)
 		return (ENOMEM);
 
diff --git a/sys/kern/sysv_msg.c b/sys/kern/sysv_msg.c
index 08ca4b5..47e629c 100644
--- a/sys/kern/sysv_msg.c
+++ b/sys/kern/sysv_msg.c
@@ -141,16 +141,16 @@ msginit()
 	msginfo.msgmax = msginfo.msgseg * msginfo.msgssz;
 	TUNABLE_INT_FETCH("kern.ipc.msgmni", &msginfo.msgmni);
 
-	msgpool = malloc(msginfo.msgmax, M_MSG, 0);
+	msgpool = malloc(msginfo.msgmax, M_MSG, M_WAITOK);
 	if (msgpool == NULL)
 		panic("msgpool is NULL");
-	msgmaps = malloc(sizeof(struct msgmap) * msginfo.msgseg, M_MSG, 0);
+	msgmaps = malloc(sizeof(struct msgmap) * msginfo.msgseg, M_MSG, M_WAITOK);
 	if (msgmaps == NULL)
 		panic("msgmaps is NULL");
-	msghdrs = malloc(sizeof(struct msg) * msginfo.msgtql, M_MSG, 0);
+	msghdrs = malloc(sizeof(struct msg) * msginfo.msgtql, M_MSG, M_WAITOK);
 	if (msghdrs == NULL)
 		panic("msghdrs is NULL");
-	msqids = malloc(sizeof(struct msqid_ds) * msginfo.msgmni, M_MSG, 0);
+	msqids = malloc(sizeof(struct msqid_ds) * msginfo.msgmni, M_MSG, M_WAITOK);
 	if (msqids == NULL)
 		panic("msqids is NULL");
 
diff --git a/sys/kern/sysv_sem.c b/sys/kern/sysv_sem.c
index 0a7e58b..7eeb625 100644
--- a/sys/kern/sysv_sem.c
+++ b/sys/kern/sysv_sem.c
@@ -185,12 +185,12 @@ seminit(void)
 	TUNABLE_INT_FETCH("kern.ipc.semvmx", &seminfo.semvmx);
 	TUNABLE_INT_FETCH("kern.ipc.semaem", &seminfo.semaem);
 
-	sem = malloc(sizeof(struct sem) * seminfo.semmns, M_SEM, 0);
+	sem = malloc(sizeof(struct sem) * seminfo.semmns, M_SEM, M_WAITOK);
 	sema = malloc(sizeof(struct semid_ds) * seminfo.semmni, M_SEM,
-	    0);
+	    M_WAITOK);
 	sema_mtx = malloc(sizeof(struct mtx) * seminfo.semmni, M_SEM,
-	    M_ZERO);
-	semu = malloc(seminfo.semmnu * seminfo.semusz, M_SEM, 0);
+	    M_WAITOK | M_ZERO);
+	semu = malloc(seminfo.semmnu * seminfo.semusz, M_SEM, M_WAITOK);
 
 	for (i = 0; i < seminfo.semmni; i++) {
 		sema[i].sem_base = 0;
@@ -644,7 +644,7 @@ __semctl(td, uap)
 		if ((error = copyin(arg, &real_arg, sizeof(real_arg))) != 0)
 			goto done2;
 		array = malloc(sizeof(*array) * semaptr->sem_nsems, M_TEMP,
-		    0);
+		    M_WAITOK);
 		mtx_lock(sema_mtxp);
 		if ((error = semvalid(uap->semid, semaptr)) != 0)
 			goto done2;
@@ -702,7 +702,7 @@ raced:
 		mtx_unlock(sema_mtxp);
 		if ((error = copyin(arg, &real_arg, sizeof(real_arg))) != 0)
 			goto done2;
-		array = malloc(sizeof(*array) * count, M_TEMP, 0);
+		array = malloc(sizeof(*array) * count, M_TEMP, M_WAITOK);
 		copyin(real_arg.array, array, count * sizeof(*array));
 		if (error)
 			break;
@@ -898,7 +898,7 @@ semop(td, uap)
 		    nsops));
 		return (E2BIG);
 	}
-	sops = malloc(nsops * sizeof(sops[0]), M_SEM, 0);
+	sops = malloc(nsops * sizeof(sops[0]), M_SEM, M_WAITOK);
 	if ((error = copyin(uap->sops, sops, nsops * sizeof(sops[0]))) != 0) {
 		DPRINTF(("error = %d from copyin(%08x, %08x, %d)\n", error,
 		    uap->sops, sops, nsops * sizeof(sops[0])));
diff --git a/sys/kern/sysv_shm.c b/sys/kern/sysv_shm.c
index 97f9afb..d3fa323 100644
--- a/sys/kern/sysv_shm.c
+++ b/sys/kern/sysv_shm.c
@@ -314,7 +314,7 @@ shmat(td, uap)
 	shmmap_s = p->p_vmspace->vm_shm;
 	if (shmmap_s == NULL) {
 		size = shminfo.shmseg * sizeof(struct shmmap_state);
-		shmmap_s = malloc(size, M_SHM, 0);
+		shmmap_s = malloc(size, M_SHM, M_WAITOK);
 		for (i = 0; i < shminfo.shmseg; i++)
 			shmmap_s[i].shmid = -1;
 		p->p_vmspace->vm_shm = shmmap_s;
@@ -643,7 +643,7 @@ shmget_allocate_segment(td, uap, mode)
 	shmseg->shm_perm.key = uap->key;
 	shmseg->shm_perm.seq = (shmseg->shm_perm.seq + 1) & 0x7fff;
 	shm_handle = (struct shm_handle *)
-	    malloc(sizeof(struct shm_handle), M_SHM, 0);
+	    malloc(sizeof(struct shm_handle), M_SHM, M_WAITOK);
 	shmid = IXSEQ_TO_IPCID(segnum, shmseg->shm_perm);
 	
 	/*
@@ -756,7 +756,7 @@ shmfork_myhook(p1, p2)
 	int i;
 
 	size = shminfo.shmseg * sizeof(struct shmmap_state);
-	shmmap_s = malloc(size, M_SHM, 0);
+	shmmap_s = malloc(size, M_SHM, M_WAITOK);
 	bcopy(p1->p_vmspace->vm_shm, shmmap_s, size);
 	p2->p_vmspace->vm_shm = shmmap_s;
 	for (i = 0; i < shminfo.shmseg; i++, shmmap_s++)
@@ -791,7 +791,7 @@ shmrealloc(void)
 	if (shmalloced >= shminfo.shmmni)
 		return;
 
-	newsegs = malloc(shminfo.shmmni * sizeof(*newsegs), M_SHM, 0);
+	newsegs = malloc(shminfo.shmmni * sizeof(*newsegs), M_SHM, M_WAITOK);
 	if (newsegs == NULL)
 		return;
 	for (i = 0; i < shmalloced; i++)
@@ -822,7 +822,7 @@ shminit()
 	TUNABLE_INT_FETCH("kern.ipc.shm_use_phys", &shm_use_phys);
 
 	shmalloced = shminfo.shmmni;
-	shmsegs = malloc(shmalloced * sizeof(shmsegs[0]), M_SHM, 0);
+	shmsegs = malloc(shmalloced * sizeof(shmsegs[0]), M_SHM, M_WAITOK);
 	if (shmsegs == NULL)
 		panic("cannot allocate initial memory for sysvshm");
 	for (i = 0; i < shmalloced; i++) {
diff --git a/sys/kern/tty.c b/sys/kern/tty.c
index 2c4e554..6f8114e 100644
--- a/sys/kern/tty.c
+++ b/sys/kern/tty.c
@@ -2609,7 +2609,7 @@ ttymalloc(struct tty *tp)
 
 	if (tp)
 		return(tp);
-	tp = malloc(sizeof *tp, M_TTYS, M_ZERO);
+	tp = malloc(sizeof *tp, M_TTYS, M_WAITOK | M_ZERO);
 	ttyregister(tp);
 	return (tp);
 }
diff --git a/sys/kern/tty_cons.c b/sys/kern/tty_cons.c
index 9d487b7..361a5dd 100644
--- a/sys/kern/tty_cons.c
+++ b/sys/kern/tty_cons.c
@@ -277,7 +277,7 @@ sysctl_kern_console(SYSCTL_HANDLER_ARGS)
 	STAILQ_FOREACH(cnd, &cn_devlist, cnd_next)
 		len += strlen(devtoname(cnd->cnd_cn->cn_dev)) + 1;
 	len = len > CNDEVPATHMAX ? len : CNDEVPATHMAX;
-	MALLOC(name, char *, len, M_TEMP, M_ZERO);
+	MALLOC(name, char *, len, M_TEMP, M_WAITOK | M_ZERO);
 	p = name;
 	STAILQ_FOREACH(cnd, &cn_devlist, cnd_next)
 		p += sprintf(p, "%s,", devtoname(cnd->cnd_cn->cn_dev));
diff --git a/sys/kern/tty_pty.c b/sys/kern/tty_pty.c
index d954ac7..098108c 100644
--- a/sys/kern/tty_pty.c
+++ b/sys/kern/tty_pty.c
@@ -153,7 +153,7 @@ ptyinit(dev_t devc)
 
 	devc->si_flags &= ~SI_CHEAPCLONE;
 
-	pt = malloc(sizeof(*pt), M_PTY, M_ZERO);
+	pt = malloc(sizeof(*pt), M_PTY, M_WAITOK | M_ZERO);
 	pt->devs = devs = make_dev(&pts_cdevsw, n,
 	    UID_ROOT, GID_WHEEL, 0666, "tty%c%r", names[n / 32], n % 32);
 	pt->devc = devc;
diff --git a/sys/kern/tty_subr.c b/sys/kern/tty_subr.c
index e4da151..165f628 100644
--- a/sys/kern/tty_subr.c
+++ b/sys/kern/tty_subr.c
@@ -135,8 +135,8 @@ cblock_alloc_cblocks(number)
 		cbp = malloc(sizeof *cbp, M_TTYS, M_NOWAIT);
 		if (cbp == NULL) {
 			printf(
-"cblock_alloc_cblocks: M_NOWAIT malloc failed, trying blocking malloc\n");
-			cbp = malloc(sizeof *cbp, M_TTYS, 0);
+"cblock_alloc_cblocks: M_NOWAIT malloc failed, trying M_WAITOK\n");
+			cbp = malloc(sizeof *cbp, M_TTYS, M_WAITOK);
 		}
 		/*
 		 * Freed cblocks have zero quotes and garbage elsewhere.
diff --git a/sys/kern/uipc_accf.c b/sys/kern/uipc_accf.c
index 6580e1d..b31026a 100644
--- a/sys/kern/uipc_accf.c
+++ b/sys/kern/uipc_accf.c
@@ -115,7 +115,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, 0);
+		MALLOC(p, struct accept_filter *, sizeof(*p), M_ACCF, M_WAITOK);
 		bcopy(accfp, p, sizeof(*p));
 		s = splnet();
 		error = accept_filt_add(p);
diff --git a/sys/kern/uipc_mbuf.c b/sys/kern/uipc_mbuf.c
index 4ea316c..bc6aa71 100644
--- a/sys/kern/uipc_mbuf.c
+++ b/sys/kern/uipc_mbuf.c
@@ -164,7 +164,7 @@ m_prepend(struct mbuf *m, int len, int how)
 /*
  * Make a copy of an mbuf chain starting "off0" bytes from the beginning,
  * continuing for "len" bytes.  If len is M_COPYALL, copy to end of mbuf.
- * The wait parameter is a choice of 0/M_NOWAIT from caller.
+ * The wait parameter is a choice of M_TRYWAIT/M_DONTWAIT from caller.
  * Note that the copy is read-only, because clusters are not copied,
  * only their reference counts are incremented.
  */
@@ -522,7 +522,7 @@ m_pullup(struct mbuf *n, int len)
 	} else {
 		if (len > MHLEN)
 			goto bad;
-		MGET(m, M_NOWAIT, n->m_type);
+		MGET(m, M_DONTWAIT, n->m_type);
 		if (m == NULL)
 			goto bad;
 		m->m_len = 0;
@@ -639,7 +639,7 @@ m_devget(char *buf, int totlen, int off, struct ifnet *ifp,
 	if (off < 0 || off > MHLEN)
 		return (NULL);
 
-	MGETHDR(m, M_NOWAIT, MT_DATA);
+	MGETHDR(m, M_DONTWAIT, MT_DATA);
 	if (m == NULL)
 		return (NULL);
 	m->m_pkthdr.rcvif = ifp;
@@ -648,7 +648,7 @@ m_devget(char *buf, int totlen, int off, struct ifnet *ifp,
 
 	while (totlen > 0) {
 		if (top) {
-			MGET(m, M_NOWAIT, MT_DATA);
+			MGET(m, M_DONTWAIT, MT_DATA);
 			if (m == NULL) {
 				m_freem(top);
 				return (NULL);
@@ -656,7 +656,7 @@ m_devget(char *buf, int totlen, int off, struct ifnet *ifp,
 			len = MLEN;
 		}
 		if (totlen + off >= MINCLSIZE) {
-			MCLGET(m, M_NOWAIT);
+			MCLGET(m, M_DONTWAIT);
 			if (m->m_flags & M_EXT)
 				len = MCLBYTES;
 		} else {
@@ -704,7 +704,7 @@ m_copyback(struct mbuf *m0, int off, int len, caddr_t cp)
 		off -= mlen;
 		totlen += mlen;
 		if (m->m_next == NULL) {
-			n = m_get_clrd(M_NOWAIT, m->m_type);
+			n = m_get_clrd(M_DONTWAIT, m->m_type);
 			if (n == NULL)
 				goto out;
 			n->m_len = min(MLEN, len + off);
@@ -723,7 +723,7 @@ m_copyback(struct mbuf *m0, int off, int len, caddr_t cp)
 		if (len == 0)
 			break;
 		if (m->m_next == NULL) {
-			n = m_get(M_NOWAIT, m->m_type);
+			n = m_get(M_DONTWAIT, m->m_type);
 			if (n == NULL)
 				break;
 			n->m_len = min(MLEN, len);
diff --git a/sys/kern/uipc_mbuf2.c b/sys/kern/uipc_mbuf2.c
index 336ffa5..50b37f5 100644
--- a/sys/kern/uipc_mbuf2.c
+++ b/sys/kern/uipc_mbuf2.c
@@ -171,7 +171,7 @@ m_pulldown(struct mbuf *m, int off, int len, int *offp)
 	 * chop the current mbuf into two pieces, set off to 0.
 	 */
 	if (len <= n->m_len - off) {
-		o = m_dup1(n, off, n->m_len - off, M_NOWAIT);
+		o = m_dup1(n, off, n->m_len - off, M_DONTWAIT);
 		if (o == NULL) {
 			m_freem(m);
 			return NULL;	/* ENOBUFS */
@@ -230,9 +230,9 @@ m_pulldown(struct mbuf *m, int off, int len, int *offp)
 	 * now, we need to do the hard way.  don't m_copy as there's no room
 	 * on both end.
 	 */
-	MGET(o, M_NOWAIT, m->m_type);
+	MGET(o, M_DONTWAIT, m->m_type);
 	if (o && len > MLEN) {
-		MCLGET(o, M_NOWAIT);
+		MCLGET(o, M_DONTWAIT);
 		if ((o->m_flags & M_EXT) == 0) {
 			m_free(o);
 			o = NULL;
diff --git a/sys/kern/uipc_sem.c b/sys/kern/uipc_sem.c
index 3d9d5b55..e3912e1 100644
--- a/sys/kern/uipc_sem.c
+++ b/sys/kern/uipc_sem.c
@@ -188,7 +188,7 @@ sem_create(td, name, ksret, mode, value)
 	uc = p->p_ucred;
 	if (value > SEM_VALUE_MAX)
 		return (EINVAL);
-	ret = malloc(sizeof(*ret), M_SEM, M_ZERO);
+	ret = malloc(sizeof(*ret), M_SEM, M_WAITOK | M_ZERO);
 	if (name != NULL) {
 		len = strlen(name);
 		if (len > SEM_MAX_NAMELEN) {
@@ -200,7 +200,7 @@ sem_create(td, name, ksret, mode, value)
 			free(ret, M_SEM);
 			return (EINVAL);
 		}
-		ret->ks_name = malloc(len + 1, M_SEM, 0);
+		ret->ks_name = malloc(len + 1, M_SEM, M_WAITOK);
 		strcpy(ret->ks_name, name);
 	} else {
 		ret->ks_name = NULL;
@@ -504,7 +504,7 @@ sem_enter(p, ks)
 {
 	struct kuser *ku, *k;
 
-	ku = malloc(sizeof(*ku), M_SEM, 0);
+	ku = malloc(sizeof(*ku), M_SEM, M_WAITOK);
 	ku->ku_pid = p->p_pid;
 	mtx_lock(&sem_lock);
 	k = sem_getuser(p, ks);
diff --git a/sys/kern/uipc_sockbuf.c b/sys/kern/uipc_sockbuf.c
index 2ca7010..b63eb1a 100644
--- a/sys/kern/uipc_sockbuf.c
+++ b/sys/kern/uipc_sockbuf.c
@@ -315,7 +315,7 @@ sowakeup(so, sb)
 	if ((so->so_state & SS_ASYNC) && so->so_sigio != NULL)
 		pgsigio(&so->so_sigio, SIGIO, 0);
 	if (sb->sb_flags & SB_UPCALL)
-		(*so->so_upcall)(so, so->so_upcallarg, M_NOWAIT);
+		(*so->so_upcall)(so, so->so_upcallarg, M_DONTWAIT);
 	if (sb->sb_flags & SB_AIO)
 		aio_swake(so, sb);
 	KNOTE(&sb->sb_sel.si_note, 0);
@@ -626,7 +626,7 @@ sbappendaddr(sb, asa, m0, control)
 		return (0);
 	if (asa->sa_len > MLEN)
 		return (0);
-	MGET(m, M_NOWAIT, MT_SONAME);
+	MGET(m, M_DONTWAIT, MT_SONAME);
 	if (m == 0)
 		return (0);
 	m->m_len = asa->sa_len;
@@ -833,10 +833,10 @@ sbcreatecontrol(p, size, type, level)
 
 	if (CMSG_SPACE((u_int)size) > MCLBYTES)
 		return ((struct mbuf *) NULL);
-	if ((m = m_get(M_NOWAIT, MT_CONTROL)) == NULL)
+	if ((m = m_get(M_DONTWAIT, MT_CONTROL)) == NULL)
 		return ((struct mbuf *) NULL);
 	if (CMSG_SPACE((u_int)size) > MLEN) {
-		MCLGET(m, M_NOWAIT);
+		MCLGET(m, M_DONTWAIT);
 		if ((m->m_flags & M_EXT) == 0) {
 			m_free(m);
 			return ((struct mbuf *) NULL);
@@ -924,7 +924,7 @@ dup_sockaddr(sa, canwait)
 	struct sockaddr *sa2;
 
 	MALLOC(sa2, struct sockaddr *, sa->sa_len, M_SONAME, 
-	       canwait ? 0 : M_NOWAIT);
+	       canwait ? M_WAITOK : M_NOWAIT);
 	if (sa2)
 		bcopy(sa, sa2, sa->sa_len);
 	return sa2;
diff --git a/sys/kern/uipc_socket.c b/sys/kern/uipc_socket.c
index 1ab2885..4163f2e 100644
--- a/sys/kern/uipc_socket.c
+++ b/sys/kern/uipc_socket.c
@@ -137,7 +137,7 @@ soalloc(waitok)
 	int flag;
 
 	if (waitok == 1)
-		flag = 0;
+		flag = M_WAITOK;
 	else
 		flag = M_NOWAIT;
 	flag |= M_ZERO;
@@ -482,7 +482,7 @@ bad:
 	return (error);
 }
 
-#define	SBLOCKWAIT(f)	(((f) & MSG_DONTWAIT) ? M_NOWAIT : 0)
+#define	SBLOCKWAIT(f)	(((f) & MSG_DONTWAIT) ? M_NOWAIT : M_WAITOK)
 /*
  * Send on a socket.
  * If send must go all at once and message is larger than
@@ -626,7 +626,7 @@ restart:
 			cow_send = 0;
 #endif /* ZERO_COPY_SOCKETS */
 			if (top == 0) {
-				MGETHDR(m, 0, MT_DATA);
+				MGETHDR(m, M_TRYWAIT, MT_DATA);
 				if (m == NULL) {
 					error = ENOBUFS;
 					goto release;
@@ -635,7 +635,7 @@ restart:
 				m->m_pkthdr.len = 0;
 				m->m_pkthdr.rcvif = (struct ifnet *)0;
 			} else {
-				MGET(m, 0, MT_DATA);
+				MGET(m, M_TRYWAIT, MT_DATA);
 				if (m == NULL) {
 					error = ENOBUFS;
 					goto release;
@@ -657,7 +657,7 @@ restart:
 				} 
 				if (!cow_send){
 #endif /* ZERO_COPY_SOCKETS */
-				MCLGET(m, 0);
+				MCLGET(m, M_TRYWAIT);
 				if ((m->m_flags & M_EXT) == 0)
 					goto nopages;
 				mlen = MCLBYTES;
@@ -788,7 +788,7 @@ soreceive(so, psa, uio, mp0, controlp, flagsp)
 	else
 		flags = 0;
 	if (flags & MSG_OOB) {
-		m = m_get(0, MT_DATA);
+		m = m_get(M_TRYWAIT, MT_DATA);
 		if (m == NULL)
 			return (ENOBUFS);
 		error = (*pr->pr_usrreqs->pru_rcvoob)(so, m, flags & MSG_PEEK);
@@ -1025,7 +1025,7 @@ dontblock:
 				moff += len;
 			else {
 				if (mp)
-					*mp = m_copym(m, 0, len, 0);
+					*mp = m_copym(m, 0, len, M_TRYWAIT);
 				m->m_data += len;
 				m->m_len -= len;
 				so->so_rcv.sb_cc -= len;
@@ -1128,7 +1128,7 @@ sorflush(so)
 	struct sockbuf asb;
 
 	sb->sb_flags |= SB_NOINTR;
-	(void) sblock(sb, 0);
+	(void) sblock(sb, M_WAITOK);
 	s = splimp();
 	socantrcvmore(so);
 	sbunlock(sb);
@@ -1180,7 +1180,7 @@ do_setopt_accept_filter(so, sopt)
 		goto out;
 	}
 	/* don't put large objects on the kernel stack */
-	MALLOC(afap, struct accept_filter_arg *, sizeof(*afap), M_TEMP, 0);
+	MALLOC(afap, struct accept_filter_arg *, 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';
@@ -1191,12 +1191,12 @@ do_setopt_accept_filter(so, sopt)
 		error = ENOENT;
 		goto out;
 	}
-	MALLOC(af, struct so_accf *, sizeof(*af), M_ACCF, M_ZERO);
+	MALLOC(af, struct so_accf *, sizeof(*af), M_ACCF, M_WAITOK | M_ZERO);
 	if (afp->accf_create != NULL) {
 		if (afap->af_name[0] != '\0') {
 			int len = strlen(afap->af_name) + 1;
 
-			MALLOC(af->so_accept_filter_str, char *, len, M_ACCF, 0);
+			MALLOC(af->so_accept_filter_str, char *, len, M_ACCF, M_WAITOK);
 			strcpy(af->so_accept_filter_str, afap->af_name);
 		}
 		af->so_accept_filter_arg = afp->accf_create(so, afap->af_arg);
@@ -1478,7 +1478,7 @@ sogetopt(so, sopt)
 			if ((so->so_options & SO_ACCEPTCONN) == 0)
 				return (EINVAL);
 			MALLOC(afap, struct accept_filter_arg *, sizeof(*afap),
-				M_TEMP, M_ZERO);
+				M_TEMP, M_WAITOK | M_ZERO);
 			if ((so->so_options & SO_ACCEPTFILTER) != 0) {
 				strcpy(afap->af_name, so->so_accf->so_accept_filter->accf_name);
 				if (so->so_accf->so_accept_filter_str != NULL)
@@ -1581,11 +1581,11 @@ soopt_getm(struct sockopt *sopt, struct mbuf **mp)
 	struct mbuf *m, *m_prev;
 	int sopt_size = sopt->sopt_valsize;
 
-	MGET(m, sopt->sopt_td ? 0 : M_NOWAIT, MT_DATA);
+	MGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT, MT_DATA);
 	if (m == 0)
 		return ENOBUFS;
 	if (sopt_size > MLEN) {
-		MCLGET(m, sopt->sopt_td ? 0 : M_NOWAIT);
+		MCLGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT);
 		if ((m->m_flags & M_EXT) == 0) {
 			m_free(m);
 			return ENOBUFS;
@@ -1599,13 +1599,13 @@ soopt_getm(struct sockopt *sopt, struct mbuf **mp)
 	m_prev = m;
 
 	while (sopt_size) {
-		MGET(m, sopt->sopt_td ? 0 : M_NOWAIT, MT_DATA);
+		MGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT, MT_DATA);
 		if (m == 0) {
 			m_freem(*mp);
 			return ENOBUFS;
 		}
 		if (sopt_size > MLEN) {
-			MCLGET(m, sopt->sopt_td ? 0 : M_NOWAIT);
+			MCLGET(m, sopt->sopt_td ? M_TRYWAIT : M_DONTWAIT);
 			if ((m->m_flags & M_EXT) == 0) {
 				m_freem(*mp);
 				return ENOBUFS;
diff --git a/sys/kern/uipc_socket2.c b/sys/kern/uipc_socket2.c
index 2ca7010..b63eb1a 100644
--- a/sys/kern/uipc_socket2.c
+++ b/sys/kern/uipc_socket2.c
@@ -315,7 +315,7 @@ sowakeup(so, sb)
 	if ((so->so_state & SS_ASYNC) && so->so_sigio != NULL)
 		pgsigio(&so->so_sigio, SIGIO, 0);
 	if (sb->sb_flags & SB_UPCALL)
-		(*so->so_upcall)(so, so->so_upcallarg, M_NOWAIT);
+		(*so->so_upcall)(so, so->so_upcallarg, M_DONTWAIT);
 	if (sb->sb_flags & SB_AIO)
 		aio_swake(so, sb);
 	KNOTE(&sb->sb_sel.si_note, 0);
@@ -626,7 +626,7 @@ sbappendaddr(sb, asa, m0, control)
 		return (0);
 	if (asa->sa_len > MLEN)
 		return (0);
-	MGET(m, M_NOWAIT, MT_SONAME);
+	MGET(m, M_DONTWAIT, MT_SONAME);
 	if (m == 0)
 		return (0);
 	m->m_len = asa->sa_len;
@@ -833,10 +833,10 @@ sbcreatecontrol(p, size, type, level)
 
 	if (CMSG_SPACE((u_int)size) > MCLBYTES)
 		return ((struct mbuf *) NULL);
-	if ((m = m_get(M_NOWAIT, MT_CONTROL)) == NULL)
+	if ((m = m_get(M_DONTWAIT, MT_CONTROL)) == NULL)
 		return ((struct mbuf *) NULL);
 	if (CMSG_SPACE((u_int)size) > MLEN) {
-		MCLGET(m, M_NOWAIT);
+		MCLGET(m, M_DONTWAIT);
 		if ((m->m_flags & M_EXT) == 0) {
 			m_free(m);
 			return ((struct mbuf *) NULL);
@@ -924,7 +924,7 @@ dup_sockaddr(sa, canwait)
 	struct sockaddr *sa2;
 
 	MALLOC(sa2, struct sockaddr *, sa->sa_len, M_SONAME, 
-	       canwait ? 0 : M_NOWAIT);
+	       canwait ? M_WAITOK : M_NOWAIT);
 	if (sa2)
 		bcopy(sa, sa2, sa->sa_len);
 	return sa2;
diff --git a/sys/kern/uipc_syscalls.c b/sys/kern/uipc_syscalls.c
index d0ccfa0..e38bb90 100644
--- a/sys/kern/uipc_syscalls.c
+++ b/sys/kern/uipc_syscalls.c
@@ -673,7 +673,7 @@ sendit(td, s, mp, flags)
 		if (mp->msg_flags == MSG_COMPAT) {
 			register struct cmsghdr *cm;
 
-			M_PREPEND(control, sizeof(*cm), 0);
+			M_PREPEND(control, sizeof(*cm), M_TRYWAIT);
 			if (control == 0) {
 				error = ENOBUFS;
 				goto bad;
@@ -691,7 +691,7 @@ sendit(td, s, mp, flags)
 #ifdef KTRACE
 	if (KTRPOINT(td, KTR_GENIO)) {
 		iovlen = auio.uio_iovcnt * sizeof (struct iovec);
-		MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, 0);
+		MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
 		bcopy(auio.uio_iov, ktriov, iovlen);
 		ktruio = auio;
 	}
@@ -823,7 +823,7 @@ osendmsg(td, uap)
 		}
 		MALLOC(iov, struct iovec *,
 		      sizeof(struct iovec) * (u_int)msg.msg_iovlen, M_IOV,
-		      0);
+		      M_WAITOK);
 	} else {
 		iov = aiov;
 	}
@@ -870,7 +870,7 @@ sendmsg(td, uap)
 		}
 		MALLOC(iov, struct iovec *,
 		       sizeof(struct iovec) * (u_int)msg.msg_iovlen, M_IOV,
-		       0);
+		       M_WAITOK);
 	} else {
 		iov = aiov;
 	}
@@ -940,7 +940,7 @@ recvit(td, s, mp, namelenp)
 #ifdef KTRACE
 	if (KTRPOINT(td, KTR_GENIO)) {
 		iovlen = auio.uio_iovcnt * sizeof (struct iovec);
-		MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, 0);
+		MALLOC(ktriov, struct iovec *, iovlen, M_TEMP, M_WAITOK);
 		bcopy(auio.uio_iov, ktriov, iovlen);
 		ktruio = auio;
 	}
@@ -1170,7 +1170,7 @@ orecvmsg(td, uap)
 		}
 		MALLOC(iov, struct iovec *,
 		      sizeof(struct iovec) * (u_int)msg.msg_iovlen, M_IOV,
-		      0);
+		      M_WAITOK);
 	} else {
 		iov = aiov;
 	}
@@ -1221,7 +1221,7 @@ recvmsg(td, uap)
 		}
 		MALLOC(iov, struct iovec *,
 		       sizeof(struct iovec) * (u_int)msg.msg_iovlen, M_IOV,
-		       0);
+		       M_WAITOK);
 	} else {
 		iov = aiov;
 	}
@@ -1557,7 +1557,7 @@ sockargs(mp, buf, buflen, type)
 #endif
 		return (EINVAL);
 	}
-	m = m_get(0, type);
+	m = m_get(M_TRYWAIT, type);
 	if (m == NULL)
 		return (ENOBUFS);
 	m->m_len = buflen;
@@ -1590,7 +1590,7 @@ getsockaddr(namp, uaddr, len)
 
 	if (len > SOCK_MAXADDRLEN)
 		return ENAMETOOLONG;
-	MALLOC(sa, struct sockaddr *, len, M_SONAME, 0);
+	MALLOC(sa, struct sockaddr *, len, M_SONAME, M_WAITOK);
 	error = copyin(uaddr, sa, len);
 	if (error) {
 		FREE(sa, M_SONAME);
@@ -1804,7 +1804,7 @@ do_sendfile(struct thread *td, struct sendfile_args *uap, int compat)
 	/*
 	 * Protect against multiple writers to the socket.
 	 */
-	(void) sblock(&so->so_snd, 0);
+	(void) sblock(&so->so_snd, M_WAITOK);
 
 	/*
 	 * Loop through the pages in the file, starting with the requested
@@ -1948,7 +1948,7 @@ retry_lookup:
 		/*
 		 * Get an mbuf header and set it up as having external storage.
 		 */
-		MGETHDR(m, 0, MT_DATA);
+		MGETHDR(m, M_TRYWAIT, MT_DATA);
 		if (m == NULL) {
 			error = ENOBUFS;
 			sf_buf_free((void *)sf->kva, NULL);
diff --git a/sys/kern/uipc_usrreq.c b/sys/kern/uipc_usrreq.c
index 51c7d84..e3d3e3b 100644
--- a/sys/kern/uipc_usrreq.c
+++ b/sys/kern/uipc_usrreq.c
@@ -541,7 +541,7 @@ unp_attach(so)
 		if (error)
 			return (error);
 	}
-	unp = uma_zalloc(unp_zone, 0);
+	unp = uma_zalloc(unp_zone, M_WAITOK);
 	if (unp == NULL)
 		return (ENOBUFS);
 	bzero(unp, sizeof *unp);
@@ -610,7 +610,7 @@ unp_bind(unp, nam, td)
 	if (namelen <= 0)
 		return EINVAL;
 
-	buf = malloc(namelen + 1, M_TEMP, 0);
+	buf = malloc(namelen + 1, M_TEMP, M_WAITOK);
 	strlcpy(buf, soun->sun_path, namelen + 1);
 
 restart:
@@ -851,7 +851,7 @@ unp_pcblist(SYSCTL_HANDLER_ARGS)
 	/*
 	 * OK, now we're committed to doing something.
 	 */
-	xug = malloc(sizeof(*xug), M_TEMP, 0);
+	xug = malloc(sizeof(*xug), M_TEMP, M_WAITOK);
 	gencnt = unp_gencnt;
 	n = unp_count;
 
@@ -865,7 +865,7 @@ unp_pcblist(SYSCTL_HANDLER_ARGS)
 		return error;
 	}
 
-	unp_list = malloc(n * sizeof *unp_list, M_TEMP, 0);
+	unp_list = malloc(n * sizeof *unp_list, M_TEMP, M_WAITOK);
 	
 	for (unp = LIST_FIRST(head), i = 0; unp && i < n;
 	     unp = LIST_NEXT(unp, unp_link)) {
@@ -879,7 +879,7 @@ unp_pcblist(SYSCTL_HANDLER_ARGS)
 	n = i;			/* in case we lost some during malloc */
 
 	error = 0;
-	xu = malloc(sizeof(*xu), M_TEMP, 0);
+	xu = malloc(sizeof(*xu), M_TEMP, M_WAITOK);
 	for (i = 0; i < n; i++) {
 		unp = unp_list[i];
 		if (unp->unp_gencnt <= gencnt) {
@@ -1385,7 +1385,7 @@ unp_gc()
 	 *
 	 * 91/09/19, bsy@cs.cmu.edu
 	 */
-	extra_ref = malloc(nfiles * sizeof(struct file *), M_TEMP, 0);
+	extra_ref = malloc(nfiles * sizeof(struct file *), M_TEMP, M_WAITOK);
 	sx_slock(&filelist_lock);
 	for (nunref = 0, fp = LIST_FIRST(&filehead), fpp = extra_ref; fp != 0;
 	    fp = nextfp) {
diff --git a/sys/kern/vfs_aio.c b/sys/kern/vfs_aio.c
index 5cee627..9532ff2 100644
--- a/sys/kern/vfs_aio.c
+++ b/sys/kern/vfs_aio.c
@@ -392,7 +392,7 @@ aio_init_aioinfo(struct proc *p)
 	struct kaioinfo *ki;
 
 	if (p->p_aioinfo == NULL) {
-		ki = uma_zalloc(kaio_zone, 0);
+		ki = uma_zalloc(kaio_zone, M_WAITOK);
 		p->p_aioinfo = ki;
 		ki->kaio_flags = 0;
 		ki->kaio_maxactive_count = max_aio_per_proc;
@@ -777,7 +777,7 @@ aio_daemon(void *uproc)
 	 * Allocate and ready the aio control info.  There is one aiop structure
 	 * per daemon.
 	 */
-	aiop = uma_zalloc(aiop_zone, 0);
+	aiop = uma_zalloc(aiop_zone, M_WAITOK);
 	aiop->aiothread = td;
 	aiop->aiothreadflags |= AIOP_FREE;
 
@@ -801,9 +801,9 @@ aio_daemon(void *uproc)
 	mtx_unlock(&Giant);
 	/* The daemon resides in its own pgrp. */
 	MALLOC(newpgrp, struct pgrp *, sizeof(struct pgrp), M_PGRP,
-		M_ZERO);
+		M_WAITOK | M_ZERO);
 	MALLOC(newsess, struct session *, sizeof(struct session), M_SESSION,
-		M_ZERO);
+		M_WAITOK | M_ZERO);
 
 	sx_xlock(&proctree_lock);
 	enterpgrp(mycp, mycp->p_pid, newpgrp, newsess);
@@ -1301,7 +1301,7 @@ _aio_aqueue(struct thread *td, struct aiocb *job, struct aio_liojob *lj, int typ
 	struct kqueue *kq;
 	struct file *kq_fp;
 
-	aiocbe = uma_zalloc(aiocb_zone, 0);
+	aiocbe = uma_zalloc(aiocb_zone, M_WAITOK);
 	aiocbe->inputcharge = 0;
 	aiocbe->outputcharge = 0;
 	callout_handle_init(&aiocbe->timeouthandle);
@@ -1647,8 +1647,8 @@ aio_suspend(struct thread *td, struct aio_suspend_args *uap)
 		return (EAGAIN);
 
 	njoblist = 0;
-	ijoblist = uma_zalloc(aiol_zone, 0);
-	ujoblist = uma_zalloc(aiol_zone, 0);
+	ijoblist = uma_zalloc(aiol_zone, M_WAITOK);
+	ujoblist = uma_zalloc(aiol_zone, M_WAITOK);
 	cbptr = uap->aiocbp;
 
 	for (i = 0; i < uap->nent; i++) {
@@ -1971,7 +1971,7 @@ lio_listio(struct thread *td, struct lio_listio_args *uap)
 	if ((nent + ki->kaio_queue_count) > ki->kaio_qallowed_count)
 		return (EAGAIN);
 
-	lj = uma_zalloc(aiolio_zone, 0);
+	lj = uma_zalloc(aiolio_zone, M_WAITOK);
 	if (!lj)
 		return (EAGAIN);
 
diff --git a/sys/kern/vfs_bio.c b/sys/kern/vfs_bio.c
index 104043c..a1f31e1 100644
--- a/sys/kern/vfs_bio.c
+++ b/sys/kern/vfs_bio.c
@@ -2742,7 +2742,7 @@ allocbuf(struct buf *bp, int size)
 				(bp->b_bufsize == 0) &&
 				(mbsize <= PAGE_SIZE/2)) {
 
-				bp->b_data = malloc(mbsize, M_BIOBUF, 0);
+				bp->b_data = malloc(mbsize, M_BIOBUF, M_WAITOK);
 				bp->b_bufsize = mbsize;
 				bp->b_bcount = size;
 				bp->b_flags |= B_MALLOC;
diff --git a/sys/kern/vfs_cache.c b/sys/kern/vfs_cache.c
index 33fc4f0..cac844e 100644
--- a/sys/kern/vfs_cache.c
+++ b/sys/kern/vfs_cache.c
@@ -417,7 +417,7 @@ cache_enter(dvp, vp, cnp)
 	}
 	 
 	ncp = (struct namecache *)
-		malloc(sizeof *ncp + cnp->cn_namelen, M_VFSCACHE, 0);
+		malloc(sizeof *ncp + cnp->cn_namelen, M_VFSCACHE, M_WAITOK);
 	bzero((char *)ncp, sizeof *ncp);
 	numcache++;
 	if (!vp) {
@@ -737,7 +737,7 @@ kern___getcwd(struct thread *td, u_char *buf, enum uio_seg bufseg, u_int buflen)
 	if (buflen > MAXPATHLEN)
 		buflen = MAXPATHLEN;
 	error = 0;
-	tmpbuf = bp = malloc(buflen, M_TEMP, 0);
+	tmpbuf = bp = malloc(buflen, M_TEMP, M_WAITOK);
 	bp += buflen - 1;
 	*bp = '\0';
 	fdp = td->td_proc->p_fd;
@@ -848,7 +848,7 @@ vn_fullpath(struct thread *td, struct vnode *vn, char **retbuf, char **freebuf)
 		return (ENODEV);
 	if (vn == NULL)
 		return (EINVAL);
-	buf = malloc(MAXPATHLEN, M_TEMP, 0);
+	buf = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 	bp = buf + MAXPATHLEN - 1;
 	*bp = '\0';
 	fdp = td->td_proc->p_fd;
diff --git a/sys/kern/vfs_cluster.c b/sys/kern/vfs_cluster.c
index da84419..7fd0402 100644
--- a/sys/kern/vfs_cluster.c
+++ b/sys/kern/vfs_cluster.c
@@ -1001,7 +1001,7 @@ cluster_collectbufs(vp, last_bp)
 
 	len = vp->v_lastw - vp->v_cstart + 1;
 	buflist = malloc(sizeof(struct buf *) * (len + 1) + sizeof(*buflist),
-	    M_SEGMENT, 0);
+	    M_SEGMENT, M_WAITOK);
 	buflist->bs_nchildren = 0;
 	buflist->bs_children = (struct buf **) (buflist + 1);
 	for (lbn = vp->v_cstart, i = 0; i < len; lbn++, i++) {
diff --git a/sys/kern/vfs_export.c b/sys/kern/vfs_export.c
index 80158a3..b909b83 100644
--- a/sys/kern/vfs_export.c
+++ b/sys/kern/vfs_export.c
@@ -122,7 +122,7 @@ vfs_hang_addrlist(mp, nep, argp)
 		return (EINVAL);
 
 	i = sizeof(struct netcred) + argp->ex_addrlen + argp->ex_masklen;
-	np = (struct netcred *) malloc(i, M_NETADDR, M_ZERO);
+	np = (struct netcred *) malloc(i, M_NETADDR, M_WAITOK | M_ZERO);
 	saddr = (struct sockaddr *) (np + 1);
 	if ((error = copyin(argp->ex_addr, saddr, argp->ex_addrlen)))
 		goto out;
@@ -236,7 +236,7 @@ vfs_export(mp, argp)
 	}
 	if (argp->ex_flags & MNT_EXPORTED) {
 		if (nep == NULL) {
-			nep = malloc(sizeof(struct netexport), M_MOUNT, M_ZERO);
+			nep = malloc(sizeof(struct netexport), M_MOUNT, M_WAITOK | M_ZERO);
 			mp->mnt_export = nep;
 		}
 		if (argp->ex_flags & MNT_EXPUBLIC) {
@@ -306,7 +306,7 @@ vfs_setpublicfs(mp, nep, argp)
 	 */
 	if (argp->ex_indexfile != NULL) {
 		MALLOC(nfs_pub.np_index, char *, MAXNAMLEN + 1, M_TEMP,
-		    0);
+		    M_WAITOK);
 		error = copyinstr(argp->ex_indexfile, nfs_pub.np_index,
 		    MAXNAMLEN, (size_t *)0);
 		if (!error) {
diff --git a/sys/kern/vfs_extattr.c b/sys/kern/vfs_extattr.c
index 0c89a94..0592e97 100644
--- a/sys/kern/vfs_extattr.c
+++ b/sys/kern/vfs_extattr.c
@@ -1105,7 +1105,7 @@ kern_symlink(struct thread *td, char *path, char *link, enum uio_seg segflg)
 	if (segflg == UIO_SYSSPACE) {
 		syspath = path;
 	} else {
-		syspath = uma_zalloc(namei_zone, 0);
+		syspath = uma_zalloc(namei_zone, M_WAITOK);
 		if ((error = copyinstr(path, syspath, MAXPATHLEN, NULL)) != 0)
 			goto out;
 	}
@@ -3111,7 +3111,7 @@ unionread:
 		kuio.uio_iov = &kiov;
 		kuio.uio_segflg = UIO_SYSSPACE;
 		kiov.iov_len = uap->count;
-		MALLOC(dirbuf, caddr_t, uap->count, M_TEMP, 0);
+		MALLOC(dirbuf, caddr_t, uap->count, M_TEMP, M_WAITOK);
 		kiov.iov_base = dirbuf;
 		error = VOP_READDIR(vp, &kuio, fp->f_cred, &eofflag,
 			    NULL, NULL);
diff --git a/sys/kern/vfs_init.c b/sys/kern/vfs_init.c
index 24ae27a..b221cd3 100644
--- a/sys/kern/vfs_init.c
+++ b/sys/kern/vfs_init.c
@@ -133,7 +133,7 @@ vfs_opv_recalc(void)
 	 * detectable.
 	 */
 	MALLOC(vfs_op_offsets, int *,
-		num_op_descs * sizeof(int), M_TEMP, 0);
+		num_op_descs * sizeof(int), M_TEMP, M_WAITOK);
 	if (vfs_op_offsets == NULL)
 		panic("vfs_opv_recalc: no memory");
 	for (i = 0; i < num_op_descs; i++)
@@ -186,7 +186,7 @@ vfs_opv_recalc(void)
 		if (*opv_desc_vector_p == NULL)
 			MALLOC(*opv_desc_vector_p, vop_t **,
 				vfs_opv_numops * sizeof(vop_t *), M_VNODE,
-				M_ZERO);
+				M_WAITOK | M_ZERO);
 
 		/* Fill in, with slot 0 being to return EOPNOTSUPP */
 		opv_desc_vector = *opv_desc_vector_p;
@@ -221,7 +221,7 @@ vfs_add_vnodeops(const void *data)
 
 	opv = (const struct vnodeopv_desc *)data;
 	MALLOC(newopv, const struct vnodeopv_desc **,
-	       (vnodeopv_num + 1) * sizeof(*newopv), M_VNODE, 0);
+	       (vnodeopv_num + 1) * sizeof(*newopv), M_VNODE, M_WAITOK);
 	if (vnodeopv_descs) {
 		bcopy(vnodeopv_descs, newopv, vnodeopv_num * sizeof(*newopv));
 		FREE(vnodeopv_descs, M_VNODE);
@@ -244,11 +244,11 @@ vfs_add_vnodeops(const void *data)
 			/* not found, new entry */
 			MALLOC(newop, struct vnodeop_desc **,
 			       (num_op_descs + 1) * sizeof(*newop),
-			       M_VNODE, 0);
+			       M_VNODE, M_WAITOK);
 			/* new reference count (for unload) */
 			MALLOC(newref, int *,
 				(num_op_descs + 1) * sizeof(*newref),
-				M_VNODE, 0);
+				M_VNODE, M_WAITOK);
 			if (vfs_op_descs) {
 				bcopy(vfs_op_descs, newop,
 					num_op_descs * sizeof(*newop));
@@ -306,11 +306,11 @@ vfs_rm_vnodeops(const void *data)
 			}
 			MALLOC(newop, struct vnodeop_desc **,
 			       (num_op_descs - 1) * sizeof(*newop),
-			       M_VNODE, 0);
+			       M_VNODE, M_WAITOK);
 			/* new reference count (for unload) */
 			MALLOC(newref, int *,
 				(num_op_descs - 1) * sizeof(*newref),
-				M_VNODE, 0);
+				M_VNODE, M_WAITOK);
 			for (k = j; k < (num_op_descs - 1); k++) {
 				vfs_op_descs[k] = vfs_op_descs[k + 1];
 				vfs_op_desc_refs[k] = vfs_op_desc_refs[k + 1];
@@ -340,7 +340,7 @@ vfs_rm_vnodeops(const void *data)
 	if (opv_desc_vector != NULL)
 		FREE(opv_desc_vector, M_VNODE);
 	MALLOC(newopv, const struct vnodeopv_desc **,
-	       (vnodeopv_num - 1) * sizeof(*newopv), M_VNODE, 0);
+	       (vnodeopv_num - 1) * sizeof(*newopv), M_VNODE, M_WAITOK);
 	bcopy(vnodeopv_descs, newopv, (vnodeopv_num - 1) * sizeof(*newopv));
 	FREE(vnodeopv_descs, M_VNODE);
 	vnodeopv_descs = newopv;
diff --git a/sys/kern/vfs_lookup.c b/sys/kern/vfs_lookup.c
index e33e2c6..f064b64 100644
--- a/sys/kern/vfs_lookup.c
+++ b/sys/kern/vfs_lookup.c
@@ -120,7 +120,7 @@ namei(ndp)
 	 * name into the buffer.
 	 */
 	if ((cnp->cn_flags & HASBUF) == 0)
-		cnp->cn_pnbuf = uma_zalloc(namei_zone, 0);
+		cnp->cn_pnbuf = uma_zalloc(namei_zone, M_WAITOK);
 	if (ndp->ni_segflg == UIO_SYSSPACE)
 		error = copystr(ndp->ni_dirp, cnp->cn_pnbuf,
 			    MAXPATHLEN, (size_t *)&ndp->ni_pathlen);
@@ -224,7 +224,7 @@ namei(ndp)
 		}
 #endif
 		if (ndp->ni_pathlen > 1)
-			cp = uma_zalloc(namei_zone, 0);
+			cp = uma_zalloc(namei_zone, M_WAITOK);
 		else
 			cp = cnp->cn_pnbuf;
 		aiov.iov_base = cp;
diff --git a/sys/kern/vfs_mount.c b/sys/kern/vfs_mount.c
index eb208cc..9c47ceb 100644
--- a/sys/kern/vfs_mount.c
+++ b/sys/kern/vfs_mount.c
@@ -224,13 +224,13 @@ vfs_buildopts(struct uio *auio, struct vfsoptlist **options)
 	int error, namelen, optlen;
 
 	iovcnt = auio->uio_iovcnt;
-	opts = malloc(sizeof(struct vfsoptlist), M_MOUNT, 0);
+	opts = malloc(sizeof(struct vfsoptlist), M_MOUNT, M_WAITOK);
 	TAILQ_INIT(opts);
 	for (i = 0; i < iovcnt; i += 2) {
-		opt = malloc(sizeof(struct vfsopt), M_MOUNT, 0);
+		opt = malloc(sizeof(struct vfsopt), M_MOUNT, M_WAITOK);
 		namelen = auio->uio_iov[i].iov_len;
 		optlen = auio->uio_iov[i + 1].iov_len;
-		opt->name = malloc(namelen, M_MOUNT, 0);
+		opt->name = malloc(namelen, M_MOUNT, M_WAITOK);
 		opt->value = NULL;
 		if (auio->uio_segflg == UIO_SYSSPACE) {
 			bcopy(auio->uio_iov[i].iov_base, opt->name, namelen);
@@ -242,7 +242,7 @@ vfs_buildopts(struct uio *auio, struct vfsoptlist **options)
 		}
 		opt->len = optlen;
 		if (optlen != 0) {
-			opt->value = malloc(optlen, M_MOUNT, 0);
+			opt->value = malloc(optlen, M_MOUNT, M_WAITOK);
 			if (auio->uio_segflg == UIO_SYSSPACE) {
 				bcopy(auio->uio_iov[i + 1].iov_base, opt->value,
 				    optlen);
@@ -289,11 +289,11 @@ vfs_mergeopts(struct vfsoptlist *toopts, struct vfsoptlist *opts)
 			opt2 = TAILQ_NEXT(opt2, link);
 		}
 		/* We want this option, duplicate it. */
-		new = malloc(sizeof(struct vfsopt), M_MOUNT, 0);
-		new->name = malloc(strlen(opt->name) + 1, M_MOUNT, 0);
+		new = malloc(sizeof(struct vfsopt), M_MOUNT, M_WAITOK);
+		new->name = malloc(strlen(opt->name) + 1, M_MOUNT, M_WAITOK);
 		strcpy(new->name, opt->name);
 		if (opt->len != 0) {
-			new->value = malloc(opt->len, M_MOUNT, 0);
+			new->value = malloc(opt->len, M_MOUNT, M_WAITOK);
 			bcopy(opt->value, new->value, opt->len);
 		} else {
 			new->value = NULL;
@@ -334,7 +334,7 @@ nmount(td, uap)
 		return (EINVAL);
 
 	if (iovcnt > UIO_SMALLIOV) {
-		MALLOC(iov, struct iovec *, iovlen, M_IOV, 0);
+		MALLOC(iov, struct iovec *, iovlen, M_IOV, M_WAITOK);
 		needfree = iov;
 	} else {
 		iov = aiov;
@@ -406,8 +406,8 @@ kernel_vmount(int flags, ...)
 		return (EINVAL);
 
 	iovlen = iovcnt * sizeof (struct iovec);
-	MALLOC(iovp, struct iovec *, iovlen, M_MOUNT, 0);
-	MALLOC(buf, char *, len, M_MOUNT, 0);
+	MALLOC(iovp, struct iovec *, iovlen, M_MOUNT, M_WAITOK);
+	MALLOC(buf, char *, len, M_MOUNT, M_WAITOK);
 	pos = buf;
 	va_start(ap, flags);
 	for (i = 0; i < iovcnt; i++) {
@@ -634,7 +634,7 @@ vfs_nmount(td, fsflags, fsoptions)
 	/*
 	 * Allocate and initialize the filesystem.
 	 */
-	mp = malloc(sizeof(struct mount), M_MOUNT, M_ZERO);
+	mp = malloc(sizeof(struct mount), M_MOUNT, M_WAITOK | M_ZERO);
 	TAILQ_INIT(&mp->mnt_nvnodelist);
 	TAILQ_INIT(&mp->mnt_reservedvnlist);
 	lockinit(&mp->mnt_lock, PVFS, "vfslock", 0, LK_NOPAUSE);
@@ -805,8 +805,8 @@ mount(td, uap)
 	char *fspath;
 	int error;
 
-	fstype = malloc(MFSNAMELEN, M_TEMP, 0);
-	fspath = malloc(MNAMELEN, M_TEMP, 0);
+	fstype = malloc(MFSNAMELEN, M_TEMP, M_WAITOK);
+	fspath = malloc(MNAMELEN, M_TEMP, M_WAITOK);
 
 	/*
 	 * vfs_mount() actually takes a kernel string for `type' and
@@ -998,7 +998,7 @@ vfs_mount(td, fstype, fspath, fsflags, fsdata)
 	/*
 	 * Allocate and initialize the filesystem.
 	 */
-	mp = malloc(sizeof(struct mount), M_MOUNT, M_ZERO);
+	mp = malloc(sizeof(struct mount), M_MOUNT, M_WAITOK | M_ZERO);
 	TAILQ_INIT(&mp->mnt_nvnodelist);
 	TAILQ_INIT(&mp->mnt_reservedvnlist);
 	lockinit(&mp->mnt_lock, PVFS, "vfslock", 0, LK_NOPAUSE);
@@ -1361,7 +1361,7 @@ vfs_rootmountalloc(fstypename, devname, mpp)
 			break;
 	if (vfsp == NULL)
 		return (ENODEV);
-	mp = malloc((u_long)sizeof(struct mount), M_MOUNT, M_ZERO);
+	mp = malloc((u_long)sizeof(struct mount), M_MOUNT, M_WAITOK | M_ZERO);
 	lockinit(&mp->mnt_lock, PVFS, "vfslock", 0, LK_NOPAUSE);
 	(void)vfs_busy(mp, LK_NOWAIT, 0, td);
 	TAILQ_INIT(&mp->mnt_nvnodelist);
@@ -1494,8 +1494,8 @@ vfs_mountroot_try(char *mountfrom)
 	splx(s);
 
 	/* parse vfs name and path */
-	vfsname = malloc(MFSNAMELEN, M_MOUNT, 0);
-	path = malloc(MNAMELEN, M_MOUNT, 0);
+	vfsname = malloc(MFSNAMELEN, M_MOUNT, M_WAITOK);
+	path = malloc(MNAMELEN, M_MOUNT, M_WAITOK);
 	vfsname[0] = path[0] = 0;
 	sprintf(patt, "%%%d[a-z0-9]:%%%zds", MFSNAMELEN, MNAMELEN);
 	if (sscanf(mountfrom, patt, vfsname, path) < 1)
diff --git a/sys/kern/vfs_subr.c b/sys/kern/vfs_subr.c
index 7f3af03..8e954eb 100644
--- a/sys/kern/vfs_subr.c
+++ b/sys/kern/vfs_subr.c
@@ -452,7 +452,7 @@ vop_lock_post(void *ap, int rc)
 void
 v_addpollinfo(struct vnode *vp)
 {
-	vp->v_pollinfo = uma_zalloc(vnodepoll_zone, 0);
+	vp->v_pollinfo = uma_zalloc(vnodepoll_zone, M_WAITOK);
 	mtx_init(&vp->v_pollinfo->vpi_lock, "vnode pollinfo", NULL, MTX_DEF);
 }
 
@@ -996,7 +996,7 @@ getnewvnode(tag, mp, vops, vpp)
 		numvnodes++;
 		mtx_unlock(&vnode_free_list_mtx);
 
-		vp = (struct vnode *) uma_zalloc(vnode_zone, M_ZERO);
+		vp = (struct vnode *) uma_zalloc(vnode_zone, M_WAITOK|M_ZERO);
 		mtx_init(&vp->v_interlock, "vnode interlock", NULL, MTX_DEF);
 		VI_LOCK(vp);
 		vp->v_dd = vp;
@@ -2938,7 +2938,7 @@ sysctl_vfs_conflist(SYSCTL_HANDLER_ARGS)
 	cnt = 0;
 	for (vfsp = vfsconf; vfsp != NULL; vfsp = vfsp->vfc_next)
 		cnt++;
-	xvfsp = malloc(sizeof(struct xvfsconf) * cnt, M_TEMP, 0);
+	xvfsp = malloc(sizeof(struct xvfsconf) * cnt, M_TEMP, M_WAITOK);
 	/*
 	 * Handle the race that we will have here when struct vfsconf
 	 * will be locked down by using both cnt and checking vfc_next
@@ -3051,7 +3051,7 @@ sysctl_vnode(SYSCTL_HANDLER_ARGS)
 		return (SYSCTL_OUT(req, 0, len));
 
 	sysctl_wire_old_buffer(req, 0);
-	xvn = malloc(len, M_TEMP, M_ZERO | 0);
+	xvn = malloc(len, M_TEMP, M_ZERO | M_WAITOK);
 	n = 0;
 	mtx_lock(&mountlist_mtx);
 	TAILQ_FOREACH(mp, &mountlist, mnt_list) {
diff --git a/sys/kern/vfs_syscalls.c b/sys/kern/vfs_syscalls.c
index 0c89a94..0592e97 100644
--- a/sys/kern/vfs_syscalls.c
+++ b/sys/kern/vfs_syscalls.c
@@ -1105,7 +1105,7 @@ kern_symlink(struct thread *td, char *path, char *link, enum uio_seg segflg)
 	if (segflg == UIO_SYSSPACE) {
 		syspath = path;
 	} else {
-		syspath = uma_zalloc(namei_zone, 0);
+		syspath = uma_zalloc(namei_zone, M_WAITOK);
 		if ((error = copyinstr(path, syspath, MAXPATHLEN, NULL)) != 0)
 			goto out;
 	}
@@ -3111,7 +3111,7 @@ unionread:
 		kuio.uio_iov = &kiov;
 		kuio.uio_segflg = UIO_SYSSPACE;
 		kiov.iov_len = uap->count;
-		MALLOC(dirbuf, caddr_t, uap->count, M_TEMP, 0);
+		MALLOC(dirbuf, caddr_t, uap->count, M_TEMP, M_WAITOK);
 		kiov.iov_base = dirbuf;
 		error = VOP_READDIR(vp, &kuio, fp->f_cred, &eofflag,
 			    NULL, NULL);