Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • kernel/generic/src/proc/task.c

    r5bcf1f9 r1e9f8ab  
    342342sysarg_t sys_task_set_name(const char *uspace_name, size_t name_len)
    343343{
     344        int rc;
    344345        char namebuf[TASK_NAME_BUFLEN];
    345346       
    346347        /* Cap length of name and copy it from userspace. */
     348       
    347349        if (name_len > TASK_NAME_BUFLEN - 1)
    348350                name_len = TASK_NAME_BUFLEN - 1;
    349351       
    350         int rc = copy_from_uspace(namebuf, uspace_name, name_len);
     352        rc = copy_from_uspace(namebuf, uspace_name, name_len);
    351353        if (rc != 0)
    352354                return (sysarg_t) rc;
    353355       
    354356        namebuf[name_len] = '\0';
    355        
    356         /*
    357          * As the task name is referenced also from the
    358          * threads, lock the threads' lock for the course
    359          * of the update.
    360          */
    361        
    362         irq_spinlock_lock(&tasks_lock, true);
    363         irq_spinlock_lock(&TASK->lock, false);
    364         irq_spinlock_lock(&threads_lock, false);
    365        
    366         /* Set task name */
    367357        str_cpy(TASK->name, TASK_NAME_BUFLEN, namebuf);
    368358       
    369         irq_spinlock_unlock(&threads_lock, false);
    370         irq_spinlock_unlock(&TASK->lock, false);
    371         irq_spinlock_unlock(&tasks_lock, true);
    372        
    373359        return EOK;
    374360}
     
    384370{
    385371        task_id_t taskid;
    386         int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(taskid));
     372        int rc;
     373
     374        rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(taskid));
    387375        if (rc != 0)
    388376                return (sysarg_t) rc;
    389        
     377
    390378        return (sysarg_t) task_kill(taskid);
    391379}
     
    461449static void task_kill_internal(task_t *task)
    462450{
     451        link_t *cur;
     452       
     453        /*
     454         * Interrupt all threads.
     455         */
    463456        irq_spinlock_lock(&task->lock, false);
    464         irq_spinlock_lock(&threads_lock, false);
    465        
    466         /*
    467          * Interrupt all threads.
    468          */
    469        
    470         link_t *cur;
    471457        for (cur = task->th_head.next; cur != &task->th_head; cur = cur->next) {
    472458                thread_t *thread = list_get_instance(cur, thread_t, th_link);
     
    485471        }
    486472       
    487         irq_spinlock_unlock(&threads_lock, false);
    488473        irq_spinlock_unlock(&task->lock, false);
    489474}
     
    515500        irq_spinlock_unlock(&tasks_lock, true);
    516501       
    517         return EOK;
    518 }
    519 
    520 /** Kill the currently running task.
    521  *
    522  * @param notify Send out fault notifications.
    523  *
    524  * @return Zero on success or an error code from errno.h.
    525  *
    526  */
    527 void task_kill_self(bool notify)
    528 {
    529         /*
    530          * User space can subscribe for FAULT events to take action
    531          * whenever a task faults (to take a dump, run a debugger, etc.).
    532          * The notification is always available, but unless udebug is enabled,
    533          * that's all you get.
    534         */
    535         if (notify) {
    536                 if (event_is_subscribed(EVENT_FAULT)) {
    537                         /* Notify the subscriber that a fault occurred. */
    538                         event_notify_3(EVENT_FAULT, LOWER32(TASK->taskid),
    539                             UPPER32(TASK->taskid), (sysarg_t) THREAD);
    540                
    541 #ifdef CONFIG_UDEBUG
    542                         /* Wait for a debugging session. */
    543                         udebug_thread_fault();
    544 #endif
    545                 }
    546         }
    547        
    548         irq_spinlock_lock(&tasks_lock, true);
    549         task_kill_internal(TASK);
    550         irq_spinlock_unlock(&tasks_lock, true);
    551        
    552         thread_exit();
    553 }
    554 
    555 /** Process syscall to terminate the current task.
    556  *
    557  * @param notify Send out fault notifications.
    558  *
    559  */
    560 sysarg_t sys_task_exit(sysarg_t notify)
    561 {
    562         task_kill_self(notify);
    563        
    564         /* Unreachable */
    565502        return EOK;
    566503}
Note: See TracChangeset for help on using the changeset viewer.