深入理解Linux虚拟内存管理（八）

// include/asm-i386/highmem.h
// 核心函数 __kmap 的第2个参数表示调用者将进行阻塞。
#define kmap(page) __kmap(page, 0)

// include/asm-i386/highmem.h
// 核心函数 __kmap 的第2个参数表示调用者将不进行阻塞。
#define kmap_nonblock(page) __kmap(page, 1)

// include/asm-i386/highmem.h
static inline void *__kmap(struct page *page, int nonblocking)
{
// 这个函数不会在中断时调用，因为它已睡眠。out_of_line_bug()调用do_exit并
// 返回错误码来取代BUG()。之所以不调用BUG()是因为BUG()用极端方式杀掉进程，这将
// 引起如寓言 “Aiee,杀掉中断句柄! ” 般的内核瘫痪。
  if (in_interrupt())
    out_of_line_bug();
  // 如果页面已在低端内存中，则返回一个直接映射。
  if (page < highmem_start_page)
    return page_address(page);
  // 调用kmap_high()(见L1. 4小节)完成与体系结构无关的工作。
  return kmap_high(page, nonblocking);
}

// mm/highmem.c
void *kmap_high(struct page *page, int nonblocking)
{
  unsigned long vaddr;

  /*
   * For highmem pages, we can't trust "virtual" until
   * after we have the lock.
   *
   * We cannot call this from interrupts, as it may block
   */
  // kmap_lock 保护页面的 virtual 字段和 pkmap_count 数组。
  spin_lock(&kmap_lock);
  // 获取页面的虚拟地址。
  vaddr = (unsigned long) page->virtual;
  // 如果尚未映射，则调用map_new_virtual(),进行页面映射并返回其虚拟地址。
  // 如果失败，则跳转到 out 处，释放自旋锁并返回 NULL。
  if (!vaddr) {
    vaddr = map_new_virtual(page, nonblocking);
    if (!vaddr)
      goto out;
  }
  // 增加页面映射的引用计数。
  pkmap_count[PKMAP_NR(vaddr)]++;
  // 如果计数现在小于2,则这是个严重的bug。在实际运行中，严重的系统问题可能会引起这个bug。
  if (pkmap_count[PKMAP_NR(vaddr)] < 2)
    BUG();
 out:
  // 释放 kmap_lock。
  spin_unlock(&kmap_lock);
  return (void*) vaddr;
}

// mm/highmem.c
static inline unsigned long map_new_virtual(struct page *page, int nonblocking)
{
  unsigned long vaddr;
  int count;

start:
  // 从最后一个可能的槽开始扫描。
  count = LAST_PKMAP;
  /* Find an empty entry */
  // 持续扫描并等待直至有一个槽空闲。这里可能导致某些进程进入死循环。
  for (;;) {
  // last_pkmap_nr 是扫描中最后一个pkmap。为阻止搜索同一个页面，记录该值就可以
  // 进行循环搜索。如果达到LAST_PKMAP,则折返为0。
    last_pkmap_nr = (last_pkmap_nr + 1) & LAST_PKMAP_MASK;
  // 在 last_pkmap_nr 折返为 0 时，调用 flush_all_zero_pkmaps() (I. 1, 6 小节)，在
  // 刷新TLB之前设置pkmap_count数组中所有的项从1改为0。接着重新设置LAST_PKMAP
  // 表示再次开始扫描。
    if (!last_pkmap_nr) {
      flush_all_zero_pkmaps();
      count = LAST_PKMAP;
    }
  // 如果元素为0,则表示为页面找到了一个可用槽。
    if (!pkmap_count[last_pkmap_nr])
      break;  /* Found a usable entry */
  // 转到下一个下标，开始扫描。
    if (--count)
      continue;
  // 下一块代码将睡眠,等待一个槽变空闲。如果调用者要求不阻塞该函数,则直接返回
    if (nonblocking)
      return 0;

    /*
     * Sleep for somebody else to unmap their entries
     */
// 如果在扫描完所有页面一遍后仍没有可用槽，则在pkmap_map_wait队列上睡眠直至在
// 解除映射后被唤醒。
    {
  // 声明该等待队列。
      DECLARE_WAITQUEUE(wait, current);
  // 设置队列可中断，因为是在内核空间中睡眠。
      current->state = TASK_UNINTERRUPTIBLE;
  // 添加自己到pkmap_map_wait队列。
      add_wait_queue(&pkmap_map_wait, &wait);
  // 释放kmap_lock自旋锁。
      spin_unlock(&kmap_lock);
  // 调用schedule(),使自己开始睡眠。在解除映射后如果有槽空闲，则自己被唤醒。
      schedule();
  // 从等待队列移除自己。
      remove_wait_queue(&pkmap_map_wait, &wait);
  // 重新获取kmap锁。
      spin_lock(&kmap_lock);

      /* Somebody else might have mapped it while we slept */
  // 如果在睡眠时有其他的事务映射了该页面，则仅仅返回地址，并由kmap_high()增加引用计数。
      if (page->virtual)
        return (unsigned long) page->virtual;

      /* Re-start */
  // 重新开始扫描。
      goto start;
    }
  }
// 这块代码在找到一个槽时进行处理，用于映射页面。
  // 获取被找到槽的虚拟地址。
  vaddr = PKMAP_ADDR(last_pkmap_nr);
  // 确保PTE与页面对应且已获得必需的保护，将其放置在页表中被找到槽的地方。
  set_pte(&(pkmap_page_table[last_pkmap_nr]), mk_pte(page, kmap_prot));
  // 初始化pkmap_count数组的值为1。该计数在父函数中增加，如果这是第一次在该
  // 函数处出现，可以保证这是第一次映射。
  pkmap_count[last_pkmap_nr] = 1;
  // 设置页面的虚拟字段。
  page->virtual = (void *) vaddr;
  // 返回虚拟地址。
  return vaddr;
}

// mm/highmem.c
static void flush_all_zero_pkmaps(void)
{
  int i;
  // 由于全局页表将变化，因此必须刷新所有处理器的CPU高速缓存。
  flush_cache_all();
  // 循环遍历整个pkmap_count数组。
  for (i = 0; i < LAST_PKMAP; i++) {
    struct page *page;

    /*
     * zero means we don't have anything to do,
     * >1 means that it is still in use. Only
     * a count of 1 means that it is free but
     * needs to be unmapped
     */
  // 如果元素不为1,则移到下一个元素。
    if (pkmap_count[i] != 1)
      continue;
  // 从1设置为0。
    pkmap_count[i] = 0;

    /* sanity check */
  // 确保PTE没有被映射过。
    if (pte_none(pkmap_page_table[i]))
      BUG();

    /*
     * Don't need an atomic fetch-and-clear op here;
     * no-one has the page mapped, and cannot get at
     * its virtual address (and hence PTE) without first
     * getting the kmap_lock (which is held here).
     * So no dangers, even with speculative execution.
     */
  // 从PTE解除对页面的映射,并清除PTE。
    page = pte_page(pkmap_page_table[i]);
    pte_clear(&pkmap_page_table[i]);
  // 更新虚拟字段为页面未被映射。
    page->virtual = NULL;
  }
  // 刷新TLB。
  flush_tlb_all();
}

// include/asm-i386/kmap_types.h
enum km_type {
  KM_BOUNCE_READ,
  KM_SKB_SUNRPC_DATA,
  KM_SKB_DATA_SOFTIRQ,
  KM_USER0,
  KM_USER1,
  KM_BH_IRQ,
  KM_SOFTIRQ0,
  KM_SOFTIRQ1,
  KM_TYPE_NR
};

// include/asm-i386/highmem.h
/*
 * The use of kmap_atomic/kunmap_atomic is discouraged - kmap/kunmap
 * gives a more generic (and caching) interface. But kmap_atomic can
 * be used in IRQ contexts, so in some (very limited) cases we need
 * it.
 */
// 这里的参数为映射的页面和处理所需的类型。一个槽的使用对应一个处理器。
static inline void *kmap_atomic(struct page *page, enum km_type type)
{
  enum fixed_addresses idx;
  unsigned long vaddr;
  // 如果页面在低端内存，则返回直接映射。
  if (page < highmem_start_page)
    return page_address(page);
  // type给出了使用哪个槽。而 KM_TYPE_NR * smp_processor_id() 则给出了为处理
  // 器保留的槽的集合。
  idx = type + KM_TYPE_NR*smp_processor_id();
  // 获取虚拟地址。
  vaddr = __fix_to_virt(FIX_KMAP_BEGIN + idx);
#if HIGHMEM_DEBUG
  // 用于调试的代码。在实际运行中，PTE将退出。
  if (!pte_none(*(kmap_pte-idx)))
    out_of_line_bug();
#endif
  // 为保留的槽设置PTE。
  set_pte(kmap_pte-idx, mk_pte(page, kmap_prot));
  // 为槽刷新TLB。
  __flush_tlb_one(vaddr);
  // 返回虚拟地址。
  return (void*) vaddr;
}

// include/asm-i386/highmem.h
static inline void kunmap(struct page *page)
{
  // kunmap()不能在中断中进行调用，因此自然退出。
  if (in_interrupt())
    out_of_line_bug();
  // 如果页面已在低端内存中，则不需要进行解除映射的操作。
  if (page < highmem_start_page)
    return;
  // 调用与体系结构无关的函数kunmap_high()。
  kunmap_high(page);
}

// mm/highmem.c
void kunmap_high(struct page *page)
{
  unsigned long vaddr;
  unsigned long nr;
  int need_wakeup;
  // 获取kmap锁, 用来保护虚拟字段和pkmap_count数组。
  spin_lock(&kmap_lock);
  // 获取虚拟页面
  vaddr = (unsigned long) page->virtual;
  // 如果没有设置虚拟字段，那这是两次解除映射的操作或是对没有映射页面的解
  // 除映射操作,则调用BUG。
  if (!vaddr)
    BUG();
  // 获取在pkmap_count数组中的下标。
  nr = PKMAP_NR(vaddr);

  /*
   * A count must never go down to zero
   * without a TLB flush!
   */
  // 在缺省情况下，并不需要唤醒进程来调用kmap()。
  need_wakeup = 0;
  // 在减小下标后检查其值。
  switch (--pkmap_count[nr]) {
  // 如果减为0,那这是个bug,因为需要刷新TLB以使0成为合法项。
  case 0:
    BUG();
  // 如果减小到1(项虽然已释放，但还需要刷新TLB),则检查是否有谁在
  // pkmap_map_wait_queue队列上睡眠。如果有必要，则在释放自旋锁后唤醒队列。
  case 1:
    /*
     * Avoid an unnecessary wake_up() function call.
     * The common case is pkmap_count[] == 1, but
     * no waiters.
     * The tasks queued in the wait-queue are guarded
     * by both the lock in the wait-queue-head and by
     * the kmap_lock.  As the kmap_lock is held here,
     * no need for the wait-queue-head's lock.  Simply
     * test if the queue is empty.
     */
    need_wakeup = waitqueue_active(&pkmap_map_wait);
  }
  // 释放 kmap_lock。
  spin_unlock(&kmap_lock);

  /* do wake-up, if needed, race-free outside of the spin lock */
  // 如果还有等待者在队列上而槽已被释放,则唤醒它们。
  if (need_wakeup)
    wake_up(&pkmap_map_wait);
}

// include/asm-i386/highmem.h
static inline void kunmap_atomic(void *kvaddr, enum km_type type)
{
#if HIGHMEM_DEBUG
  // 获取虚拟地址并确保它和单个页边界对齐。
  unsigned long vaddr = (unsigned long) kvaddr & PAGE_MASK;
  enum fixed_addresses idx = type + KM_TYPE_NR*smp_processor_id();
  // 如果提供的地址不在定长区域内，则返回。
  if (vaddr < FIXADDR_START) // FIXME
    return;

  // 如果地址与使用类型及处理器不对应，则声明它。
  if (vaddr != __fix_to_virt(FIX_KMAP_BEGIN+idx))
    out_of_line_bug();

  /*
   * force other mappings to Oops if they'll try to access
   * this pte without first remap it
   */
  // 现在解除页面映射，如果再次引用它，则会产生oops。
  pte_clear(kmap_pte-idx);
  __flush_tlb_one(vaddr);
#endif
}

// mm/highmem.c
// 函数的参数如下所示:
//  rw 如果是写缓冲区，则设置为1。
//  bh_orig 是模板缓冲区头，是复制数据源。
struct buffer_head * create_bounce(int rw, struct buffer_head * bh_orig)
{
  struct page *page;
  struct buffer_head *bh;
  // 如果模板缓冲区头已在低端内存中，则简单地返回它。
  if (!PageHighMem(bh_orig->b_page))
    return bh_orig;
  // 从slab分配器分别缓冲区头，如果失败则从紧急池分配。
  bh = alloc_bounce_bh();
  /*
   * This is wasteful for 1k buffers, but this is a stopgap measure
   * and we are being ineffective anyway. This approach simplifies
   * things immensly. On boxes with more than 4GB RAM this should
   * not be an issue anyway.
   */
  // 从伙伴分配器分配页面,如果失败则从紧急池分配。
  page = alloc_bounce_page();
  // 将分配的页面与分配的缓冲区头关联起来。
  set_bh_page(bh, page, 0);

// 这块产生新的缓冲区头。
  // 逐个复制必要的信息，除了 b_list 字段，因为该缓冲区并不与该链表上的其他部分直
  // 接连接。
  bh->b_next = NULL;
  bh->b_blocknr = bh_orig->b_blocknr;
  bh->b_size = bh_orig->b_size;
  bh->b_list = -1;
  bh->b_dev = bh_orig->b_dev;
  bh->b_count = bh_orig->b_count;
  bh->b_rdev = bh_orig->b_rdev;
  bh->b_state = bh_orig->b_state;
#ifdef HIGHMEM_DEBUG
// 仅用于调试的信息。
  bh->b_flushtime = jiffies;
  bh->b_next_free = NULL;
  bh->b_prev_free = NULL;
  /* bh->b_this_page */
  bh->b_reqnext = NULL;
  bh->b_pprev = NULL;
#endif
  /* bh->b_page */
  if (rw == WRITE) {
// 如果这个缓冲区将被写入，则用于结束I/O的回调函数是bounce_end_io_write()
// (见L 5. 2.1节)，它在设备接收所有信息后调用。由于数据在高端内存中，则从
// copy_from_high_bh() (见 I. 5. 2. 3)复制 “下来” 。
    bh->b_end_io = bounce_end_io_write;
    copy_from_high_bh(bh, bh_orig);
  } else
// 如果等待设备写数据到缓冲区中，则调用bounce_end_io_read() (见I. 5.2.2)
// 回调函数。
    bh->b_end_io = bounce_end_io_read;
// 从模板缓冲区头复制剩下的信息。
  bh->b_private = (void *)bh_orig;
  bh->b_rsector = bh_orig->b_rsector;
#ifdef HIGHMEM_DEBUG
  memset(&bh->b_wait, -1, sizeof(bh->b_wait));
#endif
  // 返回新弹性缓冲区
  return bh;
}

// fs/buffer.c
void set_bh_page (struct buffer_head *bh, struct page *page, unsigned long offset)
{
  if (offset >= PAGE_SIZE)
    BUG();

  if (PageHighMem(page)) {
    bh->b_data = (char *)offset;
  } else {
    bh->b_data = page_address(page) + offset;
  }
  bh->b_page = page;
}
EXPORT_SYMBOL(set_bh_page);

// mm/highmem.c
struct buffer_head *alloc_bounce_bh (void)
{
  struct list_head *tmp;
  struct buffer_head *bh;
  // 尝试从slab分配器分配一个新buffer_head。 请注意，如何产生不使用I/O操作的请
  // 求以避免递归，包括高级I/O。
  bh = kmem_cache_alloc(bh_cachep, SLAB_NOHIGHIO);
  // 如果分配成功，则返回。
  if (bh)
    return bh;
  /*
   * No luck. First, kick the VM so it doesn't idle around while
   * we are using up our emergency rations.
   */
  // 如果失败，则唤醒bdflush清洗页面。
  wakeup_bdflush();

repeat_alloc:
  /*
   * Try to allocate from the emergency pool.
   */
// 由于从slab分配失败，因此从紧急池中分配。
  // 取得紧急池头链表的尾部。
  tmp = &emergency_bhs;
  // 获取保护池的锁。
  spin_lock_irq(&emergency_lock);
  // 如果池不空，则从链表取得一个缓冲区并减小nr_emergency_bhs计数器。
  if (!list_empty(tmp)) {
    bh = list_entry(tmp->next, struct buffer_head, b_inode_buffers);
    list_del(tmp->next);
    nr_emergency_bhs--;
  }
  // 释放锁。
  spin_unlock_irq(&emergency_lock);
  // 如果分配成功，则返回它。
  if (bh)
    return bh;

  /* we need to wait I/O completion */
  // 如果失败，则表示内存不足,那么补充池的惟一方法便是完成高端内存I/O操作。就
  // 这样，请求从tq_disk开始，然后写数据到磁盘，接着释放进程中适当的页面。
  run_task_queue(&tq_disk);
  // 出让处理器。
  yield();
  // 再次尝试从紧急池分配。
  goto repeat_alloc;
}

// mm/highmem.c
struct page *alloc_bounce_page (void)
{
  struct list_head *tmp;
  struct page *page;
  // 从伙伴分配器进行分配，如果成功则返回页面。
  page = alloc_page(GFP_NOHIGHIO);
  if (page)
    return page;
  /*
   * No luck. First, kick the VM so it doesn't idle around while
   * we are using up our emergency rations.
   */
  // 唤醒bdflush清洗页面。
  wakeup_bdflush();

repeat_alloc:
  /*
   * Try to allocate from the emergency pool.
   */
  // 取得紧急池缓冲区头链表尾部。   
  tmp = &emergency_pages;
  // 获取保护池的锁。
  spin_lock_irq(&emergency_lock);
  // 如果池不空，则从链表取得页面并减小可用nr_emergency_pages的计数。
  if (!list_empty(tmp)) {
    page = list_entry(tmp->next, struct page, list);
    list_del(tmp->next);
    nr_emergency_pages--;
  }
  // 释放锁。
  spin_unlock_irq(&emergency_lock);
  // 如果分配成功，则返回它。
  if (page)
    return page;

  /* we need to wait I/O completion */
  // 运行I/O任务队列，尝试并补充紧急池。
  run_task_queue(&tq_disk);
  // 让出处理器。
  yield();
  // 再次尝试从紧急池中分配。
  goto repeat_alloc;
}

// mm/highmem.c
static void bounce_end_io_write (struct buffer_head *bh, int uptodate)
{
  bounce_end_io(bh, uptodate);
}

// mm/highmem.c
static void bounce_end_io_read (struct buffer_head *bh, int uptodate)
{
  struct buffer_head *bh_orig = (struct buffer_head *)(bh->b_private);

  // 调用copy_to_high_bh_irq() 从弹性缓冲区复制数据并移至高端内存。
  if (uptodate)
    copy_to_high_bh_irq(bh_orig, bh);
  // 回收资源。
  bounce_end_io(bh, uptodate);
}

// mm/highmem.c
/*
 * Simple bounce buffer support for highmem pages.
 * This will be moved to the block layer in 2.5.
 */

static inline void copy_from_high_bh (struct buffer_head *to,
       struct buffer_head *from)
{
  struct page *p_from;
  char *vfrom;

  p_from = from->b_page;
  // 映射高端内存页面到低端内存。该执行路径由IRQ安全锁io_request_lock保护，这
  // 样可以安全地调用kmap_atomic()(见I. 2.1小节)。
  vfrom = kmap_atomic(p_from, KM_USER0);
  // 复制数据。
  memcpy(to->b_data, vfrom + bh_offset(from), to->b_size);
  // 解除页面映射。
  kunmap_atomic(vfrom, KM_USER0);
}

// mm/highmem.c
static inline void copy_to_high_bh_irq (struct buffer_head *to,
       struct buffer_head *from)
{
  struct page *p_to;
  char *vto;
  unsigned long flags;

  p_to = to->b_page;
  // 保存标志位并禁止中断。
  __save_flags(flags);
  __cli();
  // 映射高端内存页面到低端内存。
  vto = kmap_atomic(p_to, KM_BOUNCE_READ);
  // 复制数据。
  memcpy(vto + bh_offset(to), from->b_data, to->b_size);
  // 解除页面映射。
  kunmap_atomic(vto, KM_BOUNCE_READ);
  // 恢复中断标志位。
  __restore_flags(flags);
}

// mm/highmem.c
static inline void bounce_end_io (struct buffer_head *bh, int uptodate)
{
  struct page *page;
  struct buffer_head *bh_orig = (struct buffer_head *)(bh->b_private);
  unsigned long flags;
  // 为原始 buffer_head 调用I/O完成的回调函数。
  bh_orig->b_end_io(bh_orig, uptodate);
  // 获取指向待释放的缓冲区页面的指针。
  page = bh->b_page;
  // 获取紧急池的锁。
  spin_lock_irqsave(&emergency_lock, flags);
// 如果页面池已满，则仅返回页面至伙伴分配器进行页面释放 
  if (nr_emergency_pages >= POOL_SIZE)
    __free_page(page);
  else {
// 否则，添加页面到紧急池。 
    /*
     * We are abusing page->list to manage
     * the highmem emergency pool:
     */
    list_add(&page->list, &emergency_pages);
    nr_emergency_pages++;
  }

  if (nr_emergency_bhs >= POOL_SIZE) {
// 如果 buffer_head 池已满，则仅返回它至slab分配器进行释放
#ifdef HIGHMEM_DEBUG
    /* Don't clobber the constructed slab cache */
    init_waitqueue_head(&bh->b_wait);
#endif
    kmem_cache_free(bh_cachep, bh);
  } else {
//  否则，添加该 buffer_head  到紧急池。 
    /*
     * Ditto in the bh case, here we abuse b_inode_buffers:
     */
    list_add(&bh->b_inode_buffers, &emergency_bhs);
    nr_emergency_bhs++;
  }
  // 释放锁。
  spin_unlock_irqrestore(&emergency_lock, flags);
}

// mm/highmem.c
static __init int init_emergency_pool(void)
{
  struct sysinfo i;
        si_meminfo(&i);
        si_swapinfo(&i);
  // 如果没有可用的高端内存，则返回。       
        if (!i.totalhigh)
          return 0;
  // 获取保护紧急池的锁。
  spin_lock_irq(&emergency_lock);
// 从伙伴分配器分配POOL_SIZE个页面并添加它们到链接表中。然后用
// nr_emergency_pages 记录紧急池中页面的数量。
  while (nr_emergency_pages < POOL_SIZE) {
    struct page * page = alloc_page(GFP_ATOMIC);
    if (!page) {
      printk("couldn't refill highmem emergency pages");
      break;
    }
    list_add(&page->list, &emergency_pages);
    nr_emergency_pages++;
  }
// 从slab分配器分配POOL_SIZE个buffer_head对象，并添加它们到由b_inode_buffers链接
// 的链表中。而且以nr_emergency_bhs记录池中缓冲区头的数量。
  while (nr_emergency_bhs < POOL_SIZE) {
    struct buffer_head * bh = kmem_cache_alloc(bh_cachep, SLAB_ATOMIC);
    if (!bh) {
      printk("couldn't refill highmem emergency bhs");
      break;
    }
    list_add(&bh->b_inode_buffers, &emergency_bhs);
    nr_emergency_bhs++;
  }
  // 释放用于保护池的锁。
  spin_unlock_irq(&emergency_lock);
  printk("allocated %d pages and %d bhs reserved for the highmem bounces\n",
         nr_emergency_pages, nr_emergency_bhs);
  // 返回成功。
  return 0;
}

// mm/vmscan.c
int try_to_free_pages_zone(zone_t *classzone, unsigned int gfp_mask)
{
  int priority = DEF_PRIORITY;
  int nr_pages = SWAP_CLUSTER_MAX;

  gfp_mask = pf_gfp_mask(gfp_mask);
  do {
    nr_pages = shrink_caches(classzone, priority, gfp_mask, nr_pages);
    if (nr_pages <= 0)
      return 1;
  } while (--priority);

  /*
   * Hmm.. Cache shrink failed - time to kill something?
   * Mhwahahhaha! This is the part I really like. Giggle.
   */
  out_of_memory();
  return 0;
}