Changeset 98000fb in mainline for kernel/generic/src

Timestamp:

2009-06-03T19:34:45Z (16 years ago)

Author:

Martin Decky <martin@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

301ff30

Parents:

69e68e3

Message:

remove redundant index_t and count_t types (which were always quite ambiguous and not actually needed)

Location:

kernel/generic/src

Files:

• adt/bitmap.c (modified) (4 diffs)
• adt/btree.c (modified) (20 diffs)
• adt/hash_table.c (modified) (4 diffs)
• console/cmd.c (modified) (3 diffs)
• console/console.c (modified) (3 diffs)
• console/kconsole.c (modified) (10 diffs)
• ddi/ddi.c (modified) (3 diffs)
• ddi/irq.c (modified) (8 diffs)
• debug/symtab.c (modified) (6 diffs)
• ipc/event.c (modified) (2 diffs)
• lib/sort.c (modified) (5 diffs)
• lib/string.c (modified) (14 diffs)
• main/kinit.c (modified) (4 diffs)
• main/main.c (modified) (3 diffs)
• mm/as.c (modified) (24 diffs)
• mm/backend_anon.c (modified) (1 diff)
• mm/backend_elf.c (modified) (3 diffs)
• mm/frame.c (modified) (58 diffs)
• mm/slab.c (modified) (7 diffs)
• mm/tlb.c (modified) (3 diffs)
• printf/printf_core.c (modified) (6 diffs)
• printf/vprintf.c (modified) (3 diffs)
• printf/vsnprintf.c (modified) (2 diffs)
• proc/scheduler.c (modified) (1 diff)
• synch/futex.c (modified) (3 diffs)
• synch/spinlock.c (modified) (1 diff)
• synch/waitq.c (modified) (1 diff)
• time/clock.c (modified) (1 diff)

kernel/generic/src/adt/bitmap.c

@@ -55 +55 @@
  * @param bits Number of bits stored in bitmap.
  */
-void bitmap_initialize(bitmap_t *bitmap, uint8_t *map, count_t bits)
+void bitmap_initialize(bitmap_t *bitmap, uint8_t *map, size_t bits)
 {
         bitmap->map = map;
@@ -67 +67 @@
  * @param bits Number of bits to set.
  */
-void bitmap_set_range(bitmap_t *bitmap, index_t start, count_t bits)
+void bitmap_set_range(bitmap_t *bitmap, size_t start, size_t bits)
 {
-        index_t i=0;
-        index_t aligned_start;
-        count_t lub;            /* leading unaligned bits */
-        count_t amb;            /* aligned middle bits */
-        count_t tab;            /* trailing aligned bits */
+        size_t i = 0;
+        size_t aligned_start;
+        size_t lub;             /* leading unaligned bits */
+        size_t amb;             /* aligned middle bits */
+        size_t tab;             /* trailing aligned bits */
         
         ASSERT(start + bits <= bitmap->bits);
@@ -117 +117 @@
  * @param bits Number of bits to clear.
  */
-void bitmap_clear_range(bitmap_t *bitmap, index_t start, count_t bits)
+void bitmap_clear_range(bitmap_t *bitmap, size_t start, size_t bits)
 {
-        index_t i=0;
-        index_t aligned_start;
-        count_t lub;            /* leading unaligned bits */
-        count_t amb;            /* aligned middle bits */
-        count_t tab;            /* trailing aligned bits */
+        size_t i = 0;
+        size_t aligned_start;
+        size_t lub;             /* leading unaligned bits */
+        size_t amb;             /* aligned middle bits */
+        size_t tab;             /* trailing aligned bits */
         
         ASSERT(start + bits <= bitmap->bits);
@@ -169 +169 @@
  * @param bits Number of bits to copy.
  */
-void bitmap_copy(bitmap_t *dst, bitmap_t *src, count_t bits)
+void bitmap_copy(bitmap_t *dst, bitmap_t *src, size_t bits)
 {
-        index_t i;
+        size_t i;
         
         ASSERT(bits <= dst->bits);

kernel/generic/src/adt/btree.c

@@ -64 +64 @@
 static btree_node_t *node_split(btree_node_t *node, btree_key_t key, void *value, btree_node_t *rsubtree, btree_key_t *median);
 static btree_node_t *node_combine(btree_node_t *node);
-static index_t find_key_by_subtree(btree_node_t *node, btree_node_t *subtree, bool right);
-static void rotate_from_right(btree_node_t *lnode, btree_node_t *rnode, index_t idx);
-static void rotate_from_left(btree_node_t *lnode, btree_node_t *rnode, index_t idx);
+static size_t find_key_by_subtree(btree_node_t *node, btree_node_t *subtree, bool right);
+static void rotate_from_right(btree_node_t *lnode, btree_node_t *rnode, size_t idx);
+static void rotate_from_left(btree_node_t *lnode, btree_node_t *rnode, size_t idx);
 static bool try_insert_by_rotation_to_left(btree_node_t *node, btree_key_t key, void *value, btree_node_t *rsubtree);
 static bool try_insert_by_rotation_to_right(btree_node_t *node, btree_key_t key, void *value, btree_node_t *rsubtree);
@@ -138 +138 @@
 void btree_destroy_subtree(btree_node_t *root)
 {
-        count_t i;
+        size_t i;
 
         if (root->keys) {
@@ -270 +270 @@
         
         if (node->keys > FILL_FACTOR) {
-                count_t i;
+                size_t i;
 
                 /*
@@ -286 +286 @@
                 
         } else {
-                index_t idx;
+                size_t idx;
                 btree_node_t *rnode, *parent;
 
@@ -336 +336 @@
                 } else {
                         void *val;
-                        count_t i;
+                        size_t i;
                 
                         /*
@@ -443 +443 @@
 void node_insert_key_and_lsubtree(btree_node_t *node, btree_key_t key, void *value, btree_node_t *lsubtree)
 {
-        count_t i;
+        size_t i;
 
         for (i = 0; i < node->keys; i++) {
                 if (key < node->key[i]) {
-                        count_t j;
+                        size_t j;
                 
                         for (j = node->keys; j > i; j--) {
@@ -479 +479 @@
 void node_insert_key_and_rsubtree(btree_node_t *node, btree_key_t key, void *value, btree_node_t *rsubtree)
 {
-        count_t i;
+        size_t i;
 
         for (i = 0; i < node->keys; i++) {
                 if (key < node->key[i]) {
-                        count_t j;
+                        size_t j;
                 
                         for (j = node->keys; j > i; j--) {
@@ -511 +511 @@
 void node_remove_key_and_lsubtree(btree_node_t *node, btree_key_t key)
 {
-        count_t i, j;
+        size_t i, j;
         
         for (i = 0; i < node->keys; i++) {
@@ -539 +539 @@
 void node_remove_key_and_rsubtree(btree_node_t *node, btree_key_t key)
 {
-        count_t i, j;
+        size_t i, j;
         
         for (i = 0; i < node->keys; i++) {
@@ -577 +577 @@
 {
         btree_node_t *rnode;
-        count_t i, j;
+        size_t i, j;
 
         ASSERT(median);
@@ -604 +604 @@
          * If this is an index node, do not copy the median.
          */
-        i = (count_t) INDEX_NODE(node);
+        i = (size_t) INDEX_NODE(node);
         for (i += MEDIAN_HIGH_INDEX(node), j = 0; i < node->keys; i++, j++) {
                 rnode->key[j] = node->key[i];
@@ -637 +637 @@
 btree_node_t *node_combine(btree_node_t *node)
 {
-        index_t idx;
+        size_t idx;
         btree_node_t *rnode;
-        count_t i;
+        size_t i;
 
         ASSERT(!ROOT_NODE(node));
@@ -686 +686 @@
  * @return Index of the key associated with the subtree.
  */ 
-index_t find_key_by_subtree(btree_node_t *node, btree_node_t *subtree, bool right)
-{
-        count_t i;
+size_t find_key_by_subtree(btree_node_t *node, btree_node_t *subtree, bool right)
+{
+        size_t i;
         
         for (i = 0; i < node->keys + 1; i++) {
@@ -707 +707 @@
  * @param idx Index of the parent node key that is taking part in the rotation.
  */
-void rotate_from_left(btree_node_t *lnode, btree_node_t *rnode, index_t idx)
+void rotate_from_left(btree_node_t *lnode, btree_node_t *rnode, size_t idx)
 {
         btree_key_t key;
@@ -744 +744 @@
  * @param idx Index of the parent node key that is taking part in the rotation.
  */
-void rotate_from_right(btree_node_t *lnode, btree_node_t *rnode, index_t idx)
+void rotate_from_right(btree_node_t *lnode, btree_node_t *rnode, size_t idx)
 {
         btree_key_t key;
@@ -787 +787 @@
 bool try_insert_by_rotation_to_left(btree_node_t *node, btree_key_t inskey, void *insvalue, btree_node_t *rsubtree)
 {
-        index_t idx;
+        size_t idx;
         btree_node_t *lnode;
 
@@ -834 +834 @@
 bool try_insert_by_rotation_to_right(btree_node_t *node, btree_key_t inskey, void *insvalue, btree_node_t *rsubtree)
 {
-        index_t idx;
+        size_t idx;
         btree_node_t *rnode;
 
@@ -873 +873 @@
 bool try_rotation_from_left(btree_node_t *rnode)
 {
-        index_t idx;
+        size_t idx;
         btree_node_t *lnode;
 
@@ -908 +908 @@
 bool try_rotation_from_right(btree_node_t *lnode)
 {
-        index_t idx;
+        size_t idx;
         btree_node_t *rnode;
 
@@ -941 +941 @@
 void btree_print(btree_t *t)
 {
-        count_t i;
+        size_t i;
         int depth = t->root->depth;
         link_t head, *cur;

kernel/generic/src/adt/hash_table.c

@@ -52 +52 @@
  * @param op Hash table operations structure.
  */
-void hash_table_create(hash_table_t *h, count_t m, count_t max_keys, hash_table_operations_t *op)
+void hash_table_create(hash_table_t *h, size_t m, size_t max_keys, hash_table_operations_t *op)
 {
-        index_t i;
+        size_t i;
 
         ASSERT(h);
@@ -84 +84 @@
 void hash_table_insert(hash_table_t *h, unative_t key[], link_t *item)
 {
-        index_t chain;
+        size_t chain;
         
         ASSERT(item);
@@ -108 +108 @@
 {
         link_t *cur;
-        index_t chain;
+        size_t chain;
         
         ASSERT(h);
@@ -138 +138 @@
  * @param keys Number of keys in the key array.
  */
-void hash_table_remove(hash_table_t *h, unative_t key[], count_t keys)
+void hash_table_remove(hash_table_t *h, unative_t key[], size_t keys)
 {
-        index_t chain;
+        size_t chain;
         link_t *cur;
         

kernel/generic/src/console/cmd.c

@@ -514 +514 @@
         
         link_t *cur;
-        count_t len = 0;
+        size_t len = 0;
         for (cur = cmd_head.next; cur != &cmd_head; cur = cur->next) {
                 cmd_info_t *hlp;
@@ -652 +652 @@
          */
         
-        count_t i;
+        size_t i;
         for (i = 0; i < config.cpu_count; i++) {
                 if (!cpus[i].active)
@@ -971 +971 @@
 int cmd_tests(cmd_arg_t *argv)
 {
-        count_t len = 0;
+        size_t len = 0;
         test_t *test;
         for (test = tests; test->name != NULL; test++) {

kernel/generic/src/console/console.c

@@ -62 +62 @@
 static bool klog_inited = false;
 /** First kernel log characters */
-static index_t klog_start = 0;
+static size_t klog_start = 0;
 /** Number of valid kernel log characters */
 static size_t klog_len = 0;
@@ -171 +171 @@
  *
  */
-count_t gets(indev_t *indev, char *buf, size_t buflen)
+size_t gets(indev_t *indev, char *buf, size_t buflen)
 {
         size_t offset = 0;
-        count_t count = 0;
+        size_t count = 0;
         buf[offset] = 0;
         
@@ -227 +227 @@
         if ((klog_stored > 0) && (stdout) && (stdout->op->write)) {
                 /* Print charaters stored in kernel log */
-                index_t i;
+                size_t i;
                 for (i = klog_len - klog_stored; i < klog_len; i++)
                         stdout->op->write(stdout, klog[(klog_start + i) % KLOG_LENGTH], silent);

kernel/generic/src/console/kconsole.c

@@ -87 +87 @@
 
 static wchar_t history[KCONSOLE_HISTORY][MAX_CMDLINE] = {};
-static count_t history_pos = 0;
+static size_t history_pos = 0;
 
 /** Initialize kconsole data structures
@@ -160 +160 @@
 
 /** Print count times a character */
-static void print_cc(wchar_t ch, count_t count)
-{
-        count_t i;
+static void print_cc(wchar_t ch, size_t count)
+{
+        size_t i;
         for (i = 0; i < count; i++)
                 putchar(ch);
@@ -170 +170 @@
 static const char *cmdtab_search_one(const char *name, link_t **startpos)
 {
-        count_t namelen = str_length(name);
+        size_t namelen = str_length(name);
         
         spinlock_lock(&cmd_lock);
@@ -206 +206 @@
         const char *name = input;
         
-        count_t found = 0;
+        size_t found = 0;
         link_t *pos = NULL;
         const char *hint;
@@ -241 +241 @@
         printf("%s> ", prompt);
         
-        count_t position = 0;
+        size_t position = 0;
         wchar_t *current = history[history_pos];
         current[0] = 0;
@@ -281 +281 @@
                         /* Find the beginning of the word
                            and copy it to tmp */
-                        count_t beg;
+                        size_t beg;
                         for (beg = position - 1; (beg > 0) && (!isspace(current[beg]));
                             beg--);
@@ -314 +314 @@
                         
                         size_t off = 0;
-                        count_t i = 0;
+                        size_t i = 0;
                         while ((ch = str_decode(tmp, &off, STR_NO_LIMIT)) != 0) {
                                 if (!wstr_linsert(current, ch, position + i, MAX_CMDLINE))
@@ -543 +543 @@
                 if (str_lcmp(hlp->name, cmdline + start,
                     max(str_length(hlp->name),
-                    str_nlength(cmdline + start, (count_t) (end - start) - 1))) == 0) {
+                    str_nlength(cmdline + start, (size_t) (end - start) - 1))) == 0) {
                         cmd = hlp;
                         break;
@@ -569 +569 @@
         
         bool error = false;
-        count_t i;
+        size_t i;
         for (i = 0; i < cmd->argc; i++) {
                 start = end;
@@ -660 +660 @@
         while (true) {
                 wchar_t *tmp = clever_readline((char *) prompt, stdin);
-                count_t len = wstr_length(tmp);
+                size_t len = wstr_length(tmp);
                 if (!len)
                         continue;

kernel/generic/src/ddi/ddi.c

@@ -98 +98 @@
  *
  */
-static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, count_t pages, int flags)
+static int ddi_physmem_map(uintptr_t pf, uintptr_t vp, size_t pages, int flags)
 {
         ASSERT(TASK);
@@ -119 +119 @@
         /* Find the zone of the physical memory */
         spinlock_lock(&zones.lock);
-        count_t znum = find_zone(ADDR2PFN(pf), pages, 0);
-        
-        if (znum == (count_t) -1) {
+        size_t znum = find_zone(ADDR2PFN(pf), pages, 0);
+        
+        if (znum == (size_t) -1) {
                 /* Frames not found in any zones
                  * -> assume it is hardware device and allow mapping
@@ -243 +243 @@
         return (unative_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base,
             FRAME_SIZE), ALIGN_DOWN((uintptr_t) virt_base, PAGE_SIZE),
-            (count_t) pages, (int) flags);
+            (size_t) pages, (int) flags);
 }
 

kernel/generic/src/ddi/irq.c

@@ -100 +100 @@
  * there will be collisions between different keys.
  */
-static index_t irq_ht_hash(unative_t *key);
-static bool irq_ht_compare(unative_t *key, count_t keys, link_t *item);
+static size_t irq_ht_hash(unative_t *key);
+static bool irq_ht_compare(unative_t *key, size_t keys, link_t *item);
 static void irq_ht_remove(link_t *item);
 
@@ -116 +116 @@
  * elements with single key (sharing of one IRQ).
  */
-static index_t irq_lin_hash(unative_t *key);
-static bool irq_lin_compare(unative_t *key, count_t keys, link_t *item);
+static size_t irq_lin_hash(unative_t *key);
+static bool irq_lin_compare(unative_t *key, size_t keys, link_t *item);
 static void irq_lin_remove(link_t *item);
 
@@ -127 +127 @@
 
 /** Number of buckets in either of the hash tables. */
-static count_t buckets;
+static size_t buckets;
 
 /** Initialize IRQ subsystem.
@@ -134 +134 @@
  * @param chains Number of chains in the hash table.
  */
-void irq_init(count_t inrs, count_t chains)
+void irq_init(size_t inrs, size_t chains)
 {
         buckets = chains;
@@ -299 +299 @@
  * @return Index into the hash table.
  */
-index_t irq_ht_hash(unative_t key[])
+size_t irq_ht_hash(unative_t key[])
 {
         inr_t inr = (inr_t) key[KEY_INR];
@@ -325 +325 @@
  * @return True on match or false otherwise.
  */
-bool irq_ht_compare(unative_t key[], count_t keys, link_t *item)
+bool irq_ht_compare(unative_t key[], size_t keys, link_t *item)
 {
         irq_t *irq = hash_table_get_instance(item, irq_t, link);
@@ -372 +372 @@
  * @return Index into the hash table.
  */
-index_t irq_lin_hash(unative_t key[])
+size_t irq_lin_hash(unative_t key[])
 {
         inr_t inr = (inr_t) key[KEY_INR];
@@ -398 +398 @@
  * @return True on match or false otherwise.
  */
-bool irq_lin_compare(unative_t key[], count_t keys, link_t *item)
+bool irq_lin_compare(unative_t key[], size_t keys, link_t *item)
 {
         irq_t *irq = list_get_instance(item, irq_t, link);

kernel/generic/src/debug/symtab.c

@@ -56 +56 @@
 {
 #ifdef CONFIG_SYMTAB
-        count_t i;
+        size_t i;
         
         for (i = 1; symbol_table[i].address_le; i++) {
@@ -113 +113 @@
  *
  */
-static const char *symtab_search_one(const char *name, count_t *startpos)
-{
-        count_t namelen = str_length(name);
-        
-        count_t pos;
+static const char *symtab_search_one(const char *name, size_t *startpos)
+{
+        size_t namelen = str_length(name);
+        
+        size_t pos;
         for (pos = *startpos; symbol_table[pos].address_le; pos++) {
                 const char *curname = symbol_table[pos].symbol_name;
@@ -154 +154 @@
 {
 #ifdef CONFIG_SYMTAB
-        count_t found = 0;
-        count_t pos = 0;
+        size_t found = 0;
+        size_t pos = 0;
         const char *hint;
         
@@ -183 +183 @@
 {
 #ifdef CONFIG_SYMTAB
-        count_t pos = 0;
+        size_t pos = 0;
         while (symtab_search_one(name, &pos)) {
                 uintptr_t addr = uint64_t_le2host(symbol_table[pos].address_le);
@@ -204 +204 @@
  *
  */
-int symtab_compl(char *input, count_t size)
+int symtab_compl(char *input, size_t size)
 {
 #ifdef CONFIG_SYMTAB
@@ -217 +217 @@
                 return 0;
         
-        count_t found = 0;
-        count_t pos = 0;
+        size_t found = 0;
+        size_t pos = 0;
         const char *hint;
         char output[MAX_SYMBOL_NAME];

kernel/generic/src/ipc/event.c

@@ -65 +65 @@
 }
 
-static int
-event_subscribe(event_type_t evno, unative_t method, answerbox_t *answerbox)
+static int event_subscribe(event_type_t evno, unative_t method,
+    answerbox_t *answerbox)
 {
         if (evno >= EVENT_END)
@@ -123 +123 @@
 }
 
-void
-event_notify(event_type_t evno, unative_t a1, unative_t a2, unative_t a3,
+void event_notify(event_type_t evno, unative_t a1, unative_t a2, unative_t a3,
     unative_t a4, unative_t a5)
 {

kernel/generic/src/lib/sort.c

@@ -46 +46 @@
 #define EBUFSIZE        32
 
-void _qsort(void * data, count_t n, size_t e_size, int (* cmp) (void * a, void * b), void *tmp, void *pivot);
-void _bubblesort(void * data, count_t n, size_t e_size, int (* cmp) (void * a, void * b), void *slot);
+void _qsort(void * data, size_t n, size_t e_size, int (* cmp) (void * a, void * b), void *tmp, void *pivot);
+void _bubblesort(void * data, size_t n, size_t e_size, int (* cmp) (void * a, void * b), void *slot);
 
 /** Quicksort wrapper
@@ -62 +62 @@
  * 
  */
-void qsort(void * data, count_t n, size_t e_size, int (* cmp) (void * a, void * b))
+void qsort(void * data, size_t n, size_t e_size, int (* cmp) (void * a, void * b))
 {
         uint8_t buf_tmp[EBUFSIZE];
@@ -94 +94 @@
  * 
  */
-void _qsort(void * data, count_t n, size_t e_size, int (* cmp) (void * a, void * b), void *tmp, void *pivot)
+void _qsort(void * data, size_t n, size_t e_size, int (* cmp) (void * a, void * b), void *tmp, void *pivot)
 {
         if (n > 4) {
@@ -134 +134 @@
  * 
  */
-void bubblesort(void * data, count_t n, size_t e_size, int (* cmp) (void * a, void * b))
+void bubblesort(void * data, size_t n, size_t e_size, int (* cmp) (void * a, void * b))
 {
         uint8_t buf_slot[EBUFSIZE];
@@ -161 +161 @@
  * 
  */
-void _bubblesort(void * data, count_t n, size_t e_size, int (* cmp) (void * a, void * b), void *slot)
+void _bubblesort(void * data, size_t n, size_t e_size, int (* cmp) (void * a, void * b), void *slot)
 {
         bool done = false;

kernel/generic/src/lib/string.c

@@ -63 +63 @@
  *
  *  [wide] string length  number of CHARACTERS in a [wide] string (excluding
- *                        the NULL-terminator), count_t
+ *                        the NULL-terminator), size_t
  *
  *  [wide] string width   number of display cells on a monospace display taken
- *                        by a [wide] string, count_t
+ *                        by a [wide] string, size_t
  *
  *
@@ -76 +76 @@
  *                            NULL-terminator)
  *
- *  length  l        count_t  number of CHARACTERS in a string (excluding the
+ *  length  l        size_t   number of CHARACTERS in a string (excluding the
  *                            null terminator)
  *
- *  width  w         count_t  number of display cells on a monospace display
+ *  width  w         size_t   number of display cells on a monospace display
  *                            taken by a string
  *
@@ -98 +98 @@
  *  pointer (char *, wchar_t *)
  *  byte offset (size_t)
- *  character index (count_t)
+ *  character index (size_t)
  *
  */
@@ -310 +310 @@
  *
  */
-size_t str_lsize(const char *str, count_t max_len)
-{
-        count_t len = 0;
+size_t str_lsize(const char *str, size_t max_len)
+{
+        size_t len = 0;
         size_t offset = 0;
         
@@ -338 +338 @@
  *
  */
-size_t wstr_lsize(const wchar_t *str, count_t max_len)
+size_t wstr_lsize(const wchar_t *str, size_t max_len)
 {
         return (wstr_nlength(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t));
@@ -350 +350 @@
  *
  */
-count_t str_length(const char *str)
-{
-        count_t len = 0;
+size_t str_length(const char *str)
+{
+        size_t len = 0;
         size_t offset = 0;
         
@@ -368 +368 @@
  *
  */
-count_t wstr_length(const wchar_t *wstr)
-{
-        count_t len = 0;
+size_t wstr_length(const wchar_t *wstr)
+{
+        size_t len = 0;
         
         while (*wstr++ != 0)
@@ -386 +386 @@
  *
  */
-count_t str_nlength(const char *str, size_t size)
-{
-        count_t len = 0;
+size_t str_nlength(const char *str, size_t size)
+{
+        size_t len = 0;
         size_t offset = 0;
         
@@ -405 +405 @@
  *
  */
-count_t wstr_nlength(const wchar_t *str, size_t size)
-{
-        count_t len = 0;
-        count_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
-        count_t offset = 0;
+size_t wstr_nlength(const wchar_t *str, size_t size)
+{
+        size_t len = 0;
+        size_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
+        size_t offset = 0;
         
         while ((offset < limit) && (*str++ != 0)) {
@@ -497 +497 @@
  *
  */
-int str_lcmp(const char *s1, const char *s2, count_t max_len)
+int str_lcmp(const char *s1, const char *s2, size_t max_len)
 {
         wchar_t c1 = 0;
@@ -505 +505 @@
         size_t off2 = 0;
         
-        count_t len = 0;
+        size_t len = 0;
 
         while (true) {
@@ -616 +616 @@
         
         wchar_t ch;
-        count_t src_idx = 0;
+        size_t src_idx = 0;
         size_t dst_off = 0;
         
@@ -667 +667 @@
  *
  */
-bool wstr_linsert(wchar_t *str, wchar_t ch, count_t pos, count_t max_pos)
-{
-        count_t len = wstr_length(str);
+bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos)
+{
+        size_t len = wstr_length(str);
         
         if ((pos > len) || (pos + 1 > max_pos))
                 return false;
         
-        count_t i;
+        size_t i;
         for (i = len; i + 1 > pos; i--)
                 str[i + 1] = str[i];
@@ -695 +695 @@
  *
  */
-bool wstr_remove(wchar_t *str, count_t pos)
-{
-        count_t len = wstr_length(str);
+bool wstr_remove(wchar_t *str, size_t pos)
+{
+        size_t len = wstr_length(str);
         
         if (pos >= len)
                 return false;
         
-        count_t i;
+        size_t i;
         for (i = pos + 1; i <= len; i++)
                 str[i - 1] = str[i];

kernel/generic/src/main/kinit.c

@@ -128 +128 @@
         
         if (config.cpu_count > 1) {
-                count_t i;
+                size_t i;
                 
                 /*
@@ -141 +141 @@
                                 thread_ready(thread);
                         } else
-                                printf("Unable to create kcpulb thread for cpu" PRIc "\n", i);
+                                printf("Unable to create kcpulb thread for cpu" PRIs "\n", i);
                 }
         }
@@ -169 +169 @@
          * Create user tasks, load RAM disk images.
          */
-        count_t i;
+        size_t i;
         program_t programs[CONFIG_INIT_TASKS];
         
         for (i = 0; i < init.cnt; i++) {
                 if (init.tasks[i].addr % FRAME_SIZE) {
-                        printf("init[%" PRIc "].addr is not frame aligned\n", i);
+                        printf("init[%" PRIs "].addr is not frame aligned\n", i);
                         continue;
                 }
@@ -214 +214 @@
                         
                         if (rd != RE_OK)
-                                printf("Init binary %" PRIc " not used (error %d)\n", i, rd);
+                                printf("Init binary %" PRIs " not used (error %d)\n", i, rd);
                 }
         }

kernel/generic/src/main/main.c

@@ -154 +154 @@
         
         /* Avoid placing stack on top of init */
-        count_t i;
+        size_t i;
         for (i = 0; i < init.cnt; i++) {
                 if (PA_overlaps(config.stack_base, config.stack_size,
@@ -234 +234 @@
         LOG_EXEC(slab_enable_cpucache());
         
-        printf("Detected %" PRIc " CPU(s), %" PRIu64" MiB free memory\n",
+        printf("Detected %" PRIs " CPU(s), %" PRIu64" MiB free memory\n",
             config.cpu_count, SIZE2MB(zone_total_size()));
         
@@ -248 +248 @@
         
         if (init.cnt > 0) {
-                count_t i;
+                size_t i;
                 for (i = 0; i < init.cnt; i++)
-                        LOG("init[%" PRIc "].addr=%#" PRIp ", init[%" PRIc
+                        LOG("init[%" PRIs "].addr=%#" PRIp ", init[%" PRIs
                             "].size=%#" PRIs, i, init.tasks[i].addr, i,
                             init.tasks[i].size);

kernel/generic/src/mm/as.c

@@ -419 +419 @@
                         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 +556 @@
                 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 +789 @@
         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 +828 @@
                 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 +854 @@
                 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 +904 @@
                 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 +1398 @@
  * @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 +1407 @@
         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 +1424 @@
                 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 +1479 @@
         } 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 +1514 @@
                 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 +1569 @@
         } 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 +1607 @@
                         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 +1666 @@
         }
 
-        panic("Inconsistency detected while adding %" PRIc " pages of used "
+        panic("Inconsistency detected while adding %" PRIs " pages of used "
             "space at %p.", count, page);
 }
@@ -1680 +1680 @@
  * @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 +1689 @@
         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 +1718 @@
         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 +1734 @@
                         } else if (page + count * PAGE_SIZE <
                             left_pg + left_cnt*PAGE_SIZE) {
-                                count_t new_cnt;
+                                size_t new_cnt;
                                 
                                 /*
@@ -1758 +1758 @@
         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 +1773 @@
                         } else if (page + count * PAGE_SIZE < left_pg +
                             left_cnt * PAGE_SIZE) {
-                                count_t new_cnt;
+                                size_t new_cnt;
                                 
                                 /*
@@ -1800 +1800 @@
                 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 +1820 @@
                                 } else if (page + count * PAGE_SIZE <
                                     left_pg + left_cnt * PAGE_SIZE) {
-                                        count_t new_cnt;
+                                        size_t new_cnt;
                                 
                                         /*
@@ -1845 +1845 @@
 
 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 +1944 @@
                 
                         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));

kernel/generic/src/mm/backend_anon.c

@@ -196 +196 @@
                 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;
                         

kernel/generic/src/mm/backend_elf.c

@@ -83 +83 @@
         btree_node_t *leaf;
         uintptr_t base, frame, page, start_anon;
-        index_t i;
+        size_t i;
         bool dirty = false;
 
@@ -235 +235 @@
         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 +305 @@
                 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;
                         

kernel/generic/src/mm/frame.c

@@ -68 +68 @@
 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 +75 @@
 /********************/
 
-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 +121 @@
  *
  */
-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 +134 @@
                     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 +141 @@
         
         /* 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 +162 @@
  */
 #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 +185 @@
  *
  */
-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 +201 @@
         } while (i != hint);
         
-        return (count_t) -1;
+        return (size_t) -1;
 }
 
@@ -221 +221 @@
  *
  */
-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 +244 @@
         } while (i != hint);
         
-        return (count_t) -1;
+        return (size_t) -1;
 }
 
@@ -266 +266 @@
         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 +292 @@
         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 +447 @@
  *
  */
-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 +468 @@
 
 /** 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 +475 @@
 
 /** 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 +504 @@
  *
  */
-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 +530 @@
         
         /* 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 +600 @@
  *
  */
-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 +615 @@
         ASSERT(!frame->buddy_order);
         
-        count_t i;
+        size_t i;
         for (i = 0; i < cframes; i++) {
                 zones.info[znum].busy_count++;
@@ -635 +635 @@
  *
  */
-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 +641 @@
         
         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 +654 @@
         
         /* 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 +671 @@
  *
  */
-bool zone_merge(count_t z1, count_t z2)
+bool zone_merge(size_t z1, size_t z2)
 {
         ipl_t ipl = interrupts_disable();
@@ -734 +734 @@
         
         /* 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 +759 @@
 void zone_merge_all(void)
 {
-        count_t i = 0;
+        size_t i = 0;
         while (i < zones.count) {
                 if (!zone_merge(i, i + 1))
@@ -777 +777 @@
  *
  */
-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 +800 @@
                     buddy_conf_size(order));
                 
-                count_t i;
+                size_t i;
                 for (i = 0; i < count; i++)
                         frame_initialize(&zone->frames[i]);
@@ -820 +820 @@
  *
  */
-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 +841 @@
  *
  */
-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 +856 @@
                  * 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 +869 @@
                                 
                                 bool overlap = false;
-                                count_t i;
+                                size_t i;
                                 for (i = 0; i < init.cnt; i++)
                                         if (overlaps(addr, PFN2ADDR(confcount),
@@ -887 +887 @@
                 }
                 
-                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 +899 @@
                 /* 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 +912 @@
         
         /* 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 +931 @@
 
 /** 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 +947 @@
 }
 
-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 +974 @@
  *
  */
-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 +987 @@
          * 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 +1005 @@
                             FRAME_TO_ZONE_FLAGS(flags), hint);
                 
-                if (znum == (count_t) -1) {
+                if (znum == (size_t) -1) {
                         spinlock_unlock(&zones.lock);
                         interrupts_restore(ipl);
@@ -1020 +1020 @@
         }
         
-        if (znum == (count_t) -1) {
+        if (znum == (size_t) -1) {
                 if (flags & FRAME_ATOMIC) {
                         spinlock_unlock(&zones.lock);
@@ -1028 +1028 @@
                 
 #ifdef CONFIG_DEBUG
-                count_t avail = total_frames_free();
+                size_t avail = total_frames_free();
 #endif
                 
@@ -1039 +1039 @@
                 
 #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 +1049 @@
                 else
                         mem_avail_req = size;
-                count_t gen = mem_avail_gen;
+                size_t gen = mem_avail_gen;
                 
                 while (gen == mem_avail_gen)
@@ -1096 +1096 @@
          */
         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 +1135 @@
          * 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 +1146 @@
 
 /** 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 +1183 @@
                     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 +1208 @@
         
         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 +1242 @@
          */
         
-        count_t i;
+        size_t i;
         for (i = 0;; i++) {
                 ipl_t ipl = interrupts_disable();
@@ -1254 +1254 @@
                 
                 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 +1264 @@
                 bool available = zone_flags_available(flags);
                 
-                printf("%-2" PRIc, i);
+                printf("%-2" PRIs, i);
                 
 #ifdef __32_BITS__
@@ -1274 +1274 @@
 #endif
                 
-                printf(" %12" PRIc " %c%c%c      ", count,
+                printf(" %12" PRIs " %c%c%c      ", count,
                     available ? 'A' : ' ',
                     (flags & ZONE_RESERVED) ? 'R' : ' ',
@@ -1280 +1280 @@
                 
                 if (available)
-                        printf("%12" PRIc " %12" PRIc,
+                        printf("%12" PRIs " %12" PRIs,
                             free_count, busy_count);
                 
@@ -1292 +1292 @@
  *
  */
-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 +1306 @@
         }
         
-        if (znum == (count_t) -1) {
+        if (znum == (size_t) -1) {
                 spinlock_unlock(&zones.lock);
                 interrupts_restore(ipl);
@@ -1315 +1315 @@
         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 +1324 @@
         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 +1334 @@
         
         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)));
         }

kernel/generic/src/mm/slab.c

@@ -157 +157 @@
         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 +178 @@
         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 +216 @@
  * @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 +244 @@
  * @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 +372 @@
  * @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 +650 @@
  * @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 +772 @@
 
 /* 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);

kernel/generic/src/mm/tlb.c

@@ -80 +80 @@
  */
 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 +109 @@
                          * 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 +144 @@
         asid_t asid;
         uintptr_t page;
-        count_t count;
+        size_t count;
         unsigned int i;
         

kernel/generic/src/printf/printf_core.c

@@ -175 +175 @@
 static int print_char(const char ch, int width, uint32_t flags, printf_spec_t *ps)
 {
-        count_t counter = 0;
+        size_t counter = 0;
         if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
                 while (--width > 0) {
@@ -213 +213 @@
 static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)
 {
-        count_t counter = 0;
+        size_t counter = 0;
         if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
                 while (--width > 0) {
@@ -256 +256 @@
 
         /* Print leading spaces. */
-        count_t strw = str_length(str);
+        size_t strw = str_length(str);
         if (precision == 0)
                 precision = strw;
 
         /* Left padding */
-        count_t counter = 0;
+        size_t counter = 0;
         width -= precision;
         if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
@@ -312 +312 @@
         
         /* Left padding */
-        count_t counter = 0;
+        size_t counter = 0;
         width -= precision;
         if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
@@ -434 +434 @@
         
         width -= precision + size - number_size;
-        count_t counter = 0;
+        size_t counter = 0;
         
         if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
@@ -597 +597 @@
         size_t j = 0;    /* Index to the first not printed nonformating character */
         
-        count_t counter = 0;  /* Number of characters printed */
+        size_t counter = 0;   /* Number of characters printed */
         int retval;           /* Return values from nested functions */
         

kernel/generic/src/printf/vprintf.c

@@ -47 +47 @@
 {
         size_t offset = 0;
-        count_t chars = 0;
+        size_t chars = 0;
         
         while (offset < size) {
@@ -60 +60 @@
 {
         size_t offset = 0;
-        count_t chars = 0;
+        size_t chars = 0;
         
         while (offset < size) {
@@ -74 +74 @@
 {
         size_t offset = 0;
-        count_t chars = 0;
+        size_t chars = 0;
         wchar_t uc;
         

kernel/generic/src/printf/vsnprintf.c

@@ -83 +83 @@
                  * of string
                  */
-                index_t index = 0;
+                size_t index = 0;
                 
                 while (index < size) {
@@ -131 +131 @@
 static int vsnprintf_wstr_write(const wchar_t *str, size_t size, vsnprintf_data_t *data)
 {
-        index_t index = 0;
+        size_t index = 0;
         
         while (index < (size / sizeof(wchar_t))) {

kernel/generic/src/proc/scheduler.c

@@ -709 +709 @@
 
                 spinlock_lock(&cpus[cpu].lock);
-                printf("cpu%u: address=%p, nrdy=%ld, needs_relink=%" PRIc "\n",
+                printf("cpu%u: address=%p, nrdy=%ld, needs_relink=%" PRIs "\n",
                     cpus[cpu].id, &cpus[cpu], atomic_get(&cpus[cpu].nrdy),
                     cpus[cpu].needs_relink);

kernel/generic/src/synch/futex.c

@@ -60 +60 @@
 
 static futex_t *futex_find(uintptr_t paddr);
-static index_t futex_ht_hash(unative_t *key);
-static bool futex_ht_compare(unative_t *key, count_t keys, link_t *item);
+static size_t futex_ht_hash(unative_t *key);
+static bool futex_ht_compare(unative_t *key, size_t keys, link_t *item);
 static void futex_ht_remove_callback(link_t *item);
 
@@ -289 +289 @@
  * @return Index into futex hash table.
  */
-index_t futex_ht_hash(unative_t *key)
-{
-        return *key & (FUTEX_HT_SIZE-1);
+size_t futex_ht_hash(unative_t *key)
+{
+        return (*key & (FUTEX_HT_SIZE - 1));
 }
 
@@ -301 +301 @@
  * @return True if the item matches the key. False otherwise.
  */
-bool futex_ht_compare(unative_t *key, count_t keys, link_t *item)
+bool futex_ht_compare(unative_t *key, size_t keys, link_t *item)
 {
         futex_t *futex;

kernel/generic/src/synch/spinlock.c

@@ -76 +76 @@
 void spinlock_lock_debug(spinlock_t *sl)
 {
-        count_t i = 0;
+        size_t i = 0;
         bool deadlock_reported = false;
 

kernel/generic/src/synch/waitq.c

@@ -416 +416 @@
 {
         thread_t *t;
-        count_t count = 0;
+        size_t count = 0;
 
 loop:   

kernel/generic/src/time/clock.c

@@ -135 +135 @@
         timeout_handler_t f;
         void *arg;
-        count_t missed_clock_ticks = CPU->missed_clock_ticks;
+        size_t missed_clock_ticks = CPU->missed_clock_ticks;
         unsigned int i;