Changeset c4c5de5 in mainline for libc/generic


Ignore:
Timestamp:
2006-03-24T14:29:19Z (20 years ago)
Author:
Ondrej Palkovsky <ondrap@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
8fe1cdb
Parents:
520492a
Message:

Completed support for TLS in GCC (modifier thread) for ia32,amd64,ia64 and mips.

Location:
libc/generic
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • libc/generic/libc.c

    r520492a rc4c5de5  
    3737}
    3838
     39#include <stdio.h>
    3940void __main(void) {
    40         __tls_set(__make_tls());
     41        tcb_t *tcb;
     42       
     43        tcb = __make_tls();
     44        __tcb_set(tcb);
     45        psthread_setup(tcb);
    4146}
    4247
    4348void __exit(void) {
    44         free(__tls_get());
    45        
     49        tcb_t *tcb;
     50
     51        tcb = __tcb_get();
     52        psthread_teardown(tcb->pst_data);
     53        __free_tls(tcb);
    4654        _exit(0);
    4755}

  • libc/generic/psthread.c

    r520492a rc4c5de5  
    4040static void psthread_main(void);
    4141
     42/** Setup PSthread information into TCB structure */
     43psthread_data_t * psthread_setup(tcb_t *tcb)
     44{
     45        psthread_data_t *pt;
     46
     47        pt = malloc(sizeof(*pt));
     48        if (!pt) {
     49                return NULL;
     50        }
     51
     52        tcb->pst_data = pt;
     53        pt->tcb = tcb;
     54
     55        return pt;
     56}
     57
     58void psthread_teardown(psthread_data_t *pt)
     59{
     60        free(pt);
     61}
     62
    4263/** Function to preempt to other pseudo thread without adding
    4364 * currently running pseudo thread to ready_list.
    … …  
    6081void psthread_main(void)
    6182{
    62         psthread_data_t *pt = __tls_get();
     83        psthread_data_t *pt = __tcb_get()->pst_data;
     84
    6385        pt->retval = pt->func(pt->arg);
    6486
    … …  
    81103                return 0;
    82104
    83         pt = __tls_get();
     105        pt = __tcb_get()->pst_data;
    84106        if (!context_save(&pt->ctx))
    85107                return 1;
    … …  
    104126
    105127        /* Handle psthrid = Kernel address -> it is wait for call */
    106 
    107128        pt = (psthread_data_t *) psthrid;
    108129
    109130        if (!pt->finished) {
    110                 mypt = __tls_get();
     131                mypt = __tcb_get()->pst_data;
    111132                if (context_save(&((psthread_data_t *) mypt)->ctx)) {
    112133                        pt->waiter = (psthread_data_t *) mypt;
    … …  
    117138
    118139        free(pt->stack);
    119         __free_tls((psthread_data_t *) pt);
     140        __free_tls(pt->tcb);
     141        psthread_teardown((void *)pt);
    120142
    121143        return retval;
    … …  
    133155{
    134156        psthread_data_t *pt;
     157        tcb_t *tcb;
    135158
    136         pt = __make_tls();
     159        tcb = __make_tls();
     160        if (!tcb)
     161                return 0;
     162
     163        pt = psthread_setup(tcb);
     164        if (!pt) {
     165                __free_tls(tcb);
     166                return 0;
     167        }
    137168        pt->stack = (char *) malloc(getpagesize());
    138169
    139170        if (!pt->stack) {
     171                __free_tls(tcb);
     172                psthread_teardown(pt);
    140173                return 0;
    141174        }
    … …  
    147180
    148181        context_save(&pt->ctx);
    149         context_set(&pt->ctx, FADDR(psthread_main), pt->stack, getpagesize(), pt);
     182        context_set(&pt->ctx, FADDR(psthread_main), pt->stack, getpagesize(),
     183                    tcb);
    150184
    151185        list_append(&pt->link, &ready_list);

  • libc/generic/thread.c

    r520492a rc4c5de5  
    3333#include <kernel/proc/uarg.h>
    3434#include <psthread.h>
     35#include <string.h>
    3536
    3637#include <stdio.h>
    37 void * __make_tls(void)
     38
     39extern char _tdata_start;
     40extern char _tdata_end;
     41extern char _tbss_start;
     42extern char _tbss_end;
     43
     44/** Create Thread Local storage area, return pointer to TCB(ThreadControlBlock)
     45 *
     46 * !! The code requires, that sections .tdata and .tbss are adjacent.
     47 *    It may be changed in the future.
     48 */
     49tcb_t * __make_tls(void)
    3850{
    39         psthread_data_t *pt;
     51        void *data;
     52        tcb_t *tcb;
     53        size_t tls_size = &_tbss_end - &_tdata_start;
     54       
     55        tcb = __alloc_tls(&data, tls_size);
     56       
     57        memcpy(data, &_tdata_start, &_tdata_end - &_tdata_start);
     58        memset(data + (&_tbss_start-&_tdata_start), &_tbss_end-&_tbss_start, 0);
    4059
    41         pt = malloc(sizeof(psthread_data_t));
    42         pt->self = pt;
    43 
    44         return pt;
     60        return tcb;
    4561}
    4662
    47 void __free_tls(void *tls)
     63void __free_tls(tcb_t *tcb)
    4864{
    49         free(tls);
     65        size_t tls_size = &_tbss_end - &_tdata_start;
     66        __free_tls_arch(tcb, tls_size);
    5067}
    5168
    … …  
    6178void __thread_main(uspace_arg_t *uarg)
    6279{
     80        tcb_t *tcb;
    6381        /* This should initialize the area according to TLS specicification */
    64         __tls_set(__make_tls());
     82        tcb = __make_tls();
     83        __tcb_set(tcb);
     84        psthread_setup(tcb);
    6585
    6686        uarg->uspace_thread_function(uarg->uspace_thread_arg);
    … …  
    6888        free(uarg);
    6989
    70         __free_tls(__tls_get());
     90        psthread_teardown(tcb->pst_data);
     91        __free_tls(tcb);
    7192
    7293        thread_exit(0);
Note: See TracChangeset for help on using the changeset viewer.