virtio: rename dma helpers · tjh.dev/kernel@b41cb3b

+14 -14

drivers/net/virtio_net.c

··· 962 962 if (dma->need_sync && len) { 963 963 offset = buf - (head + sizeof(*dma)); 964 964 965 - virtqueue_dma_sync_single_range_for_cpu(rq->vq, dma->addr, 965 + virtqueue_map_sync_single_range_for_cpu(rq->vq, dma->addr, 966 966 offset, len, 967 967 DMA_FROM_DEVICE); 968 968 } ··· 970 970 if (dma->ref) 971 971 return; 972 972 973 - virtqueue_dma_unmap_single_attrs(rq->vq, dma->addr, dma->len, 974 - DMA_FROM_DEVICE, DMA_ATTR_SKIP_CPU_SYNC); 973 + virtqueue_unmap_single_attrs(rq->vq, dma->addr, dma->len, 974 + DMA_FROM_DEVICE, DMA_ATTR_SKIP_CPU_SYNC); 975 975 put_page(page); 976 976 } 977 977 ··· 1038 1038 1039 1039 dma->len = alloc_frag->size - sizeof(*dma); 1040 1040 1041 - addr = virtqueue_dma_map_single_attrs(rq->vq, dma + 1, 1042 - dma->len, DMA_FROM_DEVICE, 0); 1043 - if (virtqueue_dma_mapping_error(rq->vq, addr)) 1041 + addr = virtqueue_map_single_attrs(rq->vq, dma + 1, 1042 + dma->len, DMA_FROM_DEVICE, 0); 1043 + if (virtqueue_map_mapping_error(rq->vq, addr)) 1044 1044 return NULL; 1045 1045 1046 1046 dma->addr = addr; 1047 - dma->need_sync = virtqueue_dma_need_sync(rq->vq, addr); 1047 + dma->need_sync = virtqueue_map_need_sync(rq->vq, addr); 1048 1048 1049 1049 /* Add a reference to dma to prevent the entire dma from 1050 1050 * being released during error handling. This reference ··· 5952 5952 if (!rq->xsk_buffs) 5953 5953 return -ENOMEM; 5954 5954 5955 - hdr_dma = virtqueue_dma_map_single_attrs(sq->vq, &xsk_hdr, vi->hdr_len, 5956 - DMA_TO_DEVICE, 0); 5957 - if (virtqueue_dma_mapping_error(sq->vq, hdr_dma)) { 5955 + hdr_dma = virtqueue_map_single_attrs(sq->vq, &xsk_hdr, vi->hdr_len, 5956 + DMA_TO_DEVICE, 0); 5957 + if (virtqueue_map_mapping_error(sq->vq, hdr_dma)) { 5958 5958 err = -ENOMEM; 5959 5959 goto err_free_buffs; 5960 5960 } ··· 5983 5983 err_rq: 5984 5984 xsk_pool_dma_unmap(pool, 0); 5985 5985 err_xsk_map: 5986 - virtqueue_dma_unmap_single_attrs(rq->vq, hdr_dma, vi->hdr_len, 5987 - DMA_TO_DEVICE, 0); 5986 + virtqueue_unmap_single_attrs(rq->vq, hdr_dma, vi->hdr_len, 5987 + DMA_TO_DEVICE, 0); 5988 5988 err_free_buffs: 5989 5989 kvfree(rq->xsk_buffs); 5990 5990 return err; ··· 6011 6011 6012 6012 xsk_pool_dma_unmap(pool, 0); 6013 6013 6014 - virtqueue_dma_unmap_single_attrs(sq->vq, sq->xsk_hdr_dma_addr, 6015 - vi->hdr_len, DMA_TO_DEVICE, 0); 6014 + virtqueue_unmap_single_attrs(sq->vq, sq->xsk_hdr_dma_addr, 6015 + vi->hdr_len, DMA_TO_DEVICE, 0); 6016 6016 kvfree(rq->xsk_buffs); 6017 6017 6018 6018 return err;

+57 -57

drivers/virtio/virtio_ring.c

··· 166 166 bool packed_ring; 167 167 168 168 /* Is DMA API used? */ 169 - bool use_dma_api; 169 + bool use_map_api; 170 170 171 171 /* Can we use weak barriers? */ 172 172 bool weak_barriers; ··· 268 268 * unconditionally on data path. 269 269 */ 270 270 271 - static bool vring_use_dma_api(const struct virtio_device *vdev) 271 + static bool vring_use_map_api(const struct virtio_device *vdev) 272 272 { 273 273 if (!virtio_has_dma_quirk(vdev)) 274 274 return true; ··· 291 291 static bool vring_need_unmap_buffer(const struct vring_virtqueue *vring, 292 292 const struct vring_desc_extra *extra) 293 293 { 294 - return vring->use_dma_api && (extra->addr != DMA_MAPPING_ERROR); 294 + return vring->use_map_api && (extra->addr != DMA_MAPPING_ERROR); 295 295 } 296 296 297 297 size_t virtio_max_dma_size(const struct virtio_device *vdev) 298 298 { 299 299 size_t max_segment_size = SIZE_MAX; 300 300 301 - if (vring_use_dma_api(vdev)) 301 + if (vring_use_map_api(vdev)) 302 302 max_segment_size = dma_max_mapping_size(vdev->dev.parent); 303 303 304 304 return max_segment_size; ··· 309 309 dma_addr_t *dma_handle, gfp_t flag, 310 310 struct device *dma_dev) 311 311 { 312 - if (vring_use_dma_api(vdev)) { 312 + if (vring_use_map_api(vdev)) { 313 313 return dma_alloc_coherent(dma_dev, size, 314 314 dma_handle, flag); 315 315 } else { ··· 343 343 void *queue, dma_addr_t dma_handle, 344 344 struct device *dma_dev) 345 345 { 346 - if (vring_use_dma_api(vdev)) 346 + if (vring_use_map_api(vdev)) 347 347 dma_free_coherent(dma_dev, size, queue, dma_handle); 348 348 else 349 349 free_pages_exact(queue, PAGE_ALIGN(size)); ··· 372 372 373 373 *len = sg->length; 374 374 375 - if (!vq->use_dma_api) { 375 + if (!vq->use_map_api) { 376 376 /* 377 377 * If DMA is not used, KMSAN doesn't know that the scatterlist 378 378 * is initialized by the hardware. Explicitly check/unpoison it ··· 402 402 void *cpu_addr, size_t size, 403 403 enum dma_data_direction direction) 404 404 { 405 - if (!vq->use_dma_api) 405 + if (!vq->use_map_api) 406 406 return (dma_addr_t)virt_to_phys(cpu_addr); 407 407 408 - return virtqueue_dma_map_single_attrs(&vq->vq, cpu_addr, 409 - size, direction, 0); 408 + return virtqueue_map_single_attrs(&vq->vq, cpu_addr, 409 + size, direction, 0); 410 410 } 411 411 412 412 static int vring_mapping_error(const struct vring_virtqueue *vq, 413 413 dma_addr_t addr) 414 414 { 415 - if (!vq->use_dma_api) 415 + if (!vq->use_map_api) 416 416 return 0; 417 417 418 418 return dma_mapping_error(vring_dma_dev(vq), addr); ··· 449 449 flags = extra->flags; 450 450 451 451 if (flags & VRING_DESC_F_INDIRECT) { 452 - if (!vq->use_dma_api) 452 + if (!vq->use_map_api) 453 453 goto out; 454 454 } else if (!vring_need_unmap_buffer(vq, extra)) 455 455 goto out; ··· 782 782 783 783 extra = (struct vring_desc_extra *)&indir_desc[num]; 784 784 785 - if (vq->use_dma_api) { 785 + if (vq->use_map_api) { 786 786 for (j = 0; j < num; j++) 787 787 vring_unmap_one_split(vq, &extra[j]); 788 788 } ··· 1150 1150 vq->broken = false; 1151 1151 #endif 1152 1152 vq->dma_dev = dma_dev; 1153 - vq->use_dma_api = vring_use_dma_api(vdev); 1153 + vq->use_map_api = vring_use_map_api(vdev); 1154 1154 1155 1155 vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) && 1156 1156 !context; ··· 1266 1266 flags = extra->flags; 1267 1267 1268 1268 if (flags & VRING_DESC_F_INDIRECT) { 1269 - if (!vq->use_dma_api) 1269 + if (!vq->use_map_api) 1270 1270 return; 1271 1271 } else if (!vring_need_unmap_buffer(vq, extra)) 1272 1272 return; ··· 1351 1351 desc[i].addr = cpu_to_le64(addr); 1352 1352 desc[i].len = cpu_to_le32(len); 1353 1353 1354 - if (unlikely(vq->use_dma_api)) { 1354 + if (unlikely(vq->use_map_api)) { 1355 1355 extra[i].addr = premapped ? DMA_MAPPING_ERROR : addr; 1356 1356 extra[i].len = len; 1357 1357 extra[i].flags = n < out_sgs ? 0 : VRING_DESC_F_WRITE; ··· 1373 1373 sizeof(struct vring_packed_desc)); 1374 1374 vq->packed.vring.desc[head].id = cpu_to_le16(id); 1375 1375 1376 - if (vq->use_dma_api) { 1376 + if (vq->use_map_api) { 1377 1377 vq->packed.desc_extra[id].addr = addr; 1378 1378 vq->packed.desc_extra[id].len = total_sg * 1379 1379 sizeof(struct vring_packed_desc); ··· 1515 1515 desc[i].len = cpu_to_le32(len); 1516 1516 desc[i].id = cpu_to_le16(id); 1517 1517 1518 - if (unlikely(vq->use_dma_api)) { 1518 + if (unlikely(vq->use_map_api)) { 1519 1519 vq->packed.desc_extra[curr].addr = premapped ? 1520 1520 DMA_MAPPING_ERROR : addr; 1521 1521 vq->packed.desc_extra[curr].len = len; ··· 1650 1650 vq->free_head = id; 1651 1651 vq->vq.num_free += state->num; 1652 1652 1653 - if (unlikely(vq->use_dma_api)) { 1653 + if (unlikely(vq->use_map_api)) { 1654 1654 curr = id; 1655 1655 for (i = 0; i < state->num; i++) { 1656 1656 vring_unmap_extra_packed(vq, ··· 1668 1668 if (!desc) 1669 1669 return; 1670 1670 1671 - if (vq->use_dma_api) { 1671 + if (vq->use_map_api) { 1672 1672 len = vq->packed.desc_extra[id].len; 1673 1673 num = len / sizeof(struct vring_packed_desc); 1674 1674 ··· 2121 2121 #endif 2122 2122 vq->packed_ring = true; 2123 2123 vq->dma_dev = dma_dev; 2124 - vq->use_dma_api = vring_use_dma_api(vdev); 2124 + vq->use_map_api = vring_use_map_api(vdev); 2125 2125 2126 2126 vq->indirect = virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC) && 2127 2127 !context; ··· 2433 2433 { 2434 2434 struct vring_virtqueue *vq = to_vvq(_vq); 2435 2435 2436 - if (vq->use_dma_api) 2436 + if (vq->use_map_api) 2437 2437 return vring_dma_dev(vq); 2438 2438 else 2439 2439 return NULL; ··· 3122 3122 EXPORT_SYMBOL_GPL(virtqueue_get_vring); 3123 3123 3124 3124 /** 3125 - * virtqueue_dma_map_single_attrs - map DMA for _vq 3125 + * virtqueue_map_single_attrs - map DMA for _vq 3126 3126 * @_vq: the struct virtqueue we're talking about. 3127 3127 * @ptr: the pointer of the buffer to do dma 3128 3128 * @size: the size of the buffer to do dma ··· 3132 3132 * The caller calls this to do dma mapping in advance. The DMA address can be 3133 3133 * passed to this _vq when it is in pre-mapped mode. 3134 3134 * 3135 - * return DMA address. Caller should check that by virtqueue_dma_mapping_error(). 3135 + * return DMA address. Caller should check that by virtqueue_mapping_error(). 3136 3136 */ 3137 - dma_addr_t virtqueue_dma_map_single_attrs(const struct virtqueue *_vq, void *ptr, 3138 - size_t size, 3139 - enum dma_data_direction dir, 3140 - unsigned long attrs) 3137 + dma_addr_t virtqueue_map_single_attrs(const struct virtqueue *_vq, void *ptr, 3138 + size_t size, 3139 + enum dma_data_direction dir, 3140 + unsigned long attrs) 3141 3141 { 3142 3142 const struct vring_virtqueue *vq = to_vvq(_vq); 3143 3143 3144 - if (!vq->use_dma_api) { 3144 + if (!vq->use_map_api) { 3145 3145 kmsan_handle_dma(virt_to_page(ptr), offset_in_page(ptr), size, dir); 3146 3146 return (dma_addr_t)virt_to_phys(ptr); 3147 3147 } ··· 3154 3154 return dma_map_page_attrs(vring_dma_dev(vq), virt_to_page(ptr), 3155 3155 offset_in_page(ptr), size, dir, attrs); 3156 3156 } 3157 - EXPORT_SYMBOL_GPL(virtqueue_dma_map_single_attrs); 3157 + EXPORT_SYMBOL_GPL(virtqueue_map_single_attrs); 3158 3158 3159 3159 /** 3160 - * virtqueue_dma_unmap_single_attrs - unmap DMA for _vq 3160 + * virtqueue_unmap_single_attrs - unmap map for _vq 3161 3161 * @_vq: the struct virtqueue we're talking about. 3162 3162 * @addr: the dma address to unmap 3163 3163 * @size: the size of the buffer 3164 3164 * @dir: DMA direction 3165 3165 * @attrs: DMA Attrs 3166 3166 * 3167 - * Unmap the address that is mapped by the virtqueue_dma_map_* APIs. 3167 + * Unmap the address that is mapped by the virtqueue_map_* APIs. 3168 3168 * 3169 3169 */ 3170 - void virtqueue_dma_unmap_single_attrs(const struct virtqueue *_vq, 3171 - dma_addr_t addr, 3172 - size_t size, enum dma_data_direction dir, 3173 - unsigned long attrs) 3170 + void virtqueue_unmap_single_attrs(const struct virtqueue *_vq, 3171 + dma_addr_t addr, 3172 + size_t size, enum dma_data_direction dir, 3173 + unsigned long attrs) 3174 3174 { 3175 3175 const struct vring_virtqueue *vq = to_vvq(_vq); 3176 3176 3177 - if (!vq->use_dma_api) 3177 + if (!vq->use_map_api) 3178 3178 return; 3179 3179 3180 3180 dma_unmap_page_attrs(vring_dma_dev(vq), addr, size, dir, attrs); 3181 3181 } 3182 - EXPORT_SYMBOL_GPL(virtqueue_dma_unmap_single_attrs); 3182 + EXPORT_SYMBOL_GPL(virtqueue_unmap_single_attrs); 3183 3183 3184 3184 /** 3185 - * virtqueue_dma_mapping_error - check dma address 3185 + * virtqueue_map_mapping_error - check dma address 3186 3186 * @_vq: the struct virtqueue we're talking about. 3187 3187 * @addr: DMA address 3188 3188 * 3189 3189 * Returns 0 means dma valid. Other means invalid dma address. 3190 3190 */ 3191 - int virtqueue_dma_mapping_error(const struct virtqueue *_vq, dma_addr_t addr) 3191 + int virtqueue_map_mapping_error(const struct virtqueue *_vq, dma_addr_t addr) 3192 3192 { 3193 3193 const struct vring_virtqueue *vq = to_vvq(_vq); 3194 3194 3195 - if (!vq->use_dma_api) 3195 + if (!vq->use_map_api) 3196 3196 return 0; 3197 3197 3198 3198 return dma_mapping_error(vring_dma_dev(vq), addr); 3199 3199 } 3200 - EXPORT_SYMBOL_GPL(virtqueue_dma_mapping_error); 3200 + EXPORT_SYMBOL_GPL(virtqueue_map_mapping_error); 3201 3201 3202 3202 /** 3203 - * virtqueue_dma_need_sync - check a dma address needs sync 3203 + * virtqueue_map_need_sync - check a dma address needs sync 3204 3204 * @_vq: the struct virtqueue we're talking about. 3205 3205 * @addr: DMA address 3206 3206 * 3207 - * Check if the dma address mapped by the virtqueue_dma_map_* APIs needs to be 3207 + * Check if the dma address mapped by the virtqueue_map_* APIs needs to be 3208 3208 * synchronized 3209 3209 * 3210 3210 * return bool 3211 3211 */ 3212 - bool virtqueue_dma_need_sync(const struct virtqueue *_vq, dma_addr_t addr) 3212 + bool virtqueue_map_need_sync(const struct virtqueue *_vq, dma_addr_t addr) 3213 3213 { 3214 3214 const struct vring_virtqueue *vq = to_vvq(_vq); 3215 3215 3216 - if (!vq->use_dma_api) 3216 + if (!vq->use_map_api) 3217 3217 return false; 3218 3218 3219 3219 return dma_need_sync(vring_dma_dev(vq), addr); 3220 3220 } 3221 - EXPORT_SYMBOL_GPL(virtqueue_dma_need_sync); 3221 + EXPORT_SYMBOL_GPL(virtqueue_map_need_sync); 3222 3222 3223 3223 /** 3224 - * virtqueue_dma_sync_single_range_for_cpu - dma sync for cpu 3224 + * virtqueue_map_sync_single_range_for_cpu - map sync for cpu 3225 3225 * @_vq: the struct virtqueue we're talking about. 3226 3226 * @addr: DMA address 3227 3227 * @offset: DMA address offset 3228 3228 * @size: buf size for sync 3229 3229 * @dir: DMA direction 3230 3230 * 3231 - * Before calling this function, use virtqueue_dma_need_sync() to confirm that 3231 + * Before calling this function, use virtqueue_map_need_sync() to confirm that 3232 3232 * the DMA address really needs to be synchronized 3233 3233 * 3234 3234 */ 3235 - void virtqueue_dma_sync_single_range_for_cpu(const struct virtqueue *_vq, 3235 + void virtqueue_map_sync_single_range_for_cpu(const struct virtqueue *_vq, 3236 3236 dma_addr_t addr, 3237 3237 unsigned long offset, size_t size, 3238 3238 enum dma_data_direction dir) ··· 3240 3240 const struct vring_virtqueue *vq = to_vvq(_vq); 3241 3241 struct device *dev = vring_dma_dev(vq); 3242 3242 3243 - if (!vq->use_dma_api) 3243 + if (!vq->use_map_api) 3244 3244 return; 3245 3245 3246 3246 dma_sync_single_range_for_cpu(dev, addr, offset, size, dir); 3247 3247 } 3248 - EXPORT_SYMBOL_GPL(virtqueue_dma_sync_single_range_for_cpu); 3248 + EXPORT_SYMBOL_GPL(virtqueue_map_sync_single_range_for_cpu); 3249 3249 3250 3250 /** 3251 - * virtqueue_dma_sync_single_range_for_device - dma sync for device 3251 + * virtqueue_map_sync_single_range_for_device - map sync for device 3252 3252 * @_vq: the struct virtqueue we're talking about. 3253 3253 * @addr: DMA address 3254 3254 * @offset: DMA address offset 3255 3255 * @size: buf size for sync 3256 3256 * @dir: DMA direction 3257 3257 * 3258 - * Before calling this function, use virtqueue_dma_need_sync() to confirm that 3258 + * Before calling this function, use virtqueue_map_need_sync() to confirm that 3259 3259 * the DMA address really needs to be synchronized 3260 3260 */ 3261 - void virtqueue_dma_sync_single_range_for_device(const struct virtqueue *_vq, 3261 + void virtqueue_map_sync_single_range_for_device(const struct virtqueue *_vq, 3262 3262 dma_addr_t addr, 3263 3263 unsigned long offset, size_t size, 3264 3264 enum dma_data_direction dir) ··· 3266 3266 const struct vring_virtqueue *vq = to_vvq(_vq); 3267 3267 struct device *dev = vring_dma_dev(vq); 3268 3268 3269 - if (!vq->use_dma_api) 3269 + if (!vq->use_map_api) 3270 3270 return; 3271 3271 3272 3272 dma_sync_single_range_for_device(dev, addr, offset, size, dir); 3273 3273 } 3274 - EXPORT_SYMBOL_GPL(virtqueue_dma_sync_single_range_for_device); 3274 + EXPORT_SYMBOL_GPL(virtqueue_map_sync_single_range_for_device); 3275 3275 3276 3276 MODULE_DESCRIPTION("Virtio ring implementation"); 3277 3277 MODULE_LICENSE("GPL");

+6 -6

include/linux/virtio.h

··· 262 262 module_driver(__virtio_driver, register_virtio_driver, \ 263 263 unregister_virtio_driver) 264 264 265 - dma_addr_t virtqueue_dma_map_single_attrs(const struct virtqueue *_vq, void *ptr, size_t size, 265 + dma_addr_t virtqueue_map_single_attrs(const struct virtqueue *_vq, void *ptr, size_t size, 266 266 enum dma_data_direction dir, unsigned long attrs); 267 - void virtqueue_dma_unmap_single_attrs(const struct virtqueue *_vq, dma_addr_t addr, 267 + void virtqueue_unmap_single_attrs(const struct virtqueue *_vq, dma_addr_t addr, 268 268 size_t size, enum dma_data_direction dir, 269 269 unsigned long attrs); 270 - int virtqueue_dma_mapping_error(const struct virtqueue *_vq, dma_addr_t addr); 270 + int virtqueue_map_mapping_error(const struct virtqueue *_vq, dma_addr_t addr); 271 271 272 - bool virtqueue_dma_need_sync(const struct virtqueue *_vq, dma_addr_t addr); 273 - void virtqueue_dma_sync_single_range_for_cpu(const struct virtqueue *_vq, dma_addr_t addr, 272 + bool virtqueue_map_need_sync(const struct virtqueue *_vq, dma_addr_t addr); 273 + void virtqueue_map_sync_single_range_for_cpu(const struct virtqueue *_vq, dma_addr_t addr, 274 274 unsigned long offset, size_t size, 275 275 enum dma_data_direction dir); 276 - void virtqueue_dma_sync_single_range_for_device(const struct virtqueue *_vq, dma_addr_t addr, 276 + void virtqueue_map_sync_single_range_for_device(const struct virtqueue *_vq, dma_addr_t addr, 277 277 unsigned long offset, size_t size, 278 278 enum dma_data_direction dir); 279 279

Configure Feed

Configure Feed