arch/arc/mm/mmap.c - kernel/skids - Git at Google

 /*
  * Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
  *  Custom mmap layout for ARC700
  *
  * Vineet Gupta <vineet.gupta@arc.com>
  *  -mmap randomisation (borrowed from x86/ARM/s390 implementations)
  *  -dedicated mmap code virtual address space to ensure libs are mapped
  *   at same vaddr across processes: this is perf boost for VIPT I$ which
  *   suffer from aliasing.
  */

 #include <linux/mman.h>
 #include <linux/mm.h>
 #include <linux/sched.h>
 #include <linux/random.h>
 #include <linux/module.h>
 #include <linux/file.h>
 #include <linux/syscalls.h>
 #include <linux/profile.h>
 #include <asm/mman.h>
 #include <asm/mmapcode.h>
 #include <asm/uaccess.h>
 #include <asm/tlbflush.h>

 #if 0
 //#define MMAP_DBG(fmt, args...)  pr_debug(fmt , ## args)
 #define MMAP_DBG(fmt, args...)  printk(fmt , ## args)
 #else
 #define MMAP_DBG(fmt, args...)
 #endif

 /* fwd declaration */
 static unsigned long __do_mmap2(struct file *file, unsigned long addr_hint,
         unsigned long len, unsigned long prot, unsigned long flags,
         unsigned long pgoff);

 /* Helper called by mmap syscall: (2nd level)
  * common code for old (packed struct) and new mmap2/
  */

 static unsigned long do_mmap2(unsigned long addr_hint, unsigned long len,
                 unsigned long prot, unsigned long flags,
                 unsigned long fd, unsigned long pgoff)
 {
     unsigned long vaddr = -EBADF;
     struct file *file = NULL;

     flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE);

     if (!(flags & MAP_ANONYMOUS)
 #ifdef CONFIG_MMAP_CODE_CMN_VADDR
         || (flags & MAP_SHARED_CODE)
 #endif
     ) {
         file = fget(fd);
         if (!file)
             goto out;
     }

     down_write(&current->mm->mmap_sem);

     vaddr = __do_mmap2(file, addr_hint, len, prot, flags, pgoff);

     up_write(&current->mm->mmap_sem);

     if (file)
         fput(file);

 out:
     return vaddr;
 }

 /* Helper called by elf loader: (2nd level)
  */
 unsigned long do_mmap(struct file *file, unsigned long addr,
         unsigned long len, unsigned long prot,
         unsigned long flag, unsigned long offset)
 {
         unsigned long ret = -EINVAL;

         if ((offset + PAGE_ALIGN(len)) < offset)
                 goto out;

         if ((offset & ~PAGE_MASK))
         goto out;

     ret = __do_mmap2(file, addr, len, prot, flag, offset >> PAGE_SHIFT);

 out:
         return ret;
 }

 /* ARC mmap core: (3rd level)
  * -does special case handling for code mmaps (CONFIG_MMAP_CODE_CMN_VADDR)
  * -calls generic vm entry-pt do_mmap_pgoff(()
  */
 static unsigned long __do_mmap2(struct file *file, unsigned long addr_hint,
         unsigned long len, unsigned long prot, unsigned long flags,
         unsigned long pgoff)
 {
     unsigned long vaddr = -EINVAL;

 #ifdef CONFIG_MMAP_CODE_CMN_VADDR

     /* 1. What are we doing here ?
      * -------------------------------------
      *  If mmap is for code (right now only shared libs-dso)
      *  allocate a chunk of vaddr in cmn-code-vaddr space and pass that as
      *  MAP_FIXED to mmap core to ensure that shared lib code is mmaped at
      *  addr of our choice and not where Linux vm wants to.
      *  Doing it here turned out to be much easier than in arch specific
      *  arc_get_unmapped_area( )
      *
      *  If the library was already mmaped - by some other task - the existing
      *  alloc addr is returned - that is how a dso is mapped at same addr,
      *  across multiple processes.
      *
      *  It shd be obvious that this addr allocation is not plugged into VM as
      *  such, it is merely a helper, for allocating the desired vaddr in
      *  process-pvt vaddr space.
      *
      * 2. Mechanics (part #a - for shared libs loaded by user-space loader)
      * ------------------------------------------------------------------
      *  user-space dyn-loader passes a special mmap flag MAP_SHARED_CODE
      *  (possibly piggybacking a MAP_ANON), with fd of dso and it's total
      *  addr space foot-print (code+data).
      *
      *  Although we are interested only in code-part, for ease of addr space
      *  mgmt -since our allocator is unaware of any non-code mmaps -
      *  we reserve the full dso addr-space span in cmn-vaddr allocator
      *  e.g. imagine process p1 mmaping dso1 and process p2 mapping dso2.
      *  If our allco was only resev for code, there would be addr space
      *  collision when code vaddr was alloc for dso2 (with data/anon mmaps
      *  for dso1)
      *
      *  This can ofcourse go away if user-space loader supports independently
      *  relocatable lib segment - as opposed to a single load addr for entire
      *  dso. Anyhow the existing scheme doesn't hurt - we are not wasting any
      *  vaddr.
      */

     if (flags & MAP_SHARED_CODE || /* Callers converted to ask for cmn mmap */
         ((prot & PROT_EXEC) &&     /* Callers not converted */
             !(flags & MAP_FIXED) && !(prot & PROT_WRITE)))
     {
         if (mmapcode_alloc_vaddr(file, pgoff, PAGE_ALIGN(len), &addr_hint)
                             < 0) {
             goto out;
         }

         /* force this mmap to take the cmn-vaddr just alloc */
         flags |= MAP_FIXED;
     }
 #endif

     vaddr = do_mmap_pgoff(file, addr_hint, len, prot, flags, pgoff);

 #ifdef CONFIG_MMAP_CODE_CMN_VADDR
     if (!(IS_ERR_VALUE(vaddr)) && (prot & PROT_EXEC)) {

         if (mmapcode_enab_vaddr(file, pgoff, PAGE_ALIGN(len), vaddr) == -3) {
             printk("cmn-addr alloc err: svaddr[%lx] pvt%lx\n",
                         addr_hint, vaddr);
         }
     }

 out:
 #endif

     return vaddr;
 }

 /* mmp syscall entry point: (1st level)
  */
 unsigned 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);
 }

 /* cloned from stock munmap to have arch specific processing
  * This can go away once mm->unmap_area starts taking more args
  */
 SYSCALL_DEFINE2(arc_munmap, unsigned long, addr, size_t, len)
 {
 	int ret;
 	struct mm_struct *mm = current->mm;

 	profile_munmap(addr);

 	down_write(&mm->mmap_sem);
 	ret = do_munmap(mm, addr, len);

 #ifdef CONFIG_MMAP_CODE_CMN_VADDR
     if (is_any_mmapcode_task_subscribed(mm))
         mmapcode_free(mm, addr, len);
 #endif

 	up_write(&mm->mmap_sem);
 	return ret;
 }

 /*
  * Perform the select(nd, in, out, ex, tv) and mmap() system
  * calls. Linux/i386 didn't use to be able to handle more than
  * 4 system call parameters, so these system calls used a memory
  * block for parameter passing..
  */

 struct mmap_arg_struct {
     unsigned long addr;
     unsigned long len;
     unsigned long prot;
     unsigned long flags;
     unsigned long fd;
     unsigned long offset;
 };

 asmlinkage int old_mmap(struct mmap_arg_struct *arg)
 {
     struct mmap_arg_struct a;
     int err = -EFAULT;

     if (copy_from_user(&a, arg, sizeof(a)))
         goto out;

     err = -EINVAL;
     if (a.offset & ~PAGE_MASK)
         goto out;

     err =
         do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd,
              a.offset >> PAGE_SHIFT);
       out:
     return err;
 }


 static inline int mmap_is_legacy(void)
 {
 #ifdef CONFIG_ARCH_ARC_SPACE_RND
     /* ELF loader sets this flag way early.
      * So no need to check for multiple things like
      *   !(current->personality & ADDR_NO_RANDOMIZE)
      *   randomize_va_space
      */
     return !(current->flags & PF_RANDOMIZE);
 #else
     return 1;
 #endif
 }

 static inline unsigned long arc_mmap_base(void)
 {
     int rnd = 0;
     unsigned long base;

     /* 8 bits of randomness: 255 * 8k = 2MB */
     if (!mmap_is_legacy()) {
         rnd = (long)get_random_int() % (1 <<8);
         rnd <<= PAGE_SHIFT;
     }

     base = PAGE_ALIGN(TASK_UNMAPPED_BASE + rnd);

     //printk("RAND: mmap base orig %x rnd %x\n",TASK_UNMAPPED_BASE, base);

     return base;
 }

 void arch_pick_mmap_layout(struct mm_struct *mm)
 {
     mm->mmap_base = arc_mmap_base();
     mm->get_unmapped_area = arch_get_unmapped_area;
     mm->unmap_area = arch_unmap_area;
 }
 EXPORT_SYMBOL_GPL(arch_pick_mmap_layout);


 #ifdef CONFIG_MMAP_CODE_CMN_VADDR

 /********************************************************************
  *
  * Arch specific mmap quirk
  * Mapping lib at same vaddr across processes independent of loading
  * order by userspace dynamic loader
  *
  *******************************************************************/

 /* Leave some head room for non-cmn mmaps
  */
 #define ROOM_FOR_NON_CMN_MAPS   0x0F0F0000
 #define MMAP_CODE_SPC_START     (TASK_UNMAPPED_BASE + ROOM_FOR_NON_CMN_MAPS)
 #define MMAP_CODE_SPC_SZ        0x20000000  /* 512 MB */

 /* For now track only 32 dsos */
 #define MMAP_CODE_SPC_MAX       32
 #define MMAP_CODE_SPC_MAX_IDX   (MMAP_CODE_SPC_MAX -1)

 /* The mmap code address space is managed in 3 data structures
  *  -A "pool" of addr space, using bitmaps - each bit corresp to a
  *   virtual page. Only deals with address space alloc/dealloc
  *  -the file/offset/len =>vaddr rlationship needs to be maintained
  *   to enable lookups by file
  *  -A pvt-only vaddr "x" can exist which doesn't correspond to a common
  *   mmap vaddr "x" (e.g. for tasks which don't use any shared libs).
  *   Thus need to track process subscription to common vaddrs.
  */

 static struct gen_pool *mmapcode_addr_pool;

 typedef struct {

     unsigned long ino;      /* inode corresp to sh lib mmaped */
     int refcnt;             /* num of times shared */

     struct {
         unsigned long pgoff;    /* offset in file mapped from */
         unsigned long len;      /* size of full dso */
         unsigned long vaddr;     /* start vaddr */
     } dso;

     /* Right now we only support one code-segment per dso */
     struct {
         unsigned long len;      /* len of code mapping */
         unsigned long vaddr;     /* vaddr of shared code */
     } code;
 } mmapcode_tracker_t;

 static mmapcode_tracker_t  mmap_tracker[MMAP_CODE_SPC_MAX];


     // TODO: what if same file is mmaped via its symlink: will filp be same
     // TODO: do we need locking: already called under mm semaphore

 /* Allocate a vaddr to a dso's code mmap, such that vaddr itself is usable
  * across processes (doesn't overlap with any pvt maps).
  * If the dso is already loaded, return the existing vaddr.
  *
  * As of now it allocates vaddr space to cover the entire dso, not just code.
  * This happens becoz we can't have a dedicated code vaddr space YET - becoz
  * this will mean that dso loading is split - uClibc dyn-loader (for ARC)
  * assumes a single virtual addr space for entire dso.
  */

 int mmapcode_alloc_vaddr(struct file *filp,
         unsigned long pgoff, unsigned long len, unsigned long *vaddr)
 {
     mmapcode_tracker_t *db;
     int i, free_slot = -1;
     unsigned long ino, sh_vaddr;

     db = &mmap_tracker[MMAP_CODE_SPC_MAX_IDX];

     ino = filp->f_path.dentry->d_inode->i_ino;

     for (i = MMAP_CODE_SPC_MAX_IDX; i >= 0 ; i--,db--) {

         /* dso already loaded - mapped by some other process(es)
          * returns it's global mapped vaddr
          */
         if (db->ino == ino && db->dso.pgoff == pgoff &&
                 db->dso.len == len) {
             *vaddr = db->dso.vaddr;
             goto done;
         }

         /* remember a free slot in table */
         // XXX: len checked because valid inode-id can be zero ?
         if (free_slot == -1) {
             if (db->ino == 0 && db->dso.len == 0)
                 free_slot = i;
         }
     }

     /* dso not registered, do it now */
     if (free_slot != -1) {

         db = &mmap_tracker[free_slot];

         /* alloc a block of addr space from pool */
         sh_vaddr = gen_pool_alloc(mmapcode_addr_pool, len);

         if (sh_vaddr != 0) {
             *vaddr = db->dso.vaddr = sh_vaddr;
             db->refcnt = 0;
             db->ino = ino;
             db->dso.pgoff = pgoff;
             db->dso.len = len;
             MMAP_DBG("ALLOC (%d) ino %lx, len %lx => [%lx]\n",
                     free_slot, ino, len, sh_vaddr);
             i = free_slot;
         }
     }

 done:
     return i;
 }

 /* Called upon mmap for shared code itself - PROT_EXEC
  * The common vaddr has already been allocated, just enable it
  */
 int mmapcode_enab_vaddr(struct file *filp, unsigned long pgoff,
         unsigned long len, unsigned long vaddr)
 {
     mmapcode_tracker_t *db;
     int i;
     unsigned long ino;

     /* uClibc-libpthread does a anon mmap with prot-exec, which "mis-leads"
      * in here
      */
     if (!filp)
         return -2;

     ino = filp->f_path.dentry->d_inode->i_ino;
     db = &mmap_tracker[MMAP_CODE_SPC_MAX_IDX];

     for (i = MMAP_CODE_SPC_MAX_IDX; i >= 0 ; i--,db--) {

         /* An addr space already reserved for this dso */
         if (db->ino == ino) {
             if (likely(vaddr >= db->dso.vaddr && len <= db->dso.len)) {
                 db->code.len = len;
                 db->code.vaddr = vaddr;

                 db->refcnt++;
                 mmapcode_task_subscribe(current->mm, i);

                 MMAP_DBG("ENABLE (%d) ino %lx, len %lx : [%lx] refs %d\n",
                     i, ino, len, vaddr, db->refcnt);
                 return i;
             }
             else {
                 return -3;   /* This is fatal */
             }
         }
     }

     /* this inode (code) was not registered for cmd addr */
     return -1;
 }

 static void mmapcode_free_one(struct mm_struct *mm, mmapcode_tracker_t *db,
                                 int sasid)
 {
     mmapcode_task_unsubscribe(mm, sasid);

     db->refcnt--;
     BUG_ON(db->refcnt < 0);
     if (db->refcnt == 0) {
         /* Flush the cmn-code TLB entries
          * the Probe semantics are same as that for global entries
          * XXX: we can leave the non-code entries behind.
          * Since process pvt ASID will get invalid, the entries will
          * be used anyways
          */
         local_flush_tlb_kernel_range(db->code.vaddr,
                             db->code.vaddr + db->code.len);
         gen_pool_free(mmapcode_addr_pool, db->dso.vaddr, db->dso.len);
         memset(db, 0, sizeof(*db));
     }
 }

 /* Called upon unmap of a cmn-vaddr egion */

 int mmapcode_free(struct mm_struct *mm, unsigned long vaddr,
         unsigned long len)
 {
     mmapcode_tracker_t *db;
     int i;

     db = &mmap_tracker[MMAP_CODE_SPC_MAX_IDX];

     for (i = MMAP_CODE_SPC_MAX_IDX; i >= 0 ; i--,db--) {

         /* check if vaddr being mmaped exist in com-mmap space
          * and that task has subscribed to it
          *    -it is perfectly legal for task to have pvt-only vaddr "x"
          *     which also exists independently in cmn-mmap addr space
          *     e.g. a task which doesn't user any cmn-mappings at all
          */

         if (db->code.vaddr == vaddr && db->code.len == len &&
             is_mmapcode_task_subscribed(mm, i)) {

             MMAP_DBG("UNMAP (%d) ino %lx, len %lx : [%lx] refs %d\n",
                     i, db->ino, len, vaddr, db->refcnt-1);

             mmapcode_free_one(mm, db, i);
             break;
         }
     }

     return i;
 }

 /* Called upon task exit to relinquish all it's cmn-mmaps */

 int mmapcode_free_all(struct mm_struct *mm)
 {
     mmapcode_tracker_t *db;
     int i;

     db = &mmap_tracker[MMAP_CODE_SPC_MAX_IDX];

     for (i = MMAP_CODE_SPC_MAX_IDX; i >= 0 ; i--,db--) {

         if (is_mmapcode_task_subscribed(mm, i)) {

             MMAP_DBG("EXIT (%d) ino %lx, [%lx] refs %d\n",
                     i, db->ino, db->code.vaddr, db->refcnt-1);

             mmapcode_free_one(mm, db, i);
         }
     }

     return 0;
 }

 void __init mmapcode_space_init(void)
 {
     printk("Common mmap addr-space starts %lx\n",MMAP_CODE_SPC_START);

     mmapcode_addr_pool = gen_pool_create(PAGE_SHIFT, -1);
     gen_pool_add(mmapcode_addr_pool, MMAP_CODE_SPC_START, MMAP_CODE_SPC_SZ, -1);
 }

 /* Get rid of cmn-maps: Two scenarios
  * 1. sys_execve => flush_old_exec => mmput => exit_mmap => arch_exit_mmap
  * 2. do_exit    => mmput => exit_mmap => arch_exit_mmap
  */
 void arch_exit_mmap(struct mm_struct *mm)
 {
     if (is_any_mmapcode_task_subscribed(mm))
     {
         mmapcode_free_all(mm);
     }
 }

 /* Replicate the cmn-mmaps in case of fork
  * do_fork => dup_mm => dup_mmap => arch_dup_mmap
  */
 void arch_dup_mmap(struct mm_struct *oldmm, struct mm_struct *mm)
 {
     mmapcode_tracker_t *db;
     int i;

     db = &mmap_tracker[MMAP_CODE_SPC_MAX_IDX];

     for (i = MMAP_CODE_SPC_MAX_IDX; i >= 0 ; i--,db--) {

         if (is_mmapcode_task_subscribed(oldmm, i)) {

             mmapcode_task_subscribe(mm, i);
             db->refcnt++;

             MMAP_DBG("DUP (%d) ino %lx, [%lx] refs %d\n",
                     i, db->ino, db->code.vaddr, db->refcnt);
         }
     }
 }

 /* Checks if the @vaddr contained in @mm belongs to a cmn-vaddr-space
  * instance.
  * If yes returns the "sasid" of that address space, else -1
  */
 int mmapcode_find_mm_vaddr(struct mm_struct *mm, unsigned long vaddr)
 {
     mmapcode_tracker_t *db;
     int i;

     if (is_any_mmapcode_task_subscribed(mm)) {

         db = &mmap_tracker[MMAP_CODE_SPC_MAX_IDX];

         for (i = MMAP_CODE_SPC_MAX_IDX; i >= 0 ; i--,db--) {

             if (is_mmapcode_task_subscribed(mm, i) &&
                 vaddr >= db->code.vaddr &&
                 vaddr < db->code.vaddr + db->code.len) {

                 return i;
             }
         }
     }

     return -1;
 }

 #endif
	/*
	* Copyright (C) 2004, 2007-2010, 2011-2012 Synopsys, Inc. (www.synopsys.com)
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 as
	* published by the Free Software Foundation.
	*
	* Custom mmap layout for ARC700
	*
	* Vineet Gupta <vineet.gupta@arc.com>
	* -mmap randomisation (borrowed from x86/ARM/s390 implementations)
	* -dedicated mmap code virtual address space to ensure libs are mapped
	* at same vaddr across processes: this is perf boost for VIPT I$ which
	* suffer from aliasing.
	*/

	#include <linux/mman.h>
	#include <linux/mm.h>
	#include <linux/sched.h>
	#include <linux/random.h>
	#include <linux/module.h>
	#include <linux/file.h>
	#include <linux/syscalls.h>
	#include <linux/profile.h>
	#include <asm/mman.h>
	#include <asm/mmapcode.h>
	#include <asm/uaccess.h>
	#include <asm/tlbflush.h>

	#if 0
	//#define MMAP_DBG(fmt, args...) pr_debug(fmt , ## args)
	#define MMAP_DBG(fmt, args...) printk(fmt , ## args)
	#else
	#define MMAP_DBG(fmt, args...)
	#endif

	/* fwd declaration */
	static unsigned long __do_mmap2(struct file *file, unsigned long addr_hint,
	unsigned long len, unsigned long prot, unsigned long flags,
	unsigned long pgoff);

	/* Helper called by mmap syscall: (2nd level)
	* common code for old (packed struct) and new mmap2/
	*/

	static unsigned long do_mmap2(unsigned long addr_hint, unsigned long len,
	unsigned long prot, unsigned long flags,
	unsigned long fd, unsigned long pgoff)
	{
	unsigned long vaddr = -EBADF;
	struct file *file = NULL;

	flags &= ~(MAP_EXECUTABLE \| MAP_DENYWRITE);

	if (!(flags & MAP_ANONYMOUS)
	#ifdef CONFIG_MMAP_CODE_CMN_VADDR
	\|\| (flags & MAP_SHARED_CODE)
	#endif
	) {
	file = fget(fd);
	if (!file)
	goto out;
	}

	down_write(&current->mm->mmap_sem);

	vaddr = __do_mmap2(file, addr_hint, len, prot, flags, pgoff);

	up_write(&current->mm->mmap_sem);

	if (file)
	fput(file);

	out:
	return vaddr;
	}

	/* Helper called by elf loader: (2nd level)
	*/
	unsigned long do_mmap(struct file *file, unsigned long addr,
	unsigned long len, unsigned long prot,
	unsigned long flag, unsigned long offset)
	{
	unsigned long ret = -EINVAL;

	if ((offset + PAGE_ALIGN(len)) < offset)
	goto out;

	if ((offset & ~PAGE_MASK))
	goto out;

	ret = __do_mmap2(file, addr, len, prot, flag, offset >> PAGE_SHIFT);

	out:
	return ret;
	}

	/* ARC mmap core: (3rd level)
	* -does special case handling for code mmaps (CONFIG_MMAP_CODE_CMN_VADDR)
	* -calls generic vm entry-pt do_mmap_pgoff(()
	*/
	static unsigned long __do_mmap2(struct file *file, unsigned long addr_hint,
	unsigned long len, unsigned long prot, unsigned long flags,
	unsigned long pgoff)
	{
	unsigned long vaddr = -EINVAL;

	#ifdef CONFIG_MMAP_CODE_CMN_VADDR

	/* 1. What are we doing here ?
	* -------------------------------------
	* If mmap is for code (right now only shared libs-dso)
	* allocate a chunk of vaddr in cmn-code-vaddr space and pass that as
	* MAP_FIXED to mmap core to ensure that shared lib code is mmaped at
	* addr of our choice and not where Linux vm wants to.
	* Doing it here turned out to be much easier than in arch specific
	* arc_get_unmapped_area( )
	*
	* If the library was already mmaped - by some other task - the existing
	* alloc addr is returned - that is how a dso is mapped at same addr,
	* across multiple processes.
	*
	* It shd be obvious that this addr allocation is not plugged into VM as
	* such, it is merely a helper, for allocating the desired vaddr in
	* process-pvt vaddr space.
	*
	* 2. Mechanics (part #a - for shared libs loaded by user-space loader)
	* ------------------------------------------------------------------
	* user-space dyn-loader passes a special mmap flag MAP_SHARED_CODE
	* (possibly piggybacking a MAP_ANON), with fd of dso and it's total
	* addr space foot-print (code+data).
	*
	* Although we are interested only in code-part, for ease of addr space
	* mgmt -since our allocator is unaware of any non-code mmaps -
	* we reserve the full dso addr-space span in cmn-vaddr allocator
	* e.g. imagine process p1 mmaping dso1 and process p2 mapping dso2.
	* If our allco was only resev for code, there would be addr space
	* collision when code vaddr was alloc for dso2 (with data/anon mmaps
	* for dso1)
	*
	* This can ofcourse go away if user-space loader supports independently
	* relocatable lib segment - as opposed to a single load addr for entire
	* dso. Anyhow the existing scheme doesn't hurt - we are not wasting any
	* vaddr.
	*/

	if (flags & MAP_SHARED_CODE \|\| /* Callers converted to ask for cmn mmap */
	((prot & PROT_EXEC) && /* Callers not converted */
	!(flags & MAP_FIXED) && !(prot & PROT_WRITE)))
	{
	if (mmapcode_alloc_vaddr(file, pgoff, PAGE_ALIGN(len), &addr_hint)
	< 0) {
	goto out;
	}

	/* force this mmap to take the cmn-vaddr just alloc */
	flags \|= MAP_FIXED;
	}
	#endif

	vaddr = do_mmap_pgoff(file, addr_hint, len, prot, flags, pgoff);

	#ifdef CONFIG_MMAP_CODE_CMN_VADDR
	if (!(IS_ERR_VALUE(vaddr)) && (prot & PROT_EXEC)) {

	if (mmapcode_enab_vaddr(file, pgoff, PAGE_ALIGN(len), vaddr) == -3) {
	printk("cmn-addr alloc err: svaddr[%lx] pvt%lx\n",
	addr_hint, vaddr);
	}
	}

	out:
	#endif

	return vaddr;
	}

	/* mmp syscall entry point: (1st level)
	*/
	unsigned 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);
	}

	/* cloned from stock munmap to have arch specific processing
	* This can go away once mm->unmap_area starts taking more args
	*/
	SYSCALL_DEFINE2(arc_munmap, unsigned long, addr, size_t, len)
	{
	int ret;
	struct mm_struct *mm = current->mm;

	profile_munmap(addr);

	down_write(&mm->mmap_sem);
	ret = do_munmap(mm, addr, len);

	#ifdef CONFIG_MMAP_CODE_CMN_VADDR
	if (is_any_mmapcode_task_subscribed(mm))
	mmapcode_free(mm, addr, len);
	#endif

	up_write(&mm->mmap_sem);
	return ret;
	}

	/*
	* Perform the select(nd, in, out, ex, tv) and mmap() system
	* calls. Linux/i386 didn't use to be able to handle more than
	* 4 system call parameters, so these system calls used a memory
	* block for parameter passing..
	*/

	struct mmap_arg_struct {
	unsigned long addr;
	unsigned long len;
	unsigned long prot;
	unsigned long flags;
	unsigned long fd;
	unsigned long offset;
	};

	asmlinkage int old_mmap(struct mmap_arg_struct *arg)
	{
	struct mmap_arg_struct a;
	int err = -EFAULT;

	if (copy_from_user(&a, arg, sizeof(a)))
	goto out;

	err = -EINVAL;
	if (a.offset & ~PAGE_MASK)
	goto out;

	err =
	do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd,
	a.offset >> PAGE_SHIFT);
	out:
	return err;
	}


	static inline int mmap_is_legacy(void)
	{
	#ifdef CONFIG_ARCH_ARC_SPACE_RND
	/* ELF loader sets this flag way early.
	* So no need to check for multiple things like
	* !(current->personality & ADDR_NO_RANDOMIZE)
	* randomize_va_space
	*/
	return !(current->flags & PF_RANDOMIZE);
	#else
	return 1;
	#endif
	}

	static inline unsigned long arc_mmap_base(void)
	{
	int rnd = 0;
	unsigned long base;

	/* 8 bits of randomness: 255 * 8k = 2MB */
	if (!mmap_is_legacy()) {
	rnd = (long)get_random_int() % (1 <<8);
	rnd <<= PAGE_SHIFT;
	}

	base = PAGE_ALIGN(TASK_UNMAPPED_BASE + rnd);

	//printk("RAND: mmap base orig %x rnd %x\n",TASK_UNMAPPED_BASE, base);

	return base;
	}

	void arch_pick_mmap_layout(struct mm_struct *mm)
	{
	mm->mmap_base = arc_mmap_base();
	mm->get_unmapped_area = arch_get_unmapped_area;
	mm->unmap_area = arch_unmap_area;
	}
	EXPORT_SYMBOL_GPL(arch_pick_mmap_layout);


	#ifdef CONFIG_MMAP_CODE_CMN_VADDR

	/********************************************************************
	*
	* Arch specific mmap quirk
	* Mapping lib at same vaddr across processes independent of loading
	* order by userspace dynamic loader
	*
	*******************************************************************/

	/* Leave some head room for non-cmn mmaps
	*/
	#define ROOM_FOR_NON_CMN_MAPS 0x0F0F0000
	#define MMAP_CODE_SPC_START (TASK_UNMAPPED_BASE + ROOM_FOR_NON_CMN_MAPS)
	#define MMAP_CODE_SPC_SZ 0x20000000 /* 512 MB */

	/* For now track only 32 dsos */
	#define MMAP_CODE_SPC_MAX 32
	#define MMAP_CODE_SPC_MAX_IDX (MMAP_CODE_SPC_MAX -1)

	/* The mmap code address space is managed in 3 data structures
	* -A "pool" of addr space, using bitmaps - each bit corresp to a
	* virtual page. Only deals with address space alloc/dealloc
	* -the file/offset/len =>vaddr rlationship needs to be maintained
	* to enable lookups by file
	* -A pvt-only vaddr "x" can exist which doesn't correspond to a common
	* mmap vaddr "x" (e.g. for tasks which don't use any shared libs).
	* Thus need to track process subscription to common vaddrs.
	*/

	static struct gen_pool *mmapcode_addr_pool;

	typedef struct {

	unsigned long ino; /* inode corresp to sh lib mmaped */
	int refcnt; /* num of times shared */

	struct {
	unsigned long pgoff; /* offset in file mapped from */
	unsigned long len; /* size of full dso */
	unsigned long vaddr; /* start vaddr */
	} dso;

	/* Right now we only support one code-segment per dso */
	struct {
	unsigned long len; /* len of code mapping */
	unsigned long vaddr; /* vaddr of shared code */
	} code;
	} mmapcode_tracker_t;

	static mmapcode_tracker_t mmap_tracker[MMAP_CODE_SPC_MAX];


	// TODO: what if same file is mmaped via its symlink: will filp be same
	// TODO: do we need locking: already called under mm semaphore

	/* Allocate a vaddr to a dso's code mmap, such that vaddr itself is usable
	* across processes (doesn't overlap with any pvt maps).
	* If the dso is already loaded, return the existing vaddr.
	*
	* As of now it allocates vaddr space to cover the entire dso, not just code.
	* This happens becoz we can't have a dedicated code vaddr space YET - becoz
	* this will mean that dso loading is split - uClibc dyn-loader (for ARC)
	* assumes a single virtual addr space for entire dso.
	*/

	int mmapcode_alloc_vaddr(struct file *filp,
	unsigned long pgoff, unsigned long len, unsigned long *vaddr)
	{
	mmapcode_tracker_t *db;
	int i, free_slot = -1;
	unsigned long ino, sh_vaddr;

	db = &mmap_tracker[MMAP_CODE_SPC_MAX_IDX];

	ino = filp->f_path.dentry->d_inode->i_ino;

	for (i = MMAP_CODE_SPC_MAX_IDX; i >= 0 ; i--,db--) {

	/* dso already loaded - mapped by some other process(es)
	* returns it's global mapped vaddr
	*/
	if (db->ino == ino && db->dso.pgoff == pgoff &&
	db->dso.len == len) {
	*vaddr = db->dso.vaddr;
	goto done;
	}

	/* remember a free slot in table */
	// XXX: len checked because valid inode-id can be zero ?
	if (free_slot == -1) {
	if (db->ino == 0 && db->dso.len == 0)
	free_slot = i;
	}
	}

	/* dso not registered, do it now */
	if (free_slot != -1) {

	db = &mmap_tracker[free_slot];

	/* alloc a block of addr space from pool */
	sh_vaddr = gen_pool_alloc(mmapcode_addr_pool, len);

	if (sh_vaddr != 0) {
	*vaddr = db->dso.vaddr = sh_vaddr;
	db->refcnt = 0;
	db->ino = ino;
	db->dso.pgoff = pgoff;
	db->dso.len = len;
	MMAP_DBG("ALLOC (%d) ino %lx, len %lx => [%lx]\n",
	free_slot, ino, len, sh_vaddr);
	i = free_slot;
	}
	}

	done:
	return i;
	}

	/* Called upon mmap for shared code itself - PROT_EXEC
	* The common vaddr has already been allocated, just enable it
	*/
	int mmapcode_enab_vaddr(struct file *filp, unsigned long pgoff,
	unsigned long len, unsigned long vaddr)
	{
	mmapcode_tracker_t *db;
	int i;
	unsigned long ino;

	/* uClibc-libpthread does a anon mmap with prot-exec, which "mis-leads"
	* in here
	*/
	if (!filp)
	return -2;

	ino = filp->f_path.dentry->d_inode->i_ino;
	db = &mmap_tracker[MMAP_CODE_SPC_MAX_IDX];

	for (i = MMAP_CODE_SPC_MAX_IDX; i >= 0 ; i--,db--) {

	/* An addr space already reserved for this dso */
	if (db->ino == ino) {
	if (likely(vaddr >= db->dso.vaddr && len <= db->dso.len)) {
	db->code.len = len;
	db->code.vaddr = vaddr;

	db->refcnt++;
	mmapcode_task_subscribe(current->mm, i);

	MMAP_DBG("ENABLE (%d) ino %lx, len %lx : [%lx] refs %d\n",
	i, ino, len, vaddr, db->refcnt);
	return i;
	}
	else {
	return -3; /* This is fatal */
	}
	}
	}

	/* this inode (code) was not registered for cmd addr */
	return -1;
	}

	static void mmapcode_free_one(struct mm_struct mm, mmapcode_tracker_t db,
	int sasid)
	{
	mmapcode_task_unsubscribe(mm, sasid);

	db->refcnt--;
	BUG_ON(db->refcnt < 0);
	if (db->refcnt == 0) {
	/* Flush the cmn-code TLB entries
	* the Probe semantics are same as that for global entries
	* XXX: we can leave the non-code entries behind.
	* Since process pvt ASID will get invalid, the entries will
	* be used anyways
	*/
	local_flush_tlb_kernel_range(db->code.vaddr,
	db->code.vaddr + db->code.len);
	gen_pool_free(mmapcode_addr_pool, db->dso.vaddr, db->dso.len);
	memset(db, 0, sizeof(*db));
	}
	}

	/* Called upon unmap of a cmn-vaddr egion */

	int mmapcode_free(struct mm_struct *mm, unsigned long vaddr,
	unsigned long len)
	{
	mmapcode_tracker_t *db;
	int i;

	db = &mmap_tracker[MMAP_CODE_SPC_MAX_IDX];

	for (i = MMAP_CODE_SPC_MAX_IDX; i >= 0 ; i--,db--) {

	/* check if vaddr being mmaped exist in com-mmap space
	* and that task has subscribed to it
	* -it is perfectly legal for task to have pvt-only vaddr "x"
	* which also exists independently in cmn-mmap addr space
	* e.g. a task which doesn't user any cmn-mappings at all
	*/

	if (db->code.vaddr == vaddr && db->code.len == len &&
	is_mmapcode_task_subscribed(mm, i)) {

	MMAP_DBG("UNMAP (%d) ino %lx, len %lx : [%lx] refs %d\n",
	i, db->ino, len, vaddr, db->refcnt-1);

	mmapcode_free_one(mm, db, i);
	break;
	}
	}

	return i;
	}

	/* Called upon task exit to relinquish all it's cmn-mmaps */

	int mmapcode_free_all(struct mm_struct *mm)
	{
	mmapcode_tracker_t *db;
	int i;

	db = &mmap_tracker[MMAP_CODE_SPC_MAX_IDX];

	for (i = MMAP_CODE_SPC_MAX_IDX; i >= 0 ; i--,db--) {

	if (is_mmapcode_task_subscribed(mm, i)) {

	MMAP_DBG("EXIT (%d) ino %lx, [%lx] refs %d\n",
	i, db->ino, db->code.vaddr, db->refcnt-1);

	mmapcode_free_one(mm, db, i);
	}
	}

	return 0;
	}

	void __init mmapcode_space_init(void)
	{
	printk("Common mmap addr-space starts %lx\n",MMAP_CODE_SPC_START);

	mmapcode_addr_pool = gen_pool_create(PAGE_SHIFT, -1);
	gen_pool_add(mmapcode_addr_pool, MMAP_CODE_SPC_START, MMAP_CODE_SPC_SZ, -1);
	}

	/* Get rid of cmn-maps: Two scenarios
	* 1. sys_execve => flush_old_exec => mmput => exit_mmap => arch_exit_mmap
	* 2. do_exit => mmput => exit_mmap => arch_exit_mmap
	*/
	void arch_exit_mmap(struct mm_struct *mm)
	{
	if (is_any_mmapcode_task_subscribed(mm))
	{
	mmapcode_free_all(mm);
	}
	}

	/* Replicate the cmn-mmaps in case of fork
	* do_fork => dup_mm => dup_mmap => arch_dup_mmap
	*/
	void arch_dup_mmap(struct mm_struct oldmm, struct mm_struct mm)
	{
	mmapcode_tracker_t *db;
	int i;

	db = &mmap_tracker[MMAP_CODE_SPC_MAX_IDX];

	for (i = MMAP_CODE_SPC_MAX_IDX; i >= 0 ; i--,db--) {

	if (is_mmapcode_task_subscribed(oldmm, i)) {

	mmapcode_task_subscribe(mm, i);
	db->refcnt++;

	MMAP_DBG("DUP (%d) ino %lx, [%lx] refs %d\n",
	i, db->ino, db->code.vaddr, db->refcnt);
	}
	}
	}

	/* Checks if the @vaddr contained in @mm belongs to a cmn-vaddr-space
	* instance.
	* If yes returns the "sasid" of that address space, else -1
	*/
	int mmapcode_find_mm_vaddr(struct mm_struct *mm, unsigned long vaddr)
	{
	mmapcode_tracker_t *db;
	int i;

	if (is_any_mmapcode_task_subscribed(mm)) {

	db = &mmap_tracker[MMAP_CODE_SPC_MAX_IDX];

	for (i = MMAP_CODE_SPC_MAX_IDX; i >= 0 ; i--,db--) {

	if (is_mmapcode_task_subscribed(mm, i) &&
	vaddr >= db->code.vaddr &&
	vaddr < db->code.vaddr + db->code.len) {

	return i;
	}
	}
	}

	return -1;
	}

	#endif