Changes in kernel/generic/src/ipc/ipc.c [c1f68b0:cde999a] in mainline

File:

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

kernel/generic/src/ipc/ipc.c

@@ -66 +66 @@
 answerbox_t *ipc_phone_0 = NULL;
 
-static slab_cache_t *call_slab;
-static slab_cache_t *answerbox_slab;
-
-slab_cache_t *phone_slab = NULL; 
+static slab_cache_t *call_cache;
+static slab_cache_t *answerbox_cache;
+
+slab_cache_t *phone_cache = NULL; 
 
 /** Initialize a call structure.
@@ -87 +87 @@
 }
 
-void ipc_call_hold(call_t *call)
-{
-        atomic_inc(&call->refcnt);
-}
-
-void ipc_call_release(call_t *call)
-{
-        if (atomic_predec(&call->refcnt) == 0) {
-                if (call->buffer)
-                        free(call->buffer);
-                if (call->caller_phone)
-                        kobject_put(call->caller_phone->kobject);
-                slab_free(call_slab, call);
-        }
-}
+static void call_destroy(void *arg)
+{
+        call_t *call = (call_t *) arg;
+
+        if (call->buffer)
+                free(call->buffer);
+        if (call->caller_phone)
+                kobject_put(call->caller_phone->kobject);
+        slab_free(call_cache, call);
+}
+
+static kobject_ops_t call_kobject_ops = {
+        .destroy = call_destroy
+};
 
 /** Allocate and initialize a call structure.
@@ -116 +115 @@
 call_t *ipc_call_alloc(unsigned int flags)
 {
-        call_t *call = slab_alloc(call_slab, flags);
-        if (call) {
-                _ipc_call_init(call);
-                ipc_call_hold(call);
-        }
+        call_t *call = slab_alloc(call_cache, flags);
+        if (!call)
+                return NULL;
+        kobject_t *kobj = (kobject_t *) malloc(sizeof(kobject_t), flags);
+        if (!kobj) {
+                slab_free(call_cache, call);
+                return NULL;
+        }
+
+        _ipc_call_init(call);
+        kobject_initialize(kobj, KOBJECT_TYPE_CALL, call, &call_kobject_ops);
+        call->kobject = kobj;
         
         return call;
-}
-
-/** Deallocate a call structure.
- *
- * @param call Call structure to be freed.
- *
- */
-void ipc_call_free(call_t *call)
-{
-        ipc_call_release(call);
 }
 
@@ -209 +205 @@
  * @param request Call structure with request.
  *
- * @return EOK on success or a negative error code.
+ * @return EOK on success or an error code.
  *
  */
 int ipc_call_sync(phone_t *phone, call_t *request)
 {
-        answerbox_t *mybox = slab_alloc(answerbox_slab, 0);
+        answerbox_t *mybox = slab_alloc(answerbox_cache, 0);
         ipc_answerbox_init(mybox, TASK);
         
@@ -222 +218 @@
         int rc = ipc_call(phone, request);
         if (rc != EOK) {
-                slab_free(answerbox_slab, mybox);
+                slab_free(answerbox_cache, mybox);
                 return rc;
         }
@@ -269 +265 @@
         assert(!answer || request == answer);
         
-        slab_free(answerbox_slab, mybox);
+        slab_free(answerbox_cache, mybox);
         return rc;
 }
@@ -290 +286 @@
                 /* This is a forgotten call and call->sender is not valid. */
                 spinlock_unlock(&call->forget_lock);
-                ipc_call_free(call);
+                kobject_put(call->kobject);
                 return;
         } else {
@@ -375 +371 @@
  *
  */
-void ipc_backsend_err(phone_t *phone, call_t *call, sysarg_t err)
+void ipc_backsend_err(phone_t *phone, call_t *call, int err)
 {
         _ipc_call_actions_internal(phone, call, false);
@@ -448 +444 @@
  * @param phone Phone structure to be hung up.
  *
- * @return 0 if the phone is disconnected.
- * @return -1 if the phone was already disconnected.
+ * @return EOK if the phone is disconnected.
+ * @return EINVAL if the phone was already disconnected.
  *
  */
@@ -459 +455 @@
             phone->state == IPC_PHONE_CONNECTING) {
                 mutex_unlock(&phone->lock);
-                return -1;
+                return EINVAL;
         }
         
@@ -482 +478 @@
         mutex_unlock(&phone->lock);
         
-        return 0;
+        return EOK;
 }
 
@@ -542 +538 @@
         
 restart:
-        rc = waitq_sleep_timeout(&box->wq, usec, flags);
-        if (SYNCH_FAILED(rc))
+        rc = waitq_sleep_timeout(&box->wq, usec, flags, NULL);
+        if (rc != EOK)
                 return NULL;
         
@@ -642 +638 @@
                 phone = list_get_instance(list_first(&box->connected_phones),
                     phone_t, link);
-                if (SYNCH_FAILED(mutex_trylock(&phone->lock))) {
+                if (mutex_trylock(&phone->lock) != EOK) {
                         irq_spinlock_unlock(&box->lock, true);
                         DEADLOCK_PROBE(p_phonelck, DEADLOCK_THRESHOLD);
@@ -705 +701 @@
          * must hold a reference to it.
          */
-        ipc_call_hold(call);
+        kobject_add_ref(call->kobject);
 
         spinlock_unlock(&call->forget_lock);
@@ -714 +710 @@
         SYSIPC_OP(request_forget, call);
 
-        ipc_call_release(call);
+        kobject_put(call->kobject);
 }
 
@@ -822 +818 @@
         SYSIPC_OP(answer_process, call);
 
-        ipc_call_free(call);
+        kobject_put(call->kobject);
         goto restart;
 }
@@ -839 +835 @@
 {
         ipc_irq_unsubscribe(&TASK->answerbox, cap->handle);
+        return true;
+}
+
+static bool call_cap_cleanup_cb(cap_t *cap, void *arg)
+{
+        /*
+         * Here we just free the capability and release the kobject.
+         * The kernel answers the remaining calls elsewhere in ipc_cleanup().
+         */
+        kobject_t *kobj = cap_unpublish(cap->task, cap->handle,
+            KOBJECT_TYPE_CALL);
+        kobject_put(kobj);
+        cap_free(cap->task, cap->handle);
         return true;
 }
@@ -878 +887 @@
         ipc_kbox_cleanup();
 #endif
+
+        /* Destroy all call capabilities */
+        caps_apply_to_kobject_type(TASK, KOBJECT_TYPE_CALL, call_cap_cleanup_cb,
+            NULL);
         
         /* Answer all messages in 'calls' and 'dispatched_calls' queues */
@@ -893 +906 @@
 void ipc_init(void)
 {
-        call_slab = slab_cache_create("call_t", sizeof(call_t), 0, NULL,
+        call_cache = slab_cache_create("call_t", sizeof(call_t), 0, NULL,
             NULL, 0);
-        phone_slab = slab_cache_create("phone_t", sizeof(phone_t), 0, NULL,
+        phone_cache = slab_cache_create("phone_t", sizeof(phone_t), 0, NULL,
             NULL, 0);
-        answerbox_slab = slab_cache_create("answerbox_t", sizeof(answerbox_t),
+        answerbox_cache = slab_cache_create("answerbox_t", sizeof(answerbox_t),
             0, NULL, NULL, 0);
 }