.. | .. |
---|
36 | 36 | |
---|
37 | 37 | static inline int rt_restore_ucontext(struct pt_regs *regs, |
---|
38 | 38 | struct switch_stack *sw, |
---|
39 | | - struct ucontext *uc, int *pr2) |
---|
| 39 | + struct ucontext __user *uc, int *pr2) |
---|
40 | 40 | { |
---|
41 | 41 | int temp; |
---|
42 | | - unsigned long *gregs = uc->uc_mcontext.gregs; |
---|
| 42 | + unsigned long __user *gregs = uc->uc_mcontext.gregs; |
---|
43 | 43 | int err; |
---|
44 | 44 | |
---|
45 | 45 | /* Always make any pending restarted system calls return -EINTR */ |
---|
.. | .. |
---|
102 | 102 | { |
---|
103 | 103 | struct pt_regs *regs = (struct pt_regs *)(sw + 1); |
---|
104 | 104 | /* Verify, can we follow the stack back */ |
---|
105 | | - struct rt_sigframe *frame = (struct rt_sigframe *) regs->sp; |
---|
| 105 | + struct rt_sigframe __user *frame; |
---|
106 | 106 | sigset_t set; |
---|
107 | 107 | int rval; |
---|
108 | 108 | |
---|
109 | | - if (!access_ok(VERIFY_READ, frame, sizeof(*frame))) |
---|
| 109 | + frame = (struct rt_sigframe __user *) regs->sp; |
---|
| 110 | + if (!access_ok(frame, sizeof(*frame))) |
---|
110 | 111 | goto badframe; |
---|
111 | 112 | |
---|
112 | 113 | if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set))) |
---|
.. | .. |
---|
120 | 121 | return rval; |
---|
121 | 122 | |
---|
122 | 123 | badframe: |
---|
123 | | - force_sig(SIGSEGV, current); |
---|
| 124 | + force_sig(SIGSEGV); |
---|
124 | 125 | return 0; |
---|
125 | 126 | } |
---|
126 | 127 | |
---|
127 | | -static inline int rt_setup_ucontext(struct ucontext *uc, struct pt_regs *regs) |
---|
| 128 | +static inline int rt_setup_ucontext(struct ucontext __user *uc, struct pt_regs *regs) |
---|
128 | 129 | { |
---|
129 | 130 | struct switch_stack *sw = (struct switch_stack *)regs - 1; |
---|
130 | | - unsigned long *gregs = uc->uc_mcontext.gregs; |
---|
| 131 | + unsigned long __user *gregs = uc->uc_mcontext.gregs; |
---|
131 | 132 | int err = 0; |
---|
132 | 133 | |
---|
133 | 134 | err |= __put_user(MCONTEXT_VERSION, &uc->uc_mcontext.version); |
---|
.. | .. |
---|
162 | 163 | return err; |
---|
163 | 164 | } |
---|
164 | 165 | |
---|
165 | | -static inline void *get_sigframe(struct ksignal *ksig, struct pt_regs *regs, |
---|
166 | | - size_t frame_size) |
---|
| 166 | +static inline void __user *get_sigframe(struct ksignal *ksig, |
---|
| 167 | + struct pt_regs *regs, |
---|
| 168 | + size_t frame_size) |
---|
167 | 169 | { |
---|
168 | 170 | unsigned long usp; |
---|
169 | 171 | |
---|
.. | .. |
---|
174 | 176 | usp = sigsp(usp, ksig); |
---|
175 | 177 | |
---|
176 | 178 | /* Verify, is it 32 or 64 bit aligned */ |
---|
177 | | - return (void *)((usp - frame_size) & -8UL); |
---|
| 179 | + return (void __user *)((usp - frame_size) & -8UL); |
---|
178 | 180 | } |
---|
179 | 181 | |
---|
180 | 182 | static int setup_rt_frame(struct ksignal *ksig, sigset_t *set, |
---|
181 | 183 | struct pt_regs *regs) |
---|
182 | 184 | { |
---|
183 | | - struct rt_sigframe *frame; |
---|
| 185 | + struct rt_sigframe __user *frame; |
---|
184 | 186 | int err = 0; |
---|
185 | 187 | |
---|
186 | 188 | frame = get_sigframe(ksig, regs, sizeof(*frame)); |
---|
.. | .. |
---|
211 | 213 | return 0; |
---|
212 | 214 | |
---|
213 | 215 | give_sigsegv: |
---|
214 | | - force_sigsegv(ksig->sig, current); |
---|
| 216 | + force_sigsegv(ksig->sig); |
---|
215 | 217 | return -EFAULT; |
---|
216 | 218 | } |
---|
217 | 219 | |
---|
.. | .. |
---|
240 | 242 | /* |
---|
241 | 243 | * If we were from a system call, check for system call restarting... |
---|
242 | 244 | */ |
---|
243 | | - if (regs->orig_r2 >= 0) { |
---|
| 245 | + if (regs->orig_r2 >= 0 && regs->r1) { |
---|
244 | 246 | continue_addr = regs->ea; |
---|
245 | 247 | restart_addr = continue_addr - 4; |
---|
246 | 248 | retval = regs->r2; |
---|
.. | .. |
---|
252 | 254 | switch (retval) { |
---|
253 | 255 | case ERESTART_RESTARTBLOCK: |
---|
254 | 256 | restart = -2; |
---|
| 257 | + fallthrough; |
---|
255 | 258 | case ERESTARTNOHAND: |
---|
256 | 259 | case ERESTARTSYS: |
---|
257 | 260 | case ERESTARTNOINTR: |
---|
.. | .. |
---|
261 | 264 | regs->ea = restart_addr; |
---|
262 | 265 | break; |
---|
263 | 266 | } |
---|
| 267 | + regs->orig_r2 = -1; |
---|
264 | 268 | } |
---|
265 | 269 | |
---|
266 | 270 | if (get_signal(&ksig)) { |
---|
.. | .. |
---|
305 | 309 | if (!user_mode(regs)) |
---|
306 | 310 | return 0; |
---|
307 | 311 | |
---|
308 | | - if (test_thread_flag(TIF_SIGPENDING)) { |
---|
| 312 | + if (test_thread_flag(TIF_SIGPENDING) || |
---|
| 313 | + test_thread_flag(TIF_NOTIFY_SIGNAL)) { |
---|
309 | 314 | int restart = do_signal(regs); |
---|
310 | 315 | |
---|
311 | 316 | if (unlikely(restart)) { |
---|
.. | .. |
---|
316 | 321 | */ |
---|
317 | 322 | return restart; |
---|
318 | 323 | } |
---|
319 | | - } else if (test_and_clear_thread_flag(TIF_NOTIFY_RESUME)) |
---|
| 324 | + } else if (test_thread_flag(TIF_NOTIFY_RESUME)) |
---|
320 | 325 | tracehook_notify_resume(regs); |
---|
321 | 326 | |
---|
322 | 327 | return 0; |
---|