1 files changed, 164 insertions, 0 deletions

diff --git a/arch/tile/mm/elf.c b/arch/tile/mm/elf.c
new file mode 100644
index 000000000000..55e58e93bfc5
--- /dev/null
+++ b/arch/tile/mm/elf.c
@@ -0,0 +1,164 @@
+/*
+ * Copyright 2010 Tilera Corporation. All Rights Reserved.
+ *
+ *   This program is free software; you can redistribute it and/or
+ *   modify it under the terms of the GNU General Public License
+ *   as published by the Free Software Foundation, version 2.
+ *
+ *   This program is distributed in the hope that it will be useful, but
+ *   WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
+ *   NON INFRINGEMENT.  See the GNU General Public License for
+ *   more details.
+ */
+
+#include <linux/mm.h>
+#include <linux/pagemap.h>
+#include <linux/binfmts.h>
+#include <linux/compat.h>
+#include <linux/mman.h>
+#include <linux/elf.h>
+#include <asm/pgtable.h>
+#include <asm/pgalloc.h>
+#include <asm/sections.h>
+
+/* Notify a running simulator, if any, that an exec just occurred. */
+static void sim_notify_exec(const char *binary_name)
+{
+        unsigned char c;
+        do {
+                c = *binary_name++;
+                __insn_mtspr(SPR_SIM_CONTROL,
+                             (SIM_CONTROL_OS_EXEC
+                              | (c << _SIM_CONTROL_OPERATOR_BITS)));
+
+        } while (c);
+}
+
+static int notify_exec(void)
+{
+        int retval = 0;  /* failure */
+        struct vm_area_struct *vma = current->mm->mmap;
+        while (vma) {
+                if ((vma->vm_flags & VM_EXECUTABLE) && vma->vm_file)
+                        break;
+                vma = vma->vm_next;
+        }
+        if (vma) {
+                char *buf = (char *) __get_free_page(GFP_KERNEL);
+                if (buf) {
+                        char *path = d_path(&vma->vm_file->f_path,
+                                            buf, PAGE_SIZE);
+                        if (!IS_ERR(path)) {
+                                sim_notify_exec(path);
+                                retval = 1;
+                        }
+                        free_page((unsigned long)buf);
+                }
+        }
+        return retval;
+}
+
+/* Notify a running simulator, if any, that we loaded an interpreter. */
+static void sim_notify_interp(unsigned long load_addr)
+{
+        size_t i;
+        for (i = 0; i < sizeof(load_addr); i++) {
+                unsigned char c = load_addr >> (i * 8);
+                __insn_mtspr(SPR_SIM_CONTROL,
+                             (SIM_CONTROL_OS_INTERP
+                              | (c << _SIM_CONTROL_OPERATOR_BITS)));
+        }
+}
+
+
+/* Kernel address of page used to map read-only kernel data into userspace. */
+static void *vdso_page;
+
+/* One-entry array used for install_special_mapping. */
+static struct page *vdso_pages[1];
+
+static int __init vdso_setup(void)
+{
+        vdso_page = (void *)get_zeroed_page(GFP_ATOMIC);
+        memcpy(vdso_page, __rt_sigreturn, __rt_sigreturn_end - __rt_sigreturn);
+        vdso_pages[0] = virt_to_page(vdso_page);
+        return 0;
+}
+device_initcall(vdso_setup);
+
+const char *arch_vma_name(struct vm_area_struct *vma)
+{
+        if (vma->vm_private_data == vdso_pages)
+                return "[vdso]";
+#ifndef __tilegx__
+        if (vma->vm_start == MEM_USER_INTRPT)
+                return "[intrpt]";
+#endif
+        return NULL;
+}
+
+int arch_setup_additional_pages(struct linux_binprm *bprm,
+                                int executable_stack)
+{
+        struct mm_struct *mm = current->mm;
+        unsigned long vdso_base;
+        int retval = 0;
+
+        /*
+         * Notify the simulator that an exec just occurred.
+         * If we can't find the filename of the mapping, just use
+         * whatever was passed as the linux_binprm filename.
+         */
+        if (!notify_exec())
+                sim_notify_exec(bprm->filename);
+
+        down_write(&mm->mmap_sem);
+
+        /*
+         * MAYWRITE to allow gdb to COW and set breakpoints
+         *
+         * Make sure the vDSO gets into every core dump.  Dumping its
+         * contents makes post-mortem fully interpretable later
+         * without matching up the same kernel and hardware config to
+         * see what PC values meant.
+         */
+        vdso_base = VDSO_BASE;
+        retval = install_special_mapping(mm, vdso_base, PAGE_SIZE,
+                                         VM_READ|VM_EXEC|
+                                         VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC|
+                                         VM_ALWAYSDUMP,
+                                         vdso_pages);
+
+#ifndef __tilegx__
+        /*
+         * Set up a user-interrupt mapping here; the user can't
+         * create one themselves since it is above TASK_SIZE.
+         * We make it unwritable by default, so the model for adding
+         * interrupt vectors always involves an mprotect.
+         */
+        if (!retval) {
+                unsigned long addr = MEM_USER_INTRPT;
+                addr = mmap_region(NULL, addr, INTRPT_SIZE,
+                                   MAP_FIXED|MAP_ANONYMOUS|MAP_PRIVATE,
+                                   VM_READ|VM_EXEC|
+                                   VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC, 0);
+                if (addr > (unsigned long) -PAGE_SIZE)
+                        retval = (int) addr;
+        }
+#endif
+
+        up_write(&mm->mmap_sem);
+
+        return retval;
+}
+
+
+void elf_plat_init(struct pt_regs *regs, unsigned long load_addr)
+{
+        /* Zero all registers. */
+        memset(regs, 0, sizeof(*regs));
+
+        /* Report the interpreter's load address. */
+        sim_notify_interp(load_addr);
+}