Subversion Repositories HelenOS

Rev

Rev 2292 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2292 Rev 2307
Line 92... Line 92...
92
 * exist as long as the threads_lock is held.
92
 * exist as long as the threads_lock is held.
93
 */
93
 */
94
btree_t threads_btree;     
94
btree_t threads_btree;     
95
 
95
 
96
SPINLOCK_INITIALIZE(tidlock);
96
SPINLOCK_INITIALIZE(tidlock);
97
uint32_t last_tid = 0;
97
thread_id_t last_tid = 0;
98
 
98
 
99
static slab_cache_t *thread_slab;
99
static slab_cache_t *thread_slab;
100
#ifdef ARCH_HAS_FPU
100
#ifdef ARCH_HAS_FPU
101
slab_cache_t *fpu_context_slab;
101
slab_cache_t *fpu_context_slab;
102
#endif
102
#endif
Line 236... Line 236...
236
 
236
 
237
    i = (t->priority < RQ_COUNT - 1) ? ++t->priority : t->priority;
237
    i = (t->priority < RQ_COUNT - 1) ? ++t->priority : t->priority;
238
   
238
   
239
    cpu = CPU;
239
    cpu = CPU;
240
    if (t->flags & THREAD_FLAG_WIRED) {
240
    if (t->flags & THREAD_FLAG_WIRED) {
-
 
241
        ASSERT(t->cpu != NULL);
241
        cpu = t->cpu;
242
        cpu = t->cpu;
242
    }
243
    }
243
    t->state = Ready;
244
    t->state = Ready;
244
    spinlock_unlock(&t->lock);
245
    spinlock_unlock(&t->lock);
245
   
246
   
Line 494... Line 495...
494
void thread_detach(thread_t *t)
495
void thread_detach(thread_t *t)
495
{
496
{
496
    ipl_t ipl;
497
    ipl_t ipl;
497
 
498
 
498
    /*
499
    /*
499
     * Since the thread is expected to not be already detached,
500
     * Since the thread is expected not to be already detached,
500
     * pointer to it must be still valid.
501
     * pointer to it must be still valid.
501
     */
502
     */
502
    ipl = interrupts_disable();
503
    ipl = interrupts_disable();
503
    spinlock_lock(&t->lock);
504
    spinlock_lock(&t->lock);
504
    ASSERT(!t->detached);
505
    ASSERT(!t->detached);
Line 578... Line 579...
578
           
579
           
579
            uint64_t cycles;
580
            uint64_t cycles;
580
            char suffix;
581
            char suffix;
581
            order(t->cycles, &cycles, &suffix);
582
            order(t->cycles, &cycles, &suffix);
582
           
583
           
583
            printf("%-6zd %-10s %#10zx %-8s %#10zx %-3ld %#10zx "
584
            printf("%-6llu %-10s %#10zx %-8s %#10zx %-3ld %#10zx "
584
                "%#10zx %9llu%c ", t->tid, t->name, t,
585
                "%#10zx %9llu%c ", t->tid, t->name, t,
585
                thread_states[t->state], t->task, t->task->context,
586
                thread_states[t->state], t->task, t->task->context,
586
                t->thread_code, t->kstack, cycles, suffix);
587
                t->thread_code, t->kstack, cycles, suffix);
587
           
588
           
588
            if (t->cpu)
589
            if (t->cpu)
Line 634... Line 635...
634
}
635
}
635
 
636
 
636
/** Process syscall to create new thread.
637
/** Process syscall to create new thread.
637
 *
638
 *
638
 */
639
 */
639
unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name)
640
unative_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name, thread_id_t *uspace_thread_id)
640
{
641
{
641
    thread_t *t;
642
    thread_t *t;
642
    char namebuf[THREAD_NAME_BUFLEN];
643
    char namebuf[THREAD_NAME_BUFLEN];
643
    uspace_arg_t *kernel_uarg;
644
    uspace_arg_t *kernel_uarg;
644
    uint32_t tid;
-
 
645
    int rc;
645
    int rc;
646
 
646
 
647
    rc = copy_from_uspace(namebuf, uspace_name, THREAD_NAME_BUFLEN);
647
    rc = copy_from_uspace(namebuf, uspace_name, THREAD_NAME_BUFLEN);
648
    if (rc != 0)
648
    if (rc != 0)
649
        return (unative_t) rc;
649
        return (unative_t) rc;
Line 656... Line 656...
656
    }
656
    }
657
 
657
 
658
    t = thread_create(uinit, kernel_uarg, TASK, THREAD_FLAG_USPACE, namebuf,
658
    t = thread_create(uinit, kernel_uarg, TASK, THREAD_FLAG_USPACE, namebuf,
659
        false);
659
        false);
660
    if (t) {
660
    if (t) {
661
        tid = t->tid;
-
 
662
        thread_ready(t);
661
        thread_ready(t);
-
 
662
        if (uspace_thread_id != NULL)
-
 
663
            return (unative_t) copy_to_uspace(uspace_thread_id, &t->tid,
663
        return (unative_t) tid;
664
                sizeof(t->tid));
-
 
665
        else
-
 
666
            return 0;
664
    } else {
667
    } else
665
        free(kernel_uarg);
668
        free(kernel_uarg);
666
    }
-
 
667
 
669
 
668
    return (unative_t) ENOMEM;
670
    return (unative_t) ENOMEM;
669
}
671
}
670
 
672
 
671
/** Process syscall to terminate thread.
673
/** Process syscall to terminate thread.
Line 676... Line 678...
676
    thread_exit();
678
    thread_exit();
677
    /* Unreachable */
679
    /* Unreachable */
678
    return 0;
680
    return 0;
679
}
681
}
680
 
682
 
-
 
683
/** Syscall for getting TID.
-
 
684
 *
-
 
685
 * @param uspace_thread_id Userspace address of 8-byte buffer where to store
-
 
686
 * current thread ID.
681
/** @}
687
 *
-
 
688
 * @return 0 on success or an error code from @ref errno.h.
682
 */
689
 */
-
 
690
unative_t sys_thread_get_id(thread_id_t *uspace_thread_id)
-
 
691
{
-
 
692
    /*
-
 
693
     * No need to acquire lock on THREAD because tid
-
 
694
     * remains constant for the lifespan of the thread.
-
 
695
     */
-
 
696
    return (unative_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
-
 
697
        sizeof(THREAD->tid));
-
 
698
}
683
 
699
 
-
 
700
/** @}
-
 
701
 */