Changeset 2443ad8 in mainline for uspace/lib/c

Timestamp:

2019-10-02T09:27:57Z (6 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

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

Children:

9dcf472

Parents:

6fa3a03

git-author:

Jiri Svoboda <jiri@…> (2019-10-01 17:23:52)

git-committer:

Jiri Svoboda <jiri@…> (2019-10-02 09:27:57)

Message:

Let trace not use the loader API directly

This fixes traced binaries crashing due to missing working directory
in PCB. It should also prevent similar problems in the future.

Location:

uspace/lib/c

Files:

• generic/loader.c (modified) (1 diff)
• generic/task.c (modified) (7 diffs)
• include/loader/loader.h (modified) (1 diff)
• include/task.h (modified) (2 diffs)

uspace/lib/c/generic/loader.c

@@ -345 +345 @@
 }
 
+/** Instruct loader to execute the program and do not wait for reply.
+ *
+ * This function does not block even if the loaded task is stopped
+ * for debugging.
+ *
+ * After using this function, no further operations can be performed
+ * on the loader structure and it is deallocated.
+ *
+ * @param ldr Loader connection structure.
+ *
+ * @return Zero on success or an error code.
+ *
+ */
+void loader_run_nowait(loader_t *ldr)
+{
+        async_exch_t *exch = async_exchange_begin(ldr->sess);
+        async_msg_0(exch, LOADER_RUN);
+        async_exchange_end(exch);
+
+        async_hangup(ldr->sess);
+        free(ldr);
+}
+
 /** Cancel the loader session.
  *

uspace/lib/c/generic/task.c

@@ -35 +35 @@
  */
 
+#include <async.h>
 #include <task.h>
 #include <loader/loader.h>
@@ -46 +47 @@
 #include <ns.h>
 #include <stdlib.h>
+#include <udebug.h>
 #include <libc.h>
 #include "private/ns.h"
@@ -94 +96 @@
  * This is really just a convenience wrapper over the more complicated
  * loader API. Arguments are passed as a null-terminated array of strings.
+ * A debug session is created optionally.
  *
  * @param id   If not NULL, the ID of the task is stored here on success.
@@ -100 +103 @@
  * @param path Pathname of the binary to execute.
  * @param argv Command-line arguments.
- *
- * @return Zero on success or an error code.
- *
- */
-errno_t task_spawnv(task_id_t *id, task_wait_t *wait, const char *path,
-    const char *const args[])
+ * @param rsess   Place to store pointer to debug session or @c NULL
+ *                not to start a debug session
+ *
+ * @return Zero on success or an error code.
+ *
+ */
+errno_t task_spawnv_debug(task_id_t *id, task_wait_t *wait, const char *path,
+    const char *const args[], async_sess_t **rsess)
 {
         /* Send default files */
@@ -125 +130 @@
         }
 
-        return task_spawnvf(id, wait, path, args, fd_stdin, fd_stdout,
-            fd_stderr);
+        return task_spawnvf_debug(id, wait, path, args, fd_stdin, fd_stdout,
+            fd_stderr, rsess);
 }
 
 /** Create a new task by running an executable from the filesystem.
+ *
+ * This is really just a convenience wrapper over the more complicated
+ * loader API. Arguments are passed as a null-terminated array of strings.
+ *
+ * @param id   If not NULL, the ID of the task is stored here on success.
+ * @param wait If not NULL, setup waiting for task's return value and store
+ *             the information necessary for waiting here on success.
+ * @param path Pathname of the binary to execute.
+ * @param argv Command-line arguments.
+ *
+ * @return Zero on success or an error code.
+ *
+ */
+errno_t task_spawnv(task_id_t *id, task_wait_t *wait, const char *path,
+    const char *const args[])
+{
+        return task_spawnv_debug(id, wait, path, args, NULL);
+}
+
+/** Create a new task by loading an executable from the filesystem.
  *
  * This is really just a convenience wrapper over the more complicated
  * loader API. Arguments are passed as a null-terminated array of strings.
  * Files are passed as null-terminated array of pointers to fdi_node_t.
+ * A debug session is created optionally.
  *
  * @param id      If not NULL, the ID of the task is stored here on success.
- * @param wait    If not NULL, setup waiting for task's return value and store
+ * @param wait    If not NULL, setup waiting for task's return value and store.
  * @param path    Pathname of the binary to execute.
- * @param argv    Command-line arguments.
- * @param std_in  File to use as stdin.
- * @param std_out File to use as stdout.
- * @param std_err File to use as stderr.
- *
- * @return Zero on success or an error code.
- *
- */
-errno_t task_spawnvf(task_id_t *id, task_wait_t *wait, const char *path,
-    const char *const args[], int fd_stdin, int fd_stdout, int fd_stderr)
-{
+ * @param argv    Command-line arguments
+ * @param std_in  File to use as stdin
+ * @param std_out File to use as stdout
+ * @param std_err File to use as stderr
+ * @param rsess   Place to store pointer to debug session or @c NULL
+ *                not to start a debug session
+ *
+ * @return Zero on success or an error code
+ *
+ */
+errno_t task_spawnvf_debug(task_id_t *id, task_wait_t *wait,
+    const char *path, const char *const args[], int fd_stdin, int fd_stdout,
+    int fd_stderr, async_sess_t **rsess)
+{
+        async_sess_t *ksess = NULL;
+
         /* Connect to a program loader. */
         loader_t *ldr = loader_connect();
@@ -217 +248 @@
         }
 
-        /* Run it. */
-        rc = loader_run(ldr);
-        if (rc != EOK)
-                goto error;
+        /* Start a debug session if requested */
+        if (rsess != NULL) {
+                ksess = async_connect_kbox(task_id);
+                if (ksess == NULL) {
+                        /* Most likely debugging support is not compiled in */
+                        rc = ENOTSUP;
+                        goto error;
+                }
+
+                rc = udebug_begin(ksess);
+                if (rc != EOK)
+                        goto error;
+
+                /*
+                 * Run it, not waiting for response. It would never come
+                 * as the loader is stopped.
+                 */
+                loader_run_nowait(ldr);
+        } else {
+                /* Run it. */
+                rc = loader_run(ldr);
+                if (rc != EOK)
+                        goto error;
+        }
 
         /* Success */
         if (id != NULL)
                 *id = task_id;
-
+        if (rsess != NULL)
+                *rsess = ksess;
         return EOK;
 
 error:
+        if (ksess != NULL)
+                async_hangup(ksess);
         if (wait_initialized)
                 task_cancel_wait(wait);
@@ -235 +289 @@
         loader_abort(ldr);
         return rc;
+}
+
+/** Create a new task by running an executable from the filesystem.
+ *
+ * Arguments are passed as a null-terminated array of strings.
+ * Files are passed as null-terminated array of pointers to fdi_node_t.
+ *
+ * @param id      If not NULL, the ID of the task is stored here on success.
+ * @param wait    If not NULL, setup waiting for task's return value and store.
+ * @param path    Pathname of the binary to execute
+ * @param argv    Command-line arguments
+ * @param std_in  File to use as stdin
+ * @param std_out File to use as stdout
+ * @param std_err File to use as stderr
+ *
+ * @return Zero on success or an error code.
+ *
+ */
+errno_t task_spawnvf(task_id_t *id, task_wait_t *wait, const char *path,
+    const char *const args[], int fd_stdin, int fd_stdout, int fd_stderr)
+{
+        return task_spawnvf_debug(id, wait, path, args, fd_stdin, fd_stdout,
+            fd_stderr, NULL);
 }
 

uspace/lib/c/include/loader/loader.h

@@ -53 +53 @@
 extern errno_t loader_load_program(loader_t *);
 extern errno_t loader_run(loader_t *);
+extern void loader_run_nowait(loader_t *);
 extern void loader_abort(loader_t *);
 

uspace/lib/c/include/task.h

@@ -36 +36 @@
 #define _LIBC_TASK_H_
 
+#include <async.h>
 #include <stdint.h>
 #include <stdarg.h>
@@ -56 +57 @@
 extern errno_t task_spawnv(task_id_t *, task_wait_t *, const char *path,
     const char *const []);
+extern errno_t task_spawnv_debug(task_id_t *, task_wait_t *, const char *path,
+    const char *const [], async_sess_t **);
 extern errno_t task_spawnvf(task_id_t *, task_wait_t *, const char *path,
     const char *const [], int, int, int);
+extern errno_t task_spawnvf_debug(task_id_t *, task_wait_t *, const char *path,
+    const char *const [], int, int, int, async_sess_t **);
 extern errno_t task_spawn(task_id_t *, task_wait_t *, const char *path, int,
     va_list ap);