Changeset 68a552f in mainline for uspace/lib/c

Timestamp:

2021-02-22T19:52:08Z (4 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

26853ebc

Parents:

2ab8ab3

Message:

Efficient way of rendering to the console via shared buffer

Makes congfx reasonably fast

Location:

uspace/lib/c

Files:

• generic/io/con_srv.c (modified) (4 diffs)
• generic/io/console.c (modified) (3 diffs)
• include/io/con_srv.h (modified) (3 diffs)
• include/io/console.h (modified) (3 diffs)
• include/ipc/console.h (modified) (2 diffs)

uspace/lib/c/generic/io/con_srv.c

@@ -1 +1 @@
 /*
- * Copyright (c) 2012 Jiri Svoboda
+ * Copyright (c) 2021 Jiri Svoboda
  * All rights reserved.
  *
@@ -34 +34 @@
  * @brief Console protocol server stub
  */
+#include <as.h>
 #include <errno.h>
 #include <io/cons_event.h>
@@ -307 +308 @@
 }
 
+/** Create shared buffer for efficient rendering */
+static void con_map_srv(con_srv_t *srv, ipc_call_t *icall)
+{
+        errno_t rc;
+        charfield_t *buf;
+        sysarg_t cols, rows;
+        ipc_call_t call;
+        size_t size;
+
+        if (srv->srvs->ops->map == NULL || srv->srvs->ops->unmap == NULL) {
+                async_answer_0(icall, ENOTSUP);
+                return;
+        }
+
+        cols = ipc_get_arg1(icall);
+        rows = ipc_get_arg2(icall);
+
+        if (!async_share_in_receive(&call, &size)) {
+                async_answer_0(icall, EINVAL);
+                return;
+        }
+
+        /* Check size */
+        if (size != PAGES2SIZE(SIZE2PAGES(cols * rows * sizeof(charfield_t)))) {
+                async_answer_0(&call, EINVAL);
+                async_answer_0(icall, EINVAL);
+                return;
+        }
+
+        rc = srv->srvs->ops->map(srv, cols, rows, &buf);
+        if (rc != EOK) {
+                async_answer_0(&call, rc);
+                async_answer_0(icall, rc);
+                return;
+        }
+
+        rc = async_share_in_finalize(&call, buf, AS_AREA_READ |
+            AS_AREA_WRITE | AS_AREA_CACHEABLE);
+        if (rc != EOK) {
+                srv->srvs->ops->unmap(srv);
+                async_answer_0(icall, EIO);
+                return;
+        }
+
+        async_answer_0(icall, EOK);
+}
+
+/** Delete shared buffer */
+static void con_unmap_srv(con_srv_t *srv, ipc_call_t *icall)
+{
+        if (srv->srvs->ops->unmap == NULL) {
+                async_answer_0(icall, ENOTSUP);
+                return;
+        }
+
+        srv->srvs->ops->unmap(srv);
+        async_answer_0(icall, EOK);
+}
+
+/** Update console area from shared buffer */
+static void con_update_srv(con_srv_t *srv, ipc_call_t *icall)
+{
+        sysarg_t c0, r0, c1, r1;
+
+        c0 = ipc_get_arg1(icall);
+        r0 = ipc_get_arg2(icall);
+        c1 = ipc_get_arg3(icall);
+        r1 = ipc_get_arg4(icall);
+
+        if (srv->srvs->ops->update == NULL) {
+                async_answer_0(icall, ENOTSUP);
+                return;
+        }
+
+        srv->srvs->ops->update(srv, c0, r0, c1, r1);
+        async_answer_0(icall, EOK);
+}
+
 static con_srv_t *con_srv_create(con_srvs_t *srvs)
 {
@@ -412 +491 @@
                         con_get_event_srv(srv, &call);
                         break;
+                case CONSOLE_MAP:
+                        con_map_srv(srv, &call);
+                        break;
+                case CONSOLE_UNMAP:
+                        con_unmap_srv(srv, &call);
+                        break;
+                case CONSOLE_UPDATE:
+                        con_update_srv(srv, &call);
+                        break;
                 default:
                         async_answer_0(&call, ENOTSUP);

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

@@ -1 +1 @@
 /*
+ * Copyright (c) 2021 Jiri Svoboda
  * Copyright (c) 2006 Josef Cejka
  * Copyright (c) 2006 Jakub Vana
- * Copyright (c) 2008 Jiri Svoboda
  * All rights reserved.
  *
@@ -35 +35 @@
  */
 
+#include <as.h>
 #include <libc.h>
 #include <async.h>
@@ -264 +265 @@
 }
 
+/** Create a shared buffer for fast rendering to the console.
+ *
+ * @param ctrl Console
+ * @param cols Number of columns
+ * @param rows Number of rows
+ * @param rbuf Place to store pointer to the shared buffer
+ * @return EOK on success or an error code
+ */
+errno_t console_map(console_ctrl_t *ctrl, sysarg_t cols, sysarg_t rows,
+    charfield_t **rbuf)
+{
+        async_exch_t *exch = NULL;
+        void *buf;
+        aid_t req;
+        ipc_call_t answer;
+        size_t asize;
+        errno_t rc;
+
+        exch = async_exchange_begin(ctrl->output_sess);
+        req = async_send_2(exch, CONSOLE_MAP, cols, rows, &answer);
+        if (rc != EOK)
+                goto error;
+
+        asize = PAGES2SIZE(SIZE2PAGES(cols * rows * sizeof(charfield_t)));
+
+        rc = async_share_in_start_0_0(exch, asize, &buf);
+        if (rc != EOK) {
+                async_forget(req);
+                goto error;
+        }
+
+        async_exchange_end(exch);
+        exch = NULL;
+
+        async_wait_for(req, &rc);
+        if (rc != EOK)
+                goto error;
+
+        *rbuf = (charfield_t *)buf;
+        return EOK;
+error:
+        if (exch != NULL)
+                async_exchange_end(exch);
+        return rc;
+}
+
+/** Unmap console shared buffer.
+ *
+ * @param ctrl Console
+ * @param buf Buffer
+ */
+void console_unmap(console_ctrl_t *ctrl, charfield_t *buf)
+{
+        as_area_destroy(buf);
+}
+
+/** Update console rectangle from shared buffer.
+ *
+ * @param ctrl Console
+ * @param c0 Column coordinate of top-left corner (inclusive)
+ * @param r0 Row coordinate of top-left corner (inclusive)
+ * @param c1 Column coordinate of bottom-right corner (exclusive)
+ * @param r1 Row coordinate of bottom-right corner (exclusive)
+ *
+ * @return EOK on sucess or an error code
+ */
+errno_t console_update(console_ctrl_t *ctrl, sysarg_t c0, sysarg_t r0,
+    sysarg_t c1, sysarg_t r1)
+{
+        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
+        errno_t rc = async_req_4_0(exch, CONSOLE_UPDATE, c0, r0, c1, r1);
+        async_exchange_end(exch);
+
+        return rc;
+}
+
 /** @}
  */

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

@@ -1 +1 @@
 /*
- * Copyright (c) 2012 Jiri Svoboda
+ * Copyright (c) 2021 Jiri Svoboda
  * All rights reserved.
  *
@@ -39 +39 @@
 #include <async.h>
 #include <fibril_synch.h>
+#include <io/charfield.h>
 #include <io/color.h>
 #include <io/concaps.h>
@@ -83 +84 @@
         void (*set_cursor_visibility)(con_srv_t *, bool);
         errno_t (*get_event)(con_srv_t *, cons_event_t *);
+        errno_t (*map)(con_srv_t *, sysarg_t, sysarg_t, charfield_t **);
+        void (*unmap)(con_srv_t *);
+        void (*update)(con_srv_t *, sysarg_t, sysarg_t, sysarg_t, sysarg_t);
 };
 

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

@@ -1 +1 @@
 /*
- * Copyright (c) 2008 Jiri Svoboda
+ * Copyright (c) 2021 Jiri Svoboda
  * All rights reserved.
  *
@@ -37 +37 @@
 
 #include <time.h>
+#include <io/charfield.h>
 #include <io/concaps.h>
 #include <io/kbd_event.h>
@@ -86 +87 @@
 extern bool console_get_event_timeout(console_ctrl_t *, cons_event_t *,
     usec_t *);
+extern errno_t console_map(console_ctrl_t *, sysarg_t, sysarg_t,
+    charfield_t **);
+extern void console_unmap(console_ctrl_t *, charfield_t *);
+extern errno_t console_update(console_ctrl_t *, sysarg_t, sysarg_t, sysarg_t,
+    sysarg_t);
 
 #endif

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

@@ -1 +1 @@
 /*
+ * Copyright (c) 2021 Jiri Svoboda
  * Copyright (c) 2006 Josef Cejka
  * All rights reserved.
@@ -48 +49 @@
         CONSOLE_SET_COLOR,
         CONSOLE_SET_RGB_COLOR,
-        CONSOLE_SET_CURSOR_VISIBILITY
+        CONSOLE_SET_CURSOR_VISIBILITY,
+        CONSOLE_MAP,
+        CONSOLE_UNMAP,
+        CONSOLE_UPDATE
 } console_request_t;