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

     thread_t *t;
     link_t *cur;
     klog_printf("udebug_begin()");
-    ipl = interrupts_disable();
+    mutex_lock(&TASK->udebug.lock);
     klog_printf("debugging task %llu", TASK->taskid);
-    spinlock_lock(&TASK->lock);
     if (TASK->udebug.dt_state != UDEBUG_TS_INACTIVE) {
-        spinlock_unlock(&TASK->lock);
+        mutex_unlock(&TASK->udebug.lock);
-        interrupts_restore(ipl);
         klog_printf("udebug_begin(): busy error");
         return EBUSY;
+    }
     /* Set 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->debug_lock);
         if ((t->flags & THREAD_FLAG_USPACE) != 0)
             t->debug_active = true;
         spinlock_unlock(&t->debug_lock);
+        interrupts_restore(ipl);
+    }
-    spinlock_unlock(&TASK->lock);
+    mutex_unlock(&TASK->udebug.lock);
-    interrupts_restore(ipl);
     klog_printf("udebug_begin() done (%s)",
         reply ? "reply" : "stoppability wait");
     return reply;
+}
 int udebug_end(void)
+{
-    ipl_t ipl;
     int rc;
     klog_printf("udebug_end()");
-    ipl = interrupts_disable();
-    spinlock_lock(&TASK->lock);
+    mutex_lock(&TASK->udebug.lock);
-    rc = udebug_task_cleanup(TASK);
     klog_printf("task %llu", TASK->taskid);
-    spinlock_unlock(&TASK->lock);
-    interrupts_restore(ipl);
+    rc = udebug_task_cleanup(TASK);
-    if (rc < 0) return EINVAL;
+    mutex_unlock(&TASK->udebug.lock);
-    return 0;
+    return rc;
+}
 int udebug_set_evmask(udebug_evmask_t mask)
+{
-    ipl_t ipl;
     klog_printf("udebug_set_mask()");
-    ipl = interrupts_disable();
     klog_printf("debugging task %llu", TASK->taskid);
-    spinlock_lock(&TASK->lock);
+    mutex_lock(&TASK->udebug.lock);
     if (TASK->udebug.dt_state != UDEBUG_TS_ACTIVE) {
-        spinlock_unlock(&TASK->lock);
+        mutex_unlock(&TASK->udebug.lock);
-        interrupts_restore(ipl);
         klog_printf("udebug_set_mask(): not active debuging session");
         return EINVAL;
+    }
     TASK->udebug.evmask = mask;
-    spinlock_unlock(&TASK->lock);
+    mutex_unlock(&TASK->udebug.lock);
-    interrupts_restore(ipl);
     return 0;
+}
+{
     ipl_t ipl;
     int rc;
     klog_printf("udebug_stop()");
+    mutex_lock(&TASK->udebug.lock);
     ipl = interrupts_disable();
     /*
      * On success, this will lock t->debug_lock. Note that this makes sure
     IPC_SET_RETVAL(call->data, 0);
     IPC_SET_ARG1(call->data, UDEBUG_EVENT_STOP);
     klog_printf("udebug_stop/ipc_answer");
     THREAD->cur_event = UDEBUG_EVENT_STOP;
     _thread_op_end(t);
+    interrupts_restore(ipl);
-    spinlock_lock(&TASK->lock);
     ipc_answer(&TASK->answerbox, call);
-    spinlock_unlock(&TASK->lock);
+    mutex_unlock(&TASK->udebug.lock);
-    interrupts_restore(ipl);
     klog_printf("udebog_stop/done");
     return 0;
+}
 int udebug_thread_read(void **buffer, size_t buf_size, size_t *n)
     klog_printf("udebug_thread_read()");
     /* Allocate a buffer to hold thread IDs */
     id_buffer = malloc(buf_size, 0);
-    ipl = interrupts_disable();
-    spinlock_lock(&TASK->lock);
+    mutex_lock(&TASK->udebug.lock);
     /* Verify task state */
     if (TASK->udebug.dt_state != UDEBUG_TS_ACTIVE) {
-        spinlock_unlock(&TASK->lock);
+        mutex_unlock(&TASK->udebug.lock);
-        interrupts_restore(ipl);
         return EINVAL;
+    }
+    ipl = interrupts_disable();
+    spinlock_lock(&TASK->lock);
     /* Copy down the thread IDs */
     max_ids = buf_size / sizeof(unative_t);
     copied_ids = 0;
+    }
     spinlock_unlock(&TASK->lock);
     interrupts_restore(ipl);
+    mutex_unlock(&TASK->udebug.lock);
     *buffer = id_buffer;
     *n = copied_ids * sizeof(unative_t);
     return 0;
+}
 int udebug_mem_read(unative_t uspace_addr, size_t n, void **buffer)
+{
     void *data_buffer;
     int rc;
+    /* Verify task state */
-    klog_printf("udebug_mem_read()");
+    mutex_lock(&TASK->udebug.lock);
+    if (TASK->udebug.dt_state != UDEBUG_TS_ACTIVE) {
+        mutex_unlock(&TASK->udebug.lock);
+        return EBUSY;
+    }
     data_buffer = malloc(n, 0);
-    klog_printf("udebug_mem_read: src=%u, size=%u", uspace_addr, n);
+//  klog_printf("udebug_mem_read: src=%u, size=%u", uspace_addr, n);
     /* NOTE: this is not strictly from a syscall... but that shouldn't
      * be a problem */
     rc = copy_from_uspace(data_buffer, (void *)uspace_addr, n);
+    mutex_unlock(&TASK->udebug.lock);
-    if (rc) return rc;
+    if (rc != 0) return rc;
     *buffer = data_buffer;
     return 0;
+}
 int udebug_mem_write(unative_t uspace_addr, void *data, size_t n)
+{
     int rc;
-    udebug_task_state_t dts;
     klog_printf("udebug_mem_write()");
     /* Verify task state */
-    spinlock_lock(&TASK->lock);
+    mutex_lock(&TASK->udebug.lock);
-    dts = TASK->udebug.dt_state;
-    spinlock_unlock(&TASK->lock);
-    if (dts != UDEBUG_TS_ACTIVE)
+    if (TASK->udebug.dt_state != UDEBUG_TS_ACTIVE) {
+        mutex_unlock(&TASK->udebug.lock);
         return EBUSY;
+    }
     klog_printf("dst=%u, size=%u", uspace_addr, n);
     /* NOTE: this is not strictly from a syscall... but that shouldn't
      * be a problem */
 //  rc = copy_to_uspace((void *)uspace_addr, data, n);
 //  if (rc) return rc;
     rc = as_debug_write(uspace_addr, data, n);
+    mutex_unlock(&TASK->udebug.lock);
     return rc;
+}
 /** @}
  */

Subversion Repositories HelenOS

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