linux 虚拟内存管理

关于虚拟内存管理的基本内容参看相关内容，在此不再赘述，在理论的基础上，设计出合理的实验可以强化对理论的理解和应用能力

————————————————————————————————–

实验内容：在proc 文件系统下，建立一个文件，每次向这个文件写人字符时，调用相应的虚拟内存处理函数

1. /*
2. mtest_dump_vma_list（）：打印出当前进程的各个VMA，这个功能我们简称”listvma”
3. mtest_find_vma()： 找出某个虚地址所在的VMA，这个功能我们简称“findvma”
4. my_follow_page( )：根据页表，求出某个虚地址所在的物理页面，这个功能我们简称”findpage”
5. mtest_write_val(), 在某个地址写上具体数据，这个功能我们简称“writeval”.
6. */
8. #include <linux/module.h>
9. #include <linux/kernel.h>
10. #include <linux/proc_fs.h>
11. #include <linux/string.h>
12. #include <linux/vmalloc.h>
13. #include <asm/uaccess.h>
14. #include <linux/init.h>
15. #include <linux/slab.h>
16. #include <linux/mm.h>
17. #include <linux/vmalloc.h>
18. MODULE_LICENSE(“GPL”);
20. /*
21. @如何编写代码查看自己的进程到底有哪些虚拟区？
24. */
26. static void mtest_dump_vma_list(void)
27. {
28. struct mm_struct *mm = current->mm;
29. struct vm_area_struct *vma;
30. printk(“The current process is %s\n”,current->comm);
31. printk(“mtest_dump_vma_list\n”);
32. down_read(&mm->mmap_sem);
33. for (vma = mm->mmap;vma; vma = vma->vm_next) {
34. printk(“VMA 0x%lx-0x%lx ”,
35. vma->vm_start, vma->vm_end);
36. if (vma->vm_flags & VM_WRITE)
37. printk(“WRITE ”);
38. if (vma->vm_flags & VM_READ)
39. printk(“READ ”);
40. if (vma->vm_flags & VM_EXEC)
41. printk(“EXEC ”);
42. printk(“\n”);
43. }
44. up_read(&mm->mmap_sem);
45. }
48. /*
49. @如果知道某个虚地址，比如，0×8049000,
50. 又如何找到这个地址所在VMA是哪个？
53. */
56. static void  mtest_find_vma(unsigned long addr)
57. {
58. struct vm_area_struct *vma;
59. struct mm_struct *mm = current->mm;
61. printk(“mtest_find_vma\n”);
63. down_read(&mm->mmap_sem);
64. vma = find_vma(mm, addr);
65. if (vma && addr >= vma->vm_start) {
66. printk(“found vma 0x%lx-0x%lx flag %lx for addr 0x%lx\n”,
67. vma->vm_start, vma->vm_end, vma->vm_flags, addr);
68. } else {
69. printk(“no vma found for %lx\n”, addr);
70. }
71. up_read(&mm->mmap_sem);
72. }
74. /*
76. @一个物理页在内核中用struct page来描述。
77. 给定一个虚存区VMA和一个虚地址addr，
78. 找出这个地址所在的物理页面page.
80. */
83. static struct page *
84. my_follow_page(struct vm_area_struct *vma, unsigned long addr)
85. {
87. pud_t *pud;
88. pmd_t *pmd;
89. pgd_t *pgd;
90. pte_t *pte;
91. spinlock_t *ptl;
92. struct page *page = NULL;
93. struct mm_struct *mm = vma->vm_mm;
94. pgd = pgd_offset(mm, addr);
95. if (pgd_none(*pgd) || unlikely(pgd_bad(*pgd))) {
96. goto out;
97. }
98. pud = pud_offset(pgd, addr);
99. if (pud_none(*pud) || unlikely(pud_bad(*pud)))
100. goto out;
101. pmd = pmd_offset(pud, addr);
102. if (pmd_none(*pmd) || unlikely(pmd_bad(*pmd))) {
103. goto out;
104. }
105. pte = pte_offset_map_lock(mm, pmd, addr, &ptl);
106. if (!pte)
107. goto out;
108. if (!pte_present(*pte))
109. goto unlock;
110. page = pfn_to_page(pte_pfn(*pte));
111. if (!page)
112. goto unlock;
113. get_page(page);
114. unlock:
115. pte_unmap_unlock(pte, ptl);
116. out:
117. return page;
118. }
121. /*
123. @ 根据页表，求出某个虚地址所在的物理页面，
124. 这个功能我们简称”findpage”
127. */
129. static void   mtest_find_page(unsigned long addr)
130. {
132. struct vm_area_struct *vma;
133. struct mm_struct *mm = current->mm;
134. unsigned long kernel_addr;
135. struct page *page;
136. printk(“mtest_write_val\n”);
137. down_read(&mm->mmap_sem);
138. vma = find_vma(mm, addr);
139. page = my_follow_page(vma, addr);
141. if (!page)
142. {
143. printk(“page not found  for 0x%lx\n”, addr);
144. goto out;
146. }
147. printk(“page  found  for 0x%lx\n”, addr);
148. kernel_addr = (unsigned long)page_address(page);
150. kernel_addr += (addr&~PAGE_MASK);
151. printk(“find  0x%lx to kernel address 0x%lx\n”, addr, kernel_addr);
155. out:
156. up_read(&mm->mmap_sem);
158. }
163. /*
164. @你是否有这样的想法，
165. 给某个地址写入自己所想写的数据？
167. */
171. static void
172. mtest_write_val(unsigned long addr, unsigned long val)
173. {
174. struct vm_area_struct *vma;
175. struct mm_struct *mm = current->mm;
176. struct page *page;
177. unsigned long kernel_addr;
178. printk(“mtest_write_val\n”);
179. down_read(&mm->mmap_sem);
180. vma = find_vma(mm, addr);
181. if (vma && addr >= vma->vm_start && (addr + sizeof(val)) < vma->vm_end) {
182. if (!(vma->vm_flags & VM_WRITE)) {
183. printk(“vma is not writable for 0x%lx\n”, addr);
184. goto out;
185. }
186. page = my_follow_page(vma, addr);
187. if (!page) {
188. printk(“page not found  for 0x%lx\n”, addr);
189. goto out;
190. }
192. kernel_addr = (unsigned long)page_address(page);
193. kernel_addr += (addr&~PAGE_MASK);
194. printk(“write 0x%lx to address 0x%lx\n”, val, kernel_addr);
195. *(unsigned long *)kernel_addr = val;
196. put_page(page);
198. } else {
199. printk(“no vma found for %lx\n”, addr);
200. }
201. out:
202. up_read(&mm->mmap_sem);
203. }
207. static ssize_t
208. mtest_write(struct file *file, const char __user * buffer,
209. size_t count, loff_t * data)
210. {
213. printk(“mtest_write  ………..  \n”);
214. char buf[128];
215. unsigned long val, val2;
216. if (count > sizeof(buf))
217. return -EINVAL;
219. if (copy_from_user(buf, buffer, count))
220. return -EINVAL;
222. if (memcmp(buf, ”listvma”, 7) == 0)
223. mtest_dump_vma_list();
225. else if (memcmp(buf, ”findvma”, 7) == 0) {
226. if (sscanf(buf + 7, ”%lx”, &val) == 1) {
227. mtest_find_vma(val);
228. }
229. }
231. else if (memcmp(buf, ”findpage”, 8) == 0) {
232. if (sscanf(buf + 8, ”%lx”, &val) == 1) {
233. mtest_find_page(val);
235. //my_follow_page(vma, addr);
238. }
239. }
241. else  if (memcmp(buf, ”writeval”, 8) == 0) {
242. if (sscanf(buf + 8, ”%lx %lx”, &val, &val2) == 2) {
243. mtest_write_val(val, val2);
244. }
245. }
246. return count;
247. }
249. static struct
250. file_operations proc_mtest_operations = {
251. .write        = mtest_write
252. };
254. static struct proc_dir_entry *mtest_proc_entry;
257. //整个操作我们以模块的形式实现，因此，模块的初始化和退出函数如下：
258. static int __init
259. mtest_init(void)
260. {
262. mtest_proc_entry = create_proc_entry(“mtest”, 0777, NULL);
263. if (mtest_proc_entry == NULL) {
264. printk(“Error creating proc entry\n”);
265. return -1;
266. }
267. printk(“create the filename mtest mtest_init sucess  \n”);
268. mtest_proc_entry->proc_fops = &proc_mtest_operations;
269. return 0;
270. }
272. static void
273. __exit mtest_exit(void)
274. {
275. printk(“exit the module……mtest_exit \n”);
276. remove_proc_entry(“mtest”, NULL);
277. }
278. MODULE_LICENSE(“GPL”);
279. MODULE_DESCRIPTION(“mtest”);
280. MODULE_AUTHOR(“Zou Nan hai”);
282. module_init(mtest_init);
283. module_exit(mtest_exit);

下面为Makefile

1. obj-m := mm.o
3. # KDIR is the location of the kernel source.  The current standard is
4. # to link to the associated source tree from the directory containing
5. # the compiled modules.
6. KDIR  := /lib/modules/$(shell uname -r)/build
8. # PWD is the current working directory and the location of our module
9. # source files.
10. PWD   := $(shell pwd)
12. # default is the default make target.  The rule here says to run make
13. # with a working directory of the directory containing the kernel
14. # source and compile only the modules in the PWD (local) directory.
15. default:
16. $(MAKE) -C $(KDIR) M=$(PWD) modules
17. clean:
18. rm -rf *.o *.ko *.mod.c

下面为测试用例

[root@HBIDS proc]# echo “listvma” > mtest
[root@HBIDS proc]# echo “listvma” > mtest
[root@HBIDS proc]# echo “findvma0xb7f2b001″ > mtest
[root@HBIDS proc]# echo “findpage0xb7f2b001″ > mtest
[root@HBIDS proc]# echo “writeval0xb7f2b001 123456″ > mtest

打印结果为

The current process is bash
mtest_dump_vma_list
VMA 0×8048000-0x80dc000 READ EXEC
VMA 0x80dc000-0x80e2000 WRITE READ EXEC
VMA 0x80e2000-0x811e000 WRITE READ EXEC
VMA 0×42000000-0x4212e000 READ EXEC
VMA 0x4212e000-0×42131000 WRITE READ EXEC
VMA 0×42131000-0×42133000 WRITE READ EXEC
VMA 0xb7d00000-0xb7f00000 READ EXEC
VMA 0xb7f00000-0xb7f0b000 READ EXEC
VMA 0xb7f0b000-0xb7f0c000 WRITE READ EXEC
VMA 0xb7f0c000-0xb7f0d000 WRITE READ EXEC
VMA 0xb7f0d000-0xb7f0f000 READ EXEC
VMA 0xb7f0f000-0xb7f10000 WRITE READ EXEC
VMA 0xb7f10000-0xb7f13000 READ EXEC
VMA 0xb7f13000-0xb7f14000 WRITE READ EXEC
VMA 0xb7f2b000-0xb7f31000 READ EXEC
VMA 0xb7f31000-0xb7f32000 WRITE READ EXEC
VMA 0xb7f32000-0xb7f47000 READ EXEC
VMA 0xb7f47000-0xb7f48000 WRITE READ EXEC
VMA 0xbfd31000-0xbfd47000 WRITE READ EXEC
mtest_write  ………..
mtest_find_vma
found vma 0xb7f47000-0xb7f48000 flag 100877 for addr 0xb7f47001
mtest_write  ………..
mtest_write_val
page  found  for 0xb7f47001
find  0xb7f47001 to kernel address 0xc8c4e001
mtest_write  ………..
mtest_write_val
write 0×1234 to address 0xc8c4e001