Index: kernel/generic/src/mm/as.c
===================================================================
--- kernel/generic/src/mm/as.c	(revision c259b9bf9d0bc763cf915da58c8b182bd0170faf)
+++ kernel/generic/src/mm/as.c	(revision 8bfe48e81c36cb4f2aef628c058c67d0583b320b)
@@ -419,6 +419,6 @@
 			if ((cond = (bool) node->keys)) {
 				uintptr_t b = node->key[node->keys - 1];
-				count_t c =
-				    (count_t) node->value[node->keys - 1];
+				size_t c =
+				    (size_t) node->value[node->keys - 1];
 				unsigned int i = 0;
 			
@@ -556,8 +556,8 @@
 		for (i = 0; i < node->keys; i++) {
 			uintptr_t b = node->key[i];
-			count_t j;
+			size_t j;
 			pte_t *pte;
 			
-			for (j = 0; j < (count_t) node->value[i]; j++) {
+			for (j = 0; j < (size_t) node->value[i]; j++) {
 				page_table_lock(as, false);
 				pte = page_mapping_find(as, b + j * PAGE_SIZE);
@@ -789,6 +789,6 @@
 	int page_flags;
 	uintptr_t *old_frame;
-	index_t frame_idx;
-	count_t used_pages;
+	size_t frame_idx;
+	size_t used_pages;
 	
 	/* Flags for the new memory mapping */
@@ -828,5 +828,5 @@
 		node = list_get_instance(cur, btree_node_t, leaf_link);
 		for (i = 0; i < node->keys; i++) {
-			used_pages += (count_t) node->value[i];
+			used_pages += (size_t) node->value[i];
 		}
 	}
@@ -854,8 +854,8 @@
 		for (i = 0; i < node->keys; i++) {
 			uintptr_t b = node->key[i];
-			count_t j;
+			size_t j;
 			pte_t *pte;
 			
-			for (j = 0; j < (count_t) node->value[i]; j++) {
+			for (j = 0; j < (size_t) node->value[i]; j++) {
 				page_table_lock(as, false);
 				pte = page_mapping_find(as, b + j * PAGE_SIZE);
@@ -904,7 +904,7 @@
 		for (i = 0; i < node->keys; i++) {
 			uintptr_t b = node->key[i];
-			count_t j;
+			size_t j;
 			
-			for (j = 0; j < (count_t) node->value[i]; j++) {
+			for (j = 0; j < (size_t) node->value[i]; j++) {
 				page_table_lock(as, false);
 
@@ -1398,8 +1398,8 @@
  * @return		Zero on failure and non-zero on success.
  */
-int used_space_insert(as_area_t *a, uintptr_t page, count_t count)
+int used_space_insert(as_area_t *a, uintptr_t page, size_t count)
 {
 	btree_node_t *leaf, *node;
-	count_t pages;
+	size_t pages;
 	unsigned int i;
 
@@ -1407,5 +1407,5 @@
 	ASSERT(count);
 
-	pages = (count_t) btree_search(&a->used_space, page, &leaf);
+	pages = (size_t) btree_search(&a->used_space, page, &leaf);
 	if (pages) {
 		/*
@@ -1424,6 +1424,6 @@
 		uintptr_t left_pg = node->key[node->keys - 1];
 		uintptr_t right_pg = leaf->key[0];
-		count_t left_cnt = (count_t) node->value[node->keys - 1];
-		count_t right_cnt = (count_t) leaf->value[0];
+		size_t left_cnt = (size_t) node->value[node->keys - 1];
+		size_t right_cnt = (size_t) leaf->value[0];
 		
 		/*
@@ -1479,5 +1479,5 @@
 	} else if (page < leaf->key[0]) {
 		uintptr_t right_pg = leaf->key[0];
-		count_t right_cnt = (count_t) leaf->value[0];
+		size_t right_cnt = (size_t) leaf->value[0];
 	
 		/*
@@ -1514,6 +1514,6 @@
 		uintptr_t left_pg = leaf->key[leaf->keys - 1];
 		uintptr_t right_pg = node->key[0];
-		count_t left_cnt = (count_t) leaf->value[leaf->keys - 1];
-		count_t right_cnt = (count_t) node->value[0];
+		size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
+		size_t right_cnt = (size_t) node->value[0];
 		
 		/*
@@ -1569,5 +1569,5 @@
 	} else if (page >= leaf->key[leaf->keys - 1]) {
 		uintptr_t left_pg = leaf->key[leaf->keys - 1];
-		count_t left_cnt = (count_t) leaf->value[leaf->keys - 1];
+		size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
 	
 		/*
@@ -1607,6 +1607,6 @@
 			uintptr_t left_pg = leaf->key[i - 1];
 			uintptr_t right_pg = leaf->key[i];
-			count_t left_cnt = (count_t) leaf->value[i - 1];
-			count_t right_cnt = (count_t) leaf->value[i];
+			size_t left_cnt = (size_t) leaf->value[i - 1];
+			size_t right_cnt = (size_t) leaf->value[i];
 
 			/*
@@ -1666,5 +1666,5 @@
 	}
 
-	panic("Inconsistency detected while adding %" PRIc " pages of used "
+	panic("Inconsistency detected while adding %" PRIs " pages of used "
 	    "space at %p.", count, page);
 }
@@ -1680,8 +1680,8 @@
  * @return		Zero on failure and non-zero on success.
  */
-int used_space_remove(as_area_t *a, uintptr_t page, count_t count)
+int used_space_remove(as_area_t *a, uintptr_t page, size_t count)
 {
 	btree_node_t *leaf, *node;
-	count_t pages;
+	size_t pages;
 	unsigned int i;
 
@@ -1689,5 +1689,5 @@
 	ASSERT(count);
 
-	pages = (count_t) btree_search(&a->used_space, page, &leaf);
+	pages = (size_t) btree_search(&a->used_space, page, &leaf);
 	if (pages) {
 		/*
@@ -1718,5 +1718,5 @@
 	if (node && page < leaf->key[0]) {
 		uintptr_t left_pg = node->key[node->keys - 1];
-		count_t left_cnt = (count_t) node->value[node->keys - 1];
+		size_t left_cnt = (size_t) node->value[node->keys - 1];
 
 		if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,
@@ -1734,5 +1734,5 @@
 			} else if (page + count * PAGE_SIZE <
 			    left_pg + left_cnt*PAGE_SIZE) {
-				count_t new_cnt;
+				size_t new_cnt;
 				
 				/*
@@ -1758,5 +1758,5 @@
 	if (page > leaf->key[leaf->keys - 1]) {
 		uintptr_t left_pg = leaf->key[leaf->keys - 1];
-		count_t left_cnt = (count_t) leaf->value[leaf->keys - 1];
+		size_t left_cnt = (size_t) leaf->value[leaf->keys - 1];
 
 		if (overlaps(left_pg, left_cnt * PAGE_SIZE, page,
@@ -1773,5 +1773,5 @@
 			} else if (page + count * PAGE_SIZE < left_pg +
 			    left_cnt * PAGE_SIZE) {
-				count_t new_cnt;
+				size_t new_cnt;
 				
 				/*
@@ -1800,5 +1800,5 @@
 		if (page < leaf->key[i]) {
 			uintptr_t left_pg = leaf->key[i - 1];
-			count_t left_cnt = (count_t) leaf->value[i - 1];
+			size_t left_cnt = (size_t) leaf->value[i - 1];
 
 			/*
@@ -1820,5 +1820,5 @@
 				} else if (page + count * PAGE_SIZE <
 				    left_pg + left_cnt * PAGE_SIZE) {
-					count_t new_cnt;
+					size_t new_cnt;
 				
 					/*
@@ -1845,5 +1845,5 @@
 
 error:
-	panic("Inconsistency detected while removing %" PRIc " pages of used "
+	panic("Inconsistency detected while removing %" PRIs " pages of used "
 	    "space from %p.", count, page);
 }
@@ -1944,5 +1944,5 @@
 		
 			mutex_lock(&area->lock);
-			printf("as_area: %p, base=%p, pages=%" PRIc
+			printf("as_area: %p, base=%p, pages=%" PRIs
 			    " (%p - %p)\n", area, area->base, area->pages,
 			    area->base, area->base + FRAMES2SIZE(area->pages));
Index: kernel/generic/src/mm/backend_anon.c
===================================================================
--- kernel/generic/src/mm/backend_anon.c	(revision c259b9bf9d0bc763cf915da58c8b182bd0170faf)
+++ kernel/generic/src/mm/backend_anon.c	(revision 8bfe48e81c36cb4f2aef628c058c67d0583b320b)
@@ -196,5 +196,5 @@
 		for (i = 0; i < node->keys; i++) {
 			uintptr_t base = node->key[i];
-			count_t count = (count_t) node->value[i];
+			size_t count = (size_t) node->value[i];
 			unsigned int j;
 			
Index: kernel/generic/src/mm/backend_elf.c
===================================================================
--- kernel/generic/src/mm/backend_elf.c	(revision c259b9bf9d0bc763cf915da58c8b182bd0170faf)
+++ kernel/generic/src/mm/backend_elf.c	(revision 8bfe48e81c36cb4f2aef628c058c67d0583b320b)
@@ -83,5 +83,5 @@
 	btree_node_t *leaf;
 	uintptr_t base, frame, page, start_anon;
-	index_t i;
+	size_t i;
 	bool dirty = false;
 
@@ -235,5 +235,5 @@
 	elf_segment_header_t *entry = area->backend_data.segment;
 	uintptr_t base, start_anon;
-	index_t i;
+	size_t i;
 
 	ASSERT((page >= ALIGN_DOWN(entry->p_vaddr, PAGE_SIZE)) &&
@@ -305,5 +305,5 @@
 		for (i = 0; i < node->keys; i++) {
 			uintptr_t base = node->key[i];
-			count_t count = (count_t) node->value[i];
+			size_t count = (size_t) node->value[i];
 			unsigned int j;
 			
Index: kernel/generic/src/mm/frame.c
===================================================================
--- kernel/generic/src/mm/frame.c	(revision c259b9bf9d0bc763cf915da58c8b182bd0170faf)
+++ kernel/generic/src/mm/frame.c	(revision 8bfe48e81c36cb4f2aef628c058c67d0583b320b)
@@ -68,6 +68,6 @@
 mutex_t mem_avail_mtx;
 condvar_t mem_avail_cv;
-count_t mem_avail_req = 0;  /**< Number of frames requested. */
-count_t mem_avail_gen = 0;  /**< Generation counter. */
+size_t mem_avail_req = 0;  /**< Number of frames requested. */
+size_t mem_avail_gen = 0;  /**< Generation counter. */
 
 /********************/
@@ -75,20 +75,20 @@
 /********************/
 
-static inline index_t frame_index(zone_t *zone, frame_t *frame)
-{
-	return (index_t) (frame - zone->frames);
-}
-
-static inline index_t frame_index_abs(zone_t *zone, frame_t *frame)
-{
-	return (index_t) (frame - zone->frames) + zone->base;
-}
-
-static inline bool frame_index_valid(zone_t *zone, index_t index)
+static inline size_t frame_index(zone_t *zone, frame_t *frame)
+{
+	return (size_t) (frame - zone->frames);
+}
+
+static inline size_t frame_index_abs(zone_t *zone, frame_t *frame)
+{
+	return (size_t) (frame - zone->frames) + zone->base;
+}
+
+static inline bool frame_index_valid(zone_t *zone, size_t index)
 {
 	return (index < zone->count);
 }
 
-static inline index_t make_frame_index(zone_t *zone, frame_t *frame)
+static inline size_t make_frame_index(zone_t *zone, frame_t *frame)
 {
 	return (frame - zone->frames);
@@ -121,12 +121,12 @@
  *
  */
-static count_t zones_insert_zone(pfn_t base, count_t count)
+static size_t zones_insert_zone(pfn_t base, size_t count)
 {
 	if (zones.count + 1 == ZONES_MAX) {
 		printf("Maximum zone count %u exceeded!\n", ZONES_MAX);
-		return (count_t) -1;
-	}
-	
-	count_t i;
+		return (size_t) -1;
+	}
+	
+	size_t i;
 	for (i = 0; i < zones.count; i++) {
 		/* Check for overlap */
@@ -134,5 +134,5 @@
 		    zones.info[i].base, zones.info[i].count)) {
 			printf("Zones overlap!\n");
-			return (count_t) -1;
+			return (size_t) -1;
 		}
 		if (base < zones.info[i].base)
@@ -141,5 +141,5 @@
 	
 	/* Move other zones up */
-	count_t j;
+	size_t j;
 	for (j = zones.count; j > i; j--) {
 		zones.info[j] = zones.info[j - 1];
@@ -162,8 +162,8 @@
  */
 #ifdef CONFIG_DEBUG
-static count_t total_frames_free(void)
-{
-	count_t total = 0;
-	count_t i;
+static size_t total_frames_free(void)
+{
+	size_t total = 0;
+	size_t i;
 	for (i = 0; i < zones.count; i++)
 		total += zones.info[i].free_count;
@@ -185,10 +185,10 @@
  *
  */
-count_t find_zone(pfn_t frame, count_t count, count_t hint)
+size_t find_zone(pfn_t frame, size_t count, size_t hint)
 {
 	if (hint >= zones.count)
 		hint = 0;
 	
-	count_t i = hint;
+	size_t i = hint;
 	do {
 		if ((zones.info[i].base <= frame)
@@ -201,5 +201,5 @@
 	} while (i != hint);
 	
-	return (count_t) -1;
+	return (size_t) -1;
 }
 
@@ -221,10 +221,10 @@
  *
  */
-static count_t find_free_zone(uint8_t order, zone_flags_t flags, count_t hint)
+static size_t find_free_zone(uint8_t order, zone_flags_t flags, size_t hint)
 {
 	if (hint >= zones.count)
 		hint = 0;
 	
-	count_t i = hint;
+	size_t i = hint;
 	do {
 		/*
@@ -244,5 +244,5 @@
 	} while (i != hint);
 	
-	return (count_t) -1;
+	return (size_t) -1;
 }
 
@@ -266,5 +266,5 @@
 	zone_t *zone = (zone_t *) buddy->data;
 	
-	index_t index = frame_index(zone, frame);
+	size_t index = frame_index(zone, frame);
 	do {
 		if (zone->frames[index].buddy_order != order)
@@ -292,5 +292,5 @@
 	bool is_left = IS_BUDDY_LEFT_BLOCK_ABS(zone, frame);
 	
-	index_t index;
+	size_t index;
 	if (is_left) {
 		index = (frame_index(zone, frame)) +
@@ -447,5 +447,5 @@
  *
  */
-static void zone_frame_free(zone_t *zone, index_t frame_idx)
+static void zone_frame_free(zone_t *zone, size_t frame_idx)
 {
 	ASSERT(zone_flags_available(zone->flags));
@@ -468,5 +468,5 @@
 
 /** Return frame from zone. */
-static frame_t *zone_get_frame(zone_t *zone, index_t frame_idx)
+static frame_t *zone_get_frame(zone_t *zone, size_t frame_idx)
 {
 	ASSERT(frame_idx < zone->count);
@@ -475,5 +475,5 @@
 
 /** Mark frame in zone unavailable to allocation. */
-static void zone_mark_unavailable(zone_t *zone, index_t frame_idx)
+static void zone_mark_unavailable(zone_t *zone, size_t frame_idx)
 {
 	ASSERT(zone_flags_available(zone->flags));
@@ -504,5 +504,5 @@
  *
  */
-static void zone_merge_internal(count_t z1, count_t z2, zone_t *old_z1, buddy_system_t *buddy)
+static void zone_merge_internal(size_t z1, size_t z2, zone_t *old_z1, buddy_system_t *buddy)
 {
 	ASSERT(zone_flags_available(zones.info[z1].flags));
@@ -530,5 +530,5 @@
 	
 	/* This marks all frames busy */
-	count_t i;
+	size_t i;
 	for (i = 0; i < zones.info[z1].count; i++)
 		frame_initialize(&zones.info[z1].frames[i]);
@@ -600,9 +600,9 @@
  *
  */
-static void return_config_frames(count_t znum, pfn_t pfn, count_t count)
+static void return_config_frames(size_t znum, pfn_t pfn, size_t count)
 {
 	ASSERT(zone_flags_available(zones.info[znum].flags));
 	
-	count_t cframes = SIZE2FRAMES(zone_conf_size(count));
+	size_t cframes = SIZE2FRAMES(zone_conf_size(count));
 	
 	if ((pfn < zones.info[znum].base)
@@ -615,5 +615,5 @@
 	ASSERT(!frame->buddy_order);
 	
-	count_t i;
+	size_t i;
 	for (i = 0; i < cframes; i++) {
 		zones.info[znum].busy_count++;
@@ -635,5 +635,5 @@
  *
  */
-static void zone_reduce_region(count_t znum, pfn_t frame_idx, count_t count)
+static void zone_reduce_region(size_t znum, pfn_t frame_idx, size_t count)
 {
 	ASSERT(zone_flags_available(zones.info[znum].flags));
@@ -641,9 +641,9 @@
 	
 	uint8_t order = zones.info[znum].frames[frame_idx].buddy_order;
-	ASSERT((count_t) (1 << order) >= count);
+	ASSERT((size_t) (1 << order) >= count);
 	
 	/* Reduce all blocks to order 0 */
-	count_t i;
-	for (i = 0; i < (count_t) (1 << order); i++) {
+	size_t i;
+	for (i = 0; i < (size_t) (1 << order); i++) {
 		frame_t *frame = &zones.info[znum].frames[i + frame_idx];
 		frame->buddy_order = 0;
@@ -654,5 +654,5 @@
 	
 	/* Free unneeded frames */
-	for (i = count; i < (count_t) (1 << order); i++)
+	for (i = count; i < (size_t) (1 << order); i++)
 		zone_frame_free(&zones.info[znum], i + frame_idx);
 }
@@ -671,5 +671,5 @@
  *
  */
-bool zone_merge(count_t z1, count_t z2)
+bool zone_merge(size_t z1, size_t z2)
 {
 	ipl_t ipl = interrupts_disable();
@@ -734,5 +734,5 @@
 	
 	/* Move zones down */
-	count_t i;
+	size_t i;
 	for (i = z2 + 1; i < zones.count; i++) {
 		zones.info[i - 1] = zones.info[i];
@@ -759,5 +759,5 @@
 void zone_merge_all(void)
 {
-	count_t i = 0;
+	size_t i = 0;
 	while (i < zones.count) {
 		if (!zone_merge(i, i + 1))
@@ -777,5 +777,5 @@
  *
  */
-static void zone_construct(zone_t *zone, buddy_system_t *buddy, pfn_t start, count_t count, zone_flags_t flags)
+static void zone_construct(zone_t *zone, buddy_system_t *buddy, pfn_t start, size_t count, zone_flags_t flags)
 {
 	zone->base = start;
@@ -800,5 +800,5 @@
 		    buddy_conf_size(order));
 		
-		count_t i;
+		size_t i;
 		for (i = 0; i < count; i++)
 			frame_initialize(&zone->frames[i]);
@@ -820,5 +820,5 @@
  *
  */
-uintptr_t zone_conf_size(count_t count)
+uintptr_t zone_conf_size(size_t count)
 {
 	return (count * sizeof(frame_t) + buddy_conf_size(fnzb(count)));
@@ -841,5 +841,5 @@
  *
  */
-count_t zone_create(pfn_t start, count_t count, pfn_t confframe, zone_flags_t flags)
+size_t zone_create(pfn_t start, size_t count, pfn_t confframe, zone_flags_t flags)
 {
 	ipl_t ipl = interrupts_disable();
@@ -856,5 +856,5 @@
 		 * it does not span kernel & init
 		 */
-		count_t confcount = SIZE2FRAMES(zone_conf_size(count));
+		size_t confcount = SIZE2FRAMES(zone_conf_size(count));
 		if ((confframe >= start) && (confframe < start + count)) {
 			for (; confframe < start + count; confframe++) {
@@ -869,5 +869,5 @@
 				
 				bool overlap = false;
-				count_t i;
+				size_t i;
 				for (i = 0; i < init.cnt; i++)
 					if (overlaps(addr, PFN2ADDR(confcount),
@@ -887,9 +887,9 @@
 		}
 		
-		count_t znum = zones_insert_zone(start, count);
-		if (znum == (count_t) -1) {
+		size_t znum = zones_insert_zone(start, count);
+		if (znum == (size_t) -1) {
 			spinlock_unlock(&zones.lock);
 			interrupts_restore(ipl);
-			return (count_t) -1;
+			return (size_t) -1;
 		}
 		
@@ -899,5 +899,5 @@
 		/* If confdata in zone, mark as unavailable */
 		if ((confframe >= start) && (confframe < start + count)) {
-			count_t i;
+			size_t i;
 			for (i = confframe; i < confframe + confcount; i++)
 				zone_mark_unavailable(&zones.info[znum],
@@ -912,9 +912,9 @@
 	
 	/* Non-available zone */
-	count_t znum = zones_insert_zone(start, count);
-	if (znum == (count_t) -1) {
+	size_t znum = zones_insert_zone(start, count);
+	if (znum == (size_t) -1) {
 		spinlock_unlock(&zones.lock);
 		interrupts_restore(ipl);
-		return (count_t) -1;
+		return (size_t) -1;
 	}
 	zone_construct(&zones.info[znum], NULL, start, count, flags);
@@ -931,12 +931,12 @@
 
 /** Set parent of frame. */
-void frame_set_parent(pfn_t pfn, void *data, count_t hint)
+void frame_set_parent(pfn_t pfn, void *data, size_t hint)
 {
 	ipl_t ipl = interrupts_disable();
 	spinlock_lock(&zones.lock);
 	
-	count_t znum = find_zone(pfn, 1, hint);
-	
-	ASSERT(znum != (count_t) -1);
+	size_t znum = find_zone(pfn, 1, hint);
+	
+	ASSERT(znum != (size_t) -1);
 	
 	zone_get_frame(&zones.info[znum],
@@ -947,12 +947,12 @@
 }
 
-void *frame_get_parent(pfn_t pfn, count_t hint)
+void *frame_get_parent(pfn_t pfn, size_t hint)
 {
 	ipl_t ipl = interrupts_disable();
 	spinlock_lock(&zones.lock);
 	
-	count_t znum = find_zone(pfn, 1, hint);
-	
-	ASSERT(znum != (count_t) -1);
+	size_t znum = find_zone(pfn, 1, hint);
+	
+	ASSERT(znum != (size_t) -1);
 	
 	void *res = zone_get_frame(&zones.info[znum],
@@ -974,9 +974,9 @@
  *
  */
-void *frame_alloc_generic(uint8_t order, frame_flags_t flags, count_t *pzone)
-{
-	count_t size = ((count_t) 1) << order;
+void *frame_alloc_generic(uint8_t order, frame_flags_t flags, size_t *pzone)
+{
+	size_t size = ((size_t) 1) << order;
 	ipl_t ipl;
-	count_t hint = pzone ? (*pzone) : 0;
+	size_t hint = pzone ? (*pzone) : 0;
 	
 loop:
@@ -987,14 +987,14 @@
 	 * First, find suitable frame zone.
 	 */
-	count_t znum = find_free_zone(order,
+	size_t znum = find_free_zone(order,
 	    FRAME_TO_ZONE_FLAGS(flags), hint);
 	
 	/* If no memory, reclaim some slab memory,
 	   if it does not help, reclaim all */
-	if ((znum == (count_t) -1) && (!(flags & FRAME_NO_RECLAIM))) {
+	if ((znum == (size_t) -1) && (!(flags & FRAME_NO_RECLAIM))) {
 		spinlock_unlock(&zones.lock);
 		interrupts_restore(ipl);
 		
-		count_t freed = slab_reclaim(0);
+		size_t freed = slab_reclaim(0);
 		
 		ipl = interrupts_disable();
@@ -1005,5 +1005,5 @@
 			    FRAME_TO_ZONE_FLAGS(flags), hint);
 		
-		if (znum == (count_t) -1) {
+		if (znum == (size_t) -1) {
 			spinlock_unlock(&zones.lock);
 			interrupts_restore(ipl);
@@ -1020,5 +1020,5 @@
 	}
 	
-	if (znum == (count_t) -1) {
+	if (znum == (size_t) -1) {
 		if (flags & FRAME_ATOMIC) {
 			spinlock_unlock(&zones.lock);
@@ -1028,5 +1028,5 @@
 		
 #ifdef CONFIG_DEBUG
-		count_t avail = total_frames_free();
+		size_t avail = total_frames_free();
 #endif
 		
@@ -1039,6 +1039,6 @@
 		
 #ifdef CONFIG_DEBUG
-		printf("Thread %" PRIu64 " waiting for %" PRIc " frames, "
-		    "%" PRIc " available.\n", THREAD->tid, size, avail);
+		printf("Thread %" PRIu64 " waiting for %" PRIs " frames, "
+		    "%" PRIs " available.\n", THREAD->tid, size, avail);
 #endif
 		
@@ -1049,5 +1049,5 @@
 		else
 			mem_avail_req = size;
-		count_t gen = mem_avail_gen;
+		size_t gen = mem_avail_gen;
 		
 		while (gen == mem_avail_gen)
@@ -1096,7 +1096,7 @@
 	 */
 	pfn_t pfn = ADDR2PFN(frame);
-	count_t znum = find_zone(pfn, 1, NULL);
-	
-	ASSERT(znum != (count_t) -1);
+	size_t znum = find_zone(pfn, 1, NULL);
+	
+	ASSERT(znum != (size_t) -1);
 	
 	zone_frame_free(&zones.info[znum], pfn - zones.info[znum].base);
@@ -1135,7 +1135,7 @@
 	 * First, find host frame zone for addr.
 	 */
-	count_t znum = find_zone(pfn, 1, NULL);
-	
-	ASSERT(znum != (count_t) -1);
+	size_t znum = find_zone(pfn, 1, NULL);
+	
+	ASSERT(znum != (size_t) -1);
 	
 	zones.info[znum].frames[pfn - zones.info[znum].base].refcount++;
@@ -1146,13 +1146,13 @@
 
 /** Mark given range unavailable in frame zones. */
-void frame_mark_unavailable(pfn_t start, count_t count)
+void frame_mark_unavailable(pfn_t start, size_t count)
 {
 	ipl_t ipl = interrupts_disable();
 	spinlock_lock(&zones.lock);
 	
-	count_t i;
+	size_t i;
 	for (i = 0; i < count; i++) {
-		count_t znum = find_zone(start + i, 1, 0);
-		if (znum == (count_t) -1)  /* PFN not found */
+		size_t znum = find_zone(start + i, 1, 0);
+		if (znum == (size_t) -1)  /* PFN not found */
 			continue;
 		
@@ -1183,5 +1183,5 @@
 		    SIZE2FRAMES(config.stack_size));
 		
-		count_t i;
+		size_t i;
 		for (i = 0; i < init.cnt; i++) {
 			pfn_t pfn = ADDR2PFN(KA2PA(init.tasks[i].addr));
@@ -1208,5 +1208,5 @@
 	
 	uint64_t total = 0;
-	count_t i;
+	size_t i;
 	for (i = 0; i < zones.count; i++)
 		total += (uint64_t) FRAMES2SIZE(zones.info[i].count);
@@ -1242,5 +1242,5 @@
 	 */
 	
-	count_t i;
+	size_t i;
 	for (i = 0;; i++) {
 		ipl_t ipl = interrupts_disable();
@@ -1254,8 +1254,8 @@
 		
 		uintptr_t base = PFN2ADDR(zones.info[i].base);
-		count_t count = zones.info[i].count;
+		size_t count = zones.info[i].count;
 		zone_flags_t flags = zones.info[i].flags;
-		count_t free_count = zones.info[i].free_count;
-		count_t busy_count = zones.info[i].busy_count;
+		size_t free_count = zones.info[i].free_count;
+		size_t busy_count = zones.info[i].busy_count;
 		
 		spinlock_unlock(&zones.lock);
@@ -1264,5 +1264,5 @@
 		bool available = zone_flags_available(flags);
 		
-		printf("%-2" PRIc, i);
+		printf("%-2" PRIs, i);
 		
 #ifdef __32_BITS__
@@ -1274,5 +1274,5 @@
 #endif
 		
-		printf(" %12" PRIc " %c%c%c      ", count,
+		printf(" %12" PRIs " %c%c%c      ", count,
 		    available ? 'A' : ' ',
 		    (flags & ZONE_RESERVED) ? 'R' : ' ',
@@ -1280,5 +1280,5 @@
 		
 		if (available)
-			printf("%12" PRIc " %12" PRIc,
+			printf("%12" PRIs " %12" PRIs,
 			    free_count, busy_count);
 		
@@ -1292,11 +1292,11 @@
  *
  */
-void zone_print_one(count_t num)
+void zone_print_one(size_t num)
 {
 	ipl_t ipl = interrupts_disable();
 	spinlock_lock(&zones.lock);
-	count_t znum = (count_t) -1;
-	
-	count_t i;
+	size_t znum = (size_t) -1;
+	
+	size_t i;
 	for (i = 0; i < zones.count; i++) {
 		if ((i == num) || (PFN2ADDR(zones.info[i].base) == num)) {
@@ -1306,5 +1306,5 @@
 	}
 	
-	if (znum == (count_t) -1) {
+	if (znum == (size_t) -1) {
 		spinlock_unlock(&zones.lock);
 		interrupts_restore(ipl);
@@ -1315,7 +1315,7 @@
 	uintptr_t base = PFN2ADDR(zones.info[i].base);
 	zone_flags_t flags = zones.info[i].flags;
-	count_t count = zones.info[i].count;
-	count_t free_count = zones.info[i].free_count;
-	count_t busy_count = zones.info[i].busy_count;
+	size_t count = zones.info[i].count;
+	size_t free_count = zones.info[i].free_count;
+	size_t busy_count = zones.info[i].busy_count;
 	
 	spinlock_unlock(&zones.lock);
@@ -1324,7 +1324,7 @@
 	bool available = zone_flags_available(flags);
 	
-	printf("Zone number:       %" PRIc "\n", znum);
+	printf("Zone number:       %" PRIs "\n", znum);
 	printf("Zone base address: %p\n", base);
-	printf("Zone size:         %" PRIc " frames (%" PRIs " KiB)\n", count,
+	printf("Zone size:         %" PRIs " frames (%" PRIs " KiB)\n", count,
 	    SIZE2KB(FRAMES2SIZE(count)));
 	printf("Zone flags:        %c%c%c\n",
@@ -1334,7 +1334,7 @@
 	
 	if (available) {
-		printf("Allocated space:   %" PRIc " frames (%" PRIs " KiB)\n",
+		printf("Allocated space:   %" PRIs " frames (%" PRIs " KiB)\n",
 		    busy_count, SIZE2KB(FRAMES2SIZE(busy_count)));
-		printf("Available space:   %" PRIc " frames (%" PRIs " KiB)\n",
+		printf("Available space:   %" PRIs " frames (%" PRIs " KiB)\n",
 		    free_count, SIZE2KB(FRAMES2SIZE(free_count)));
 	}
Index: kernel/generic/src/mm/slab.c
===================================================================
--- kernel/generic/src/mm/slab.c	(revision c259b9bf9d0bc763cf915da58c8b182bd0170faf)
+++ kernel/generic/src/mm/slab.c	(revision 8bfe48e81c36cb4f2aef628c058c67d0583b320b)
@@ -157,6 +157,6 @@
 	link_t link;       	/**< List of full/partial slabs. */
 	void *start;       	/**< Start address of first available item. */
-	count_t available; 	/**< Count of available items in this slab. */
-	index_t nextavail; 	/**< The index of next available item. */
+	size_t available; 	/**< Count of available items in this slab. */
+	size_t nextavail; 	/**< The index of next available item. */
 } slab_t;
 
@@ -178,5 +178,5 @@
 	size_t fsize;
 	unsigned int i;
-	count_t zone = 0;
+	size_t zone = 0;
 	
 	data = frame_alloc_generic(cache->order, FRAME_KA | flags, &zone);
@@ -216,5 +216,5 @@
  * @return number of freed frames
  */
-static count_t slab_space_free(slab_cache_t *cache, slab_t *slab)
+static size_t slab_space_free(slab_cache_t *cache, slab_t *slab)
 {
 	frame_free(KA2PA(slab->start));
@@ -244,5 +244,5 @@
  * @return Number of freed pages
  */
-static count_t slab_obj_destroy(slab_cache_t *cache, void *obj, slab_t *slab)
+static size_t slab_obj_destroy(slab_cache_t *cache, void *obj, slab_t *slab)
 {
 	int freed = 0;
@@ -372,8 +372,8 @@
  * @return Number of freed pages
  */
-static count_t magazine_destroy(slab_cache_t *cache, slab_magazine_t *mag)
+static size_t magazine_destroy(slab_cache_t *cache, slab_magazine_t *mag)
 {
 	unsigned int i;
-	count_t frames = 0;
+	size_t frames = 0;
 
 	for (i = 0; i < mag->busy; i++) {
@@ -650,9 +650,9 @@
  * @return Number of freed pages
  */
-static count_t _slab_reclaim(slab_cache_t *cache, int flags)
+static size_t _slab_reclaim(slab_cache_t *cache, int flags)
 {
 	unsigned int i;
 	slab_magazine_t *mag;
-	count_t frames = 0;
+	size_t frames = 0;
 	int magcount;
 	
@@ -772,9 +772,9 @@
 
 /* Go through all caches and reclaim what is possible */
-count_t slab_reclaim(int flags)
+size_t slab_reclaim(int flags)
 {
 	slab_cache_t *cache;
 	link_t *cur;
-	count_t frames = 0;
+	size_t frames = 0;
 
 	spinlock_lock(&slab_cache_lock);
Index: kernel/generic/src/mm/tlb.c
===================================================================
--- kernel/generic/src/mm/tlb.c	(revision c259b9bf9d0bc763cf915da58c8b182bd0170faf)
+++ kernel/generic/src/mm/tlb.c	(revision 8bfe48e81c36cb4f2aef628c058c67d0583b320b)
@@ -80,5 +80,5 @@
  */
 void tlb_shootdown_start(tlb_invalidate_type_t type, asid_t asid,
-    uintptr_t page, count_t count)
+    uintptr_t page, size_t count)
 {
 	unsigned int i;
@@ -109,5 +109,5 @@
 			 * Enqueue the message.
 			 */
-			index_t idx = cpu->tlb_messages_count++;
+			size_t idx = cpu->tlb_messages_count++;
 			cpu->tlb_messages[idx].type = type;
 			cpu->tlb_messages[idx].asid = asid;
@@ -144,5 +144,5 @@
 	asid_t asid;
 	uintptr_t page;
-	count_t count;
+	size_t count;
 	unsigned int i;