Changeset 357b5f5 in mainline for kernel/generic/src

Timestamp:

2011-01-23T20:09:13Z (15 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

fdb9982c

Parents:

cead2aa (diff), 7e36c8d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge mainline changes.

Location:

kernel/generic/src

Files:

• adt/avl.c (modified) (1 diff)
• adt/hash_table.c (modified) (3 diffs)
• console/cmd.c (modified) (9 diffs)
• console/console.c (modified) (5 diffs)
• console/kconsole.c (modified) (4 diffs)
• ddi/ddi.c (modified) (2 diffs)
• ddi/device.c (modified) (1 diff)
• ddi/irq.c (modified) (11 diffs)
• interrupt/interrupt.c (modified) (3 diffs)
• ipc/event.c (modified) (6 diffs)
• ipc/ipc.c (modified) (8 diffs)
• ipc/ipcrsc.c (modified) (2 diffs)
• ipc/irq.c (modified) (10 diffs)
• ipc/kbox.c (modified) (2 diffs)
• ipc/sysipc.c (modified) (54 diffs)
• lib/memstr.c (modified) (1 diff)
• lib/rd.c (modified) (1 diff)
• main/main.c (modified) (2 diffs)
• mm/as.c (modified) (1 diff)
• mm/slab.c (modified) (3 diffs)
• proc/program.c (modified) (2 diffs)
• proc/task.c (modified) (8 diffs)
• proc/thread.c (modified) (8 diffs)
• security/cap.c (modified) (5 diffs)
• synch/futex.c (modified) (8 diffs)
• synch/smc.c (modified) (1 diff)
• syscall/syscall.c (modified) (9 diffs)
• sysinfo/stats.c (modified) (1 diff)
• sysinfo/sysinfo.c (modified) (10 diffs)
• time/clock.c (modified) (2 diffs)
• udebug/udebug.c (modified) (2 diffs)
• udebug/udebug_ipc.c (modified) (6 diffs)
• udebug/udebug_ops.c (modified) (7 diffs)

kernel/generic/src/adt/avl.c

@@ -723 +723 @@
 void avltree_walk(avltree_t *t, avltree_walker_t walker, void *arg)
 {
-        _avltree_walk(t->root, walker, arg);
+        if (t->root)
+                _avltree_walk(t->root, walker, arg);
 }
 

kernel/generic/src/adt/hash_table.c

@@ -82 +82 @@
  * @param item Item to be inserted into the hash table.
  */
-void hash_table_insert(hash_table_t *h, unative_t key[], link_t *item)
+void hash_table_insert(hash_table_t *h, sysarg_t key[], link_t *item)
 {
         size_t chain;
@@ -105 +105 @@
  * @return Matching item on success, NULL if there is no such item.
  */
-link_t *hash_table_find(hash_table_t *h, unative_t key[])
+link_t *hash_table_find(hash_table_t *h, sysarg_t key[])
 {
         link_t *cur;
@@ -138 +138 @@
  * @param keys Number of keys in the key array.
  */
-void hash_table_remove(hash_table_t *h, unative_t key[], size_t keys)
+void hash_table_remove(hash_table_t *h, sysarg_t key[], size_t keys)
 {
         size_t chain;

kernel/generic/src/console/cmd.c

@@ -601 +601 @@
         
         /* This doesn't have to be very accurate */
-        unative_t sec = uptime->seconds1;
+        sysarg_t sec = uptime->seconds1;
         
         printf("Up %" PRIun " days, %" PRIun " hours, %" PRIun " minutes, %" PRIun " seconds\n",
@@ -656 +656 @@
         uintptr_t symaddr;
         char *symbol;
-        unative_t (*fnc)(void);
+        sysarg_t (*fnc)(void);
         fncptr_t fptr;
         int rc;
@@ -672 +672 @@
 
                 ipl = interrupts_disable();
-                fnc = (unative_t (*)(void)) arch_construct_function(&fptr,
+                fnc = (sysarg_t (*)(void)) arch_construct_function(&fptr,
                     (void *) symaddr, (void *) cmd_call0);
                 printf("Calling %s() (%p)\n", symbol, (void *) symaddr);
@@ -720 +720 @@
         uintptr_t symaddr;
         char *symbol;
-        unative_t (*fnc)(unative_t, ...);
-        unative_t arg1 = argv[1].intval;
+        sysarg_t (*fnc)(sysarg_t, ...);
+        sysarg_t arg1 = argv[1].intval;
         fncptr_t fptr;
         int rc;
@@ -737 +737 @@
 
                 ipl = interrupts_disable();
-                fnc = (unative_t (*)(unative_t, ...))
+                fnc = (sysarg_t (*)(sysarg_t, ...))
                     arch_construct_function(&fptr, (void *) symaddr,
                     (void *) cmd_call1);
@@ -756 +756 @@
         uintptr_t symaddr;
         char *symbol;
-        unative_t (*fnc)(unative_t, unative_t, ...);
-        unative_t arg1 = argv[1].intval;
-        unative_t arg2 = argv[2].intval;
+        sysarg_t (*fnc)(sysarg_t, sysarg_t, ...);
+        sysarg_t arg1 = argv[1].intval;
+        sysarg_t arg2 = argv[2].intval;
         fncptr_t fptr;
         int rc;
@@ -774 +774 @@
 
                 ipl = interrupts_disable();
-                fnc = (unative_t (*)(unative_t, unative_t, ...))
+                fnc = (sysarg_t (*)(sysarg_t, sysarg_t, ...))
                     arch_construct_function(&fptr, (void *) symaddr,
                     (void *) cmd_call2);
@@ -792 +792 @@
         uintptr_t symaddr;
         char *symbol;
-        unative_t (*fnc)(unative_t, unative_t, unative_t, ...);
-        unative_t arg1 = argv[1].intval;
-        unative_t arg2 = argv[2].intval;
-        unative_t arg3 = argv[3].intval;
+        sysarg_t (*fnc)(sysarg_t, sysarg_t, sysarg_t, ...);
+        sysarg_t arg1 = argv[1].intval;
+        sysarg_t arg2 = argv[2].intval;
+        sysarg_t arg3 = argv[3].intval;
         fncptr_t fptr;
         int rc;
@@ -811 +811 @@
 
                 ipl = interrupts_disable();
-                fnc = (unative_t (*)(unative_t, unative_t, unative_t, ...))
+                fnc = (sysarg_t (*)(sysarg_t, sysarg_t, sysarg_t, ...))
                     arch_construct_function(&fptr, (void *) symaddr,
                     (void *) cmd_call3);

kernel/generic/src/console/console.c

@@ -162 +162 @@
         ddi_parea_register(&klog_parea);
         
-        sysinfo_set_item_val("klog.faddr", NULL, (unative_t) faddr);
+        sysinfo_set_item_val("klog.faddr", NULL, (sysarg_t) faddr);
         sysinfo_set_item_val("klog.pages", NULL, KLOG_PAGES);
         
@@ -193 +193 @@
 
 /** Tell kernel to get keyboard/console access again */
-unative_t sys_debug_enable_console(void)
+sysarg_t sys_debug_enable_console(void)
 {
 #ifdef CONFIG_KCONSOLE
@@ -204 +204 @@
 
 /** Tell kernel to relinquish keyboard/console access */
-unative_t sys_debug_disable_console(void)
+sysarg_t sys_debug_disable_console(void)
 {
         release_console();
@@ -333 +333 @@
  *
  */
-unative_t sys_klog(int fd, const void *buf, size_t size)
+sysarg_t sys_klog(int fd, const void *buf, size_t size)
 {
         char *data;
@@ -339 +339 @@
         
         if (size > PAGE_SIZE)
-                return (unative_t) ELIMIT;
+                return (sysarg_t) ELIMIT;
         
         if (size > 0) {
                 data = (char *) malloc(size + 1, 0);
                 if (!data)
-                        return (unative_t) ENOMEM;
+                        return (sysarg_t) ENOMEM;
                 
                 rc = copy_from_uspace(data, buf, size);
                 if (rc) {
                         free(data);
-                        return (unative_t) rc;
+                        return (sysarg_t) rc;
                 }
                 data[size] = 0;

kernel/generic/src/console/kconsole.c

@@ -426 +426 @@
 
 NO_TRACE static bool parse_int_arg(const char *text, size_t len,
-    unative_t *result)
+    sysarg_t *result)
 {
         bool isaddr = false;
@@ -461 +461 @@
                 case EOK:
                         if (isaddr)
-                                *result = (unative_t) symaddr;
+                                *result = (sysarg_t) symaddr;
                         else if (isptr)
-                                *result = **((unative_t **) symaddr);
+                                *result = **((sysarg_t **) symaddr);
                         else
-                                *result = *((unative_t *) symaddr);
+                                *result = *((sysarg_t *) symaddr);
                         break;
                 default:
@@ -483 +483 @@
                         return false;
                 case EOK:
-                        *result = (unative_t) value;
+                        *result = (sysarg_t) value;
                         if (isptr)
-                                *result = *((unative_t *) *result);
+                                *result = *((sysarg_t *) *result);
                         break;
                 default:
@@ -629 +629 @@
                                             cmdline + start + 1,
                                             (end - start) - 1);
-                                        cmd->argv[i].intval = (unative_t) buf;
+                                        cmd->argv[i].intval = (sysarg_t) buf;
                                         cmd->argv[i].vartype = ARG_TYPE_STRING;
                                 } else {

kernel/generic/src/ddi/ddi.c

@@ -232 +232 @@
  *
  */
-unative_t sys_physmem_map(unative_t phys_base, unative_t virt_base,
-    unative_t pages, unative_t flags)
-{
-        return (unative_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base,
+sysarg_t sys_physmem_map(sysarg_t phys_base, sysarg_t virt_base,
+    sysarg_t pages, sysarg_t flags)
+{
+        return (sysarg_t) ddi_physmem_map(ALIGN_DOWN((uintptr_t) phys_base,
             FRAME_SIZE), ALIGN_DOWN((uintptr_t) virt_base, PAGE_SIZE),
             (size_t) pages, (int) flags);
@@ -247 +247 @@
  *
  */
-unative_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
+sysarg_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
 {
         ddi_ioarg_t arg;
         int rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t));
         if (rc != 0)
-                return (unative_t) rc;
-        
-        return (unative_t) ddi_iospace_enable((task_id_t) arg.task_id,
+                return (sysarg_t) rc;
+        
+        return (sysarg_t) ddi_iospace_enable((task_id_t) arg.task_id,
             (uintptr_t) arg.ioaddr, (size_t) arg.size);
 }
 
-/** Disable or enable specified interrupts.
- * 
- * @param irq the interrupt to be enabled/disabled.
- * @param enable if true enable the interrupt, disable otherwise.
- * 
- * @retutn Zero on success, error code otherwise.
- */
-unative_t sys_interrupt_enable(int irq, int enable)
-{
-/* FIXME: this needs to be generic code, or better not be in kernel at all. */
-#if 0
-        cap_t task_cap = cap_get(TASK);
-        if (!(task_cap & CAP_IRQ_REG))
-                return EPERM;
-                
-        if (irq < 0 || irq > 16) {
-                return EINVAL;
-        }
-        
-        uint16_t irq_mask = (uint16_t)(1 << irq);
-        if (enable) {
-                trap_virtual_enable_irqs(irq_mask);
-        } else {
-                trap_virtual_disable_irqs(irq_mask);
-        }
-        
-#endif
-        return 0;
-}
-
 /** @}
  */

kernel/generic/src/ddi/device.c

@@ -54 +54 @@
 }
 
-unative_t sys_device_assign_devno(void)
+sysarg_t sys_device_assign_devno(void)
 {
-        return (unative_t) device_assign_devno();
+        return (sysarg_t) device_assign_devno();
 }
 

kernel/generic/src/ddi/irq.c

@@ -106 +106 @@
  *
  */
-static size_t irq_ht_hash(unative_t *key);
-static bool irq_ht_compare(unative_t *key, size_t keys, link_t *item);
+static size_t irq_ht_hash(sysarg_t *key);
+static bool irq_ht_compare(sysarg_t *key, size_t keys, link_t *item);
 static void irq_ht_remove(link_t *item);
 
@@ -123 +123 @@
  *
  */
-static size_t irq_lin_hash(unative_t *key);
-static bool irq_lin_compare(unative_t *key, size_t keys, link_t *item);
+static size_t irq_lin_hash(sysarg_t *key);
+static bool irq_lin_compare(sysarg_t *key, size_t keys, link_t *item);
 static void irq_lin_remove(link_t *item);
 
@@ -136 +136 @@
 static size_t buckets;
 
+/** Last valid INR. */
+inr_t last_inr = 0;
+
 /** Initialize IRQ subsystem.
  *
@@ -145 +148 @@
 {
         buckets = chains;
+        last_inr = inrs - 1;
+
         /*
          * Be smart about the choice of the hash table operations.
@@ -194 +199 @@
 void irq_register(irq_t *irq)
 {
-        unative_t key[] = {
-                (unative_t) irq->inr,
-                (unative_t) irq->devno
+        sysarg_t key[] = {
+                (sysarg_t) irq->inr,
+                (sysarg_t) irq->devno
         };
         
@@ -212 +217 @@
 {
         link_t *lnk;
-        unative_t key[] = {
-                (unative_t) inr,
-                (unative_t) -1    /* Search will use claim() instead of devno */
+        sysarg_t key[] = {
+                (sysarg_t) inr,
+                (sysarg_t) -1    /* Search will use claim() instead of devno */
         };
         
@@ -235 +240 @@
 {
         link_t *lnk;
-        unative_t key[] = {
-                (unative_t) inr,
-                (unative_t) -1    /* Search will use claim() instead of devno */
+        sysarg_t key[] = {
+                (sysarg_t) inr,
+                (sysarg_t) -1    /* Search will use claim() instead of devno */
         };
         
@@ -306 +311 @@
  *
  */
-size_t irq_ht_hash(unative_t key[])
+size_t irq_ht_hash(sysarg_t key[])
 {
         inr_t inr = (inr_t) key[KEY_INR];
@@ -333 +338 @@
  *
  */
-bool irq_ht_compare(unative_t key[], size_t keys, link_t *item)
+bool irq_ht_compare(sysarg_t key[], size_t keys, link_t *item)
 {
         irq_t *irq = hash_table_get_instance(item, irq_t, link);
@@ -381 +386 @@
  *
  */
-size_t irq_lin_hash(unative_t key[])
+size_t irq_lin_hash(sysarg_t key[])
 {
         inr_t inr = (inr_t) key[KEY_INR];
@@ -408 +413 @@
  *
  */
-bool irq_lin_compare(unative_t key[], size_t keys, link_t *item)
+bool irq_lin_compare(sysarg_t key[], size_t keys, link_t *item)
 {
         irq_t *irq = list_get_instance(item, irq_t, link);

kernel/generic/src/interrupt/interrupt.c

@@ -197 +197 @@
                 /* Notify the subscriber that a fault occurred. */
                 event_notify_3(EVENT_FAULT, LOWER32(TASK->taskid),
-                    UPPER32(TASK->taskid), (unative_t) THREAD);
+                    UPPER32(TASK->taskid), (sysarg_t) THREAD);
                 
 #ifdef CONFIG_UDEBUG
@@ -207 +207 @@
         task_kill(TASK->taskid);
         thread_exit();
+}
+
+/** Get istate structure of a thread.
+ *
+ * Get pointer to the istate structure at the bottom of the kernel stack.
+ *
+ * This function can be called in interrupt or user context. In interrupt
+ * context the istate structure is created by the low-level exception
+ * handler. In user context the istate structure is created by the
+ * low-level syscall handler.
+ */
+istate_t *istate_get(thread_t *thread)
+{
+        /*
+         * The istate structure should be right at the bottom of the kernel
+         * stack.
+         */
+        return (istate_t *) ((uint8_t *) thread->kstack + THREAD_STACK_SIZE -
+            sizeof(istate_t));
 }
 
@@ -263 +282 @@
                 
                 const char *symbol =
-                    symtab_fmt_name_lookup((unative_t) exc_table[i].handler);
+                    symtab_fmt_name_lookup((sysarg_t) exc_table[i].handler);
                 
 #ifdef __32_BITS__

kernel/generic/src/ipc/event.c

@@ -57 +57 @@
                 events[i].answerbox = NULL;
                 events[i].counter = 0;
-                events[i].method = 0;
+                events[i].imethod = 0;
         }
 }
 
-static int event_subscribe(event_type_t evno, unative_t method,
+static int event_subscribe(event_type_t evno, sysarg_t imethod,
     answerbox_t *answerbox)
 {
@@ -73 +73 @@
         if (events[evno].answerbox == NULL) {
                 events[evno].answerbox = answerbox;
-                events[evno].method = method;
+                events[evno].imethod = imethod;
                 events[evno].counter = 0;
                 res = EOK;
@@ -84 +84 @@
 }
 
-unative_t sys_event_subscribe(unative_t evno, unative_t method)
+sysarg_t sys_event_subscribe(sysarg_t evno, sysarg_t imethod)
 {
-        return (unative_t) event_subscribe((event_type_t) evno, (unative_t)
-            method, &TASK->answerbox);
+        return (sysarg_t) event_subscribe((event_type_t) evno, (sysarg_t)
+            imethod, &TASK->answerbox);
 }
 
@@ -113 +113 @@
                         events[i].answerbox = NULL;
                         events[i].counter = 0;
-                        events[i].method = 0;
+                        events[i].imethod = 0;
                 }
                 spinlock_unlock(&events[i].lock);
@@ -119 +119 @@
 }
 
-void event_notify(event_type_t evno, unative_t a1, unative_t a2, unative_t a3,
-    unative_t a4, unative_t a5)
+void event_notify(event_type_t evno, sysarg_t a1, sysarg_t a2, sysarg_t a3,
+    sysarg_t a4, sysarg_t a5)
 {
         ASSERT(evno < EVENT_END);
@@ -130 +130 @@
                         call->flags |= IPC_CALL_NOTIF;
                         call->priv = ++events[evno].counter;
-                        IPC_SET_METHOD(call->data, events[evno].method);
+                        IPC_SET_IMETHOD(call->data, events[evno].imethod);
                         IPC_SET_ARG1(call->data, a1);
                         IPC_SET_ARG2(call->data, a2);

kernel/generic/src/ipc/ipc.c

@@ -270 +270 @@
  *
  */
-void ipc_backsend_err(phone_t *phone, call_t *call, unative_t err)
+void ipc_backsend_err(phone_t *phone, call_t *call, sysarg_t err)
 {
         call->data.phone = phone;
@@ -367 +367 @@
                 
                 call_t *call = ipc_call_alloc(0);
-                IPC_SET_METHOD(call->data, IPC_M_PHONE_HUNGUP);
+                IPC_SET_IMETHOD(call->data, IPC_M_PHONE_HUNGUP);
                 call->flags |= IPC_CALL_DISCARD_ANSWER;
                 _ipc_call(phone, box, call);
@@ -547 +547 @@
                          * disconnected.
                          */
-                        IPC_SET_METHOD(call->data, IPC_M_PHONE_HUNGUP);
+                        IPC_SET_IMETHOD(call->data, IPC_M_PHONE_HUNGUP);
                         call->flags |= IPC_CALL_DISCARD_ANSWER;
                         _ipc_call(phone, box, call);
@@ -655 +655 @@
                     (call->flags & IPC_CALL_NOTIF));
                 
-                /*
-                 * Record the receipt of this call in the current task's counter
-                 * of active calls. IPC_M_PHONE_HUNGUP calls do not contribute
-                 * to this counter so do not record answers to them either.
-                 */
-                if (!(call->flags & IPC_CALL_DISCARD_ANSWER))
-                        atomic_dec(&TASK->active_calls);
-                
                 ipc_call_free(call);
         }
@@ -714 +706 @@
                                 break;
                         case IPC_PHONE_CONNECTED:
-                                printf("connected to: %p ",
-                                    task->phones[i].callee);
+                                printf("connected to: %p (%" PRIu64 ") ",
+                                    task->phones[i].callee,
+                                    task->phones[i].callee->task->taskid);
                                 break;
                         case IPC_PHONE_SLAMMED:
@@ -749 +742 @@
                     " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call,
                     call->sender->taskid,
-                    IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
+                    IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data),
                     IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
                     IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
@@ -765 +758 @@
                     " A4:%" PRIun " A5:%" PRIun " Flags:%x\n", call,
                     call->sender->taskid,
-                    IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
+                    IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data),
                     IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
                     IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),
@@ -779 +772 @@
                 printf("Callid:%p M:%" PRIun " A1:%" PRIun " A2:%" PRIun
                     " A3:%" PRIun " A4:%" PRIun " A5:%" PRIun " Flags:%x\n",
-                    call, IPC_GET_METHOD(call->data), IPC_GET_ARG1(call->data),
+                    call, IPC_GET_IMETHOD(call->data), IPC_GET_ARG1(call->data),
                     IPC_GET_ARG2(call->data), IPC_GET_ARG3(call->data),
                     IPC_GET_ARG4(call->data), IPC_GET_ARG5(call->data),

kernel/generic/src/ipc/ipcrsc.c

@@ -144 +144 @@
  *
  */
-call_t *get_call(unative_t callid)
+call_t *get_call(sysarg_t callid)
 {
         link_t *lst;
@@ -153 +153 @@
             lst != &TASK->answerbox.dispatched_calls; lst = lst->next) {
                 call_t *call = list_get_instance(lst, call_t, link);
-                if ((unative_t) call == callid) {
+                if ((sysarg_t) call == callid) {
                         result = call;
                         break;

kernel/generic/src/ipc/irq.c

@@ -42 +42 @@
  *
  * The structure of a notification message is as follows:
- * - METHOD: method as registered by the SYS_IPC_REGISTER_IRQ syscall
+ * - IMETHOD: interface and method as registered by the SYS_IPC_REGISTER_IRQ
+ *            syscall
  * - ARG1: payload modified by a 'top-half' handler
  * - ARG2: payload modified by a 'top-half' handler
@@ -49 +50 @@
  * - ARG5: payload modified by a 'top-half' handler
  * - in_phone_hash: interrupt counter (may be needed to assure correct order
- *         in multithreaded drivers)
+ *                  in multithreaded drivers)
  *
  * Note on synchronization for ipc_irq_register(), ipc_irq_unregister(),
@@ -130 +131 @@
 /** Register an answerbox as a receiving end for IRQ notifications.
  *
- * @param box    Receiving answerbox.
- * @param inr    IRQ number.
- * @param devno  Device number.
- * @param method Method to be associated with the notification.
- * @param ucode  Uspace pointer to top-half pseudocode.
- *
- * @return EBADMEM, ENOENT or EEXISTS on failure or 0 on success.
+ * @param box           Receiving answerbox.
+ * @param inr           IRQ number.
+ * @param devno         Device number.
+ * @param imethod       Interface and method to be associated with the
+ *                      notification.
+ * @param ucode         Uspace pointer to top-half pseudocode.
+ * @return              EOK on success or a negative error code.
  *
  */
 int ipc_irq_register(answerbox_t *box, inr_t inr, devno_t devno,
-    unative_t method, irq_code_t *ucode)
-{
-        unative_t key[] = {
-                (unative_t) inr,
-                (unative_t) devno
+    sysarg_t imethod, irq_code_t *ucode)
+{
+        sysarg_t key[] = {
+                (sysarg_t) inr,
+                (sysarg_t) devno
         };
+
+        if ((inr < 0) || (inr > last_inr))
+                return ELIMIT;
         
         irq_code_t *code;
@@ -167 +171 @@
         irq->notif_cfg.notify = true;
         irq->notif_cfg.answerbox = box;
-        irq->notif_cfg.method = method;
+        irq->notif_cfg.imethod = imethod;
         irq->notif_cfg.code = code;
         irq->notif_cfg.counter = 0;
@@ -206 +210 @@
 /** Unregister task from IRQ notification.
  *
- * @param box   Answerbox associated with the notification.
- * @param inr   IRQ number.
- * @param devno Device number.
- *
+ * @param box           Answerbox associated with the notification.
+ * @param inr           IRQ number.
+ * @param devno         Device number.
+ * @return              EOK on success or a negative error code.
  */
 int ipc_irq_unregister(answerbox_t *box, inr_t inr, devno_t devno)
 {
-        unative_t key[] = {
-                (unative_t) inr,
-                (unative_t) devno
+        sysarg_t key[] = {
+                (sysarg_t) inr,
+                (sysarg_t) devno
         };
+
+        if ((inr < 0) || (inr > last_inr))
+                return ELIMIT;
         
         irq_spinlock_lock(&irq_uspace_hash_table_lock, true);
@@ -290 +297 @@
                 }
                 
-                unative_t key[2];
+                sysarg_t key[2];
                 key[0] = irq->inr;
                 key[1] = irq->devno;
@@ -397 +404 @@
                             (uint32_t) code->cmds[i].value);
                         break;
+                case CMD_PIO_WRITE_A_8:
+                        if (srcarg) {
+                                pio_write_8((ioport8_t *) code->cmds[i].addr,
+                                    (uint8_t) scratch[srcarg]);
+                        }
+                        break;
+                case CMD_PIO_WRITE_A_16:
+                        if (srcarg) {
+                                pio_write_16((ioport16_t *) code->cmds[i].addr,
+                                    (uint16_t) scratch[srcarg]);
+                        }
+                        break;
+                case CMD_PIO_WRITE_A_32:
+                        if (srcarg) {
+                                pio_write_32((ioport32_t *) code->cmds[i].addr,
+                                    (uint32_t) scratch[srcarg]);
+                        }
+                        break;
                 case CMD_BTEST:
                         if ((srcarg) && (dstarg)) {
@@ -444 +469 @@
                 
                 /* Set up args */
-                IPC_SET_METHOD(call->data, irq->notif_cfg.method);
+                IPC_SET_IMETHOD(call->data, irq->notif_cfg.imethod);
                 IPC_SET_ARG1(call->data, irq->notif_cfg.scratch[1]);
                 IPC_SET_ARG2(call->data, irq->notif_cfg.scratch[2]);
@@ -465 +490 @@
  *
  */
-void ipc_irq_send_msg(irq_t *irq, unative_t a1, unative_t a2, unative_t a3,
-    unative_t a4, unative_t a5)
+void ipc_irq_send_msg(irq_t *irq, sysarg_t a1, sysarg_t a2, sysarg_t a3,
+    sysarg_t a4, sysarg_t a5)
 {
         irq_spinlock_lock(&irq->lock, true);
@@ -481 +506 @@
                 call->priv = ++irq->notif_cfg.counter;
                 
-                IPC_SET_METHOD(call->data, irq->notif_cfg.method);
+                IPC_SET_IMETHOD(call->data, irq->notif_cfg.imethod);
                 IPC_SET_ARG1(call->data, a1);
                 IPC_SET_ARG2(call->data, a2);

kernel/generic/src/ipc/kbox.c

@@ -167 +167 @@
                         continue;  /* Try again. */
                 
-                switch (IPC_GET_METHOD(call->data)) {
+                switch (IPC_GET_IMETHOD(call->data)) {
                 
                 case IPC_M_DEBUG_ALL:
@@ -192 +192 @@
 }
 
-
 /** Connect phone to a task kernel-box specified by id.
  *

kernel/generic/src/ipc/sysipc.c

@@ -49 +49 @@
 #include <syscall/copy.h>
 #include <security/cap.h>
+#include <console/console.h>
 #include <mm/as.h>
 #include <print.h>
@@ -68 +69 @@
  *
  */
-static int phone_get(unative_t phoneid, phone_t **phone)
+static int phone_get(sysarg_t phoneid, phone_t **phone)
 {
         if (phoneid >= IPC_MAX_PHONES)
@@ -77 +78 @@
 }
 
-/** Decide if the method is a system method.
- *
- * @param method Method to be decided.
- *
- * @return true if the method is a system method.
- *
- */
-static inline bool method_is_system(unative_t method)
-{
-        if (method <= IPC_M_LAST_SYSTEM)
+/** Decide if the interface and method is a system method.
+ *
+ * @param imethod Interface and method to be decided.
+ *
+ * @return True if the interface and method is a system
+ *         interface and method.
+ *
+ */
+static inline bool method_is_system(sysarg_t imethod)
+{
+        if (imethod <= IPC_M_LAST_SYSTEM)
                 return true;
         
@@ -92 +94 @@
 }
 
-/** Decide if the message with this method is forwardable.
- *
- * - some system messages may be forwarded, for some of them
- *   it is useless
- *
- * @param method Method to be decided.
- *
- * @return true if the method is forwardable.
- *
- */
-static inline bool method_is_forwardable(unative_t method)
-{
-        switch (method) {
+/** Decide if the message with this interface and method is forwardable.
+ *
+ * Some system messages may be forwarded, for some of them
+ * it is useless.
+ *
+ * @param imethod Interface and method to be decided.
+ *
+ * @return True if the interface and method is forwardable.
+ *
+ */
+static inline bool method_is_forwardable(sysarg_t imethod)
+{
+        switch (imethod) {
         case IPC_M_CONNECTION_CLONE:
         case IPC_M_CONNECT_ME:
@@ -115 +117 @@
 }
 
-/** Decide if the message with this method is immutable on forward.
- *
- * - some system messages may be forwarded but their content cannot be altered
- *
- * @param method Method to be decided.
- *
- * @return true if the method is immutable on forward.
- *
- */
-static inline bool method_is_immutable(unative_t method)
-{
-        switch (method) {
+/** Decide if the message with this interface and method is immutable on forward.
+ *
+ * Some system messages may be forwarded but their content cannot be altered.
+ *
+ * @param imethod Interface and method to be decided.
+ *
+ * @return True if the interface and method is immutable on forward.
+ *
+ */
+static inline bool method_is_immutable(sysarg_t imethod)
+{
+        switch (imethod) {
         case IPC_M_SHARE_OUT:
         case IPC_M_SHARE_IN:
@@ -152 +154 @@
 static inline bool answer_need_old(call_t *call)
 {
-        switch (IPC_GET_METHOD(call->data)) {
+        switch (IPC_GET_IMETHOD(call->data)) {
         case IPC_M_CONNECTION_CLONE:
         case IPC_M_CONNECT_ME:
@@ -196 +198 @@
                 return 0;
         
-        if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECTION_CLONE) {
+        if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECTION_CLONE) {
                 int phoneid = IPC_GET_ARG1(*olddata);
                 phone_t *phone = &TASK->phones[phoneid];
@@ -218 +220 @@
                         mutex_unlock(&phone->lock);
                 }
-        } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME) {
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECT_ME) {
                 phone_t *phone = (phone_t *) IPC_GET_ARG5(*olddata);
                 
@@ -237 +239 @@
                         mutex_unlock(&phone->lock);
                 }
-        } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_TO_ME) {
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECT_TO_ME) {
                 int phoneid = IPC_GET_ARG5(*olddata);
                 
@@ -248 +250 @@
                         /* Set 'phone hash' as arg5 of response */
                         IPC_SET_ARG5(answer->data,
-                            (unative_t) &TASK->phones[phoneid]);
-                }
-        } else if (IPC_GET_METHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
+                            (sysarg_t) &TASK->phones[phoneid]);
+                }
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_CONNECT_ME_TO) {
                 /* If the users accepted call, connect */
                 if (IPC_GET_RETVAL(answer->data) == EOK) {
@@ -256 +258 @@
                             &TASK->answerbox);
                 }
-        } else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_OUT) {
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_SHARE_OUT) {
                 if (!IPC_GET_RETVAL(answer->data)) {
                         /* Accepted, handle as_area receipt */
@@ -270 +272 @@
                         return rc;
                 }
-        } else if (IPC_GET_METHOD(*olddata) == IPC_M_SHARE_IN) {
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_SHARE_IN) {
                 if (!IPC_GET_RETVAL(answer->data)) { 
                         irq_spinlock_lock(&answer->sender->lock, true);
@@ -281 +283 @@
                         IPC_SET_RETVAL(answer->data, rc);
                 }
-        } else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_READ) {
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_DATA_READ) {
                 ASSERT(!answer->buffer);
                 if (!IPC_GET_RETVAL(answer->data)) {
@@ -310 +312 @@
                         }
                 }
-        } else if (IPC_GET_METHOD(*olddata) == IPC_M_DATA_WRITE) {
+        } else if (IPC_GET_IMETHOD(*olddata) == IPC_M_DATA_WRITE) {
                 ASSERT(answer->buffer);
                 if (!IPC_GET_RETVAL(answer->data)) {
@@ -363 +365 @@
 static int request_preprocess(call_t *call, phone_t *phone)
 {
-        switch (IPC_GET_METHOD(call->data)) {
+        switch (IPC_GET_IMETHOD(call->data)) {
         case IPC_M_CONNECTION_CLONE: {
                 phone_t *cloned_phone;
@@ -399 +401 @@
         }
         case IPC_M_CONNECT_ME:
-                IPC_SET_ARG5(call->data, (unative_t) phone);
+                IPC_SET_ARG5(call->data, (sysarg_t) phone);
                 break;
         case IPC_M_CONNECT_ME_TO: {
@@ -407 +409 @@
                 
                 /* Set arg5 for server */
-                IPC_SET_ARG5(call->data, (unative_t) &TASK->phones[newphid]);
+                IPC_SET_ARG5(call->data, (sysarg_t) &TASK->phones[newphid]);
                 call->flags |= IPC_CALL_CONN_ME_TO;
                 call->priv = newphid;
@@ -503 +505 @@
 static int process_request(answerbox_t *box, call_t *call)
 {
-        if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME) {
+        if (IPC_GET_IMETHOD(call->data) == IPC_M_CONNECT_TO_ME) {
                 int phoneid = phone_alloc(TASK);
                 if (phoneid < 0) { /* Failed to allocate phone */
@@ -514 +516 @@
         }
         
-        switch (IPC_GET_METHOD(call->data)) {
+        switch (IPC_GET_IMETHOD(call->data)) {
         case IPC_M_DEBUG_ALL:
                 return -1;
@@ -530 +532 @@
  *
  * @param phoneid Phone handle for the call.
- * @param method  Method of the call.
+ * @param imethod Interface and method of the call.
  * @param arg1    Service-defined payload argument.
  * @param arg2    Service-defined payload argument.
  * @param arg3    Service-defined payload argument.
- * @param data    Address of userspace structure where the reply call will
+ * @param data    Address of user-space structure where the reply call will
  *                be stored.
  *
@@ -541 +543 @@
  *
  */
-unative_t sys_ipc_call_sync_fast(unative_t phoneid, unative_t method,
-    unative_t arg1, unative_t arg2, unative_t arg3, ipc_data_t *data)
+sysarg_t sys_ipc_call_sync_fast(sysarg_t phoneid, sysarg_t imethod,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, ipc_data_t *data)
 {
         phone_t *phone;
         if (phone_get(phoneid, &phone) != EOK)
                 return ENOENT;
-
+        
         call_t *call = ipc_call_alloc(0);
-        IPC_SET_METHOD(call->data, method);
+        IPC_SET_IMETHOD(call->data, imethod);
         IPC_SET_ARG1(call->data, arg1);
         IPC_SET_ARG2(call->data, arg2);
@@ -579 +581 @@
                 
                 process_answer(call);
-                
         } else
                 IPC_SET_RETVAL(call->data, res);
@@ -593 +594 @@
 /** Make a synchronous IPC call allowing to transmit the entire payload.
  *
- * @param phoneid  Phone handle for the call.
- * @param question Userspace address of call data with the request.
- * @param reply    Userspace address of call data where to store the
- *                 answer.
+ * @param phoneid Phone handle for the call.
+ * @param request User-space address of call data with the request.
+ * @param reply   User-space address of call data where to store the
+ *                answer.
  *
  * @return Zero on success or an error code.
  *
  */
-unative_t sys_ipc_call_sync_slow(unative_t phoneid, ipc_data_t *question,
+sysarg_t sys_ipc_call_sync_slow(sysarg_t phoneid, ipc_data_t *request,
     ipc_data_t *reply)
 {
@@ -607 +608 @@
         if (phone_get(phoneid, &phone) != EOK)
                 return ENOENT;
-
+        
         call_t *call = ipc_call_alloc(0);
-        int rc = copy_from_uspace(&call->data.args, &question->args,
+        int rc = copy_from_uspace(&call->data.args, &request->args,
             sizeof(call->data.args));
         if (rc != 0) {
                 ipc_call_free(call);
-                return (unative_t) rc;
+                return (sysarg_t) rc;
         }
         
@@ -644 +645 @@
 }
 
-/** Check that the task did not exceed the allowed limit of asynchronous calls.
+/** Check that the task did not exceed the allowed limit of asynchronous calls
+ * made over a phone.
+ *
+ * @param phone Phone to check the limit against.
  *
  * @return 0 if limit not reached or -1 if limit exceeded.
  *
  */
-static int check_call_limit(void)
-{
-        if (atomic_preinc(&TASK->active_calls) > IPC_MAX_ASYNC_CALLS) {
-                atomic_dec(&TASK->active_calls);
+static int check_call_limit(phone_t *phone)
+{
+        if (atomic_get(&phone->active_calls) >= IPC_MAX_ASYNC_CALLS)
                 return -1;
-        }
         
         return 0;
@@ -665 +667 @@
  *
  * @param phoneid Phone handle for the call.
- * @param method  Method of the call.
+ * @param imethod Interface and method of the call.
  * @param arg1    Service-defined payload argument.
  * @param arg2    Service-defined payload argument.
@@ -677 +679 @@
  *
  */
-unative_t sys_ipc_call_async_fast(unative_t phoneid, unative_t method,
-    unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
-{
-        if (check_call_limit())
-                return IPC_CALLRET_TEMPORARY;
-        
+sysarg_t sys_ipc_call_async_fast(sysarg_t phoneid, sysarg_t imethod,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
+{
         phone_t *phone;
         if (phone_get(phoneid, &phone) != EOK)
                 return IPC_CALLRET_FATAL;
         
+        if (check_call_limit(phone))
+                return IPC_CALLRET_TEMPORARY;
+        
         call_t *call = ipc_call_alloc(0);
-        IPC_SET_METHOD(call->data, method);
+        IPC_SET_IMETHOD(call->data, imethod);
         IPC_SET_ARG1(call->data, arg1);
         IPC_SET_ARG2(call->data, arg2);
@@ -707 +709 @@
                 ipc_backsend_err(phone, call, res);
         
-        return (unative_t) call;
+        return (sysarg_t) call;
 }
 
@@ -718 +720 @@
  *
  */
-unative_t sys_ipc_call_async_slow(unative_t phoneid, ipc_data_t *data)
-{
-        if (check_call_limit())
-                return IPC_CALLRET_TEMPORARY;
-        
+sysarg_t sys_ipc_call_async_slow(sysarg_t phoneid, ipc_data_t *data)
+{
         phone_t *phone;
         if (phone_get(phoneid, &phone) != EOK)
                 return IPC_CALLRET_FATAL;
+
+        if (check_call_limit(phone))
+                return IPC_CALLRET_TEMPORARY;
 
         call_t *call = ipc_call_alloc(0);
@@ -732 +734 @@
         if (rc != 0) {
                 ipc_call_free(call);
-                return (unative_t) rc;
+                return (sysarg_t) rc;
         }
         
@@ -742 +744 @@
                 ipc_backsend_err(phone, call, res);
         
-        return (unative_t) call;
+        return (sysarg_t) call;
 }
 
@@ -751 +753 @@
  * @param callid  Hash of the call to forward.
  * @param phoneid Phone handle to use for forwarding.
- * @param method  New method to use for the forwarded call.
+ * @param imethod New interface and method to use for the forwarded call.
  * @param arg1    New value of the first argument for the forwarded call.
  * @param arg2    New value of the second argument for the forwarded call.
@@ -767 +769 @@
  *
  */
-static unative_t sys_ipc_forward_common(unative_t callid, unative_t phoneid,
-    unative_t method, unative_t arg1, unative_t arg2, unative_t arg3,
-    unative_t arg4, unative_t arg5, unsigned int mode, bool slow)
+static sysarg_t sys_ipc_forward_common(sysarg_t callid, sysarg_t phoneid,
+    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
+    sysarg_t arg4, sysarg_t arg5, unsigned int mode, bool slow)
 {
         call_t *call = get_call(callid);
@@ -784 +786 @@
         }
         
-        if (!method_is_forwardable(IPC_GET_METHOD(call->data))) {
+        if (!method_is_forwardable(IPC_GET_IMETHOD(call->data))) {
                 IPC_SET_RETVAL(call->data, EFORWARD);
                 ipc_answer(&TASK->answerbox, call);
@@ -791 +793 @@
         
         /*
-         * Userspace is not allowed to change method of system methods on
-         * forward, allow changing ARG1, ARG2, ARG3 and ARG4 by means of method,
-         * arg1, arg2 and arg3.
-         * If the method is immutable, don't change anything.
+         * Userspace is not allowed to change interface and method of system
+         * methods on forward, allow changing ARG1, ARG2, ARG3 and ARG4 by
+         * means of method, arg1, arg2 and arg3.
+         * If the interface and method is immutable, don't change anything.
          */
-        if (!method_is_immutable(IPC_GET_METHOD(call->data))) {
-                if (method_is_system(IPC_GET_METHOD(call->data))) {
-                        if (IPC_GET_METHOD(call->data) == IPC_M_CONNECT_TO_ME)
+        if (!method_is_immutable(IPC_GET_IMETHOD(call->data))) {
+                if (method_is_system(IPC_GET_IMETHOD(call->data))) {
+                        if (IPC_GET_IMETHOD(call->data) == IPC_M_CONNECT_TO_ME)
                                 phone_dealloc(IPC_GET_ARG5(call->data));
                         
-                        IPC_SET_ARG1(call->data, method);
+                        IPC_SET_ARG1(call->data, imethod);
                         IPC_SET_ARG2(call->data, arg1);
                         IPC_SET_ARG3(call->data, arg2);
@@ -813 +815 @@
                         }
                 } else {
-                        IPC_SET_METHOD(call->data, method);
+                        IPC_SET_IMETHOD(call->data, imethod);
                         IPC_SET_ARG1(call->data, arg1);
                         IPC_SET_ARG2(call->data, arg2);
@@ -829 +831 @@
 /** Forward a received call to another destination - fast version.
  *
- * In case the original method is a system method, ARG1, ARG2 and ARG3 are
- * overwritten in the forwarded message with the new method and the new
- * arg1 and arg2, respectively. Otherwise the METHOD, ARG1 and ARG2 are
- * rewritten with the new method, arg1 and arg2, respectively. Also note there
- * is a set of immutable methods, for which the new method and arguments are not
- * set and these values are ignored.
+ * In case the original interface and method is a system method, ARG1, ARG2
+ * and ARG3 are overwritten in the forwarded message with the new method and
+ * the new arg1 and arg2, respectively. Otherwise the IMETHOD, ARG1 and ARG2
+ * are rewritten with the new interface and method, arg1 and arg2, respectively.
+ * Also note there is a set of immutable methods, for which the new method and
+ * arguments are not set and these values are ignored.
  *
  * @param callid  Hash of the call to forward.
  * @param phoneid Phone handle to use for forwarding.
- * @param method  New method to use for the forwarded call.
+ * @param imethod New interface and method to use for the forwarded call.
  * @param arg1    New value of the first argument for the forwarded call.
  * @param arg2    New value of the second argument for the forwarded call.
@@ -846 +848 @@
  *
  */
-unative_t sys_ipc_forward_fast(unative_t callid, unative_t phoneid,
-    unative_t method, unative_t arg1, unative_t arg2, unsigned int mode)
-{
-        return sys_ipc_forward_common(callid, phoneid, method, arg1, arg2, 0, 0,
+sysarg_t sys_ipc_forward_fast(sysarg_t callid, sysarg_t phoneid,
+    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
+{
+        return sys_ipc_forward_common(callid, phoneid, imethod, arg1, arg2, 0, 0,
             0, mode, false); 
 }
@@ -856 +858 @@
  *
  * This function is the slow verision of the sys_ipc_forward_fast interface.
- * It can copy all five new arguments and the new method from the userspace.
- * It naturally extends the functionality of the fast version. For system
- * methods, it additionally stores the new value of arg3 to ARG4. For non-system
- * methods, it additionally stores the new value of arg3, arg4 and arg5,
- * respectively, to ARG3, ARG4 and ARG5, respectively.
+ * It can copy all five new arguments and the new interface and method from
+ * the userspace. It naturally extends the functionality of the fast version.
+ * For system methods, it additionally stores the new value of arg3 to ARG4.
+ * For non-system methods, it additionally stores the new value of arg3, arg4
+ * and arg5, respectively, to ARG3, ARG4 and ARG5, respectively.
  *
  * @param callid  Hash of the call to forward.
@@ -870 +872 @@
  *
  */
-unative_t sys_ipc_forward_slow(unative_t callid, unative_t phoneid,
+sysarg_t sys_ipc_forward_slow(sysarg_t callid, sysarg_t phoneid,
     ipc_data_t *data, unsigned int mode)
 {
@@ -877 +879 @@
             sizeof(newdata.args));
         if (rc != 0)
-                return (unative_t) rc;
+                return (sysarg_t) rc;
         
         return sys_ipc_forward_common(callid, phoneid,
-            IPC_GET_METHOD(newdata), IPC_GET_ARG1(newdata),
+            IPC_GET_IMETHOD(newdata), IPC_GET_ARG1(newdata),
             IPC_GET_ARG2(newdata), IPC_GET_ARG3(newdata),
             IPC_GET_ARG4(newdata), IPC_GET_ARG5(newdata), mode, true); 
@@ -900 +902 @@
  *
  */
-unative_t sys_ipc_answer_fast(unative_t callid, unative_t retval,
-    unative_t arg1, unative_t arg2, unative_t arg3, unative_t arg4)
+sysarg_t sys_ipc_answer_fast(sysarg_t callid, sysarg_t retval,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
 {
         /* Do not answer notification callids */
@@ -945 +947 @@
  *
  */
-unative_t sys_ipc_answer_slow(unative_t callid, ipc_data_t *data)
+sysarg_t sys_ipc_answer_slow(sysarg_t callid, ipc_data_t *data)
 {
         /* Do not answer notification callids */
@@ -982 +984 @@
  *
  */
-unative_t sys_ipc_hangup(unative_t phoneid)
+sysarg_t sys_ipc_hangup(sysarg_t phoneid)
 {
         phone_t *phone;
@@ -1008 +1010 @@
  *
  */
-unative_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
+sysarg_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
     unsigned int flags)
 {
@@ -1037 +1039 @@
                 ipc_call_free(call);
                 
-                return ((unative_t) call) | IPC_CALLID_NOTIFICATION;
+                return ((sysarg_t) call) | IPC_CALLID_NOTIFICATION;
         }
         
@@ -1046 +1048 @@
                         ipc_call_free(call);
                         goto restart;
-                } else {
-                        /*
-                         * Decrement the counter of active calls only if the
-                         * call is not an answer to IPC_M_PHONE_HUNGUP,
-                         * which doesn't contribute to the counter.
-                         */
-                        atomic_dec(&TASK->active_calls);
                 }
                 
@@ -1058 +1053 @@
                 ipc_call_free(call);
                 
-                return ((unative_t) call) | IPC_CALLID_ANSWERED;
+                return ((sysarg_t) call) | IPC_CALLID_ANSWERED;
         }
         
@@ -1086 +1081 @@
         }
         
-        return (unative_t) call;
+        return (sysarg_t) call;
 }
 
@@ -1092 +1087 @@
  *
  */
-unative_t sys_ipc_poke(void)
+sysarg_t sys_ipc_poke(void)
 {
         waitq_unsleep(&TASK->answerbox.wq);
@@ -1100 +1095 @@
 /** Connect an IRQ handler to a task.
  *
- * @param inr    IRQ number.
- * @param devno  Device number.
- * @param method Method to be associated with the notification.
- * @param ucode  Uspace pointer to the top-half pseudocode.
+ * @param inr     IRQ number.
+ * @param devno   Device number.
+ * @param imethod Interface and method to be associated with the notification.
+ * @param ucode   Uspace pointer to the top-half pseudocode.
  *
  * @return EPERM or a return code returned by ipc_irq_register().
  *
  */
-unative_t sys_ipc_register_irq(inr_t inr, devno_t devno, unative_t method,
+sysarg_t sys_ipc_register_irq(inr_t inr, devno_t devno, sysarg_t imethod,
     irq_code_t *ucode)
 {
@@ -1114 +1109 @@
                 return EPERM;
         
-        return ipc_irq_register(&TASK->answerbox, inr, devno, method, ucode);
+        return ipc_irq_register(&TASK->answerbox, inr, devno, imethod, ucode);
 }
 
@@ -1125 +1120 @@
  *
  */
-unative_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)
+sysarg_t sys_ipc_unregister_irq(inr_t inr, devno_t devno)
 {
         if (!(cap_get(TASK) & CAP_IRQ_REG))
@@ -1135 +1130 @@
 }
 
-#include <console/console.h>
-
-/** Syscall connect to a task by id.
+#ifdef __32_BITS__
+
+/** Syscall connect to a task by ID (32 bits)
  *
  * @return Phone id on success, or negative error code.
  *
  */
-unative_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid_arg)
+sysarg_t sys_ipc_connect_kbox(sysarg64_t *uspace_taskid)
 {
 #ifdef CONFIG_UDEBUG
-        sysarg64_t taskid_arg;
-        int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
+        sysarg64_t taskid;
+        int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(sysarg64_t));
         if (rc != 0)
-                return (unative_t) rc;
-        
-        LOG("sys_ipc_connect_kbox(%" PRIu64 ")", taskid_arg.value);
-        
-        return ipc_connect_kbox(taskid_arg.value);
+                return (sysarg_t) rc;
+        
+        return ipc_connect_kbox((task_id_t) taskid);
 #else
-        return (unative_t) ENOTSUP;
+        return (sysarg_t) ENOTSUP;
 #endif
 }
 
+#endif  /* __32_BITS__ */
+
+#ifdef __64_BITS__
+
+/** Syscall connect to a task by ID (64 bits)
+ *
+ * @return Phone id on success, or negative error code.
+ *
+ */
+sysarg_t sys_ipc_connect_kbox(sysarg_t taskid)
+{
+#ifdef CONFIG_UDEBUG
+        return ipc_connect_kbox((task_id_t) taskid);
+#else
+        return (sysarg_t) ENOTSUP;
+#endif
+}
+
+#endif  /* __64_BITS__ */
+
 /** @}
  */

kernel/generic/src/lib/memstr.c

@@ -62 +62 @@
         unsigned int i, j;
         
-        if (ALIGN_UP((uintptr_t) src, sizeof(unative_t)) != (uintptr_t) src ||
-            ALIGN_UP((uintptr_t) dst, sizeof(unative_t)) != (uintptr_t) dst) {
+        if (ALIGN_UP((uintptr_t) src, sizeof(sysarg_t)) != (uintptr_t) src ||
+            ALIGN_UP((uintptr_t) dst, sizeof(sysarg_t)) != (uintptr_t) dst) {
                 for (i = 0; i < cnt; i++)
                         ((uint8_t *) dst)[i] = ((uint8_t *) src)[i];
         } else { 
-                for (i = 0; i < cnt / sizeof(unative_t); i++)
-                        ((unative_t *) dst)[i] = ((unative_t *) src)[i];
+                for (i = 0; i < cnt / sizeof(sysarg_t); i++)
+                        ((sysarg_t *) dst)[i] = ((sysarg_t *) src)[i];
                 
-                for (j = 0; j < cnt % sizeof(unative_t); j++)
-                        ((uint8_t *)(((unative_t *) dst) + i))[j] =
-                            ((uint8_t *)(((unative_t *) src) + i))[j];
+                for (j = 0; j < cnt % sizeof(sysarg_t); j++)
+                        ((uint8_t *)(((sysarg_t *) dst) + i))[j] =
+                            ((uint8_t *)(((sysarg_t *) src) + i))[j];
         }
                 

kernel/generic/src/lib/rd.c

@@ -96 +96 @@
         sysinfo_set_item_val("rd.size", NULL, dsize);
         sysinfo_set_item_val("rd.address.physical", NULL,
-            (unative_t) KA2PA((void *) header + hsize));
+            (sysarg_t) KA2PA((void *) header + hsize));
 
         return RE_OK;

kernel/generic/src/main/main.c

@@ -185 +185 @@
         LOG("\nconfig.base=%p config.kernel_size=%zu"
             "\nconfig.stack_base=%p config.stack_size=%zu",
-            config.base, config.kernel_size, config.stack_base,
-            config.stack_size);
+            (void *) config.base, config.kernel_size,
+            (void *) config.stack_base, config.stack_size);
         
 #ifdef CONFIG_KCONSOLE
@@ -242 +242 @@
                 for (i = 0; i < init.cnt; i++)
                         LOG("init[%zu].addr=%p, init[%zu].size=%zu",
-                            i, init.tasks[i].addr, i, init.tasks[i].size);
+                            i, (void *) init.tasks[i].addr, i, init.tasks[i].size);
         } else
                 printf("No init binaries found.\n");

kernel/generic/src/mm/as.c

@@ -2000 +2000 @@
 
 /** Wrapper for as_area_create(). */
-unative_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)
+sysarg_t sys_as_area_create(uintptr_t address, size_t size, unsigned int flags)
 {
         if (as_area_create(AS, flags | AS_AREA_CACHEABLE, size, address,
             AS_AREA_ATTR_NONE, &anon_backend, NULL))
-                return (unative_t) address;
+                return (sysarg_t) address;
         else
-                return (unative_t) -1;
+                return (sysarg_t) -1;
 }
 
 /** Wrapper for as_area_resize(). */
-unative_t sys_as_area_resize(uintptr_t address, size_t size, unsigned int flags)
-{
-        return (unative_t) as_area_resize(AS, address, size, 0);
+sysarg_t sys_as_area_resize(uintptr_t address, size_t size, unsigned int flags)
+{
+        return (sysarg_t) as_area_resize(AS, address, size, 0);
 }
 
 /** Wrapper for as_area_change_flags(). */
-unative_t sys_as_area_change_flags(uintptr_t address, unsigned int flags)
-{
-        return (unative_t) as_area_change_flags(AS, flags, address);
+sysarg_t sys_as_area_change_flags(uintptr_t address, unsigned int flags)
+{
+        return (sysarg_t) as_area_change_flags(AS, flags, address);
 }
 
 /** Wrapper for as_area_destroy(). */
-unative_t sys_as_area_destroy(uintptr_t address)
-{
-        return (unative_t) as_area_destroy(AS, address);
+sysarg_t sys_as_area_destroy(uintptr_t address)
+{
+        return (sysarg_t) as_area_destroy(AS, address);
 }
 

kernel/generic/src/mm/slab.c

@@ -612 +612 @@
         cache->name = name;
         
-        if (align < sizeof(unative_t))
-                align = sizeof(unative_t);
+        if (align < sizeof(sysarg_t))
+                align = sizeof(sysarg_t);
         
         size = ALIGN_UP(size, align);
@@ -806 +806 @@
 }
 
-/** Go through all caches and reclaim what is possible
- *
- * Interrupts must be disabled before calling this function,
- * otherwise  memory allocation from interrupts can deadlock.
- *
- */
+/** Go through all caches and reclaim what is possible */
 size_t slab_reclaim(unsigned int flags)
 {
-        irq_spinlock_lock(&slab_cache_lock, false);
+        irq_spinlock_lock(&slab_cache_lock, true);
         
         size_t frames = 0;
@@ -824 +819 @@
         }
         
-        irq_spinlock_unlock(&slab_cache_lock, false);
+        irq_spinlock_unlock(&slab_cache_lock, true);
         
         return frames;

kernel/generic/src/proc/program.c

@@ -210 +210 @@
  *
  */
-unative_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
+sysarg_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
 {
         /* Cap length of name and copy it from userspace. */
@@ -219 +219 @@
         int rc = copy_from_uspace(namebuf, uspace_name, name_len);
         if (rc != 0)
-                return (unative_t) rc;
+                return (sysarg_t) rc;
         
         namebuf[name_len] = 0;

kernel/generic/src/proc/task.c

@@ -151 +151 @@
         atomic_set(&task->refcount, 0);
         atomic_set(&task->lifecount, 0);
-        atomic_set(&task->active_calls, 0);
         
         irq_spinlock_initialize(&task->lock, "task_t_lock");
@@ -291 +290 @@
 }
 
-/** Syscall for reading task ID from userspace.
- *
- * @param uspace_task_id Userspace address of 8-byte buffer
- *                       where to store current task ID.
+#ifdef __32_BITS__
+
+/** Syscall for reading task ID from userspace (32 bits)
+ *
+ * @param uspace_taskid Pointer to user-space buffer
+ *                      where to store current task ID.
  *
  * @return Zero on success or an error code from @ref errno.h.
  *
  */
-unative_t sys_task_get_id(task_id_t *uspace_task_id)
+sysarg_t sys_task_get_id(sysarg64_t *uspace_taskid)
 {
         /*
@@ -305 +306 @@
          * the lifespan of the task.
          */
-        return (unative_t) copy_to_uspace(uspace_task_id, &TASK->taskid,
+        return (sysarg_t) copy_to_uspace(uspace_taskid, &TASK->taskid,
             sizeof(TASK->taskid));
 }
+
+#endif  /* __32_BITS__ */
+
+#ifdef __64_BITS__
+
+/** Syscall for reading task ID from userspace (64 bits)
+ *
+ * @return Current task ID.
+ *
+ */
+sysarg_t sys_task_get_id(void)
+{
+        /*
+         * No need to acquire lock on TASK because taskid remains constant for
+         * the lifespan of the task.
+         */
+        return TASK->taskid;
+}
+
+#endif  /* __64_BITS__ */
 
 /** Syscall for setting the task name.
@@ -319 +340 @@
  *
  */
-unative_t sys_task_set_name(const char *uspace_name, size_t name_len)
+sysarg_t sys_task_set_name(const char *uspace_name, size_t name_len)
 {
         int rc;
@@ -331 +352 @@
         rc = copy_from_uspace(namebuf, uspace_name, name_len);
         if (rc != 0)
-                return (unative_t) rc;
+                return (sysarg_t) rc;
         
         namebuf[name_len] = '\0';
@@ -337 +358 @@
         
         return EOK;
+}
+
+/** Syscall to forcefully terminate a task
+ *
+ * @param uspace_taskid Pointer to task ID in user space.
+ *
+ * @return 0 on success or an error code from @ref errno.h.
+ *
+ */
+sysarg_t sys_task_kill(task_id_t *uspace_taskid)
+{
+        task_id_t taskid;
+        int rc;
+
+        rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(taskid));
+        if (rc != 0)
+                return (sysarg_t) rc;
+
+        return (sysarg_t) task_kill(taskid);
 }
 
@@ -478 +518 @@
 #ifdef __32_BITS__
         if (*additional)
-                printf("%-8" PRIu64 " %9" PRIua " %7" PRIua, task->taskid,
-                    atomic_get(&task->refcount), atomic_get(&task->active_calls));
+                printf("%-8" PRIu64 " %9" PRIua, task->taskid,
+                    atomic_get(&task->refcount));
         else
                 printf("%-8" PRIu64 " %-14s %-5" PRIu32 " %10p %10p"
@@ -490 +530 @@
         if (*additional)
                 printf("%-8" PRIu64 " %9" PRIu64 "%c %9" PRIu64 "%c "
-                    "%9" PRIua " %7" PRIua,
-                    task->taskid, ucycles, usuffix, kcycles, ksuffix,
-                    atomic_get(&task->refcount), atomic_get(&task->active_calls));
+                    "%9" PRIua, task->taskid, ucycles, usuffix, kcycles,
+                    ksuffix, atomic_get(&task->refcount));
         else
                 printf("%-8" PRIu64 " %-14s %-5" PRIu32 " %18p %18p\n",

kernel/generic/src/proc/thread.c

@@ -755 +755 @@
  *
  */
-unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
+sysarg_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
     size_t name_len, thread_id_t *uspace_thread_id)
 {
@@ -764 +764 @@
         int rc = copy_from_uspace(namebuf, uspace_name, name_len);
         if (rc != 0)
-                return (unative_t) rc;
+                return (sysarg_t) rc;
         
         namebuf[name_len] = 0;
@@ -779 +779 @@
         if (rc != 0) {
                 free(kernel_uarg);
-                return (unative_t) rc;
+                return (sysarg_t) rc;
         }
         
@@ -804 +804 @@
                                 free(kernel_uarg);
                                 
-                                return (unative_t) rc;
+                                return (sysarg_t) rc;
                          }
                 }
@@ -827 +827 @@
                 free(kernel_uarg);
         
-        return (unative_t) ENOMEM;
+        return (sysarg_t) ENOMEM;
 }
 
@@ -833 +833 @@
  *
  */
-unative_t sys_thread_exit(int uspace_status)
+sysarg_t sys_thread_exit(int uspace_status)
 {
         thread_exit();
@@ -849 +849 @@
  *
  */
-unative_t sys_thread_get_id(thread_id_t *uspace_thread_id)
+sysarg_t sys_thread_get_id(thread_id_t *uspace_thread_id)
 {
         /*
@@ -856 +856 @@
          *
          */
-        return (unative_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
+        return (sysarg_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
             sizeof(THREAD->tid));
 }
 
 /** Syscall wrapper for sleeping. */
-unative_t sys_thread_usleep(uint32_t usec)
+sysarg_t sys_thread_usleep(uint32_t usec)
 {
         thread_usleep(usec);

kernel/generic/src/security/cap.c

@@ -41 +41 @@
 #include <proc/task.h>
 #include <synch/spinlock.h>
-#include <syscall/sysarg64.h>
 #include <syscall/copy.h>
 #include <arch.h>
@@ -79 +78 @@
  * The calling task must have the CAP_CAP capability.
  *
- * @param uspace_taskid_arg Userspace structure holding destination task ID.
- * @param caps Capabilities to grant.
- *
- * @return Zero on success or an error code from @ref errno.h.
- *
- */
-unative_t sys_cap_grant(sysarg64_t *uspace_taskid_arg, cap_t caps)
+ * @param taskid Destination task ID.
+ * @param caps   Capabilities to grant.
+ *
+ * @return Zero on success or an error code from @ref errno.h.
+ *
+ */
+static sysarg_t cap_grant(task_id_t taskid, cap_t caps)
 {
         if (!(cap_get(TASK) & CAP_CAP))
-                return (unative_t) EPERM;
-        
-        sysarg64_t taskid_arg;
-        int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
-        if (rc != 0)
-                return (unative_t) rc;
+                return (sysarg_t) EPERM;
         
         irq_spinlock_lock(&tasks_lock, true);
-        task_t *task = task_find_by_id((task_id_t) taskid_arg.value);
+        task_t *task = task_find_by_id(taskid);
         
         if ((!task) || (!context_check(CONTEXT, task->context))) {
                 irq_spinlock_unlock(&tasks_lock, true);
-                return (unative_t) ENOENT;
+                return (sysarg_t) ENOENT;
         }
         
@@ -116 +110 @@
  * attempt to revoke capabilities from itself.
  *
- * @param uspace_taskid_arg Userspace structure holding destination task ID.
- * @param caps Capabilities to revoke.
- *
- * @return Zero on success or an error code from @ref errno.h.
- *
- */
-unative_t sys_cap_revoke(sysarg64_t *uspace_taskid_arg, cap_t caps)
-{
-        sysarg64_t taskid_arg;
-        int rc = copy_from_uspace(&taskid_arg, uspace_taskid_arg, sizeof(sysarg64_t));
-        if (rc != 0)
-                return (unative_t) rc;
-        
+ * @param taskid Destination task ID.
+ * @param caps   Capabilities to revoke.
+ *
+ * @return Zero on success or an error code from @ref errno.h.
+ *
+ */
+static sysarg_t cap_revoke(task_id_t taskid, cap_t caps)
+{
         irq_spinlock_lock(&tasks_lock, true);
         
-        task_t *task = task_find_by_id((task_id_t) taskid_arg.value);
+        task_t *task = task_find_by_id(taskid);
         if ((!task) || (!context_check(CONTEXT, task->context))) {
                 irq_spinlock_unlock(&tasks_lock, true);
-                return (unative_t) ENOENT;
+                return (sysarg_t) ENOENT;
         }
         
@@ -147 +136 @@
                 irq_spinlock_unlock(&TASK->lock, false);
                 irq_spinlock_unlock(&tasks_lock, true);
-                return (unative_t) EPERM;
+                return (sysarg_t) EPERM;
         }
         
@@ -157 +146 @@
 }
 
+#ifdef __32_BITS__
+
+/** Grant capabilities to a task (32 bits)
+ *
+ * The calling task must have the CAP_CAP capability.
+ *
+ * @param uspace_taskid User-space pointer to destination task ID.
+ * @param caps          Capabilities to grant.
+ *
+ * @return Zero on success or an error code from @ref errno.h.
+ *
+ */
+sysarg_t sys_cap_grant(sysarg64_t *uspace_taskid, cap_t caps)
+{
+        sysarg64_t taskid;
+        int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(sysarg64_t));
+        if (rc != 0)
+                return (sysarg_t) rc;
+        
+        return cap_grant((task_id_t) taskid, caps);
+}
+
+/** Revoke capabilities from a task (32 bits)
+ *
+ * The calling task must have the CAP_CAP capability or the caller must
+ * attempt to revoke capabilities from itself.
+ *
+ * @param uspace_taskid User-space pointer to destination task ID.
+ * @param caps          Capabilities to revoke.
+ *
+ * @return Zero on success or an error code from @ref errno.h.
+ *
+ */
+sysarg_t sys_cap_revoke(sysarg64_t *uspace_taskid, cap_t caps)
+{
+        sysarg64_t taskid;
+        int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(sysarg64_t));
+        if (rc != 0)
+                return (sysarg_t) rc;
+        
+        return cap_revoke((task_id_t) taskid, caps);
+}
+
+#endif  /* __32_BITS__ */
+
+#ifdef __64_BITS__
+
+/** Grant capabilities to a task (64 bits)
+ *
+ * The calling task must have the CAP_CAP capability.
+ *
+ * @param taskid Destination task ID.
+ * @param caps   Capabilities to grant.
+ *
+ * @return Zero on success or an error code from @ref errno.h.
+ *
+ */
+sysarg_t sys_cap_grant(sysarg_t taskid, cap_t caps)
+{
+        return cap_grant((task_id_t) taskid, caps);
+}
+
+/** Revoke capabilities from a task (64 bits)
+ *
+ * The calling task must have the CAP_CAP capability or the caller must
+ * attempt to revoke capabilities from itself.
+ *
+ * @param taskid Destination task ID.
+ * @param caps   Capabilities to revoke.
+ *
+ * @return Zero on success or an error code from @ref errno.h.
+ *
+ */
+sysarg_t sys_cap_revoke(sysarg_t taskid, cap_t caps)
+{
+        return cap_revoke((task_id_t) taskid, caps);
+}
+
+#endif  /* __64_BITS__ */
+
 /** @}
  */

kernel/generic/src/synch/futex.c

@@ -60 +60 @@
 
 static futex_t *futex_find(uintptr_t paddr);
-static size_t futex_ht_hash(unative_t *key);
-static bool futex_ht_compare(unative_t *key, size_t keys, link_t *item);
+static size_t futex_ht_hash(sysarg_t *key);
+static bool futex_ht_compare(sysarg_t *key, size_t keys, link_t *item);
 static void futex_ht_remove_callback(link_t *item);
 
@@ -108 +108 @@
  *                      synch.h.
  */
-unative_t sys_futex_sleep(uintptr_t uaddr)
+sysarg_t sys_futex_sleep(uintptr_t uaddr)
 {
         futex_t *futex;
@@ -122 +122 @@
         if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
                 page_table_unlock(AS, true);
-                return (unative_t) ENOENT;
+                return (sysarg_t) ENOENT;
         }
         paddr = PTE_GET_FRAME(t) + (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
@@ -136 +136 @@
         udebug_stoppable_end();
 #endif
-        return (unative_t) rc;
+        return (sysarg_t) rc;
 }
 
@@ -145 +145 @@
  * @return              ENOENT if there is no physical mapping for uaddr.
  */
-unative_t sys_futex_wakeup(uintptr_t uaddr)
+sysarg_t sys_futex_wakeup(uintptr_t uaddr)
 {
         futex_t *futex;
@@ -158 +158 @@
         if (!t || !PTE_VALID(t) || !PTE_PRESENT(t)) {
                 page_table_unlock(AS, true);
-                return (unative_t) ENOENT;
+                return (sysarg_t) ENOENT;
         }
         paddr = PTE_GET_FRAME(t) + (uaddr - ALIGN_DOWN(uaddr, PAGE_SIZE));
@@ -235 +235 @@
  * @return              Index into futex hash table.
  */
-size_t futex_ht_hash(unative_t *key)
+size_t futex_ht_hash(sysarg_t *key)
 {
         return (*key & (FUTEX_HT_SIZE - 1));
@@ -247 +247 @@
  * @return              True if the item matches the key. False otherwise.
  */
-bool futex_ht_compare(unative_t *key, size_t keys, link_t *item)
+bool futex_ht_compare(sysarg_t *key, size_t keys, link_t *item)
 {
         futex_t *futex;

kernel/generic/src/synch/smc.c

@@ -42 +42 @@
 #include <synch/smc.h>
 
-unative_t sys_smc_coherence(uintptr_t va, size_t size)
+sysarg_t sys_smc_coherence(uintptr_t va, size_t size)
 {
         if (overlaps(va, size, (uintptr_t) NULL, PAGE_SIZE))

kernel/generic/src/syscall/syscall.c

@@ -45 +45 @@
 #include <debug.h>
 #include <ddi/device.h>
+#include <interrupt.h>
 #include <ipc/sysipc.h>
 #include <synch/futex.h>
@@ -56 +57 @@
 
 /** Dispatch system call */
-unative_t syscall_handler(unative_t a1, unative_t a2, unative_t a3,
-    unative_t a4, unative_t a5, unative_t a6, unative_t id)
+sysarg_t syscall_handler(sysarg_t a1, sysarg_t a2, sysarg_t a3,
+    sysarg_t a4, sysarg_t a5, sysarg_t a6, sysarg_t id)
 {
         /* Do userpace accounting */
@@ -66 +67 @@
 #ifdef CONFIG_UDEBUG
         /*
+         * An istate_t-compatible record was created on the stack by the
+         * low-level syscall handler. This is the userspace space state
+         * structure.
+         */
+        THREAD->udebug.uspace_state = istate_get(THREAD);
+
+        /*
          * Early check for undebugged tasks. We do not lock anything as this
          * test need not be precise in either direction.
-         *
          */
         if (THREAD->udebug.active)
@@ -74 +81 @@
 #endif
         
-        unative_t rc;
+        sysarg_t rc;
         if (id < SYSCALL_END) {
                 rc = syscall_table[id](a1, a2, a3, a4, a5, a6);
@@ -98 +105 @@
                 udebug_stoppable_end();
         }
+
+        /* Clear userspace state pointer */
+        THREAD->udebug.uspace_state = NULL;
 #endif
         
@@ -120 +130 @@
         (syshandler_t) sys_task_get_id,
         (syshandler_t) sys_task_set_name,
+        (syshandler_t) sys_task_kill,
         (syshandler_t) sys_program_spawn_loader,
         
@@ -147 +158 @@
         (syshandler_t) sys_ipc_register_irq,
         (syshandler_t) sys_ipc_unregister_irq,
+        (syshandler_t) sys_ipc_connect_kbox,
         
         /* Event notification syscalls. */
@@ -159 +171 @@
         (syshandler_t) sys_physmem_map,
         (syshandler_t) sys_iospace_enable,
-        (syshandler_t) sys_interrupt_enable,
         
         /* Sysinfo syscalls */
@@ -169 +180 @@
         /* Debug calls */
         (syshandler_t) sys_debug_enable_console,
-        (syshandler_t) sys_debug_disable_console,
-        
-        (syshandler_t) sys_ipc_connect_kbox
+        (syshandler_t) sys_debug_disable_console
 };
 

kernel/generic/src/sysinfo/stats.c

@@ -87 +87 @@
  *
  */
-static unative_t get_stats_uptime(struct sysinfo_item *item)
+static sysarg_t get_stats_uptime(struct sysinfo_item *item)
 {
         /* This doesn't have to be very accurate */

kernel/generic/src/sysinfo/sysinfo.c

@@ -296 +296 @@
  */
 void sysinfo_set_item_val(const char *name, sysinfo_item_t **root,
-    unative_t val)
+    sysarg_t val)
 {
         /* Protect sysinfo tree consistency */
@@ -481 +481 @@
                 sysinfo_indent(depth);
                 
-                unative_t val;
+                sysarg_t val;
                 size_t size;
                 
@@ -660 +660 @@
  *
  */
-unative_t sys_sysinfo_get_tag(void *path_ptr, size_t path_size)
+sysarg_t sys_sysinfo_get_tag(void *path_ptr, size_t path_size)
 {
         /*
@@ -679 +679 @@
                 ret.tag = SYSINFO_VAL_DATA;
         
-        return (unative_t) ret.tag;
+        return (sysarg_t) ret.tag;
 }
 
@@ -696 +696 @@
  *
  */
-unative_t sys_sysinfo_get_value(void *path_ptr, size_t path_size,
+sysarg_t sys_sysinfo_get_value(void *path_ptr, size_t path_size,
     void *value_ptr)
 {
@@ -715 +715 @@
                 rc = EINVAL;
         
-        return (unative_t) rc;
+        return (sysarg_t) rc;
 }
 
@@ -732 +732 @@
  *
  */
-unative_t sys_sysinfo_get_data_size(void *path_ptr, size_t path_size,
+sysarg_t sys_sysinfo_get_data_size(void *path_ptr, size_t path_size,
     void *size_ptr)
 {
@@ -752 +752 @@
                 rc = EINVAL;
         
-        return (unative_t) rc;
+        return (sysarg_t) rc;
 }
 
@@ -774 +774 @@
  *
  */
-unative_t sys_sysinfo_get_data(void *path_ptr, size_t path_size,
+sysarg_t sys_sysinfo_get_data(void *path_ptr, size_t path_size,
     void *buffer_ptr, size_t buffer_size)
 {
@@ -797 +797 @@
                 free(ret.data.data);
         
-        return (unative_t) rc;
+        return (sysarg_t) rc;
 }
 

kernel/generic/src/time/clock.c

@@ -70 +70 @@
  *
  */
-static unative_t secfrag = 0;
+static sysarg_t secfrag = 0;
 
 /** Initialize realtime clock counter
@@ -100 +100 @@
          *
          */
-        sysinfo_set_item_val("clock.cacheable", NULL, (unative_t) true);
-        sysinfo_set_item_val("clock.faddr", NULL, (unative_t) faddr);
+        sysinfo_set_item_val("clock.cacheable", NULL, (sysarg_t) true);
+        sysinfo_set_item_val("clock.faddr", NULL, (sysarg_t) faddr);
 }
 

kernel/generic/src/udebug/udebug.c

@@ -219 +219 @@
  *
  */
-void udebug_syscall_event(unative_t a1, unative_t a2, unative_t a3,
-    unative_t a4, unative_t a5, unative_t a6, unative_t id, unative_t rc,
+void udebug_syscall_event(sysarg_t a1, sysarg_t a2, sysarg_t a3,
+    sysarg_t a4, sysarg_t a5, sysarg_t a6, sysarg_t id, sysarg_t rc,
     bool end_variant)
 {
@@ -314 +314 @@
         IPC_SET_RETVAL(call->data, 0);
         IPC_SET_ARG1(call->data, UDEBUG_EVENT_THREAD_B);
-        IPC_SET_ARG2(call->data, (unative_t) thread);
+        IPC_SET_ARG2(call->data, (sysarg_t) thread);
         
         /*

kernel/generic/src/udebug/udebug_ipc.c

@@ -210 +210 @@
 static void udebug_receive_name_read(call_t *call)
 {
-        unative_t uspace_addr;
-        unative_t to_copy;
+        sysarg_t uspace_addr;
+        sysarg_t to_copy;
         size_t data_size;
         size_t buf_size;
@@ -257 +257 @@
 static void udebug_receive_areas_read(call_t *call)
 {
-        unative_t uspace_addr;
-        unative_t to_copy;
+        sysarg_t uspace_addr;
+        sysarg_t to_copy;
         size_t data_size;
         size_t buf_size;
@@ -304 +304 @@
 {
         thread_t *t;
-        unative_t uspace_addr;
+        sysarg_t uspace_addr;
         int rc;
         void *buffer;
@@ -328 +328 @@
            (no way to distinguish method in answer) */
         IPC_SET_ARG1(call->data, uspace_addr);
-        IPC_SET_ARG2(call->data, 6 * sizeof(unative_t));
+        IPC_SET_ARG2(call->data, 6 * sizeof(sysarg_t));
         call->buffer = buffer;
 
@@ -341 +341 @@
 {
         thread_t *t;
-        unative_t uspace_addr;
-        unative_t to_copy;
+        sysarg_t uspace_addr;
+        sysarg_t to_copy;
         void *buffer;
         int rc;
@@ -382 +382 @@
 static void udebug_receive_mem_read(call_t *call)
 {
-        unative_t uspace_dst;
-        unative_t uspace_src;
+        sysarg_t uspace_dst;
+        sysarg_t uspace_src;
         unsigned size;
         void *buffer;

kernel/generic/src/udebug/udebug_ops.c

@@ -371 +371 @@
         
         /* Allocate a buffer to hold thread IDs */
-        unative_t *id_buffer = malloc(buf_size + 1, 0);
+        sysarg_t *id_buffer = malloc(buf_size + 1, 0);
         
         mutex_lock(&TASK->udebug.lock);
@@ -385 +385 @@
         /* Copy down the thread IDs */
         
-        size_t max_ids = buf_size / sizeof(unative_t);
+        size_t max_ids = buf_size / sizeof(sysarg_t);
         size_t copied_ids = 0;
         size_t extra_ids = 0;
@@ -404 +404 @@
                 if (copied_ids < max_ids) {
                         /* Using thread struct pointer as identification hash */
-                        id_buffer[copied_ids++] = (unative_t) thread;
+                        id_buffer[copied_ids++] = (sysarg_t) thread;
                 } else
                         extra_ids++;
@@ -414 +414 @@
         
         *buffer = id_buffer;
-        *stored = copied_ids * sizeof(unative_t);
-        *needed = (copied_ids + extra_ids) * sizeof(unative_t);
+        *stored = copied_ids * sizeof(sysarg_t);
+        *needed = (copied_ids + extra_ids) * sizeof(sysarg_t);
         
         return 0;
@@ -463 +463 @@
 {
         /* Prepare a buffer to hold the arguments. */
-        unative_t *arg_buffer = malloc(6 * sizeof(unative_t), 0);
+        sysarg_t *arg_buffer = malloc(6 * sizeof(sysarg_t), 0);
         
         /* On success, this will lock t->udebug.lock. */
@@ -478 +478 @@
         
         /* Copy to a local buffer before releasing the lock. */
-        memcpy(arg_buffer, thread->udebug.syscall_args, 6 * sizeof(unative_t));
+        memcpy(arg_buffer, thread->udebug.syscall_args, 6 * sizeof(sysarg_t));
         
         _thread_op_end(thread);
@@ -539 +539 @@
  *
  */
-int udebug_mem_read(unative_t uspace_addr, size_t n, void **buffer)
+int udebug_mem_read(sysarg_t uspace_addr, size_t n, void **buffer)
 {
         /* Verify task state */