Linux中TLS

TLS（Thread Local Storage）

线程局部存储。

在Linux操作系统中，TLS保存成GDT中描述的一个段。

/*
 * This creates a new process as a copy of the old one,
 * but does not actually start it yet.
 *
 * It copies the registers, and all the appropriate
 * parts of the process environment (as per the clone
 * flags). The actual kick-off is left to the caller.
 */
static struct task_struct *copy_process(unsigned long clone_flags,
                    unsigned long stack_start,
                    struct pt_regs *regs,
                    unsigned long stack_size,
                    int __user *child_tidptr,
                    struct pid *pid,
                    int trace)
{
......
retval = copy_thread(clone_flags, stack_start, stack_size, p, regs);
......
}

int copy_thread(unsigned long clone_flags, unsigned long sp,
    unsigned long unused,
    struct task_struct *p, struct pt_regs *regs)
{
    struct pt_regs *childregs;
    struct task_struct *tsk;
    int err;

    childregs = task_pt_regs(p);
    *childregs = *regs;
    childregs->ax = 0;
    childregs->sp = sp;

    p->thread.sp = (unsigned long) childregs;
    p->thread.sp0 = (unsigned long) (childregs+1);

    p->thread.ip = (unsigned long) ret_from_fork;

    task_user_gs(p) = get_user_gs(regs);

    p->thread.io_bitmap_ptr = NULL;
    tsk = current;
    err = -ENOMEM;

    memset(p->thread.ptrace_bps, 0, sizeof(p->thread.ptrace_bps));

    if (unlikely(test_tsk_thread_flag(tsk, TIF_IO_BITMAP))) {
        p->thread.io_bitmap_ptr = kmemdup(tsk->thread.io_bitmap_ptr,
                        IO_BITMAP_BYTES, GFP_KERNEL);
        if (!p->thread.io_bitmap_ptr) {
            p->thread.io_bitmap_max = 0;
            return -ENOMEM;
        }
        set_tsk_thread_flag(p, TIF_IO_BITMAP);
    }

    err = 0;

    /*
     * Set a new TLS for the child thread?
     */
    if (clone_flags & CLONE_SETTLS)
        err = do_set_thread_area(p, -1,
            (struct user_desc __user *)childregs->si, 0);

    if (err && p->thread.io_bitmap_ptr) {
        kfree(p->thread.io_bitmap_ptr);
        p->thread.io_bitmap_max = 0;
    }
    return err;
}

/*
 * Set a given TLS descriptor:
 */
int do_set_thread_area(struct task_struct *p, int idx,
               struct user_desc __user *u_info,
               int can_allocate)
{
    struct user_desc info;

    if (copy_from_user(&info, u_info, sizeof(info)))
        return -EFAULT;

    if (idx == -1)
        idx = info.entry_number;

    /*
     * index -1 means the kernel should try to find and
     * allocate an empty descriptor:
     */
    if (idx == -1 && can_allocate) {
        idx = get_free_idx();
        if (idx < 0)
            return idx;
        if (put_user(idx, &u_info->entry_number))
            return -EFAULT;
    }

    if (idx < GDT_ENTRY_TLS_MIN || idx > GDT_ENTRY_TLS_MAX)
        return -EINVAL;

    set_tls_desc(p, idx, &info, 1);

    return 0;
}

static void set_tls_desc(struct task_struct *p, int idx,
             const struct user_desc *info, int n)
{
    struct thread_struct *t = &p->thread;
    struct desc_struct *desc = &t->tls_array[idx - GDT_ENTRY_TLS_MIN];
    int cpu;

    /*
     * We must not get preempted while modifying the TLS.
     */
    cpu = get_cpu();

    while (n-- > 0) {
        if (LDT_empty(info))
            desc->a = desc->b = 0;
        else
            fill_ldt(desc, info);
        ++info;
        ++desc;
    }

    if (t == &current->thread)
        load_TLS(t, cpu);

    put_cpu();
}

static inline void fill_ldt(struct desc_struct *desc, const struct user_desc *info)
{
    desc->limit0        = info->limit & 0x0ffff;

    desc->base0        = (info->base_addr & 0x0000ffff);
    desc->base1        = (info->base_addr & 0x00ff0000) >> 16;

    desc->type        = (info->read_exec_only ^ 1) << 1;
    desc->type           |= info->contents << 2;

    desc->s            = 1;
    desc->dpl        = 0x3;
    desc->p            = info->seg_not_present ^ 1;
    desc->limit        = (info->limit & 0xf0000) >> 16;
    desc->avl        = info->useable;
    desc->d            = info->seg_32bit;
    desc->g            = info->limit_in_pages;

    desc->base2        = (info->base_addr & 0xff000000) >> 24;
    /*
     * Don't allow setting of the lm bit. It is useless anyway
     * because 64bit system calls require __USER_CS:
     */
    desc->l            = 0;
}

从上面的call_tree可以看到，在fork系统调用创建一个新的进程时，会为新的任务设置TLS。

参考：http://blog.csdn.net/dog250/article/details/7704898

fill_ldt设置GDT中第6个段描述符的基址和段限以及DPL等信息，这些信息都是从sys_set_thread_area系统调用的u_info参数中得来的。本质上，最终GDT的第6个段中描述的信息其实就是一块内存，这块内存用于存储TLS节，这块内存其实也是使用brk，mmap之类调用在主线程的堆空间申请的，只是后来调用sys_set_thread_area将其设置成了本线程的私有空间罢了，主线程或者其它线程如果愿意，也是可以通过其它手段访问到这块空间的。

因为TLS是一个对应于C/C++ Runtime库的概念，所以要深入了解TLS，需要结合glibc来理解。