1 /* 2 * Conversion between 32-bit and 64-bit native system calls. 3 * 4 * Copyright (C) 2000 Silicon Graphics, Inc. 5 * Written by Ulf Carlsson (ulfc@engr.sgi.com) 6 * sys32_execve from ia64/ia32 code, Feb 2000, Kanoj Sarcar (kanoj@sgi.com) 7 */ 8 #include <linux/compiler.h> 9 #include <linux/mm.h> 10 #include <linux/errno.h> 11 #include <linux/file.h> 12 #include <linux/smp_lock.h> 13 #include <linux/highuid.h> 14 #include <linux/dirent.h> 15 #include <linux/resource.h> 16 #include <linux/highmem.h> 17 #include <linux/time.h> 18 #include <linux/times.h> 19 #include <linux/poll.h> 20 #include <linux/slab.h> 21 #include <linux/skbuff.h> 22 #include <linux/filter.h> 23 #include <linux/shm.h> 24 #include <linux/sem.h> 25 #include <linux/msg.h> 26 #include <linux/icmpv6.h> 27 #include <linux/syscalls.h> 28 #include <linux/sysctl.h> 29 #include <linux/utime.h> 30 #include <linux/utsname.h> 31 #include <linux/personality.h> 32 #include <linux/dnotify.h> 33 #include <linux/module.h> 34 #include <linux/binfmts.h> 35 #include <linux/security.h> 36 #include <linux/compat.h> 37 #include <linux/vfs.h> 38 #include <linux/ipc.h> 39 40 #include <net/sock.h> 41 #include <net/scm.h> 42 43 #include <asm/compat-signal.h> 44 #include <asm/sim.h> 45 #include <asm/uaccess.h> 46 #include <asm/mmu_context.h> 47 #include <asm/mman.h> 48 49 /* Use this to get at 32-bit user passed pointers. */ 50 /* A() macro should be used for places where you e.g. 51 have some internal variable u32 and just want to get 52 rid of a compiler warning. AA() has to be used in 53 places where you want to convert a function argument 54 to 32bit pointer or when you e.g. access pt_regs 55 structure and want to consider 32bit registers only. 56 */ 57 #define A(__x) ((unsigned long)(__x)) 58 #define AA(__x) ((unsigned long)((int)__x)) 59 60 #ifdef __MIPSEB__ 61 #define merge_64(r1, r2) ((((r1) & 0xffffffffUL) << 32) + ((r2) & 0xffffffffUL)) 62 #endif 63 #ifdef __MIPSEL__ 64 #define merge_64(r1, r2) ((((r2) & 0xffffffffUL) << 32) + ((r1) & 0xffffffffUL)) 65 #endif 66 67 /* 68 * Revalidate the inode. This is required for proper NFS attribute caching. 69 */ 70 71 int cp_compat_stat(struct kstat *stat, struct compat_stat __user *statbuf) 72 { 73 struct compat_stat tmp; 74 75 if (!new_valid_dev(stat->dev) || !new_valid_dev(stat->rdev)) 76 return -EOVERFLOW; 77 78 memset(&tmp, 0, sizeof(tmp)); 79 tmp.st_dev = new_encode_dev(stat->dev); 80 tmp.st_ino = stat->ino; 81 if (sizeof(tmp.st_ino) < sizeof(stat->ino) && tmp.st_ino != stat->ino) 82 return -EOVERFLOW; 83 tmp.st_mode = stat->mode; 84 tmp.st_nlink = stat->nlink; 85 SET_UID(tmp.st_uid, stat->uid); 86 SET_GID(tmp.st_gid, stat->gid); 87 tmp.st_rdev = new_encode_dev(stat->rdev); 88 tmp.st_size = stat->size; 89 tmp.st_atime = stat->atime.tv_sec; 90 tmp.st_mtime = stat->mtime.tv_sec; 91 tmp.st_ctime = stat->ctime.tv_sec; 92 #ifdef STAT_HAVE_NSEC 93 tmp.st_atime_nsec = stat->atime.tv_nsec; 94 tmp.st_mtime_nsec = stat->mtime.tv_nsec; 95 tmp.st_ctime_nsec = stat->ctime.tv_nsec; 96 #endif 97 tmp.st_blocks = stat->blocks; 98 tmp.st_blksize = stat->blksize; 99 return copy_to_user(statbuf, &tmp, sizeof(tmp)) ? -EFAULT : 0; 100 } 101 102 asmlinkage unsigned long 103 sys32_mmap2(unsigned long addr, unsigned long len, unsigned long prot, 104 unsigned long flags, unsigned long fd, unsigned long pgoff) 105 { 106 struct file * file = NULL; 107 unsigned long error; 108 109 error = -EINVAL; 110 if (pgoff & (~PAGE_MASK >> 12)) 111 goto out; 112 pgoff >>= PAGE_SHIFT-12; 113 114 if (!(flags & MAP_ANONYMOUS)) { 115 error = -EBADF; 116 file = fget(fd); 117 if (!file) 118 goto out; 119 } 120 flags &= ~(MAP_EXECUTABLE | MAP_DENYWRITE); 121 122 down_write(¤t->mm->mmap_sem); 123 error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff); 124 up_write(¤t->mm->mmap_sem); 125 if (file) 126 fput(file); 127 128 out: 129 return error; 130 } 131 132 133 asmlinkage int sys_truncate64(const char __user *path, unsigned int high, 134 unsigned int low) 135 { 136 if ((int)high < 0) 137 return -EINVAL; 138 return sys_truncate(path, ((long) high << 32) | low); 139 } 140 141 asmlinkage int sys_ftruncate64(unsigned int fd, unsigned int high, 142 unsigned int low) 143 { 144 if ((int)high < 0) 145 return -EINVAL; 146 return sys_ftruncate(fd, ((long) high << 32) | low); 147 } 148 149 /* 150 * sys_execve() executes a new program. 151 */ 152 asmlinkage int sys32_execve(nabi_no_regargs struct pt_regs regs) 153 { 154 int error; 155 char * filename; 156 157 filename = getname(compat_ptr(regs.regs[4])); 158 error = PTR_ERR(filename); 159 if (IS_ERR(filename)) 160 goto out; 161 error = compat_do_execve(filename, compat_ptr(regs.regs[5]), 162 compat_ptr(regs.regs[6]), ®s); 163 putname(filename); 164 165 out: 166 return error; 167 } 168 169 #define RLIM_INFINITY32 0x7fffffff 170 #define RESOURCE32(x) ((x > RLIM_INFINITY32) ? RLIM_INFINITY32 : x) 171 172 struct rlimit32 { 173 int rlim_cur; 174 int rlim_max; 175 }; 176 177 asmlinkage long sys32_truncate64(const char __user * path, 178 unsigned long __dummy, int a2, int a3) 179 { 180 return sys_truncate(path, merge_64(a2, a3)); 181 } 182 183 asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned long __dummy, 184 int a2, int a3) 185 { 186 return sys_ftruncate(fd, merge_64(a2, a3)); 187 } 188 189 static inline long 190 get_tv32(struct timeval *o, struct compat_timeval __user *i) 191 { 192 return (!access_ok(VERIFY_READ, i, sizeof(*i)) || 193 (__get_user(o->tv_sec, &i->tv_sec) | 194 __get_user(o->tv_usec, &i->tv_usec))); 195 } 196 197 static inline long 198 put_tv32(struct compat_timeval __user *o, struct timeval *i) 199 { 200 return (!access_ok(VERIFY_WRITE, o, sizeof(*o)) || 201 (__put_user(i->tv_sec, &o->tv_sec) | 202 __put_user(i->tv_usec, &o->tv_usec))); 203 } 204 205 extern struct timezone sys_tz; 206 207 asmlinkage int 208 sys32_gettimeofday(struct compat_timeval __user *tv, struct timezone __user *tz) 209 { 210 if (tv) { 211 struct timeval ktv; 212 do_gettimeofday(&ktv); 213 if (put_tv32(tv, &ktv)) 214 return -EFAULT; 215 } 216 if (tz) { 217 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz))) 218 return -EFAULT; 219 } 220 return 0; 221 } 222 223 static inline long get_ts32(struct timespec *o, struct compat_timeval __user *i) 224 { 225 long usec; 226 227 if (!access_ok(VERIFY_READ, i, sizeof(*i))) 228 return -EFAULT; 229 if (__get_user(o->tv_sec, &i->tv_sec)) 230 return -EFAULT; 231 if (__get_user(usec, &i->tv_usec)) 232 return -EFAULT; 233 o->tv_nsec = usec * 1000; 234 return 0; 235 } 236 237 asmlinkage int 238 sys32_settimeofday(struct compat_timeval __user *tv, struct timezone __user *tz) 239 { 240 struct timespec kts; 241 struct timezone ktz; 242 243 if (tv) { 244 if (get_ts32(&kts, tv)) 245 return -EFAULT; 246 } 247 if (tz) { 248 if (copy_from_user(&ktz, tz, sizeof(ktz))) 249 return -EFAULT; 250 } 251 252 return do_sys_settimeofday(tv ? &kts : NULL, tz ? &ktz : NULL); 253 } 254 255 asmlinkage int sys32_llseek(unsigned int fd, unsigned int offset_high, 256 unsigned int offset_low, loff_t __user * result, 257 unsigned int origin) 258 { 259 return sys_llseek(fd, offset_high, offset_low, result, origin); 260 } 261 262 /* From the Single Unix Spec: pread & pwrite act like lseek to pos + op + 263 lseek back to original location. They fail just like lseek does on 264 non-seekable files. */ 265 266 asmlinkage ssize_t sys32_pread(unsigned int fd, char __user * buf, 267 size_t count, u32 unused, u64 a4, u64 a5) 268 { 269 return sys_pread64(fd, buf, count, merge_64(a4, a5)); 270 } 271 272 asmlinkage ssize_t sys32_pwrite(unsigned int fd, const char __user * buf, 273 size_t count, u32 unused, u64 a4, u64 a5) 274 { 275 return sys_pwrite64(fd, buf, count, merge_64(a4, a5)); 276 } 277 278 asmlinkage int sys32_sched_rr_get_interval(compat_pid_t pid, 279 struct compat_timespec __user *interval) 280 { 281 struct timespec t; 282 int ret; 283 mm_segment_t old_fs = get_fs(); 284 285 set_fs(KERNEL_DS); 286 ret = sys_sched_rr_get_interval(pid, (struct timespec __user *)&t); 287 set_fs(old_fs); 288 if (put_user (t.tv_sec, &interval->tv_sec) || 289 __put_user(t.tv_nsec, &interval->tv_nsec)) 290 return -EFAULT; 291 return ret; 292 } 293 294 #ifdef CONFIG_SYSVIPC 295 296 asmlinkage long 297 sys32_ipc(u32 call, int first, int second, int third, u32 ptr, u32 fifth) 298 { 299 int version, err; 300 301 version = call >> 16; /* hack for backward compatibility */ 302 call &= 0xffff; 303 304 switch (call) { 305 case SEMOP: 306 /* struct sembuf is the same on 32 and 64bit :)) */ 307 err = sys_semtimedop(first, compat_ptr(ptr), second, NULL); 308 break; 309 case SEMTIMEDOP: 310 err = compat_sys_semtimedop(first, compat_ptr(ptr), second, 311 compat_ptr(fifth)); 312 break; 313 case SEMGET: 314 err = sys_semget(first, second, third); 315 break; 316 case SEMCTL: 317 err = compat_sys_semctl(first, second, third, compat_ptr(ptr)); 318 break; 319 case MSGSND: 320 err = compat_sys_msgsnd(first, second, third, compat_ptr(ptr)); 321 break; 322 case MSGRCV: 323 err = compat_sys_msgrcv(first, second, fifth, third, 324 version, compat_ptr(ptr)); 325 break; 326 case MSGGET: 327 err = sys_msgget((key_t) first, second); 328 break; 329 case MSGCTL: 330 err = compat_sys_msgctl(first, second, compat_ptr(ptr)); 331 break; 332 case SHMAT: 333 err = compat_sys_shmat(first, second, third, version, 334 compat_ptr(ptr)); 335 break; 336 case SHMDT: 337 err = sys_shmdt(compat_ptr(ptr)); 338 break; 339 case SHMGET: 340 err = sys_shmget(first, (unsigned)second, third); 341 break; 342 case SHMCTL: 343 err = compat_sys_shmctl(first, second, compat_ptr(ptr)); 344 break; 345 default: 346 err = -EINVAL; 347 break; 348 } 349 350 return err; 351 } 352 353 #else 354 355 asmlinkage long 356 sys32_ipc(u32 call, int first, int second, int third, u32 ptr, u32 fifth) 357 { 358 return -ENOSYS; 359 } 360 361 #endif /* CONFIG_SYSVIPC */ 362 363 #ifdef CONFIG_MIPS32_N32 364 asmlinkage long sysn32_semctl(int semid, int semnum, int cmd, u32 arg) 365 { 366 /* compat_sys_semctl expects a pointer to union semun */ 367 u32 __user *uptr = compat_alloc_user_space(sizeof(u32)); 368 if (put_user(arg, uptr)) 369 return -EFAULT; 370 return compat_sys_semctl(semid, semnum, cmd, uptr); 371 } 372 373 asmlinkage long sysn32_msgsnd(int msqid, u32 msgp, unsigned msgsz, int msgflg) 374 { 375 return compat_sys_msgsnd(msqid, msgsz, msgflg, compat_ptr(msgp)); 376 } 377 378 asmlinkage long sysn32_msgrcv(int msqid, u32 msgp, size_t msgsz, int msgtyp, 379 int msgflg) 380 { 381 return compat_sys_msgrcv(msqid, msgsz, msgtyp, msgflg, IPC_64, 382 compat_ptr(msgp)); 383 } 384 #endif 385 386 struct sysctl_args32 387 { 388 compat_caddr_t name; 389 int nlen; 390 compat_caddr_t oldval; 391 compat_caddr_t oldlenp; 392 compat_caddr_t newval; 393 compat_size_t newlen; 394 unsigned int __unused[4]; 395 }; 396 397 #ifdef CONFIG_SYSCTL_SYSCALL 398 399 asmlinkage long sys32_sysctl(struct sysctl_args32 __user *args) 400 { 401 struct sysctl_args32 tmp; 402 int error; 403 size_t oldlen; 404 size_t __user *oldlenp = NULL; 405 unsigned long addr = (((unsigned long)&args->__unused[0]) + 7) & ~7; 406 407 if (copy_from_user(&tmp, args, sizeof(tmp))) 408 return -EFAULT; 409 410 if (tmp.oldval && tmp.oldlenp) { 411 /* Duh, this is ugly and might not work if sysctl_args 412 is in read-only memory, but do_sysctl does indirectly 413 a lot of uaccess in both directions and we'd have to 414 basically copy the whole sysctl.c here, and 415 glibc's __sysctl uses rw memory for the structure 416 anyway. */ 417 if (get_user(oldlen, (u32 __user *)A(tmp.oldlenp)) || 418 put_user(oldlen, (size_t __user *)addr)) 419 return -EFAULT; 420 oldlenp = (size_t __user *)addr; 421 } 422 423 lock_kernel(); 424 error = do_sysctl((int __user *)A(tmp.name), tmp.nlen, (void __user *)A(tmp.oldval), 425 oldlenp, (void __user *)A(tmp.newval), tmp.newlen); 426 unlock_kernel(); 427 if (oldlenp) { 428 if (!error) { 429 if (get_user(oldlen, (size_t __user *)addr) || 430 put_user(oldlen, (u32 __user *)A(tmp.oldlenp))) 431 error = -EFAULT; 432 } 433 copy_to_user(args->__unused, tmp.__unused, sizeof(tmp.__unused)); 434 } 435 return error; 436 } 437 438 #endif /* CONFIG_SYSCTL_SYSCALL */ 439 440 asmlinkage long sys32_newuname(struct new_utsname __user * name) 441 { 442 int ret = 0; 443 444 down_read(&uts_sem); 445 if (copy_to_user(name, utsname(), sizeof *name)) 446 ret = -EFAULT; 447 up_read(&uts_sem); 448 449 if (current->personality == PER_LINUX32 && !ret) 450 if (copy_to_user(name->machine, "mips\0\0\0", 8)) 451 ret = -EFAULT; 452 453 return ret; 454 } 455 456 asmlinkage int sys32_personality(unsigned long personality) 457 { 458 int ret; 459 personality &= 0xffffffff; 460 if (personality(current->personality) == PER_LINUX32 && 461 personality == PER_LINUX) 462 personality = PER_LINUX32; 463 ret = sys_personality(personality); 464 if (ret == PER_LINUX32) 465 ret = PER_LINUX; 466 return ret; 467 } 468 469 /* ustat compatibility */ 470 struct ustat32 { 471 compat_daddr_t f_tfree; 472 compat_ino_t f_tinode; 473 char f_fname[6]; 474 char f_fpack[6]; 475 }; 476 477 extern asmlinkage long sys_ustat(dev_t dev, struct ustat __user * ubuf); 478 479 asmlinkage int sys32_ustat(dev_t dev, struct ustat32 __user * ubuf32) 480 { 481 int err; 482 struct ustat tmp; 483 struct ustat32 tmp32; 484 mm_segment_t old_fs = get_fs(); 485 486 set_fs(KERNEL_DS); 487 err = sys_ustat(dev, (struct ustat __user *)&tmp); 488 set_fs(old_fs); 489 490 if (err) 491 goto out; 492 493 memset(&tmp32, 0, sizeof(struct ustat32)); 494 tmp32.f_tfree = tmp.f_tfree; 495 tmp32.f_tinode = tmp.f_tinode; 496 497 err = copy_to_user(ubuf32, &tmp32, sizeof(struct ustat32)) ? -EFAULT : 0; 498 499 out: 500 return err; 501 } 502 503 asmlinkage int sys32_sendfile(int out_fd, int in_fd, compat_off_t __user *offset, 504 s32 count) 505 { 506 mm_segment_t old_fs = get_fs(); 507 int ret; 508 off_t of; 509 510 if (offset && get_user(of, offset)) 511 return -EFAULT; 512 513 set_fs(KERNEL_DS); 514 ret = sys_sendfile(out_fd, in_fd, offset ? (off_t __user *)&of : NULL, count); 515 set_fs(old_fs); 516 517 if (offset && put_user(of, offset)) 518 return -EFAULT; 519 520 return ret; 521 } 522 523 asmlinkage ssize_t sys32_readahead(int fd, u32 pad0, u64 a2, u64 a3, 524 size_t count) 525 { 526 return sys_readahead(fd, merge_64(a2, a3), count); 527 } 528 529 asmlinkage long sys32_sync_file_range(int fd, int __pad, 530 unsigned long a2, unsigned long a3, 531 unsigned long a4, unsigned long a5, 532 int flags) 533 { 534 return sys_sync_file_range(fd, 535 merge_64(a2, a3), merge_64(a4, a5), 536 flags); 537 } 538 539 asmlinkage long sys32_fadvise64_64(int fd, int __pad, 540 unsigned long a2, unsigned long a3, 541 unsigned long a4, unsigned long a5, 542 int flags) 543 { 544 return sys_fadvise64_64(fd, 545 merge_64(a2, a3), merge_64(a4, a5), 546 flags); 547 } 548 549 asmlinkage long sys32_fallocate(int fd, int mode, unsigned offset_a2, 550 unsigned offset_a3, unsigned len_a4, unsigned len_a5) 551 { 552 return sys_fallocate(fd, mode, merge_64(offset_a2, offset_a3), 553 merge_64(len_a4, len_a5)); 554 } 555 556 save_static_function(sys32_clone); 557 static int noinline __used 558 _sys32_clone(nabi_no_regargs struct pt_regs regs) 559 { 560 unsigned long clone_flags; 561 unsigned long newsp; 562 int __user *parent_tidptr, *child_tidptr; 563 564 clone_flags = regs.regs[4]; 565 newsp = regs.regs[5]; 566 if (!newsp) 567 newsp = regs.regs[29]; 568 parent_tidptr = (int __user *) regs.regs[6]; 569 570 /* Use __dummy4 instead of getting it off the stack, so that 571 syscall() works. */ 572 child_tidptr = (int __user *) __dummy4; 573 return do_fork(clone_flags, newsp, ®s, 0, 574 parent_tidptr, child_tidptr); 575 } 576