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

/*
 * These are the virtual MM functions - opening of an area, closing and
 * unmapping it (needed to keep files on disk up-to-date etc), pointer
 * to the functions called when a no-page or a wp-page exception occurs. 
 */
struct vm_operations_struct {
  void (*open)(struct vm_area_struct * area);
  void (*close)(struct vm_area_struct * area);
  struct page * (*nopage)(struct vm_area_struct * area, unsigned long address, 
              int unused);
};

struct address_space {
  struct list_head  clean_pages;  /* list of clean pages */
  struct list_head  dirty_pages;  /* list of dirty pages */
  struct list_head  locked_pages; /* list of locked pages */
  unsigned long   nrpages;  /* number of total pages */
  struct address_space_operations *a_ops; /* methods */
  struct inode    *host;    /* owner: inode, block_device */
  struct vm_area_struct *i_mmap;  /* list of private mappings */
  struct vm_area_struct *i_mmap_shared; /* list of shared mappings */
  spinlock_t    i_shared_lock;  /* and spinlock protecting it */
  int     gfp_mask; /* how to allocate the pages */
};

       #include <sys/mman.h>

       void *mmap(void *addr, size_t length, int prot, int flags,
                  int fd, off_t offset);
       int munmap(void *addr, size_t length);

// arch/i386/kernel/sys_i386.c
asmlinkage long sys_mmap2(unsigned long addr, unsigned long len,
  unsigned long prot, unsigned long flags,
  unsigned long fd, unsigned long pgoff)
{
  return do_mmap2(addr, len, prot, flags, fd, pgoff);
}

static inline long do_mmap2(
  unsigned long addr, unsigned long len,
  unsigned long prot, unsigned long flags,
  unsigned long fd, unsigned long pgoff)
{
  int error = -EBADF;
  struct file * file = NULL;

  flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);
  if (!(flags & MAP_ANONYMOUS)) {
    file = fget(fd);
    if (!file)
      goto out;
  }

  down_write(&current->mm->mmap_sem);
  error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff);
  up_write(&current->mm->mmap_sem);

  if (file)
    fput(file);
out:
  return error;
}

// mm/mmap.c
unsigned long do_mmap_pgoff(struct file * file, unsigned long addr, unsigned long len,
  unsigned long prot, unsigned long flags, unsigned long pgoff)
{
  struct mm_struct * mm = current->mm;
  struct vm_area_struct * vma, * prev;
  unsigned int vm_flags;
  int correct_wcount = 0;
  int error;
  rb_node_t ** rb_link, * rb_parent;

  if (file && (!file->f_op || !file->f_op->mmap))
    return -ENODEV;

  if (!len)
    return addr;

  len = PAGE_ALIGN(len);

  if (len > TASK_SIZE || len == 0)
    return -EINVAL;

  /* offset overflow? */
  if ((pgoff + (len >> PAGE_SHIFT)) < pgoff)
    return -EINVAL;

  /* Too many mappings? */
  if (mm->map_count > max_map_count)
    return -ENOMEM;

  /* Obtain the address to map to. we verify (or select) it and ensure
   * that it represents a valid section of the address space.
   */
  addr = get_unmapped_area(file, addr, len, pgoff, flags);
  if (addr & ~PAGE_MASK)
    return addr;

  /* Do simple checking here so the lower-level routines won't have
   * to. we assume access permissions have been handled by the open
   * of the memory object, so we don't do any here.
   */
  vm_flags = calc_vm_flags(prot,flags) | mm->def_flags | VM_MAYREAD | VM_MAYWRITE | VM_MAYEXEC;

  /* mlock MCL_FUTURE? */
  if (vm_flags & VM_LOCKED) {
    unsigned long locked = mm->locked_vm << PAGE_SHIFT;
    locked += len;
    if (locked > current->rlim[RLIMIT_MEMLOCK].rlim_cur)
      return -EAGAIN;
  }

  if (file) {
    switch (flags & MAP_TYPE) {
    case MAP_SHARED:
      if ((prot & PROT_WRITE) && !(file->f_mode & FMODE_WRITE))
        return -EACCES;

      /* Make sure we don't allow writing to an append-only file.. */
      if (IS_APPEND(file->f_dentry->d_inode) && (file->f_mode & FMODE_WRITE))
        return -EACCES;

      /* make sure there are no mandatory locks on the file. */
      if (locks_verify_locked(file->f_dentry->d_inode))
        return -EAGAIN;

      vm_flags |= VM_SHARED | VM_MAYSHARE;
      if (!(file->f_mode & FMODE_WRITE))
        vm_flags &= ~(VM_MAYWRITE | VM_SHARED);

      /* fall through */
    case MAP_PRIVATE:
      if (!(file->f_mode & FMODE_READ))
        return -EACCES;
      break;

    default:
      return -EINVAL;
    }
  } else {
    vm_flags |= VM_SHARED | VM_MAYSHARE;
    switch (flags & MAP_TYPE) {
    default:
      return -EINVAL;
    case MAP_PRIVATE:
      vm_flags &= ~(VM_SHARED | VM_MAYSHARE);
      /* fall through */
    case MAP_SHARED:
      break;
    }
  }

  /* Clear old maps */
munmap_back:
  vma = find_vma_prepare(mm, addr, &prev, &rb_link, &rb_parent);
  if (vma && vma->vm_start < addr + len) {
    if (do_munmap(mm, addr, len))
      return -ENOMEM;
    goto munmap_back;
  }

  /* Check against address space limit. */
  if ((mm->total_vm << PAGE_SHIFT) + len
      > current->rlim[RLIMIT_AS].rlim_cur)
    return -ENOMEM;

  /* Private writable mapping? Check memory availability.. */
  if ((vm_flags & (VM_SHARED | VM_WRITE)) == VM_WRITE &&
      !(flags & MAP_NORESERVE)         &&
      !vm_enough_memory(len >> PAGE_SHIFT))
    return -ENOMEM;

  /* Can we just expand an old anonymous mapping? */
  if (!file && !(vm_flags & VM_SHARED) && rb_parent)
    if (vma_merge(mm, prev, rb_parent, addr, addr + len, vm_flags))
      goto out;

  /* Determine the object being mapped and call the appropriate
   * specific mapper. the address has already been validated, but
   * not unmapped, but the maps are removed from the list.
   */
  vma = kmem_cache_alloc(vm_area_cachep, SLAB_KERNEL);
  if (!vma)
    return -ENOMEM;

  vma->vm_mm = mm;
  vma->vm_start = addr;
  vma->vm_end = addr + len;
  vma->vm_flags = vm_flags;
  vma->vm_page_prot = protection_map[vm_flags & 0x0f];
  vma->vm_ops = NULL;
  vma->vm_pgoff = pgoff;
  vma->vm_file = NULL;
  vma->vm_private_data = NULL;
  vma->vm_raend = 0;

  if (file) {
    error = -EINVAL;
    if (vm_flags & (VM_GROWSDOWN|VM_GROWSUP))
      goto free_vma;
    if (vm_flags & VM_DENYWRITE) {
      error = deny_write_access(file);
      if (error)
        goto free_vma;
      correct_wcount = 1;
    }
    vma->vm_file = file;
    get_file(file);
    error = file->f_op->mmap(file, vma);
    if (error)
      goto unmap_and_free_vma;
  } else if (flags & MAP_SHARED) {
    error = shmem_zero_setup(vma);
    if (error)
      goto free_vma;
  }

  /* Can addr have changed??
   *
   * Answer: Yes, several device drivers can do it in their
   *         f_op->mmap method. -DaveM
   */
  if (addr != vma->vm_start) {
    /*
     * It is a bit too late to pretend changing the virtual
     * area of the mapping, we just corrupted userspace
     * in the do_munmap, so FIXME (not in 2.4 to avoid breaking
     * the driver API).
     */
    struct vm_area_struct * stale_vma;
    /* Since addr changed, we rely on the mmap op to prevent 
     * collisions with existing vmas and just use find_vma_prepare 
     * to update the tree pointers.
     */
    addr = vma->vm_start;
    stale_vma = find_vma_prepare(mm, addr, &prev,
            &rb_link, &rb_parent);
    /*
     * Make sure the lowlevel driver did its job right.
     */
    if (unlikely(stale_vma && stale_vma->vm_start < vma->vm_end)) {
      printk(KERN_ERR "buggy mmap operation: [<%p>]\n",
        file ? file->f_op->mmap : NULL);
      BUG();
    }
  }

  vma_link(mm, vma, prev, rb_link, rb_parent);
  if (correct_wcount)
    atomic_inc(&file->f_dentry->d_inode->i_writecount);

out:  
  mm->total_vm += len >> PAGE_SHIFT;
  if (vm_flags & VM_LOCKED) {
    mm->locked_vm += len >> PAGE_SHIFT;
    make_pages_present(addr, addr + len);
  }
  return addr;

unmap_and_free_vma:
  if (correct_wcount)
    atomic_inc(&file->f_dentry->d_inode->i_writecount);
  vma->vm_file = NULL;
  fput(file);

  /* Undo any partial mapping done by a device driver. */
  zap_page_range(mm, vma->vm_start, vma->vm_end - vma->vm_start);
free_vma:
  kmem_cache_free(vm_area_cachep, vma);
  return error;
}

// drivers/staging/android/binder.c
static struct file_operations binder_fops = {
  .owner = THIS_MODULE,
  .poll = binder_poll,
  .unlocked_ioctl = binder_ioctl,
  .mmap = binder_mmap,
  .open = binder_open,
  .flush = binder_flush,
  .release = binder_release,
};

static int binder_mmap(struct file *filp, struct vm_area_struct *vma)
{
  int ret;
  struct vm_struct *area;
  struct binder_proc *proc = filp->private_data;
  const char *failure_string;
  struct binder_buffer *buffer;

  if ((vma->vm_end - vma->vm_start) > SZ_4M)
    vma->vm_end = vma->vm_start + SZ_4M;

  if (binder_debug_mask & BINDER_DEBUG_OPEN_CLOSE)
    printk(KERN_INFO
      "binder_mmap: %d %lx-%lx (%ld K) vma %lx pagep %lx\n",
      proc->pid, vma->vm_start, vma->vm_end,
      (vma->vm_end - vma->vm_start) / SZ_1K, vma->vm_flags,
      (unsigned long)pgprot_val(vma->vm_page_prot));

  if (vma->vm_flags & FORBIDDEN_MMAP_FLAGS) {
    ret = -EPERM;
    failure_string = "bad vm_flags";
    goto err_bad_arg;
  }
  vma->vm_flags = (vma->vm_flags | VM_DONTCOPY) & ~VM_MAYWRITE;

  if (proc->buffer) {
    ret = -EBUSY;
    failure_string = "already mapped";
    goto err_already_mapped;
  }

  area = get_vm_area(vma->vm_end - vma->vm_start, VM_IOREMAP);
  if (area == NULL) {
    ret = -ENOMEM;
    failure_string = "get_vm_area";
    goto err_get_vm_area_failed;
  }
  proc->buffer = area->addr;
  proc->user_buffer_offset = vma->vm_start - (uintptr_t)proc->buffer;

#ifdef CONFIG_CPU_CACHE_VIPT
  if (cache_is_vipt_aliasing()) {
    while (CACHE_COLOUR((vma->vm_start ^ (uint32_t)proc->buffer))) {
      printk(KERN_INFO "binder_mmap: %d %lx-%lx maps %p bad alignment\n", proc->pid, vma->vm_start, vma->vm_end, proc->buffer);
      vma->vm_start += PAGE_SIZE;
    }
  }
#endif
  proc->pages = kzalloc(sizeof(proc->pages[0]) * ((vma->vm_end - vma->vm_start) / PAGE_SIZE), GFP_KERNEL);
  if (proc->pages == NULL) {
    ret = -ENOMEM;
    failure_string = "alloc page array";
    goto err_alloc_pages_failed;
  }
  proc->buffer_size = vma->vm_end - vma->vm_start;

  vma->vm_ops = &binder_vm_ops;
  vma->vm_private_data = proc;

  if (binder_update_page_range(proc, 1, proc->buffer, proc->buffer + PAGE_SIZE, vma)) {
    ret = -ENOMEM;
    failure_string = "alloc small buf";
    goto err_alloc_small_buf_failed;
  }
  buffer = proc->buffer;
  INIT_LIST_HEAD(&proc->buffers);
  list_add(&buffer->entry, &proc->buffers);
  buffer->free = 1;
  binder_insert_free_buffer(proc, buffer);
  proc->free_async_space = proc->buffer_size / 2;
  barrier();
  proc->files = get_files_struct(current);
  proc->vma = vma;

  /*printk(KERN_INFO "binder_mmap: %d %lx-%lx maps %p\n", proc->pid, vma->vm_start, vma->vm_end, proc->buffer);*/
  return 0;

err_alloc_small_buf_failed:
  kfree(proc->pages);
  proc->pages = NULL;
err_alloc_pages_failed:
  vfree(proc->buffer);
  proc->buffer = NULL;
err_get_vm_area_failed:
err_already_mapped:
err_bad_arg:
  printk(KERN_ERR "binder_mmap: %d %lx-%lx %s failed %d\n", proc->pid, vma->vm_start, vma->vm_end, failure_string, ret);
  return ret;
}

static struct vm_operations_struct binder_vm_ops = {
  .open = binder_vma_open,
  .close = binder_vma_close,
};

static void binder_vma_open(struct vm_area_struct *vma)
{
  struct binder_proc *proc = vma->vm_private_data;
  if (binder_debug_mask & BINDER_DEBUG_OPEN_CLOSE)
    printk(KERN_INFO
      "binder: %d open vm area %lx-%lx (%ld K) vma %lx pagep %lx\n",
      proc->pid, vma->vm_start, vma->vm_end,
      (vma->vm_end - vma->vm_start) / SZ_1K, vma->vm_flags,
      (unsigned long)pgprot_val(vma->vm_page_prot));
  dump_stack();
}

static void binder_vma_close(struct vm_area_struct *vma)
{
  struct binder_proc *proc = vma->vm_private_data;
  if (binder_debug_mask & BINDER_DEBUG_OPEN_CLOSE)
    printk(KERN_INFO
      "binder: %d close vm area %lx-%lx (%ld K) vma %lx pagep %lx\n",
      proc->pid, vma->vm_start, vma->vm_end,
      (vma->vm_end - vma->vm_start) / SZ_1K, vma->vm_flags,
      (unsigned long)pgprot_val(vma->vm_page_prot));
  proc->vma = NULL;
  binder_defer_work(proc, BINDER_DEFERRED_PUT_FILES);
}