Loading...
1/*
2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation, version 2.
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
11 * NON INFRINGEMENT. See the GNU General Public License for
12 * more details.
13 */
14
15#include <linux/mm.h>
16#include <linux/pagemap.h>
17#include <linux/binfmts.h>
18#include <linux/compat.h>
19#include <linux/mman.h>
20#include <linux/elf.h>
21#include <asm/pgtable.h>
22#include <asm/pgalloc.h>
23#include <asm/sections.h>
24
25/* Notify a running simulator, if any, that an exec just occurred. */
26static void sim_notify_exec(const char *binary_name)
27{
28 unsigned char c;
29 do {
30 c = *binary_name++;
31 __insn_mtspr(SPR_SIM_CONTROL,
32 (SIM_CONTROL_OS_EXEC
33 | (c << _SIM_CONTROL_OPERATOR_BITS)));
34
35 } while (c);
36}
37
38static int notify_exec(void)
39{
40 int retval = 0; /* failure */
41 struct vm_area_struct *vma = current->mm->mmap;
42 while (vma) {
43 if ((vma->vm_flags & VM_EXECUTABLE) && vma->vm_file)
44 break;
45 vma = vma->vm_next;
46 }
47 if (vma) {
48 char *buf = (char *) __get_free_page(GFP_KERNEL);
49 if (buf) {
50 char *path = d_path(&vma->vm_file->f_path,
51 buf, PAGE_SIZE);
52 if (!IS_ERR(path)) {
53 sim_notify_exec(path);
54 retval = 1;
55 }
56 free_page((unsigned long)buf);
57 }
58 }
59 return retval;
60}
61
62/* Notify a running simulator, if any, that we loaded an interpreter. */
63static void sim_notify_interp(unsigned long load_addr)
64{
65 size_t i;
66 for (i = 0; i < sizeof(load_addr); i++) {
67 unsigned char c = load_addr >> (i * 8);
68 __insn_mtspr(SPR_SIM_CONTROL,
69 (SIM_CONTROL_OS_INTERP
70 | (c << _SIM_CONTROL_OPERATOR_BITS)));
71 }
72}
73
74
75/* Kernel address of page used to map read-only kernel data into userspace. */
76static void *vdso_page;
77
78/* One-entry array used for install_special_mapping. */
79static struct page *vdso_pages[1];
80
81static int __init vdso_setup(void)
82{
83 vdso_page = (void *)get_zeroed_page(GFP_ATOMIC);
84 memcpy(vdso_page, __rt_sigreturn, __rt_sigreturn_end - __rt_sigreturn);
85 vdso_pages[0] = virt_to_page(vdso_page);
86 return 0;
87}
88device_initcall(vdso_setup);
89
90const char *arch_vma_name(struct vm_area_struct *vma)
91{
92 if (vma->vm_private_data == vdso_pages)
93 return "[vdso]";
94#ifndef __tilegx__
95 if (vma->vm_start == MEM_USER_INTRPT)
96 return "[intrpt]";
97#endif
98 return NULL;
99}
100
101int arch_setup_additional_pages(struct linux_binprm *bprm,
102 int executable_stack)
103{
104 struct mm_struct *mm = current->mm;
105 unsigned long vdso_base;
106 int retval = 0;
107
108 /*
109 * Notify the simulator that an exec just occurred.
110 * If we can't find the filename of the mapping, just use
111 * whatever was passed as the linux_binprm filename.
112 */
113 if (!notify_exec())
114 sim_notify_exec(bprm->filename);
115
116 down_write(&mm->mmap_sem);
117
118 /*
119 * MAYWRITE to allow gdb to COW and set breakpoints
120 *
121 * Make sure the vDSO gets into every core dump. Dumping its
122 * contents makes post-mortem fully interpretable later
123 * without matching up the same kernel and hardware config to
124 * see what PC values meant.
125 */
126 vdso_base = VDSO_BASE;
127 retval = install_special_mapping(mm, vdso_base, PAGE_SIZE,
128 VM_READ|VM_EXEC|
129 VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC|
130 VM_ALWAYSDUMP,
131 vdso_pages);
132
133#ifndef __tilegx__
134 /*
135 * Set up a user-interrupt mapping here; the user can't
136 * create one themselves since it is above TASK_SIZE.
137 * We make it unwritable by default, so the model for adding
138 * interrupt vectors always involves an mprotect.
139 */
140 if (!retval) {
141 unsigned long addr = MEM_USER_INTRPT;
142 addr = mmap_region(NULL, addr, INTRPT_SIZE,
143 MAP_FIXED|MAP_ANONYMOUS|MAP_PRIVATE,
144 VM_READ|VM_EXEC|
145 VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC, 0);
146 if (addr > (unsigned long) -PAGE_SIZE)
147 retval = (int) addr;
148 }
149#endif
150
151 up_write(&mm->mmap_sem);
152
153 return retval;
154}
155
156
157void elf_plat_init(struct pt_regs *regs, unsigned long load_addr)
158{
159 /* Zero all registers. */
160 memset(regs, 0, sizeof(*regs));
161
162 /* Report the interpreter's load address. */
163 sim_notify_interp(load_addr);
164}
1/*
2 * Copyright 2010 Tilera Corporation. All Rights Reserved.
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation, version 2.
7 *
8 * This program is distributed in the hope that it will be useful, but
9 * WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
11 * NON INFRINGEMENT. See the GNU General Public License for
12 * more details.
13 */
14
15#include <linux/mm.h>
16#include <linux/pagemap.h>
17#include <linux/binfmts.h>
18#include <linux/compat.h>
19#include <linux/mman.h>
20#include <linux/file.h>
21#include <linux/elf.h>
22#include <asm/pgtable.h>
23#include <asm/pgalloc.h>
24#include <asm/sections.h>
25#include <asm/vdso.h>
26#include <arch/sim.h>
27
28/* Notify a running simulator, if any, that an exec just occurred. */
29static void sim_notify_exec(const char *binary_name)
30{
31 unsigned char c;
32 do {
33 c = *binary_name++;
34 __insn_mtspr(SPR_SIM_CONTROL,
35 (SIM_CONTROL_OS_EXEC
36 | (c << _SIM_CONTROL_OPERATOR_BITS)));
37
38 } while (c);
39}
40
41static int notify_exec(struct mm_struct *mm)
42{
43 int ret = 0;
44 char *buf, *path;
45 struct vm_area_struct *vma;
46 struct file *exe_file;
47
48 if (!sim_is_simulator())
49 return 1;
50
51 buf = (char *) __get_free_page(GFP_KERNEL);
52 if (buf == NULL)
53 return 0;
54
55 exe_file = get_mm_exe_file(mm);
56 if (exe_file == NULL)
57 goto done_free;
58
59 path = file_path(exe_file, buf, PAGE_SIZE);
60 if (IS_ERR(path))
61 goto done_put;
62
63 down_read(&mm->mmap_sem);
64 for (vma = current->mm->mmap; ; vma = vma->vm_next) {
65 if (vma == NULL) {
66 up_read(&mm->mmap_sem);
67 goto done_put;
68 }
69 if (vma->vm_file == exe_file)
70 break;
71 }
72
73 /*
74 * Notify simulator of an ET_DYN object so we know the load address.
75 * The somewhat cryptic overuse of SIM_CONTROL_DLOPEN allows us
76 * to be backward-compatible with older simulator releases.
77 */
78 if (vma->vm_start == (ELF_ET_DYN_BASE & PAGE_MASK)) {
79 char buf[64];
80 int i;
81
82 snprintf(buf, sizeof(buf), "0x%lx:@", vma->vm_start);
83 for (i = 0; ; ++i) {
84 char c = buf[i];
85 __insn_mtspr(SPR_SIM_CONTROL,
86 (SIM_CONTROL_DLOPEN
87 | (c << _SIM_CONTROL_OPERATOR_BITS)));
88 if (c == '\0') {
89 ret = 1; /* success */
90 break;
91 }
92 }
93 }
94 up_read(&mm->mmap_sem);
95
96 sim_notify_exec(path);
97done_put:
98 fput(exe_file);
99done_free:
100 free_page((unsigned long)buf);
101 return ret;
102}
103
104/* Notify a running simulator, if any, that we loaded an interpreter. */
105static void sim_notify_interp(unsigned long load_addr)
106{
107 size_t i;
108 for (i = 0; i < sizeof(load_addr); i++) {
109 unsigned char c = load_addr >> (i * 8);
110 __insn_mtspr(SPR_SIM_CONTROL,
111 (SIM_CONTROL_OS_INTERP
112 | (c << _SIM_CONTROL_OPERATOR_BITS)));
113 }
114}
115
116
117int arch_setup_additional_pages(struct linux_binprm *bprm,
118 int executable_stack)
119{
120 struct mm_struct *mm = current->mm;
121 int retval = 0;
122
123 /*
124 * Notify the simulator that an exec just occurred.
125 * If we can't find the filename of the mapping, just use
126 * whatever was passed as the linux_binprm filename.
127 */
128 if (!notify_exec(mm))
129 sim_notify_exec(bprm->filename);
130
131 down_write(&mm->mmap_sem);
132
133 retval = setup_vdso_pages();
134
135#ifndef __tilegx__
136 /*
137 * Set up a user-interrupt mapping here; the user can't
138 * create one themselves since it is above TASK_SIZE.
139 * We make it unwritable by default, so the model for adding
140 * interrupt vectors always involves an mprotect.
141 */
142 if (!retval) {
143 unsigned long addr = MEM_USER_INTRPT;
144 addr = mmap_region(NULL, addr, INTRPT_SIZE,
145 VM_READ|VM_EXEC|
146 VM_MAYREAD|VM_MAYWRITE|VM_MAYEXEC, 0);
147 if (addr > (unsigned long) -PAGE_SIZE)
148 retval = (int) addr;
149 }
150#endif
151
152 up_write(&mm->mmap_sem);
153
154 return retval;
155}
156
157
158void elf_plat_init(struct pt_regs *regs, unsigned long load_addr)
159{
160 /* Zero all registers. */
161 memset(regs, 0, sizeof(*regs));
162
163 /* Report the interpreter's load address. */
164 sim_notify_interp(load_addr);
165}