进程地址空间[3]

   内核常常要判断进程地址空间中的内存区域是否满足某些条件，为了方便执行，内核定义了许多辅助函数，它们都声明在linux/mm.h中。 

• find_vma()

    在mm/mmap.c中

 

2. /* Look up the first VMA which satisfies  addr < vm_end,  NULL if none. */
3. struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr)
4. {
5.     struct vm_area_struct *vma = NULL;
7.     if (mm) {
8.         /* Check the cache first. */
9.         /* (Cache hit rate is typically around 35%.) */
10.         vma = mm->mmap_cache;
11. //如果缓存中并未包含希望的VMA，则搜索红黑树
12.         if (!(vma && vma->vm_end > addr && vma->vm_start <= addr)) {
13.             struct rb_node * rb_node;
15.             rb_node = mm->mm_rb.rb_node;
16.             vma = NULL;
18.             while (rb_node) {
19.                 struct vm_area_struct * vma_tmp;
21.                 vma_tmp = rb_entry(rb_node,
22.                         struct vm_area_struct, vm_rb);
24.                 if (vma_tmp->vm_end > addr) {
25.                     vma = vma_tmp;
26.                     if (vma_tmp->vm_start <= addr)
27.                         break;
28.                     rb_node = rb_node->rb_left;
29.                 } else
30.                     rb_node = rb_node->rb_right;
31.             }
32.             if (vma)
33.                 mm->mmap_cache = vma;
34.         }
35.     }
36.     return vma;  //返回第一个大于addr的VMA
37. }

    该函数在指定的地址空间中搜索第一个vm_end大于addr的内存区域。换句话说，该函数寻找第一个包含addr或首地址大于addr的内存区域。

   注意，由于返回的ＶＭＡ首地址可能大于addr，所以指定的地址并不一定就包含在返回的VMA中。因为肯那个在对某个VMA执行操作之后，还有其他操作会对该VMA继续进行，所以该函数返回的结果被缓存在内存描述符mm_struct中的mmap_cache域中。如果指定的地址不在缓存中，那么必须搜索和内存描述符相关的所有内存区域，这种搜索通过红黑树进行。

find_vma_prev()

   find_vma_prev()函数和find_vma()工作方式相同，但是它返回第一个小于addr的VMA。

 

2. /* Same as find_vma, but also return a pointer to the previous VMA in *pprev. */
3. struct vm_area_struct *
4. find_vma_prev(struct mm_struct *mm, unsigned long addr,
5.             struct vm_area_struct **pprev)
6. {
7.     struct vm_area_struct *vma = NULL, *prev = NULL;
8.     struct rb_node * rb_node;
9.     if (!mm)
10.         goto out;
12.     /* Guard against addr being lower than the first VMA */
13.     vma = mm->mmap;
15.     /* Go through the RB tree quickly. */
16.     rb_node = mm->mm_rb.rb_node;
18.     while (rb_node) {
19.         struct vm_area_struct *vma_tmp;
20.         vma_tmp = rb_entry(rb_node, struct vm_area_struct, vm_rb);
22.         if (addr < vma_tmp->vm_end) {
23.             rb_node = rb_node->rb_left;
24.         } else {
25.             prev = vma_tmp;
26.             if (!prev->vm_next || (addr < prev->vm_next->vm_end))
27.                 break;
28.             rb_node = rb_node->rb_right;
29.         }
30.     }
32. out:
33.     *pprev = prev;
34.     return prev ? prev->vm_next : vma;
35. }

• find_vma_intersection()

   find_vma_intersection()函数返回第一个和指定区间相交的VMA。因为该函数是内联函数，故定义在linux/mm.h中：

2. /* Look up the first VMA which intersects the interval start_addr..end_addr-1,
3.    NULL if none.  Assume start_addr < end_addr. */
4. static inline struct vm_area_struct * find_vma_intersection(struct mm_struct * mm, unsigned long start_addr, unsigned long end_addr)
5. {
6.     struct vm_area_struct * vma = find_vma(mm,start_addr);
8.     if (vma && end_addr <= vma->vm_start)
9.         vma = NULL;
10.     return vma;
11. }

• mmap()和do_mmap()：创建地址空间

   内核使用do_mmap()函数创建一个新的线性地址空间。如果说该函数创建了一个新的VMA并不非常准确，因为如果创建的地址区间和益而高已经存在的地址空间相邻，并且它们具有同样的访问权限的话，那么两个区间将合并为一个。如果不能合并，那么就确实要创建一个新的VMA了。无论哪种情况，do_mmap()都会将一个地址区间加入到进程的地址空间中（无论是扩展已存在的内存空间还是创建一个新的区域）。

1. 在mm.h中
2. static inline unsigned long do_mmap(struct file *file, unsigned long addr,
3.     unsigned long len, unsigned long prot,
4.     unsigned long flag, unsigned long offset)
5. {
6.     unsigned long ret = -EINVAL;
7.     if ((offset + PAGE_ALIGN(len)) < offset)
8.         goto out;
9.     if (!(offset & ~PAGE_MASK))
10.         ret = do_mmap_pgoff(file, addr, len, prot, flag, offset >> PAGE_SHIFT);
11. out:
12.     return ret;
13. }

 

   如果file参数是NULL并且offset参数也是0，那么就代表这次映射没有和文件相关，该情况被称作匿名映射；如果指定了文件名和偏移量，那么该映射被称为文件映射。

   addr是可选参数，它指定搜索空闲区域的起始位置。

   prot参数指定内存区域中页面的访问权限，不同的体系结构标志的定义不同。  flag参数指定了VMA标志。

1. /*
2.  Author: Michael S. Tsirkin <mst@mellanox.co.il>, Mellanox Technologies Ltd.
3.  Based on: asm-xxx/mman.h
4. */
6. #define PROT_READ   0x1     /* page can be read */
7. #define PROT_WRITE  0x2     /* page can be written */
8. #define PROT_EXEC   0x4     /* page can be executed */
9. #define PROT_SEM    0x8     /* page may be used for atomic ops */
10. #define PROT_NONE   0x0     /* page can not be accessed */
11. #define PROT_GROWSDOWN  0x01000000  /* mprotect flag: extend change to start of growsdown vma */
12. #define PROT_GROWSUP    0x02000000  /* mprotect flag: extend change to end of growsup vma */
14. #define MAP_SHARED  0x01        /* Share changes */
15. #define MAP_PRIVATE 0x02        /* Changes are private */
16. #define MAP_TYPE    0x0f        /* Mask for type of mapping */
17. #define MAP_FIXED   0x10        /* Interpret addr exactly */
18. #define MAP_ANONYMOUS   0x20        /* don't use a file */

1. 在mm/mmap.c中
2. /*
3.  * The caller must hold down_write(current->mm->mmap_sem).
4.  */
6. unsigned long do_mmap_pgoff(struct file * file, unsigned long addr,
7.             unsigned long len, unsigned long prot,
8.             unsigned long flags, unsigned long pgoff)
9. {
10.     struct mm_struct * mm = current->mm;
11.     struct vm_area_struct * vma, * prev;
12.     struct inode *inode;
13.     unsigned int vm_flags;
14.     int correct_wcount = 0;
15.     int error;
16.     struct rb_node ** rb_link, * rb_parent;
17.     int accountable = 1;
18.     unsigned long charged = 0, reqprot = prot;
20.     /*
21.      * Does the application expect PROT_READ to imply PROT_EXEC?
22.      *
23.      * (the exception is when the underlying filesystem is noexec
24.      *  mounted, in which case we dont add PROT_EXEC.)
25.      */
26.     if ((prot & PROT_READ) && (current->personality & READ_IMPLIES_EXEC))
27.         if (!(file && (file->f_path.mnt->mnt_flags & MNT_NOEXEC)))
28.             prot |= PROT_EXEC;
30.     if (!len)
31.         return -EINVAL;
33.     error = arch_mmap_check(addr, len, flags);
34.     if (error)
35.         return error;
37.     /* Careful about overflows.. */
38.     len = PAGE_ALIGN(len);
39.     if (!len || len > TASK_SIZE)
40.         return -ENOMEM;
42.     /* offset overflow? */
43.     if ((pgoff + (len >> PAGE_SHIFT)) < pgoff)
44.                return -EOVERFLOW;
46.     /* Too many mappings? */
47.     if (mm->map_count > sysctl_max_map_count)
48.         return -ENOMEM;
50.     /* Obtain the address to map to. we verify (or select) it and ensure
51.      * that it represents a valid section of the address space.
52.      */
53.     addr = get_unmapped_area(file, addr, len, pgoff, flags);
54.     if (addr & ~PAGE_MASK)
55.         return addr;
57.     /* Do simple checking here so the lower-level routines won't have
58.      * to. we assume access permissions have been handled by the open
59.      * of the memory object, so we don't do any here.
60.      */
61.     vm_flags = calc_vm_prot_bits(prot) | calc_vm_flag_bits(flags) |
62.             mm->def_flags | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC;
64.     if (flags & MAP_LOCKED) {
65.         if (!can_do_mlock())
66.             return -EPERM;
67.         vm_flags |= VM_LOCKED;
68.     }
69.     /* mlock MCL_FUTURE? */
70.     if (vm_flags & VM_LOCKED) {
71.         unsigned long locked, lock_limit;
72.         locked = len >> PAGE_SHIFT;
73.         locked += mm->locked_vm;
74.         lock_limit = current->signal->rlim[RLIMIT_MEMLOCK].rlim_cur;
75.         lock_limit >>= PAGE_SHIFT;
76.         if (locked > lock_limit && !capable(CAP_IPC_LOCK))
77.             return -EAGAIN;
78.     }
80.     inode = file ? file->f_path.dentry->d_inode : NULL;
82.     if (file) {
83.         switch (flags & MAP_TYPE) {
84.         case MAP_SHARED:
85.             if ((prot&PROT_WRITE) && !(file->f_mode&FMODE_WRITE))
86.                 return -EACCES;
88.             /*
89.              * Make sure we don't allow writing to an append-only
90.              * file..
91.              */
92.             if (IS_APPEND(inode) && (file->f_mode & FMODE_WRITE))
93.                 return -EACCES;
95.             /*
96.              * Make sure there are no mandatory locks on the file.
97.              */
98.             if (locks_verify_locked(inode))
99.                 return -EAGAIN;
101.             vm_flags |= VM_SHARED | VM_MAYSHARE;
102.             if (!(file->f_mode & FMODE_WRITE))
103.                 vm_flags &= ~(VM_MAYWRITE | VM_SHARED);
105.             /* fall through */
106.         case MAP_PRIVATE:
107.             if (!(file->f_mode & FMODE_READ))
108.                 return -EACCES;
109.             if (file->f_path.mnt->mnt_flags & MNT_NOEXEC) {
110.                 if (vm_flags & VM_EXEC)
111.                     return -EPERM;
112.                 vm_flags &= ~VM_MAYEXEC;
113.             }
114.             if (is_file_hugepages(file))
115.                 accountable = 0;
117.             if (!file->f_op || !file->f_op->mmap)
118.                 return -ENODEV;
119.             break;
121.         default:
122.             return -EINVAL;
123.         }
124.     } else {
125.         switch (flags & MAP_TYPE) {
126.         case MAP_SHARED:
127.             vm_flags |= VM_SHARED | VM_MAYSHARE;
128.             break;
129.         case MAP_PRIVATE:
130.             /*
131.              * Set pgoff according to addr for anon_vma.
132.              */
133.             pgoff = addr >> PAGE_SHIFT;
134.             break;
135.         default:
136.             return -EINVAL;
137.         }
138.     }
140.     error = security_file_mmap(file, reqprot, prot, flags);
141.     if (error)
142.         return error;
143.         
144.     /* Clear old maps */
145.     error = -ENOMEM;
146. munmap_back:
147.     vma = find_vma_prepare(mm, addr, &prev, &rb_link, &rb_parent);
148.     if (vma && vma->vm_start < addr + len) {
149.         if (do_munmap(mm, addr, len))
150.             return -ENOMEM;
151.         goto munmap_back;
152.     }
154.     /* Check against address space limit. */
155.     if (!may_expand_vm(mm, len >> PAGE_SHIFT))
156.         return -ENOMEM;
158.     if (accountable && (!(flags & MAP_NORESERVE) ||
159.                 sysctl_overcommit_memory == OVERCOMMIT_NEVER)) {
160.         if (vm_flags & VM_SHARED) {
161.             /* Check memory availability in shmem_file_setup? */
162.             vm_flags |= VM_ACCOUNT;
163.         } else if (vm_flags & VM_WRITE) {
164.             /*
165.              * Private writable mapping: check memory availability
166.              */
167.             charged = len >> PAGE_SHIFT;
168.             if (security_vm_enough_memory(charged))
169.                 return -ENOMEM;
170.             vm_flags |= VM_ACCOUNT;
171.         }
172.     }
174.     /*
175.      * Can we just expand an old private anonymous mapping?
176.      * The VM_SHARED test is necessary because shmem_zero_setup
177.      * will create the file object for a shared anonymous map below.
178.      */
179.     if (!file && !(vm_flags & VM_SHARED) &
180.         vma_merge(mm, prev, addr, addr + len, vm_flags,
181.                     NULL, NULL, pgoff, NULL))
182.         goto out;
184.     /*
185.      * Determine the object being mapped and call the appropriate
186.      * specific mapper. the address has already been validated, but
187.      * not unmapped, but the maps are removed from the list.
188.      */
189.     vma = kmem_cache_zalloc(vm_area_cachep, GFP_KERNEL);
190.     if (!vma) {
191.         error = -ENOMEM;
192.         goto unacct_error;
193.     }
195.     vma->vm_mm = mm;
196.     vma->vm_start = addr;
197.     vma->vm_end = addr + len;
198.     vma->vm_flags = vm_flags;
199.     vma->vm_page_prot = protection_map[vm_flags 
200.                 (VM_READ|VM_WRITE|VM_EXEC|VM_SHARED)];
201.     vma->vm_pgoff = pgoff;
203.     if (file) {
204.         error = -EINVAL;
205.         if (vm_flags & (VM_GROWSDOWN|VM_GROWSUP))
206.             goto free_vma;
207.         if (vm_flags & VM_DENYWRITE) {
208.             error = deny_write_access(file);
209.             if (error)
210.                 goto free_vma;
211.             correct_wcount = 1;
212.         }
213.         vma->vm_file = file;
214.         get_file(file);
215.         error = file->f_op->mmap(file, vma);
216.         if (error)
217.             goto unmap_and_free_vma;
218.     } else if (vm_flags & VM_SHARED) {
219.         error = shmem_zero_setup(vma);
220.         if (error)
221.             goto free_vma;
222.     }
224.     /* We set VM_ACCOUNT in a shared mapping's vm_flags, to inform
225.      * shmem_zero_setup (perhaps called through /dev/zero's ->mmap)
226.      * that memory reservation must be checked; but that reservation
227.      * belongs to shared memory object, not to vma: so now clear it.
228.      */
229.     if ((vm_flags & (VM_SHARED|VM_ACCOUNT)) == (VM_SHARED|VM_ACCOUNT))
230.         vma->vm_flags &= ~VM_ACCOUNT;
232.     /* Can addr have changed??
233.      *
234.      * Answer: Yes, several device drivers can do it in their
235.      *         f_op->mmap method. -DaveM
236.      */
237.     addr = vma->vm_start;
238.     pgoff = vma->vm_pgoff;
239.     vm_flags = vma->vm_flags;
241.     if (vma_wants_writenotify(vma))
242.         vma->vm_page_prot =
243.             protection_map[vm_flags & (VM_READ|VM_WRITE|VM_EXEC)];
245.     if (!file || !vma_merge(mm, prev, addr, vma->vm_end,
246.             vma->vm_flags, NULL, file, pgoff, vma_policy(vma))) {
247.         file = vma->vm_file;
248.         vma_link(mm, vma, prev, rb_link, rb_parent);
249.         if (correct_wcount)
250.             atomic_inc(&inode->i_writecount);
251.     } else {
252.         if (file) {
253.             if (correct_wcount)
254.                 atomic_inc(&inode->i_writecount);
255.             fput(file);
256.         }
257.         mpol_free(vma_policy(vma));
258.         kmem_cache_free(vm_area_cachep, vma);
259.     }
260. out:    
261.     mm->total_vm += len >> PAGE_SHIFT;
262.     vm_stat_account(mm, vm_flags, file, len >> PAGE_SHIFT);
263.     if (vm_flags & VM_LOCKED) {
264.         mm->locked_vm += len >> PAGE_SHIFT;
265.         make_pages_present(addr, addr + len);
266.     }
267.     if (flags & MAP_POPULATE) {
268.         up_write(&mm->mmap_sem);
269.         sys_remap_file_pages(addr, len, 0,
270.                     pgoff, flags & MAP_NONBLOCK);
271.         down_write(&mm->mmap_sem);
272.     }
273.     return addr;
275. unmap_and_free_vma:
276.     if (correct_wcount)
277.         atomic_inc(&inode->i_writecount);
278.     vma->vm_file = NULL;
279.     fput(file);
281.     /* Undo any partial mapping done by a device driver. */
282.     unmap_region(mm, vma, prev, vma->vm_start, vma->vm_end);
283.     charged = 0;
284. free_vma:
285.     kmem_cache_free(vm_area_cachep, vma);
286. unacct_error:
287.     if (charged)
288.         vm_unacct_memory(charged);
289.     return error;
290. }

mmap()系统调用

  在用户空间可以通过mmap()系统调用获取内核函数do_mmap()的功能。mmap()系统调用定义如下：

1. void *mmap2(void ＊start,size_t length,int prot,int flags,int fd,off_t pgoff)

  该系统调用是mmap()的变种所以起名为mmap2()。最原始的mmap()调用中最后一个参数是字节偏移量，而且目前这个变种使用页面偏移量最最后一个参数。使用页面偏移量可以映射更大的文件和更大的偏移位置。原始的mmap()调用由POSIX定义，仍然在C库中作为mmap()方法被使用。虽然C库仍然可以使用原始版本的映射方法，但是它其实还是基于函数mmap2()进行的，对原始mmap()方法的调用是通过将字节偏移转化为页面偏移，从而转化为对mmap2()函数的调用。

• munmap()和do_munmap()：删除地址空间

   do_munmap()函数从特定的进程地址空间中删除指定地址区间。

1. 
   
2. /* Munmap is split into 2 main parts -- this part which finds
3.  * what needs doing, and the areas themselves, which do the
4.  * work.  This now handles partial unmappings.
5.  * Jeremy Fitzhardinge <jeremy@goop.org>
6.  */
7. int do_munmap(struct mm_struct *mm, unsigned long start, size_t len)
8. {
9.     unsigned long end;
10.     struct vm_area_struct *vma, *prev, *last;
11. 
    
12.     if ((start & ~PAGE_MASK) || start > TASK_SIZE || len > TASK_SIZE-start)
13.         return -EINVAL;
14. 
    
15.     if ((len = PAGE_ALIGN(len)) == 0)
16.         return -EINVAL;
17. 
    
18.     /* Find the first overlapping VMA */
19.     vma = find_vma_prev(mm, start, &prev);
20.     if (!vma)
21.         return 0;
22.     /* we have  start < vma->vm_end  */
23. 
    
24.     /* if it doesn't overlap, we have nothing.. */
25.     end = start + len;
26.     if (vma->vm_start >= end)
27.         return 0;
28. 
    
29.     /*
30.      * If we need to split any vma, do it now to save pain later.
31.      *
32.      * Note: mremap's move_vma VM_ACCOUNT handling assumes a partially
33.      * unmapped vm_area_struct will remain in use: so lower split_vma
34.      * places tmp vma above, and higher split_vma places tmp vma below.
35.      */
36.     if (start > vma->vm_start) {
37.         int error = split_vma(mm, vma, start, 0);
38.         if (error)
39.             return error;
40.         prev = vma;
41.     }
42. 
    
43.     /* Does it split the last one? */
44.     last = find_vma(mm, end);
45.     if (last && end > last->vm_start) {
46.         int error = split_vma(mm, last, end, 1);
47.         if (error)
48.             return error;
49.     }
50.     vma = prev? prev->vm_next: mm->mmap;
51. 
    
52.     /*
53.      * Remove the vma's, and unmap the actual pages
54.      */
55.     detach_vmas_to_be_unmapped(mm, vma, prev, end);
56.     unmap_region(mm, vma, prev, start, end);
57. 
    
58.     /* Fix up all other VM information */
59.     remove_vma_list(mm, vma);
60. 
    
61.     return 0;
62. }
63. 
    

munmap()系统调用

   系统调用munmap()给用户空间程序提供了一种从自身地址空间中删除指定地址区间的方法，它的定义如下：

1. int munmap(void *start,size_t length)

   该系统调用定义在文件mm/mmap.c中，它是对do_munmap()函数的一个简单的封装：

1. asmlinkage long sys_munmap(unsigned long addr, size_t len)
2. {
3.     int ret;
4.     struct mm_struct *mm = current->mm;
6.     profile_munmap(addr);
8.     down_write(&mm->mmap_sem);
9.     ret = do_munmap(mm, addr, len);
10.     up_write(&mm->mmap_sem);
11.     return ret;
12. }