| .. | .. |
|---|
| 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; |
|---|