Changeset 91b60499 in mainline for kernel/generic/src/ipc/ops

Timestamp:

2017-09-30T06:29:42Z (8 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

300f4c4

Parents:

d076f16 (diff), 6636fb19 (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 support for capabilities from lp:~jakub/helenos/caps

This commit introduces capabilities as task-local names for references to kernel
objects. Kernel objects are reference-counted wrappers for a select group of
objects allocated in and by the kernel that can be made accessible to userspace
in a controlled way via integer handles.

So far, a kernel object encapsulates either an irq_t or a phone_t.

Support for the former lead to the removal of kernel-assigned devnos and
unsecure deregistration of IRQs in which a random task was able to unregister
some other task's IRQ.

Location:

kernel/generic/src/ipc/ops

Files:

• clnestab.c (deleted)
• conctmeto.c (modified) (5 diffs)
• concttome.c (modified) (4 diffs)
• connclone.c (deleted)
• stchngath.c (modified) (3 diffs)

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2006 Ondrej Palkovsky
- * Copyright (c) 2012 Jakub Jermar 
+ * Copyright (c) 2012 Jakub Jermar
  * All rights reserved.
  *
@@ -42 +42 @@
 static int request_preprocess(call_t *call, phone_t *phone)
 {
-        int newphid = phone_alloc(TASK);
+        cap_handle_t phone_handle = phone_alloc(TASK);
 
-        /* Remember the phoneid or the error. */
-        call->priv = newphid;
-        if (newphid < 0)
-                return ELIMIT;
-                
+        /* Remember the phone capability or the error. */
+        call->priv = phone_handle;
+        if (phone_handle < 0)
+                return phone_handle;
+
         /* Set arg5 for server */
-        IPC_SET_ARG5(call->data, (sysarg_t) &TASK->phones[newphid]);
+        kobject_t *phone_obj = kobject_get(TASK, phone_handle,
+            KOBJECT_TYPE_PHONE);
+        /* Hand over phone_obj's reference to ARG5 */
+        IPC_SET_ARG5(call->data, (sysarg_t) phone_obj->phone);
 
         return EOK;
@@ -57 +60 @@
 static int request_forget(call_t *call)
 {
-        phone_dealloc(call->priv);
+        cap_handle_t phone_handle = (cap_handle_t) call->priv;
+        phone_dealloc(phone_handle);
+        /* Hand over reference from ARG5 to phone->kobject */
+        phone_t *phone = (phone_t *) IPC_GET_ARG5(call->data);
+        /* Drop phone_obj's reference */
+        kobject_put(phone->kobject);
         return EOK;
 }
@@ -63 +71 @@
 static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
 {
+        /* Hand over reference from ARG5 to phone */
         phone_t *phone = (phone_t *) IPC_GET_ARG5(*olddata);
 
         /* If the user accepted call, connect */
-        if (IPC_GET_RETVAL(answer->data) == EOK)
+        if (IPC_GET_RETVAL(answer->data) == EOK) {
+                /* Hand over reference from phone to the answerbox */
                 (void) ipc_phone_connect(phone, &TASK->answerbox);
+        } else {
+                kobject_put(phone->kobject);
+        }
 
         return EOK;
@@ -74 +87 @@
 static int answer_process(call_t *answer)
 {
-        int newphid = (int) answer->priv;
+        cap_handle_t phone_handle = (cap_handle_t) answer->priv;
 
         if (IPC_GET_RETVAL(answer->data)) {
-                if (newphid >= 0) {
+                if (phone_handle >= 0) {
                         /*
                          * The phone was indeed allocated and now needs
                          * to be deallocated.
                          */
-                        phone_dealloc(newphid);
+                        phone_dealloc(phone_handle);
                 }
         } else {
-                IPC_SET_ARG5(answer->data, newphid);
+                IPC_SET_ARG5(answer->data, phone_handle);
         }
         

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

@@ -1 +1 @@
 /*
  * Copyright (c) 2006 Ondrej Palkovsky
- * Copyright (c) 2012 Jakub Jermar 
+ * Copyright (c) 2012 Jakub Jermar
  * All rights reserved.
  *
@@ -42 +42 @@
 static int request_process(call_t *call, answerbox_t *box)
 {
-        int phoneid = phone_alloc(TASK);
+        cap_handle_t phone_handle = phone_alloc(TASK);
 
-        IPC_SET_ARG5(call->data, phoneid);
+        IPC_SET_ARG5(call->data, phone_handle);
         
         return EOK;
@@ -51 +51 @@
 static int answer_cleanup(call_t *answer, ipc_data_t *olddata)
 {
-        int phoneid = (int) IPC_GET_ARG5(*olddata);
+        cap_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
 
-        if (phoneid >= 0)
-                phone_dealloc(phoneid);
+        if (phone_handle >= 0)
+                phone_dealloc(phone_handle);
 
         return EOK;
@@ -61 +61 @@
 static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
 {
-        int phoneid = (int) IPC_GET_ARG5(*olddata);
+        cap_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
 
         if (IPC_GET_RETVAL(answer->data) != EOK) {
                 /* The connection was not accepted */
                 answer_cleanup(answer, olddata);
-        } else if (phoneid >= 0) {
+        } else if (phone_handle >= 0) {
                 /* The connection was accepted */
-                if (phone_connect(phoneid, &answer->sender->answerbox)) {
-                        /* Set 'phone hash' as arg5 of response */
+                if (phone_connect(phone_handle, &answer->sender->answerbox)) {
+                        /* Set 'phone hash' as ARG5 of response */
+                        kobject_t *phone_obj = kobject_get(TASK, phone_handle,
+                            KOBJECT_TYPE_PHONE);
                         IPC_SET_ARG5(answer->data,
-                            (sysarg_t) &TASK->phones[phoneid]);
+                            (sysarg_t) phone_obj->phone);
+                        kobject_put(phone_obj);
                 } else {
                         /* The answerbox is shutting down. */

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

@@ -43 +43 @@
 static int request_preprocess(call_t *call, phone_t *phone)
 {
-        phone_t *sender_phone;
         task_t *other_task_s;
 
-        if (phone_get(IPC_GET_ARG5(call->data), &sender_phone) != EOK)
+        kobject_t *sender_obj = kobject_get(TASK, IPC_GET_ARG5(call->data),
+            KOBJECT_TYPE_PHONE);
+        if (!sender_obj)
                 return ENOENT;
 
-        mutex_lock(&sender_phone->lock);
-        if (sender_phone->state != IPC_PHONE_CONNECTED) {
-                mutex_unlock(&sender_phone->lock);
+        mutex_lock(&sender_obj->phone->lock);
+        if (sender_obj->phone->state != IPC_PHONE_CONNECTED) {
+                mutex_unlock(&sender_obj->phone->lock);
+                kobject_put(sender_obj);
                 return EINVAL;
         }
 
-        other_task_s = sender_phone->callee->task;
+        other_task_s = sender_obj->phone->callee->task;
 
-        mutex_unlock(&sender_phone->lock);
+        mutex_unlock(&sender_obj->phone->lock);
 
         /* Remember the third party task hash. */
         IPC_SET_ARG5(call->data, (sysarg_t) other_task_s);
 
+        kobject_put(sender_obj);
         return EOK;
 }
@@ -71 +74 @@
         if (!IPC_GET_RETVAL(answer->data)) {
                 /* The recipient authorized the change of state. */
-                phone_t *recipient_phone;
                 task_t *other_task_s;
                 task_t *other_task_r;
 
-                rc = phone_get(IPC_GET_ARG1(answer->data),
-                    &recipient_phone);
-                if (rc != EOK) {
+                kobject_t *recipient_obj = kobject_get(TASK,
+                    IPC_GET_ARG1(answer->data), KOBJECT_TYPE_PHONE);
+                if (!recipient_obj) {
                         IPC_SET_RETVAL(answer->data, ENOENT);
                         return ENOENT;
                 }
 
-                mutex_lock(&recipient_phone->lock);
-                if (recipient_phone->state != IPC_PHONE_CONNECTED) {
-                        mutex_unlock(&recipient_phone->lock);
+                mutex_lock(&recipient_obj->phone->lock);
+                if (recipient_obj->phone->state != IPC_PHONE_CONNECTED) {
+                        mutex_unlock(&recipient_obj->phone->lock);
                         IPC_SET_RETVAL(answer->data, EINVAL);
+                        kobject_put(recipient_obj);
                         return EINVAL;
                 }
 
-                other_task_r = recipient_phone->callee->task;
+                other_task_r = recipient_obj->phone->callee->task;
                 other_task_s = (task_t *) IPC_GET_ARG5(*olddata);
 
@@ -110 +113 @@
                 }
 
-                mutex_unlock(&recipient_phone->lock);
+                mutex_unlock(&recipient_obj->phone->lock);
+                kobject_put(recipient_obj);
         }