使用DMA实现memcpy

mayjojo

Hi, there

至于为什么有这样的需求，http://linux.chinaunix.net/bbs/thread-1173346-1-1.html 已经给出来说明。我是这个论坛的新人，也是kernel的新人。第一次在这里发帖提问，但是没有得到任何答案。于是在解决来问题之后，将自己的程序贴出来，希望大家提出改进意见。以下代码遵守GPL协议。

文件：dma_memcpy.c

1. #include <linux/init.h>
   
2. #include <linux/module.h>
   
3. #include <linux/fs.h>
   
4. #include <linux/mm_types.h>
   
5. #include <linux/mm.h>
   
6. #include <linux/sched.h>
   
7. #include <linux/async_tx.h>
   
8. #include <linux/slab.h>
   
9. #include <linux/slub_def.h>
   
10. #include <asm/page.h>
    
11. #include <asm/uaccess.h>
    
12. #include <asm/current.h>
    
13. 
    
14. #include "dma_memcpy.h"
    
15. 
    
16. MODULE_LICENSE("GPL");
    
17. 
    
18. #define DMA_MEMCPY_DEVICE_NAME "dma_memcpy_device"
    
19. 
    
20. static int major = 0;
    
21. 
    
22. static int memcpy_ioctl(struct inode * inode, struct file * pfile, unsigned int cmd, unsigned long arg);
    
23. 
    
24. static struct file_operations fops = { .ioctl = memcpy_ioctl };
    
25. 
    
26. static int memcpy_init(void)
    
27. {
    
28.         major = register_chrdev(0, DMA_MEMCPY_DEVICE_NAME, &fops);
    
29.         if (major < 0) {
    
30.                 printk(KERN_ALERT "failed to register chrdev :%d\n", major);
    
31.                 return major;
    
32.         }
    
33.         else {
    
34.                 printk(KERN_ALERT "load dma_memcpy module : %d\n", major);
    
35.                 return 0;
    
36.         }
    
37. }
    
38. 
    
39. static void memcpy_exit(void)
    
40. {
    
41.         unregister_chrdev(major, DMA_MEMCPY_DEVICE_NAME);
    
42.         printk(KERN_ALERT "exit dma_memcpy module\n");
    
43. }
    
44. 
    
45. static int memcpy_ioctl(struct inode * inode, struct file * pfile, unsigned int cmd, unsigned long arg)
    
46. {
    
47.         dma_memcpy_ioctr_t k_arg;
    
48.         unsigned long count;
    
49.         unsigned long nr_page;
    
50.         unsigned long dest;
    
51.         unsigned long src;
    
52.         unsigned long i;
    
53.         int nr_page_fetched;
    
54.         int retval;
    
55. 
    
56.         struct page ** dest_pages = NULL;
    
57.         struct page ** src_pages = NULL;
    
58.         struct async_submit_ctl * ctls = NULL;
    
59.         struct dma_async_tx_descriptor ** desps = NULL;
    
60. 
    
61.         printk(KERN_ALERT "file ioctl.\n");
    
62. 
    
63.         if (!access_ok(VERIFY_READ, arg, sizeof(dma_memcpy_ioctr_t))) {
    
64.                 printk(KERN_ALERT "invalid parameter of ioctl.\n");
    
65.                 retval = -EFAULT;
    
66.                 goto CLEAN;
    
67.         }
    
68. 
    
69.         if (copy_from_user((void *) &k_arg, (const void *) arg, sizeof(dma_memcpy_ioctr_t))) {
    
70.                 printk(KERN_ALERT "can NOT copy data from user space.\n");
    
71.                 retval = -EFAULT;
    
72.                 goto CLEAN;
    
73.         }
    
74. 
    
75.         if (!access_ok(VERIFY_READ, k_arg.src, sizeof(k_arg.size))) {
    
76.                 printk(KERN_ALERT "can NOT read data from src.\n");
    
77.                 retval = -EFAULT;
    
78.                 goto CLEAN;
    
79.         }
    
80. 
    
81.         if (!access_ok(VERIFY_WRITE, k_arg.dest, sizeof(k_arg.size))) {
    
82.                 printk(KERN_ALERT "can NOT write data to dest.\n");
    
83.                 retval = -EFAULT;
    
84.                 goto CLEAN;
    
85.         }
    
86. 
    
87.         src = (unsigned long) k_arg.src;
    
88.         dest = (unsigned long) k_arg.dest;
    
89. 
    
90.         if (!(dest & PAGE_MASK && src & PAGE_MASK)) {
    
91.                 printk(KERN_ALERT "src or dest is NOT aligned with PAGE.\n");
    
92.                 retval = -EDOM;
    
93.                 goto CLEAN;
    
94.         }
    
95. 
    
96.         count = k_arg.size;
    
97.         retval = count;
    
98.         nr_page = count / PAGE_SIZE;
    
99.         printk(KERN_ALERT "to copy %ld page.\n", nr_page);
    
100. 
     
101.         if (count % PAGE_SIZE != 0) {
     
102.                 printk(KERN_ALERT "the size is NOT the multiple of PAGE.\n");
     
103.                 retval = -EDOM;
     
104.                 goto CLEAN;
     
105.         }
     
106. 
     
107.         dest_pages = (struct page **) kmalloc(nr_page * sizeof(struct page *), GFP_KERNEL);
     
108.         src_pages = (struct page **) kmalloc(nr_page * sizeof(struct page *), GFP_KERNEL);
     
109.         if (NULL == dest_pages || NULL == src_pages) {
     
110.                 printk(KERN_ALERT "can NOT kmalloc memory.\n");
     
111.                 retval = -ENOMEM;
     
112.                 goto CLEAN;
     
113.         }
     
114. 
     
115.         if (nr_page != (nr_page_fetched = get_user_pages(current, current->mm, src, nr_page, 0, 0, src_pages, NULL))) {
     
116.                 printk(KERN_ALERT "can NOT get user pages of virtual address 0x%lx\n", src);
     
117.                 for (i = 0; i < nr_page_fetched; i++) {
     
118.                         put_page(src_pages[i]);
     
119.                 }
     
120.                 goto CLEAN;
     
121.         }
     
122. 
     
123.         if (nr_page != (nr_page_fetched = get_user_pages(current, current->mm, dest, nr_page, 1, 0, dest_pages, NULL))) {
     
124.                 printk(KERN_ALERT "can NOT get user pages of virtual address 0x%lx\n", dest);
     
125.                 for (i = 0; i < nr_page_fetched; i++) {
     
126.                         put_page(dest_pages[i]);
     
127.                 }
     
128.                 goto CLEAN;
     
129.         }
     
130. 
     
131.         ctls = (struct async_submit_ctl *) kmalloc(nr_page * sizeof(struct async_submit_ctl), GFP_KERNEL);
     
132.         if (NULL == ctls) {
     
133.                 printk(KERN_ALERT "can NOT kmalloc memory.\n");
     
134.                 retval = -ENOMEM;
     
135.                 goto CLEAN;
     
136.         }
     
137. 
     
138.         desps = (struct dma_async_tx_descriptor **) kmalloc(nr_page * sizeof(struct dma_async_tx_descriptor *), GFP_KERNEL);
     
139.         if (NULL == desps) {
     
140.                 printk(KERN_ALERT "can NOT kmalloc memory.\n");
     
141.                 retval = -ENOMEM;
     
142.                 goto CLEAN;
     
143.         }
     
144. 
     
145.         for (i = 0; i < nr_page; i++) {
     
146.                 ctls[i].cb_fn = NULL;
     
147.                 ctls[i].cb_param = NULL;
     
148.                 ctls[i].depend_tx = NULL;
     
149.                 ctls[i].flags = ASYNC_TX_ACK;
     
150.                 ctls[i].scribble = NULL;
     
151.         }
     
152. 
     
153.         for (i = 0; i < nr_page; i++) {
     
154.                 printk(KERN_ALERT "copy %ldth page.\n", i + 1);
     
155.                 desps[i] = async_memcpy(dest_pages[i], src_pages[i], 0, 0, PAGE_SIZE, ctls + i);
     
156.         }
     
157. 
     
158.         for (i = 0; i < nr_page; i++) {
     
159.                 printk(KERN_ALERT "finished copying %ldth page.\n", i + 1);
     
160.                 if (NULL == desps) {
     
161.                         printk(KERN_ALERT "do NOT use DMA to memcpy.\n");
     
162.                 }
     
163.                 else {
     
164.                         dma_wait_for_async_tx(desps[i]);
     
165.                 }
     
166.         }
     
167.         for (i = 0; i < nr_page_fetched; i++) {
     
168.                 put_page(src_pages[i]);
     
169.                 set_page_dirty(dest_pages[i]);
     
170.                 put_page(dest_pages[i]);
     
171.         }
     
172. 
     
173. CLEAN :
     
174.         kfree(dest_pages);
     
175.         kfree(src_pages);
     
176.         kfree(ctls);
     
177.         kfree(desps);
     
178. 
     
179.         printk(KERN_ALERT "complete.\n");
     
180.         return retval;
     
181. }
     
182. module_init(memcpy_init);
     
183. module_exit(memcpy_exit);
     
184. 
     

复制代码

文件：dma_memcpy.h

1. #ifndef _DMA_MEMCPY_H_
   
2. #define _DMA_MEMCPY_H_
   
3. 
   
4. typedef struct dma_memcpy_ioctr {
   
5.         void * dest;
   
6.         void * src;
   
7.         unsigned long size;
   
8. } dma_memcpy_ioctr_t;
   
9. 
   
10. #ifndef __KERNEL__
    
11. #include <sys/ioctl.h>
    
12. #include <unistd.h>
    
13. #include <fcntl.h>
    
14. 
    
15. #define DMA_MEMCPY_DEVICE_NAME "dma_memcpy_device"
    
16. #define DMA_MEMCPY_DEVICE_PATH "/dev/dma_memcpy_device"
    
17. 
    
18. const unsigned long PAGE_SIZE = (unsigned long)getpagesize();
    
19. #define PAGE_MASK ( ~( PAGE_SIZE - 1 ))
    
20. inline void * page_align_up(void * point) {
    
21.         return (void *)(( ( unsigned long )(point) + PAGE_SIZE - 1 ) & PAGE_MASK );
    
22. }
    
23. 
    
24. static int dma_memcpy_device = 0;
    
25. 
    
26. /**
    
27. * @brief to open dma_memcpy_device
    
28. *
    
29. * @return return 1 if success, 0 otherwise.
    
30. */
    
31. inline int init_dma_memcpy() {
    
32.         dma_memcpy_device = open(DMA_MEMCPY_DEVICE_PATH, O_RDONLY);
    
33.         if (dma_memcpy_device <= 0) {
    
34.                 return 0;
    
35.         }
    
36.         return 1;
    
37. }
    
38. 
    
39. /**
    
40. * @brief to close dma_memcpy_device
    
41. */
    
42. inline void clean_dma_memcpy() {
    
43.         close(dma_memcpy_device);
    
44. }
    
45. 
    
46. /**
    
47. * @brief using dma to copy data in memory, dest and src are not overlapped.
    
48. *
    
49. * @param dest the destination point aligned with page size.
    
50. * @param src the source point aligned with page size.
    
51. * @param size the byte to be copied, must be the multiple of page size.
    
52. *
    
53. * @return the byte been copied. negative number on any error.
    
54. */
    
55. inline unsigned long dma_memcpy(void * dest, const void * src, unsigned long size) {
    
56.         int retval;
    
57.         dma_memcpy_ioctr_t ioctr;
    
58.         ioctr.dest = dest;
    
59.         ioctr.src = (void *)src;
    
60.         ioctr.size = size;
    
61. 
    
62.         retval = ioctl(dma_memcpy_device, 0, &ioctr);
    
63.         return retval;
    
64. }
    
65. 
    
66. #endif
    
67. 
    
68. #endif /*_DMA_MEMCPY_H_*/
    

复制代码

文件：Makefile

1. ifneq (X$(KERNELRELEASE),X)
   
2. obj-m := dma_memcpy.o
   
3. 
   
4. else
   
5. KERNELDIR := /lib/modules/$(shell uname -r)/build
   
6. PWD := $(shell pwd)
   
7. 
   
8. all:
   
9.         $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
   
10. endif
    
11. 
    
12. clean:
    
13.         @rm -f *.o *.mod.* *.ko *.symvers *.order .d*
    
14.         @rm -rf .tmp_versions
    
15.        
    
16. install:
    
17.         /bin/sh ./ins_memcpy_device.sh
    
18.        
    
19. .PHONY:all clean

复制代码

文件：ins_memcpy_device.sh

1. #!/bin/sh
   
2. module="dma_memcpy"
   
3. device="dma_memcpy_device"
   
4. mode="664"
   
5. 
   
6. # invoke modprobe to install depended module.
   
7. /sbin/modprobe async_memcpy
   
8. 
   
9. # uninstall old module.
   
10. /sbin/rmmod $module 2> /dev/null
    
11. 
    
12. # invoke insmod with all arguments we got
    
13. /sbin/insmod ./$module.ko $* || exit 1
    
14. 
    
15. major=`awk '$2~/dma_memcpy_device/ {print $1}' /proc/devices`
    
16. 
    
17. # remove stale node
    
18. rm -f /dev/$device 2> /dev/null
    
19. 
    
20. # make new
    
21. mknod /dev/$device c $major 0
    
22. 
    
23. # change owner
    
24. chmod $mode /dev/$device

复制代码

文件：test.cpp

1. #include <iostream>
   
2. #include <cstring>
   
3. #include <cassert>
   
4. #include <cstdio>
   
5. #include "dma_memcpy.h"
   
6. 
   
7. using namespace std;
   
8. 
   
9. int main()
   
10. {
    
11.         char * src, *dest;
    
12.         char * align_src, *align_dest;
    
13. 
    
14.         unsigned int nr_page = 10;
    
15. 
    
16.         src = new char[PAGE_SIZE * (nr_page + 1)];
    
17.         dest = new char[PAGE_SIZE * (nr_page + 1)];
    
18. 
    
19.         align_src = (char *) page_align_up(src);
    
20.         align_dest = (char *) page_align_up(dest);
    
21. 
    
22.         memset(align_dest, 'B', nr_page * PAGE_SIZE);
    
23.         memset(align_src, 'A', nr_page * PAGE_SIZE);
    
24. 
    
25.         if (!init_dma_memcpy()) {
    
26.                 perror("init_dma_memcpy");
    
27.                 return -1;
    
28.         }
    
29. 
    
30.         if (nr_page * PAGE_SIZE != dma_memcpy(align_dest, align_src, nr_page * PAGE_SIZE)) {
    
31.                 perror("dma_memcpy ");
    
32.         }
    
33. 
    
34.         assert(0 == memcmp(align_src, align_dest, nr_page * PAGE_SIZE));
    
35. 
    
36.         clean_dma_memcpy();
    
37. 
    
38.         cout << "All test is OK." << endl;
    
39. 
    
40.         return 0;
    
41. }
    

复制代码

蔡万钊

OMG ... 这样的效率已经低下到没有意义了。