[apple/dyld.git] / src / threadLocalVariables.c

/* -*- mode: C++; c-basic-offset: 4; tab-width: 4 -*-
 *
 * Copyright (c) 2010 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */


#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <stddef.h>
#include <stdio.h>
#include <pthread.h>
#include <Block.h>
#include <malloc/malloc.h>
#include <mach-o/loader.h>
#include <libkern/OSAtomic.h>

#include "dyld_priv.h"


#if __LP64__
        typedef struct mach_header_64           macho_header;
        #define LC_SEGMENT_COMMAND                      LC_SEGMENT_64
        typedef struct segment_command_64       macho_segment_command;
        typedef struct section_64                       macho_section;
#else
        typedef struct mach_header                      macho_header;
        #define LC_SEGMENT_COMMAND                      LC_SEGMENT
        typedef struct segment_command          macho_segment_command;
        typedef struct section                          macho_section;
#endif

#ifndef S_THREAD_LOCAL_REGULAR
#define S_THREAD_LOCAL_REGULAR                   0x11
#endif

#ifndef S_THREAD_LOCAL_ZEROFILL
#define S_THREAD_LOCAL_ZEROFILL                  0x12
#endif

#ifndef S_THREAD_LOCAL_VARIABLES
#define S_THREAD_LOCAL_VARIABLES                 0x13
#endif

#ifndef S_THREAD_LOCAL_VARIABLE_POINTERS
#define S_THREAD_LOCAL_VARIABLE_POINTERS         0x14
#endif

#ifndef S_THREAD_LOCAL_INIT_FUNCTION_POINTERS
#define S_THREAD_LOCAL_INIT_FUNCTION_POINTERS    0x15
#endif

#ifndef MH_HAS_TLV_DESCRIPTORS
        #define MH_HAS_TLV_DESCRIPTORS 0x800000
#endif

#if __i386__ || __x86_64__

typedef struct TLVHandler {
        struct TLVHandler *next;
        dyld_tlv_state_change_handler handler;
        enum dyld_tlv_states state;
} TLVHandler;

// lock-free prepend-only linked list
static TLVHandler * volatile tlv_handlers = NULL;


struct TLVDescriptor
{
        void*                   (*thunk)(struct TLVDescriptor*);
        unsigned long   key;
        unsigned long   offset;
};
typedef struct TLVDescriptor  TLVDescriptor;


// implemented in assembly
extern void* tlv_get_addr(TLVDescriptor*);

struct TLVImageInfo
{
        pthread_key_t                           key;
        const struct mach_header*       mh;
};
typedef struct TLVImageInfo             TLVImageInfo;

static TLVImageInfo*    tlv_live_images = NULL;
static unsigned int             tlv_live_image_alloc_count = 0;
static unsigned int             tlv_live_image_used_count = 0;
static pthread_mutex_t  tlv_live_image_lock = PTHREAD_MUTEX_INITIALIZER;

static void tlv_set_key_for_image(const struct mach_header* mh, pthread_key_t key)
{
        pthread_mutex_lock(&tlv_live_image_lock);
                if ( tlv_live_image_used_count == tlv_live_image_alloc_count ) {
                        unsigned int newCount = (tlv_live_images == NULL) ? 8 : 2*tlv_live_image_alloc_count;
                        struct TLVImageInfo* newBuffer = malloc(sizeof(TLVImageInfo)*newCount);
                        if ( tlv_live_images != NULL ) {
                                memcpy(newBuffer, tlv_live_images, sizeof(TLVImageInfo)*tlv_live_image_used_count);
                                free(tlv_live_images);
                        }
                        tlv_live_images = newBuffer;
                        tlv_live_image_alloc_count = newCount;
                }
                tlv_live_images[tlv_live_image_used_count].key = key;
                tlv_live_images[tlv_live_image_used_count].mh = mh;
                ++tlv_live_image_used_count;
        pthread_mutex_unlock(&tlv_live_image_lock);
}

static const struct mach_header* tlv_get_image_for_key(pthread_key_t key)
{
        const struct mach_header* result = NULL;
        pthread_mutex_lock(&tlv_live_image_lock);
                for(unsigned int i=0; i < tlv_live_image_used_count; ++i) {
                        if ( tlv_live_images[i].key == key ) {
                                result = tlv_live_images[i].mh;
                                break;
                        }
                }
        pthread_mutex_unlock(&tlv_live_image_lock);
        return result;
}


static void
tlv_notify(enum dyld_tlv_states state, void *buffer)
{
        if (!tlv_handlers) return;

        // Always use malloc_size() to ensure allocated and deallocated states 
        // send the same size. tlv_free() doesn't have anything else recorded.
        dyld_tlv_info info = { sizeof(info), buffer, malloc_size(buffer) };
        
        for (TLVHandler *h = tlv_handlers; h != NULL; h = h->next) {
                if (h->state == state  &&  h->handler) {
                        h->handler(h->state, &info);
                }
        }
}


// called lazily when TLV is first accessed
__attribute__((visibility("hidden")))
void* tlv_allocate_and_initialize_for_key(pthread_key_t key)
{
        const struct mach_header* mh = tlv_get_image_for_key(key);
        // first pass, find size and template
        uint8_t*                start = NULL;
        unsigned long   size;
        intptr_t                slide = 0;
        bool                    slideComputed = false;
        bool                    hasInitializers = false;
        const uint32_t  cmd_count = mh->ncmds;
        const struct load_command* const cmds = (struct load_command*)(((uint8_t*)mh) + sizeof(macho_header));
        const struct load_command* cmd = cmds;
        for (uint32_t i = 0; i < cmd_count; ++i) {
                if ( cmd->cmd == LC_SEGMENT_COMMAND) {
                        const macho_segment_command* seg = (macho_segment_command*)cmd;
                        if ( !slideComputed && (seg->filesize != 0) ) {
                                slide = (uintptr_t)mh - seg->vmaddr;
                                slideComputed = true;
                        }
                        const macho_section* const sectionsStart = (macho_section*)((char*)seg + sizeof(macho_segment_command));
                        const macho_section* const sectionsEnd = &sectionsStart[seg->nsects];
                        for (const macho_section* sect=sectionsStart; sect < sectionsEnd; ++sect) {
                                switch ( sect->flags & SECTION_TYPE ) {
                                        case S_THREAD_LOCAL_INIT_FUNCTION_POINTERS:
                                                hasInitializers = true;
                                                break;
                                        case S_THREAD_LOCAL_ZEROFILL:
                                        case S_THREAD_LOCAL_REGULAR:
                                                if ( start == NULL ) {
                                                        // first of N contiguous TLV template sections, record as if this was only section
                                                        start = (uint8_t*)(sect->addr + slide);
                                                        size = sect->size;
                                                }
                                                else {
                                                        // non-first of N contiguous TLV template sections, accumlate values
                                                        const uint8_t* newEnd = (uint8_t*)(sect->addr + slide + sect->size);
                                                        size = newEnd - start;
                                                }
                                                break;
                                }
                        }
                }
                cmd = (const struct load_command*)(((char*)cmd)+cmd->cmdsize);
        }
        
        // allocate buffer and fill with template
        void* buffer = malloc(size);
        memcpy(buffer, start, size);
        
        // set this thread's value for key to be the new buffer.
        pthread_setspecific(key, buffer);

        // send tlv state notifications
        tlv_notify(dyld_tlv_state_allocated, buffer);
        
        // second pass, run initializers
        if ( hasInitializers ) {
                cmd = cmds;
                for (uint32_t i = 0; i < cmd_count; ++i) {
                        if ( cmd->cmd == LC_SEGMENT_COMMAND) {
                                const macho_segment_command* seg = (macho_segment_command*)cmd;
                                const macho_section* const sectionsStart = (macho_section*)((char*)seg + sizeof(macho_segment_command));
                                const macho_section* const sectionsEnd = &sectionsStart[seg->nsects];
                                for (const macho_section* sect=sectionsStart; sect < sectionsEnd; ++sect) {
                                        if ( (sect->flags & SECTION_TYPE) == S_THREAD_LOCAL_INIT_FUNCTION_POINTERS ) {
                                                typedef void (*InitFunc)(void);
                                                InitFunc* funcs = (InitFunc*)(sect->addr + slide);
                                                const uint32_t count = sect->size / sizeof(uintptr_t);
                                                for (uint32_t i=count; i > 0; --i) {
                                                        InitFunc func = funcs[i-1];
                                                        func();
                                                }
                                        }
                                }
                        }
                        cmd = (const struct load_command*)(((char*)cmd)+cmd->cmdsize);
                }
        }
        return buffer;
}


// pthread destructor for TLV storage
static void
tlv_free(void *storage)
{
        tlv_notify(dyld_tlv_state_deallocated, storage);
        free(storage);
}


// called when image is loaded
static void tlv_initialize_descriptors(const struct mach_header* mh)
{
        pthread_key_t   key = 0;
        intptr_t                slide = 0;
        bool                    slideComputed = false;
        const uint32_t cmd_count = mh->ncmds;
        const struct load_command* const cmds = (struct load_command*)(((uint8_t*)mh) + sizeof(macho_header));
        const struct load_command* cmd = cmds;
        for (uint32_t i = 0; i < cmd_count; ++i) {
                if ( cmd->cmd == LC_SEGMENT_COMMAND) {
                        const macho_segment_command* seg = (macho_segment_command*)cmd;
                        if ( !slideComputed && (seg->filesize != 0) ) {
                                slide = (uintptr_t)mh - seg->vmaddr;
                                slideComputed = true;
                        }
                        const macho_section* const sectionsStart = (macho_section*)((char*)seg + sizeof(macho_segment_command));
                        const macho_section* const sectionsEnd = &sectionsStart[seg->nsects];
                        for (const macho_section* sect=sectionsStart; sect < sectionsEnd; ++sect) {
                                if ( (sect->flags & SECTION_TYPE) == S_THREAD_LOCAL_VARIABLES ) {
                                        if ( sect->size != 0 ) {
                                                // allocate pthread key when we first discover this image has TLVs
                                                if ( key == 0 ) {
                                                        int result = pthread_key_create(&key, &tlv_free);
                                                        if ( result != 0 )
                                                                abort();
                                                        tlv_set_key_for_image(mh, key);
                                                }
                                                // initialize each descriptor
                                                TLVDescriptor* start = (TLVDescriptor*)(sect->addr + slide);
                                                TLVDescriptor* end = (TLVDescriptor*)(sect->addr + sect->size + slide);
                                                for (TLVDescriptor* d=start; d < end; ++d) {
                                                        d->thunk = tlv_get_addr;
                                                        d->key = key;
                                                        //d->offset = d->offset;  // offset unchanged
                                                }
                                        }
                                }
                        }
                }
                cmd = (const struct load_command*)(((char*)cmd)+cmd->cmdsize);
        }
}

// called by dyld when a image is loaded
static const char* tlv_load_notification(enum dyld_image_states state, uint32_t infoCount, const struct dyld_image_info info[])
{
        // this is called on all images, even those without TLVs, so we want
        // this to be fast.  The linker sets MH_HAS_TLV_DESCRIPTORS so we don't
        // have to search images just to find the don't have TLVs.
        for (uint32_t i=0; i < infoCount; ++i) {
                if ( info[i].imageLoadAddress->flags & MH_HAS_TLV_DESCRIPTORS )
                        tlv_initialize_descriptors(info[i].imageLoadAddress);
        }
        return NULL;
}


void dyld_register_tlv_state_change_handler(enum dyld_tlv_states state, dyld_tlv_state_change_handler handler)
{
        TLVHandler *h = malloc(sizeof(TLVHandler));
        h->state = state;
        h->handler = Block_copy(handler);

        TLVHandler *old;
        do {
                old = tlv_handlers;
                h->next = old;
        } while (! OSAtomicCompareAndSwapPtrBarrier(old, h, (void * volatile *)&tlv_handlers));
}


void dyld_enumerate_tlv_storage(dyld_tlv_state_change_handler handler)
{
        pthread_mutex_lock(&tlv_live_image_lock);
                unsigned int count = tlv_live_image_used_count;
                void *list[count];
                for (unsigned int i = 0; i < count; ++i) {
                        list[i] = pthread_getspecific(tlv_live_images[i].key);
                }
        pthread_mutex_unlock(&tlv_live_image_lock);

        for (unsigned int i = 0; i < count; ++i) {
                if (list[i]) {
                        dyld_tlv_info info = { sizeof(info), list[i], malloc_size(list[i]) };
                        handler(dyld_tlv_state_allocated, &info);
                }
        }
}


//
//  thread_local terminators
//
// C++ 0x allows thread_local C++ objects which have constructors run
// on the thread before any use of the object and the object's destructor
// is run on the thread when the thread terminates.
//
// To support this libdyld gets a pthread key early in process start up and
// uses tlv_finalize and the key's destructor function.  This key must be
// allocated before any thread local variables are instantiated because when
// a thread is terminated, the pthread package runs the destructor function
// on each key's storage values in key allocation order.  Since we want
// C++ objects to be destructred before they are deallocated, we need the 
// destructor key to come before the deallocation key.
//

typedef void (*TermFunc)(void*);
struct TLVTerminatorListEntry
{
    TermFunc    termFunc;
    void*       objAddr;
};

struct TLVTerminatorList
{
    uint32_t                        allocCount;
    uint32_t                        useCount;
    struct TLVTerminatorListEntry   entries[1];  // variable length
};


static pthread_key_t tlv_terminators_key = 0;

void _tlv_atexit(TermFunc func, void* objAddr)
{
    // NOTE: this does not need locks because it only operates on current thread data
        struct TLVTerminatorList* list = (struct TLVTerminatorList*)pthread_getspecific(tlv_terminators_key);
    if ( list == NULL ) {
        // handle first allocation
        list = (struct TLVTerminatorList*)malloc(offsetof(struct TLVTerminatorList, entries[1]));
        list->allocCount = 1;
        list->useCount = 1;
        list->entries[0].termFunc = func;
        list->entries[0].objAddr = objAddr;
        pthread_setspecific(tlv_terminators_key, list);
    }
    else {
        if ( list->allocCount == list->allocCount ) {
            // handle resizing allocation 
            uint32_t newAllocCount = list->allocCount * 2;
            uint32_t newAllocSize = offsetof(struct TLVTerminatorList, entries[newAllocCount]);
            struct TLVTerminatorList* newlist = (struct TLVTerminatorList*)malloc(newAllocSize);
            newlist->allocCount = newAllocCount;
            newlist->useCount = list->useCount;
            for(uint32_t i=0; i < list->useCount; ++i)
                newlist->entries[i] = list->entries[i];
            pthread_setspecific(tlv_terminators_key, newlist);
            free(list);
            list = newlist;
        }
        // handle appending new entry
        list->entries[list->useCount].termFunc = func;
        list->entries[list->useCount].objAddr = objAddr;
        list->useCount += 1;
    }
}

// called by pthreads when the current thread is going way and 
// _tlv_atexit() has been called on the thread.
static void tlv_finalize(void* storage)
{
    struct TLVTerminatorList* list = (struct TLVTerminatorList*)storage;
    for(uint32_t i=0; i < list->useCount; ++i) {
        struct TLVTerminatorListEntry* entry = &list->entries[i];
        if ( entry->termFunc != NULL ) {
            (*entry->termFunc)(entry->objAddr);
        }
    }
    free(storage);
}


__attribute__((visibility("hidden")))
void tlv_initializer()
{
    // create pthread key to handle thread_local destructors
    // NOTE: this key must be allocated before any keys for TLV
    // so that _pthread_tsd_cleanup will run destructors before deallocation
    (void)pthread_key_create(&tlv_terminators_key, &tlv_finalize);
       
    // register with dyld for notification when images are loaded
    dyld_register_image_state_change_handler(dyld_image_state_bound, true, tlv_load_notification);
}


// linked images with TLV have references to this symbol, but it is never used at runtime
void _tlv_bootstrap()
{
        abort();
}


// __i386__ || __x86_64__
#else
// !(__i386__ || __x86_64__)


void dyld_register_tlv_state_change_handler(enum dyld_tlv_states state, dyld_tlv_state_change_handler handler)
{
}

void dyld_enumerate_tlv_storage(dyld_tlv_state_change_handler handler)
{
}

__attribute__((visibility("hidden")))
void tlv_initializer()
{
}


// !(__i386__ || __x86_64__)
#endif