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 #include "systbls.h" 53 54 asmlinkage long sys32_truncate64(const char __user * path, unsigned long high, unsigned long low) 55 { 56 if ((int)high < 0) 57 return -EINVAL; 58 else 59 return sys_truncate(path, (high << 32) | low); 60 } 61 62 asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low) 63 { 64 if ((int)high < 0) 65 return -EINVAL; 66 else 67 return sys_ftruncate(fd, (high << 32) | low); 68 } 69 70 static int cp_compat_stat64(struct kstat *stat, 71 struct compat_stat64 __user *statbuf) 72 { 73 int err; 74 75 err = put_user(huge_encode_dev(stat->dev), &statbuf->st_dev); 76 err |= put_user(stat->ino, &statbuf->st_ino); 77 err |= put_user(stat->mode, &statbuf->st_mode); 78 err |= put_user(stat->nlink, &statbuf->st_nlink); 79 err |= put_user(from_kuid_munged(current_user_ns(), stat->uid), &statbuf->st_uid); 80 err |= put_user(from_kgid_munged(current_user_ns(), stat->gid), &statbuf->st_gid); 81 err |= put_user(huge_encode_dev(stat->rdev), &statbuf->st_rdev); 82 err |= put_user(0, (unsigned long __user *) &statbuf->__pad3[0]); 83 err |= put_user(stat->size, &statbuf->st_size); 84 err |= put_user(stat->blksize, &statbuf->st_blksize); 85 err |= put_user(0, (unsigned int __user *) &statbuf->__pad4[0]); 86 err |= put_user(0, (unsigned int __user *) &statbuf->__pad4[4]); 87 err |= put_user(stat->blocks, &statbuf->st_blocks); 88 err |= put_user(stat->atime.tv_sec, &statbuf->st_atime); 89 err |= put_user(stat->atime.tv_nsec, &statbuf->st_atime_nsec); 90 err |= put_user(stat->mtime.tv_sec, &statbuf->st_mtime); 91 err |= put_user(stat->mtime.tv_nsec, &statbuf->st_mtime_nsec); 92 err |= put_user(stat->ctime.tv_sec, &statbuf->st_ctime); 93 err |= put_user(stat->ctime.tv_nsec, &statbuf->st_ctime_nsec); 94 err |= put_user(0, &statbuf->__unused4); 95 err |= put_user(0, &statbuf->__unused5); 96 97 return err; 98 } 99 100 asmlinkage long compat_sys_stat64(const char __user * filename, 101 struct compat_stat64 __user *statbuf) 102 { 103 struct kstat stat; 104 int error = vfs_stat(filename, &stat); 105 106 if (!error) 107 error = cp_compat_stat64(&stat, statbuf); 108 return error; 109 } 110 111 asmlinkage long compat_sys_lstat64(const char __user * filename, 112 struct compat_stat64 __user *statbuf) 113 { 114 struct kstat stat; 115 int error = vfs_lstat(filename, &stat); 116 117 if (!error) 118 error = cp_compat_stat64(&stat, statbuf); 119 return error; 120 } 121 122 asmlinkage long compat_sys_fstat64(unsigned int fd, 123 struct compat_stat64 __user * statbuf) 124 { 125 struct kstat stat; 126 int error = vfs_fstat(fd, &stat); 127 128 if (!error) 129 error = cp_compat_stat64(&stat, statbuf); 130 return error; 131 } 132 133 asmlinkage long compat_sys_fstatat64(unsigned int dfd, 134 const char __user *filename, 135 struct compat_stat64 __user * statbuf, int flag) 136 { 137 struct kstat stat; 138 int error; 139 140 error = vfs_fstatat(dfd, filename, &stat, flag); 141 if (error) 142 return error; 143 return cp_compat_stat64(&stat, statbuf); 144 } 145 146 COMPAT_SYSCALL_DEFINE3(sparc_sigaction, int, sig, 147 struct compat_old_sigaction __user *,act, 148 struct compat_old_sigaction __user *,oact) 149 { 150 WARN_ON_ONCE(sig >= 0); 151 return compat_sys_sigaction(-sig, act, oact); 152 } 153 154 COMPAT_SYSCALL_DEFINE5(rt_sigaction, int, sig, 155 struct compat_sigaction __user *,act, 156 struct compat_sigaction __user *,oact, 157 void __user *,restorer, 158 compat_size_t,sigsetsize) 159 { 160 struct k_sigaction new_ka, old_ka; 161 int ret; 162 compat_sigset_t set32; 163 164 /* XXX: Don't preclude handling different sized sigset_t's. */ 165 if (sigsetsize != sizeof(compat_sigset_t)) 166 return -EINVAL; 167 168 if (act) { 169 u32 u_handler, u_restorer; 170 171 new_ka.ka_restorer = restorer; 172 ret = get_user(u_handler, &act->sa_handler); 173 new_ka.sa.sa_handler = compat_ptr(u_handler); 174 ret |= copy_from_user(&set32, &act->sa_mask, sizeof(compat_sigset_t)); 175 sigset_from_compat(&new_ka.sa.sa_mask, &set32); 176 ret |= get_user(new_ka.sa.sa_flags, &act->sa_flags); 177 ret |= get_user(u_restorer, &act->sa_restorer); 178 new_ka.sa.sa_restorer = compat_ptr(u_restorer); 179 if (ret) 180 return -EFAULT; 181 } 182 183 ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); 184 185 if (!ret && oact) { 186 sigset_to_compat(&set32, &old_ka.sa.sa_mask); 187 ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler); 188 ret |= copy_to_user(&oact->sa_mask, &set32, sizeof(compat_sigset_t)); 189 ret |= put_user(old_ka.sa.sa_flags, &oact->sa_flags); 190 ret |= put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer); 191 if (ret) 192 ret = -EFAULT; 193 } 194 195 return ret; 196 } 197 198 asmlinkage compat_ssize_t sys32_pread64(unsigned int fd, 199 char __user *ubuf, 200 compat_size_t count, 201 unsigned long poshi, 202 unsigned long poslo) 203 { 204 return sys_pread64(fd, ubuf, count, (poshi << 32) | poslo); 205 } 206 207 asmlinkage compat_ssize_t sys32_pwrite64(unsigned int fd, 208 char __user *ubuf, 209 compat_size_t count, 210 unsigned long poshi, 211 unsigned long poslo) 212 { 213 return sys_pwrite64(fd, ubuf, count, (poshi << 32) | poslo); 214 } 215 216 asmlinkage long compat_sys_readahead(int fd, 217 unsigned long offhi, 218 unsigned long offlo, 219 compat_size_t count) 220 { 221 return sys_readahead(fd, (offhi << 32) | offlo, count); 222 } 223 224 long compat_sys_fadvise64(int fd, 225 unsigned long offhi, 226 unsigned long offlo, 227 compat_size_t len, int advice) 228 { 229 return sys_fadvise64_64(fd, (offhi << 32) | offlo, len, advice); 230 } 231 232 long compat_sys_fadvise64_64(int fd, 233 unsigned long offhi, unsigned long offlo, 234 unsigned long lenhi, unsigned long lenlo, 235 int advice) 236 { 237 return sys_fadvise64_64(fd, 238 (offhi << 32) | offlo, 239 (lenhi << 32) | lenlo, 240 advice); 241 } 242 243 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) 244 { 245 return sys_sync_file_range(fd, 246 (off_high << 32) | off_low, 247 (nb_high << 32) | nb_low, 248 flags); 249 } 250 251 asmlinkage long compat_sys_fallocate(int fd, int mode, u32 offhi, u32 offlo, 252 u32 lenhi, u32 lenlo) 253 { 254 return sys_fallocate(fd, mode, ((loff_t)offhi << 32) | offlo, 255 ((loff_t)lenhi << 32) | lenlo); 256 } 257