Skip to content

Commit ce57208

Browse files
horiagherbertx
horiag
authored and
herbertx
committed
crypto: caam - fix "failed to check map error" DMA warnings
Use dma_mapping_error for every dma_map_single / dma_map_page. Signed-off-by: Horia Geanta <[email protected]> Acked-by: Kim Phillips <[email protected]> Signed-off-by: Herbert Xu <[email protected]>
1 parent 71c65f7 commit ce57208

File tree

3 files changed

+163
-28
lines changed

3 files changed

+163
-28
lines changed

‎drivers/crypto/caam/caamalg.c

Lines changed: 31 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1313,8 +1313,13 @@ static struct aead_edesc *aead_edesc_alloc(struct aead_request *req,
13131313
DMA_FROM_DEVICE, dst_chained);
13141314
}
13151315

1316-
/* Check if data are contiguous */
13171316
iv_dma = dma_map_single(jrdev, req->iv, ivsize, DMA_TO_DEVICE);
1317+
if (dma_mapping_error(jrdev, iv_dma)) {
1318+
dev_err(jrdev, "unable to map IV\n");
1319+
return ERR_PTR(-ENOMEM);
1320+
}
1321+
1322+
/* Check if data are contiguous */
13181323
if (assoc_nents || sg_dma_address(req->assoc) + req->assoclen !=
13191324
iv_dma || src_nents || iv_dma + ivsize !=
13201325
sg_dma_address(req->src)) {
@@ -1369,6 +1374,10 @@ static struct aead_edesc *aead_edesc_alloc(struct aead_request *req,
13691374
}
13701375
edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
13711376
sec4_sg_bytes, DMA_TO_DEVICE);
1377+
if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) {
1378+
dev_err(jrdev, "unable to map S/G table\n");
1379+
return ERR_PTR(-ENOMEM);
1380+
}
13721381

13731382
return edesc;
13741383
}
@@ -1494,8 +1503,13 @@ static struct aead_edesc *aead_giv_edesc_alloc(struct aead_givcrypt_request
14941503
DMA_FROM_DEVICE, dst_chained);
14951504
}
14961505

1497-
/* Check if data are contiguous */
14981506
iv_dma = dma_map_single(jrdev, greq->giv, ivsize, DMA_TO_DEVICE);
1507+
if (dma_mapping_error(jrdev, iv_dma)) {
1508+
dev_err(jrdev, "unable to map IV\n");
1509+
return ERR_PTR(-ENOMEM);
1510+
}
1511+
1512+
/* Check if data are contiguous */
14991513
if (assoc_nents || sg_dma_address(req->assoc) + req->assoclen !=
15001514
iv_dma || src_nents || iv_dma + ivsize != sg_dma_address(req->src))
15011515
contig &= ~GIV_SRC_CONTIG;
@@ -1559,6 +1573,10 @@ static struct aead_edesc *aead_giv_edesc_alloc(struct aead_givcrypt_request
15591573
}
15601574
edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
15611575
sec4_sg_bytes, DMA_TO_DEVICE);
1576+
if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) {
1577+
dev_err(jrdev, "unable to map S/G table\n");
1578+
return ERR_PTR(-ENOMEM);
1579+
}
15621580

15631581
return edesc;
15641582
}
@@ -1650,11 +1668,16 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request
16501668
DMA_FROM_DEVICE, dst_chained);
16511669
}
16521670

1671+
iv_dma = dma_map_single(jrdev, req->info, ivsize, DMA_TO_DEVICE);
1672+
if (dma_mapping_error(jrdev, iv_dma)) {
1673+
dev_err(jrdev, "unable to map IV\n");
1674+
return ERR_PTR(-ENOMEM);
1675+
}
1676+
16531677
/*
16541678
* Check if iv can be contiguous with source and destination.
16551679
* If so, include it. If not, create scatterlist.
16561680
*/
1657-
iv_dma = dma_map_single(jrdev, req->info, ivsize, DMA_TO_DEVICE);
16581681
if (!src_nents && iv_dma + ivsize == sg_dma_address(req->src))
16591682
iv_contig = true;
16601683
else
@@ -1693,6 +1716,11 @@ static struct ablkcipher_edesc *ablkcipher_edesc_alloc(struct ablkcipher_request
16931716

16941717
edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
16951718
sec4_sg_bytes, DMA_TO_DEVICE);
1719+
if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) {
1720+
dev_err(jrdev, "unable to map S/G table\n");
1721+
return ERR_PTR(-ENOMEM);
1722+
}
1723+
16961724
edesc->iv_dma = iv_dma;
16971725

16981726
#ifdef DEBUG

‎drivers/crypto/caam/caamhash.c

Lines changed: 90 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -137,13 +137,20 @@ struct caam_hash_state {
137137
/* Common job descriptor seq in/out ptr routines */
138138

139139
/* Map state->caam_ctx, and append seq_out_ptr command that points to it */
140-
static inline void map_seq_out_ptr_ctx(u32 *desc, struct device *jrdev,
141-
struct caam_hash_state *state,
142-
int ctx_len)
140+
static inline int map_seq_out_ptr_ctx(u32 *desc, struct device *jrdev,
141+
struct caam_hash_state *state,
142+
int ctx_len)
143143
{
144144
state->ctx_dma = dma_map_single(jrdev, state->caam_ctx,
145145
ctx_len, DMA_FROM_DEVICE);
146+
if (dma_mapping_error(jrdev, state->ctx_dma)) {
147+
dev_err(jrdev, "unable to map ctx\n");
148+
return -ENOMEM;
149+
}
150+
146151
append_seq_out_ptr(desc, state->ctx_dma, ctx_len, 0);
152+
153+
return 0;
147154
}
148155

149156
/* Map req->result, and append seq_out_ptr command that points to it */
@@ -201,14 +208,19 @@ try_buf_map_to_sec4_sg(struct device *jrdev, struct sec4_sg_entry *sec4_sg,
201208
}
202209

203210
/* Map state->caam_ctx, and add it to link table */
204-
static inline void ctx_map_to_sec4_sg(u32 *desc, struct device *jrdev,
205-
struct caam_hash_state *state,
206-
int ctx_len,
207-
struct sec4_sg_entry *sec4_sg,
208-
u32 flag)
211+
static inline int ctx_map_to_sec4_sg(u32 *desc, struct device *jrdev,
212+
struct caam_hash_state *state, int ctx_len,
213+
struct sec4_sg_entry *sec4_sg, u32 flag)
209214
{
210215
state->ctx_dma = dma_map_single(jrdev, state->caam_ctx, ctx_len, flag);
216+
if (dma_mapping_error(jrdev, state->ctx_dma)) {
217+
dev_err(jrdev, "unable to map ctx\n");
218+
return -ENOMEM;
219+
}
220+
211221
dma_to_sec4_sg_one(sec4_sg, state->ctx_dma, ctx_len, 0);
222+
223+
return 0;
212224
}
213225

214226
/* Common shared descriptor commands */
@@ -809,8 +821,10 @@ static int ahash_update_ctx(struct ahash_request *req)
809821
edesc->sec4_sg = (void *)edesc + sizeof(struct ahash_edesc) +
810822
DESC_JOB_IO_LEN;
811823

812-
ctx_map_to_sec4_sg(desc, jrdev, state, ctx->ctx_len,
813-
edesc->sec4_sg, DMA_BIDIRECTIONAL);
824+
ret = ctx_map_to_sec4_sg(desc, jrdev, state, ctx->ctx_len,
825+
edesc->sec4_sg, DMA_BIDIRECTIONAL);
826+
if (ret)
827+
return ret;
814828

815829
state->buf_dma = try_buf_map_to_sec4_sg(jrdev,
816830
edesc->sec4_sg + 1,
@@ -839,6 +853,10 @@ static int ahash_update_ctx(struct ahash_request *req)
839853
edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
840854
sec4_sg_bytes,
841855
DMA_TO_DEVICE);
856+
if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) {
857+
dev_err(jrdev, "unable to map S/G table\n");
858+
return -ENOMEM;
859+
}
842860

843861
append_seq_in_ptr(desc, edesc->sec4_sg_dma, ctx->ctx_len +
844862
to_hash, LDST_SGF);
@@ -914,8 +932,10 @@ static int ahash_final_ctx(struct ahash_request *req)
914932
DESC_JOB_IO_LEN;
915933
edesc->src_nents = 0;
916934

917-
ctx_map_to_sec4_sg(desc, jrdev, state, ctx->ctx_len, edesc->sec4_sg,
918-
DMA_TO_DEVICE);
935+
ret = ctx_map_to_sec4_sg(desc, jrdev, state, ctx->ctx_len,
936+
edesc->sec4_sg, DMA_TO_DEVICE);
937+
if (ret)
938+
return ret;
919939

920940
state->buf_dma = try_buf_map_to_sec4_sg(jrdev, edesc->sec4_sg + 1,
921941
buf, state->buf_dma, buflen,
@@ -924,12 +944,20 @@ static int ahash_final_ctx(struct ahash_request *req)
924944

925945
edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
926946
sec4_sg_bytes, DMA_TO_DEVICE);
947+
if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) {
948+
dev_err(jrdev, "unable to map S/G table\n");
949+
return -ENOMEM;
950+
}
927951

928952
append_seq_in_ptr(desc, edesc->sec4_sg_dma, ctx->ctx_len + buflen,
929953
LDST_SGF);
930954

931955
edesc->dst_dma = map_seq_out_ptr_result(desc, jrdev, req->result,
932956
digestsize);
957+
if (dma_mapping_error(jrdev, edesc->dst_dma)) {
958+
dev_err(jrdev, "unable to map dst\n");
959+
return -ENOMEM;
960+
}
933961

934962
#ifdef DEBUG
935963
print_hex_dump(KERN_ERR, "jobdesc@"__stringify(__LINE__)": ",
@@ -992,8 +1020,10 @@ static int ahash_finup_ctx(struct ahash_request *req)
9921020
edesc->sec4_sg = (void *)edesc + sizeof(struct ahash_edesc) +
9931021
DESC_JOB_IO_LEN;
9941022

995-
ctx_map_to_sec4_sg(desc, jrdev, state, ctx->ctx_len, edesc->sec4_sg,
996-
DMA_TO_DEVICE);
1023+
ret = ctx_map_to_sec4_sg(desc, jrdev, state, ctx->ctx_len,
1024+
edesc->sec4_sg, DMA_TO_DEVICE);
1025+
if (ret)
1026+
return ret;
9971027

9981028
state->buf_dma = try_buf_map_to_sec4_sg(jrdev, edesc->sec4_sg + 1,
9991029
buf, state->buf_dma, buflen,
@@ -1004,12 +1034,20 @@ static int ahash_finup_ctx(struct ahash_request *req)
10041034

10051035
edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
10061036
sec4_sg_bytes, DMA_TO_DEVICE);
1037+
if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) {
1038+
dev_err(jrdev, "unable to map S/G table\n");
1039+
return -ENOMEM;
1040+
}
10071041

10081042
append_seq_in_ptr(desc, edesc->sec4_sg_dma, ctx->ctx_len +
10091043
buflen + req->nbytes, LDST_SGF);
10101044

10111045
edesc->dst_dma = map_seq_out_ptr_result(desc, jrdev, req->result,
10121046
digestsize);
1047+
if (dma_mapping_error(jrdev, edesc->dst_dma)) {
1048+
dev_err(jrdev, "unable to map dst\n");
1049+
return -ENOMEM;
1050+
}
10131051

10141052
#ifdef DEBUG
10151053
print_hex_dump(KERN_ERR, "jobdesc@"__stringify(__LINE__)": ",
@@ -1070,6 +1108,10 @@ static int ahash_digest(struct ahash_request *req)
10701108
sg_to_sec4_sg_last(req->src, src_nents, edesc->sec4_sg, 0);
10711109
edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
10721110
sec4_sg_bytes, DMA_TO_DEVICE);
1111+
if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) {
1112+
dev_err(jrdev, "unable to map S/G table\n");
1113+
return -ENOMEM;
1114+
}
10731115
src_dma = edesc->sec4_sg_dma;
10741116
options = LDST_SGF;
10751117
} else {
@@ -1080,6 +1122,10 @@ static int ahash_digest(struct ahash_request *req)
10801122

10811123
edesc->dst_dma = map_seq_out_ptr_result(desc, jrdev, req->result,
10821124
digestsize);
1125+
if (dma_mapping_error(jrdev, edesc->dst_dma)) {
1126+
dev_err(jrdev, "unable to map dst\n");
1127+
return -ENOMEM;
1128+
}
10831129

10841130
#ifdef DEBUG
10851131
print_hex_dump(KERN_ERR, "jobdesc@"__stringify(__LINE__)": ",
@@ -1128,11 +1174,19 @@ static int ahash_final_no_ctx(struct ahash_request *req)
11281174
init_job_desc_shared(desc, ptr, sh_len, HDR_SHARE_DEFER | HDR_REVERSE);
11291175

11301176
state->buf_dma = dma_map_single(jrdev, buf, buflen, DMA_TO_DEVICE);
1177+
if (dma_mapping_error(jrdev, state->buf_dma)) {
1178+
dev_err(jrdev, "unable to map src\n");
1179+
return -ENOMEM;
1180+
}
11311181

11321182
append_seq_in_ptr(desc, state->buf_dma, buflen, 0);
11331183

11341184
edesc->dst_dma = map_seq_out_ptr_result(desc, jrdev, req->result,
11351185
digestsize);
1186+
if (dma_mapping_error(jrdev, edesc->dst_dma)) {
1187+
dev_err(jrdev, "unable to map dst\n");
1188+
return -ENOMEM;
1189+
}
11361190
edesc->src_nents = 0;
11371191

11381192
#ifdef DEBUG
@@ -1219,10 +1273,16 @@ static int ahash_update_no_ctx(struct ahash_request *req)
12191273
edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
12201274
sec4_sg_bytes,
12211275
DMA_TO_DEVICE);
1276+
if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) {
1277+
dev_err(jrdev, "unable to map S/G table\n");
1278+
return -ENOMEM;
1279+
}
12221280

12231281
append_seq_in_ptr(desc, edesc->sec4_sg_dma, to_hash, LDST_SGF);
12241282

1225-
map_seq_out_ptr_ctx(desc, jrdev, state, ctx->ctx_len);
1283+
ret = map_seq_out_ptr_ctx(desc, jrdev, state, ctx->ctx_len);
1284+
if (ret)
1285+
return ret;
12261286

12271287
#ifdef DEBUG
12281288
print_hex_dump(KERN_ERR, "jobdesc@"__stringify(__LINE__)": ",
@@ -1311,12 +1371,20 @@ static int ahash_finup_no_ctx(struct ahash_request *req)
13111371

13121372
edesc->sec4_sg_dma = dma_map_single(jrdev, edesc->sec4_sg,
13131373
sec4_sg_bytes, DMA_TO_DEVICE);
1374+
if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) {
1375+
dev_err(jrdev, "unable to map S/G table\n");
1376+
return -ENOMEM;
1377+
}
13141378

13151379
append_seq_in_ptr(desc, edesc->sec4_sg_dma, buflen +
13161380
req->nbytes, LDST_SGF);
13171381

13181382
edesc->dst_dma = map_seq_out_ptr_result(desc, jrdev, req->result,
13191383
digestsize);
1384+
if (dma_mapping_error(jrdev, edesc->dst_dma)) {
1385+
dev_err(jrdev, "unable to map dst\n");
1386+
return -ENOMEM;
1387+
}
13201388

13211389
#ifdef DEBUG
13221390
print_hex_dump(KERN_ERR, "jobdesc@"__stringify(__LINE__)": ",
@@ -1393,6 +1461,10 @@ static int ahash_update_first(struct ahash_request *req)
13931461
edesc->sec4_sg,
13941462
sec4_sg_bytes,
13951463
DMA_TO_DEVICE);
1464+
if (dma_mapping_error(jrdev, edesc->sec4_sg_dma)) {
1465+
dev_err(jrdev, "unable to map S/G table\n");
1466+
return -ENOMEM;
1467+
}
13961468
src_dma = edesc->sec4_sg_dma;
13971469
options = LDST_SGF;
13981470
} else {
@@ -1410,7 +1482,9 @@ static int ahash_update_first(struct ahash_request *req)
14101482

14111483
append_seq_in_ptr(desc, src_dma, to_hash, options);
14121484

1413-
map_seq_out_ptr_ctx(desc, jrdev, state, ctx->ctx_len);
1485+
ret = map_seq_out_ptr_ctx(desc, jrdev, state, ctx->ctx_len);
1486+
if (ret)
1487+
return ret;
14141488

14151489
#ifdef DEBUG
14161490
print_hex_dump(KERN_ERR, "jobdesc@"__stringify(__LINE__)": ",

0 commit comments

Comments
 (0)