Changeset eadaeae8 in mainline for kernel/generic/src

Timestamp:

2018-03-21T20:58:49Z (7 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

3be9d10

Parents:

874381a

Message:

Make capability handles type-safe

Define distinct pointer types for the handles of the supported
capability types and use them instead of integer handles. This makes it
virtually impossible to pass a non-handle or a handle of different type
instead of the proper handle. Also turn cap_handle_t into an "untyped"
capability handle that can be assigned to and from the "typed" handles.

This commit also fixes a bug in msim-con driver, which wrongly used the
IRQ number instead of the IRQ capability handle to unregister the IRQ.

This commit also fixes the wrong use of the capability handle instead
of error code in libusbhost.

Location:

kernel/generic/src

Files:

• cap/cap.c (modified) (5 diffs)
• ipc/ipc.c (modified) (1 diff)
• ipc/ipcrsc.c (modified) (2 diffs)
• ipc/irq.c (modified) (2 diffs)
• ipc/kbox.c (modified) (2 diffs)
• ipc/ops/conctmeto.c (modified) (5 diffs)
• ipc/ops/concttome.c (modified) (4 diffs)
• ipc/ops/stchngath.c (modified) (2 diffs)
• ipc/sysipc.c (modified) (16 diffs)
• mm/backend_user.c (modified) (1 diff)
• proc/task.c (modified) (1 diff)

kernel/generic/src/cap/cap.c

@@ -92 +92 @@
 {
         cap_t *cap = hash_table_get_inst(item, cap_t, caps_link);
-        return hash_mix(cap->handle);
+        return hash_mix(CAP_HANDLE_RAW(cap->handle));
 }
 
@@ -98 +98 @@
 {
         cap_handle_t *handle = (cap_handle_t *) key;
-        return hash_mix(*handle);
+        return hash_mix(CAP_HANDLE_RAW(*handle));
 }
 
@@ -224 +224 @@
         assert(mutex_locked(&task->cap_info->lock));
 
-        if ((handle < CAPS_START) || (handle > CAPS_LAST))
+        if ((CAP_HANDLE_RAW(handle) < CAPS_START) ||
+            (CAP_HANDLE_RAW(handle) > CAPS_LAST))
                 return NULL;
         ht_link_t *link = hash_table_find(&task->cap_info->caps, &handle);
@@ -329 +330 @@
 void cap_free(task_t *task, cap_handle_t handle)
 {
-        assert(handle >= CAPS_START);
-        assert(handle <= CAPS_LAST);
+        assert(CAP_HANDLE_RAW(handle) >= CAPS_START);
+        assert(CAP_HANDLE_RAW(handle) <= CAPS_LAST);
 
         mutex_lock(&task->cap_info->lock);
@@ -338 +339 @@
 
         hash_table_remove_item(&task->cap_info->caps, &cap->caps_link);
-        ra_free(task->cap_info->handles, handle, 1);
+        ra_free(task->cap_info->handles, CAP_HANDLE_RAW(handle), 1);
         slab_free(cap_cache, cap);
         mutex_unlock(&task->cap_info->lock);

kernel/generic/src/ipc/ipc.c

@@ -910 +910 @@
         mutex_lock(&phone->lock);
         if (phone->state != IPC_PHONE_FREE) {
-                printf("%-11d %7" PRIun " ", cap->handle,
+                printf("%-11d %7" PRIun " ", (int) CAP_HANDLE_RAW(cap->handle),
                     atomic_get(&phone->active_calls));
 

kernel/generic/src/ipc/ipcrsc.c

@@ -157 +157 @@
  * @return  An error code if a new capability cannot be allocated.
  */
-errno_t phone_alloc(task_t *task, bool publish, cap_handle_t *phandle,
+errno_t phone_alloc(task_t *task, bool publish, cap_phone_handle_t *phandle,
     kobject_t **kobject)
 {
@@ -199 +199 @@
  *
  */
-void phone_dealloc(cap_handle_t handle)
+void phone_dealloc(cap_phone_handle_t handle)
 {
         kobject_t *kobj = cap_unpublish(TASK, handle, KOBJECT_TYPE_PHONE);

kernel/generic/src/ipc/irq.c

@@ -314 +314 @@
  */
 errno_t ipc_irq_subscribe(answerbox_t *box, inr_t inr, sysarg_t imethod,
-    irq_code_t *ucode, cap_handle_t *uspace_handle)
+    irq_code_t *ucode, cap_irq_handle_t *uspace_handle)
 {
         if ((inr < 0) || (inr > last_inr))
@@ -390 +390 @@
  *
  */
-errno_t ipc_irq_unsubscribe(answerbox_t *box, int handle)
+errno_t ipc_irq_unsubscribe(answerbox_t *box, cap_irq_handle_t handle)
 {
         kobject_t *kobj = cap_unpublish(TASK, handle, KOBJECT_TYPE_IRQ);

kernel/generic/src/ipc/kbox.c

@@ -210 +210 @@
  *
  */
-errno_t ipc_connect_kbox(task_id_t taskid, cap_handle_t *out_phone)
+errno_t ipc_connect_kbox(task_id_t taskid, cap_phone_handle_t *out_phone)
 {
         irq_spinlock_lock(&tasks_lock, true);
@@ -252 +252 @@
 
         /* Allocate a new phone. */
-        cap_handle_t phone_handle;
+        cap_phone_handle_t phone_handle;
         errno_t rc = phone_alloc(TASK, true, &phone_handle, NULL);
         if (rc != EOK) {

kernel/generic/src/ipc/ops/conctmeto.c

@@ -46 +46 @@
          * That will be done once the phone is connected.
          */
-        cap_handle_t phone_handle;
+        cap_phone_handle_t phone_handle;
         kobject_t *phone_obj;
         errno_t rc = phone_alloc(TASK, false, &phone_handle, &phone_obj);
@@ -58 +58 @@
 
         /* Remember the handle */
-        call->priv = phone_handle;
+        call->priv = CAP_HANDLE_RAW(phone_handle);
 
         return EOK;
@@ -65 +65 @@
 static errno_t request_forget(call_t *call)
 {
-        cap_handle_t phone_handle = (cap_handle_t) call->priv;
+        cap_phone_handle_t phone_handle = (cap_handle_t) call->priv;
 
-        if (phone_handle < 0)
+        if (CAP_HANDLE_RAW(phone_handle) < 0)
                 return EOK;
 
@@ -103 +103 @@
 static errno_t answer_process(call_t *answer)
 {
-        cap_handle_t phone_handle = (cap_handle_t) answer->priv;
+        cap_phone_handle_t phone_handle = (cap_handle_t) answer->priv;
         phone_t *phone = (phone_t *) IPC_GET_ARG5(answer->data);
 
         if (IPC_GET_RETVAL(answer->data)) {
-                if (phone_handle >= 0) {
+                if (CAP_HANDLE_RAW(phone_handle) >= 0) {
                         /*
                          * Cleanup the unpublished capability and drop
@@ -123 +123 @@
                 cap_publish(TASK, phone_handle, phone->kobject);
 
-                IPC_SET_ARG5(answer->data, phone_handle);
+                IPC_SET_ARG5(answer->data, CAP_HANDLE_RAW(phone_handle));
         }
 

kernel/generic/src/ipc/ops/concttome.c

@@ -42 +42 @@
 static int request_process(call_t *call, answerbox_t *box)
 {
-        cap_handle_t phone_handle;
+        cap_phone_handle_t phone_handle;
         kobject_t *phone_obj;
         errno_t rc = phone_alloc(TASK, false, &phone_handle, &phone_obj);
         call->priv = (sysarg_t) phone_obj;
-        IPC_SET_ARG5(call->data, (rc == EOK) ? phone_handle : -1);
+        IPC_SET_ARG5(call->data,
+            (rc == EOK) ? CAP_HANDLE_RAW(phone_handle) : CAP_NIL);
         return 0;
 }
@@ -52 +53 @@
 static errno_t answer_cleanup(call_t *answer, ipc_data_t *olddata)
 {
-        cap_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
+        cap_phone_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
         kobject_t *phone_obj = (kobject_t *) answer->priv;
 
-        if (phone_handle >= 0) {
+        if (CAP_HANDLE_VALID(phone_handle)) {
                 kobject_put(phone_obj);
                 cap_free(TASK, phone_handle);
@@ -65 +66 @@
 static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
 {
-        cap_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
+        cap_phone_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
         kobject_t *phone_obj = (kobject_t *) answer->priv;
 
@@ -71 +72 @@
                 /* The connection was not accepted */
                 answer_cleanup(answer, olddata);
-        } else if (phone_handle >= 0) {
+        } else if (CAP_HANDLE_VALID(phone_handle)) {
                 /*
                  * The connection was accepted

kernel/generic/src/ipc/ops/stchngath.c

@@ -45 +45 @@
         task_t *other_task_s;
 
-        kobject_t *sender_obj = kobject_get(TASK, IPC_GET_ARG5(call->data),
-            KOBJECT_TYPE_PHONE);
+        kobject_t *sender_obj = kobject_get(TASK,
+            (cap_handle_t) IPC_GET_ARG5(call->data), KOBJECT_TYPE_PHONE);
         if (!sender_obj)
                 return ENOENT;
@@ -78 +78 @@
 
                 kobject_t *recipient_obj = kobject_get(TASK,
-                    IPC_GET_ARG1(answer->data), KOBJECT_TYPE_PHONE);
+                    (cap_handle_t) IPC_GET_ARG1(answer->data),
+                    KOBJECT_TYPE_PHONE);
                 if (!recipient_obj) {
                         IPC_SET_RETVAL(answer->data, ENOENT);

kernel/generic/src/ipc/sysipc.c

@@ -271 +271 @@
  *
  */
-errno_t ipc_req_internal(cap_handle_t handle, ipc_data_t *data, sysarg_t priv)
+errno_t
+ipc_req_internal(cap_phone_handle_t handle, ipc_data_t *data, sysarg_t priv)
 {
         kobject_t *kobj = kobject_get(TASK, handle, KOBJECT_TYPE_PHONE);
@@ -362 +363 @@
  *
  */
-sys_errno_t sys_ipc_call_async_fast(sysarg_t handle, sysarg_t imethod,
+sys_errno_t sys_ipc_call_async_fast(cap_phone_handle_t handle, sysarg_t imethod,
     sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t label)
 {
@@ -409 +410 @@
  *
  */
-sys_errno_t sys_ipc_call_async_slow(sysarg_t handle, ipc_data_t *data,
+sys_errno_t sys_ipc_call_async_slow(cap_phone_handle_t handle, ipc_data_t *data,
     sysarg_t label)
 {
@@ -466 +467 @@
  *
  */
-static sys_errno_t sys_ipc_forward_common(sysarg_t chandle, sysarg_t phandle,
-    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
-    sysarg_t arg4, sysarg_t arg5, unsigned int mode, bool slow)
+static sys_errno_t sys_ipc_forward_common(cap_call_handle_t chandle,
+    cap_phone_handle_t phandle, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, unsigned int mode, bool slow)
 {
         kobject_t *ckobj = cap_unpublish(TASK, chandle, KOBJECT_TYPE_CALL);
@@ -506 +507 @@
                 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));
+                                phone_dealloc((cap_phone_handle_t)
+                                    IPC_GET_ARG5(call->data));
 
                         IPC_SET_ARG1(call->data, imethod);
@@ -577 +579 @@
  *
  */
-sys_errno_t sys_ipc_forward_fast(sysarg_t chandle, sysarg_t phandle,
-    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
+sys_errno_t sys_ipc_forward_fast(cap_call_handle_t chandle,
+    cap_phone_handle_t phandle, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
+    unsigned int mode)
 {
         return sys_ipc_forward_common(chandle, phandle, imethod, arg1, arg2, 0,
@@ -601 +604 @@
  *
  */
-sys_errno_t sys_ipc_forward_slow(sysarg_t chandle, sysarg_t phandle,
-    ipc_data_t *data, unsigned int mode)
+sys_errno_t sys_ipc_forward_slow(cap_call_handle_t chandle,
+    cap_phone_handle_t phandle, ipc_data_t *data, unsigned int mode)
 {
         ipc_data_t newdata;
@@ -631 +634 @@
  *
  */
-sys_errno_t sys_ipc_answer_fast(sysarg_t chandle, sysarg_t retval, sysarg_t arg1,
-    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
+sys_errno_t sys_ipc_answer_fast(cap_call_handle_t chandle, sysarg_t retval,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
 {
         kobject_t *kobj = cap_unpublish(TASK, chandle, KOBJECT_TYPE_CALL);
@@ -678 +681 @@
  *
  */
-sys_errno_t sys_ipc_answer_slow(sysarg_t chandle, ipc_data_t *data)
+sys_errno_t sys_ipc_answer_slow(cap_call_handle_t chandle, ipc_data_t *data)
 {
         kobject_t *kobj = cap_unpublish(TASK, chandle, KOBJECT_TYPE_CALL);
@@ -722 +725 @@
  *
  */
-sys_errno_t sys_ipc_hangup(sysarg_t handle)
+sys_errno_t sys_ipc_hangup(cap_phone_handle_t handle)
 {
         kobject_t *kobj = cap_unpublish(TASK, handle, KOBJECT_TYPE_PHONE);
@@ -800 +803 @@
                 goto restart;
 
-        cap_handle_t handle;
+        cap_handle_t handle = CAP_NIL;
         errno_t rc = cap_alloc(TASK, &handle);
         if (rc != EOK) {
@@ -821 +824 @@
 
 error:
-        if (handle >= 0)
+        if (CAP_HANDLE_VALID(handle))
                 cap_free(TASK, handle);
 
@@ -861 +864 @@
  * @param ucode   Uspace pointer to the top-half pseudocode.
  *
- * @param[out] uspace_handle  Uspace pointer to IRQ kernel object capability
+ * @param[out] uspace_handle  Uspace pointer to IRQ capability handle
  *
  * @return EPERM
@@ -867 +870 @@
  *
  */
-sys_errno_t sys_ipc_irq_subscribe(inr_t inr, sysarg_t imethod, irq_code_t *ucode,
-        cap_handle_t *uspace_handle)
+sys_errno_t sys_ipc_irq_subscribe(inr_t inr, sysarg_t imethod,
+    irq_code_t *ucode, cap_irq_handle_t *uspace_handle)
 {
         if (!(perm_get(TASK) & PERM_IRQ_REG))
@@ -878 +881 @@
 /** Disconnect an IRQ handler from a task.
  *
- * @param inr   IRQ number.
- * @param devno Device number.
+ * @param handle  IRQ capability handle.
  *
  * @return Zero on success or EPERM on error.
  *
  */
-sys_errno_t sys_ipc_irq_unsubscribe(sysarg_t cap)
+sys_errno_t sys_ipc_irq_unsubscribe(cap_irq_handle_t handle)
 {
         if (!(perm_get(TASK) & PERM_IRQ_REG))
                 return EPERM;
 
-        ipc_irq_unsubscribe(&TASK->answerbox, cap);
+        ipc_irq_unsubscribe(&TASK->answerbox, handle);
 
         return 0;
@@ -899 +901 @@
  *
  */
-sys_errno_t sys_ipc_connect_kbox(task_id_t *uspace_taskid, cap_handle_t *uspace_phone)
+sys_errno_t sys_ipc_connect_kbox(task_id_t *uspace_taskid,
+    cap_phone_handle_t *uspace_phone)
 {
 #ifdef CONFIG_UDEBUG
         task_id_t taskid;
-        cap_handle_t phone;
+        cap_phone_handle_t phone;
 
         errno_t rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(task_id_t));

kernel/generic/src/mm/backend_user.c

@@ -131 +131 @@
                 log(LF_USPACE, LVL_FATAL,
                     "Page-in request for page %#" PRIxPTR
-                    " at pager %d failed with error %s.",
+                    " at pager %p failed with error %s.",
                     upage, pager_info->pager, str_error_name(rc));
                 return AS_PF_FAULT;

kernel/generic/src/proc/task.c

@@ -245 +245 @@
         if ((ipc_box_0) &&
             (container_check(ipc_box_0->task->container, task->container))) {
-                cap_handle_t phone_handle;
+                cap_phone_handle_t phone_handle;
                 errno_t rc = phone_alloc(task, true, &phone_handle, NULL);
                 if (rc != EOK) {