ref.h

Go to the documentation of this file.

#pragma once
 
#include <kernel/defs.h>
 
#include <assert.h>
#include <stdatomic.h>
#include <stdint.h>
 
#define REF_MAGIC 0x26CB6E4C
 
typedef struct ref
{
#ifndef NDEBUG
    uint32_t magic;
#endif
    atomic_uint32_t count;
    void (*free)(void* self);
} ref_t;
 
#define DEREF_DEFER(ptr) __attribute__((cleanup(ref_defer_cleanup))) void* CONCAT(p, __COUNTER__) = (ptr)
 
#define REF(ptr) \
    ({ \
        ref_t* ref = (ref_t*)ptr; \
        ref_inc(ref); \
        ptr; \
    })
 
#define DEREF(ptr) \
    ({ \
        ref_t* ref = (ref_t*)ptr; \
        ref_dec(ref); \
    })
 
static inline void ref_init(ref_t* ref, void* free)
{
#ifndef NDEBUG
    ref->magic = REF_MAGIC;
#endif
    atomic_init(&ref->count, 1);
    ref->free = free;
}
 
static inline void* ref_inc(void* ptr)
{
    ref_t* ref = (ref_t*)ptr;
    if (ref == NULL)
    {
        return NULL;
    }
 
    assert(ref->magic == REF_MAGIC);
    atomic_fetch_add_explicit(&ref->count, 1, memory_order_relaxed);
    return ptr;
}
 
static inline void ref_dec(void* ptr)
{
    ref_t* ref = (ref_t*)ptr;
    if (ref == NULL)
    {
        return;
    }
 
    assert(ref->magic == REF_MAGIC);
    uint64_t count = atomic_fetch_sub_explicit(&ref->count, 1, memory_order_relaxed);
    if (count > 1)
    {
        return;
    }
 
    atomic_thread_fence(memory_order_acquire);
    assert(count == 1); // Count is now zero, if it was zero before then we have a double free.
    if (ref->free == NULL)
    {
        return;
    }
 
#ifndef NDEBUG
    ref->magic = 0;
#endif
    ref->free(ptr);
}
 
static inline void ref_defer_cleanup(void** ptr)
{
    ref_dec(*ptr);
}