Changeset 3f74275 in mainline for kernel/generic/src/ipc

Timestamp:

2017-08-20T16:45:01Z (8 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

e68765e

Parents:

e7ac23d0

Message:

Fix terminology around capabilities, capability handles and kernel objects

Location:

kernel/generic/src/ipc

Files:

• ipc.c (modified) (4 diffs)
• ipcrsc.c (modified) (6 diffs)
• irq.c (modified) (5 diffs)

kernel/generic/src/ipc/ipc.c

@@ -59 +59 @@
 #include <arch/interrupt.h>
 #include <ipc/irq.h>
-#include <kobject/kobject.h>
+#include <cap/cap.h>
 
 static void ipc_forget_call(call_t *);
@@ -743 +743 @@
          */
         all_clean = true;
-        for_each_kobject_current(kobj, KOBJECT_TYPE_PHONE) {
-                phone_t *phone = &kobj->phone;
+        for_each_cap_current(cap, CAP_TYPE_PHONE) {
+                phone_t *phone = &cap->phone;
 
                 mutex_lock(&phone->lock);
@@ -820 +820 @@
 
         /* Disconnect all our phones ('ipc_phone_hangup') */
-        for_each_kobject_current(kobj, KOBJECT_TYPE_PHONE) {
-                phone_t *phone = &kobj->phone;
+        for_each_cap_current(cap, CAP_TYPE_PHONE) {
+                phone_t *phone = &cap->phone;
                 ipc_phone_hangup(phone);
         }
@@ -911 +911 @@
         printf("[phone cap] [calls] [state\n");
         
-        for_each_kobject(task, kobj, KOBJECT_TYPE_PHONE) {
-                phone_t *phone = &kobj->phone;
-                int cap = kobject_to_cap(task, kobj);
-
+        for_each_cap(task, cap, CAP_TYPE_PHONE) {
+                phone_t *phone = &cap->phone;
+                int cap_handle = cap_get_handle(task, cap);
+        
                 if (SYNCH_FAILED(mutex_trylock(&phone->lock))) {
-                        printf("%-11d (mutex busy)\n", cap);
+                        printf("%-11d (mutex busy)\n", cap_handle);
                         continue;
                 }
                 
                 if (phone->state != IPC_PHONE_FREE) {
-                        printf("%-11d %7" PRIun " ", cap,
+                        printf("%-11d %7" PRIun " ", cap_handle,
                             atomic_get(&phone->active_calls));
                         

kernel/generic/src/ipc/ipcrsc.c

@@ -133 +133 @@
 #include <assert.h>
 #include <abi/errno.h>
-#include <kobject/kobject.h>
+#include <cap/cap.h>
 
 /** Find call_t * in call table according to callid.
@@ -163 +163 @@
 }
 
-/** Get phone from the current task by capability.
- *
- * @param cap    Phone capability.
- * @param phone  Place to store pointer to phone.
+/** Get phone from the current task by capability handle.
+ *
+ * @param handle  Phone capability handle.
+ * @param phone   Place to store pointer to phone.
  *
  * @return  Address of the phone kernel object.
@@ -172 +172 @@
  *
  */
-phone_t *phone_get(task_t *task, int cap)
-{
-        kobject_t *kobj = kobject_get(task, cap, KOBJECT_TYPE_PHONE);
-        if (!kobj)
+phone_t *phone_get(task_t *task, int handle)
+{
+        cap_t *cap = cap_get(task, handle, CAP_TYPE_PHONE);
+        if (!cap)
                 return NULL;
         
-        return &kobj->phone;
-}
-
-phone_t *phone_get_current(int cap)
-{
-        return phone_get(TASK, cap);
-}
-
-static bool phone_can_reclaim(kobject_t *kobj)
-{
-        assert(kobj->type == KOBJECT_TYPE_PHONE);
-
-        return (kobj->phone.state == IPC_PHONE_HUNGUP) &&
-            (atomic_get(&kobj->phone.active_calls) == 0);
+        return &cap->phone;
+}
+
+phone_t *phone_get_current(int handle)
+{
+        return phone_get(TASK, handle);
+}
+
+static bool phone_can_reclaim(cap_t *cap)
+{
+        assert(cap->type == CAP_TYPE_PHONE);
+
+        return (cap->phone.state == IPC_PHONE_HUNGUP) &&
+            (atomic_get(&cap->phone.active_calls) == 0);
 }
 
@@ -198 +198 @@
  * @param task  Task for which to allocate a new phone.
  *
- * @return  New phone capability.
+ * @return  New phone capability handle.
  * @return  Negative error code if a new capability cannot be allocated.
  */
 int phone_alloc(task_t *task)
 {
-        int cap = kobject_alloc(task);
-        if (cap >= 0) {
+        int handle = cap_alloc(task);
+        if (handle >= 0) {
                 irq_spinlock_lock(&task->lock, true);
-                kobject_t *kobj = &task->kobject[cap];
-                ipc_phone_init(&kobj->phone, task);
-                kobj->type = KOBJECT_TYPE_PHONE;
-                kobj->can_reclaim = phone_can_reclaim;
-                kobj->phone.state = IPC_PHONE_CONNECTING;
+                cap_t *cap = &task->caps[handle];
+                ipc_phone_init(&cap->phone, task);
+                cap->type = CAP_TYPE_PHONE;
+                cap->can_reclaim = phone_can_reclaim;
+                cap->phone.state = IPC_PHONE_CONNECTING;
                 irq_spinlock_unlock(&task->lock, true);
         }
         
-        return cap;
+        return handle;
 }
 
@@ -221 +221 @@
  * All already sent messages will be correctly processed.
  *
- * @param phoneid Phone handle of the phone to be freed.
- *
- */
-void phone_dealloc(int cap)
-{
-        phone_t *phone = phone_get_current(cap);
+ * @param handle Phone capability handle of the phone to be freed.
+ *
+ */
+void phone_dealloc(int handle)
+{
+        phone_t *phone = phone_get_current(handle);
         
         assert(phone);
         assert(phone->state == IPC_PHONE_CONNECTING);
 
-        kobject_free(TASK, cap);
+        cap_free(TASK, handle);
 }
 
 /** Connect phone to a given answerbox.
  *
- * @param cap  Phone capability to be connected.
- * @param box  Answerbox to which to connect the phone capability.
- * @return     True if the phone was connected, false otherwise.
+ * @param handle  Capability handle of the phone to be connected.
+ * @param box     Answerbox to which to connect the phone.
+ * @return        True if the phone was connected, false otherwise.
  *
  * The procedure _enforces_ that the user first marks the phone busy (e.g. via
@@ -245 +245 @@
  *
  */
-bool phone_connect(int cap, answerbox_t *box)
-{
-        phone_t *phone = phone_get_current(cap);
+bool phone_connect(int handle, answerbox_t *box)
+{
+        phone_t *phone = phone_get_current(handle);
         
         assert(phone);

kernel/generic/src/ipc/irq.c

@@ -84 +84 @@
 #include <print.h>
 #include <macros.h>
-#include <kobject/kobject.h>
+#include <cap/cap.h>
 
 static void ranges_unmap(irq_pio_range_t *ranges, size_t rangecount)
@@ -298 +298 @@
  * @param ucode   Uspace pointer to top-half pseudocode.
  *
- * @return  IRQ capability.
+ * @return  IRQ capability handle.
  * @return  Negative error code.
  *
@@ -324 +324 @@
          * Allocate and populate the IRQ kernel object.
          */
-        int cap = kobject_alloc(TASK);
-        if (cap < 0)
-                return cap;
-        kobject_t *kobj = kobject_get_current(cap, KOBJECT_TYPE_ALLOCATED);
-        assert(kobj);
-        kobj->type = KOBJECT_TYPE_IRQ;
-
-        irq_t *irq = &kobj->irq;
+        int handle = cap_alloc(TASK);
+        if (handle < 0)
+                return handle;
+        cap_t *cap = cap_get_current(handle, CAP_TYPE_ALLOCATED);
+        assert(cap);
+        cap->type = CAP_TYPE_IRQ;
+
+        irq_t *irq = &cap->irq;
         irq_initialize(irq);
         irq->inr = inr;
@@ -357 +357 @@
         irq_spinlock_unlock(&irq_uspace_hash_table_lock, true);
         
-        return cap;
+        return handle;
 }
 
 /** Unsubscribe task from IRQ notification.
  *
- * @param box      Answerbox associated with the notification.
- * @param irq_cap  IRQ capability.
+ * @param box     Answerbox associated with the notification.
+ * @param handle  IRQ capability handle.
  *
  * @return EOK on success or a negative error code.
  *
  */
-int ipc_irq_unsubscribe(answerbox_t *box, int irq_cap)
-{
-        kobject_t *kobj = kobject_get_current(irq_cap, KOBJECT_TYPE_IRQ);
-        if (!kobj)
+int ipc_irq_unsubscribe(answerbox_t *box, int handle)
+{
+        cap_t *cap = cap_get_current(handle, CAP_TYPE_IRQ);
+        if (!cap)
                 return ENOENT;
-        irq_t *irq = &kobj->irq;
+        irq_t *irq = &cap->irq;
 
         irq_spinlock_lock(&irq_uspace_hash_table_lock, true);
@@ -394 +394 @@
         code_free(irq->notif_cfg.code);
         
-        /* Free up the IRQ kernel object. */
-        kobject_free(TASK, irq_cap);
+        /* Free up the IRQ capability and the underlying kernel object. */
+        cap_free(TASK, handle);
         
         return EOK;