/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2024 Oxide Computer Company
 */

#include "lint.h"
#include "thr_uberdata.h"

static uint32_t _semvaluemax;

/*
 * Check to see if anyone is waiting for this semaphore.
 */
#pragma weak _sema_held = sema_held
int
sema_held(sema_t *sp)
{
        return (sp->count == 0);
}

#pragma weak _sema_init = sema_init
int
sema_init(sema_t *sp, unsigned int count, int type, void *arg __unused)
{
        if (_semvaluemax == 0)
                _semvaluemax = (uint32_t)_sysconf(_SC_SEM_VALUE_MAX);
        if ((type != USYNC_THREAD && type != USYNC_PROCESS) ||
            (count > _semvaluemax))
                return (EINVAL);
        (void) memset(sp, 0, sizeof (*sp));
        sp->count = count;
        sp->type = (uint16_t)type;
        sp->magic = SEMA_MAGIC;

        /*
         * This should be at the beginning of the function,
         * but for the sake of old broken applications that
         * do not have proper alignment for their semaphores
         * (and don't check the return code from sema_init),
         * we put it here, after initializing the semaphore regardless.
         */
        if (((uintptr_t)sp & (_LONG_LONG_ALIGNMENT - 1)) &&
            curthread->ul_misaligned == 0)
                return (EINVAL);

        return (0);
}

#pragma weak _sema_destroy = sema_destroy
int
sema_destroy(sema_t *sp)
{
        sp->magic = 0;
        tdb_sync_obj_deregister(sp);
        return (0);
}

static int
sema_wait_impl(sema_t *sp, timespec_t *tsp)
{
        lwp_sema_t *lsp = (lwp_sema_t *)sp;
        ulwp_t *self = curthread;
        uberdata_t *udp = self->ul_uberdata;
        tdb_sema_stats_t *ssp = SEMA_STATS(sp, udp);
        hrtime_t begin_sleep = 0;
        uint_t count;
        int error = 0;

        /*
         * All variations of sema_wait() are cancellation points.
         */
        _cancelon();

        if (ssp)
                tdb_incr(ssp->sema_wait);

        self->ul_sp = stkptr();
        self->ul_wchan = lsp;
        if (__td_event_report(self, TD_SLEEP, udp)) {
                self->ul_td_evbuf.eventnum = TD_SLEEP;
                self->ul_td_evbuf.eventdata = lsp;
                tdb_event(TD_SLEEP, udp);
        }
        /* just a guess, but it looks like we will sleep */
        if (ssp && lsp->count == 0) {
                begin_sleep = gethrtime();
                if (lsp->count == 0)    /* still looks like sleep */
                        tdb_incr(ssp->sema_wait_sleep);
                else                    /* we changed our mind */
                        begin_sleep = 0;
        }

        if (lsp->type == USYNC_PROCESS) {               /* kernel-level */
                set_parking_flag(self, 1);
                if (self->ul_cursig != 0 ||
                    (self->ul_cancelable && self->ul_cancel_pending))
                        set_parking_flag(self, 0);
                /* the kernel always does FIFO queueing */
                error = ___lwp_sema_timedwait(lsp, tsp, 1);
                set_parking_flag(self, 0);
        } else if (!udp->uberflags.uf_mt &&             /* single threaded */
            lsp->count != 0) {                          /* and non-blocking */
                /*
                 * Since we are single-threaded, we don't need the
                 * protection of queue_lock().  However, we do need
                 * to block signals while modifying the count.
                 */
                sigoff(self);
                lsp->count--;
                sigon(self);
        } else {                                /* multithreaded or blocking */
                queue_head_t *qp;
                ulwp_t *ulwp;
                lwpid_t lwpid = 0;

                qp = queue_lock(lsp, CV);
                while (error == 0 && lsp->count == 0) {
                        /*
                         * SUSV3 requires FIFO queueing for semaphores,
                         * at least for SCHED_FIFO and SCHED_RR scheduling.
                         */
                        enqueue(qp, self, 1);
                        lsp->sema_waiters = 1;
                        set_parking_flag(self, 1);
                        queue_unlock(qp);
                        /*
                         * We may have received SIGCANCEL before we
                         * called queue_lock().  If so and we are
                         * cancelable we should return EINTR.
                         */
                        if (self->ul_cursig != 0 ||
                            (self->ul_cancelable && self->ul_cancel_pending))
                                set_parking_flag(self, 0);
                        error = __lwp_park(tsp, 0);
                        set_parking_flag(self, 0);
                        qp = queue_lock(lsp, CV);
                        if (self->ul_sleepq)    /* timeout or spurious wakeup */
                                lsp->sema_waiters = dequeue_self(qp);
                }
                if (error == 0)
                        lsp->count--;
                if (lsp->count != 0 && lsp->sema_waiters) {
                        int more;
                        if ((ulwp = dequeue(qp, &more)) != NULL) {
                                no_preempt(self);
                                lwpid = ulwp->ul_lwpid;
                        }
                        lsp->sema_waiters = more;
                }
                queue_unlock(qp);
                if (lwpid) {
                        (void) __lwp_unpark(lwpid);
                        preempt(self);
                }
        }

        self->ul_wchan = NULL;
        self->ul_sp = 0;
        if (ssp) {
                if (error == 0) {
                        /* we just decremented the count */
                        count = lsp->count;
                        if (ssp->sema_min_count > count)
                                ssp->sema_min_count = count;
                }
                if (begin_sleep)
                        ssp->sema_wait_sleep_time += gethrtime() - begin_sleep;
        }

        if (error == EINTR)
                _canceloff();
        else
                _canceloff_nocancel();
        return (error);
}

#pragma weak _sema_wait = sema_wait
int
sema_wait(sema_t *sp)
{
        ASSERT(!curthread->ul_critical || curthread->ul_bindflags);
        return (sema_wait_impl(sp, NULL));
}

/*
 * sema_relcockwait() and sema_clockwait() are currently only internal to libc
 * to aid with implementing the POSIX versions of these functions.
 */
int
sema_relclockwait(sema_t *sp, clockid_t clock, const timespec_t *reltime)
{
        timespec_t tslocal = *reltime;

        ASSERT(!curthread->ul_critical || curthread->ul_bindflags);
        switch (clock) {
        case CLOCK_REALTIME:
        case CLOCK_HIGHRES:
                break;
        default:
                return (EINVAL);
        }
        return (sema_wait_impl(sp, &tslocal));
}

int
sema_clockwait(sema_t *sp, clockid_t clock, const timespec_t *abstime)
{
        timespec_t tslocal;

        ASSERT(!curthread->ul_critical || curthread->ul_bindflags);
        switch (clock) {
        case CLOCK_REALTIME:
        case CLOCK_HIGHRES:
                break;
        default:
                return (EINVAL);
        }
        abstime_to_reltime(clock, abstime, &tslocal);
        return (sema_wait_impl(sp, &tslocal));
}

int
sema_reltimedwait(sema_t *sp, const timespec_t *reltime)
{
        return (sema_relclockwait(sp, CLOCK_REALTIME, reltime));
}

int
sema_timedwait(sema_t *sp, const timespec_t *abstime)
{
        return (sema_clockwait(sp, CLOCK_REALTIME, abstime));
}

#pragma weak _sema_trywait = sema_trywait
int
sema_trywait(sema_t *sp)
{
        lwp_sema_t *lsp = (lwp_sema_t *)sp;
        ulwp_t *self = curthread;
        uberdata_t *udp = self->ul_uberdata;
        tdb_sema_stats_t *ssp = SEMA_STATS(sp, udp);
        uint_t count;
        int error = 0;

        ASSERT(!curthread->ul_critical || curthread->ul_bindflags);

        if (ssp)
                tdb_incr(ssp->sema_trywait);

        if (lsp->type == USYNC_PROCESS) {       /* kernel-level */
                error = _lwp_sema_trywait(lsp);
        } else if (!udp->uberflags.uf_mt) {     /* single threaded */
                sigoff(self);
                if (lsp->count == 0)
                        error = EBUSY;
                else
                        lsp->count--;
                sigon(self);
        } else {                                /* multithreaded */
                queue_head_t *qp;
                ulwp_t *ulwp;
                lwpid_t lwpid = 0;

                qp = queue_lock(lsp, CV);
                if (lsp->count == 0)
                        error = EBUSY;
                else if (--lsp->count != 0 && lsp->sema_waiters) {
                        int more;
                        if ((ulwp = dequeue(qp, &more)) != NULL) {
                                no_preempt(self);
                                lwpid = ulwp->ul_lwpid;
                        }
                        lsp->sema_waiters = more;
                }
                queue_unlock(qp);
                if (lwpid) {
                        (void) __lwp_unpark(lwpid);
                        preempt(self);
                }
        }

        if (error == 0) {
                if (ssp) {
                        /* we just decremented the count */
                        count = lsp->count;
                        if (ssp->sema_min_count > count)
                                ssp->sema_min_count = count;
                }
        } else {
                if (ssp)
                        tdb_incr(ssp->sema_trywait_fail);
                if (__td_event_report(self, TD_LOCK_TRY, udp)) {
                        self->ul_td_evbuf.eventnum = TD_LOCK_TRY;
                        tdb_event(TD_LOCK_TRY, udp);
                }
        }

        return (error);
}

#pragma weak _sema_post = sema_post
int
sema_post(sema_t *sp)
{
        lwp_sema_t *lsp = (lwp_sema_t *)sp;
        ulwp_t *self = curthread;
        uberdata_t *udp = self->ul_uberdata;
        tdb_sema_stats_t *ssp = SEMA_STATS(sp, udp);
        uint_t count;
        int error = 0;

        if (ssp)
                tdb_incr(ssp->sema_post);
        if (_semvaluemax == 0)
                _semvaluemax = (uint32_t)_sysconf(_SC_SEM_VALUE_MAX);

        if (lsp->type == USYNC_PROCESS) {       /* kernel-level */
                error = _lwp_sema_post(lsp);
        } else if (!udp->uberflags.uf_mt) {     /* single threaded */
                sigoff(self);
                if (lsp->count >= _semvaluemax)
                        error = EOVERFLOW;
                else
                        lsp->count++;
                sigon(self);
        } else {                                /* multithreaded */
                queue_head_t *qp;
                ulwp_t *ulwp;
                lwpid_t lwpid = 0;

                qp = queue_lock(lsp, CV);
                if (lsp->count >= _semvaluemax)
                        error = EOVERFLOW;
                else if (lsp->count++ == 0 && lsp->sema_waiters) {
                        int more;
                        if ((ulwp = dequeue(qp, &more)) != NULL) {
                                no_preempt(self);
                                lwpid = ulwp->ul_lwpid;
                        }
                        lsp->sema_waiters = more;
                }
                queue_unlock(qp);
                if (lwpid) {
                        (void) __lwp_unpark(lwpid);
                        preempt(self);
                }
        }

        if (error == 0) {
                if (ssp) {
                        /* we just incremented the count */
                        count = lsp->count;
                        if (ssp->sema_max_count < count)
                                ssp->sema_max_count = count;
                }
        }

        return (error);
}