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