1 /* sys_sparc32.c: Conversion between 32bit and 64bit native syscalls. 2 * 3 * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) 4 * Copyright (C) 1997, 2007 David S. Miller (davem@davemloft.net) 5 * 6 * These routines maintain argument size conversion between 32bit and 64bit 7 * environment. 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/sched.h> 12 #include <linux/capability.h> 13 #include <linux/fs.h> 14 #include <linux/mm.h> 15 #include <linux/file.h> 16 #include <linux/signal.h> 17 #include <linux/resource.h> 18 #include <linux/times.h> 19 #include <linux/smp.h> 20 #include <linux/sem.h> 21 #include <linux/msg.h> 22 #include <linux/shm.h> 23 #include <linux/uio.h> 24 #include <linux/nfs_fs.h> 25 #include <linux/quota.h> 26 #include <linux/poll.h> 27 #include <linux/personality.h> 28 #include <linux/stat.h> 29 #include <linux/filter.h> 30 #include <linux/highmem.h> 31 #include <linux/highuid.h> 32 #include <linux/mman.h> 33 #include <linux/ipv6.h> 34 #include <linux/in.h> 35 #include <linux/icmpv6.h> 36 #include <linux/syscalls.h> 37 #include <linux/sysctl.h> 38 #include <linux/binfmts.h> 39 #include <linux/dnotify.h> 40 #include <linux/security.h> 41 #include <linux/compat.h> 42 #include <linux/vfs.h> 43 #include <linux/ptrace.h> 44 #include <linux/slab.h> 45 46 #include <asm/types.h> 47 #include <asm/uaccess.h> 48 #include <asm/fpumacro.h> 49 #include <asm/mmu_context.h> 50 #include <asm/compat_signal.h> 51 52 asmlinkage long sys32_truncate64(const char __user * path, unsigned long high, unsigned long low) 53 { 54 if ((int)high < 0) 55 return -EINVAL; 56 else 57 return sys_truncate(path, (high << 32) | low); 58 } 59 60 asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low) 61 { 62 if ((int)high < 0) 63 return -EINVAL; 64 else 65 return sys_ftruncate(fd, (high << 32) | low); 66 } 67 68 static int cp_compat_stat64(struct kstat *stat, 69 struct compat_stat64 __user *statbuf) 70 { 71 int err; 72 73 err = put_user(huge_encode_dev(stat->dev), &statbuf->st_dev); 74 err |= put_user(stat->ino, &statbuf->st_ino); 75 err |= put_user(stat->mode, &statbuf->st_mode); 76 err |= put_user(stat->nlink, &statbuf->st_nlink); 77 err |= put_user(from_kuid_munged(current_user_ns(), stat->uid), &statbuf->st_uid); 78 err |= put_user(from_kgid_munged(current_user_ns(), stat->gid), &statbuf->st_gid); 79 err |= put_user(huge_encode_dev(stat->rdev), &statbuf->st_rdev); 80 err |= put_user(0, (unsigned long __user *) &statbuf->__pad3[0]); 81 err |= put_user(stat->size, &statbuf->st_size); 82 err |= put_user(stat->blksize, &statbuf->st_blksize); 83 err |= put_user(0, (unsigned int __user *) &statbuf->__pad4[0]); 84 err |= put_user(0, (unsigned int __user *) &statbuf->__pad4[4]); 85 err |= put_user(stat->blocks, &statbuf->st_blocks); 86 err |= put_user(stat->atime.tv_sec, &statbuf->st_atime); 87 err |= put_user(stat->atime.tv_nsec, &statbuf->st_atime_nsec); 88 err |= put_user(stat->mtime.tv_sec, &statbuf->st_mtime); 89 err |= put_user(stat->mtime.tv_nsec, &statbuf->st_mtime_nsec); 90 err |= put_user(stat->ctime.tv_sec, &statbuf->st_ctime); 91 err |= put_user(stat->ctime.tv_nsec, &statbuf->st_ctime_nsec); 92 err |= put_user(0, &statbuf->__unused4); 93 err |= put_user(0, &statbuf->__unused5); 94 95 return err; 96 } 97 98 asmlinkage long compat_sys_stat64(const char __user * filename, 99 struct compat_stat64 __user *statbuf) 100 { 101 struct kstat stat; 102 int error = vfs_stat(filename, &stat); 103 104 if (!error) 105 error = cp_compat_stat64(&stat, statbuf); 106 return error; 107 } 108 109 asmlinkage long compat_sys_lstat64(const char __user * filename, 110 struct compat_stat64 __user *statbuf) 111 { 112 struct kstat stat; 113 int error = vfs_lstat(filename, &stat); 114 115 if (!error) 116 error = cp_compat_stat64(&stat, statbuf); 117 return error; 118 } 119 120 asmlinkage long compat_sys_fstat64(unsigned int fd, 121 struct compat_stat64 __user * statbuf) 122 { 123 struct kstat stat; 124 int error = vfs_fstat(fd, &stat); 125 126 if (!error) 127 error = cp_compat_stat64(&stat, statbuf); 128 return error; 129 } 130 131 asmlinkage long compat_sys_fstatat64(unsigned int dfd, 132 const char __user *filename, 133 struct compat_stat64 __user * statbuf, int flag) 134 { 135 struct kstat stat; 136 int error; 137 138 error = vfs_fstatat(dfd, filename, &stat, flag); 139 if (error) 140 return error; 141 return cp_compat_stat64(&stat, statbuf); 142 } 143 144 COMPAT_SYSCALL_DEFINE3(sparc_sigaction, int, sig, 145 struct compat_old_sigaction __user *,act, 146 struct compat_old_sigaction __user *,oact) 147 { 148 WARN_ON_ONCE(sig >= 0); 149 return compat_sys_sigaction(-sig, act, oact); 150 } 151 152 COMPAT_SYSCALL_DEFINE5(rt_sigaction, int, sig, 153 struct compat_sigaction __user *,act, 154 struct compat_sigaction __user *,oact, 155 void __user *,restorer, 156 compat_size_t,sigsetsize) 157 { 158 struct k_sigaction new_ka, old_ka; 159 int ret; 160 compat_sigset_t set32; 161 162 /* XXX: Don't preclude handling different sized sigset_t's. */ 163 if (sigsetsize != sizeof(compat_sigset_t)) 164 return -EINVAL; 165 166 if (act) { 167 u32 u_handler, u_restorer; 168 169 new_ka.ka_restorer = restorer; 170 ret = get_user(u_handler, &act->sa_handler); 171 new_ka.sa.sa_handler = compat_ptr(u_handler); 172 ret |= copy_from_user(&set32, &act->sa_mask, sizeof(compat_sigset_t)); 173 sigset_from_compat(&new_ka.sa.sa_mask, &set32); 174 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags); 175 ret |= get_user(u_restorer, &act->sa_restorer); 176 new_ka.sa.sa_restorer = compat_ptr(u_restorer); 177 if (ret) 178 return -EFAULT; 179 } 180 181 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 182 183 if (!ret && oact) { 184 sigset_to_compat(&set32, &old_ka.sa.sa_mask); 185 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler); 186 ret |= copy_to_user(&oact->sa_mask, &set32, sizeof(compat_sigset_t)); 187 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags); 188 ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer); 189 if (ret) 190 ret = -EFAULT; 191 } 192 193 return ret; 194 } 195 196 asmlinkage compat_ssize_t sys32_pread64(unsigned int fd, 197 char __user *ubuf, 198 compat_size_t count, 199 unsigned long poshi, 200 unsigned long poslo) 201 { 202 return sys_pread64(fd, ubuf, count, (poshi << 32) | poslo); 203 } 204 205 asmlinkage compat_ssize_t sys32_pwrite64(unsigned int fd, 206 char __user *ubuf, 207 compat_size_t count, 208 unsigned long poshi, 209 unsigned long poslo) 210 { 211 return sys_pwrite64(fd, ubuf, count, (poshi << 32) | poslo); 212 } 213 214 asmlinkage long compat_sys_readahead(int fd, 215 unsigned long offhi, 216 unsigned long offlo, 217 compat_size_t count) 218 { 219 return sys_readahead(fd, (offhi << 32) | offlo, count); 220 } 221 222 long compat_sys_fadvise64(int fd, 223 unsigned long offhi, 224 unsigned long offlo, 225 compat_size_t len, int advice) 226 { 227 return sys_fadvise64_64(fd, (offhi << 32) | offlo, len, advice); 228 } 229 230 long compat_sys_fadvise64_64(int fd, 231 unsigned long offhi, unsigned long offlo, 232 unsigned long lenhi, unsigned long lenlo, 233 int advice) 234 { 235 return sys_fadvise64_64(fd, 236 (offhi << 32) | offlo, 237 (lenhi << 32) | lenlo, 238 advice); 239 } 240 241 long sys32_sync_file_range(unsigned int fd, unsigned long off_high, unsigned long off_low, unsigned long nb_high, unsigned long nb_low, unsigned int flags) 242 { 243 return sys_sync_file_range(fd, 244 (off_high << 32) | off_low, 245 (nb_high << 32) | nb_low, 246 flags); 247 } 248 249 asmlinkage long compat_sys_fallocate(int fd, int mode, u32 offhi, u32 offlo, 250 u32 lenhi, u32 lenlo) 251 { 252 return sys_fallocate(fd, mode, ((loff_t)offhi << 32) | offlo, 253 ((loff_t)lenhi << 32) | lenlo); 254 } 255