Changeset 87822ce in mainline for uspace/lib

Timestamp:

2021-03-04T19:14:30Z (5 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

d6c4d40

Parents:

760a392

Message:

Avoid infinite loop when console communication is broken

Need to make sure callers of console_get_event_timeout() can distinguish
between timeout and I/O error. Fix all callers of console_get_event()
and console_get_event_timeout() not to enter infinite loop when console
connection is broken. Also avoid setting of errno variable.

Location:

uspace/lib

Files:

• c/generic/io/console.c (modified) (5 diffs)
• c/include/io/console.h (modified) (1 diff)
• clui/tinput.c (modified) (2 diffs)
• ui/src/ui.c (modified) (3 diffs)

uspace/lib/c/generic/io/console.c

@@ -180 +180 @@
 }
 
-bool console_get_event(console_ctrl_t *ctrl, cons_event_t *event)
+/** Get console event.
+ *
+ * @param ctrl Console
+ * @param event Place to store event
+ * @return EOK on success, EIO on failure
+ */
+errno_t console_get_event(console_ctrl_t *ctrl, cons_event_t *event)
 {
         if (ctrl->input_aid == 0) {
@@ -192 +198 @@
                 async_wait_for(aid, &rc);
 
-                if (rc != EOK) {
-                        errno = rc;
-                        return false;
-                }
+                if (rc != EOK)
+                        return EIO;
 
                 rc = console_ev_decode(&result, event);
-                if (rc != EOK) {
-                        errno = rc;
-                        return false;
-                }
+                if (rc != EOK)
+                        return EIO;
         } else {
                 errno_t retval;
@@ -208 +210 @@
                 ctrl->input_aid = 0;
 
-                if (retval != EOK) {
-                        errno = retval;
-                        return false;
-                }
+                if (retval != EOK)
+                        return EIO;
 
                 errno_t rc = console_ev_decode(&ctrl->input_call, event);
-                if (rc != EOK) {
-                        errno = rc;
-                        return false;
-                }
-        }
-
-        return true;
-}
-
-bool console_get_event_timeout(console_ctrl_t *ctrl, cons_event_t *event,
+                if (rc != EOK)
+                        return EIO;
+        }
+
+        return EOK;
+}
+
+/** Get console event with timeout.
+ *
+ * @param ctrl Console
+ * @param event Place to store event
+ * @param timeout Pointer to timeout. This will be updated to reflect
+ *                the remaining time in case of timeout.
+ * @return EOK on success (event received), ETIMEOUT on time out,
+ *         EIO on I/O error (e.g. lost console connection), ENOMEM
+ *         if out of memory
+ */
+errno_t console_get_event_timeout(console_ctrl_t *ctrl, cons_event_t *event,
     usec_t *timeout)
 {
@@ -239 +247 @@
         errno_t rc = async_wait_timeout(ctrl->input_aid, &retval, *timeout);
         if (rc != EOK) {
+                if (rc == ENOMEM)
+                        return ENOMEM;
                 *timeout = 0;
-                errno = rc;
-                return false;
+                return ETIMEOUT;
         }
 
         ctrl->input_aid = 0;
 
-        if (retval != EOK) {
-                errno = retval;
-                return false;
-        }
+        if (retval != EOK)
+                return EIO;
 
         rc = console_ev_decode(&ctrl->input_call, event);
-        if (rc != EOK) {
-                errno = rc;
-                return false;
-        }
+        if (rc != EOK)
+                return EIO;
 
         /* Update timeout */
@@ -262 +267 @@
         *timeout -= NSEC2USEC(ts_sub_diff(&t1, &t0));
 
-        return true;
+        return EOK;
 }
 

uspace/lib/c/include/io/console.h

@@ -84 +84 @@
 extern void console_cursor_visibility(console_ctrl_t *, bool);
 extern errno_t console_get_color_cap(console_ctrl_t *, sysarg_t *);
-extern bool console_get_event(console_ctrl_t *, cons_event_t *);
-extern bool console_get_event_timeout(console_ctrl_t *, cons_event_t *,
+extern errno_t console_get_event(console_ctrl_t *, cons_event_t *);
+extern errno_t console_get_event_timeout(console_ctrl_t *, cons_event_t *,
     usec_t *);
 extern errno_t console_map(console_ctrl_t *, sysarg_t, sysarg_t,

uspace/lib/clui/tinput.c

@@ -874 +874 @@
 errno_t tinput_read_i(tinput_t *ti, const char *istr, char **dstr)
 {
+        errno_t rc;
+
         console_flush(ti->console);
         if (console_get_size(ti->console, &ti->con_cols, &ti->con_rows) != EOK)
@@ -891 +893 @@
 
                 cons_event_t ev;
-                if (!console_get_event(ti->console, &ev))
+                rc = console_get_event(ti->console, &ev);
+                if (rc != EOK)
                         return EIO;
 

uspace/lib/ui/src/ui.c

@@ -39 +39 @@
 #include <fibril.h>
 #include <io/console.h>
+#include <stdbool.h>
 #include <stdlib.h>
 #include <str.h>
@@ -220 +221 @@
 void ui_run(ui_t *ui)
 {
-        bool have_event;
         cons_event_t event;
         usec_t timeout;
+        errno_t rc;
 
         /* Only return command prompt if we are running in a separate window */
@@ -231 +232 @@
                 if (ui->console != NULL) {
                         timeout = 100000;
-                        have_event = console_get_event_timeout(ui->console,
+                        rc = console_get_event_timeout(ui->console,
                             &event, &timeout);
-                        if (have_event)
+
+                        /* Do we actually have an event? */
+                        if (rc == EOK) {
                                 ui_cons_event_process(ui, &event);
+                        } else if (rc != ETIMEOUT) {
+                                /* Error, quit */
+                                break;
+                        }
                 } else {
                         fibril_usleep(100000);