Changeset 241f1985 in mainline for uspace/srv/taskman/event.c

Timestamp:

2019-08-31T10:45:17Z (6 years ago)

Author:

Matthieu Riolo <matthieu.riolo@…>

Children:

102f641

Parents:

f92b315

git-author:

Matthieu Riolo <matthieu.riolo@…> (2019-08-23 22:04:34)

git-committer:

Matthieu Riolo <matthieu.riolo@…> (2019-08-31 10:45:17)

Message:

Correcting failure from previous merge

The commits from Michal Koutný from the branch system-daemon
where built on a old version of Helenos. Because of this
many types and API functions have changed. This commit
upgrades the merge code

File:

• uspace/srv/taskman/event.c (modified) (15 diffs)

uspace/srv/taskman/event.c

@@ -49 +49 @@
         task_id_t id;         /**< Task ID who we wait for. */
         task_id_t waiter_id;  /**< Task ID who waits. */
-        ipc_callid_t callid;  /**< Call ID waiting for the event. */
+        ipc_call_t *icall;  /**< Call ID waiting for the event. */
         int flags;            /**< Wait flags. */
 } pending_wait_t;
@@ -59 +59 @@
 static FIBRIL_RWLOCK_INITIALIZE(listeners_lock);
 
-int event_init(void)
+errno_t event_init(void)
 {
         list_initialize(&pending_waits);
@@ -150 +150 @@
                 int match = notify_flags & pr->flags;
                 // TODO why do I even accept such calls?
-                bool answer = !(pr->callid & IPC_CALLID_NOTIFICATION);
+                bool answer = !(pr->icall->flags & IPC_CALL_NOTIF);
 
                 if (match == 0) {
@@ -156 +156 @@
                                 /* Nothing to wait for anymore */
                                 if (answer) {
-                                        async_answer_0(pr->callid, EINTR);
+                                        async_answer_0(pr->icall, EINTR);
                                 }
                         } else {
@@ -165 +165 @@
                         if ((pr->flags & TASK_WAIT_BOTH) && match == TASK_WAIT_EXIT) {
                                 /* No sense to wait for both anymore */
-                                async_answer_1(pr->callid, EINTR, t->exit);
+                                async_answer_1(pr->icall, EINTR, t->exit);
                         } else {
                                 /* Send both exit status and retval, caller
                                  * should know what is valid */
-                                async_answer_3(pr->callid, EOK, t->exit,
+                                async_answer_3(pr->icall, EOK, t->exit,
                                     t->retval, rest);
                         }
@@ -195 +195 @@
 
 void event_register_listener(task_id_t id, bool past_events, async_sess_t *sess,
-    ipc_callid_t iid)
-{
-        int rc = EOK;
+    ipc_call_t *icall)
+{
+        errno_t rc = EOK;
         /*
          * We have lock of tasks structures so that we can guarantee
@@ -219 +219 @@
          * while we dump events.
          */
-        async_answer_0(iid, rc);
+        async_answer_0(icall, rc);
         if (past_events) {
                 task_foreach(&dump_walker, t->sess);
@@ -228 +228 @@
         fibril_rwlock_write_unlock(&task_hash_table_lock);
         if (rc != EOK) {
-                async_answer_0(iid, rc);
-        }
-}
-
-void wait_for_task(task_id_t id, int flags, ipc_callid_t callid,
+                async_answer_0(icall, rc);
+        }
+}
+
+void wait_for_task(task_id_t id, int flags, ipc_call_t *icall,
      task_id_t waiter_id)
 {
@@ -244 +244 @@
         if (t == NULL) {
                 /* No such task exists. */
-                async_answer_0(callid, ENOENT);
+                async_answer_0(icall, ENOENT);
                 return;
         }
@@ -250 +250 @@
         if (t->exit != TASK_EXIT_RUNNING) {
                 //TODO are flags BOTH processed correctly here?
-                async_answer_3(callid, EOK, t->exit, t->retval, 0);
+                async_answer_3(icall, EOK, t->exit, t->retval, 0);
                 return;
         }
@@ -267 +267 @@
         }
 
-        int rc = EOK;
+        errno_t rc = EOK;
         if (pr == NULL) {
                 pr = malloc(sizeof(pending_wait_t));
@@ -279 +279 @@
                 pr->waiter_id = waiter_id;
                 pr->flags = flags;
-                pr->callid = callid;
+                pr->icall = icall;
 
                 list_append(&pr->link, &pending_waits);
@@ -288 +288 @@
                  * fibril).
                  */
-                rc = EEXISTS;
+                rc = EEXIST;
         } else {
                 /*
@@ -294 +294 @@
                  */
                 pr->flags &= ~TASK_WAIT_BOTH; // TODO maybe new flags should be set?
-                pr->callid = callid;
+                pr->icall = icall;
         }
 
@@ -300 +300 @@
         fibril_rwlock_write_unlock(&pending_wait_lock);
         // TODO why IPC_CALLID_NOTIFICATION? explain!
-        if (rc != EOK && !(callid & IPC_CALLID_NOTIFICATION)) {
-                async_answer_0(callid, rc);
-        }
-}
-
-
-int task_set_retval(task_id_t sender, int retval, bool wait_for_exit)
-{
-        int rc = EOK;
+        if (rc != EOK && !(icall->flags & IPC_CALL_NOTIF)) {
+                async_answer_0(icall, rc);
+        }
+}
+
+
+errno_t task_set_retval(task_id_t sender, int retval, bool wait_for_exit)
+{
+        errno_t rc = EOK;
         
         fibril_rwlock_write_lock(&task_hash_table_lock);