/*      $OpenBSD: completion.h,v 1.10 2024/01/06 09:33:08 kettenis Exp $        */
/*
 * Copyright (c) 2015, 2018 Mark Kettenis
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef _LINUX_COMPLETION_H
#define _LINUX_COMPLETION_H

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/mutex.h>
#include <linux/wait.h>

struct completion {
        u_int done;
        struct mutex lock;
};

#define DECLARE_COMPLETION_ONSTACK(name) \
        struct completion name = { 0, MUTEX_INITIALIZER(IPL_TTY) }

static inline void
init_completion(struct completion *x)
{
        x->done = 0;
        mtx_init(&x->lock, IPL_TTY);
}

static inline void
reinit_completion(struct completion *x)
{
        x->done = 0;
}

static inline u_long
wait_for_completion_timeout(struct completion *x, u_long timo)
{
        int ret;

        KASSERT(!cold);

        mtx_enter(&x->lock);
        while (x->done == 0) {
                ret = msleep(x, &x->lock, 0, "wfct", timo);
                if (ret) {
                        mtx_leave(&x->lock);
                        /* timeout */
                        return 0;
                }
        }
        if (x->done != UINT_MAX)
                x->done--;
        mtx_leave(&x->lock);

        return 1;
}

static inline void
wait_for_completion(struct completion *x)
{
        KASSERT(!cold);

        mtx_enter(&x->lock);
        while (x->done == 0) {
                msleep_nsec(x, &x->lock, 0, "wfcom", INFSLP);
        }
        if (x->done != UINT_MAX)
                x->done--;
        mtx_leave(&x->lock);
}

static inline u_long
wait_for_completion_interruptible(struct completion *x)
{
        int ret;

        KASSERT(!cold);

        mtx_enter(&x->lock);
        while (x->done == 0) {
                ret = msleep_nsec(x, &x->lock, PCATCH, "wfci", INFSLP);
                if (ret) {
                        mtx_leave(&x->lock);
                        if (ret == EWOULDBLOCK)
                                return 0;
                        return -ERESTARTSYS;
                }
        }
        if (x->done != UINT_MAX)
                x->done--;
        mtx_leave(&x->lock);

        return 0;
}

static inline u_long
wait_for_completion_interruptible_timeout(struct completion *x, u_long timo)
{
        int ret;

        KASSERT(!cold);

        mtx_enter(&x->lock);
        while (x->done == 0) {
                ret = msleep(x, &x->lock, PCATCH, "wfcit", timo);
                if (ret) {
                        mtx_leave(&x->lock);
                        if (ret == EWOULDBLOCK)
                                return 0;
                        return -ERESTARTSYS;
                }
        }
        if (x->done != UINT_MAX)
                x->done--;
        mtx_leave(&x->lock);

        return 1;
}

static inline void
complete(struct completion *x)
{
        mtx_enter(&x->lock);
        if (x->done != UINT_MAX)
                x->done++;
        mtx_leave(&x->lock);
        wakeup_one(x);
}

static inline void
complete_all(struct completion *x)
{
        mtx_enter(&x->lock);
        x->done = UINT_MAX;
        mtx_leave(&x->lock);
        wakeup(x);
}

static inline bool
try_wait_for_completion(struct completion *x)
{
        mtx_enter(&x->lock);
        if (x->done == 0) {
                mtx_leave(&x->lock);
                return false;
        }
        if (x->done != UINT_MAX)
                x->done--;
        mtx_leave(&x->lock);
        return true;
}

#endif