现在的位置: 首页 > 综合 > 正文

进程地址空间[1]

2013年04月08日 ⁄ 综合 ⁄ 共 9421字 ⁄ 字号 小 中 大 ⁄ 评论关闭
 

     内核除了管理本身的内存外，还必须管理进程的地址空间，即系统中每个用户空间进程所看到的内存。Linux采用虚拟内存技术，系统中的所有进程之间以虚拟方式共享内存。对每个进程来说，它们好像都可以访问整个系统的所有物理内存；即使单独一个进程，它拥有的地址空间也可以远远大于系统物理内存。

    进程地址空间由每个进程中的线性地址区组成，而且更为重要的特点是内核允许进程使用该空间中的地址。每个进程都有一个32或64位的flat地址空间，空间的具体大小取决于体系结构。flat描述的是地址空间范围是一个独立的连续区间。通常情况下，每个进程都有惟一的这种flat地址空间，进程地址空间之间彼此互不相干。两个不同的进程可以在鸽子地址空间的相同地址内存放不同的数据。进程之间也可以选择共享地址空间，称这样的进程为线程。

    内存地址是一个给定的值，它要在地址空间范围之内。在地址空间中，我们更为关心的是进程有权访问的虚拟内存地址区间，这些可被访问的合法地址区间被称为内存区域(memory area)，通过内核，进程可以给自己的地址空间动态地添加或减少内存区域。

   进程只能访问有效范围内的内存地址。每个内存区域也具有相应进程必须遵循的特定访问属性，如果一个进程访问了不在有效范围中的地址，或以不正确的方式访问有效地址，那么内核就会终止该进程，并返回“段错误”信息。

   内存区域可以包含各种内存对象，比如：

1. 可执行文件代码的内存映射，称为代码段(text section)

2. 可执行文件的已初始化全局变量的内存映射，称为数据段(data section)

3. 包含未初始化全局变量，也就是bss段的零页（页面中的信息全部为0值，可用于映射bss段等目的）的内存映射。

   术语“BSS”是block started by symbol的缩写。因为未初始化的变量没有对应的值，所以不需要存放在可执行对象中。但是因为C标准强制规定未初始化的全局变量要被赋予特殊的默认值，所以内核要将未赋值的变量从可执行代码载入到内存中，然后将零页映射到该片内存上，于是这些未初始化的变量就被赋予了0值，这样避免了在目标文件中显式地进行初始化，减少空间浪费。

4. 用于进程用户空间栈(不要和进程内核栈混淆，进程的内核栈独立存在并由内核维护)的零页的内存映射。

5. 每一个诸如C库或动态连接程序等共享库的代码段，数据段和bss也会被载入进程的地址空间。

6. 任何内存映射文件

7. 任何共享内存段

8. 任何匿名的内存映射，比如由malloc()分配的内存。

   进程地址空间中的任何有效地址都只能位于惟一的区域。这些内存区域不能相互覆盖。在执行的进程中，每个不同的内存片段都对应一个独立的内存区域：栈、对象代码、全局变量、被映射的文件等。

  • 内存描述符

  内核使用内存描述符结构体表示进程的地址空间，该结构包含了和进程地址空间相关的全部信息：

 

  1. 在<include/linux/sched.h>中
  3. struct mm_struct {
  4.     struct vm_area_struct * mmap;       /* list of VMAs */
  5.     struct rb_root mm_rb;  /* 虚拟内存区域红黑树 */
  6.     struct vm_area_struct * mmap_cache; /* last find_vma result */
  7.     unsigned long (*get_unmapped_area) (struct file *filp,
  8.                 unsigned long addr, unsigned long len,
  9.                 unsigned long pgoff, unsigned long flags);
  10.     void (*unmap_area) (struct mm_struct *mm, unsigned long addr);
  11.     unsigned long mmap_base;        /* base of mmap area */
  12.     unsigned long task_size;        /* size of task vm space */
  13.     unsigned long cached_hole_size;         /* if non-zero, the largest hole below free_area_cache */
  14.     unsigned long free_area_cache;      /* first hole of size cached_hole_size or larger */
  15.     pgd_t * pgd;
  16.     atomic_t mm_users;          /* How many users with user space? */
  17.     atomic_t mm_count;          /* How many references to "struct mm_struct" (users count as 1) */
  18.     int map_count;              /* number of VMAs */
  19.     struct rw_semaphore mmap_sem;
  20.     spinlock_t page_table_lock;     /* Protects page tables and some counters */
  22.     struct list_head mmlist;        /* List of maybe swapped mm's.  These are globally strung
  23.                          * together off init_mm.mmlist, and are protected
  24.                          * by mmlist_lock
  25.                          */
  27.     /* Special counters, in some configurations protected by the
  28.      * page_table_lock, in other configurations by being atomic.
  29.      */
  30.     mm_counter_t _file_rss;
  31.     mm_counter_t _anon_rss;
  33.     unsigned long hiwater_rss;  /* High-watermark of RSS usage */
  34.     unsigned long hiwater_vm;   /* High-water virtual memory usage */
  36.     unsigned long total_vm, locked_vm, shared_vm, exec_vm;
  37.     unsigned long stack_vm, reserved_vm, def_flags, nr_ptes;
  38.     unsigned long start_code, end_code, start_data, end_data;
  39.     unsigned long start_brk, brk, start_stack;
  40.     unsigned long arg_start, arg_end, env_start, env_end;
  42.     unsigned long saved_auxv[AT_VECTOR_SIZE]; /* for /proc/PID/auxv */
  44.     cpumask_t cpu_vm_mask;
  46.     /* Architecture-specific MM context */
  47.     mm_context_t context; 
  49.     /* Swap token stuff */
  50.     /*
  51.      * Last value of global fault stamp as seen by this process.
  52.      * In other words, this value gives an indication of how long
  53.      * it has been since this task got the token.
  54.      * Look at mm/thrash.c
  55.      */
  56.     unsigned int faultstamp;
  57.     unsigned int token_priority;
  58.     unsigned int last_interval;
  60.     unsigned char dumpable:2;
  62.     /* coredumping support */
  63.     int core_waiters;    /*内核转储等待线程 */
  64.     struct completion *core_startup_done,/*core 开始完成 */ core_done/*core结束完成 */;
  66.     /* aio bits */
  67.     rwlock_t        ioctx_list_lock;   /* AIO IO链表锁*/
  68.     struct kioctx       *ioctx_list;  /* AIO IO链表*/
  69. };

   内核同时使用mm_count和mm_users这两个计数器是为了区别主使用计数器(mm_count)和使用该地址空间的进程数目(mm_users)。

   mmap和mm_rb这两个不同的数据结构体描述的对象是相同的：该地址空间中的全部内存区域。mmap是以链表形式存放的，这样利于简单高效地遍历所有元素；而mm_rb以红黑树形式存放，适合搜索指定元素。

   所有mm_struct结构体通过自身的mmlist域连接成一个双向链表中，首元素是init_mm内存描述符，它代表init进程的地址空间。操作该链表的时候，需要使用mmlist_lock锁（定义在kernel/fork.c中）来防止并发访问。

   内存描述符的总数存放在mmlist_nr全局变量（定义在kernel/fork.c中）中。

  • 分配内存描述符

   进程的进程描述符中，mm域存放着该进程使用的内存描述符，所以current->mm便指向当前进程的内存描述符。

   fork()函数利于copy_mm()函数复制父进程的内存描述符，就是将current->mm域给子进程，子进程中的mm_struct结构实际上是通过文件kernel/fork.c中的allocate_mm()宏从mm_cachep slab缓存中分配得到的。通常，每个进程都有唯一的mm_struct结构体，即唯一的进程地址空间。

   如果父进程希望和子进程共享地址空间，可以在调用clone()时，设置CLONE_VM标志。我们把这样的进程称为线程。

    2. /* SLAB cache for mm_struct structures (tsk->mm) */
    3. static struct kmem_cache *mm_cachep;
    5. #define allocate_mm()   (kmem_cache_alloc(mm_cachep, GFP_KERNEL))
    7. static int copy_mm(unsigned long clone_flags, struct task_struct * tsk)
    8. {
    9.     struct mm_struct * mm, *oldmm;
    10.     int retval;
    12.     tsk->min_flt = tsk->maj_flt = 0;
    13.     tsk->nvcsw = tsk->nivcsw = 0;
    15.     tsk->mm = NULL;
    16.     tsk->active_mm = NULL;
    18.     /*
    19.      * Are we cloning a kernel thread?
    20.      *
    21.      * We need to steal a active VM for that..
    22.      */
    23.     oldmm = current->mm;
    24.     if (!oldmm)
    25.         return 0;
    27.     if (clone_flags & CLONE_VM) {
    28.         atomic_inc(&oldmm->mm_users);
    29.         mm = oldmm;
    30.         goto good_mm;
    31.     }
    33.     retval = -ENOMEM;
    34.     mm = dup_mm(tsk);
    35.     if (!mm)
    36.         goto fail_nomem;
    38. good_mm:
    39.     /* Initializing for Swap token stuff */
    40.     mm->token_priority = 0;
    41.     mm->last_interval = 0;
    43.     tsk->mm = mm;
    44.     tsk->active_mm = mm;
    45.     return 0;
    47. fail_nomem:
    48.     return retval;
    49. }
  • 销毁内存描述符

  当进程退出时，内核会调用exit_mm()函数，该函数执行一些常规的销毁工作，同时更新一些统计量。

  1. 在<kernel/Exit.c>中
  2. /*
  3.  * Turn us into a lazy TLB process if we
  4.  * aren't already..
  5.  */
  6. static void exit_mm(struct task_struct * tsk)
  7. {
  8.     struct mm_struct *mm = tsk->mm;
  10.     mm_release(tsk, mm);
  11.     if (!mm)
  12.         return;
  13.     /*
  14.      * Serialize with any possible pending coredump.
  15.      * We must hold mmap_sem around checking core_waiters
  16.      * and clearing tsk->mm.  The core-inducing thread
  17.      * will increment core_waiters for each thread in the
  18.      * group with ->mm != NULL.
  19.      */
  20.     down_read(&mm->mmap_sem);
  21.     if (mm->core_waiters) {
  22.         up_read(&mm->mmap_sem);
  23.         down_write(&mm->mmap_sem);
  24.         if (!--mm->core_waiters)
  25.             complete(mm->core_startup_done);
  26.         up_write(&mm->mmap_sem);
  28.         wait_for_completion(&mm->core_done);
  29.         down_read(&mm->mmap_sem);
  30.     }
  31.     atomic_inc(&mm->mm_count);
  32.     BUG_ON(mm != tsk->active_mm);
  33.     /* more a memory barrier than a real lock */
  34.     task_lock(tsk);
  35.     tsk->mm = NULL;
  36.     up_read(&mm->mmap_sem);
  37.     enter_lazy_tlb(mm, current);
  38.     task_unlock(tsk);
  39.     mmput(mm);  //减少内存描述符中的mm_users用户计数
  40. }
  42. 在fork.c中
  44. /* Please note the differences between mmput and mm_release.
  45.  * mmput is called whenever we stop holding onto a mm_struct,
  46.  * error success whatever.
  47.  *
  48.  * mm_release is called after a mm_struct has been removed
  49.  * from the current process.
  50.  *
  51.  * This difference is important for error handling, when we
  52.  * only half set up a mm_struct for a new process and need to restore
  53.  * the old one.  Because we mmput the new mm_struct before
  54.  * restoring the old one. . .
  55.  * Eric Biederman 10 January 1998
  56.  */
  57. void mm_release(struct task_struct *tsk, struct mm_struct *mm)
  58. {
  59.     struct completion *vfork_done = tsk->vfork_done;
  61.     /* Get rid of any cached register state */
  62.     deactivate_mm(tsk, mm);
  64.     /* notify parent sleeping on vfork() */
  65.     if (vfork_done) {
  66.         tsk->vfork_done = NULL;
  67.         complete(vfork_done);
  68.     }
  70.     /*
  71.      * If we're exiting normally, clear a user-space tid field if
  72.      * requested.  We leave this alone when dying by signal, to leave
  73.      * the value intact in a core dump, and to save the unnecessary
  74.      * trouble otherwise.  Userland only wants this done for a sys_exit.
  75.      */
  76.     if (tsk->clear_child_tid
  77.         && !(tsk->flags & PF_SIGNALED)
  78.         && atomic_read(&mm->mm_users) > 1) {
  79.         u32 __user * tidptr = tsk->clear_child_tid;
  80.         tsk->clear_child_tid = NULL;
  82.         /*
  83.          * We don't check the error code - if userspace has
  84.          * not set up a proper pointer then tough luck.
  85.          */
  86.         put_user(0, tidptr);
  87.         sys_futex(tidptr, FUTEX_WAKE, 1, NULL, NULL, 0);
  88.     }
  89. }
  91. /*
  92.  * Decrement the use count and release all resources for an mm.
  93.  */
  94. void mmput(struct mm_struct *mm)
  95. {
  96.     might_sleep();
  98.     if (atomic_dec_and_test(&mm->mm_users)) {
  99.         exit_aio(mm);
  100.         exit_mmap(mm);
  101.         if (!list_empty(&mm->mmlist)) {
  102.             spin_lock(&mmlist_lock);
  103.             list_del(&mm->mmlist);
  104.             spin_unlock(&mmlist_lock);
  105.         }
  106.         put_swap_token(mm);
  107.         mmdrop(mm);
  108.     }
  109. }
  112. /*
  113.  * Called when the last reference to the mm
  114.  * is dropped: either by a lazy thread or by
  115.  * mmput. Free the page directory and the mm.
  116.  */
  117. void fastcall __mmdrop(struct mm_struct *mm)
  118. {
  119.     BUG_ON(mm == &init_mm);
  120.     mm_free_pgd(mm);
  121.     destroy_context(mm);
  122.     free_mm(mm);
  123. }
  125. 在sched.h中
  126. static inline void mmdrop(struct mm_struct * mm)
  127. {
  128.     if (atomic_dec_and_test(&mm->mm_count))
  129.         __mmdrop(mm);
  130. }

 

  • mm_struct与内核线程

  内核线程没有进程地址空间，也没有相关的内存描述符。所以内核线程对应的进程描述符中mm域为空。这正式内核线程的真正含义，它们没有用户上下文。

  内核线程并不需要访问任何用户空间的内存，以为内核线程在用户空间没有任何页，所以它们并不需要有自己的内存描述符和页表。尽管如此，即使访问内核内存，内核线程饿还是需要使用一些数据的，比如页表。为了避免内核线程为内存描述符和页表浪费内存，也为了当新内核线程运行时，避免浪费处理器周期向新地址空间进行切换，内核系拿出将直接使用前一个进程的内存描述符。

  当一个进程被调度时，该进程的mm域执行的地址空间被装载到内存，进程描述符中的active_mm域会被更新，指向新的地址空间。内核线程没有地址空间，所以mm为空。当内核线程被调度时，内核发现它的mm为空，就会保留前一个进程的地址空间，随后内核更新内核线程对应的进程描述符中的active_mm域，使其指向前一个进程的内存描述符，在需要时，内核线程可以使用前一个进程的页表。因为内核线程不访问用户空间的内存，所以它们仅仅使用地址空间中的和内核内存相关的信息。

  

 

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞