scsi_lib_test.c

  1// SPDX-License-Identifier: GPL-2.0
  2/*
  3 * KUnit tests for scsi_lib.c.
  4 *
  5 * Copyright (C) 2023, Oracle Corporation
  6 */
  7#include <kunit/test.h>
  8
  9#include <scsi/scsi_proto.h>
 10#include <scsi/scsi_cmnd.h>
 11#include <scsi/scsi_device.h>
 12
 13#define SCSI_LIB_TEST_MAX_ALLOWED 3
 14#define SCSI_LIB_TEST_TOTAL_MAX_ALLOWED 5
 15
 16static void scsi_lib_test_multiple_sense(struct kunit *test)
 17{
 18	struct scsi_failure multiple_sense_failure_defs[] = {
 19		{
 20			.sense = DATA_PROTECT,
 21			.asc = 0x1,
 22			.ascq = 0x1,
 23			.result = SAM_STAT_CHECK_CONDITION,
 24		},
 25		{
 26			.sense = UNIT_ATTENTION,
 27			.asc = 0x11,
 28			.ascq = 0x0,
 29			.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
 30			.result = SAM_STAT_CHECK_CONDITION,
 31		},
 32		{
 33			.sense = NOT_READY,
 34			.asc = 0x11,
 35			.ascq = 0x22,
 36			.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
 37			.result = SAM_STAT_CHECK_CONDITION,
 38		},
 39		{
 40			.sense = ABORTED_COMMAND,
 41			.asc = 0x11,
 42			.ascq = SCMD_FAILURE_ASCQ_ANY,
 43			.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
 44			.result = SAM_STAT_CHECK_CONDITION,
 45		},
 46		{
 47			.sense = HARDWARE_ERROR,
 48			.asc = SCMD_FAILURE_ASC_ANY,
 49			.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
 50			.result = SAM_STAT_CHECK_CONDITION,
 51		},
 52		{
 53			.sense = ILLEGAL_REQUEST,
 54			.asc = 0x91,
 55			.ascq = 0x36,
 56			.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
 57			.result = SAM_STAT_CHECK_CONDITION,
 58		},
 59		{}
 60	};
 61	struct scsi_failures failures = {
 62		.failure_definitions = multiple_sense_failure_defs,
 63	};
 64	u8 sense[SCSI_SENSE_BUFFERSIZE] = {};
 65	struct scsi_cmnd sc = {
 66		.sense_buffer = sense,
 67	};
 68	int i;
 69
 70	/* Success */
 71	sc.result = 0;
 72	KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
 73	KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, NULL));
 74	/* Command failed but caller did not pass in a failures array */
 75	scsi_build_sense(&sc, 0, ILLEGAL_REQUEST, 0x91, 0x36);
 76	KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, NULL));
 77	/* Match end of array */
 78	scsi_build_sense(&sc, 0, ILLEGAL_REQUEST, 0x91, 0x36);
 79	KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
 80	/* Basic match in array */
 81	scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x11, 0x0);
 82	KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
 83	/* No matching sense entry */
 84	scsi_build_sense(&sc, 0, MISCOMPARE, 0x11, 0x11);
 85	KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
 86	/* Match using SCMD_FAILURE_ASCQ_ANY */
 87	scsi_build_sense(&sc, 0, ABORTED_COMMAND, 0x11, 0x22);
 88	KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
 89	/* Fail to match */
 90	scsi_build_sense(&sc, 0, ABORTED_COMMAND, 0x22, 0x22);
 91	KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
 92	/* Match using SCMD_FAILURE_ASC_ANY */
 93	scsi_build_sense(&sc, 0, HARDWARE_ERROR, 0x11, 0x22);
 94	KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
 95	/* No matching status entry */
 96	sc.result = SAM_STAT_RESERVATION_CONFLICT;
 97	KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
 98
 99	/* Test hitting allowed limit */
100	scsi_build_sense(&sc, 0, NOT_READY, 0x11, 0x22);
101	for (i = 0; i < SCSI_LIB_TEST_MAX_ALLOWED; i++)
102		KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc,
103				&failures));
104	KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
105
106	/* reset retries so we can retest */
107	failures.failure_definitions = multiple_sense_failure_defs;
108	scsi_failures_reset_retries(&failures);
109
110	/* Test no retries allowed */
111	scsi_build_sense(&sc, 0, DATA_PROTECT, 0x1, 0x1);
112	KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
113}
114
115static void scsi_lib_test_any_sense(struct kunit *test)
116{
117	struct scsi_failure any_sense_failure_defs[] = {
118		{
119			.result = SCMD_FAILURE_SENSE_ANY,
120			.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
121		},
122		{}
123	};
124	struct scsi_failures failures = {
125		.failure_definitions = any_sense_failure_defs,
126	};
127	u8 sense[SCSI_SENSE_BUFFERSIZE] = {};
128	struct scsi_cmnd sc = {
129		.sense_buffer = sense,
130	};
131
132	/* Match using SCMD_FAILURE_SENSE_ANY */
133	failures.failure_definitions = any_sense_failure_defs;
134	scsi_build_sense(&sc, 0, MEDIUM_ERROR, 0x11, 0x22);
135	KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
136}
137
138static void scsi_lib_test_host(struct kunit *test)
139{
140	struct scsi_failure retryable_host_failure_defs[] = {
141		{
142			.result = DID_TRANSPORT_DISRUPTED << 16,
143			.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
144		},
145		{
146			.result = DID_TIME_OUT << 16,
147			.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
148		},
149		{}
150	};
151	struct scsi_failures failures = {
152		.failure_definitions = retryable_host_failure_defs,
153	};
154	u8 sense[SCSI_SENSE_BUFFERSIZE] = {};
155	struct scsi_cmnd sc = {
156		.sense_buffer = sense,
157	};
158
159	/* No matching host byte entry */
160	failures.failure_definitions = retryable_host_failure_defs;
161	sc.result = DID_NO_CONNECT << 16;
162	KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
163	/* Matching host byte entry */
164	sc.result = DID_TIME_OUT << 16;
165	KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
166}
167
168static void scsi_lib_test_any_failure(struct kunit *test)
169{
170	struct scsi_failure any_failure_defs[] = {
171		{
172			.result = SCMD_FAILURE_RESULT_ANY,
173			.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
174		},
175		{}
176	};
177	struct scsi_failures failures = {
178		.failure_definitions = any_failure_defs,
179	};
180	u8 sense[SCSI_SENSE_BUFFERSIZE] = {};
181	struct scsi_cmnd sc = {
182		.sense_buffer = sense,
183	};
184
185	/* Match SCMD_FAILURE_RESULT_ANY */
186	failures.failure_definitions = any_failure_defs;
187	sc.result = DID_TRANSPORT_FAILFAST << 16;
188	KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
189}
190
191static void scsi_lib_test_any_status(struct kunit *test)
192{
193	struct scsi_failure any_status_failure_defs[] = {
194		{
195			.result = SCMD_FAILURE_STAT_ANY,
196			.allowed = SCSI_LIB_TEST_MAX_ALLOWED,
197		},
198		{}
199	};
200	struct scsi_failures failures = {
201		.failure_definitions = any_status_failure_defs,
202	};
203	u8 sense[SCSI_SENSE_BUFFERSIZE] = {};
204	struct scsi_cmnd sc = {
205		.sense_buffer = sense,
206	};
207
208	/* Test any status handling */
209	failures.failure_definitions = any_status_failure_defs;
210	sc.result = SAM_STAT_RESERVATION_CONFLICT;
211	KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
212}
213
214static void scsi_lib_test_total_allowed(struct kunit *test)
215{
216	struct scsi_failure total_allowed_defs[] = {
217		{
218			.sense = UNIT_ATTENTION,
219			.asc = SCMD_FAILURE_ASC_ANY,
220			.ascq = SCMD_FAILURE_ASCQ_ANY,
221			.result = SAM_STAT_CHECK_CONDITION,
222		},
223		/* Fail all CCs except the UA above */
224		{
225			.sense = SCMD_FAILURE_SENSE_ANY,
226			.result = SAM_STAT_CHECK_CONDITION,
227		},
228		/* Retry any other errors not listed above */
229		{
230			.result = SCMD_FAILURE_RESULT_ANY,
231		},
232		{}
233	};
234	struct scsi_failures failures = {
235		.failure_definitions = total_allowed_defs,
236	};
237	u8 sense[SCSI_SENSE_BUFFERSIZE] = {};
238	struct scsi_cmnd sc = {
239		.sense_buffer = sense,
240	};
241	int i;
242
243	/* Test total_allowed */
244	failures.failure_definitions = total_allowed_defs;
245	scsi_failures_reset_retries(&failures);
246	failures.total_allowed = SCSI_LIB_TEST_TOTAL_MAX_ALLOWED;
247
248	scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x28, 0x0);
249	for (i = 0; i < SCSI_LIB_TEST_TOTAL_MAX_ALLOWED; i++)
250		/* Retry since we under the total_allowed limit */
251		KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc,
252				&failures));
253	sc.result = DID_TIME_OUT << 16;
254	/* We have now hit the total_allowed limit so no more retries */
255	KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
256}
257
258static void scsi_lib_test_mixed_total(struct kunit *test)
259{
260	struct scsi_failure mixed_total_defs[] = {
261		{
262			.sense = UNIT_ATTENTION,
263			.asc = 0x28,
264			.result = SAM_STAT_CHECK_CONDITION,
265		},
266		{
267			.sense = UNIT_ATTENTION,
268			.asc = 0x29,
269			.result = SAM_STAT_CHECK_CONDITION,
270		},
271		{
272			.allowed = 1,
273			.result = DID_TIME_OUT << 16,
274		},
275		{}
276	};
277	u8 sense[SCSI_SENSE_BUFFERSIZE] = {};
278	struct scsi_failures failures = {
279		.failure_definitions = mixed_total_defs,
280	};
281	struct scsi_cmnd sc = {
282		.sense_buffer = sense,
283	};
284	int i;
285
286	/*
287	 * Test total_allowed when there is a mix of per failure allowed
288	 * and total_allowed limits.
289	 */
290	failures.failure_definitions = mixed_total_defs;
291	scsi_failures_reset_retries(&failures);
292	failures.total_allowed = SCSI_LIB_TEST_TOTAL_MAX_ALLOWED;
293
294	scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x28, 0x0);
295	for (i = 0; i < SCSI_LIB_TEST_TOTAL_MAX_ALLOWED; i++)
296		/* Retry since we under the total_allowed limit */
297		KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc,
298				&failures));
299	/* Do not retry since we are now over total_allowed limit */
300	KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
301
302	scsi_failures_reset_retries(&failures);
303	scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x28, 0x0);
304	for (i = 0; i < SCSI_LIB_TEST_TOTAL_MAX_ALLOWED; i++)
305		/* Retry since we under the total_allowed limit */
306		KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc,
307				&failures));
308	sc.result = DID_TIME_OUT << 16;
309	/* Retry because this failure has a per failure limit */
310	KUNIT_EXPECT_EQ(test, -EAGAIN, scsi_check_passthrough(&sc, &failures));
311	scsi_build_sense(&sc, 0, UNIT_ATTENTION, 0x29, 0x0);
312	/* total_allowed is now hit so no more retries */
313	KUNIT_EXPECT_EQ(test, 0, scsi_check_passthrough(&sc, &failures));
314}
315
316static void scsi_lib_test_check_passthough(struct kunit *test)
317{
318	scsi_lib_test_multiple_sense(test);
319	scsi_lib_test_any_sense(test);
320	scsi_lib_test_host(test);
321	scsi_lib_test_any_failure(test);
322	scsi_lib_test_any_status(test);
323	scsi_lib_test_total_allowed(test);
324	scsi_lib_test_mixed_total(test);
325}
326
327static struct kunit_case scsi_lib_test_cases[] = {
328	KUNIT_CASE(scsi_lib_test_check_passthough),
329	{}
330};
331
332static struct kunit_suite scsi_lib_test_suite = {
333	.name = "scsi_lib",
334	.test_cases = scsi_lib_test_cases,
335};
336
337kunit_test_suite(scsi_lib_test_suite);