diff options
Diffstat (limited to 'inc/pls.h')
| -rw-r--r-- | inc/pls.h | 213 |
1 files changed, 213 insertions, 0 deletions
diff --git a/inc/pls.h b/inc/pls.h new file mode 100644 index 0000000..c832aa9 --- /dev/null +++ b/inc/pls.h @@ -0,0 +1,213 @@ +#ifndef PLS_H +#define PLS_H + +/** + * Copyright (c) 2019, The Linux Foundation. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of The Linux Foundation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <stdlib.h> +#include "AEEStdDef.h" +#include "AEEatomic.h" +#include "verify.h" +#include "HAP_farf.h" + +struct PLS; + +struct plskey { + uintptr_t type; + uintptr_t key; +}; + +struct PLS { + struct PLS* next; + struct plskey key; + void (*dtor)(void* data); + uint64_t data[1]; +}; + + +struct pls_table { + struct PLS* lst; + uint32_t uRefs; + uint32_t primThread; +}; + +/** + * initialize on every thread and stick the pls_thread_deinit + * function into the threads tls + */ +static __inline int pls_thread_init(struct pls_table* me, uintptr_t tid) { + if(tid == me->primThread) { + return 0; + } + if(0 == atomic_CompareOrAdd(&me->uRefs, 0, 1)) { + return -1; + } + return 0; +} + +/* call this constructor before the first thread creation with the + * first threads id + */ +static __inline void pls_ctor(struct pls_table* me, uintptr_t primThread) { + me->uRefs = 1; + me->primThread = primThread; +} + +static __inline struct pls_table* pls_thread_deinit(struct pls_table* me) { + if(me && 0 != me->uRefs && 0 == atomic_Add(&me->uRefs, -1)) { + struct PLS* lst, *next; + lst = me->lst; + me->lst = 0; + while(lst) { + next = lst->next; + if(lst->dtor) { + FARF(HIGH, "pls dtor %p", lst->dtor); + lst->dtor((void*)lst->data); + } + free(lst); + lst = next; + } + return me; + } + return 0; +} + +/** + * adds a new key to the local storage, overriding + * any previous value at the key. Overriding the key + * does not cause the destructor to run. + * + * @param type, type part of the key to be used for lookup, + these should be static addresses. + * @param key, the key to be used for lookup + * @param size, the size of the data + * @param ctor, constructor that takes a context and memory of size + * @param ctx, constructor context passed as the first argument to ctor + * @param dtor, destructor to run at pls shutdown + * @param ppo, output data + * @retval, 0 for success + */ + +static __inline int pls_add(struct pls_table* me, uintptr_t type, uintptr_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* data), void** ppo) { + int nErr = 0; + struct PLS* pls = 0; + struct PLS* prev; + VERIFY(me->uRefs != 0); + VERIFY(0 != (pls = (struct PLS*)calloc(1, size + sizeof(*pls) - sizeof(pls->data)))); + if(ctor) { + VERIFY(0 == ctor(ctx, (void*)pls->data)); + } + pls->dtor = dtor; + pls->key.type = type; + pls->key.key = key; + do { + pls->next = me->lst; + prev = (struct PLS*)atomic_CompareAndExchangeUP((uintptr_t*)&me->lst, (uintptr_t)pls, (uintptr_t)pls->next); + } while(prev != pls->next); + if(ppo) { + *ppo = (void*)pls->data; + } + FARF(HIGH, "pls added %p", dtor); +bail: + if(nErr && pls) { + free(pls); + } + return nErr; +} + +static __inline int pls_lookup(struct pls_table* me, uintptr_t type, uintptr_t key, void** ppo); + +/** + * like add, but will only add 1 item if two threads try to add at the same time. returns + * item if its already there, otherwise tries to add. + * ctor may be called twice + * callers should avoid calling pls_add which will override the singleton + */ +static __inline int pls_add_lookup_singleton(struct pls_table* me, uintptr_t type, uintptr_t key, int size, int (*ctor)(void* ctx, void* data), void* ctx, void (*dtor)(void* data), void** ppo) { + int nErr = 0; + struct PLS* pls = 0; + struct PLS* prev; + if(0 == pls_lookup(me, type, key, ppo)) { + return 0; + } + VERIFY(me->uRefs != 0); + VERIFY(0 != (pls = (struct PLS*)calloc(1, size + sizeof(*pls) - sizeof(pls->data)))); + if(ctor) { + VERIFY(0 == ctor(ctx, (void*)pls->data)); + } + pls->dtor = dtor; + pls->key.type = type; + pls->key.key = key; + do { + pls->next = me->lst; + if(0 == pls_lookup(me, type, key, ppo)) { + if(pls->dtor) { + pls->dtor((void*)pls->data); + } + free(pls); + return 0; + } + prev = (struct PLS*)atomic_CompareAndExchangeUP((uintptr_t*)&me->lst, (uintptr_t)pls, (uintptr_t)pls->next); + } while(prev != pls->next); + if(ppo) { + *ppo = (void*)pls->data; + } + FARF(HIGH, "pls added %p", dtor); +bail: + if(nErr && pls) { + free(pls); + } + return nErr; +} + + +/** + * finds the last data pointer added for key to the local storage + * + * @param key, the key to be used for lookup + * @param ppo, output data + * @retval, 0 for success + */ + +static __inline int pls_lookup(struct pls_table* me, uintptr_t type, uintptr_t key, void** ppo) { + struct PLS* lst; + for(lst = me->lst; me->uRefs != 0 && lst != 0; lst = lst->next) { + if(lst->key.type == type && lst->key.key == key) { + if(ppo) { + *ppo = lst->data; + } + return 0; + } + } + return -1; +} + +#endif //PLS_H + + |