Changes in kernel/generic/src/ipc/ipcrsc.c [aadde10:a35b458] in mainline

File:

• kernel/generic/src/ipc/ipcrsc.c (modified) (10 diffs)

kernel/generic/src/ipc/ipcrsc.c

@@ -39 +39 @@
  *
  * The pattern of usage of the resources is:
- * - allocate a capability and phone kernel object (do not publish yet),
- *   connect to the answerbox, and finally publish the capability
+ * - allocate empty phone capability slot, connect | deallocate slot
  * - disconnect connected phone (some messages might be on the fly)
- * - find phone capability and send a message using phone
+ * - find phone in slot and send a message using phone
  * - answer message to phone
  * - hangup phone (the caller has hung up)
@@ -54 +53 @@
  *   atomic on all platforms)
  *
+ * - To find an empty phone capability slot, the TASK must be locked
  * - To answer a message, the answerbox must be locked
  * - The locking of phone and answerbox is done at the ipc_ level.
@@ -73 +73 @@
  * *** Connect_me_to ***
  * The caller sends IPC_M_CONNECT_ME_TO to an answerbox. The server receives
- * 'phoneid' of the connecting phone as an ARG5. If it answers with RETVAL=EOK,
- * the phone call is accepted, otherwise it is refused.
+ * 'phoneid' of the connecting phone as an ARG5. If it answers with RETVAL=0,
+ * the phonecall is accepted, otherwise it is refused.
  *
  * *** Connect_to_me ***
  * The caller sends IPC_M_CONNECT_TO_ME.
  * The server receives an automatically opened phoneid. If it accepts
- * (RETVAL=EOK), it can use the phoneid immediately. Possible race condition can
+ * (RETVAL=0), it can use the phoneid immediately.  Possible race condition can
  * arise, when the client receives messages from new connection before getting
  * response for connect_to_me message. Userspace should implement handshake
@@ -95 +95 @@
  * - The phone is disconnected. EHANGUP response code is sent to the calling
  *   task. All new calls through this phone get a EHUNGUP error code, the task
- *   is expected to call sys_ipc_hangup after cleaning up its internal
+ *   is expected to send an sys_ipc_hangup after cleaning up its internal
  *   structures.
  *
@@ -137 +137 @@
 #include <mm/slab.h>
 
+static bool phone_reclaim(kobject_t *kobj)
+{
+        bool gc = false;
+
+        mutex_lock(&kobj->phone->lock);
+        if (kobj->phone->state == IPC_PHONE_HUNGUP &&
+            atomic_get(&kobj->phone->active_calls) == 0)
+                gc = true;
+        mutex_unlock(&kobj->phone->lock);
+
+        return gc;
+}
+
 static void phone_destroy(void *arg)
 {
@@ -144 +157 @@
 
 static kobject_ops_t phone_kobject_ops = {
+        .reclaim = phone_reclaim,
         .destroy = phone_destroy
 };
@@ -150 +164 @@
 /** Allocate new phone in the specified task.
  *
- * @param[in]  task     Task for which to allocate a new phone.
- * @param[in]  publish  If true, the new capability will be published.
- * @param[out] phandle  New phone capability handle.
- * @param[out] kobject  New phone kobject.
+ * @param task  Task for which to allocate a new phone.
+ *
+ * @param[out] out_handle  New phone capability handle.
  *
  * @return  An error code if a new capability cannot be allocated.
  */
-errno_t phone_alloc(task_t *task, bool publish, cap_handle_t *phandle,
-    kobject_t **kobject)
+errno_t phone_alloc(task_t *task, cap_handle_t *out_handle)
 {
         cap_handle_t handle;
@@ -168 +180 @@
                         return ENOMEM;
                 }
-                kobject_t *kobj = malloc(sizeof(kobject_t), FRAME_ATOMIC);
-                if (!kobj) {
+                kobject_t *kobject = malloc(sizeof(kobject_t), FRAME_ATOMIC);
+                if (!kobject) {
                         cap_free(TASK, handle);
                         slab_free(phone_cache, phone);
@@ -178 +190 @@
                 phone->state = IPC_PHONE_CONNECTING;
 
-                kobject_initialize(kobj, KOBJECT_TYPE_PHONE, phone,
+                kobject_initialize(kobject, KOBJECT_TYPE_PHONE, phone,
                     &phone_kobject_ops);
-                phone->kobject = kobj;
-
-                if (publish)
-                        cap_publish(task, handle, kobj);
-
-                *phandle = handle;
-                if (kobject)
-                        *kobject = kobj;
+                phone->kobject = kobject;
+
+                cap_publish(task, handle, kobject);
+
+                *out_handle = handle;
         }
         return rc;
@@ -205 +214 @@
                 return;
 
+        assert(kobj->phone);
+        assert(kobj->phone->state == IPC_PHONE_CONNECTING);
+
         kobject_put(kobj);
         cap_free(TASK, handle);
 }
 
+/** Connect phone to a given answerbox.
+ *
+ * @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.
+ */
+bool phone_connect(cap_handle_t handle, answerbox_t *box)
+{
+        kobject_t *phone_obj = kobject_get(TASK, handle, KOBJECT_TYPE_PHONE);
+        if (!phone_obj)
+                return false;
+
+        assert(phone_obj->phone->state == IPC_PHONE_CONNECTING);
+
+        /* Hand over phone_obj reference to the answerbox */
+        return ipc_phone_connect(phone_obj->phone, box);
+}
+
 /** @}
  */