Changeset 67f11a0 in mainline for kernel/generic/src/ipc/ops/conctmeto.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/ipc/ops/conctmeto.c (modified) (4 diffs)

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

@@ -42 +42 @@
 static errno_t request_preprocess(call_t *call, phone_t *phone)
 {
+        /*
+         * Create the new phone and capability, but don't publish them yet.
+         * That will be done once the phone is connected.
+         */
         cap_handle_t phone_handle;
-        errno_t rc = phone_alloc(TASK, &phone_handle);
-
-        /* Remember the phone capability or that an error occured. */
-        call->priv = (rc == EOK) ? phone_handle : -1;
-
+        kobject_t *phone_obj;
+        errno_t rc = phone_alloc(TASK, false, &phone_handle, &phone_obj);
         if (rc != EOK) {
+                call->priv = -1;
                 return rc;
         }
 
-        /* Set arg5 for server */
-        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);
+
+        /* Remember the handle */
+        call->priv = phone_handle;
 
         return EOK;
@@ -65 +67 @@
         cap_handle_t phone_handle = (cap_handle_t) call->priv;
 
-        if (phone_handle < 0) {
+        if (phone_handle < 0)
                 return EOK;
-        }
 
-        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 */
+        /* Drop phone->kobject's reference */
         kobject_put(phone->kobject);
+        cap_free(TASK, phone_handle);
+
         return EOK;
 }
@@ -82 +84 @@
         phone_t *phone = (phone_t *) IPC_GET_ARG5(*olddata);
 
-        /* If the user accepted call, connect */
+        /*
+         * Get an extra reference and pass it in the answer data.
+         */
+        kobject_add_ref(phone->kobject);
+        IPC_SET_ARG5(answer->data, (sysarg_t) phone);
+
+        /* If the user accepted the call, connect */
         if (IPC_GET_RETVAL(answer->data) == EOK) {
                 /* Hand over reference from phone to the answerbox */
@@ -96 +104 @@
 {
         cap_handle_t phone_handle = (cap_handle_t) answer->priv;
+        phone_t *phone = (phone_t *) IPC_GET_ARG5(answer->data);
 
         if (IPC_GET_RETVAL(answer->data)) {
                 if (phone_handle >= 0) {
                         /*
-                         * The phone was indeed allocated and now needs
-                         * to be deallocated.
+                         * Cleanup the unpublished capability and drop
+                         * phone->kobject's reference.
                          */
-                        phone_dealloc(phone_handle);
+                        kobject_put(phone->kobject);
+                        cap_free(TASK, phone_handle);
                 }
         } else {
+                /*
+                 * Publish the capability. Publishing the capability this late
+                 * is important for ipc_cleanup() where we want to have a
+                 * capability for each phone that wasn't hung up by the user.
+                 */
+                cap_publish(TASK, phone_handle, phone->kobject);
+
                 IPC_SET_ARG5(answer->data, phone_handle);
         }