Changeset 3f74275 in mainline

Timestamp:

2017-08-20T16:45:01Z (7 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

Files:

• kernel/Makefile (modified) (1 diff)
• kernel/generic/include/cap/cap.h (moved) (moved from kernel/generic/include/kobject/kobject.h ) (2 diffs)
• kernel/generic/include/proc/task.h (modified) (2 diffs)
• kernel/generic/src/cap/cap.c (moved) (moved from kernel/generic/src/kobject/kobject.c ) (3 diffs)
• kernel/generic/src/ipc/ipc.c (modified) (4 diffs)
• kernel/generic/src/ipc/ipcrsc.c (modified) (6 diffs)
• kernel/generic/src/ipc/irq.c (modified) (5 diffs)
• kernel/generic/src/proc/task.c (modified) (5 diffs)
• uspace/drv/char/ns8250/ns8250.c (modified) (1 diff)
• uspace/drv/nic/e1k/e1k.c (modified) (1 diff)
• uspace/drv/nic/rtl8139/driver.c (modified) (1 diff)
• uspace/lib/c/generic/async.c (modified) (2 diffs)
• uspace/lib/c/generic/irq.c (modified) (2 diffs)
• uspace/lib/usbhost/src/ddf_helpers.c (modified) (1 diff)

kernel/Makefile

@@ -285 +285 @@
         generic/src/ipc/irq.c \
         generic/src/ipc/event.c \
-        generic/src/kobject/kobject.c \
+        generic/src/cap/cap.c \
         generic/src/security/perm.c \
         generic/src/sysinfo/sysinfo.c \

kernel/generic/include/cap/cap.h

@@ -33 +33 @@
  */
 
-#ifndef KERN_KOBJECT_H_
-#define KERN_KOBJECT_H_
+#ifndef KERN_CAP_H_
+#define KERN_CAP_H_
 
 #include <typedefs.h>
@@ -40 +40 @@
 #include <ddi/irq.h>
 
-#define MAX_KERNEL_OBJECTS  64
+#define MAX_CAPS  64
 
-#define for_each_kobject(task, ko, type) \
-        for (int i = 0, l = 1; i < MAX_KERNEL_OBJECTS && l; i++) \
-                for (kobject_t *(ko) = kobject_get((task), i, (type)); \
-                    (ko) && !(l = 0); (ko) = NULL, l = 1)
+#define for_each_cap(task, cap, type) \
+        for (int i = 0, l = 1; i < MAX_CAPS && l; i++) \
+                for (cap_t *(cap) = cap_get((task), i, (type)); \
+                    (cap) && !(l = 0); (cap) = NULL, l = 1)
 
-#define for_each_kobject_current(ko, type) \
-        for_each_kobject(TASK, (ko), (type))
+#define for_each_cap_current(cap, type) \
+        for_each_cap(TASK, (cap), (type))
 
 typedef enum {
-        KOBJECT_TYPE_INVALID,
-        KOBJECT_TYPE_ALLOCATED,
-        KOBJECT_TYPE_PHONE,
-        KOBJECT_TYPE_IRQ
-} kobject_type_t;
+        CAP_TYPE_INVALID,
+        CAP_TYPE_ALLOCATED,
+        CAP_TYPE_PHONE,
+        CAP_TYPE_IRQ
+} cap_type_t;
 
-typedef struct kobject {
-        kobject_type_t type;
-        bool (* can_reclaim)(struct kobject *);
+typedef struct cap {
+        cap_type_t type;
+        bool (* can_reclaim)(struct cap *);
 
+        /* The underlying kernel object. */
         union {
                 phone_t phone;
                 irq_t irq;
         };
-} kobject_t;
+} cap_t;
 
 struct task;
 
-void kobject_task_alloc(struct task *);
-void kobject_task_free(struct task *);
-void kobject_task_init(struct task *);
+void caps_task_alloc(struct task *);
+void caps_task_free(struct task *);
+void caps_task_init(struct task *);
 
-extern void kobject_initialize(kobject_t *);
-extern kobject_t *kobject_get(struct task *, int, kobject_type_t);
-extern kobject_t *kobject_get_current(int, kobject_type_t);
-extern int kobject_alloc(struct task *);
-extern void kobject_free(struct task *, int);
+extern void cap_initialize(cap_t *);
+extern cap_t *cap_get(struct task *, int, cap_type_t);
+extern cap_t *cap_get_current(int, cap_type_t);
+extern int cap_alloc(struct task *);
+extern void cap_free(struct task *, int);
 
-extern int kobject_to_cap(struct task *, kobject_t *);
+extern int cap_get_handle(struct task *, cap_t *);
 
 #endif

kernel/generic/include/proc/task.h

@@ -65 +65 @@
 
 struct thread;
-struct kobject;
+struct cap;
 
 /** Task structure. */
@@ -97 +97 @@
         perm_t perms;
 
-        /** Kernel objects */
-        struct kobject *kobject;
+        /** Capabilities */
+        struct cap *caps;
         
         /* IPC stuff */

kernel/generic/src/cap/cap.c

@@ -33 +33 @@
  */
 
-#include <kobject/kobject.h>
+#include <cap/cap.h>
 #include <proc/task.h>
 #include <synch/spinlock.h>
@@ -39 +39 @@
 #include <mm/slab.h>
 
-void kobject_initialize(kobject_t *kobj)
+void cap_initialize(cap_t *cap)
 {
-        kobj->type = KOBJECT_TYPE_INVALID;
-        kobj->can_reclaim = NULL;
+        cap->type = CAP_TYPE_INVALID;
+        cap->can_reclaim = NULL;
 }
 
-void kobject_task_alloc(task_t *task)
+void caps_task_alloc(task_t *task)
 {
-        task->kobject = malloc(sizeof(kobject_t) * MAX_KERNEL_OBJECTS, 0);
+        task->caps = malloc(sizeof(cap_t) * MAX_CAPS, 0);
 }
 
-void kobject_task_init(task_t *task)
+void caps_task_init(task_t *task)
 {
-        for (int cap = 0; cap < MAX_KERNEL_OBJECTS; cap++)
-                kobject_initialize(&task->kobject[cap]);
+        for (int i = 0; i < MAX_CAPS; i++)
+                cap_initialize(&task->caps[i]);
 }
 
-void kobject_task_free(task_t *task)
+void caps_task_free(task_t *task)
 {
-        free(task->kobject);
+        free(task->caps);
 }
 
-kobject_t *kobject_get(task_t *task, int cap, kobject_type_t type)
+cap_t *cap_get(task_t *task, int handle, cap_type_t type)
 {
-        if ((cap < 0) || (cap >= MAX_KERNEL_OBJECTS))
+        if ((handle < 0) || (handle >= MAX_CAPS))
                 return NULL;
-        if (task->kobject[cap].type != type)
+        if (task->caps[handle].type != type)
                 return NULL;
-        return &task->kobject[cap];
+        return &task->caps[handle];
 }
 
-kobject_t *kobject_get_current(int cap, kobject_type_t type)
+cap_t *cap_get_current(int handle, cap_type_t type)
 {
-        return kobject_get(TASK, cap, type);
+        return cap_get(TASK, handle, type);
 }
 
-int kobject_alloc(task_t *task)
+int cap_alloc(task_t *task)
 {
-        int cap;
+        int handle;
 
         irq_spinlock_lock(&task->lock, true);
-        for (cap = 0; cap < MAX_KERNEL_OBJECTS; cap++) {
-                kobject_t *kobj = &task->kobject[cap];
-                if (kobj->type > KOBJECT_TYPE_ALLOCATED) {
-                        if (kobj->can_reclaim && kobj->can_reclaim(kobj))
-                                kobject_initialize(kobj);
+        for (handle = 0; handle < MAX_CAPS; handle++) {
+                cap_t *cap = &task->caps[handle];
+                if (cap->type > CAP_TYPE_ALLOCATED) {
+                        if (cap->can_reclaim && cap->can_reclaim(cap))
+                                cap_initialize(cap);
                 }
-                if (kobj->type == KOBJECT_TYPE_INVALID) {
-                        kobj->type = KOBJECT_TYPE_ALLOCATED;
+                if (cap->type == CAP_TYPE_INVALID) {
+                        cap->type = CAP_TYPE_ALLOCATED;
                         irq_spinlock_unlock(&task->lock, true);
-                        return cap;
+                        return handle;
                 }
         }
@@ -97 +97 @@
 }
 
-void kobject_free(task_t *task, int cap)
+void cap_free(task_t *task, int handle)
 {
-        assert(cap >= 0);
-        assert(cap < MAX_KERNEL_OBJECTS);
-        assert(task->kobject[cap].type != KOBJECT_TYPE_INVALID);
+        assert(handle >= 0);
+        assert(handle < MAX_CAPS);
+        assert(task->caps[handle].type != CAP_TYPE_INVALID);
 
         irq_spinlock_lock(&task->lock, true);
-        kobject_initialize(&task->kobject[cap]);
+        cap_initialize(&task->caps[handle]);
         irq_spinlock_unlock(&task->lock, true);
 }
 
-int kobject_to_cap(task_t *task, kobject_t *kobj)
+int cap_get_handle(task_t *task, cap_t *cap)
 {
-        return kobj - task->kobject;
+        return cap - task->caps;
 }
 

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;

kernel/generic/src/proc/task.c

@@ -50 +50 @@
 #include <adt/btree.h>
 #include <adt/list.h>
-#include <kobject/kobject.h>
+#include <cap/cap.h>
 #include <ipc/ipc.h>
 #include <ipc/ipcrsc.h>
@@ -169 +169 @@
         list_initialize(&task->threads);
         
-        kobject_task_alloc(task);
+        caps_task_alloc(task);
         
         ipc_answerbox_init(&task->answerbox, task);
@@ -190 +190 @@
         task_t *task = (task_t *) obj;
         
-        kobject_task_free(task);
+        caps_task_free(task);
         return 0;
 }
@@ -215 +215 @@
         task->kcycles = 0;
 
-        kobject_task_init(task);
+        caps_task_init(task);
 
         task->ipc_info.call_sent = 0;
@@ -624 +624 @@
         
         if (*additional) {
-                for_each_kobject(task, ko, KOBJECT_TYPE_PHONE) {
-                        phone_t *phone = &ko->phone;
+                for_each_cap(task, cap, CAP_TYPE_PHONE) {
+                        phone_t *phone = &cap->phone;
                         if (phone->callee)
-                                printf(" %d:%p", kobject_to_cap(task, ko),
+                                printf(" %d:%p", cap_get_handle(task, cap),
                                     phone->callee);
                 }

uspace/drv/char/ns8250/ns8250.c

@@ -160 +160 @@
         /** The irq assigned to this device. */
         int irq;
-        /** IRQ capability */
+        /** IRQ capability handle */
         int irq_cap;
         /** The base i/o address of the devices registers. */

uspace/drv/nic/e1k/e1k.c

@@ -1253 +1253 @@
  * @param nic Driver data
  *
- * @return IRQ capability if the handler was registered
+ * @return IRQ capability handle if the handler was registered
  * @return Negative error code otherwise
  *

uspace/drv/nic/rtl8139/driver.c

@@ -881 +881 @@
  *  @param nic_data  The driver data
  *
- *  @return IRQ capability if the handler was registered.
+ *  @return IRQ capability handle if the handler was registered.
  *  @return Negative error code otherwise.
  */

uspace/lib/c/generic/async.c

@@ -1026 +1026 @@
  * @param ucode   Top-half pseudocode handler.
  *
- * @return IRQ capability on success.
+ * @return IRQ capability handle on success.
  * @return Negative error code.
  *
@@ -1056 +1056 @@
 /** Unsubscribe from IRQ notification.
  *
- * @param cap     IRQ capability. 
+ * @param cap     IRQ capability handle. 
  *
  * @return Zero on success or a negative error code.

uspace/lib/c/generic/irq.c

@@ -58 +58 @@
  * @param ucode  Top-half pseudocode handler.
  *
- * @return IRQ capability returned by the kernel.
+ * @return IRQ capability handle returned by the kernel.
  * @return Error code returned by the kernel.
  *
@@ -72 +72 @@
 /** Unsubscribe from IRQ notification.
  *
- * @param cap   IRQ capability.
+ * @param cap   IRQ capability handle.
  *
  * @return Value returned by the kernel.

uspace/lib/usbhost/src/ddf_helpers.c

@@ -748 +748 @@
  * @param[in] gen_irq_code IRQ code generator.
  *
- * @return IRQ kernel object capability on success.
+ * @return IRQ capability handle on success.
  * @return Negative error code.
  */