Changes in kernel/generic/src/udebug/udebug_ops.c [3698e44:41df2827] in mainline

File:

• kernel/generic/src/udebug/udebug_ops.c (modified) (10 diffs)

kernel/generic/src/udebug/udebug_ops.c

@@ -46 +46 @@
 #include <errno.h>
 #include <print.h>
-#include <string.h>
 #include <syscall/copy.h>
 #include <ipc/ipc.h>
@@ -210 +209 @@
 
                 mutex_lock(&t->udebug.lock);
-                if ((t->flags & THREAD_FLAG_USPACE) != 0) {
+                if ((t->flags & THREAD_FLAG_USPACE) != 0)
                         t->udebug.active = true;
-                        mutex_unlock(&t->udebug.lock);
-                        condvar_broadcast(&t->udebug.active_cv);
-                } else {
-                        mutex_unlock(&t->udebug.lock);
-                }
+                mutex_unlock(&t->udebug.lock);
         }
 
@@ -360 +355 @@
  *
  * If the sequence is longer than @a buf_size bytes, only as much hashes
- * as can fit are copied. The number of bytes copied is stored in @a stored.
- * The total number of thread bytes that could have been saved had there been
- * enough space is stored in @a needed.
+ * as can fit are copied. The number of thread hashes copied is stored
+ * in @a n.
  *
  * The rationale for having @a buf_size is that this function is only
@@ -370 +364 @@
  * @param buffer        The buffer for storing thread hashes.
  * @param buf_size      Buffer size in bytes.
- * @param stored        The actual number of bytes copied will be stored here.
- * @param needed        Total number of hashes that could have been saved.
- */
-int udebug_thread_read(void **buffer, size_t buf_size, size_t *stored,
-    size_t *needed)
+ * @param n             The actual number of hashes copied will be stored here.
+ */
+int udebug_thread_read(void **buffer, size_t buf_size, size_t *n)
 {
         thread_t *t;
         link_t *cur;
         unative_t tid;
-        size_t copied_ids;
-        size_t extra_ids;
+        unsigned copied_ids;
         ipl_t ipl;
         unative_t *id_buffer;
@@ -389 +380 @@
 
         /* Allocate a buffer to hold thread IDs */
-        id_buffer = malloc(buf_size + 1, 0);
+        id_buffer = malloc(buf_size, 0);
 
         mutex_lock(&TASK->udebug.lock);
@@ -405 +396 @@
         max_ids = buf_size / sizeof(unative_t);
         copied_ids = 0;
-        extra_ids = 0;
 
         /* FIXME: make sure the thread isn't past debug shutdown... */
         for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
+                /* Do not write past end of buffer */
+                if (copied_ids >= max_ids) break;
+
                 t = list_get_instance(cur, thread_t, th_link);
 
@@ -416 +409 @@
 
                 /* Not interested in kernel threads. */
-                if ((flags & THREAD_FLAG_USPACE) == 0)
-                        continue;
-
-                if (copied_ids < max_ids) {
+                if ((flags & THREAD_FLAG_USPACE) != 0) {
                         /* Using thread struct pointer as identification hash */
                         tid = (unative_t) t;
                         id_buffer[copied_ids++] = tid;
-                } else {
-                        extra_ids++;
                 }
         }
@@ -434 +422 @@
 
         *buffer = id_buffer;
-        *stored = copied_ids * sizeof(unative_t);
-        *needed = (copied_ids + extra_ids) * sizeof(unative_t);
-
-        return 0;
-}
-
-/** Read task name.
- *
- * Returns task name as non-terminated string in a newly allocated buffer.
- * Also returns the size of the data.
- *
- * @param data          Place to store pointer to newly allocated block.
- * @param data_size     Place to store size of the data.
- *
- * @returns             EOK.
- */
-int udebug_name_read(char **data, size_t *data_size)
-{
-        size_t name_size;
-
-        name_size = str_size(TASK->name) + 1;
-        *data = malloc(name_size, 0);
-        *data_size = name_size;
-
-        memcpy(*data, TASK->name, name_size);
+        *n = copied_ids * sizeof(unative_t);
 
         return 0;
@@ -473 +437 @@
  * this function will fail with an EINVAL error code.
  *
- * @param t             Thread where call arguments are to be read.
- * @param buffer        Place to store pointer to new buffer.
- * @return              EOK on success, ENOENT if @a t is invalid, EINVAL
- *                      if thread state is not valid for this operation.
+ * @param buffer        The buffer for storing thread hashes.
  */
 int udebug_args_read(thread_t *t, void **buffer)
@@ -508 +469 @@
 }
 
-/** Read the register state of the thread.
- *
- * The contents of the thread's istate structure are copied to a newly
- * allocated buffer and a pointer to it is written to @a buffer. The size of
- * the buffer will be sizeof(istate_t).
- *
- * Currently register state cannot be read if the thread is inside a system
- * call (as opposed to an exception). This is an implementation limit.
- *
- * @param t             Thread whose state is to be read.
- * @param buffer        Place to store pointer to new buffer.
- * @return              EOK on success, ENOENT if @a t is invalid, EINVAL
- *                      if thread is not in valid state, EBUSY if istate
- *                      is not available.
- */
-int udebug_regs_read(thread_t *t, void **buffer)
-{
-        istate_t *state, *state_buf;
-        int rc;
-
-        /* Prepare a buffer to hold the data. */
-        state_buf = malloc(sizeof(istate_t), 0);
-
-        /* On success, this will lock t->udebug.lock */
-        rc = _thread_op_begin(t, false);
-        if (rc != EOK) {
-                return rc;
-        }
-
-        state = t->udebug.uspace_state;
-        if (state == NULL) {
-                _thread_op_end(t);
-                return EBUSY;
-        }
-
-        /* Copy to the allocated buffer */
-        memcpy(state_buf, state, sizeof(istate_t));
-
-        _thread_op_end(t);
-
-        *buffer = (void *) state_buf;
-        return 0;
-}
-
 /** Read the memory of the debugged task.
  *