| 1 | /* |
| 2 | * arch/s390x/kernel/linux32.c |
| 3 | * |
| 4 | * S390 version |
| 5 | * Copyright (C) 2000 IBM Deutschland Entwicklung GmbH, IBM Corporation |
| 6 | * Author(s): Martin Schwidefsky (schwidefsky@de.ibm.com), |
| 7 | * Gerhard Tonn (ton@de.ibm.com) |
| 8 | * Thomas Spatzier (tspat@de.ibm.com) |
| 9 | * |
| 10 | * Conversion between 31bit and 64bit native syscalls. |
| 11 | * |
| 12 | * Heavily inspired by the 32-bit Sparc compat code which is |
| 13 | * Copyright (C) 1997,1998 Jakub Jelinek (jj@sunsite.mff.cuni.cz) |
| 14 | * Copyright (C) 1997 David S. Miller (davem@caip.rutgers.edu) |
| 15 | * |
| 16 | */ |
| 17 | |
| 18 | |
| 19 | #include <linux/kernel.h> |
| 20 | #include <linux/sched.h> |
| 21 | #include <linux/fs.h> |
| 22 | #include <linux/mm.h> |
| 23 | #include <linux/file.h> |
| 24 | #include <linux/signal.h> |
| 25 | #include <linux/resource.h> |
| 26 | #include <linux/times.h> |
| 27 | #include <linux/smp.h> |
| 28 | #include <linux/smp_lock.h> |
| 29 | #include <linux/sem.h> |
| 30 | #include <linux/msg.h> |
| 31 | #include <linux/shm.h> |
| 32 | #include <linux/slab.h> |
| 33 | #include <linux/uio.h> |
| 34 | #include <linux/nfs_fs.h> |
| 35 | #include <linux/quota.h> |
| 36 | #include <linux/module.h> |
| 37 | #include <linux/sunrpc/svc.h> |
| 38 | #include <linux/nfsd/nfsd.h> |
| 39 | #include <linux/nfsd/cache.h> |
| 40 | #include <linux/nfsd/xdr.h> |
| 41 | #include <linux/nfsd/syscall.h> |
| 42 | #include <linux/poll.h> |
| 43 | #include <linux/personality.h> |
| 44 | #include <linux/stat.h> |
| 45 | #include <linux/filter.h> |
| 46 | #include <linux/highmem.h> |
| 47 | #include <linux/highuid.h> |
| 48 | #include <linux/mman.h> |
| 49 | #include <linux/ipv6.h> |
| 50 | #include <linux/in.h> |
| 51 | #include <linux/icmpv6.h> |
| 52 | #include <linux/syscalls.h> |
| 53 | #include <linux/sysctl.h> |
| 54 | #include <linux/binfmts.h> |
| 55 | #include <linux/capability.h> |
| 56 | #include <linux/compat.h> |
| 57 | #include <linux/vfs.h> |
| 58 | #include <linux/ptrace.h> |
| 59 | #include <linux/fadvise.h> |
| 60 | #include <linux/ipc.h> |
| 61 | |
| 62 | #include <asm/types.h> |
| 63 | #include <asm/uaccess.h> |
| 64 | |
| 65 | #include <net/scm.h> |
| 66 | #include <net/sock.h> |
| 67 | |
| 68 | #include "compat_linux.h" |
| 69 | |
| 70 | long psw_user32_bits = (PSW_BASE32_BITS | PSW_MASK_DAT | PSW_ASC_HOME | |
| 71 | PSW_MASK_IO | PSW_MASK_EXT | PSW_MASK_MCHECK | |
| 72 | PSW_MASK_PSTATE | PSW_DEFAULT_KEY); |
| 73 | long psw32_user_bits = (PSW32_BASE_BITS | PSW32_MASK_DAT | PSW32_ASC_HOME | |
| 74 | PSW32_MASK_IO | PSW32_MASK_EXT | PSW32_MASK_MCHECK | |
| 75 | PSW32_MASK_PSTATE); |
| 76 | |
| 77 | /* For this source file, we want overflow handling. */ |
| 78 | |
| 79 | #undef high2lowuid |
| 80 | #undef high2lowgid |
| 81 | #undef low2highuid |
| 82 | #undef low2highgid |
| 83 | #undef SET_UID16 |
| 84 | #undef SET_GID16 |
| 85 | #undef NEW_TO_OLD_UID |
| 86 | #undef NEW_TO_OLD_GID |
| 87 | #undef SET_OLDSTAT_UID |
| 88 | #undef SET_OLDSTAT_GID |
| 89 | #undef SET_STAT_UID |
| 90 | #undef SET_STAT_GID |
| 91 | |
| 92 | #define high2lowuid(uid) ((uid) > 65535) ? (u16)overflowuid : (u16)(uid) |
| 93 | #define high2lowgid(gid) ((gid) > 65535) ? (u16)overflowgid : (u16)(gid) |
| 94 | #define low2highuid(uid) ((uid) == (u16)-1) ? (uid_t)-1 : (uid_t)(uid) |
| 95 | #define low2highgid(gid) ((gid) == (u16)-1) ? (gid_t)-1 : (gid_t)(gid) |
| 96 | #define SET_UID16(var, uid) var = high2lowuid(uid) |
| 97 | #define SET_GID16(var, gid) var = high2lowgid(gid) |
| 98 | #define NEW_TO_OLD_UID(uid) high2lowuid(uid) |
| 99 | #define NEW_TO_OLD_GID(gid) high2lowgid(gid) |
| 100 | #define SET_OLDSTAT_UID(stat, uid) (stat).st_uid = high2lowuid(uid) |
| 101 | #define SET_OLDSTAT_GID(stat, gid) (stat).st_gid = high2lowgid(gid) |
| 102 | #define SET_STAT_UID(stat, uid) (stat).st_uid = high2lowuid(uid) |
| 103 | #define SET_STAT_GID(stat, gid) (stat).st_gid = high2lowgid(gid) |
| 104 | |
| 105 | asmlinkage long sys32_chown16(const char __user * filename, u16 user, u16 group) |
| 106 | { |
| 107 | return sys_chown(filename, low2highuid(user), low2highgid(group)); |
| 108 | } |
| 109 | |
| 110 | asmlinkage long sys32_lchown16(const char __user * filename, u16 user, u16 group) |
| 111 | { |
| 112 | return sys_lchown(filename, low2highuid(user), low2highgid(group)); |
| 113 | } |
| 114 | |
| 115 | asmlinkage long sys32_fchown16(unsigned int fd, u16 user, u16 group) |
| 116 | { |
| 117 | return sys_fchown(fd, low2highuid(user), low2highgid(group)); |
| 118 | } |
| 119 | |
| 120 | asmlinkage long sys32_setregid16(u16 rgid, u16 egid) |
| 121 | { |
| 122 | return sys_setregid(low2highgid(rgid), low2highgid(egid)); |
| 123 | } |
| 124 | |
| 125 | asmlinkage long sys32_setgid16(u16 gid) |
| 126 | { |
| 127 | return sys_setgid((gid_t)gid); |
| 128 | } |
| 129 | |
| 130 | asmlinkage long sys32_setreuid16(u16 ruid, u16 euid) |
| 131 | { |
| 132 | return sys_setreuid(low2highuid(ruid), low2highuid(euid)); |
| 133 | } |
| 134 | |
| 135 | asmlinkage long sys32_setuid16(u16 uid) |
| 136 | { |
| 137 | return sys_setuid((uid_t)uid); |
| 138 | } |
| 139 | |
| 140 | asmlinkage long sys32_setresuid16(u16 ruid, u16 euid, u16 suid) |
| 141 | { |
| 142 | return sys_setresuid(low2highuid(ruid), low2highuid(euid), |
| 143 | low2highuid(suid)); |
| 144 | } |
| 145 | |
| 146 | asmlinkage long sys32_getresuid16(u16 __user *ruid, u16 __user *euid, u16 __user *suid) |
| 147 | { |
| 148 | int retval; |
| 149 | |
| 150 | if (!(retval = put_user(high2lowuid(current->cred->uid), ruid)) && |
| 151 | !(retval = put_user(high2lowuid(current->cred->euid), euid))) |
| 152 | retval = put_user(high2lowuid(current->cred->suid), suid); |
| 153 | |
| 154 | return retval; |
| 155 | } |
| 156 | |
| 157 | asmlinkage long sys32_setresgid16(u16 rgid, u16 egid, u16 sgid) |
| 158 | { |
| 159 | return sys_setresgid(low2highgid(rgid), low2highgid(egid), |
| 160 | low2highgid(sgid)); |
| 161 | } |
| 162 | |
| 163 | asmlinkage long sys32_getresgid16(u16 __user *rgid, u16 __user *egid, u16 __user *sgid) |
| 164 | { |
| 165 | int retval; |
| 166 | |
| 167 | if (!(retval = put_user(high2lowgid(current->cred->gid), rgid)) && |
| 168 | !(retval = put_user(high2lowgid(current->cred->egid), egid))) |
| 169 | retval = put_user(high2lowgid(current->cred->sgid), sgid); |
| 170 | |
| 171 | return retval; |
| 172 | } |
| 173 | |
| 174 | asmlinkage long sys32_setfsuid16(u16 uid) |
| 175 | { |
| 176 | return sys_setfsuid((uid_t)uid); |
| 177 | } |
| 178 | |
| 179 | asmlinkage long sys32_setfsgid16(u16 gid) |
| 180 | { |
| 181 | return sys_setfsgid((gid_t)gid); |
| 182 | } |
| 183 | |
| 184 | static int groups16_to_user(u16 __user *grouplist, struct group_info *group_info) |
| 185 | { |
| 186 | int i; |
| 187 | u16 group; |
| 188 | |
| 189 | for (i = 0; i < group_info->ngroups; i++) { |
| 190 | group = (u16)GROUP_AT(group_info, i); |
| 191 | if (put_user(group, grouplist+i)) |
| 192 | return -EFAULT; |
| 193 | } |
| 194 | |
| 195 | return 0; |
| 196 | } |
| 197 | |
| 198 | static int groups16_from_user(struct group_info *group_info, u16 __user *grouplist) |
| 199 | { |
| 200 | int i; |
| 201 | u16 group; |
| 202 | |
| 203 | for (i = 0; i < group_info->ngroups; i++) { |
| 204 | if (get_user(group, grouplist+i)) |
| 205 | return -EFAULT; |
| 206 | GROUP_AT(group_info, i) = (gid_t)group; |
| 207 | } |
| 208 | |
| 209 | return 0; |
| 210 | } |
| 211 | |
| 212 | asmlinkage long sys32_getgroups16(int gidsetsize, u16 __user *grouplist) |
| 213 | { |
| 214 | int i; |
| 215 | |
| 216 | if (gidsetsize < 0) |
| 217 | return -EINVAL; |
| 218 | |
| 219 | get_group_info(current->cred->group_info); |
| 220 | i = current->cred->group_info->ngroups; |
| 221 | if (gidsetsize) { |
| 222 | if (i > gidsetsize) { |
| 223 | i = -EINVAL; |
| 224 | goto out; |
| 225 | } |
| 226 | if (groups16_to_user(grouplist, current->cred->group_info)) { |
| 227 | i = -EFAULT; |
| 228 | goto out; |
| 229 | } |
| 230 | } |
| 231 | out: |
| 232 | put_group_info(current->cred->group_info); |
| 233 | return i; |
| 234 | } |
| 235 | |
| 236 | asmlinkage long sys32_setgroups16(int gidsetsize, u16 __user *grouplist) |
| 237 | { |
| 238 | struct group_info *group_info; |
| 239 | int retval; |
| 240 | |
| 241 | if (!capable(CAP_SETGID)) |
| 242 | return -EPERM; |
| 243 | if ((unsigned)gidsetsize > NGROUPS_MAX) |
| 244 | return -EINVAL; |
| 245 | |
| 246 | group_info = groups_alloc(gidsetsize); |
| 247 | if (!group_info) |
| 248 | return -ENOMEM; |
| 249 | retval = groups16_from_user(group_info, grouplist); |
| 250 | if (retval) { |
| 251 | put_group_info(group_info); |
| 252 | return retval; |
| 253 | } |
| 254 | |
| 255 | retval = set_current_groups(group_info); |
| 256 | put_group_info(group_info); |
| 257 | |
| 258 | return retval; |
| 259 | } |
| 260 | |
| 261 | asmlinkage long sys32_getuid16(void) |
| 262 | { |
| 263 | return high2lowuid(current->cred->uid); |
| 264 | } |
| 265 | |
| 266 | asmlinkage long sys32_geteuid16(void) |
| 267 | { |
| 268 | return high2lowuid(current->cred->euid); |
| 269 | } |
| 270 | |
| 271 | asmlinkage long sys32_getgid16(void) |
| 272 | { |
| 273 | return high2lowgid(current->cred->gid); |
| 274 | } |
| 275 | |
| 276 | asmlinkage long sys32_getegid16(void) |
| 277 | { |
| 278 | return high2lowgid(current->cred->egid); |
| 279 | } |
| 280 | |
| 281 | /* |
| 282 | * sys32_ipc() is the de-multiplexer for the SysV IPC calls in 32bit emulation. |
| 283 | * |
| 284 | * This is really horribly ugly. |
| 285 | */ |
| 286 | #ifdef CONFIG_SYSVIPC |
| 287 | asmlinkage long sys32_ipc(u32 call, int first, int second, int third, u32 ptr) |
| 288 | { |
| 289 | if (call >> 16) /* hack for backward compatibility */ |
| 290 | return -EINVAL; |
| 291 | |
| 292 | call &= 0xffff; |
| 293 | |
| 294 | switch (call) { |
| 295 | case SEMTIMEDOP: |
| 296 | return compat_sys_semtimedop(first, compat_ptr(ptr), |
| 297 | second, compat_ptr(third)); |
| 298 | case SEMOP: |
| 299 | /* struct sembuf is the same on 32 and 64bit :)) */ |
| 300 | return sys_semtimedop(first, compat_ptr(ptr), |
| 301 | second, NULL); |
| 302 | case SEMGET: |
| 303 | return sys_semget(first, second, third); |
| 304 | case SEMCTL: |
| 305 | return compat_sys_semctl(first, second, third, |
| 306 | compat_ptr(ptr)); |
| 307 | case MSGSND: |
| 308 | return compat_sys_msgsnd(first, second, third, |
| 309 | compat_ptr(ptr)); |
| 310 | case MSGRCV: |
| 311 | return compat_sys_msgrcv(first, second, 0, third, |
| 312 | 0, compat_ptr(ptr)); |
| 313 | case MSGGET: |
| 314 | return sys_msgget((key_t) first, second); |
| 315 | case MSGCTL: |
| 316 | return compat_sys_msgctl(first, second, compat_ptr(ptr)); |
| 317 | case SHMAT: |
| 318 | return compat_sys_shmat(first, second, third, |
| 319 | 0, compat_ptr(ptr)); |
| 320 | case SHMDT: |
| 321 | return sys_shmdt(compat_ptr(ptr)); |
| 322 | case SHMGET: |
| 323 | return sys_shmget(first, (unsigned)second, third); |
| 324 | case SHMCTL: |
| 325 | return compat_sys_shmctl(first, second, compat_ptr(ptr)); |
| 326 | } |
| 327 | |
| 328 | return -ENOSYS; |
| 329 | } |
| 330 | #endif |
| 331 | |
| 332 | asmlinkage long sys32_truncate64(const char __user * path, unsigned long high, unsigned long low) |
| 333 | { |
| 334 | if ((int)high < 0) |
| 335 | return -EINVAL; |
| 336 | else |
| 337 | return sys_truncate(path, (high << 32) | low); |
| 338 | } |
| 339 | |
| 340 | asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long high, unsigned long low) |
| 341 | { |
| 342 | if ((int)high < 0) |
| 343 | return -EINVAL; |
| 344 | else |
| 345 | return sys_ftruncate(fd, (high << 32) | low); |
| 346 | } |
| 347 | |
| 348 | asmlinkage long sys32_sched_rr_get_interval(compat_pid_t pid, |
| 349 | struct compat_timespec __user *interval) |
| 350 | { |
| 351 | struct timespec t; |
| 352 | int ret; |
| 353 | mm_segment_t old_fs = get_fs (); |
| 354 | |
| 355 | set_fs (KERNEL_DS); |
| 356 | ret = sys_sched_rr_get_interval(pid, |
| 357 | (struct timespec __force __user *) &t); |
| 358 | set_fs (old_fs); |
| 359 | if (put_compat_timespec(&t, interval)) |
| 360 | return -EFAULT; |
| 361 | return ret; |
| 362 | } |
| 363 | |
| 364 | asmlinkage long sys32_rt_sigprocmask(int how, compat_sigset_t __user *set, |
| 365 | compat_sigset_t __user *oset, size_t sigsetsize) |
| 366 | { |
| 367 | sigset_t s; |
| 368 | compat_sigset_t s32; |
| 369 | int ret; |
| 370 | mm_segment_t old_fs = get_fs(); |
| 371 | |
| 372 | if (set) { |
| 373 | if (copy_from_user (&s32, set, sizeof(compat_sigset_t))) |
| 374 | return -EFAULT; |
| 375 | switch (_NSIG_WORDS) { |
| 376 | case 4: s.sig[3] = s32.sig[6] | (((long)s32.sig[7]) << 32); |
| 377 | case 3: s.sig[2] = s32.sig[4] | (((long)s32.sig[5]) << 32); |
| 378 | case 2: s.sig[1] = s32.sig[2] | (((long)s32.sig[3]) << 32); |
| 379 | case 1: s.sig[0] = s32.sig[0] | (((long)s32.sig[1]) << 32); |
| 380 | } |
| 381 | } |
| 382 | set_fs (KERNEL_DS); |
| 383 | ret = sys_rt_sigprocmask(how, |
| 384 | set ? (sigset_t __force __user *) &s : NULL, |
| 385 | oset ? (sigset_t __force __user *) &s : NULL, |
| 386 | sigsetsize); |
| 387 | set_fs (old_fs); |
| 388 | if (ret) return ret; |
| 389 | if (oset) { |
| 390 | switch (_NSIG_WORDS) { |
| 391 | case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3]; |
| 392 | case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2]; |
| 393 | case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1]; |
| 394 | case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0]; |
| 395 | } |
| 396 | if (copy_to_user (oset, &s32, sizeof(compat_sigset_t))) |
| 397 | return -EFAULT; |
| 398 | } |
| 399 | return 0; |
| 400 | } |
| 401 | |
| 402 | asmlinkage long sys32_rt_sigpending(compat_sigset_t __user *set, |
| 403 | size_t sigsetsize) |
| 404 | { |
| 405 | sigset_t s; |
| 406 | compat_sigset_t s32; |
| 407 | int ret; |
| 408 | mm_segment_t old_fs = get_fs(); |
| 409 | |
| 410 | set_fs (KERNEL_DS); |
| 411 | ret = sys_rt_sigpending((sigset_t __force __user *) &s, sigsetsize); |
| 412 | set_fs (old_fs); |
| 413 | if (!ret) { |
| 414 | switch (_NSIG_WORDS) { |
| 415 | case 4: s32.sig[7] = (s.sig[3] >> 32); s32.sig[6] = s.sig[3]; |
| 416 | case 3: s32.sig[5] = (s.sig[2] >> 32); s32.sig[4] = s.sig[2]; |
| 417 | case 2: s32.sig[3] = (s.sig[1] >> 32); s32.sig[2] = s.sig[1]; |
| 418 | case 1: s32.sig[1] = (s.sig[0] >> 32); s32.sig[0] = s.sig[0]; |
| 419 | } |
| 420 | if (copy_to_user (set, &s32, sizeof(compat_sigset_t))) |
| 421 | return -EFAULT; |
| 422 | } |
| 423 | return ret; |
| 424 | } |
| 425 | |
| 426 | asmlinkage long |
| 427 | sys32_rt_sigqueueinfo(int pid, int sig, compat_siginfo_t __user *uinfo) |
| 428 | { |
| 429 | siginfo_t info; |
| 430 | int ret; |
| 431 | mm_segment_t old_fs = get_fs(); |
| 432 | |
| 433 | if (copy_siginfo_from_user32(&info, uinfo)) |
| 434 | return -EFAULT; |
| 435 | set_fs (KERNEL_DS); |
| 436 | ret = sys_rt_sigqueueinfo(pid, sig, (siginfo_t __force __user *) &info); |
| 437 | set_fs (old_fs); |
| 438 | return ret; |
| 439 | } |
| 440 | |
| 441 | /* |
| 442 | * sys32_execve() executes a new program after the asm stub has set |
| 443 | * things up for us. This should basically do what I want it to. |
| 444 | */ |
| 445 | asmlinkage long sys32_execve(char __user *name, compat_uptr_t __user *argv, |
| 446 | compat_uptr_t __user *envp) |
| 447 | { |
| 448 | struct pt_regs *regs = task_pt_regs(current); |
| 449 | char *filename; |
| 450 | long rc; |
| 451 | |
| 452 | filename = getname(name); |
| 453 | rc = PTR_ERR(filename); |
| 454 | if (IS_ERR(filename)) |
| 455 | return rc; |
| 456 | rc = compat_do_execve(filename, argv, envp, regs); |
| 457 | if (rc) |
| 458 | goto out; |
| 459 | current->thread.fp_regs.fpc=0; |
| 460 | asm volatile("sfpc %0,0" : : "d" (0)); |
| 461 | rc = regs->gprs[2]; |
| 462 | out: |
| 463 | putname(filename); |
| 464 | return rc; |
| 465 | } |
| 466 | |
| 467 | asmlinkage long sys32_pread64(unsigned int fd, char __user *ubuf, |
| 468 | size_t count, u32 poshi, u32 poslo) |
| 469 | { |
| 470 | if ((compat_ssize_t) count < 0) |
| 471 | return -EINVAL; |
| 472 | return sys_pread64(fd, ubuf, count, ((loff_t)AA(poshi) << 32) | AA(poslo)); |
| 473 | } |
| 474 | |
| 475 | asmlinkage long sys32_pwrite64(unsigned int fd, const char __user *ubuf, |
| 476 | size_t count, u32 poshi, u32 poslo) |
| 477 | { |
| 478 | if ((compat_ssize_t) count < 0) |
| 479 | return -EINVAL; |
| 480 | return sys_pwrite64(fd, ubuf, count, ((loff_t)AA(poshi) << 32) | AA(poslo)); |
| 481 | } |
| 482 | |
| 483 | asmlinkage compat_ssize_t sys32_readahead(int fd, u32 offhi, u32 offlo, s32 count) |
| 484 | { |
| 485 | return sys_readahead(fd, ((loff_t)AA(offhi) << 32) | AA(offlo), count); |
| 486 | } |
| 487 | |
| 488 | asmlinkage long sys32_sendfile(int out_fd, int in_fd, compat_off_t __user *offset, size_t count) |
| 489 | { |
| 490 | mm_segment_t old_fs = get_fs(); |
| 491 | int ret; |
| 492 | off_t of; |
| 493 | |
| 494 | if (offset && get_user(of, offset)) |
| 495 | return -EFAULT; |
| 496 | |
| 497 | set_fs(KERNEL_DS); |
| 498 | ret = sys_sendfile(out_fd, in_fd, |
| 499 | offset ? (off_t __force __user *) &of : NULL, count); |
| 500 | set_fs(old_fs); |
| 501 | |
| 502 | if (offset && put_user(of, offset)) |
| 503 | return -EFAULT; |
| 504 | |
| 505 | return ret; |
| 506 | } |
| 507 | |
| 508 | asmlinkage long sys32_sendfile64(int out_fd, int in_fd, |
| 509 | compat_loff_t __user *offset, s32 count) |
| 510 | { |
| 511 | mm_segment_t old_fs = get_fs(); |
| 512 | int ret; |
| 513 | loff_t lof; |
| 514 | |
| 515 | if (offset && get_user(lof, offset)) |
| 516 | return -EFAULT; |
| 517 | |
| 518 | set_fs(KERNEL_DS); |
| 519 | ret = sys_sendfile64(out_fd, in_fd, |
| 520 | offset ? (loff_t __force __user *) &lof : NULL, |
| 521 | count); |
| 522 | set_fs(old_fs); |
| 523 | |
| 524 | if (offset && put_user(lof, offset)) |
| 525 | return -EFAULT; |
| 526 | |
| 527 | return ret; |
| 528 | } |
| 529 | |
| 530 | #ifdef CONFIG_SYSCTL_SYSCALL |
| 531 | struct __sysctl_args32 { |
| 532 | u32 name; |
| 533 | int nlen; |
| 534 | u32 oldval; |
| 535 | u32 oldlenp; |
| 536 | u32 newval; |
| 537 | u32 newlen; |
| 538 | u32 __unused[4]; |
| 539 | }; |
| 540 | |
| 541 | asmlinkage long sys32_sysctl(struct __sysctl_args32 __user *args) |
| 542 | { |
| 543 | struct __sysctl_args32 tmp; |
| 544 | int error; |
| 545 | size_t oldlen; |
| 546 | size_t __user *oldlenp = NULL; |
| 547 | unsigned long addr = (((unsigned long)&args->__unused[0]) + 7) & ~7; |
| 548 | |
| 549 | if (copy_from_user(&tmp, args, sizeof(tmp))) |
| 550 | return -EFAULT; |
| 551 | |
| 552 | if (tmp.oldval && tmp.oldlenp) { |
| 553 | /* Duh, this is ugly and might not work if sysctl_args |
| 554 | is in read-only memory, but do_sysctl does indirectly |
| 555 | a lot of uaccess in both directions and we'd have to |
| 556 | basically copy the whole sysctl.c here, and |
| 557 | glibc's __sysctl uses rw memory for the structure |
| 558 | anyway. */ |
| 559 | if (get_user(oldlen, (u32 __user *)compat_ptr(tmp.oldlenp)) || |
| 560 | put_user(oldlen, (size_t __user *)addr)) |
| 561 | return -EFAULT; |
| 562 | oldlenp = (size_t __user *)addr; |
| 563 | } |
| 564 | |
| 565 | lock_kernel(); |
| 566 | error = do_sysctl(compat_ptr(tmp.name), tmp.nlen, compat_ptr(tmp.oldval), |
| 567 | oldlenp, compat_ptr(tmp.newval), tmp.newlen); |
| 568 | unlock_kernel(); |
| 569 | if (oldlenp) { |
| 570 | if (!error) { |
| 571 | if (get_user(oldlen, (size_t __user *)addr) || |
| 572 | put_user(oldlen, (u32 __user *)compat_ptr(tmp.oldlenp))) |
| 573 | error = -EFAULT; |
| 574 | } |
| 575 | if (copy_to_user(args->__unused, tmp.__unused, |
| 576 | sizeof(tmp.__unused))) |
| 577 | error = -EFAULT; |
| 578 | } |
| 579 | return error; |
| 580 | } |
| 581 | #endif |
| 582 | |
| 583 | struct stat64_emu31 { |
| 584 | unsigned long long st_dev; |
| 585 | unsigned int __pad1; |
| 586 | #define STAT64_HAS_BROKEN_ST_INO 1 |
| 587 | u32 __st_ino; |
| 588 | unsigned int st_mode; |
| 589 | unsigned int st_nlink; |
| 590 | u32 st_uid; |
| 591 | u32 st_gid; |
| 592 | unsigned long long st_rdev; |
| 593 | unsigned int __pad3; |
| 594 | long st_size; |
| 595 | u32 st_blksize; |
| 596 | unsigned char __pad4[4]; |
| 597 | u32 __pad5; /* future possible st_blocks high bits */ |
| 598 | u32 st_blocks; /* Number 512-byte blocks allocated. */ |
| 599 | u32 st_atime; |
| 600 | u32 __pad6; |
| 601 | u32 st_mtime; |
| 602 | u32 __pad7; |
| 603 | u32 st_ctime; |
| 604 | u32 __pad8; /* will be high 32 bits of ctime someday */ |
| 605 | unsigned long st_ino; |
| 606 | }; |
| 607 | |
| 608 | static int cp_stat64(struct stat64_emu31 __user *ubuf, struct kstat *stat) |
| 609 | { |
| 610 | struct stat64_emu31 tmp; |
| 611 | |
| 612 | memset(&tmp, 0, sizeof(tmp)); |
| 613 | |
| 614 | tmp.st_dev = huge_encode_dev(stat->dev); |
| 615 | tmp.st_ino = stat->ino; |
| 616 | tmp.__st_ino = (u32)stat->ino; |
| 617 | tmp.st_mode = stat->mode; |
| 618 | tmp.st_nlink = (unsigned int)stat->nlink; |
| 619 | tmp.st_uid = stat->uid; |
| 620 | tmp.st_gid = stat->gid; |
| 621 | tmp.st_rdev = huge_encode_dev(stat->rdev); |
| 622 | tmp.st_size = stat->size; |
| 623 | tmp.st_blksize = (u32)stat->blksize; |
| 624 | tmp.st_blocks = (u32)stat->blocks; |
| 625 | tmp.st_atime = (u32)stat->atime.tv_sec; |
| 626 | tmp.st_mtime = (u32)stat->mtime.tv_sec; |
| 627 | tmp.st_ctime = (u32)stat->ctime.tv_sec; |
| 628 | |
| 629 | return copy_to_user(ubuf,&tmp,sizeof(tmp)) ? -EFAULT : 0; |
| 630 | } |
| 631 | |
| 632 | asmlinkage long sys32_stat64(char __user * filename, struct stat64_emu31 __user * statbuf) |
| 633 | { |
| 634 | struct kstat stat; |
| 635 | int ret = vfs_stat(filename, &stat); |
| 636 | if (!ret) |
| 637 | ret = cp_stat64(statbuf, &stat); |
| 638 | return ret; |
| 639 | } |
| 640 | |
| 641 | asmlinkage long sys32_lstat64(char __user * filename, struct stat64_emu31 __user * statbuf) |
| 642 | { |
| 643 | struct kstat stat; |
| 644 | int ret = vfs_lstat(filename, &stat); |
| 645 | if (!ret) |
| 646 | ret = cp_stat64(statbuf, &stat); |
| 647 | return ret; |
| 648 | } |
| 649 | |
| 650 | asmlinkage long sys32_fstat64(unsigned long fd, struct stat64_emu31 __user * statbuf) |
| 651 | { |
| 652 | struct kstat stat; |
| 653 | int ret = vfs_fstat(fd, &stat); |
| 654 | if (!ret) |
| 655 | ret = cp_stat64(statbuf, &stat); |
| 656 | return ret; |
| 657 | } |
| 658 | |
| 659 | asmlinkage long sys32_fstatat64(unsigned int dfd, char __user *filename, |
| 660 | struct stat64_emu31 __user* statbuf, int flag) |
| 661 | { |
| 662 | struct kstat stat; |
| 663 | int error; |
| 664 | |
| 665 | error = vfs_fstatat(dfd, filename, &stat, flag); |
| 666 | if (error) |
| 667 | return error; |
| 668 | return cp_stat64(statbuf, &stat); |
| 669 | } |
| 670 | |
| 671 | /* |
| 672 | * Linux/i386 didn't use to be able to handle more than |
| 673 | * 4 system call parameters, so these system calls used a memory |
| 674 | * block for parameter passing.. |
| 675 | */ |
| 676 | |
| 677 | struct mmap_arg_struct_emu31 { |
| 678 | u32 addr; |
| 679 | u32 len; |
| 680 | u32 prot; |
| 681 | u32 flags; |
| 682 | u32 fd; |
| 683 | u32 offset; |
| 684 | }; |
| 685 | |
| 686 | /* common code for old and new mmaps */ |
| 687 | static inline long do_mmap2( |
| 688 | unsigned long addr, unsigned long len, |
| 689 | unsigned long prot, unsigned long flags, |
| 690 | unsigned long fd, unsigned long pgoff) |
| 691 | { |
| 692 | struct file * file = NULL; |
| 693 | unsigned long error = -EBADF; |
| 694 | |
| 695 | flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE); |
| 696 | if (!(flags & MAP_ANONYMOUS)) { |
| 697 | file = fget(fd); |
| 698 | if (!file) |
| 699 | goto out; |
| 700 | } |
| 701 | |
| 702 | down_write(¤t->mm->mmap_sem); |
| 703 | error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff); |
| 704 | if (!IS_ERR((void *) error) && error + len >= 0x80000000ULL) { |
| 705 | /* Result is out of bounds. */ |
| 706 | do_munmap(current->mm, addr, len); |
| 707 | error = -ENOMEM; |
| 708 | } |
| 709 | up_write(¤t->mm->mmap_sem); |
| 710 | |
| 711 | if (file) |
| 712 | fput(file); |
| 713 | out: |
| 714 | return error; |
| 715 | } |
| 716 | |
| 717 | |
| 718 | asmlinkage unsigned long |
| 719 | old32_mmap(struct mmap_arg_struct_emu31 __user *arg) |
| 720 | { |
| 721 | struct mmap_arg_struct_emu31 a; |
| 722 | int error = -EFAULT; |
| 723 | |
| 724 | if (copy_from_user(&a, arg, sizeof(a))) |
| 725 | goto out; |
| 726 | |
| 727 | error = -EINVAL; |
| 728 | if (a.offset & ~PAGE_MASK) |
| 729 | goto out; |
| 730 | |
| 731 | error = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset >> PAGE_SHIFT); |
| 732 | out: |
| 733 | return error; |
| 734 | } |
| 735 | |
| 736 | asmlinkage long |
| 737 | sys32_mmap2(struct mmap_arg_struct_emu31 __user *arg) |
| 738 | { |
| 739 | struct mmap_arg_struct_emu31 a; |
| 740 | int error = -EFAULT; |
| 741 | |
| 742 | if (copy_from_user(&a, arg, sizeof(a))) |
| 743 | goto out; |
| 744 | error = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset); |
| 745 | out: |
| 746 | return error; |
| 747 | } |
| 748 | |
| 749 | asmlinkage long sys32_read(unsigned int fd, char __user * buf, size_t count) |
| 750 | { |
| 751 | if ((compat_ssize_t) count < 0) |
| 752 | return -EINVAL; |
| 753 | |
| 754 | return sys_read(fd, buf, count); |
| 755 | } |
| 756 | |
| 757 | asmlinkage long sys32_write(unsigned int fd, char __user * buf, size_t count) |
| 758 | { |
| 759 | if ((compat_ssize_t) count < 0) |
| 760 | return -EINVAL; |
| 761 | |
| 762 | return sys_write(fd, buf, count); |
| 763 | } |
| 764 | |
| 765 | /* |
| 766 | * 31 bit emulation wrapper functions for sys_fadvise64/fadvise64_64. |
| 767 | * These need to rewrite the advise values for POSIX_FADV_{DONTNEED,NOREUSE} |
| 768 | * because the 31 bit values differ from the 64 bit values. |
| 769 | */ |
| 770 | |
| 771 | asmlinkage long |
| 772 | sys32_fadvise64(int fd, loff_t offset, size_t len, int advise) |
| 773 | { |
| 774 | if (advise == 4) |
| 775 | advise = POSIX_FADV_DONTNEED; |
| 776 | else if (advise == 5) |
| 777 | advise = POSIX_FADV_NOREUSE; |
| 778 | return sys_fadvise64(fd, offset, len, advise); |
| 779 | } |
| 780 | |
| 781 | struct fadvise64_64_args { |
| 782 | int fd; |
| 783 | long long offset; |
| 784 | long long len; |
| 785 | int advice; |
| 786 | }; |
| 787 | |
| 788 | asmlinkage long |
| 789 | sys32_fadvise64_64(struct fadvise64_64_args __user *args) |
| 790 | { |
| 791 | struct fadvise64_64_args a; |
| 792 | |
| 793 | if ( copy_from_user(&a, args, sizeof(a)) ) |
| 794 | return -EFAULT; |
| 795 | if (a.advice == 4) |
| 796 | a.advice = POSIX_FADV_DONTNEED; |
| 797 | else if (a.advice == 5) |
| 798 | a.advice = POSIX_FADV_NOREUSE; |
| 799 | return sys_fadvise64_64(a.fd, a.offset, a.len, a.advice); |
| 800 | } |