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

File:

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

kernel/generic/src/udebug/udebug_ops.c

@@ -209 +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);
+                        mutex_unlock(&t->udebug.lock);
+                        condvar_broadcast(&t->udebug.active_cv);
+                } else {
+                        mutex_unlock(&t->udebug.lock);
+                }
         }
 
@@ -355 +359 @@
  *
  * If the sequence is longer than @a buf_size bytes, only as much hashes
- * as can fit are copied. The number of thread hashes copied is stored
- * in @a n.
+ * 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.
  *
  * The rationale for having @a buf_size is that this function is only
@@ -364 +369 @@
  * @param buffer        The buffer for storing thread hashes.
  * @param buf_size      Buffer size in bytes.
- * @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)
+ * @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)
 {
         thread_t *t;
         link_t *cur;
         unative_t tid;
-        unsigned copied_ids;
+        size_t copied_ids;
+        size_t extra_ids;
         ipl_t ipl;
         unative_t *id_buffer;
@@ -380 +388 @@
 
         /* Allocate a buffer to hold thread IDs */
-        id_buffer = malloc(buf_size, 0);
+        id_buffer = malloc(buf_size + 1, 0);
 
         mutex_lock(&TASK->udebug.lock);
@@ -396 +404 @@
         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);
 
@@ -409 +415 @@
 
                 /* Not interested in kernel threads. */
-                if ((flags & THREAD_FLAG_USPACE) != 0) {
+                if ((flags & THREAD_FLAG_USPACE) == 0)
+                        continue;
+
+                if (copied_ids < max_ids) {
                         /* Using thread struct pointer as identification hash */
                         tid = (unative_t) t;
                         id_buffer[copied_ids++] = tid;
+                } else {
+                        extra_ids++;
                 }
         }
@@ -422 +433 @@
 
         *buffer = id_buffer;
-        *n = copied_ids * sizeof(unative_t);
+        *stored = copied_ids * sizeof(unative_t);
+        *needed = (copied_ids + extra_ids) * sizeof(unative_t);
 
         return 0;