/*
 * 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.
 */


/*
 * rseq implementation
 */

#include <sys/usb/clients/usbser/usbser_rseq.h>

#ifdef _KERNEL
#include <sys/debug.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
static long rseq_random();
#define random  rseq_random
#else
#include <assert.h>
#define ASSERT  assert
#include <stdlib.h>
#endif


/*ARGSUSED*/
static int
rseq_do_common(rseq_t *rseq, int num, uintptr_t arg, int flags, int fail_err,
                uintptr_t fail_num)
{
        int             i;
        rseq_step_t     *s;
        int             rval = RSEQ_OK;

        for (i = 0; i < num; i++) {
                s = &rseq[i].r_do;

                if (s->s_func == NULL) {
                        continue;
                }
                s->s_rval = (i != fail_num) ? s->s_func(arg) : fail_err;
                rval = (s->s_cb) ? (s->s_cb(rseq, i, arg)) : RSEQ_OK;

                if (rval == RSEQ_UNDO) {
                        (void) rseq_undo(rseq, i, arg, flags);
                        break;
                } else if (rval == RSEQ_ABORT) {
                        break;
                }
                ASSERT(rval == RSEQ_OK);
        }
        return (rval);
}


/*ARGSUSED*/
static int
rseq_undo_common(rseq_t *rseq, int num, uintptr_t arg, int flags, int fail_err,
                uintptr_t fail_num)
{
        int             i;
        rseq_step_t     *s;
        int             rval = RSEQ_OK;

        for (i = num - 1; i >= 0; i--) {
                s = &rseq[i].r_undo;

                if (s->s_func == NULL) {
                        continue;
                }
                s->s_rval = (i != fail_num) ? s->s_func(arg) : fail_err;
                rval = (s->s_cb) ? (s->s_cb(rseq, i, arg)) : RSEQ_OK;

                if (rval == RSEQ_ABORT) {
                        break;
                }
                ASSERT(rval == RSEQ_OK);
        }
        return (rval);
}


int
rseq_do(rseq_t *rseq, int num, uintptr_t arg, int flags)
{
        return (rseq_do_common(rseq, num, arg, flags, 0, -1));
}


int
rseq_undo(rseq_t *rseq, int num, uintptr_t arg, int flags)
{
        return (rseq_undo_common(rseq, num, arg, flags, 0, -1));
}

#ifdef DEBUG

#ifndef __lock_lint

static int
rseq_debug(rseq_t *rseq, int num, uintptr_t arg, int flags, int scenario,
                uintptr_t sarg1, uintptr_t sarg2,
                int (*func)(rseq_t *, int, uintptr_t, int, int, uintptr_t))
{
        int     rnd, rval = RSEQ_OK, i;

        switch (scenario) {
        case RSEQ_DBG_FAIL_ONE:
                rval = func(rseq, num, arg, flags, sarg1, sarg2);
                break;
        case RSEQ_DBG_FAIL_ONE_RANDOM:
                rnd = random() % num;
                rval = func(rseq, num, arg, flags, sarg1, rnd);
                break;
        case RSEQ_DBG_FAIL_ONEBYONE:
                for (i = 0; i < num; i++) {
                        rval = func(rseq, num, arg, flags, sarg1, i);
                        /*
                         * when aborted, the undo path is not executed, so we
                         * can't continue without the risk of resource leakage.
                         */
                        if (rval == RSEQ_ABORT) {
                                break;
                        }
                }
                break;
        default:
                ASSERT(!"rseq_debug: incorrect debug scenario");
                rval = RSEQ_ABORT;
        }
        return (rval);
}


int
rseq_do_debug(rseq_t *rseq, int num, uintptr_t arg, int flags, int scenario,
                uintptr_t sarg1, uintptr_t sarg2)
{
        return (rseq_debug(rseq, num, arg, flags, scenario, sarg1, sarg2,
            rseq_do_common));
}


int
rseq_undo_debug(rseq_t *rseq, int num, uintptr_t arg, int flags, int scenario,
                uintptr_t sarg1, uintptr_t sarg2)
{
        return (rseq_debug(rseq, num, arg, flags, scenario, sarg1, sarg2,
            rseq_undo_common));
}

#ifdef _KERNEL
static long
rseq_random()
{
        return (ddi_get_lbolt());
}
#endif /* _KERNEL */

#endif /* __lock_lint */

#endif /* DEBUG */