// SPDX-License-Identifier: GPL-2.0
/*
 * KUnit tests for scsi_lib.c.
 *
 * Copyright (C) 2023, Oracle Corporation
 */
#include <kunit/test.h>

#include <scsi/scsi_proto.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>

#define SCSI_LIB_TEST_MAX_ALLOWED 3
#define SCSI_LIB_TEST_TOTAL_MAX_ALLOWED 5

static void scsi_lib_test_multiple_sense(struct kunit *test)
{
        struct scsi_failure multiple_sense_failure_defs[] = {
                {
                        .sense = DATA_PROTECT,
                        .asc = 0x1,
                        .ascq = 0x1,
                        .result = SAM_STAT_CHECK_CONDITION,
                },
                {
                        .sense = UNIT_ATTENTION,
                        .asc = 0x11,
                        .ascq = 0x0,
                        .allowed = SCSI_LIB_TEST_MAX_ALLOWED,
                        .result = SAM_STAT_CHECK_CONDITION,
                },
                {
                        .sense = NOT_READY,
                        .asc = 0x11,
                        .ascq = 0x22,
                        .allowed = SCSI_LIB_TEST_MAX_ALLOWED,
                        .result = SAM_STAT_CHECK_CONDITION,
                },
                {
                        .sense = ABORTED_COMMAND,
                        .asc = 0x11,
                        .ascq = SCMD_FAILURE_ASCQ_ANY,
                        .allowed = SCSI_LIB_TEST_MAX_ALLOWED,
                        .result = SAM_STAT_CHECK_CONDITION,
                },
                {
                        .sense = HARDWARE_ERROR,
                        .asc = SCMD_FAILURE_ASC_ANY,
                        .allowed = SCSI_LIB_TEST_MAX_ALLOWED,
                        .result = SAM_STAT_CHECK_CONDITION,
                },
                {
                        .sense = ILLEGAL_REQUEST,
                        .asc = 0x91,
                        .ascq = 0x36,
                        .allowed = SCSI_LIB_TEST_MAX_ALLOWED,
                        .result = SAM_STAT_CHECK_CONDITION,
                },
                {}
        };
        struct scsi_failures failures = {
                .failure_definitions = multiple_sense_failure_defs,
        };
        u8 sense[SCSI_SENSE_BUFFERSIZE] = {};
        struct scsi_cmnd sc = {
                .sense_buffer = sense,
        };
        int i;

        /* Success */
        sc.result = 0;
        KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
        KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, NULL));
        /* Command failed but caller did not pass in a failures array */
        scsi_build_sense(&sc, 0, ILLEGAL_REQUEST, 0x91, 0x36);
        KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, NULL));
        /* Match end of array */
        scsi_build_sense(&sc, 0, ILLEGAL_REQUEST, 0x91, 0x36);
        KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
        /* Basic match in array */
        scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x11, 0x0);
        KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
        /* No matching sense entry */
        scsi_build_sense(&sc, 0, MISCOMPARE, 0x11, 0x11);
        KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
        /* Match using SCMD_FAILURE_ASCQ_ANY */
        scsi_build_sense(&sc, 0, ABORTED_COMMAND, 0x11, 0x22);
        KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
        /* Fail to match */
        scsi_build_sense(&sc, 0, ABORTED_COMMAND, 0x22, 0x22);
        KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
        /* Match using SCMD_FAILURE_ASC_ANY */
        scsi_build_sense(&sc, 0, HARDWARE_ERROR, 0x11, 0x22);
        KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
        /* No matching status entry */
        sc.result = SAM_STAT_RESERVATION_CONFLICT;
        KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));

        /* Test hitting allowed limit */
        scsi_build_sense(&sc, 0, NOT_READY, 0x11, 0x22);
        for (i = 0; i < SCSI_LIB_TEST_MAX_ALLOWED; i++)
                KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc,
                                &failures));
        KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));

        /* reset retries so we can retest */
        failures.failure_definitions = multiple_sense_failure_defs;
        scsi_failures_reset_retries(&failures);

        /* Test no retries allowed */
        scsi_build_sense(&sc, 0, DATA_PROTECT, 0x1, 0x1);
        KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
}

static void scsi_lib_test_any_sense(struct kunit *test)
{
        struct scsi_failure any_sense_failure_defs[] = {
                {
                        .result = SCMD_FAILURE_SENSE_ANY,
                        .allowed = SCSI_LIB_TEST_MAX_ALLOWED,
                },
                {}
        };
        struct scsi_failures failures = {
                .failure_definitions = any_sense_failure_defs,
        };
        u8 sense[SCSI_SENSE_BUFFERSIZE] = {};
        struct scsi_cmnd sc = {
                .sense_buffer = sense,
        };

        /* Match using SCMD_FAILURE_SENSE_ANY */
        failures.failure_definitions = any_sense_failure_defs;
        scsi_build_sense(&sc, 0, MEDIUM_ERROR, 0x11, 0x22);
        KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
}

static void scsi_lib_test_host(struct kunit *test)
{
        struct scsi_failure retryable_host_failure_defs[] = {
                {
                        .result = DID_TRANSPORT_DISRUPTED << 16,
                        .allowed = SCSI_LIB_TEST_MAX_ALLOWED,
                },
                {
                        .result = DID_TIME_OUT << 16,
                        .allowed = SCSI_LIB_TEST_MAX_ALLOWED,
                },
                {}
        };
        struct scsi_failures failures = {
                .failure_definitions = retryable_host_failure_defs,
        };
        u8 sense[SCSI_SENSE_BUFFERSIZE] = {};
        struct scsi_cmnd sc = {
                .sense_buffer = sense,
        };

        /* No matching host byte entry */
        failures.failure_definitions = retryable_host_failure_defs;
        sc.result = DID_NO_CONNECT << 16;
        KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
        /* Matching host byte entry */
        sc.result = DID_TIME_OUT << 16;
        KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
}

static void scsi_lib_test_any_failure(struct kunit *test)
{
        struct scsi_failure any_failure_defs[] = {
                {
                        .result = SCMD_FAILURE_RESULT_ANY,
                        .allowed = SCSI_LIB_TEST_MAX_ALLOWED,
                },
                {}
        };
        struct scsi_failures failures = {
                .failure_definitions = any_failure_defs,
        };
        u8 sense[SCSI_SENSE_BUFFERSIZE] = {};
        struct scsi_cmnd sc = {
                .sense_buffer = sense,
        };

        /* Match SCMD_FAILURE_RESULT_ANY */
        failures.failure_definitions = any_failure_defs;
        sc.result = DID_TRANSPORT_FAILFAST << 16;
        KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
}

static void scsi_lib_test_any_status(struct kunit *test)
{
        struct scsi_failure any_status_failure_defs[] = {
                {
                        .result = SCMD_FAILURE_STAT_ANY,
                        .allowed = SCSI_LIB_TEST_MAX_ALLOWED,
                },
                {}
        };
        struct scsi_failures failures = {
                .failure_definitions = any_status_failure_defs,
        };
        u8 sense[SCSI_SENSE_BUFFERSIZE] = {};
        struct scsi_cmnd sc = {
                .sense_buffer = sense,
        };

        /* Test any status handling */
        failures.failure_definitions = any_status_failure_defs;
        sc.result = SAM_STAT_RESERVATION_CONFLICT;
        KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
}

static void scsi_lib_test_total_allowed(struct kunit *test)
{
        struct scsi_failure total_allowed_defs[] = {
                {
                        .sense = UNIT_ATTENTION,
                        .asc = SCMD_FAILURE_ASC_ANY,
                        .ascq = SCMD_FAILURE_ASCQ_ANY,
                        .result = SAM_STAT_CHECK_CONDITION,
                },
                /* Fail all CCs except the UA above */
                {
                        .sense = SCMD_FAILURE_SENSE_ANY,
                        .result = SAM_STAT_CHECK_CONDITION,
                },
                /* Retry any other errors not listed above */
                {
                        .result = SCMD_FAILURE_RESULT_ANY,
                },
                {}
        };
        struct scsi_failures failures = {
                .failure_definitions = total_allowed_defs,
        };
        u8 sense[SCSI_SENSE_BUFFERSIZE] = {};
        struct scsi_cmnd sc = {
                .sense_buffer = sense,
        };
        int i;

        /* Test total_allowed */
        failures.failure_definitions = total_allowed_defs;
        scsi_failures_reset_retries(&failures);
        failures.total_allowed = SCSI_LIB_TEST_TOTAL_MAX_ALLOWED;

        scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x28, 0x0);
        for (i = 0; i < SCSI_LIB_TEST_TOTAL_MAX_ALLOWED; i++)
                /* Retry since we under the total_allowed limit */
                KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc,
                                &failures));
        sc.result = DID_TIME_OUT << 16;
        /* We have now hit the total_allowed limit so no more retries */
        KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
}

static void scsi_lib_test_mixed_total(struct kunit *test)
{
        struct scsi_failure mixed_total_defs[] = {
                {
                        .sense = UNIT_ATTENTION,
                        .asc = 0x28,
                        .result = SAM_STAT_CHECK_CONDITION,
                },
                {
                        .sense = UNIT_ATTENTION,
                        .asc = 0x29,
                        .result = SAM_STAT_CHECK_CONDITION,
                },
                {
                        .allowed = 1,
                        .result = DID_TIME_OUT << 16,
                },
                {}
        };
        u8 sense[SCSI_SENSE_BUFFERSIZE] = {};
        struct scsi_failures failures = {
                .failure_definitions = mixed_total_defs,
        };
        struct scsi_cmnd sc = {
                .sense_buffer = sense,
        };
        int i;

        /*
         * Test total_allowed when there is a mix of per failure allowed
         * and total_allowed limits.
         */
        failures.failure_definitions = mixed_total_defs;
        scsi_failures_reset_retries(&failures);
        failures.total_allowed = SCSI_LIB_TEST_TOTAL_MAX_ALLOWED;

        scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x28, 0x0);
        for (i = 0; i < SCSI_LIB_TEST_TOTAL_MAX_ALLOWED; i++)
                /* Retry since we under the total_allowed limit */
                KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc,
                                &failures));
        /* Do not retry since we are now over total_allowed limit */
        KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));

        scsi_failures_reset_retries(&failures);
        scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x28, 0x0);
        for (i = 0; i < SCSI_LIB_TEST_TOTAL_MAX_ALLOWED; i++)
                /* Retry since we under the total_allowed limit */
                KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc,
                                &failures));
        sc.result = DID_TIME_OUT << 16;
        /* Retry because this failure has a per failure limit */
        KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
        scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x29, 0x0);
        /* total_allowed is now hit so no more retries */
        KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
}

static void scsi_lib_test_check_passthough(struct kunit *test)
{
        scsi_lib_test_multiple_sense(test);
        scsi_lib_test_any_sense(test);
        scsi_lib_test_host(test);
        scsi_lib_test_any_failure(test);
        scsi_lib_test_any_status(test);
        scsi_lib_test_total_allowed(test);
        scsi_lib_test_mixed_total(test);
}

static struct kunit_case scsi_lib_test_cases[] = {
        KUNIT_CASE(scsi_lib_test_check_passthough),
        {}
};

static struct kunit_suite scsi_lib_test_suite = {
        .name = "scsi_lib",
        .test_cases = scsi_lib_test_cases,
};

kunit_test_suite(scsi_lib_test_suite);