Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'dma-mapping-5.15-2' of git://git.infradead.org/users/hch/dma-mapping
Pull dma-mapping fixes from Christoph Hellwig:
- fix more dma-debug fallout (Gerald Schaefer, Hamza Mahfooz)
- fix a kerneldoc warning (Logan Gunthorpe)
* tag 'dma-mapping-5.15-2' of git://git.infradead.org/users/hch/dma-mapping:
dma-debug: teach add_dma_entry() about DMA_ATTR_SKIP_CPU_SYNC
dma-debug: fix sg checks in debug_dma_map_sg()
dma-mapping: fix the kerneldoc for dma_map_sgtable()
+48
-36
+20
-16
kernel/dma/debug.c
+20
-16
kernel/dma/debug.c
···
552
552
* Wrapper function for adding an entry to the hash.
553
553
* This function takes care of locking itself.
554
554
*/
555
-
static void add_dma_entry(struct dma_debug_entry *entry)
555
+
static void add_dma_entry(struct dma_debug_entry *entry, unsigned long attrs)
556
556
{
557
557
struct hash_bucket *bucket;
558
558
unsigned long flags;
···
566
566
if (rc == -ENOMEM) {
567
567
pr_err("cacheline tracking ENOMEM, dma-debug disabled\n");
568
568
global_disable = true;
569
-
} else if (rc == -EEXIST) {
569
+
} else if (rc == -EEXIST && !(attrs & DMA_ATTR_SKIP_CPU_SYNC)) {
570
570
err_printk(entry->dev, entry,
571
571
"cacheline tracking EEXIST, overlapping mappings aren't supported\n");
572
572
}
···
1191
1191
EXPORT_SYMBOL(debug_dma_map_single);
1192
1192
1193
1193
void debug_dma_map_page(struct device *dev, struct page *page, size_t offset,
1194
-
size_t size, int direction, dma_addr_t dma_addr)
1194
+
size_t size, int direction, dma_addr_t dma_addr,
1195
+
unsigned long attrs)
1195
1196
{
1196
1197
struct dma_debug_entry *entry;
1197
1198
···
1223
1222
check_for_illegal_area(dev, addr, size);
1224
1223
}
1225
1224
1226
-
add_dma_entry(entry);
1225
+
add_dma_entry(entry, attrs);
1227
1226
}
1228
1227
1229
1228
void debug_dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
···
1281
1280
}
1282
1281
1283
1282
void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,
1284
-
int nents, int mapped_ents, int direction)
1283
+
int nents, int mapped_ents, int direction,
1284
+
unsigned long attrs)
1285
1285
{
1286
1286
struct dma_debug_entry *entry;
1287
1287
struct scatterlist *s;
···
1290
1288
1291
1289
if (unlikely(dma_debug_disabled()))
1292
1290
return;
1291
+
1292
+
for_each_sg(sg, s, nents, i) {
1293
+
check_for_stack(dev, sg_page(s), s->offset);
1294
+
if (!PageHighMem(sg_page(s)))
1295
+
check_for_illegal_area(dev, sg_virt(s), s->length);
1296
+
}
1293
1297
1294
1298
for_each_sg(sg, s, mapped_ents, i) {
1295
1299
entry = dma_entry_alloc();
···
1312
1304
entry->sg_call_ents = nents;
1313
1305
entry->sg_mapped_ents = mapped_ents;
1314
1306
1315
-
check_for_stack(dev, sg_page(s), s->offset);
1316
-
1317
-
if (!PageHighMem(sg_page(s))) {
1318
-
check_for_illegal_area(dev, sg_virt(s), sg_dma_len(s));
1319
-
}
1320
-
1321
1307
check_sg_segment(dev, s);
1322
1308
1323
-
add_dma_entry(entry);
1309
+
add_dma_entry(entry, attrs);
1324
1310
}
1325
1311
}
1326
1312
···
1370
1368
}
1371
1369
1372
1370
void debug_dma_alloc_coherent(struct device *dev, size_t size,
1373
-
dma_addr_t dma_addr, void *virt)
1371
+
dma_addr_t dma_addr, void *virt,
1372
+
unsigned long attrs)
1374
1373
{
1375
1374
struct dma_debug_entry *entry;
1376
1375
···
1401
1398
else
1402
1399
entry->pfn = page_to_pfn(virt_to_page(virt));
1403
1400
1404
-
add_dma_entry(entry);
1401
+
add_dma_entry(entry, attrs);
1405
1402
}
1406
1403
1407
1404
void debug_dma_free_coherent(struct device *dev, size_t size,
···
1432
1429
}
1433
1430
1434
1431
void debug_dma_map_resource(struct device *dev, phys_addr_t addr, size_t size,
1435
-
int direction, dma_addr_t dma_addr)
1432
+
int direction, dma_addr_t dma_addr,
1433
+
unsigned long attrs)
1436
1434
{
1437
1435
struct dma_debug_entry *entry;
1438
1436
···
1453
1449
entry->direction = direction;
1454
1450
entry->map_err_type = MAP_ERR_NOT_CHECKED;
1455
1451
1456
-
add_dma_entry(entry);
1452
+
add_dma_entry(entry, attrs);
1457
1453
}
1458
1454
1459
1455
void debug_dma_unmap_resource(struct device *dev, dma_addr_t dma_addr,
+16
-8
kernel/dma/debug.h
+16
-8
kernel/dma/debug.h
···
11
11
#ifdef CONFIG_DMA_API_DEBUG
12
12
extern void debug_dma_map_page(struct device *dev, struct page *page,
13
13
size_t offset, size_t size,
14
-
int direction, dma_addr_t dma_addr);
14
+
int direction, dma_addr_t dma_addr,
15
+
unsigned long attrs);
15
16
16
17
extern void debug_dma_unmap_page(struct device *dev, dma_addr_t addr,
17
18
size_t size, int direction);
18
19
19
20
extern void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,
20
-
int nents, int mapped_ents, int direction);
21
+
int nents, int mapped_ents, int direction,
22
+
unsigned long attrs);
21
23
22
24
extern void debug_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
23
25
int nelems, int dir);
24
26
25
27
extern void debug_dma_alloc_coherent(struct device *dev, size_t size,
26
-
dma_addr_t dma_addr, void *virt);
28
+
dma_addr_t dma_addr, void *virt,
29
+
unsigned long attrs);
27
30
28
31
extern void debug_dma_free_coherent(struct device *dev, size_t size,
29
32
void *virt, dma_addr_t addr);
30
33
31
34
extern void debug_dma_map_resource(struct device *dev, phys_addr_t addr,
32
35
size_t size, int direction,
33
-
dma_addr_t dma_addr);
36
+
dma_addr_t dma_addr,
37
+
unsigned long attrs);
34
38
35
39
extern void debug_dma_unmap_resource(struct device *dev, dma_addr_t dma_addr,
36
40
size_t size, int direction);
···
57
53
#else /* CONFIG_DMA_API_DEBUG */
58
54
static inline void debug_dma_map_page(struct device *dev, struct page *page,
59
55
size_t offset, size_t size,
60
-
int direction, dma_addr_t dma_addr)
56
+
int direction, dma_addr_t dma_addr,
57
+
unsigned long attrs)
61
58
{
62
59
}
63
60
···
68
63
}
69
64
70
65
static inline void debug_dma_map_sg(struct device *dev, struct scatterlist *sg,
71
-
int nents, int mapped_ents, int direction)
66
+
int nents, int mapped_ents, int direction,
67
+
unsigned long attrs)
72
68
{
73
69
}
74
70
···
80
74
}
81
75
82
76
static inline void debug_dma_alloc_coherent(struct device *dev, size_t size,
83
-
dma_addr_t dma_addr, void *virt)
77
+
dma_addr_t dma_addr, void *virt,
78
+
unsigned long attrs)
84
79
{
85
80
}
86
81
···
92
85
93
86
static inline void debug_dma_map_resource(struct device *dev, phys_addr_t addr,
94
87
size_t size, int direction,
95
-
dma_addr_t dma_addr)
88
+
dma_addr_t dma_addr,
89
+
unsigned long attrs)
96
90
{
97
91
}
98
92
+12
-12
kernel/dma/mapping.c
+12
-12
kernel/dma/mapping.c
···
156
156
addr = dma_direct_map_page(dev, page, offset, size, dir, attrs);
157
157
else
158
158
addr = ops->map_page(dev, page, offset, size, dir, attrs);
159
-
debug_dma_map_page(dev, page, offset, size, dir, addr);
159
+
debug_dma_map_page(dev, page, offset, size, dir, addr, attrs);
160
160
161
161
return addr;
162
162
}
···
195
195
ents = ops->map_sg(dev, sg, nents, dir, attrs);
196
196
197
197
if (ents > 0)
198
-
debug_dma_map_sg(dev, sg, nents, ents, dir);
198
+
debug_dma_map_sg(dev, sg, nents, ents, dir, attrs);
199
199
else if (WARN_ON_ONCE(ents != -EINVAL && ents != -ENOMEM &&
200
200
ents != -EIO))
201
201
return -EIO;
···
249
249
* Returns 0 on success or a negative error code on error. The following
250
250
* error codes are supported with the given meaning:
251
251
*
252
-
* -EINVAL - An invalid argument, unaligned access or other error
253
-
* in usage. Will not succeed if retried.
254
-
* -ENOMEM - Insufficient resources (like memory or IOVA space) to
255
-
* complete the mapping. Should succeed if retried later.
256
-
* -EIO - Legacy error code with an unknown meaning. eg. this is
257
-
* returned if a lower level call returned DMA_MAPPING_ERROR.
252
+
* -EINVAL An invalid argument, unaligned access or other error
253
+
* in usage. Will not succeed if retried.
254
+
* -ENOMEM Insufficient resources (like memory or IOVA space) to
255
+
* complete the mapping. Should succeed if retried later.
256
+
* -EIO Legacy error code with an unknown meaning. eg. this is
257
+
* returned if a lower level call returned DMA_MAPPING_ERROR.
258
258
*/
259
259
int dma_map_sgtable(struct device *dev, struct sg_table *sgt,
260
260
enum dma_data_direction dir, unsigned long attrs)
···
305
305
else if (ops->map_resource)
306
306
addr = ops->map_resource(dev, phys_addr, size, dir, attrs);
307
307
308
-
debug_dma_map_resource(dev, phys_addr, size, dir, addr);
308
+
debug_dma_map_resource(dev, phys_addr, size, dir, addr, attrs);
309
309
return addr;
310
310
}
311
311
EXPORT_SYMBOL(dma_map_resource);
···
510
510
else
511
511
return NULL;
512
512
513
-
debug_dma_alloc_coherent(dev, size, *dma_handle, cpu_addr);
513
+
debug_dma_alloc_coherent(dev, size, *dma_handle, cpu_addr, attrs);
514
514
return cpu_addr;
515
515
}
516
516
EXPORT_SYMBOL(dma_alloc_attrs);
···
566
566
struct page *page = __dma_alloc_pages(dev, size, dma_handle, dir, gfp);
567
567
568
568
if (page)
569
-
debug_dma_map_page(dev, page, 0, size, dir, *dma_handle);
569
+
debug_dma_map_page(dev, page, 0, size, dir, *dma_handle, 0);
570
570
return page;
571
571
}
572
572
EXPORT_SYMBOL_GPL(dma_alloc_pages);
···
644
644
645
645
if (sgt) {
646
646
sgt->nents = 1;
647
-
debug_dma_map_sg(dev, sgt->sgl, sgt->orig_nents, 1, dir);
647
+
debug_dma_map_sg(dev, sgt->sgl, sgt->orig_nents, 1, dir, attrs);
648
648
}
649
649
return sgt;
650
650
}