1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
|
// SPDX-License-Identifier: GPL-2.0
// KUnit tests for the SPI core DMA mapping error paths.
//
// A mapping error must clear all SG tables and *_sg_mapped flags while
// cur_{tx,rx}_dma_dev identify the devices used for the attempted mapping.
// Zero-length transfers make sg_alloc_table() fail with -EINVAL, providing
// deterministic failure injection without test hooks.
#include <kunit/device.h>
#include <kunit/test.h>
#include <linux/dma-mapping.h>
#include <linux/limits.h>
#include <linux/spi/spi.h>
#include "../internals.h"
MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING");
#define SPI_DMA_TEST_LEN 256
#define SPI_DMA_TEST_XFERS 2
struct spi_dma_test_ctx {
struct spi_controller *ctlr;
struct spi_device *spi;
struct device *dma_dev;
struct device *stale_dma_dev;
struct spi_transfer xfer[SPI_DMA_TEST_XFERS];
struct spi_message msg;
void *buf[SPI_DMA_TEST_XFERS * 2];
};
static bool spi_dma_test_can_dma(struct spi_controller *ctlr,
struct spi_device *spi,
struct spi_transfer *xfer)
{
/* Opt every transfer into the core DMA mapping path. */
return true;
}
/*
* A bare controller is sufficient because the mapping helpers do not
* dereference ctlr->dev. With dma_tx and dma_rx unset, both directions use
* dma_map_dev, so the controller need not be registered.
*/
static struct spi_dma_test_ctx *spi_dma_test_ctx_new(struct kunit *test)
{
struct spi_dma_test_ctx *ctx;
ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
ctx->dma_dev = kunit_device_register(test, "spi-dma-error-path");
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->dma_dev);
ctx->stale_dma_dev =
kunit_device_register(test, "spi-dma-stale-device");
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->stale_dma_dev);
/* Keep both devices valid if an assertion aborts the test. */
KUNIT_ASSERT_EQ(test, 0,
dma_coerce_mask_and_coherent(ctx->dma_dev,
DMA_BIT_MASK(64)));
KUNIT_ASSERT_EQ(test, 0,
dma_coerce_mask_and_coherent(ctx->stale_dma_dev,
DMA_BIT_MASK(64)));
ctx->ctlr = kunit_kzalloc(test, sizeof(*ctx->ctlr), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->ctlr);
ctx->spi = kunit_kzalloc(test, sizeof(*ctx->spi), GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->spi);
ctx->ctlr->can_dma = spi_dma_test_can_dma;
ctx->ctlr->dma_map_dev = ctx->dma_dev;
/* Normally initialized by spi_register_controller(). */
ctx->ctlr->max_dma_len = INT_MAX;
ctx->spi->controller = ctx->ctlr;
spi_message_init(&ctx->msg);
ctx->msg.spi = ctx->spi;
return ctx;
}
static void *spi_dma_test_buf(struct kunit *test, struct spi_dma_test_ctx *ctx,
unsigned int slot)
{
KUNIT_ASSERT_LT(test, slot, ARRAY_SIZE(ctx->buf));
ctx->buf[slot] = kunit_kzalloc(test, SPI_DMA_TEST_LEN, GFP_KERNEL);
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->buf[slot]);
return ctx->buf[slot];
}
/*
* Emulate DMA devices retained from an earlier message. Using valid devices
* also lets the unfixed path reach the assertions instead of dereferencing
* NULL during cleanup.
*/
static void spi_dma_test_pin_stale_dma_devs(struct spi_dma_test_ctx *ctx)
{
ctx->ctlr->cur_tx_dma_dev = ctx->stale_dma_dev;
ctx->ctlr->cur_rx_dma_dev = ctx->stale_dma_dev;
}
static void spi_dma_test_assert_dma_devs_published(struct kunit *test,
struct spi_dma_test_ctx *ctx)
{
KUNIT_ASSERT_PTR_EQ(test, ctx->ctlr->cur_tx_dma_dev, ctx->dma_dev);
KUNIT_ASSERT_PTR_EQ(test, ctx->ctlr->cur_rx_dma_dev, ctx->dma_dev);
}
static void spi_dma_test_assert_nothing_mapped(struct kunit *test,
struct spi_dma_test_ctx *ctx,
unsigned int nr_xfers)
{
unsigned int i;
for (i = 0; i < nr_xfers; i++) {
KUNIT_ASSERT_FALSE_MSG(test, ctx->xfer[i].tx_sg_mapped,
"xfer[%u] still claims a TX mapping after __spi_map_msg() failed",
i);
KUNIT_ASSERT_FALSE_MSG(test, ctx->xfer[i].rx_sg_mapped,
"xfer[%u] still claims an RX mapping after __spi_map_msg() failed",
i);
KUNIT_EXPECT_NULL(test, ctx->xfer[i].tx_sg.sgl);
KUNIT_EXPECT_EQ(test, ctx->xfer[i].tx_sg.orig_nents, 0U);
KUNIT_EXPECT_EQ(test, ctx->xfer[i].tx_sg.nents, 0U);
KUNIT_EXPECT_NULL(test, ctx->xfer[i].rx_sg.sgl);
KUNIT_EXPECT_EQ(test, ctx->xfer[i].rx_sg.orig_nents, 0U);
KUNIT_EXPECT_EQ(test, ctx->xfer[i].rx_sg.nents, 0U);
}
}
/*
* xfer0 maps TX and RX; zero-length xfer1 then fails its TX mapping.
* The failure must unwind xfer0 and update cur_*_dma_dev.
*/
static void spi_dma_later_tx_fail_rolls_back_earlier(struct kunit *test)
{
struct spi_dma_test_ctx *ctx = spi_dma_test_ctx_new(test);
int ret;
ctx->xfer[0].tx_buf = spi_dma_test_buf(test, ctx, 0);
ctx->xfer[0].rx_buf = spi_dma_test_buf(test, ctx, 1);
ctx->xfer[0].len = SPI_DMA_TEST_LEN;
ctx->xfer[1].tx_buf = spi_dma_test_buf(test, ctx, 2);
ctx->xfer[1].rx_buf = NULL;
ctx->xfer[1].len = 0; /* forces -EINVAL */
spi_message_add_tail(&ctx->xfer[0], &ctx->msg);
spi_message_add_tail(&ctx->xfer[1], &ctx->msg);
spi_dma_test_pin_stale_dma_devs(ctx);
ret = __spi_map_msg(ctx->ctlr, &ctx->msg);
KUNIT_ASSERT_EQ(test, ret, -EINVAL);
spi_dma_test_assert_dma_devs_published(test, ctx);
spi_dma_test_assert_nothing_mapped(test, ctx, SPI_DMA_TEST_XFERS);
KUNIT_EXPECT_EQ(test, 0, __spi_unmap_msg(ctx->ctlr, &ctx->msg));
}
/*
* xfer0 maps TX and RX; zero-length RX-only xfer1 then fails.
* The failure must unwind xfer0 without leaving either mapping flag set.
*/
static void spi_dma_later_rx_fail_rolls_back_earlier(struct kunit *test)
{
struct spi_dma_test_ctx *ctx = spi_dma_test_ctx_new(test);
int ret;
ctx->xfer[0].tx_buf = spi_dma_test_buf(test, ctx, 0);
ctx->xfer[0].rx_buf = spi_dma_test_buf(test, ctx, 1);
ctx->xfer[0].len = SPI_DMA_TEST_LEN;
ctx->xfer[1].tx_buf = NULL;
ctx->xfer[1].rx_buf = spi_dma_test_buf(test, ctx, 2);
ctx->xfer[1].len = 0; /* forces -EINVAL */
spi_message_add_tail(&ctx->xfer[0], &ctx->msg);
spi_message_add_tail(&ctx->xfer[1], &ctx->msg);
spi_dma_test_pin_stale_dma_devs(ctx);
ret = __spi_map_msg(ctx->ctlr, &ctx->msg);
KUNIT_ASSERT_EQ(test, ret, -EINVAL);
spi_dma_test_assert_dma_devs_published(test, ctx);
spi_dma_test_assert_nothing_mapped(test, ctx, SPI_DMA_TEST_XFERS);
KUNIT_EXPECT_EQ(test, 0, __spi_unmap_msg(ctx->ctlr, &ctx->msg));
}
/* Ensure the error unwind does not affect successful mappings. */
static void spi_dma_map_success_publishes_dma_devs(struct kunit *test)
{
struct spi_dma_test_ctx *ctx = spi_dma_test_ctx_new(test);
int ret;
ctx->xfer[0].tx_buf = spi_dma_test_buf(test, ctx, 0);
ctx->xfer[0].rx_buf = spi_dma_test_buf(test, ctx, 1);
ctx->xfer[0].len = SPI_DMA_TEST_LEN;
spi_message_add_tail(&ctx->xfer[0], &ctx->msg);
ret = __spi_map_msg(ctx->ctlr, &ctx->msg);
KUNIT_ASSERT_EQ(test, ret, 0);
KUNIT_EXPECT_TRUE(test, ctx->xfer[0].tx_sg_mapped);
KUNIT_EXPECT_TRUE(test, ctx->xfer[0].rx_sg_mapped);
KUNIT_EXPECT_PTR_EQ(test, ctx->ctlr->cur_tx_dma_dev, ctx->dma_dev);
KUNIT_EXPECT_PTR_EQ(test, ctx->ctlr->cur_rx_dma_dev, ctx->dma_dev);
KUNIT_EXPECT_EQ(test, 0, __spi_unmap_msg(ctx->ctlr, &ctx->msg));
KUNIT_EXPECT_FALSE(test, ctx->xfer[0].tx_sg_mapped);
KUNIT_EXPECT_FALSE(test, ctx->xfer[0].rx_sg_mapped);
KUNIT_EXPECT_NULL(test, ctx->xfer[0].tx_sg.sgl);
KUNIT_EXPECT_NULL(test, ctx->xfer[0].rx_sg.sgl);
}
/* A transfer without buffers requires no DMA mapping. */
static void spi_dma_map_nothing_is_success(struct kunit *test)
{
struct spi_dma_test_ctx *ctx = spi_dma_test_ctx_new(test);
int ret;
ctx->xfer[0].tx_buf = NULL;
ctx->xfer[0].rx_buf = NULL;
ctx->xfer[0].len = SPI_DMA_TEST_LEN;
spi_message_add_tail(&ctx->xfer[0], &ctx->msg);
ret = __spi_map_msg(ctx->ctlr, &ctx->msg);
KUNIT_EXPECT_EQ(test, ret, 0);
spi_dma_test_assert_nothing_mapped(test, ctx, 1);
}
static struct kunit_case spi_dma_error_path_cases[] = {
KUNIT_CASE(spi_dma_later_tx_fail_rolls_back_earlier),
KUNIT_CASE(spi_dma_later_rx_fail_rolls_back_earlier),
KUNIT_CASE(spi_dma_map_success_publishes_dma_devs),
KUNIT_CASE(spi_dma_map_nothing_is_success),
{}
};
static struct kunit_suite spi_dma_error_path_suite = {
.name = "spi_dma",
.test_cases = spi_dma_error_path_cases,
};
kunit_test_suite(spi_dma_error_path_suite);
MODULE_DESCRIPTION("KUnit tests for SPI core DMA mapping");
MODULE_LICENSE("GPL");
|
