int do_sigaltstack32 (const compat_stack_t __user *uss32, compat_stack_t __user *uoss32, unsigned long sp) { compat_stack_t ss32, oss32; stack_t ss, oss; stack_t *ssp = NULL, *ossp = NULL; int ret; if (uss32) { if (copy_from_user(&ss32, uss32, sizeof ss32)) return -EFAULT; ss.ss_sp = (void __user *)(unsigned long)ss32.ss_sp; ss.ss_flags = ss32.ss_flags; ss.ss_size = ss32.ss_size; ssp = &ss; } if (uoss32) ossp = &oss; KERNEL_SYSCALL(ret, do_sigaltstack, (const stack_t __user *)ssp, (stack_t __user *)ossp, sp); if (!ret && uoss32) { oss32.ss_sp = (unsigned int)(unsigned long)oss.ss_sp; oss32.ss_flags = oss.ss_flags; oss32.ss_size = oss.ss_size; if (copy_to_user(uoss32, &oss32, sizeof *uoss32)) return -EFAULT; } return ret; }
asmlinkage long sys32_msgrcv(int msqid, struct msgbuf32 __user *umsgp32, size_t msgsz, long msgtyp, int msgflg) { struct msgbuf *mb; struct msgbuf32 mb32; int err, len; if ((mb = kmalloc(msgsz + sizeof *mb + 4, GFP_KERNEL)) == NULL) return -ENOMEM; KERNEL_SYSCALL(err, sys_msgrcv, msqid, (struct msgbuf __user *)mb, msgsz, msgtyp, msgflg); if (err >= 0) { len = err; mb32.mtype = mb->mtype; err = put_user(mb32.mtype, &umsgp32->mtype); err |= copy_to_user(&umsgp32->mtext, mb->mtext, len); if (err) err = -EFAULT; else err = len; } kfree(mb); return err; }
asmlinkage long sys32_sched_rr_get_interval(pid_t pid, struct compat_timespec __user *interval) { struct timespec t; int ret; KERNEL_SYSCALL(ret, sys_sched_rr_get_interval, pid, (struct timespec __user *)&t); if (put_compat_timespec(&t, interval)) return -EFAULT; return ret; }
int sys32_rt_sigpending(compat_sigset_t __user *uset, unsigned int sigsetsize) { int ret; sigset_t set; KERNEL_SYSCALL(ret, sys_rt_sigpending, (sigset_t __user *)&set, sigsetsize); if (!ret && put_sigset32(uset, &set, sigsetsize)) return -EFAULT; return ret; }
int sys32_rt_sigpending(sigset_t32 *uset, unsigned int sigsetsize) { int ret; sigset_t set; extern long sys_rt_sigpending(sigset_t *set, size_t sigsetsize); KERNEL_SYSCALL(ret, sys_rt_sigpending, &set, sigsetsize); if (!ret && put_sigset32(uset, &set, sigsetsize)) return -EFAULT; return ret; }
int sys32_sigprocmask(int how, old_sigset_t32 *set, old_sigset_t32 *oset) { extern int sys_sigprocmask(int how, old_sigset_t *set, old_sigset_t *oset); old_sigset_t s; int ret; if (set && get_old_segset32 (set, &s)) return -EFAULT; KERNEL_SYSCALL(ret, sys_sigprocmask, how, set ? &s : NULL, oset ? &s : NULL); if (!ret && oset && put_old_sigset32(oset, &s)) return -EFAULT; return ret; }
long sys32_sigpending(old_sigset_t32 *set) { extern long sys_sigpending(old_sigset_t *set); old_sigset_t pending; int ret; KERNEL_SYSCALL(ret, sys_sigpending, &pending); /* can't put_user an old_sigset_t -- it is too big */ if (put_old_sigset32(set, &pending)) return -EFAULT; return ret; }
int sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, compat_sigset_t __user *oset, unsigned int sigsetsize) { sigset_t old_set, new_set; int ret; if (set && get_sigset32(set, &new_set, sigsetsize)) return -EFAULT; KERNEL_SYSCALL(ret, sys_rt_sigprocmask, how, set ? (sigset_t __user *)&new_set : NULL, oset ? (sigset_t __user *)&old_set : NULL, sigsetsize); if (!ret && oset && put_sigset32(oset, &old_set, sigsetsize)) return -EFAULT; return ret; }
int sys32_rt_sigprocmask(int how, sigset_t32 *set, sigset_t32 *oset, unsigned int sigsetsize) { extern long sys_rt_sigprocmask(int how, sigset_t *set, sigset_t *oset, size_t sigsetsize); sigset_t old_set, new_set; int ret; if (set && get_sigset32(set, &new_set, sigsetsize)) return -EFAULT; KERNEL_SYSCALL(ret, sys_rt_sigprocmask, how, set ? &new_set : NULL, oset ? &old_set : NULL, sigsetsize); if (!ret && oset && put_sigset32(oset, &old_set, sigsetsize)) return -EFAULT; return ret; }
asmlinkage long sys32_msgsnd(int msqid, struct msgbuf32 __user *umsgp32, size_t msgsz, int msgflg) { struct msgbuf *mb; struct msgbuf32 mb32; int err; if ((mb = kmalloc(msgsz + sizeof *mb + 4, GFP_KERNEL)) == NULL) return -ENOMEM; err = get_user(mb32.mtype, &umsgp32->mtype); mb->mtype = mb32.mtype; err |= copy_from_user(mb->mtext, &umsgp32->mtext, msgsz); if (err) err = -EFAULT; else KERNEL_SYSCALL(err, sys_msgsnd, msqid, (struct msgbuf __user *)mb, msgsz, msgflg); kfree(mb); return err; }