Return to thread_value.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libstrongswan / threading / windows

Annotation of embedaddon/strongswan/src/libstrongswan/threading/windows/thread_value.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  * Copyright (C) 2013 Martin Willi
        !             3:  * Copyright (C) 2013 revosec AG
        !             4:  *
        !             5:  * This program is free software; you can redistribute it and/or modify it
        !             6:  * under the terms of the GNU General Public License as published by the
        !             7:  * Free Software Foundation; either version 2 of the License, or (at your
        !             8:  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
        !             9:  *
        !            10:  * This program is distributed in the hope that it will be useful, but
        !            11:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
        !            12:  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
        !            13:  * for more details.
        !            14:  */
        !            15: 
        !            16: #include "thread.h"
        !            17: 
        !            18: #include <threading/thread_value.h>
        !            19: 
        !            20: 
        !            21: typedef struct private_thread_value_t private_thread_value_t;
        !            22: 
        !            23: /**
        !            24:  * Unified thread_value_t implementation
        !            25:  */
        !            26: struct private_thread_value_t {
        !            27: 
        !            28:        /**
        !            29:         * Public interface.
        !            30:         */
        !            31:        thread_value_t public;
        !            32: 
        !            33:        union {
        !            34: 
        !            35:                /**
        !            36:                 * Cleanup function
        !            37:                 */
        !            38:                thread_cleanup_t cleanup;
        !            39: 
        !            40:                /**
        !            41:                 * Windows TLS index, if used
        !            42:                 */
        !            43:                DWORD index;
        !            44:        };
        !            45: };
        !            46: 
        !            47: /**
        !            48:  * TLS entry
        !            49:  */
        !            50: typedef struct {
        !            51:        /** TLS value */
        !            52:        void *value;
        !            53:        /** cleanup handler function */
        !            54:        thread_cleanup_t cleanup;
        !            55: } entry_t;
        !            56: 
        !            57: /**
        !            58:  * See windows/thread.h
        !            59:  */
        !            60: void thread_tls_cleanup(void *value)
        !            61: {
        !            62:        entry_t *entry = (entry_t*)value;
        !            63: 
        !            64:        if (entry->cleanup)
        !            65:        {
        !            66:                entry->cleanup(entry->value);
        !            67:        }
        !            68:        free(entry);
        !            69: }
        !            70: 
        !            71: METHOD(thread_value_t, tls_set, void,
        !            72:        private_thread_value_t *this, void *val)
        !            73: {
        !            74:        entry_t *entry;
        !            75: 
        !            76:        if (val)
        !            77:        {
        !            78:                INIT(entry,
        !            79:                        .cleanup = this->cleanup,
        !            80:                        .value = val,
        !            81:                );
        !            82: 
        !            83:                free(thread_tls_put(this, entry));
        !            84:        }
        !            85:        else
        !            86:        {
        !            87:                free(thread_tls_remove(this));
        !            88:        }
        !            89: }
        !            90: 
        !            91: METHOD(thread_value_t, tls_get, void*,
        !            92:        private_thread_value_t *this)
        !            93: {
        !            94:        entry_t *entry;
        !            95: 
        !            96:        entry = thread_tls_get(this);
        !            97:        if (entry)
        !            98:        {
        !            99:                return entry->value;
        !           100:        }
        !           101:        return NULL;
        !           102: }
        !           103: 
        !           104: METHOD(thread_value_t, tls_destroy, void,
        !           105:        private_thread_value_t *this)
        !           106: {
        !           107:        entry_t *entry;
        !           108: 
        !           109:        entry = thread_tls_remove(this);
        !           110:        if (entry)
        !           111:        {
        !           112:                thread_tls_cleanup(entry);
        !           113:        }
        !           114:        free(this);
        !           115: }
        !           116: 
        !           117: METHOD(thread_value_t, tls_set_index, void,
        !           118:        private_thread_value_t *this, void *val)
        !           119: {
        !           120:        TlsSetValue(this->index, val);
        !           121: }
        !           122: 
        !           123: METHOD(thread_value_t, tls_get_index, void*,
        !           124:        private_thread_value_t *this)
        !           125: {
        !           126:        return TlsGetValue(this->index);
        !           127: }
        !           128: 
        !           129: METHOD(thread_value_t, tls_destroy_index, void,
        !           130:        private_thread_value_t *this)
        !           131: {
        !           132:        TlsFree(this->index);
        !           133:        free(this);
        !           134: }
        !           135: 
        !           136: /**
        !           137:  * Described in header.
        !           138:  */
        !           139: thread_value_t *thread_value_create(thread_cleanup_t cleanup)
        !           140: {
        !           141:        private_thread_value_t *this;
        !           142:        DWORD index = TLS_OUT_OF_INDEXES;
        !           143: 
        !           144:        /* we have two implementations: Windows Tls* functions do not support
        !           145:         * callbacks and has limited instances. We use it nonetheless if possible,
        !           146:         * especially as leak detective relies on TLS, but we have to mangle
        !           147:         * leak detective state for TLS storage. */
        !           148: 
        !           149:        if (!cleanup)
        !           150:        {
        !           151:                index = TlsAlloc();
        !           152:        }
        !           153: 
        !           154:        if (index == TLS_OUT_OF_INDEXES)
        !           155:        {
        !           156:                INIT(this,
        !           157:                        .public = {
        !           158:                                .set = _tls_set,
        !           159:                                .get = _tls_get,
        !           160:                                .destroy = _tls_destroy,
        !           161:                        },
        !           162:                        .cleanup = cleanup,
        !           163:                );
        !           164:        }
        !           165:        else
        !           166:        {
        !           167:                INIT(this,
        !           168:                        .public = {
        !           169:                                .set = _tls_set_index,
        !           170:                                .get = _tls_get_index,
        !           171:                                .destroy = _tls_destroy_index,
        !           172:                        },
        !           173:                        .index = index,
        !           174:                );
        !           175:        }
        !           176: 
        !           177:        return &this->public;
        !           178: }