/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2024-2026 The FreeBSD Foundation
 *
 * This software was developed by Björn Zeeb under sponsorship from
 * the FreeBSD Foundation.
 */

#ifndef _LINUXKPI_LINUX_CLEANUP_H
#define _LINUXKPI_LINUX_CLEANUP_H

#include <linux/err.h>

#define CLEANUP_NAME(_n, _s)    __CONCAT(__CONCAT(cleanup_, _n), _s)

#define __cleanup(_f)           __attribute__((__cleanup__(_f)))

#define DECLARE(_n, _x)                                                 \
    CLEANUP_NAME(_n, _t) _x __cleanup(CLEANUP_NAME(_n, _destroy)) =     \
        CLEANUP_NAME(_n, _create)

/*
 * Note: "_T" are special as they are exposed into common code for
 * statements.  Extra care should be taken when changing the code.
 */
#define DEFINE_GUARD(_n, _dt, _lock, _unlock)                           \
                                                                        \
    typedef _dt CLEANUP_NAME(_n, _t);                                   \
                                                                        \
    static inline _dt                                                   \
    CLEANUP_NAME(_n, _create)( _dt _T)                                  \
    {                                                                   \
        _dt c;                                                          \
                                                                        \
        c = ({ _lock; _T; });                                           \
        return (c);                                                     \
    }                                                                   \
                                                                        \
    static inline void                                                  \
    CLEANUP_NAME(_n, _destroy)(_dt *t)                                  \
    {                                                                   \
        _dt _T;                                                         \
                                                                        \
        _T = *t;                                                        \
        if (_T) { _unlock; };                                           \
    }

/* We need to keep these calls unique. */
#define _guard(_n, _x)                                                  \
    DECLARE(_n, _x)
#define guard(_n)                                                       \
    _guard(_n, guard_ ## _n ## _ ## __COUNTER__)

#define DEFINE_FREE(_n, _t, _f)                                         \
    static inline void                                                  \
    __free_ ## _n(void *p)                                              \
    {                                                                   \
        _t _T;                                                          \
                                                                        \
        _T = *(_t *)p;                                                  \
        _f;                                                             \
    }

#define __free(_n)              __cleanup(__free_##_n)

/*
 * Our initial version go broken up.  Some simplifications like using
 * "bool" for the lock had to be changed to a more general type.
 * _T is still special and, like other bits, may not always be used,
 * so tag with __unused (or better the LinuxKPI __maybe_unused).
 */
#define _DEFINE_LOCK_GUARD_0(_n, _lock)                                 \
    static inline CLEANUP_NAME(_n, _t)                                  \
    CLEANUP_NAME(_n, _create)(void)                                     \
    {                                                                   \
        CLEANUP_NAME(_n, _t) _tmp;                                      \
        CLEANUP_NAME(_n, _t) *_T __maybe_unused;                        \
                                                                        \
        _tmp.lock = (void *)1;                                          \
        _T = &_tmp;                                                     \
        _lock;                                                          \
        return (_tmp);                                                  \
    }

#define _DEFINE_LOCK_GUARD_1(_n, _type, _lock)                          \
    static inline CLEANUP_NAME(_n, _t)                                  \
    CLEANUP_NAME(_n, _create)(_type *l)                                 \
    {                                                                   \
        CLEANUP_NAME(_n, _t) _tmp;                                      \
        CLEANUP_NAME(_n, _t) *_T __maybe_unused;                        \
                                                                        \
        _tmp.lock = l;                                                  \
        _T = &_tmp;                                                     \
        _lock;                                                          \
        return (_tmp);                                                  \
    }

#define _GUARD_IS_ERR(_v)                                               \
    ({                                                                  \
        uintptr_t x = (uintptr_t)(void *)(_v);                          \
        IS_ERR_VALUE(x);                                                \
    })

#define __is_cond_ptr(_n)                                               \
    CLEANUP_NAME(_n, _is_cond)
#define __guard_ptr(_n)                                                 \
    CLEANUP_NAME(_n, _ptr)

#define _DEFINE_CLEANUP_IS_CONDITIONAL(_n, _b)                          \
    static const bool CLEANUP_NAME(_n, _is_cond) __maybe_unused = _b

#define _DEFINE_GUARD_LOCK_PTR(_n, _lp)                                 \
    static inline void *                                                \
    CLEANUP_NAME(_n, _lock_ptr)(CLEANUP_NAME(_n, _t) *_T)               \
    {                                                                   \
        void *_p;                                                       \
                                                                        \
        _p = (void *)(uintptr_t)*(_lp);                                 \
        if (IS_ERR(_p))                                                 \
                _p = NULL;                                              \
        return (_p);                                                    \
    }

#define _DEFINE_UNLOCK_GUARD(_n, _type, _unlock, ...)                   \
    typedef struct {                                                    \
        _type *lock;                                                    \
        __VA_ARGS__;                                                    \
    } CLEANUP_NAME(_n, _t);                                             \
                                                                        \
    static inline void                                                  \
    CLEANUP_NAME(_n, _destroy)(CLEANUP_NAME(_n, _t) *_T)                \
    {                                                                   \
        if (!_GUARD_IS_ERR(_T->lock)) {                                 \
            _unlock;                                                    \
        }                                                               \
    }                                                                   \
                                                                        \
    _DEFINE_GUARD_LOCK_PTR(_n, &_T->lock)

#define DEFINE_LOCK_GUARD_0(_n, _lock, _unlock, ...)                    \
    _DEFINE_CLEANUP_IS_CONDITIONAL(_n, false);                          \
    _DEFINE_UNLOCK_GUARD(_n, void, _unlock, __VA_ARGS__)                \
    _DEFINE_LOCK_GUARD_0(_n, _lock)

/* This allows the type to be set. */
#define DEFINE_LOCK_GUARD_1(_n, _t, _lock, _unlock, ...)                \
    _DEFINE_CLEANUP_IS_CONDITIONAL(_n, false);                          \
    _DEFINE_UNLOCK_GUARD(_n, _t, _unlock, __VA_ARGS__)                  \
    _DEFINE_LOCK_GUARD_1(_n, _t, _lock)

#define _scoped_guard(_n, _l, ...)                                      \
    for (DECLARE(_n, _scoped)(__VA_ARGS__);                             \
        1 /*__guard_ptr(_n)(&_scoped) || !__is_cond_ptr(_n) */;         \
        ({ goto _l; }))                                                 \
                if (0) {                                                \
_l:                                                                     \
                        break;                                          \
                } else

#define scoped_guard(_n, ...)                                           \
    _scoped_guard(_n, ___label_ ## __COUNTER__, ##__VA_ARGS__)

#endif  /* _LINUXKPI_LINUX_CLEANUP_H */