diff options
Diffstat (limited to 'arch/parisc/kernel/signal32.c')
-rw-r--r-- | arch/parisc/kernel/signal32.c | 149 |
1 files changed, 0 insertions, 149 deletions
diff --git a/arch/parisc/kernel/signal32.c b/arch/parisc/kernel/signal32.c index 2ddcabb616ce..33eca1b04926 100644 --- a/arch/parisc/kernel/signal32.c +++ b/arch/parisc/kernel/signal32.c | |||
@@ -60,136 +60,6 @@ sigset_64to32(compat_sigset_t *s32, sigset_t *s64) | |||
60 | s32->sig[1] = (s64->sig[0] >> 32) & 0xffffffffUL; | 60 | s32->sig[1] = (s64->sig[0] >> 32) & 0xffffffffUL; |
61 | } | 61 | } |
62 | 62 | ||
63 | static int | ||
64 | put_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz) | ||
65 | { | ||
66 | compat_sigset_t s; | ||
67 | |||
68 | if (sz != sizeof(compat_sigset_t)) | ||
69 | return -EINVAL; | ||
70 | sigset_64to32(&s, set); | ||
71 | |||
72 | return copy_to_user(up, &s, sizeof s); | ||
73 | } | ||
74 | |||
75 | static int | ||
76 | get_sigset32(compat_sigset_t __user *up, sigset_t *set, size_t sz) | ||
77 | { | ||
78 | compat_sigset_t s; | ||
79 | int r; | ||
80 | |||
81 | if (sz != sizeof(compat_sigset_t)) | ||
82 | return -EINVAL; | ||
83 | |||
84 | if ((r = copy_from_user(&s, up, sz)) == 0) { | ||
85 | sigset_32to64(set, &s); | ||
86 | } | ||
87 | |||
88 | return r; | ||
89 | } | ||
90 | |||
91 | int sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, compat_sigset_t __user *oset, | ||
92 | unsigned int sigsetsize) | ||
93 | { | ||
94 | sigset_t old_set, new_set; | ||
95 | int ret; | ||
96 | |||
97 | if (set) { | ||
98 | ret = get_sigset32(set, &new_set, sigsetsize); | ||
99 | if (ret) | ||
100 | return ret; | ||
101 | } | ||
102 | |||
103 | KERNEL_SYSCALL(ret, sys_rt_sigprocmask, how, set ? (sigset_t __user *)&new_set : NULL, | ||
104 | oset ? (sigset_t __user *)&old_set : NULL, sigsetsize); | ||
105 | |||
106 | if (!ret && oset && put_sigset32(oset, &old_set, sigsetsize)) | ||
107 | return -EFAULT; | ||
108 | |||
109 | return ret; | ||
110 | } | ||
111 | |||
112 | |||
113 | int sys32_rt_sigpending(compat_sigset_t __user *uset, unsigned int sigsetsize) | ||
114 | { | ||
115 | int ret; | ||
116 | sigset_t set; | ||
117 | |||
118 | KERNEL_SYSCALL(ret, sys_rt_sigpending, (sigset_t __user *)&set, sigsetsize); | ||
119 | |||
120 | if (!ret && put_sigset32(uset, &set, sigsetsize)) | ||
121 | return -EFAULT; | ||
122 | |||
123 | return ret; | ||
124 | } | ||
125 | |||
126 | long | ||
127 | sys32_rt_sigaction(int sig, const struct sigaction32 __user *act, struct sigaction32 __user *oact, | ||
128 | size_t sigsetsize) | ||
129 | { | ||
130 | struct k_sigaction32 new_sa32, old_sa32; | ||
131 | struct k_sigaction new_sa, old_sa; | ||
132 | int ret = -EINVAL; | ||
133 | |||
134 | /* XXX: Don't preclude handling different sized sigset_t's. */ | ||
135 | if (sigsetsize != sizeof(compat_sigset_t)) | ||
136 | return -EINVAL; | ||
137 | |||
138 | if (act) { | ||
139 | if (copy_from_user(&new_sa32.sa, act, sizeof new_sa32.sa)) | ||
140 | return -EFAULT; | ||
141 | new_sa.sa.sa_handler = (__sighandler_t)(unsigned long)new_sa32.sa.sa_handler; | ||
142 | new_sa.sa.sa_flags = new_sa32.sa.sa_flags; | ||
143 | sigset_32to64(&new_sa.sa.sa_mask, &new_sa32.sa.sa_mask); | ||
144 | } | ||
145 | |||
146 | ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL); | ||
147 | |||
148 | if (!ret && oact) { | ||
149 | sigset_64to32(&old_sa32.sa.sa_mask, &old_sa.sa.sa_mask); | ||
150 | old_sa32.sa.sa_flags = old_sa.sa.sa_flags; | ||
151 | old_sa32.sa.sa_handler = (__sighandler_t32)(unsigned long)old_sa.sa.sa_handler; | ||
152 | if (copy_to_user(oact, &old_sa32.sa, sizeof old_sa32.sa)) | ||
153 | return -EFAULT; | ||
154 | } | ||
155 | return ret; | ||
156 | } | ||
157 | |||
158 | int | ||
159 | do_sigaltstack32 (const compat_stack_t __user *uss32, compat_stack_t __user *uoss32, unsigned long sp) | ||
160 | { | ||
161 | compat_stack_t ss32, oss32; | ||
162 | stack_t ss, oss; | ||
163 | stack_t *ssp = NULL, *ossp = NULL; | ||
164 | int ret; | ||
165 | |||
166 | if (uss32) { | ||
167 | if (copy_from_user(&ss32, uss32, sizeof ss32)) | ||
168 | return -EFAULT; | ||
169 | |||
170 | ss.ss_sp = (void __user *)(unsigned long)ss32.ss_sp; | ||
171 | ss.ss_flags = ss32.ss_flags; | ||
172 | ss.ss_size = ss32.ss_size; | ||
173 | |||
174 | ssp = &ss; | ||
175 | } | ||
176 | |||
177 | if (uoss32) | ||
178 | ossp = &oss; | ||
179 | |||
180 | KERNEL_SYSCALL(ret, do_sigaltstack, (const stack_t __user *)ssp, (stack_t __user *)ossp, sp); | ||
181 | |||
182 | if (!ret && uoss32) { | ||
183 | oss32.ss_sp = (unsigned int)(unsigned long)oss.ss_sp; | ||
184 | oss32.ss_flags = oss.ss_flags; | ||
185 | oss32.ss_size = oss.ss_size; | ||
186 | if (copy_to_user(uoss32, &oss32, sizeof *uoss32)) | ||
187 | return -EFAULT; | ||
188 | } | ||
189 | |||
190 | return ret; | ||
191 | } | ||
192 | |||
193 | long | 63 | long |
194 | restore_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf, | 64 | restore_sigcontext32(struct compat_sigcontext __user *sc, struct compat_regfile __user * rf, |
195 | struct pt_regs *regs) | 65 | struct pt_regs *regs) |
@@ -506,22 +376,3 @@ copy_siginfo_to_user32 (compat_siginfo_t __user *to, siginfo_t *from) | |||
506 | } | 376 | } |
507 | return err; | 377 | return err; |
508 | } | 378 | } |
509 | |||
510 | asmlinkage long compat_sys_rt_sigqueueinfo(int pid, int sig, | ||
511 | struct compat_siginfo __user *uinfo) | ||
512 | { | ||
513 | siginfo_t info; | ||
514 | |||
515 | if (copy_siginfo_from_user32(&info, uinfo)) | ||
516 | return -EFAULT; | ||
517 | |||
518 | /* Not even root can pretend to send signals from the kernel. | ||
519 | Nor can they impersonate a kill(), which adds source info. */ | ||
520 | if (info.si_code >= 0) | ||
521 | return -EPERM; | ||
522 | info.si_signo = sig; | ||
523 | |||
524 | /* POSIX.1b doesn't mention process groups. */ | ||
525 | return kill_proc_info(sig, &info, pid); | ||
526 | } | ||
527 | |||