Index: kernel/arch/amd64/src/kseg.c
===================================================================
--- kernel/arch/amd64/src/kseg.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/arch/amd64/src/kseg.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -47,5 +47,5 @@
 	kseg_t *kseg;
 
-	kseg = (kseg_t *) malloc(sizeof(kseg_t), FRAME_ATOMIC);
+	kseg = (kseg_t *) malloc(sizeof(kseg_t));
 	if (!kseg)
 		panic("Cannot allocate kseg.");
Index: kernel/arch/amd64/src/pm.c
===================================================================
--- kernel/arch/amd64/src/pm.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/arch/amd64/src/pm.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -273,5 +273,5 @@
 		write_cr3((uintptr_t) AS_KERNEL->genarch.page_table);
 
-		tss_p = (tss_t *) malloc(sizeof(tss_t), FRAME_ATOMIC);
+		tss_p = (tss_t *) malloc(sizeof(tss_t));
 		if (!tss_p)
 			panic("Cannot allocate TSS.");
Index: kernel/arch/arm32/src/mach/integratorcp/integratorcp.c
===================================================================
--- kernel/arch/arm32/src/mach/integratorcp/integratorcp.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/arch/arm32/src/mach/integratorcp/integratorcp.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -320,5 +320,5 @@
 {
 
-	pl050_t *pl050 = malloc(sizeof(pl050_t), FRAME_ATOMIC);
+	pl050_t *pl050 = malloc(sizeof(pl050_t));
 	pl050->status = (ioport8_t *) icp.hw_map.kbd_stat;
 	pl050->data = (ioport8_t *) icp.hw_map.kbd_data;
Index: kernel/arch/ia32/src/pm.c
===================================================================
--- kernel/arch/ia32/src/pm.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/arch/ia32/src/pm.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -283,5 +283,5 @@
 		tss_p = &tss0;
 	} else {
-		tss_p = (tss_t *) malloc(sizeof(tss_t), FRAME_ATOMIC);
+		tss_p = (tss_t *) malloc(sizeof(tss_t));
 		if (!tss_p)
 			panic("Cannot allocate TSS.");
Index: kernel/arch/ia32/src/smp/smp.c
===================================================================
--- kernel/arch/ia32/src/smp/smp.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/arch/ia32/src/smp/smp.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -161,6 +161,5 @@
 		 */
 		descriptor_t *gdt_new =
-		    (descriptor_t *) malloc(GDT_ITEMS * sizeof(descriptor_t),
-		    FRAME_ATOMIC);
+		    (descriptor_t *) malloc(GDT_ITEMS * sizeof(descriptor_t));
 		if (!gdt_new)
 			panic("Cannot allocate memory for GDT.");
Index: kernel/arch/ia64/src/ddi/ddi.c
===================================================================
--- kernel/arch/ia64/src/ddi/ddi.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/arch/ia64/src/ddi/ddi.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -56,10 +56,9 @@
 {
 	if (!task->arch.iomap) {
-		task->arch.iomap = malloc(sizeof(bitmap_t), FRAME_ATOMIC);
+		task->arch.iomap = malloc(sizeof(bitmap_t));
 		if (task->arch.iomap == NULL)
 			return ENOMEM;
 
-		void *store = malloc(bitmap_size(IO_MEMMAP_PAGES),
-		    FRAME_ATOMIC);
+		void *store = malloc(bitmap_size(IO_MEMMAP_PAGES));
 		if (store == NULL)
 			return ENOMEM;
Index: kernel/arch/ia64/src/drivers/ski.c
===================================================================
--- kernel/arch/ia64/src/drivers/ski.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/arch/ia64/src/drivers/ski.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -150,5 +150,5 @@
 	);
 
-	instance = malloc(sizeof(ski_instance_t), FRAME_ATOMIC);
+	instance = malloc(sizeof(ski_instance_t));
 
 	if (instance) {
@@ -209,5 +209,5 @@
 		return NULL;
 
-	outdev_t *skidev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
+	outdev_t *skidev = malloc(sizeof(outdev_t));
 	if (!skidev)
 		return NULL;
Index: kernel/arch/riscv64/src/drivers/ucb.c
===================================================================
--- kernel/arch/riscv64/src/drivers/ucb.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/arch/riscv64/src/drivers/ucb.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -65,5 +65,5 @@
 outdev_t *htifout_init(void)
 {
-	outdev_t *htifdev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
+	outdev_t *htifdev = malloc(sizeof(outdev_t));
 	if (!htifdev)
 		return NULL;
Index: kernel/arch/sparc64/src/drivers/niagara.c
===================================================================
--- kernel/arch/sparc64/src/drivers/niagara.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/arch/sparc64/src/drivers/niagara.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -178,5 +178,5 @@
 		return;
 
-	instance = malloc(sizeof(niagara_instance_t), FRAME_ATOMIC);
+	instance = malloc(sizeof(niagara_instance_t));
 	instance->thread = thread_create(kniagarapoll, NULL, TASK,
 	    THREAD_FLAG_UNCOUNTED, "kniagarapoll");
@@ -230,5 +230,5 @@
 	ddi_parea_register(&inbuf_parea);
 
-	outdev_t *niagara_dev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
+	outdev_t *niagara_dev = malloc(sizeof(outdev_t));
 	outdev_initialize("niagara_dev", niagara_dev, &niagara_ops);
 	stdout_wire(niagara_dev);
Index: kernel/arch/sparc64/src/drivers/pci.c
===================================================================
--- kernel/arch/sparc64/src/drivers/pci.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/arch/sparc64/src/drivers/pci.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -103,5 +103,5 @@
 		return NULL;
 
-	pci = (pci_t *) malloc(sizeof(pci_t), FRAME_ATOMIC);
+	pci = (pci_t *) malloc(sizeof(pci_t));
 	if (!pci)
 		return NULL;
@@ -145,5 +145,5 @@
 		return NULL;
 
-	pci = (pci_t *) malloc(sizeof(pci_t), FRAME_ATOMIC);
+	pci = (pci_t *) malloc(sizeof(pci_t));
 	if (!pci)
 		return NULL;
Index: kernel/genarch/src/acpi/madt.c
===================================================================
--- kernel/genarch/src/acpi/madt.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/acpi/madt.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -197,6 +197,5 @@
 	/* Create MADT APIC entries index array */
 	madt_entries_index = (struct madt_apic_header **)
-	    malloc(madt_entries_index_cnt * sizeof(struct madt_apic_header *),
-	    FRAME_ATOMIC);
+	    malloc(madt_entries_index_cnt * sizeof(struct madt_apic_header *));
 	if (!madt_entries_index)
 		panic("Memory allocation error.");
Index: kernel/genarch/src/ddi/ddi-bitmap.c
===================================================================
--- kernel/genarch/src/ddi/ddi-bitmap.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/ddi/ddi-bitmap.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -68,5 +68,5 @@
 		 */
 
-		void *store = malloc(bitmap_size(elements), FRAME_ATOMIC);
+		void *store = malloc(bitmap_size(elements));
 		if (!store)
 			return ENOMEM;
Index: kernel/genarch/src/drivers/dsrln/dsrlnin.c
===================================================================
--- kernel/genarch/src/drivers/dsrln/dsrlnin.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/drivers/dsrln/dsrlnin.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -57,5 +57,5 @@
 {
 	dsrlnin_instance_t *instance =
-	    malloc(sizeof(dsrlnin_instance_t), FRAME_ATOMIC);
+	    malloc(sizeof(dsrlnin_instance_t));
 	if (instance) {
 		instance->dsrlnin = dev;
Index: kernel/genarch/src/drivers/dsrln/dsrlnout.c
===================================================================
--- kernel/genarch/src/drivers/dsrln/dsrlnout.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/drivers/dsrln/dsrlnout.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -70,10 +70,9 @@
 outdev_t *dsrlnout_init(ioport8_t *base)
 {
-	outdev_t *dsrlndev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
+	outdev_t *dsrlndev = malloc(sizeof(outdev_t));
 	if (!dsrlndev)
 		return NULL;
 
-	dsrlnout_instance_t *instance = malloc(sizeof(dsrlnout_instance_t),
-	    FRAME_ATOMIC);
+	dsrlnout_instance_t *instance = malloc(sizeof(dsrlnout_instance_t));
 	if (!instance) {
 		free(dsrlndev);
Index: kernel/genarch/src/drivers/ega/ega.c
===================================================================
--- kernel/genarch/src/drivers/ega/ega.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/drivers/ega/ega.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -584,9 +584,9 @@
 outdev_t *ega_init(ioport8_t *base, uintptr_t addr)
 {
-	outdev_t *egadev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
+	outdev_t *egadev = malloc(sizeof(outdev_t));
 	if (!egadev)
 		return NULL;
 
-	ega_instance_t *instance = malloc(sizeof(ega_instance_t), FRAME_ATOMIC);
+	ega_instance_t *instance = malloc(sizeof(ega_instance_t));
 	if (!instance) {
 		free(egadev);
@@ -609,5 +609,5 @@
 	}
 
-	instance->backbuf = (uint8_t *) malloc(EGA_VRAM_SIZE, FRAME_ATOMIC);
+	instance->backbuf = (uint8_t *) malloc(EGA_VRAM_SIZE);
 	if (!instance->backbuf) {
 		LOG("Unable to allocate backbuffer.");
Index: kernel/genarch/src/drivers/i8042/i8042.c
===================================================================
--- kernel/genarch/src/drivers/i8042/i8042.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/drivers/i8042/i8042.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -106,5 +106,5 @@
 {
 	i8042_instance_t *instance =
-	    malloc(sizeof(i8042_instance_t), FRAME_ATOMIC);
+	    malloc(sizeof(i8042_instance_t));
 	if (instance) {
 		instance->i8042 = dev;
Index: kernel/genarch/src/drivers/ns16550/ns16550.c
===================================================================
--- kernel/genarch/src/drivers/ns16550/ns16550.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/drivers/ns16550/ns16550.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -129,5 +129,5 @@
 {
 	ns16550_instance_t *instance =
-	    malloc(sizeof(ns16550_instance_t), FRAME_ATOMIC);
+	    malloc(sizeof(ns16550_instance_t));
 	if (instance) {
 		instance->ns16550 = dev;
@@ -137,6 +137,5 @@
 
 		if (output) {
-			instance->output = malloc(sizeof(outdev_t),
-			    FRAME_ATOMIC);
+			instance->output = malloc(sizeof(outdev_t));
 			if (!instance->output) {
 				free(instance);
Index: kernel/genarch/src/drivers/pl050/pl050.c
===================================================================
--- kernel/genarch/src/drivers/pl050/pl050.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/drivers/pl050/pl050.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -77,5 +77,5 @@
 
 	pl050_instance_t *instance =
-	    malloc(sizeof(pl050_instance_t), FRAME_ATOMIC);
+	    malloc(sizeof(pl050_instance_t));
 
 	pl050 = dev;
Index: kernel/genarch/src/drivers/s3c24xx/uart.c
===================================================================
--- kernel/genarch/src/drivers/s3c24xx/uart.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/drivers/s3c24xx/uart.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -102,10 +102,10 @@
 outdev_t *s3c24xx_uart_init(uintptr_t paddr, inr_t inr)
 {
-	outdev_t *uart_dev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
+	outdev_t *uart_dev = malloc(sizeof(outdev_t));
 	if (!uart_dev)
 		return NULL;
 
 	s3c24xx_uart_t *uart =
-	    malloc(sizeof(s3c24xx_uart_t), FRAME_ATOMIC);
+	    malloc(sizeof(s3c24xx_uart_t));
 	if (!uart) {
 		free(uart_dev);
Index: kernel/genarch/src/drivers/via-cuda/cuda.c
===================================================================
--- kernel/genarch/src/drivers/via-cuda/cuda.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/drivers/via-cuda/cuda.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -91,5 +91,5 @@
 {
 	cuda_instance_t *instance =
-	    malloc(sizeof(cuda_instance_t), FRAME_ATOMIC);
+	    malloc(sizeof(cuda_instance_t));
 	if (instance) {
 		instance->cuda = dev;
Index: kernel/genarch/src/fb/fb.c
===================================================================
--- kernel/genarch/src/fb/fb.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/fb/fb.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -571,9 +571,9 @@
 	}
 
-	outdev_t *fbdev = malloc(sizeof(outdev_t), FRAME_ATOMIC);
+	outdev_t *fbdev = malloc(sizeof(outdev_t));
 	if (!fbdev)
 		return NULL;
 
-	fb_instance_t *instance = malloc(sizeof(fb_instance_t), FRAME_ATOMIC);
+	fb_instance_t *instance = malloc(sizeof(fb_instance_t));
 	if (!instance) {
 		free(fbdev);
@@ -618,5 +618,5 @@
 	}
 
-	instance->backbuf = (uint16_t *) malloc(bbsize, FRAME_ATOMIC);
+	instance->backbuf = (uint16_t *) malloc(bbsize);
 	if (!instance->backbuf) {
 		LOG("Unable to allocate backbuffer.");
@@ -626,5 +626,5 @@
 	}
 
-	instance->glyphs = (uint8_t *) malloc(glyphsize, FRAME_ATOMIC);
+	instance->glyphs = (uint8_t *) malloc(glyphsize);
 	if (!instance->glyphs) {
 		LOG("Unable to allocate glyphs.");
@@ -635,5 +635,5 @@
 	}
 
-	instance->bgscan = malloc(instance->bgscanbytes, FRAME_ATOMIC);
+	instance->bgscan = malloc(instance->bgscanbytes);
 	if (!instance->bgscan) {
 		LOG("Unable to allocate background pixel.");
Index: kernel/genarch/src/kbrd/kbrd.c
===================================================================
--- kernel/genarch/src/kbrd/kbrd.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/kbrd/kbrd.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -172,5 +172,5 @@
 {
 	kbrd_instance_t *instance =
-	    malloc(sizeof(kbrd_instance_t), FRAME_ATOMIC);
+	    malloc(sizeof(kbrd_instance_t));
 	if (instance) {
 		instance->thread = thread_create(kkbrd, (void *) instance,
Index: kernel/genarch/src/kbrd/kbrd_at.c
===================================================================
--- kernel/genarch/src/kbrd/kbrd_at.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/kbrd/kbrd_at.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -170,5 +170,5 @@
 	kbrd_instance_t *instance;
 
-	instance = malloc(sizeof(kbrd_instance_t), FRAME_ATOMIC);
+	instance = malloc(sizeof(kbrd_instance_t));
 	if (instance) {
 		instance->thread = thread_create(kkbrd, (void *) instance, TASK, 0,
Index: kernel/genarch/src/ofw/ofw_tree.c
===================================================================
--- kernel/genarch/src/ofw/ofw_tree.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/ofw/ofw_tree.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -348,5 +348,5 @@
 		return NULL;
 
-	void *dump = malloc(*size, FRAME_ATOMIC);
+	void *dump = malloc(*size);
 	if (dump == NULL) {
 		*size = 0;
@@ -386,5 +386,5 @@
 static void ofw_tree_node_sysinfo(ofw_tree_node_t *node, const char *path)
 {
-	char *cur_path = (char *) malloc(PATH_MAX_LEN, 0);
+	char *cur_path = (char *) nfmalloc(PATH_MAX_LEN);
 
 	for (ofw_tree_node_t *cur = node; cur; cur = cur->peer) {
Index: kernel/genarch/src/srln/srln.c
===================================================================
--- kernel/genarch/src/srln/srln.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/genarch/src/srln/srln.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -130,5 +130,5 @@
 {
 	srln_instance_t *instance =
-	    malloc(sizeof(srln_instance_t), FRAME_ATOMIC);
+	    malloc(sizeof(srln_instance_t));
 	if (instance) {
 		instance->thread = thread_create(ksrln, (void *) instance,
Index: kernel/generic/include/adt/fifo.h
===================================================================
--- kernel/generic/include/adt/fifo.h	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/include/adt/fifo.h	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -115,5 +115,5 @@
  */
 #define fifo_create(name) \
-	name.fifo = malloc(sizeof(*name.fifo) * name.items, 0)
+	name.fifo = nfmalloc(sizeof(*name.fifo) * name.items)
 
 #endif
Index: kernel/generic/include/mm/slab.h
===================================================================
--- kernel/generic/include/mm/slab.h	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/include/mm/slab.h	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -140,9 +140,12 @@
 
 /* malloc support */
-extern void *malloc(size_t, unsigned int)
+extern void *malloc(size_t)
     __attribute__((malloc));
-extern void *realloc(void *, size_t, unsigned int)
+extern void *realloc(void *, size_t)
     __attribute__((warn_unused_result));
 extern void free(void *);
+
+extern void *nfmalloc(size_t)
+    __attribute__((malloc, returns_nonnull));
 
 #endif
Index: kernel/generic/include/synch/rcu.h
===================================================================
--- kernel/generic/include/synch/rcu.h	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/include/synch/rcu.h	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -55,5 +55,5 @@
  *
  * // Insert at the beginning of the list.
- * exam_t *my_exam = malloc(sizeof(exam_t), FRAME_ATOMIC);
+ * exam_t *my_exam = malloc(sizeof(exam_t));
  * my_exam->grade = 5;
  * my_exam->next = exam_list;
Index: kernel/generic/src/adt/cht.c
===================================================================
--- kernel/generic/src/adt/cht.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/adt/cht.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -573,5 +573,5 @@
 	size_t bytes =
 	    sizeof(cht_buckets_t) + (bucket_cnt - 1) * sizeof(marked_ptr_t);
-	cht_buckets_t *b = malloc(bytes, can_block ? 0 : FRAME_ATOMIC);
+	cht_buckets_t *b = can_block ? nfmalloc(bytes) : malloc(bytes);
 
 	if (!b)
Index: kernel/generic/src/adt/hash_table.c
===================================================================
--- kernel/generic/src/adt/hash_table.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/adt/hash_table.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -401,5 +401,5 @@
 	assert(pbuckets && HT_MIN_BUCKETS <= bucket_cnt);
 
-	list_t *buckets = malloc(bucket_cnt * sizeof(list_t), FRAME_ATOMIC);
+	list_t *buckets = malloc(bucket_cnt * sizeof(list_t));
 	if (!buckets)
 		return false;
Index: kernel/generic/src/cap/cap.c
===================================================================
--- kernel/generic/src/cap/cap.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/cap/cap.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -126,6 +126,5 @@
 errno_t caps_task_alloc(task_t *task)
 {
-	task->cap_info = (cap_info_t *) malloc(sizeof(cap_info_t),
-	    FRAME_ATOMIC);
+	task->cap_info = (cap_info_t *) malloc(sizeof(cap_info_t));
 	if (!task->cap_info)
 		return ENOMEM;
Index: kernel/generic/src/console/cmd.c
===================================================================
--- kernel/generic/src/console/cmd.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/console/cmd.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -1465,6 +1465,5 @@
 		return true;
 
-	uint64_t *data = (uint64_t *) malloc(sizeof(uint64_t) * cnt,
-	    FRAME_ATOMIC);
+	uint64_t *data = (uint64_t *) malloc(sizeof(uint64_t) * cnt);
 	if (data == NULL) {
 		printf("Error allocating memory for statistics\n");
Index: kernel/generic/src/console/console.c
===================================================================
--- kernel/generic/src/console/console.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/console/console.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -411,5 +411,5 @@
 
 	if (size > 0) {
-		data = (char *) malloc(size + 1, FRAME_ATOMIC);
+		data = (char *) malloc(size + 1);
 		if (!data)
 			return (sys_errno_t) ENOMEM;
Index: kernel/generic/src/console/kconsole.c
===================================================================
--- kernel/generic/src/console/kconsole.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/console/kconsole.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -219,5 +219,5 @@
 	const char *hint;
 	const char *help;
-	char *output = malloc(MAX_CMDLINE, 0);
+	char *output = nfmalloc(MAX_CMDLINE);
 	size_t hints_to_show = MAX_TAB_HINTS - 1;
 	size_t total_hints_shown = 0;
@@ -298,5 +298,5 @@
 		end++;
 
-	tmp = malloc(STR_BOUNDS(end - start + 1), FRAME_ATOMIC);
+	tmp = malloc(STR_BOUNDS(end - start + 1));
 	if (!tmp)
 		return NULL;
@@ -332,5 +332,5 @@
 	wchar_t *current = history[history_pos];
 	current[0] = 0;
-	char *tmp = malloc(STR_BOUNDS(MAX_CMDLINE), 0);
+	char *tmp = nfmalloc(STR_BOUNDS(MAX_CMDLINE));
 
 	while (true) {
@@ -810,5 +810,5 @@
 		printf("Type \"exit\" to leave the console.\n");
 
-	char *cmdline = malloc(STR_BOUNDS(MAX_CMDLINE), 0);
+	char *cmdline = nfmalloc(STR_BOUNDS(MAX_CMDLINE));
 	while (true) {
 		wchar_t *tmp = clever_readline((char *) prompt, stdin);
Index: kernel/generic/src/cpu/cpu.c
===================================================================
--- kernel/generic/src/cpu/cpu.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/cpu/cpu.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -65,6 +65,5 @@
 #endif /* CONFIG_SMP */
 
-		cpus = (cpu_t *) malloc(sizeof(cpu_t) * config.cpu_count,
-		    FRAME_ATOMIC);
+		cpus = (cpu_t *) malloc(sizeof(cpu_t) * config.cpu_count);
 		if (!cpus)
 			panic("Cannot allocate CPU structures.");
Index: kernel/generic/src/ipc/ipc.c
===================================================================
--- kernel/generic/src/ipc/ipc.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/ipc/ipc.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -118,5 +118,11 @@
 	if (!call)
 		return NULL;
-	kobject_t *kobj = (kobject_t *) malloc(sizeof(kobject_t), flags);
+
+	kobject_t *kobj;
+	if (flags & FRAME_ATOMIC)
+		kobj = (kobject_t *) malloc(sizeof(kobject_t));
+	else
+		kobj = (kobject_t *) nfmalloc(sizeof(kobject_t));
+
 	if (!kobj) {
 		slab_free(call_cache, call);
Index: kernel/generic/src/ipc/ipcrsc.c
===================================================================
--- kernel/generic/src/ipc/ipcrsc.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/ipc/ipcrsc.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -168,5 +168,5 @@
 			return ENOMEM;
 		}
-		kobject_t *kobj = malloc(sizeof(kobject_t), FRAME_ATOMIC);
+		kobject_t *kobj = malloc(sizeof(kobject_t));
 		if (!kobj) {
 			cap_free(TASK, handle);
Index: kernel/generic/src/ipc/irq.c
===================================================================
--- kernel/generic/src/ipc/irq.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/ipc/irq.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -82,5 +82,5 @@
 {
 	/* Copy the physical base addresses aside. */
-	uintptr_t *pbase = malloc(rangecount * sizeof(uintptr_t), FRAME_ATOMIC);
+	uintptr_t *pbase = malloc(rangecount * sizeof(uintptr_t));
 	if (!pbase)
 		return ENOMEM;
@@ -227,5 +227,5 @@
 	irq_cmd_t *cmds = NULL;
 
-	irq_code_t *code = malloc(sizeof(*code), FRAME_ATOMIC);
+	irq_code_t *code = malloc(sizeof(*code));
 	if (!code)
 		return NULL;
@@ -238,6 +238,5 @@
 		goto error;
 
-	ranges = malloc(sizeof(code->ranges[0]) * code->rangecount,
-	    FRAME_ATOMIC);
+	ranges = malloc(sizeof(code->ranges[0]) * code->rangecount);
 	if (!ranges)
 		goto error;
@@ -247,5 +246,5 @@
 		goto error;
 
-	cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount, FRAME_ATOMIC);
+	cmds = malloc(sizeof(code->cmds[0]) * code->cmdcount);
 	if (!cmds)
 		goto error;
@@ -356,5 +355,5 @@
 	}
 
-	kobject_t *kobject = malloc(sizeof(kobject_t), FRAME_ATOMIC);
+	kobject_t *kobject = malloc(sizeof(kobject_t));
 	if (!kobject) {
 		cap_free(TASK, handle);
Index: kernel/generic/src/ipc/ops/dataread.c
===================================================================
--- kernel/generic/src/ipc/ops/dataread.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/ipc/ops/dataread.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -75,5 +75,5 @@
 			IPC_SET_ARG1(answer->data, dst);
 
-			answer->buffer = malloc(size, FRAME_ATOMIC);
+			answer->buffer = malloc(size);
 			if (!answer->buffer) {
 				IPC_SET_RETVAL(answer->data, ENOMEM);
Index: kernel/generic/src/ipc/ops/datawrite.c
===================================================================
--- kernel/generic/src/ipc/ops/datawrite.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/ipc/ops/datawrite.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -56,5 +56,5 @@
 	}
 
-	call->buffer = (uint8_t *) malloc(size, FRAME_ATOMIC);
+	call->buffer = (uint8_t *) malloc(size);
 	if (!call->buffer)
 		return ENOMEM;
Index: kernel/generic/src/lib/gsort.c
===================================================================
--- kernel/generic/src/lib/gsort.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/lib/gsort.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -111,5 +111,5 @@
 
 	if (elem_size > IBUF_SIZE) {
-		slot = (void *) malloc(elem_size, FRAME_ATOMIC);
+		slot = (void *) malloc(elem_size);
 		if (!slot)
 			return false;
Index: kernel/generic/src/lib/ra.c
===================================================================
--- kernel/generic/src/lib/ra.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/lib/ra.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -124,5 +124,5 @@
 	unsigned int i;
 
-	span = (ra_span_t *) malloc(sizeof(ra_span_t), FRAME_ATOMIC);
+	span = (ra_span_t *) malloc(sizeof(ra_span_t));
 	if (!span)
 		return NULL;
@@ -132,6 +132,5 @@
 	span->size = size;
 
-	span->free = (list_t *) malloc((span->max_order + 1) * sizeof(list_t),
-	    FRAME_ATOMIC);
+	span->free = (list_t *) malloc((span->max_order + 1) * sizeof(list_t));
 	if (!span->free) {
 		free(span);
@@ -205,5 +204,5 @@
 	ra_arena_t *arena;
 
-	arena = (ra_arena_t *) malloc(sizeof(ra_arena_t), FRAME_ATOMIC);
+	arena = (ra_arena_t *) malloc(sizeof(ra_arena_t));
 	if (!arena)
 		return NULL;
Index: kernel/generic/src/lib/str.c
===================================================================
--- kernel/generic/src/lib/str.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/lib/str.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -634,5 +634,5 @@
 {
 	size_t size = str_size(src) + 1;
-	char *dest = malloc(size, 0);
+	char *dest = nfmalloc(size);
 	assert(dest);
 
@@ -667,5 +667,5 @@
 		size = n;
 
-	char *dest = malloc(size + 1, 0);
+	char *dest = nfmalloc(size + 1);
 	assert(dest);
 
Index: kernel/generic/src/log/log.c
===================================================================
--- kernel/generic/src/log/log.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/log/log.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -307,5 +307,5 @@
 	switch (operation) {
 	case KLOG_WRITE:
-		data = (char *) malloc(size + 1, FRAME_ATOMIC);
+		data = (char *) malloc(size + 1);
 		if (!data)
 			return (sys_errno_t) ENOMEM;
@@ -326,5 +326,5 @@
 		return EOK;
 	case KLOG_READ:
-		data = (char *) malloc(size, FRAME_ATOMIC);
+		data = (char *) malloc(size);
 		if (!data)
 			return (sys_errno_t) ENOMEM;
Index: kernel/generic/src/main/kinit.c
===================================================================
--- kernel/generic/src/main/kinit.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/main/kinit.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -209,5 +209,5 @@
 		size_t arguments_size = str_size(arguments);
 
-		void *arguments_copy = malloc(arguments_size, FRAME_ATOMIC);
+		void *arguments_copy = malloc(arguments_size);
 		if (arguments_copy == NULL)
 			continue;
Index: kernel/generic/src/mm/as.c
===================================================================
--- kernel/generic/src/mm/as.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/mm/as.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -620,5 +620,5 @@
 	}
 
-	as_area_t *area = (as_area_t *) malloc(sizeof(as_area_t), FRAME_ATOMIC);
+	as_area_t *area = (as_area_t *) malloc(sizeof(as_area_t));
 	if (!area) {
 		mutex_unlock(&as->lock);
@@ -650,6 +650,5 @@
 	 */
 	if (!(attrs & AS_AREA_ATTR_PARTIAL)) {
-		si = (share_info_t *) malloc(sizeof(share_info_t),
-		    FRAME_ATOMIC);
+		si = (share_info_t *) malloc(sizeof(share_info_t));
 		if (!si) {
 			free(area);
@@ -1302,6 +1301,5 @@
 
 	/* An array for storing frame numbers */
-	uintptr_t *old_frame = malloc(used_pages * sizeof(uintptr_t),
-	    FRAME_ATOMIC);
+	uintptr_t *old_frame = malloc(used_pages * sizeof(uintptr_t));
 	if (!old_frame) {
 		mutex_unlock(&area->lock);
@@ -2260,5 +2258,5 @@
 
 	size_t isize = area_cnt * sizeof(as_area_info_t);
-	as_area_info_t *info = malloc(isize, 0);
+	as_area_info_t *info = nfmalloc(isize);
 
 	/* Second pass, record data. */
Index: kernel/generic/src/mm/backend_phys.c
===================================================================
--- kernel/generic/src/mm/backend_phys.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/mm/backend_phys.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -160,6 +160,5 @@
 		phys_shared_data_t *data;
 
-		data = (phys_shared_data_t *) malloc(sizeof(*data),
-		    FRAME_ATOMIC);
+		data = (phys_shared_data_t *) malloc(sizeof(*data));
 		if (!data)
 			return false;
Index: kernel/generic/src/mm/slab.c
===================================================================
--- kernel/generic/src/mm/slab.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/mm/slab.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -954,5 +954,5 @@
 }
 
-void *malloc(size_t size, unsigned int flags)
+static void *_malloc(size_t size, unsigned int flags)
 {
 	assert(_slab_initialized);
@@ -967,5 +967,18 @@
 }
 
-void *realloc(void *ptr, size_t size, unsigned int flags)
+void *malloc(size_t size)
+{
+	return _malloc(size, FRAME_ATOMIC);
+}
+
+/** Non-failing malloc.
+ *  Never returns NULL, but may block forever if no memory is available.
+ */
+void *nfmalloc(size_t size)
+{
+	return _malloc(size, 0);
+}
+
+static void *_realloc(void *ptr, size_t size, unsigned int flags)
 {
 	assert(_slab_initialized);
@@ -994,4 +1007,9 @@
 }
 
+void *realloc(void *ptr, size_t size)
+{
+	return _realloc(ptr, size, FRAME_ATOMIC);
+}
+
 void free(void *ptr)
 {
Index: kernel/generic/src/proc/program.c
===================================================================
--- kernel/generic/src/proc/program.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/proc/program.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -72,5 +72,5 @@
 {
 	uspace_arg_t *kernel_uarg = (uspace_arg_t *)
-	    malloc(sizeof(uspace_arg_t), FRAME_ATOMIC);
+	    malloc(sizeof(uspace_arg_t));
 	if (!kernel_uarg)
 		return ENOMEM;
Index: kernel/generic/src/proc/thread.c
===================================================================
--- kernel/generic/src/proc/thread.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/proc/thread.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -949,5 +949,5 @@
 	 */
 	uspace_arg_t *kernel_uarg =
-	    (uspace_arg_t *) malloc(sizeof(uspace_arg_t), FRAME_ATOMIC);
+	    (uspace_arg_t *) malloc(sizeof(uspace_arg_t));
 	if (!kernel_uarg)
 		return (sys_errno_t) ENOMEM;
Index: kernel/generic/src/synch/futex.c
===================================================================
--- kernel/generic/src/synch/futex.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/synch/futex.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -156,5 +156,5 @@
 void futex_task_init(struct task *task)
 {
-	task->futexes = malloc(sizeof(struct futex_cache), 0);
+	task->futexes = nfmalloc(sizeof(struct futex_cache));
 
 	cht_create(&task->futexes->ht, 0, 0, 0, true, &task_futex_ht_ops);
@@ -339,5 +339,5 @@
 static futex_t *get_and_cache_futex(uintptr_t phys_addr, uintptr_t uaddr)
 {
-	futex_t *futex = malloc(sizeof(futex_t), FRAME_ATOMIC);
+	futex_t *futex = malloc(sizeof(futex_t));
 	if (!futex)
 		return NULL;
@@ -365,5 +365,5 @@
 	 * Cache the link to the futex object for this task.
 	 */
-	futex_ptr_t *fut_ptr = malloc(sizeof(futex_ptr_t), FRAME_ATOMIC);
+	futex_ptr_t *fut_ptr = malloc(sizeof(futex_ptr_t));
 	if (!fut_ptr) {
 		spinlock_lock(&futex_ht_lock);
Index: kernel/generic/src/synch/workqueue.c
===================================================================
--- kernel/generic/src/synch/workqueue.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/synch/workqueue.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -187,6 +187,5 @@
 struct work_queue *workq_create(const char *name)
 {
-	struct work_queue *workq = malloc(sizeof(struct work_queue),
-	    FRAME_ATOMIC);
+	struct work_queue *workq = malloc(sizeof(struct work_queue));
 	if (!workq)
 		return NULL;
Index: kernel/generic/src/sysinfo/stats.c
===================================================================
--- kernel/generic/src/sysinfo/stats.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/sysinfo/stats.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -101,5 +101,5 @@
 
 	/* Assumption: config.cpu_count is constant */
-	stats_cpu_t *stats_cpus = (stats_cpu_t *) malloc(*size, FRAME_ATOMIC);
+	stats_cpu_t *stats_cpus = (stats_cpu_t *) malloc(*size);
 	if (stats_cpus == NULL) {
 		*size = 0;
@@ -307,5 +307,5 @@
 	}
 
-	stats_task_t *stats_tasks = (stats_task_t *) malloc(*size, FRAME_ATOMIC);
+	stats_task_t *stats_tasks = (stats_task_t *) malloc(*size);
 	if (stats_tasks == NULL) {
 		/* No free space for allocation */
@@ -413,5 +413,5 @@
 	}
 
-	stats_thread_t *stats_threads = (stats_thread_t *) malloc(*size, FRAME_ATOMIC);
+	stats_thread_t *stats_threads = (stats_thread_t *) malloc(*size);
 	if (stats_threads == NULL) {
 		/* No free space for allocation */
@@ -479,5 +479,5 @@
 		/* Allocate stats_task_t structure */
 		stats_task_t *stats_task =
-		    (stats_task_t *) malloc(sizeof(stats_task_t), FRAME_ATOMIC);
+		    (stats_task_t *) malloc(sizeof(stats_task_t));
 		if (stats_task == NULL) {
 			irq_spinlock_unlock(&tasks_lock, true);
@@ -550,5 +550,5 @@
 		/* Allocate stats_thread_t structure */
 		stats_thread_t *stats_thread =
-		    (stats_thread_t *) malloc(sizeof(stats_thread_t), FRAME_ATOMIC);
+		    (stats_thread_t *) malloc(sizeof(stats_thread_t));
 		if (stats_thread == NULL) {
 			irq_spinlock_unlock(&threads_lock, true);
@@ -592,5 +592,5 @@
 
 	stats_exc_t *stats_exceptions =
-	    (stats_exc_t *) malloc(*size, FRAME_ATOMIC);
+	    (stats_exc_t *) malloc(*size);
 	if (stats_exceptions == NULL) {
 		/* No free space for allocation */
@@ -670,5 +670,5 @@
 		/* Allocate stats_exc_t structure */
 		stats_exc_t *stats_exception =
-		    (stats_exc_t *) malloc(sizeof(stats_exc_t), FRAME_ATOMIC);
+		    (stats_exc_t *) malloc(sizeof(stats_exc_t));
 		if (stats_exception == NULL)
 			return ret;
@@ -713,5 +713,5 @@
 
 	stats_physmem_t *stats_physmem =
-	    (stats_physmem_t *) malloc(*size, FRAME_ATOMIC);
+	    (stats_physmem_t *) malloc(*size);
 	if (stats_physmem == NULL) {
 		*size = 0;
@@ -743,5 +743,5 @@
 		return NULL;
 
-	load_t *stats_load = (load_t *) malloc(*size, FRAME_ATOMIC);
+	load_t *stats_load = (load_t *) malloc(*size);
 	if (stats_load == NULL) {
 		*size = 0;
Index: kernel/generic/src/sysinfo/sysinfo.c
===================================================================
--- kernel/generic/src/sysinfo/sysinfo.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/sysinfo/sysinfo.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -649,5 +649,5 @@
 		return ret;
 
-	char *path = (char *) malloc(size + 1, 0);
+	char *path = (char *) nfmalloc(size + 1);
 	assert(path);
 
@@ -716,5 +716,5 @@
 		} else {
 			/* Allocate buffer for subkeys */
-			char *names = (char *) malloc(size, FRAME_ATOMIC);
+			char *names = (char *) malloc(size);
 			if (names == NULL)
 				return ret;
@@ -758,5 +758,5 @@
 		return ret;
 
-	char *path = (char *) malloc(size + 1, 0);
+	char *path = (char *) nfmalloc(size + 1);
 	assert(path);
 
Index: kernel/generic/src/udebug/udebug_ops.c
===================================================================
--- kernel/generic/src/udebug/udebug_ops.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/generic/src/udebug/udebug_ops.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -370,5 +370,5 @@
 
 	/* Allocate a buffer to hold thread IDs */
-	sysarg_t *id_buffer = malloc(buf_size + 1, FRAME_ATOMIC);
+	sysarg_t *id_buffer = malloc(buf_size + 1);
 	if (!id_buffer)
 		return ENOMEM;
@@ -434,5 +434,5 @@
 	size_t name_size = str_size(TASK->name) + 1;
 
-	*data = malloc(name_size, FRAME_ATOMIC);
+	*data = malloc(name_size);
 	if (!*data)
 		return ENOMEM;
@@ -476,5 +476,5 @@
 
 	/* Prepare a buffer to hold the arguments. */
-	sysarg_t *arg_buffer = malloc(6 * sizeof(sysarg_t), FRAME_ATOMIC);
+	sysarg_t *arg_buffer = malloc(6 * sizeof(sysarg_t));
 	if (!arg_buffer) {
 		_thread_op_end(thread);
@@ -522,5 +522,5 @@
 
 	/* Prepare a buffer to hold the data. */
-	istate_t *state_buf = malloc(sizeof(istate_t), FRAME_ATOMIC);
+	istate_t *state_buf = malloc(sizeof(istate_t));
 	if (!state_buf) {
 		_thread_op_end(thread);
@@ -558,5 +558,5 @@
 	}
 
-	void *data_buffer = malloc(n, FRAME_ATOMIC);
+	void *data_buffer = malloc(n);
 	if (!data_buffer) {
 		mutex_unlock(&TASK->udebug.lock);
Index: kernel/test/cht/cht1.c
===================================================================
--- kernel/test/cht/cht1.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/test/cht/cht1.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -110,5 +110,5 @@
 
 	for (int i = 0; i < val_cnt; ++i)
-		v[i] = malloc(sizeof(val_t), 0);
+		v[i] = nfmalloc(sizeof(val_t));
 
 	size_t key[] = { 1, 1, 1, 11, 12, 13 };
@@ -316,5 +316,5 @@
 		TPRINTF("I{");
 		for (size_t i = 0; i < work->wave_elems; ++i) {
-			stress_t *s = malloc(sizeof(stress_t), FRAME_ATOMIC);
+			stress_t *s = malloc(sizeof(stress_t));
 			if (!s) {
 				TPRINTF("[out-of-mem]\n");
@@ -473,5 +473,5 @@
 
 	TPRINTF("Alloc and init table items. \n");
-	void *p = malloc(size, FRAME_ATOMIC);
+	void *p = malloc(size);
 	if (!p) {
 		TPRINTF("Failed to alloc items\n");
Index: kernel/test/mm/falloc1.c
===================================================================
--- kernel/test/mm/falloc1.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/test/mm/falloc1.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -47,5 +47,5 @@
 
 	uintptr_t *frames = (uintptr_t *)
-	    malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC);
+	    malloc(MAX_FRAMES * sizeof(uintptr_t));
 	if (frames == NULL)
 		return "Unable to allocate frames";
Index: kernel/test/mm/falloc2.c
===================================================================
--- kernel/test/mm/falloc2.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/test/mm/falloc2.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -53,5 +53,5 @@
 
 	uintptr_t *frames = (uintptr_t *)
-	    malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC);
+	    malloc(MAX_FRAMES * sizeof(uintptr_t));
 	if (frames == NULL) {
 		TPRINTF("Thread #%" PRIu64 " (cpu%u): "
Index: kernel/test/synch/rcu1.c
===================================================================
--- kernel/test/synch/rcu1.c	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/test/synch/rcu1.c	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -251,6 +251,6 @@
 {
 	for (int i = 0; i < nop_updater_iters; i += 2) {
-		rcu_item_t *a = malloc(sizeof(rcu_item_t), FRAME_ATOMIC);
-		rcu_item_t *b = malloc(sizeof(rcu_item_t), FRAME_ATOMIC);
+		rcu_item_t *a = malloc(sizeof(rcu_item_t));
+		rcu_item_t *b = malloc(sizeof(rcu_item_t));
 
 		if (a && b) {
@@ -315,5 +315,5 @@
 	rcu_read_lock();
 
-	item_w_cookie_t *item = malloc(sizeof(item_w_cookie_t), FRAME_ATOMIC);
+	item_w_cookie_t *item = malloc(sizeof(item_w_cookie_t));
 
 	if (item) {
@@ -420,6 +420,6 @@
 		/* Updater */
 		for (size_t i = 0; i < work->update_cnt; ++i) {
-			seq_item_t *a = malloc(sizeof(seq_item_t), FRAME_ATOMIC);
-			seq_item_t *b = malloc(sizeof(seq_item_t), FRAME_ATOMIC);
+			seq_item_t *a = malloc(sizeof(seq_item_t));
+			seq_item_t *b = malloc(sizeof(seq_item_t));
 
 			if (a && b) {
@@ -523,5 +523,5 @@
 	TPRINTF("\nReader exits thread with rcu_lock\n");
 
-	exited_t *p = malloc(sizeof(exited_t), FRAME_ATOMIC);
+	exited_t *p = malloc(sizeof(exited_t));
 	if (!p) {
 		TPRINTF("[out-of-mem]\n");
@@ -686,5 +686,5 @@
 static bool do_one_reader_preempt(void (*f)(void *), const char *err)
 {
-	preempt_t *p = malloc(sizeof(preempt_t), FRAME_ATOMIC);
+	preempt_t *p = malloc(sizeof(preempt_t));
 	if (!p) {
 		TPRINTF("[out-of-mem]\n");
@@ -777,5 +777,5 @@
 	TPRINTF("\nSynchronize with long reader\n");
 
-	synch_t *synch = malloc(sizeof(synch_t), FRAME_ATOMIC);
+	synch_t *synch = malloc(sizeof(synch_t));
 
 	if (!synch) {
@@ -828,5 +828,5 @@
 	TPRINTF("\nrcu_barrier: Wait for outstanding rcu callbacks to complete\n");
 
-	barrier_t *barrier = malloc(sizeof(barrier_t), FRAME_ATOMIC);
+	barrier_t *barrier = malloc(sizeof(barrier_t));
 
 	if (!barrier) {
@@ -886,5 +886,5 @@
 
 	for (size_t i = 0; i < s->iters; ++i) {
-		rcu_item_t *item = malloc(sizeof(rcu_item_t), FRAME_ATOMIC);
+		rcu_item_t *item = malloc(sizeof(rcu_item_t));
 
 		if (item) {
Index: kernel/test/synch/workq-test-core.h
===================================================================
--- kernel/test/synch/workq-test-core.h	(revision 8a1be7692f8710c1044d21f081dc5cffc0d5c33d)
+++ kernel/test/synch/workq-test-core.h	(revision f134413fa55addfb59fcf058f5aa96cdc941f065)
@@ -72,5 +72,5 @@
 static test_work_t *create_child(test_work_t *work)
 {
-	test_work_t *child = malloc(sizeof(test_work_t), 0);
+	test_work_t *child = nfmalloc(sizeof(test_work_t));
 	assert(child);
 	if (child) {
@@ -152,5 +152,5 @@
 	}
 
-	test_work_t *work = malloc(sizeof(test_work_t), 0);
+	test_work_t *work = nfmalloc(sizeof(test_work_t));
 
 	work->master = true;