Changeset c1f68b0 in mainline

Timestamp:

2017-10-28T11:40:41Z (7 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

eca820c

Parents:

15d9fe6

Message:

Use recursive mutex to protect task_t::cap_info

This makes it possible to use the mutex-protected capability APIs even
inside caps_apply_to_kobject_type() callbacks. Now there is no need to
provide eg. cap_unpublish_locked() and cap_free_locked(). Likewise,
ipc_irq_unsubscribe() can be used when the task's cap_info is already
locked by the current thread inside of a callback.

Location:

kernel/generic

Files:

• include/cap/cap.h (modified) (1 diff)
• src/cap/cap.c (modified) (5 diffs)
• src/ipc/ipc.c (modified) (2 diffs)
• src/ipc/irq.c (modified) (2 diffs)

kernel/generic/include/cap/cap.h

@@ -121 +121 @@
 extern void cap_publish(struct task *, cap_handle_t, kobject_t *);
 extern kobject_t *cap_unpublish(struct task *, cap_handle_t, kobject_type_t);
-extern kobject_t *cap_unpublish_locked(struct task *, cap_handle_t,
-    kobject_type_t);
 extern void cap_free(struct task *, cap_handle_t);
-extern void cap_free_locked(struct task *, cap_handle_t);
 
 extern void kobject_initialize(kobject_t *, kobject_type_t, void *,

kernel/generic/src/cap/cap.c

@@ -148 +148 @@
 void caps_task_init(task_t *task)
 {
-        mutex_initialize(&task->cap_info->lock, MUTEX_PASSIVE);
+        mutex_initialize(&task->cap_info->lock, MUTEX_RECURSIVE);
 
         for (kobject_type_t t = 0; t < KOBJECT_TYPE_MAX; t++)
@@ -238 +238 @@
         if (cap->state == CAP_STATE_PUBLISHED && cap->kobject->ops->reclaim &&
             cap->kobject->ops->reclaim(cap->kobject)) {
-                kobject_t *kobj = cap_unpublish_locked(cap->task, cap->handle,
+                kobject_t *kobj = cap_unpublish(cap->task, cap->handle,
                     cap->kobject->type);
                 kobject_put(kobj);
@@ -318 +318 @@
 }
 
-/** @copydoc cap_unpublish()
- *
- * Can only be called internally by the capability subsytem or from a
- * caps_apply_to_kobject_type() callback.
- */
-kobject_t *
-cap_unpublish_locked(task_t *task, cap_handle_t handle, kobject_type_t type)
+/** Unpublish published capability
+ *
+ * The kernel object is moved out of the capability. In other words, the
+ * capability's reference to the objects is handed over to the kernel object
+ * pointer returned by this function. Once unpublished, the capability does not
+ * refer to any kernel object anymore.
+ *
+ * @param task    Task in which to unpublish the capability.
+ * @param handle  Capability handle.
+ * @param type    Kernel object type of the object associated with the
+ *                capability.
+ */
+kobject_t *cap_unpublish(task_t *task, cap_handle_t handle, kobject_type_t type)
 {
         kobject_t *kobj = NULL;
 
+        mutex_lock(&task->cap_info->lock);
         cap_t *cap = cap_get(task, handle, CAP_STATE_PUBLISHED);
         if (cap) {
@@ -338 +345 @@
                 }
         }
+        mutex_unlock(&task->cap_info->lock);
 
         return kobj;
 }
 
-/** Unpublish published capability
- *
- * The kernel object is moved out of the capability. In other words, the
- * capability's reference to the objects is handed over to the kernel object
- * pointer returned by this function. Once unpublished, the capability does not
- * refer to any kernel object anymore.
- *
- * @param task    Task in which to unpublish the capability.
+/** Free allocated capability
+ *
+ * @param task    Task in which to free the capability.
  * @param handle  Capability handle.
- * @param type    Kernel object type of the object associated with the
- *                capability.
- */
-kobject_t *cap_unpublish(task_t *task, cap_handle_t handle, kobject_type_t type)
-{
-
-        mutex_lock(&task->cap_info->lock);
-        kobject_t *kobj = cap_unpublish_locked(task, handle, type);
-        mutex_unlock(&task->cap_info->lock);
-
-        return kobj;
-}
-
-/** @copydoc cap_free()
- *
- * Can only be called internally by the capability subsytem or from a
- * caps_apply_to_kobject_type() callback.
- */
-void cap_free_locked(task_t *task, cap_handle_t handle)
+ */
+void cap_free(task_t *task, cap_handle_t handle)
 {
         assert(handle >= 0);
         assert(handle < MAX_CAPS);
 
+        mutex_lock(&task->cap_info->lock);
         cap_t *cap = cap_get(task, handle, CAP_STATE_ALLOCATED);
 
@@ -381 +368 @@
         ra_free(task->cap_info->handles, handle, 1);
         slab_free(cap_slab, cap);
-}
-
-/** Free allocated capability
- *
- * @param task    Task in which to free the capability.
- * @param handle  Capability handle.
- */
-void cap_free(task_t *task, cap_handle_t handle)
-{
-        mutex_lock(&task->cap_info->lock);
-        cap_free_locked(task, handle);
         mutex_unlock(&task->cap_info->lock);
 }

kernel/generic/src/ipc/ipc.c

@@ -829 +829 @@
 {
         ipc_phone_hangup(cap->kobject->phone);
-        kobject_t *kobj = cap_unpublish_locked(cap->task, cap->handle,
+        kobject_t *kobj = cap_unpublish(cap->task, cap->handle,
             KOBJECT_TYPE_PHONE);
         kobject_put(kobj);
-        cap_free_locked(cap->task, cap->handle);
+        cap_free(cap->task, cap->handle);
         return true;
 }
@@ -839 +839 @@
 {
         ipc_irq_unsubscribe(&TASK->answerbox, cap->handle);
-        kobject_t *kobj = cap_unpublish_locked(cap->task, cap->handle,
-            KOBJECT_TYPE_IRQ);
-        kobject_put(kobj);
-        cap_free_locked(cap->task, cap->handle);
         return true;
 }

kernel/generic/src/ipc/irq.c

@@ -271 +271 @@
 }
 
+static void irq_hash_out(irq_t *irq)
+{
+        irq_spinlock_lock(&irq_uspace_hash_table_lock, true);
+        irq_spinlock_lock(&irq->lock, false);
+        
+        if (irq->notif_cfg.hashed_in) {
+                /* Remove the IRQ from the uspace IRQ hash table. */
+                hash_table_remove_item(&irq_uspace_hash_table, &irq->link);
+                irq->notif_cfg.hashed_in = false;
+        }
+
+        irq_spinlock_unlock(&irq->lock, false);
+        irq_spinlock_unlock(&irq_uspace_hash_table_lock, true);
+}
+
 static void irq_destroy(void *arg)
 {
         irq_t *irq = (irq_t *) arg;
+
+        irq_hash_out(irq);
 
         /* Free up the IRQ code and associated structures. */
@@ -373 +390 @@
         assert(kobj->irq->notif_cfg.answerbox == box);
 
-        irq_spinlock_lock(&irq_uspace_hash_table_lock, true);
-        irq_spinlock_lock(&kobj->irq->lock, false);
-        
-        if (kobj->irq->notif_cfg.hashed_in) {
-                /* Remove the IRQ from the uspace IRQ hash table. */
-                hash_table_remove_item(&irq_uspace_hash_table,
-                    &kobj->irq->link);
-                kobj->irq->notif_cfg.hashed_in = false;
-        }
-
-        irq_spinlock_unlock(&kobj->irq->lock, false);
-        irq_spinlock_unlock(&irq_uspace_hash_table_lock, true);
+        irq_hash_out(kobj->irq);
 
         kobject_put(kobj);