Quelle  mmap.c   Sprache: C

/*
 * arch/sh/mm/mmap.c
 *
 * Copyright (C) 2008 - 2009  Paul Mundt
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 */
#include <linux/io.h>
#include <linux/mm.h>
#include <linux/sched/mm.h>
#include <linux/mman.h>
#include <linux/module.h>
#include <asm/page.h>
#include <asm/processor.h>

unsigned long shm_align_mask = PAGE_SIZE - 1; /* Sane caches */
EXPORT_SYMBOL(shm_align_mask);

#ifdef CONFIG_MMU
static const pgprot_t protection_map[16] = {
 [VM_NONE]     = PAGE_NONE,
 [VM_READ]     = PAGE_READONLY,
 [VM_WRITE]     = PAGE_COPY,
 [VM_WRITE | VM_READ]    = PAGE_COPY,
 [VM_EXEC]     = PAGE_EXECREAD,
 [VM_EXEC | VM_READ]    = PAGE_EXECREAD,
 [VM_EXEC | VM_WRITE]    = PAGE_COPY,
 [VM_EXEC | VM_WRITE | VM_READ]   = PAGE_COPY,
 [VM_SHARED]     = PAGE_NONE,
 [VM_SHARED | VM_READ]    = PAGE_READONLY,
 [VM_SHARED | VM_WRITE]    = PAGE_WRITEONLY,
 [VM_SHARED | VM_WRITE | VM_READ]  = PAGE_SHARED,
 [VM_SHARED | VM_EXEC]    = PAGE_EXECREAD,
 [VM_SHARED | VM_EXEC | VM_READ]   = PAGE_EXECREAD,
 [VM_SHARED | VM_EXEC | VM_WRITE]  = PAGE_RWX,
 [VM_SHARED | VM_EXEC | VM_WRITE | VM_READ] = PAGE_RWX
};
DECLARE_VM_GET_PAGE_PROT

/*
 * To avoid cache aliases, we map the shared page with same color.
 */
static inline unsigned long COLOUR_ALIGN(unsigned long addr,
      unsigned long pgoff)
{
 unsigned long base = (addr + shm_align_mask) & ~shm_align_mask;
 unsigned long off = (pgoff << PAGE_SHIFT) & shm_align_mask;

 return base + off;
}

unsigned long arch_get_unmapped_area(struct file *filp, unsigned long addr,
 unsigned long len, unsigned long pgoff, unsigned long flags,
 vm_flags_t vm_flags)
{
 struct mm_struct *mm = current->mm;
 struct vm_area_struct *vma;
 int do_colour_align;
 struct vm_unmapped_area_info info = {};

 if (flags & MAP_FIXED) {
  /* We do not accept a shared mapping if it would violate
 * cache aliasing constraints.
 */
  if ((flags & MAP_SHARED) &&
      ((addr - (pgoff << PAGE_SHIFT)) & shm_align_mask))
   return -EINVAL;
  return addr;
 }

 if (unlikely(len > TASK_SIZE))
  return -ENOMEM;

 do_colour_align = 0;
 if (filp || (flags & MAP_SHARED))
  do_colour_align = 1;

 if (addr) {
  if (do_colour_align)
   addr = COLOUR_ALIGN(addr, pgoff);
  else
   addr = PAGE_ALIGN(addr);

  vma = find_vma(mm, addr);
  if (TASK_SIZE - len >= addr &&
      (!vma || addr + len <= vm_start_gap(vma)))
   return addr;
 }

 info.length = len;
 info.low_limit = TASK_UNMAPPED_BASE;
 info.high_limit = TASK_SIZE;
 info.align_mask = do_colour_align ? (PAGE_MASK & shm_align_mask) : 0;
 info.align_offset = pgoff << PAGE_SHIFT;
 return vm_unmapped_area(&info);
}

unsigned long
arch_get_unmapped_area_topdown(struct file *filp, const unsigned long addr0,
     const unsigned long len, const unsigned long pgoff,
     const unsigned long flags, vm_flags_t vm_flags)
{
 struct vm_area_struct *vma;
 struct mm_struct *mm = current->mm;
 unsigned long addr = addr0;
 int do_colour_align;
 struct vm_unmapped_area_info info = {};

 if (flags & MAP_FIXED) {
  /* We do not accept a shared mapping if it would violate
 * cache aliasing constraints.
 */
  if ((flags & MAP_SHARED) &&
      ((addr - (pgoff << PAGE_SHIFT)) & shm_align_mask))
   return -EINVAL;
  return addr;
 }

 if (unlikely(len > TASK_SIZE))
  return -ENOMEM;

 do_colour_align = 0;
 if (filp || (flags & MAP_SHARED))
  do_colour_align = 1;

 /* requesting a specific address */
 if (addr) {
  if (do_colour_align)
   addr = COLOUR_ALIGN(addr, pgoff);
  else
   addr = PAGE_ALIGN(addr);

  vma = find_vma(mm, addr);
  if (TASK_SIZE - len >= addr &&
      (!vma || addr + len <= vm_start_gap(vma)))
   return addr;
 }

 info.flags = VM_UNMAPPED_AREA_TOPDOWN;
 info.length = len;
 info.low_limit = PAGE_SIZE;
 info.high_limit = mm->mmap_base;
 info.align_mask = do_colour_align ? (PAGE_MASK & shm_align_mask) : 0;
 info.align_offset = pgoff << PAGE_SHIFT;
 addr = vm_unmapped_area(&info);

 /*
 * A failed mmap() very likely causes application failure,
 * so fall back to the bottom-up function here. This scenario
 * can happen with large stack limits and large mmap()
 * allocations.
 */
 if (addr & ~PAGE_MASK) {
  VM_BUG_ON(addr != -ENOMEM);
  info.flags = 0;
  info.low_limit = TASK_UNMAPPED_BASE;
  info.high_limit = TASK_SIZE;
  addr = vm_unmapped_area(&info);
 }

 return addr;
}
#endif /* CONFIG_MMU */

/*
 * You really shouldn't be using read() or write() on /dev/mem.  This
 * might go away in the future.
 */
int valid_phys_addr_range(phys_addr_t addr, size_t count)
{
 if (addr < __MEMORY_START)
  return 0;
 if (addr + count > __pa(high_memory))
  return 0;

 return 1;
}

int valid_mmap_phys_addr_range(unsigned long pfn, size_t size)
{
 return 1;
}