WebSVN – HelenOS – Diff – /branches/tracing/kernel/generic/src/udebug/udebug_ops.c

  * but only if it verifies all conditions.
+ *
  * Specifically, verifies that thread t exists, is a userspace thread,
  * and belongs to the current task (TASK). Verifies, that the thread
  * has (or hasn't) go according to having_go (typically false).
- * It also locks t->udebug.lock, making sure that t->udebug.debug_active is true
+ * It also locks t->udebug.lock, making sure that t->udebug.debug_active
- * - that the thread is in a valid debugging session.
+ * is true - that the thread is in a valid debugging session.
+ *
- * Returns EOK if all went well, or an error code otherwise.
+ * With this verified and the t->udebug.lock mutex held, it is ensured
- * Interrupts must be already disabled when calling this function.
+ * that the thread cannot leave the debugging session, let alone cease
+ * to exist.
+ *
+ * In this function, holding the TASK->udebug.lock mutex prevents the
+ * thread from leaving the debugging session, while relaxing from
+ * the t->lock spinlock to the t->udebug.lock mutex.
+ *
- * Note: This function sports complicated locking.
+ * Returns EOK if all went well, or an error code otherwise.
  */
 static int _thread_op_begin(thread_t *t, bool having_go)
+{
-    int rc;
     task_id_t taskid;
+    ipl_t ipl;
     taskid = TASK->taskid;
+    mutex_lock(&TASK->udebug.lock);
-    /* Must lock threads_lock to ensure continued existence of the thread */
+    /* thread_exists() must be called with threads_lock held */
+    ipl = interrupts_disable();
     spinlock_lock(&threads_lock);
     if (!thread_exists(t)) {
         spinlock_unlock(&threads_lock);
+        interrupts_restore(ipl);
+        mutex_unlock(&TASK->udebug.lock);
         return ENOENT;
+    }
-    spinlock_lock(&t->udebug.lock);
+    /* t->lock is enough to ensure the thread's existence */
     spinlock_lock(&t->lock);
-    /* Now verify that it's the current task */
-    if (t->task != TASK) {
-        /* No such thread belonging to callee */
+    spinlock_unlock(&threads_lock);
-        rc = ENOENT;
-        goto error_exit;
-    }
     /* Verify that 't' is a userspace thread */
     if ((t->flags & THREAD_FLAG_USPACE) == 0) {
         /* It's not, deny its existence */
+        spinlock_unlock(&t->lock);
-        rc = ENOENT;
+        interrupts_restore(ipl);
+        mutex_unlock(&TASK->udebug.lock);
-        goto error_exit;
+        return ENOENT;
+    }
+    /* Verify debugging state */
-    if ((t->udebug.debug_active != true) || (!t->udebug.stop != having_go)) {
+    if (t->udebug.debug_active != true) {
         /* Not in debugging session or undesired GO state */
+        spinlock_unlock(&t->lock);
-        rc = EINVAL;
+        interrupts_restore(ipl);
+        mutex_unlock(&TASK->udebug.lock);
-        goto error_exit;
+        return ENOENT;
+    }
+    /*
-    spinlock_unlock(&threads_lock);
+     * Since the thread has debug_active == true, TASK->udebug.lock
+     * is enough to ensure its existence and that debug_active remains
+     * true.
+     */
     spinlock_unlock(&t->lock);
+    interrupts_restore(ipl);
-    /* Only t->udebug.lock left */
+    /* Only mutex TASK->udebug.lock left */
+    /* Now verify that the thread belongs to the current task */
+    if (t->task != TASK) {
+        /* No such thread belonging this task*/
+        mutex_unlock(&TASK->udebug.lock);
+        return ENOENT;
+    }
+    /*
+     * Now we need to grab the thread's debug lock for synchronization
+     * of the threads stoppability/stop state.
+     */
-    return EOK; /* All went well */
+    mutex_lock(&t->udebug.lock);
+    /* The big task mutex is no longer needed */
+    mutex_unlock(&TASK->udebug.lock);
-    /* Executed when a check on the thread fails */
+    if (!t->udebug.stop != having_go) {
-error_exit:
-    spinlock_unlock(&t->lock);
+        /* Not in debugging session or undesired GO state */
-    spinlock_unlock(&t->udebug.lock);
+        mutex_unlock(&t->udebug.lock);
-    spinlock_unlock(&threads_lock);
+        return EINVAL;
+    }
-    /* No locks left here */
+    /* Only t->udebug.lock left */
-    return rc;  /* Some errors occured */
+    return EOK; /* All went well */
+}
 static void _thread_op_end(thread_t *t)
+{
-    spinlock_unlock(&t->udebug.lock);
+    mutex_unlock(&t->udebug.lock);
+}
 /**
  * \return 0 (ok, but not done yet), 1 (done) or negative error code.
  */
 int udebug_begin(call_t *call)
+{
-    ipl_t ipl;
     int reply;
     thread_t *t;
     link_t *cur;
     /* Set udebug.debug_active on all of the task's userspace threads */
     for (cur = TASK->th_head.next; cur != &TASK->th_head; cur = cur->next) {
         t = list_get_instance(cur, thread_t, th_link);
-        ipl = interrupts_disable();
-        spinlock_lock(&t->udebug.lock);
+        mutex_lock(&t->udebug.lock);
         if ((t->flags & THREAD_FLAG_USPACE) != 0)
             t->udebug.debug_active = true;
-        spinlock_unlock(&t->udebug.lock);
+        mutex_unlock(&t->udebug.lock);
-        interrupts_restore(ipl);
+    }
     mutex_unlock(&TASK->udebug.lock);
     klog_printf("udebug_begin() done (%s)",
+}
 int udebug_go(thread_t *t, call_t *call)
+{
-    ipl_t ipl;
     int rc;
 //  klog_printf("udebug_go()");
-    ipl = interrupts_disable();
     /* On success, this will lock t->udebug.lock */
     rc = _thread_op_begin(t, false);
     if (rc != EOK) {
-        interrupts_restore(ipl);
         return rc;
+    }
     t->udebug.go_call = call;
     t->udebug.stop = false;
      * Neither t's lock nor threads_lock may be held during wakeup
      */
     waitq_wakeup(&t->udebug.go_wq, WAKEUP_FIRST);
     _thread_op_end(t);
-    interrupts_restore(ipl);
     return 0;
+}
 int udebug_stop(thread_t *t, call_t *call)
+{
-    ipl_t ipl;
     int rc;
     klog_printf("udebug_stop()");
     mutex_lock(&TASK->udebug.lock);
-    ipl = interrupts_disable();
     /*
      * On success, this will lock t->udebug.lock. Note that this makes sure
      * the thread is not stopped.
      */
     rc = _thread_op_begin(t, true);
     if (rc != EOK) {
-        interrupts_restore(ipl);
         return rc;
+    }
     /* Take GO away from the thread */
     t->udebug.stop = true;
     if (!t->udebug.stoppable) {
         /* Answer will be sent when the thread becomes stoppable */
         _thread_op_end(t);
-        interrupts_restore(ipl);
         return 0;
+    }
     /*
      * Answer GO call
     klog_printf("udebug_stop/ipc_answer");
     THREAD->udebug.cur_event = UDEBUG_EVENT_STOP;
     _thread_op_end(t);
-    interrupts_restore(ipl);
     ipc_answer(&TASK->answerbox, call);
     mutex_unlock(&TASK->udebug.lock);
     klog_printf("udebog_stop/done");
     /* Copy down the thread IDs */
     max_ids = buf_size / sizeof(unative_t);
     copied_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);
+}
 int udebug_args_read(thread_t *t, void **buffer)
+{
     int rc;
-    ipl_t ipl;
     unative_t *arg_buffer;
-    klog_printf("udebug_args_read()");
+//  klog_printf("udebug_args_read()");
     /* Prepare a buffer to hold the arguments */
     arg_buffer = malloc(6 * sizeof(unative_t), 0);
-    ipl = interrupts_disable();
     /* On success, this will lock t->udebug.lock */
     rc = _thread_op_begin(t, false);
     if (rc != EOK) {
-        interrupts_restore(ipl);
         return rc;
+    }
     /* Additionally we need to verify that we are inside a syscall */
     if (t->udebug.cur_event != UDEBUG_EVENT_SYSCALL_B &&
         t->udebug.cur_event != UDEBUG_EVENT_SYSCALL_E) {
         _thread_op_end(t);
-        interrupts_restore(ipl);
         return EINVAL;
+    }
     /* Copy to a local buffer before releasing the lock */
     memcpy(arg_buffer, t->udebug.syscall_args, 6 * sizeof(unative_t));
     _thread_op_end(t);
-    interrupts_restore(ipl);
     *buffer = arg_buffer;
     return 0;
+}
 int udebug_regs_read(thread_t *t, void *buffer)
+{
     istate_t *state;
     int rc;
-    ipl_t ipl;
-    klog_printf("udebug_regs_read()");
+//  klog_printf("udebug_regs_read()");
-    ipl = interrupts_disable();
     /* On success, this will lock t->udebug.lock */
     rc = _thread_op_begin(t, false);
     if (rc != EOK) {
-        interrupts_restore(ipl);
         return rc;
+    }
     state = t->udebug.uspace_state;
     if (state == NULL) {
         _thread_op_end(t);
-        interrupts_restore(ipl);
         klog_printf("udebug_regs_read() - istate not available");
         return EBUSY;
+    }
     /* Copy to the allocated buffer */
     memcpy(buffer, state, sizeof(istate_t));
     _thread_op_end(t);
-    interrupts_restore(ipl);
     return 0;
+}
 int udebug_regs_write(thread_t *t, void *buffer)
+{
     int rc;
     istate_t *state;
-    ipl_t ipl;
     klog_printf("udebug_regs_write()");
     /* Try to change the thread's uspace_state */
-    ipl = interrupts_disable();
     /* On success, this will lock t->udebug.lock */
     rc = _thread_op_begin(t, false);
     if (rc != EOK) {
         klog_printf("error locking thread");
-        interrupts_restore(ipl);
         return rc;
+    }
     state = t->udebug.uspace_state;
     if (state == NULL) {
         _thread_op_end(t);
-        interrupts_restore(ipl);
         klog_printf("udebug_regs_write() - istate not available");
         return EBUSY;
+    }
     memcpy(t->udebug.uspace_state, buffer, sizeof(istate_t));
     _thread_op_end(t);
-    interrupts_restore(ipl);
     return 0;
+}

Subversion Repositories HelenOS

(root)/branches/tracing/kernel/generic/src/udebug/udebug_ops.c – Rev 3018 → 3026