Changeset e768aea in mainline

Timestamp:

2018-06-26T17:34:48Z (6 years ago)

Author:

Jiří Zárevúcky <jiri.zarevucky@…>

Branches:

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

Children:

8119363

Parents:

ab6edb6

git-author:

Jiří Zárevúcky <jiri.zarevucky@…> (2018-06-16 18:56:15)

git-committer:

Jiří Zárevúcky <jiri.zarevucky@…> (2018-06-26 17:34:48)

Message:

Simplify async manager.

Location:

uspace/lib/c/generic

Files:

• async/server.c (modified) (6 diffs)
• fibril.c (modified) (1 diff)

uspace/lib/c/generic/async/server.c

@@ -1066 +1066 @@
         assert(call);
 
-        /* Kernel notification */
-        if ((chandle == CAP_NIL) && (call->flags & IPC_CALL_NOTIF)) {
-                queue_notification(call);
+        if (call->flags & IPC_CALL_ANSWERED)
+                return;
+
+        if (chandle == CAP_NIL) {
+                if (call->flags & IPC_CALL_NOTIF) {
+                        /* Kernel notification */
+                        queue_notification(call);
+                }
                 return;
         }
@@ -1096 +1101 @@
 
 /** Fire all timeouts that expired. */
-static void handle_expired_timeouts(void)
-{
+static suseconds_t handle_expired_timeouts(unsigned int *flags)
+{
+        /* Make sure the async_futex is held. */
+        futex_assert_is_locked(&async_futex);
+
         struct timeval tv;
         getuptime(&tv);
 
-        futex_lock(&async_futex);
+        bool fired = false;
 
         link_t *cur = list_first(&timeout_list);
@@ -1108 +1116 @@
                     list_get_instance(cur, awaiter_t, to_event.link);
 
-                if (tv_gt(&waiter->to_event.expires, &tv))
-                        break;
+                if (tv_gt(&waiter->to_event.expires, &tv)) {
+                        if (fired) {
+                                *flags = SYNCH_FLAGS_NON_BLOCKING;
+                                return 0;
+                        }
+                        *flags = 0;
+                        return tv_sub_diff(&waiter->to_event.expires, &tv);
+                }
 
                 list_remove(&waiter->to_event.link);
@@ -1122 +1136 @@
                         waiter->active = true;
                         fibril_add_ready(waiter->fid);
+                        fired = true;
                 }
 
@@ -1127 +1142 @@
         }
 
-        futex_unlock(&async_futex);
+        if (fired) {
+                *flags = SYNCH_FLAGS_NON_BLOCKING;
+                return 0;
+        }
+
+        return SYNCH_NO_TIMEOUT;
 }
 
@@ -1146 +1166 @@
                  */
 
-                suseconds_t timeout;
                 unsigned int flags = SYNCH_FLAGS_NONE;
-                if (!list_empty(&timeout_list)) {
-                        awaiter_t *waiter = list_get_instance(
-                            list_first(&timeout_list), awaiter_t, to_event.link);
-
-                        struct timeval tv;
-                        getuptime(&tv);
-
-                        if (tv_gteq(&tv, &waiter->to_event.expires)) {
-                                futex_unlock(&async_futex);
-                                handle_expired_timeouts();
-                                /*
-                                 * Notice that even if the event(s) already
-                                 * expired (and thus the other fibril was
-                                 * supposed to be running already),
-                                 * we check for incoming IPC.
-                                 *
-                                 * Otherwise, a fibril that continuously
-                                 * creates (almost) expired events could
-                                 * prevent IPC retrieval from the kernel.
-                                 */
-                                timeout = 0;
-                                flags = SYNCH_FLAGS_NON_BLOCKING;
-
-                        } else {
-                                timeout = tv_sub_diff(&waiter->to_event.expires,
-                                    &tv);
-                                futex_unlock(&async_futex);
-                        }
-                } else {
-                        futex_unlock(&async_futex);
-                        timeout = SYNCH_NO_TIMEOUT;
-                }
+                suseconds_t next_timeout = handle_expired_timeouts(&flags);
+                futex_unlock(&async_futex);
 
                 atomic_inc(&threads_in_ipc_wait);
 
                 ipc_call_t call;
-                errno_t rc = ipc_wait_cycle(&call, timeout, flags);
+                errno_t rc = ipc_wait_cycle(&call, next_timeout, flags);
 
                 atomic_dec(&threads_in_ipc_wait);
 
                 assert(rc == EOK);
-
-                if (call.cap_handle == CAP_NIL) {
-                        if ((call.flags &
-                            (IPC_CALL_NOTIF | IPC_CALL_ANSWERED)) == 0) {
-                                /* Neither a notification nor an answer. */
-                                handle_expired_timeouts();
-                                continue;
-                        }
-                }
-
-                if (call.flags & IPC_CALL_ANSWERED)
-                        continue;
-
                 handle_call(call.cap_handle, &call);
         }

uspace/lib/c/generic/fibril.c

@@ -151 +151 @@
         /* Choose a new fibril to run */
         if (list_empty(&ready_list)) {
-                if (stype == FIBRIL_PREEMPT) {
+                if (stype == FIBRIL_PREEMPT || stype == FIBRIL_FROM_MANAGER) {
                         // FIXME: This means that as long as there is a fibril
                         // that only yields, IPC messages are never retrieved.