Changeset 67f11a0 in mainline for kernel/generic/src/cap/cap.c

Timestamp:

2018-03-15T17:40:20Z (7 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

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

Children:

530f2de, e9e4068

Parents:

30f1a25 (diff), a36f442 (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.

git-author:

Jakub Jermar <jakub@…> (2018-03-15 17:25:56)

git-committer:

Jakub Jermar <jakub@…> (2018-03-15 17:40:20)

Message:

Merge branch 'noreclaimers'

This commit removes the left-over from the original IPC phone life-cycle
management in which phones were freed lazily during an attempt to
allocate a new phone when the allocator found a hung-up phone with zero
active calls. This mechanism is the reason why kernel objects had to
have the reclaim method. This commit changes the behavior in that phones
are deallocated with their last reference. At the same time it makes
sure that each active call has its own reference on the phone.

This change also makes sure that each connected phone has a capability
via which it can be hung up by the user or cleaned up in ipc_cleanup().
A special mode for phone_alloc() was introduced that allows calls such
as IPC_M_CONNECT_ME_TO and IPC_M_CONNECT_TO_ME to allocate an
unpublished capability and publish it only when the phone is
successfully connected. This fixes a nasty race condition when the user
destroys the capability before the phone is connected and then this
phone becomes essentially invisible for ipc_cleanup().

Last but not least, ipc_cleanup() was slightly streamlined in that it
now knows for how many calls it has to wait from the answerbox's active
call count.

File:

• kernel/generic/src/cap/cap.c (modified) (2 diffs)

kernel/generic/src/cap/cap.c

@@ -235 +235 @@
 }
 
-static bool cap_reclaimer(ht_link_t *link, void *arg)
-{
-        cap_t **result = (cap_t **) arg;
-        cap_t *cap = hash_table_get_inst(link, cap_t, caps_link);
-
-        if (cap->state == CAP_STATE_PUBLISHED && cap->kobject->ops->reclaim &&
-            cap->kobject->ops->reclaim(cap->kobject)) {
-                kobject_t *kobj = cap_unpublish(cap->task, cap->handle,
-                    cap->kobject->type);
-                kobject_put(kobj);
-                cap_initialize(cap, cap->task, cap->handle);
-                *result = cap;
-                return false;
-        }
-
-        return true;
-}
-
 /** Allocate new capability
  *
@@ -263 +245 @@
 errno_t cap_alloc(task_t *task, cap_handle_t *handle)
 {
-        cap_t *cap = NULL;
-
-        /*
-         * First of all, see if we can reclaim a capability. Note that this
-         * feature is only temporary and capability reclamaition will eventually
-         * be phased out.
-         */
-        mutex_lock(&task->cap_info->lock);
-        hash_table_apply(&task->cap_info->caps, cap_reclaimer, &cap);
-
-        /*
-         * If we don't have a capability by now, try to allocate a new one.
-         */
+        mutex_lock(&task->cap_info->lock);
+        cap_t *cap = slab_alloc(cap_cache, FRAME_ATOMIC);
         if (!cap) {
-                cap = slab_alloc(cap_cache, FRAME_ATOMIC);
-                if (!cap) {
-                        mutex_unlock(&task->cap_info->lock);
-                        return ENOMEM;
-                }
-                uintptr_t hbase;
-                if (!ra_alloc(task->cap_info->handles, 1, 1, &hbase)) {
-                        slab_free(cap_cache, cap);
-                        mutex_unlock(&task->cap_info->lock);
-                        return ENOMEM;
-                }
-                cap_initialize(cap, task, (cap_handle_t) hbase);
-                hash_table_insert(&task->cap_info->caps, &cap->caps_link);
-        }
+                mutex_unlock(&task->cap_info->lock);
+                return ENOMEM;
+        }
+        uintptr_t hbase;
+        if (!ra_alloc(task->cap_info->handles, 1, 1, &hbase)) {
+                slab_free(cap_cache, cap);
+                mutex_unlock(&task->cap_info->lock);
+                return ENOMEM;
+        }
+        cap_initialize(cap, task, (cap_handle_t) hbase);
+        hash_table_insert(&task->cap_info->caps, &cap->caps_link);
 
         cap->state = CAP_STATE_ALLOCATED;