aboutsummaryrefslogtreecommitdiffstats
path: root/arch/um/kernel/skas/mem_user.c
diff options
context:
space:
mode:
Diffstat (limited to 'arch/um/kernel/skas/mem_user.c')
-rw-r--r--arch/um/kernel/skas/mem_user.c224
1 files changed, 166 insertions, 58 deletions
diff --git a/arch/um/kernel/skas/mem_user.c b/arch/um/kernel/skas/mem_user.c
index b0980ff3bd95..1d89640bd502 100644
--- a/arch/um/kernel/skas/mem_user.c
+++ b/arch/um/kernel/skas/mem_user.c
@@ -5,13 +5,14 @@
5 5
6#include <signal.h> 6#include <signal.h>
7#include <errno.h> 7#include <errno.h>
8#include <string.h>
8#include <sys/mman.h> 9#include <sys/mman.h>
9#include <sys/wait.h> 10#include <sys/wait.h>
10#include <asm/page.h> 11#include <asm/page.h>
11#include <asm/unistd.h> 12#include <asm/unistd.h>
12#include "mem_user.h" 13#include "mem_user.h"
13#include "mem.h" 14#include "mem.h"
14#include "mm_id.h" 15#include "skas.h"
15#include "user.h" 16#include "user.h"
16#include "os.h" 17#include "os.h"
17#include "proc_mm.h" 18#include "proc_mm.h"
@@ -23,46 +24,155 @@
23#include "uml-config.h" 24#include "uml-config.h"
24#include "sysdep/ptrace.h" 25#include "sysdep/ptrace.h"
25#include "sysdep/stub.h" 26#include "sysdep/stub.h"
26#include "skas.h"
27 27
28extern unsigned long syscall_stub, __syscall_stub_start; 28extern unsigned long batch_syscall_stub, __syscall_stub_start;
29 29
30extern void wait_stub_done(int pid, int sig, char * fname); 30extern void wait_stub_done(int pid, int sig, char * fname);
31 31
32static long run_syscall_stub(struct mm_id * mm_idp, int syscall, 32static inline unsigned long *check_init_stack(struct mm_id * mm_idp,
33 unsigned long *args) 33 unsigned long *stack)
34{
35 if(stack == NULL){
36 stack = (unsigned long *) mm_idp->stack + 2;
37 *stack = 0;
38 }
39 return stack;
40}
41
42extern int proc_mm;
43
44int single_count = 0;
45int multi_count = 0;
46int multi_op_count = 0;
47
48static long do_syscall_stub(struct mm_id *mm_idp, void **addr)
34{ 49{
50 unsigned long regs[MAX_REG_NR];
51 unsigned long *data;
52 unsigned long *syscall;
53 long ret, offset;
35 int n, pid = mm_idp->u.pid; 54 int n, pid = mm_idp->u.pid;
36 unsigned long regs[MAX_REG_NR]; 55
56 if(proc_mm)
57#warning Need to look up userspace_pid by cpu
58 pid = userspace_pid[0];
59
60 multi_count++;
37 61
38 get_safe_registers(regs); 62 get_safe_registers(regs);
39 regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE + 63 regs[REGS_IP_INDEX] = UML_CONFIG_STUB_CODE +
40 ((unsigned long) &syscall_stub - 64 ((unsigned long) &batch_syscall_stub -
41 (unsigned long) &__syscall_stub_start); 65 (unsigned long) &__syscall_stub_start);
42 /* XXX Don't have a define for starting a syscall */ 66 n = ptrace_setregs(pid, regs);
43 regs[REGS_SYSCALL_NR] = syscall; 67 if(n < 0)
44 regs[REGS_SYSCALL_ARG1] = args[0]; 68 panic("do_syscall_stub : PTRACE_SETREGS failed, errno = %d\n",
45 regs[REGS_SYSCALL_ARG2] = args[1]; 69 n);
46 regs[REGS_SYSCALL_ARG3] = args[2]; 70
47 regs[REGS_SYSCALL_ARG4] = args[3]; 71 wait_stub_done(pid, 0, "do_syscall_stub");
48 regs[REGS_SYSCALL_ARG5] = args[4]; 72
49 regs[REGS_SYSCALL_ARG6] = args[5]; 73 /* When the stub stops, we find the following values on the
50 n = ptrace_setregs(pid, regs); 74 * beginning of the stack:
51 if(n < 0){ 75 * (long )return_value
52 printk("run_syscall_stub : PTRACE_SETREGS failed, " 76 * (long )offset to failed sycall-data (0, if no error)
53 "errno = %d\n", n); 77 */
54 return(n); 78 ret = *((unsigned long *) mm_idp->stack);
79 offset = *((unsigned long *) mm_idp->stack + 1);
80 if (offset) {
81 data = (unsigned long *)(mm_idp->stack +
82 offset - UML_CONFIG_STUB_DATA);
83 syscall = (unsigned long *)((unsigned long)data + data[0]);
84 printk("do_syscall_stub: syscall %ld failed, return value = "
85 "0x%lx, expected return value = 0x%lx\n",
86 syscall[0], ret, syscall[7]);
87 printk(" syscall parameters: "
88 "0x%lx 0x%lx 0x%lx 0x%lx 0x%lx 0x%lx\n",
89 syscall[1], syscall[2], syscall[3],
90 syscall[4], syscall[5], syscall[6]);
91 for(n = 1; n < data[0]/sizeof(long); n++) {
92 if(n == 1)
93 printk(" additional syscall data:");
94 if(n % 4 == 1)
95 printk("\n ");
96 printk(" 0x%lx", data[n]);
97 }
98 if(n > 1)
99 printk("\n");
100 }
101 else ret = 0;
102
103 *addr = check_init_stack(mm_idp, NULL);
104
105 return ret;
106}
107
108long run_syscall_stub(struct mm_id * mm_idp, int syscall,
109 unsigned long *args, long expected, void **addr,
110 int done)
111{
112 unsigned long *stack = check_init_stack(mm_idp, *addr);
113
114 if(done && *addr == NULL)
115 single_count++;
116
117 *stack += sizeof(long);
118 stack += *stack / sizeof(long);
119
120 *stack++ = syscall;
121 *stack++ = args[0];
122 *stack++ = args[1];
123 *stack++ = args[2];
124 *stack++ = args[3];
125 *stack++ = args[4];
126 *stack++ = args[5];
127 *stack++ = expected;
128 *stack = 0;
129 multi_op_count++;
130
131 if(!done && ((((unsigned long) stack) & ~PAGE_MASK) <
132 PAGE_SIZE - 10 * sizeof(long))){
133 *addr = stack;
134 return 0;
55 } 135 }
56 136
57 wait_stub_done(pid, 0, "run_syscall_stub"); 137 return do_syscall_stub(mm_idp, addr);
138}
139
140long syscall_stub_data(struct mm_id * mm_idp,
141 unsigned long *data, int data_count,
142 void **addr, void **stub_addr)
143{
144 unsigned long *stack;
145 int ret = 0;
58 146
59 return(*((unsigned long *) mm_idp->stack)); 147 /* If *addr still is uninitialized, it *must* contain NULL.
148 * Thus in this case do_syscall_stub correctly won't be called.
149 */
150 if((((unsigned long) *addr) & ~PAGE_MASK) >=
151 PAGE_SIZE - (10 + data_count) * sizeof(long)) {
152 ret = do_syscall_stub(mm_idp, addr);
153 /* in case of error, don't overwrite data on stack */
154 if(ret)
155 return ret;
156 }
157
158 stack = check_init_stack(mm_idp, *addr);
159 *addr = stack;
160
161 *stack = data_count * sizeof(long);
162
163 memcpy(stack + 1, data, data_count * sizeof(long));
164
165 *stub_addr = (void *)(((unsigned long)(stack + 1) & ~PAGE_MASK) +
166 UML_CONFIG_STUB_DATA);
167
168 return 0;
60} 169}
61 170
62int map(struct mm_id *mm_idp, unsigned long virt, unsigned long len, 171int map(struct mm_id * mm_idp, unsigned long virt, unsigned long len,
63 int r, int w, int x, int phys_fd, unsigned long long offset) 172 int r, int w, int x, int phys_fd, unsigned long long offset,
173 int done, void **data)
64{ 174{
65 int prot, n; 175 int prot, ret;
66 176
67 prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) | 177 prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
68 (x ? PROT_EXEC : 0); 178 (x ? PROT_EXEC : 0);
@@ -70,6 +180,7 @@ int map(struct mm_id *mm_idp, unsigned long virt, unsigned long len,
70 if(proc_mm){ 180 if(proc_mm){
71 struct proc_mm_op map; 181 struct proc_mm_op map;
72 int fd = mm_idp->u.mm_fd; 182 int fd = mm_idp->u.mm_fd;
183
73 map = ((struct proc_mm_op) { .op = MM_MMAP, 184 map = ((struct proc_mm_op) { .op = MM_MMAP,
74 .u = 185 .u =
75 { .mmap = 186 { .mmap =
@@ -81,63 +192,61 @@ int map(struct mm_id *mm_idp, unsigned long virt, unsigned long len,
81 .fd = phys_fd, 192 .fd = phys_fd,
82 .offset= offset 193 .offset= offset
83 } } } ); 194 } } } );
84 n = os_write_file(fd, &map, sizeof(map)); 195 ret = os_write_file(fd, &map, sizeof(map));
85 if(n != sizeof(map)) 196 if(ret != sizeof(map))
86 printk("map : /proc/mm map failed, err = %d\n", -n); 197 printk("map : /proc/mm map failed, err = %d\n", -ret);
198 else ret = 0;
87 } 199 }
88 else { 200 else {
89 long res;
90 unsigned long args[] = { virt, len, prot, 201 unsigned long args[] = { virt, len, prot,
91 MAP_SHARED | MAP_FIXED, phys_fd, 202 MAP_SHARED | MAP_FIXED, phys_fd,
92 MMAP_OFFSET(offset) }; 203 MMAP_OFFSET(offset) };
93 204
94 res = run_syscall_stub(mm_idp, STUB_MMAP_NR, args); 205 ret = run_syscall_stub(mm_idp, STUB_MMAP_NR, args, virt,
95 if((void *) res == MAP_FAILED) 206 data, done);
96 printk("mmap stub failed, errno = %d\n", res);
97 } 207 }
98 208
99 return 0; 209 return ret;
100} 210}
101 211
102int unmap(struct mm_id *mm_idp, void *addr, unsigned long len) 212int unmap(struct mm_id * mm_idp, void *addr, unsigned long len, int done,
213 void **data)
103{ 214{
104 int n; 215 int ret;
105 216
106 if(proc_mm){ 217 if(proc_mm){
107 struct proc_mm_op unmap; 218 struct proc_mm_op unmap;
108 int fd = mm_idp->u.mm_fd; 219 int fd = mm_idp->u.mm_fd;
220
109 unmap = ((struct proc_mm_op) { .op = MM_MUNMAP, 221 unmap = ((struct proc_mm_op) { .op = MM_MUNMAP,
110 .u = 222 .u =
111 { .munmap = 223 { .munmap =
112 { .addr = 224 { .addr =
113 (unsigned long) addr, 225 (unsigned long) addr,
114 .len = len } } } ); 226 .len = len } } } );
115 n = os_write_file(fd, &unmap, sizeof(unmap)); 227 ret = os_write_file(fd, &unmap, sizeof(unmap));
116 if(n != sizeof(unmap)) { 228 if(ret != sizeof(unmap))
117 if(n < 0) 229 printk("unmap - proc_mm write returned %d\n", ret);
118 return(n); 230 else ret = 0;
119 else if(n > 0)
120 return(-EIO);
121 }
122 } 231 }
123 else { 232 else {
124 int res;
125 unsigned long args[] = { (unsigned long) addr, len, 0, 0, 0, 233 unsigned long args[] = { (unsigned long) addr, len, 0, 0, 0,
126 0 }; 234 0 };
127 235
128 res = run_syscall_stub(mm_idp, __NR_munmap, args); 236 ret = run_syscall_stub(mm_idp, __NR_munmap, args, 0,
129 if(res < 0) 237 data, done);
130 printk("munmap stub failed, errno = %d\n", res); 238 if(ret < 0)
239 printk("munmap stub failed, errno = %d\n", ret);
131 } 240 }
132 241
133 return(0); 242 return ret;
134} 243}
135 244
136int protect(struct mm_id *mm_idp, unsigned long addr, unsigned long len, 245int protect(struct mm_id * mm_idp, unsigned long addr, unsigned long len,
137 int r, int w, int x) 246 int r, int w, int x, int done, void **data)
138{ 247{
139 struct proc_mm_op protect; 248 struct proc_mm_op protect;
140 int prot, n; 249 int prot, ret;
141 250
142 prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) | 251 prot = (r ? PROT_READ : 0) | (w ? PROT_WRITE : 0) |
143 (x ? PROT_EXEC : 0); 252 (x ? PROT_EXEC : 0);
@@ -152,20 +261,19 @@ int protect(struct mm_id *mm_idp, unsigned long addr, unsigned long len,
152 .len = len, 261 .len = len,
153 .prot = prot } } } ); 262 .prot = prot } } } );
154 263
155 n = os_write_file(fd, &protect, sizeof(protect)); 264 ret = os_write_file(fd, &protect, sizeof(protect));
156 if(n != sizeof(protect)) 265 if(ret != sizeof(protect))
157 panic("protect failed, err = %d", -n); 266 printk("protect failed, err = %d", -ret);
267 else ret = 0;
158 } 268 }
159 else { 269 else {
160 int res;
161 unsigned long args[] = { addr, len, prot, 0, 0, 0 }; 270 unsigned long args[] = { addr, len, prot, 0, 0, 0 };
162 271
163 res = run_syscall_stub(mm_idp, __NR_mprotect, args); 272 ret = run_syscall_stub(mm_idp, __NR_mprotect, args, 0,
164 if(res < 0) 273 data, done);
165 panic("mprotect stub failed, errno = %d\n", res);
166 } 274 }
167 275
168 return(0); 276 return ret;
169} 277}
170 278
171void before_mem_skas(unsigned long unused) 279void before_mem_skas(unsigned long unused)
generated by cgit v1.2.2 (git 2.25.0) at 2025-03-07 04:27:23 -0500