1/* 2 * sys_parisc32.c: Conversion between 32bit and 64bit native syscalls. 3 * 4 * Copyright (C) 2000-2001 Hewlett Packard Company 5 * Copyright (C) 2000 John Marvin 6 * Copyright (C) 2001 Matthew Wilcox 7 * 8 * These routines maintain argument size conversion between 32bit and 64bit 9 * environment. Based heavily on sys_ia32.c and sys_sparc32.c. 10 */ 11 12#include <linux/config.h> 13#include <linux/kernel.h> 14#include <linux/sched.h> 15#include <linux/fs.h> 16#include <linux/mm.h> 17#include <linux/file.h> 18#include <linux/signal.h> 19#include <linux/utime.h> 20#include <linux/resource.h> 21#include <linux/times.h> 22#include <linux/utsname.h> 23#include <linux/timex.h> 24#include <linux/smp.h> 25#include <linux/smp_lock.h> 26#include <linux/sem.h> 27#include <linux/msg.h> 28#include <linux/shm.h> 29#include <linux/slab.h> 30#include <linux/uio.h> 31#include <linux/nfs_fs.h> 32#include <linux/smb_fs.h> 33#include <linux/smb_mount.h> 34#include <linux/ncp_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> /* for setsockopt() */ 46#include <linux/icmpv6.h> /* for setsockopt() */ 47#include <linux/netfilter_ipv4/ip_queue.h> /* for setsockopt() */ 48#include <linux/netfilter_ipv4/ip_tables.h> /* for setsockopt() */ 49#include <linux/netfilter_ipv6/ip6_tables.h> /* for setsockopt() */ 50#include <linux/highmem.h> 51#include <linux/highuid.h> 52#include <linux/mman.h> 53 54#include <asm/types.h> 55#include <asm/uaccess.h> 56#include <asm/semaphore.h> 57 58#include "sys32.h" 59 60#define A(__x) ((unsigned long)(__x)) 61 62 63#undef DEBUG 64 65#ifdef DEBUG 66#define DBG(x) printk x 67#else 68#define DBG(x) 69#endif 70 71 72/* 73 * count32() counts the number of arguments/envelopes. It is basically 74 * a copy of count() from fs/exec.c, except that it works 75 * with 32 bit argv and envp pointers. 76 */ 77 78static int count32(u32 *argv, int max) 79{ 80 int i = 0; 81 82 if (argv != NULL) { 83 for (;;) { 84 u32 p; 85 int error; 86 87 error = get_user(p,argv); 88 if (error) 89 return error; 90 if (!p) 91 break; 92 argv++; 93 if(++i > max) 94 return -E2BIG; 95 } 96 } 97 return i; 98} 99 100 101/* 102 * copy_strings32() is basically a copy of copy_strings() from fs/exec.c 103 * except that it works with 32 bit argv and envp pointers. 104 */ 105 106 107static int copy_strings32(int argc, u32 *argv, struct linux_binprm *bprm) 108{ 109 while (argc-- > 0) { 110 u32 str; 111 int len; 112 unsigned long pos; 113 114 if (get_user(str, argv + argc) || 115 !str || 116 !(len = strnlen_user((char *)A(str), bprm->p))) 117 return -EFAULT; 118 119 if (bprm->p < len) 120 return -E2BIG; 121 122 bprm->p -= len; 123 124 pos = bprm->p; 125 while (len > 0) { 126 char *kaddr; 127 int i, new, err; 128 struct page *page; 129 int offset, bytes_to_copy; 130 131 offset = pos % PAGE_SIZE; 132 i = pos/PAGE_SIZE; 133 page = bprm->page[i]; 134 new = 0; 135 if (!page) { 136 page = alloc_page(GFP_HIGHUSER); 137 bprm->page[i] = page; 138 if (!page) 139 return -ENOMEM; 140 new = 1; 141 } 142 kaddr = (char *)kmap(page); 143 144 if (new && offset) 145 memset(kaddr, 0, offset); 146 bytes_to_copy = PAGE_SIZE - offset; 147 if (bytes_to_copy > len) { 148 bytes_to_copy = len; 149 if (new) 150 memset(kaddr+offset+len, 0, PAGE_SIZE-offset-len); 151 } 152 err = copy_from_user(kaddr + offset, (char *)A(str), bytes_to_copy); 153 flush_dcache_page(page); 154 flush_page_to_ram(page); 155 kunmap(page); 156 157 if (err) 158 return -EFAULT; 159 160 pos += bytes_to_copy; 161 str += bytes_to_copy; 162 len -= bytes_to_copy; 163 } 164 } 165 return 0; 166} 167 168/* 169 * do_execve32() is mostly a copy of do_execve(), with the exception 170 * that it processes 32 bit argv and envp pointers. 171 */ 172 173static inline int 174do_execve32(char * filename, u32 * argv, u32 * envp, struct pt_regs * regs) 175{ 176 struct linux_binprm bprm; 177 struct file *file; 178 int retval; 179 int i; 180 181 file = open_exec(filename); 182 183 retval = PTR_ERR(file); 184 if (IS_ERR(file)) 185 return retval; 186 187 bprm.p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *); 188 memset(bprm.page, 0, MAX_ARG_PAGES*sizeof(bprm.page[0])); 189 190 DBG(("do_execve32(%s, %p, %p, %p)\n", filename, argv, envp, regs)); 191 192 bprm.file = file; 193 bprm.filename = filename; 194 bprm.sh_bang = 0; 195 bprm.loader = 0; 196 bprm.exec = 0; 197 if ((bprm.argc = count32(argv, bprm.p / sizeof(u32))) < 0) { 198 allow_write_access(file); 199 fput(file); 200 return bprm.argc; 201 } 202 if ((bprm.envc = count32(envp, bprm.p / sizeof(u32))) < 0) { 203 allow_write_access(file); 204 fput(file); 205 return bprm.envc; 206 } 207 208 retval = prepare_binprm(&bprm); 209 if (retval < 0) 210 goto out; 211 212 retval = copy_strings_kernel(1, &bprm.filename, &bprm); 213 if (retval < 0) 214 goto out; 215 216 bprm.exec = bprm.p; 217 retval = copy_strings32(bprm.envc, envp, &bprm); 218 if (retval < 0) 219 goto out; 220 221 retval = copy_strings32(bprm.argc, argv, &bprm); 222 if (retval < 0) 223 goto out; 224 225 retval = search_binary_handler(&bprm,regs); 226 if (retval >= 0) 227 /* execve success */ 228 return retval; 229 230out: 231 /* Something went wrong, return the inode and free the argument pages*/ 232 allow_write_access(bprm.file); 233 if (bprm.file) 234 fput(bprm.file); 235 236 for (i = 0 ; i < MAX_ARG_PAGES ; i++) { 237 struct page * page = bprm.page[i]; 238 if (page) 239 __free_page(page); 240 } 241 242 return retval; 243} 244 245/* 246 * sys32_execve() executes a new program. 247 */ 248 249asmlinkage int sys32_execve(struct pt_regs *regs) 250{ 251 int error; 252 char *filename; 253 254 DBG(("sys32_execve(%p) r26 = 0x%lx\n", regs, regs->gr[26])); 255 filename = getname((char *) regs->gr[26]); 256 error = PTR_ERR(filename); 257 if (IS_ERR(filename)) 258 goto out; 259 error = do_execve32(filename, (u32 *) regs->gr[25], 260 (u32 *) regs->gr[24], regs); 261 if (error == 0) 262 current->ptrace &= ~PT_DTRACE; 263 putname(filename); 264out: 265 266 return error; 267} 268 269asmlinkage long sys32_unimplemented(int r26, int r25, int r24, int r23, 270 int r22, int r21, int r20) 271{ 272 printk(KERN_ERR "%s(%d): Unimplemented 32 on 64 syscall #%d!\n", 273 current->comm, current->pid, r20); 274 return -ENOSYS; 275} 276 277/* 32-bit user apps use struct statfs which uses 'long's */ 278struct statfs32 { 279 __s32 f_type; 280 __s32 f_bsize; 281 __s32 f_blocks; 282 __s32 f_bfree; 283 __s32 f_bavail; 284 __s32 f_files; 285 __s32 f_ffree; 286 __kernel_fsid_t f_fsid; 287 __s32 f_namelen; 288 __s32 f_spare[6]; 289}; 290 291/* convert statfs struct to statfs32 struct and copy result to user */ 292static unsigned long statfs32_to_user(struct statfs32 *ust32, struct statfs *st) 293{ 294 struct statfs32 st32; 295#undef CP 296#define CP(a) st32.a = st->a 297 CP(f_type); 298 CP(f_bsize); 299 CP(f_blocks); 300 CP(f_bfree); 301 CP(f_bavail); 302 CP(f_files); 303 CP(f_ffree); 304 CP(f_fsid); 305 CP(f_namelen); 306 return copy_to_user(ust32, &st32, sizeof st32); 307} 308 309/* The following statfs calls are copies of code from linux/fs/open.c and 310 * should be checked against those from time to time */ 311asmlinkage long sys32_statfs(const char * path, struct statfs32 * buf) 312{ 313 struct nameidata nd; 314 int error; 315 316 error = user_path_walk(path, &nd); 317 if (!error) { 318 struct statfs tmp; 319 error = vfs_statfs(nd.dentry->d_inode->i_sb, &tmp); 320 if (!error && statfs32_to_user(buf, &tmp)) 321 error = -EFAULT; 322 path_release(&nd); 323 } 324 return error; 325} 326 327asmlinkage long sys32_fstatfs(unsigned int fd, struct statfs32 * buf) 328{ 329 struct file * file; 330 struct statfs tmp; 331 int error; 332 333 error = -EBADF; 334 file = fget(fd); 335 if (!file) 336 goto out; 337 error = vfs_statfs(file->f_dentry->d_inode->i_sb, &tmp); 338 if (!error && statfs32_to_user(buf, &tmp)) 339 error = -EFAULT; 340 fput(file); 341out: 342 return error; 343} 344 345/* These may not work without my local types changes, but I wanted the 346 * code available in case it's useful to others. -PB 347 */ 348 349/* from utime.h */ 350struct utimbuf32 { 351 __kernel_time_t32 actime; 352 __kernel_time_t32 modtime; 353}; 354 355asmlinkage long sys32_utime(char *filename, struct utimbuf32 *times) 356{ 357 struct utimbuf32 times32; 358 struct utimbuf times64; 359 extern long sys_utime(char *filename, struct utimbuf *times); 360 char *fname; 361 long ret; 362 363 if (!times) 364 return sys_utime(filename, NULL); 365 366 /* get the 32-bit struct from user space */ 367 if (copy_from_user(×32, times, sizeof times32)) 368 return -EFAULT; 369 370 /* convert it into the 64-bit one */ 371 times64.actime = times32.actime; 372 times64.modtime = times32.modtime; 373 374 /* grab the file name */ 375 fname = getname(filename); 376 377 KERNEL_SYSCALL(ret, sys_utime, fname, ×64); 378 379 /* free the file name */ 380 putname(fname); 381 382 return ret; 383} 384 385struct tms32 { 386 __kernel_clock_t32 tms_utime; 387 __kernel_clock_t32 tms_stime; 388 __kernel_clock_t32 tms_cutime; 389 __kernel_clock_t32 tms_cstime; 390}; 391 392asmlinkage long sys32_times(struct tms32 *tbuf) 393{ 394 struct tms t; 395 long ret; 396 extern asmlinkage long sys_times(struct tms * tbuf); 397int err; 398 399 KERNEL_SYSCALL(ret, sys_times, tbuf ? &t : NULL); 400 if (tbuf) { 401 err = put_user (t.tms_utime, &tbuf->tms_utime); 402 err |= __put_user (t.tms_stime, &tbuf->tms_stime); 403 err |= __put_user (t.tms_cutime, &tbuf->tms_cutime); 404 err |= __put_user (t.tms_cstime, &tbuf->tms_cstime); 405 if (err) 406 ret = -EFAULT; 407 } 408 return ret; 409} 410 411struct flock32 { 412 short l_type; 413 short l_whence; 414 __kernel_off_t32 l_start; 415 __kernel_off_t32 l_len; 416 __kernel_pid_t32 l_pid; 417}; 418 419 420static inline int get_flock(struct flock *kfl, struct flock32 *ufl) 421{ 422 int err; 423 424 err = get_user(kfl->l_type, &ufl->l_type); 425 err |= __get_user(kfl->l_whence, &ufl->l_whence); 426 err |= __get_user(kfl->l_start, &ufl->l_start); 427 err |= __get_user(kfl->l_len, &ufl->l_len); 428 err |= __get_user(kfl->l_pid, &ufl->l_pid); 429 return err; 430} 431 432static inline int put_flock(struct flock *kfl, struct flock32 *ufl) 433{ 434 int err; 435 436 err = __put_user(kfl->l_type, &ufl->l_type); 437 err |= __put_user(kfl->l_whence, &ufl->l_whence); 438 err |= __put_user(kfl->l_start, &ufl->l_start); 439 err |= __put_user(kfl->l_len, &ufl->l_len); 440 err |= __put_user(kfl->l_pid, &ufl->l_pid); 441 return err; 442} 443 444extern asmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg); 445 446asmlinkage long sys32_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg) 447{ 448 switch (cmd) { 449 case F_GETLK: 450 case F_SETLK: 451 case F_SETLKW: 452 { 453 struct flock f; 454 long ret; 455 456 if(get_flock(&f, (struct flock32 *)arg)) 457 return -EFAULT; 458 KERNEL_SYSCALL(ret, sys_fcntl, fd, cmd, (unsigned long)&f); 459 if (ret) return ret; 460 if (f.l_start >= 0x7fffffffUL || 461 f.l_len >= 0x7fffffffUL || 462 f.l_start + f.l_len >= 0x7fffffffUL) 463 return -EOVERFLOW; 464 if(put_flock(&f, (struct flock32 *)arg)) 465 return -EFAULT; 466 return 0; 467 } 468 default: 469 return sys_fcntl(fd, cmd, (unsigned long)arg); 470 } 471} 472 473#ifdef CONFIG_SYSCTL 474 475struct __sysctl_args32 { 476 u32 name; 477 int nlen; 478 u32 oldval; 479 u32 oldlenp; 480 u32 newval; 481 u32 newlen; 482 u32 __unused[4]; 483}; 484 485asmlinkage long sys32_sysctl(struct __sysctl_args32 *args) 486{ 487 struct __sysctl_args32 tmp; 488 int error; 489 unsigned int oldlen32; 490 size_t oldlen, *oldlenp = NULL; 491 unsigned long addr = (((long)&args->__unused[0]) + 7) & ~7; 492 extern int do_sysctl(int *name, int nlen, void *oldval, size_t *oldlenp, 493 void *newval, size_t newlen); 494 495 DBG(("sysctl32(%p)\n", args)); 496 497 if (copy_from_user(&tmp, args, sizeof(tmp))) 498 return -EFAULT; 499 500 if (tmp.oldval && tmp.oldlenp) { 501 /* Duh, this is ugly and might not work if sysctl_args 502 is in read-only memory, but do_sysctl does indirectly 503 a lot of uaccess in both directions and we'd have to 504 basically copy the whole sysctl.c here, and 505 glibc's __sysctl uses rw memory for the structure 506 anyway. */ 507 /* a possibly better hack than this, which will avoid the 508 * problem if the struct is read only, is to push the 509 * 'oldlen' value out to the user's stack instead. -PB 510 */ 511 if (get_user(oldlen32, (u32 *)(u64)tmp.oldlenp)) 512 return -EFAULT; 513 oldlen = oldlen32; 514 if (put_user(oldlen, (size_t *)addr)) 515 return -EFAULT; 516 oldlenp = (size_t *)addr; 517 } 518 519 lock_kernel(); 520 error = do_sysctl((int *)(u64)tmp.name, tmp.nlen, (void *)(u64)tmp.oldval, 521 oldlenp, (void *)(u64)tmp.newval, tmp.newlen); 522 unlock_kernel(); 523 if (oldlenp) { 524 if (!error) { 525 if (get_user(oldlen, (size_t *)addr)) { 526 error = -EFAULT; 527 } else { 528 oldlen32 = oldlen; 529 if (put_user(oldlen32, (u32 *)(u64)tmp.oldlenp)) 530 error = -EFAULT; 531 } 532 } 533 if (copy_to_user(args->__unused, tmp.__unused, sizeof(tmp.__unused))) 534 error = -EFAULT; 535 } 536 return error; 537} 538 539#else /* CONFIG_SYSCTL */ 540 541asmlinkage long sys32_sysctl(struct __sysctl_args *args) 542{ 543 return -ENOSYS; 544} 545#endif /* CONFIG_SYSCTL */ 546 547struct timespec32 { 548 s32 tv_sec; 549 s32 tv_nsec; 550}; 551 552static int 553put_timespec32(struct timespec32 *u, struct timespec *t) 554{ 555 struct timespec32 t32; 556 t32.tv_sec = t->tv_sec; 557 t32.tv_nsec = t->tv_nsec; 558 return copy_to_user(u, &t32, sizeof t32); 559} 560 561asmlinkage int sys32_nanosleep(struct timespec32 *rqtp, struct timespec32 *rmtp) 562{ 563 struct timespec t; 564 struct timespec32 t32; 565 int ret; 566 extern asmlinkage int sys_nanosleep(struct timespec *rqtp, struct timespec *rmtp); 567 568 if (copy_from_user(&t32, rqtp, sizeof t32)) 569 return -EFAULT; 570 t.tv_sec = t32.tv_sec; 571 t.tv_nsec = t32.tv_nsec; 572 573 DBG(("sys32_nanosleep({%d, %d})\n", t32.tv_sec, t32.tv_nsec)); 574 575 KERNEL_SYSCALL(ret, sys_nanosleep, &t, rmtp ? &t : NULL); 576 if (rmtp && ret == -EINTR) { 577 if (put_timespec32(rmtp, &t)) 578 return -EFAULT; 579 } 580 return ret; 581} 582 583asmlinkage long sys32_sched_rr_get_interval(pid_t pid, 584 struct timespec32 *interval) 585{ 586 struct timespec t; 587 int ret; 588 extern asmlinkage long sys_sched_rr_get_interval(pid_t pid, struct timespec *interval); 589 590 KERNEL_SYSCALL(ret, sys_sched_rr_get_interval, pid, &t); 591 if (put_timespec32(interval, &t)) 592 return -EFAULT; 593 return ret; 594} 595 596typedef __kernel_time_t32 time_t32; 597 598static int 599put_timeval32(struct timeval32 *u, struct timeval *t) 600{ 601 struct timeval32 t32; 602 t32.tv_sec = t->tv_sec; 603 t32.tv_usec = t->tv_usec; 604 return copy_to_user(u, &t32, sizeof t32); 605} 606 607static int 608get_timeval32(struct timeval32 *u, struct timeval *t) 609{ 610 int err; 611 struct timeval32 t32; 612 613 if ((err = copy_from_user(&t32, u, sizeof t32)) == 0) 614 { 615 t->tv_sec = t32.tv_sec; 616 t->tv_usec = t32.tv_usec; 617 } 618 return err; 619} 620 621asmlinkage long sys32_time(time_t32 *tloc) 622{ 623 time_t now = CURRENT_TIME; 624 time_t32 now32 = now; 625 626 if (tloc) 627 if (put_user(now32, tloc)) 628 now32 = -EFAULT; 629 630 return now32; 631} 632 633asmlinkage int 634sys32_gettimeofday(struct timeval32 *tv, struct timezone *tz) 635{ 636 extern void do_gettimeofday(struct timeval *tv); 637 638 if (tv) { 639 struct timeval ktv; 640 do_gettimeofday(&ktv); 641 if (put_timeval32(tv, &ktv)) 642 return -EFAULT; 643 } 644 if (tz) { 645 extern struct timezone sys_tz; 646 if (copy_to_user(tz, &sys_tz, sizeof(sys_tz))) 647 return -EFAULT; 648 } 649 return 0; 650} 651 652asmlinkage int 653sys32_settimeofday(struct timeval32 *tv, struct timezone *tz) 654{ 655 struct timeval ktv; 656 struct timezone ktz; 657 extern int do_sys_settimeofday(struct timeval *tv, struct timezone *tz); 658 659 if (tv) { 660 if (get_timeval32(tv, &ktv)) 661 return -EFAULT; 662 } 663 if (tz) { 664 if (copy_from_user(&ktz, tz, sizeof(ktz))) 665 return -EFAULT; 666 } 667 668 return do_sys_settimeofday(tv ? &ktv : NULL, tz ? &ktz : NULL); 669} 670 671struct itimerval32 { 672 struct timeval32 it_interval; /* timer interval */ 673 struct timeval32 it_value; /* current value */ 674}; 675 676asmlinkage long sys32_getitimer(int which, struct itimerval32 *ov32) 677{ 678 int error = -EFAULT; 679 struct itimerval get_buffer; 680 extern int do_getitimer(int which, struct itimerval *value); 681 682 if (ov32) { 683 error = do_getitimer(which, &get_buffer); 684 if (!error) { 685 struct itimerval32 gb32; 686 gb32.it_interval.tv_sec = get_buffer.it_interval.tv_sec; 687 gb32.it_interval.tv_usec = get_buffer.it_interval.tv_usec; 688 gb32.it_value.tv_sec = get_buffer.it_value.tv_sec; 689 gb32.it_value.tv_usec = get_buffer.it_value.tv_usec; 690 if (copy_to_user(ov32, &gb32, sizeof(gb32))) 691 error = -EFAULT; 692 } 693 } 694 return error; 695} 696 697asmlinkage long sys32_setitimer(int which, struct itimerval32 *v32, 698 struct itimerval32 *ov32) 699{ 700 struct itimerval set_buffer, get_buffer; 701 struct itimerval32 sb32, gb32; 702 extern int do_setitimer(int which, struct itimerval *value, struct itimerval *ov32); 703 int error; 704 705 if (v32) { 706 if(copy_from_user(&sb32, v32, sizeof(sb32))) 707 return -EFAULT; 708 709 set_buffer.it_interval.tv_sec = sb32.it_interval.tv_sec; 710 set_buffer.it_interval.tv_usec = sb32.it_interval.tv_usec; 711 set_buffer.it_value.tv_sec = sb32.it_value.tv_sec; 712 set_buffer.it_value.tv_usec = sb32.it_value.tv_usec; 713 } else 714 memset((char *) &set_buffer, 0, sizeof(set_buffer)); 715 716 error = do_setitimer(which, &set_buffer, ov32 ? &get_buffer : 0); 717 if (error || !ov32) 718 return error; 719 720 gb32.it_interval.tv_sec = get_buffer.it_interval.tv_sec; 721 gb32.it_interval.tv_usec = get_buffer.it_interval.tv_usec; 722 gb32.it_value.tv_sec = get_buffer.it_value.tv_sec; 723 gb32.it_value.tv_usec = get_buffer.it_value.tv_usec; 724 if (copy_to_user(ov32, &gb32, sizeof(gb32))) 725 return -EFAULT; 726 return 0; 727} 728 729struct rusage32 { 730 struct timeval32 ru_utime; 731 struct timeval32 ru_stime; 732 int ru_maxrss; 733 int ru_ixrss; 734 int ru_idrss; 735 int ru_isrss; 736 int ru_minflt; 737 int ru_majflt; 738 int ru_nswap; 739 int ru_inblock; 740 int ru_oublock; 741 int ru_msgsnd; 742 int ru_msgrcv; 743 int ru_nsignals; 744 int ru_nvcsw; 745 int ru_nivcsw; 746}; 747 748static int 749put_rusage32(struct rusage32 *ru32p, struct rusage *r) 750{ 751 struct rusage32 r32; 752#undef CP 753#define CP(t) r32.t = r->t; 754 CP(ru_utime.tv_sec); CP(ru_utime.tv_usec); 755 CP(ru_stime.tv_sec); CP(ru_stime.tv_usec); 756 CP(ru_maxrss); 757 CP(ru_ixrss); 758 CP(ru_idrss); 759 CP(ru_isrss); 760 CP(ru_minflt); 761 CP(ru_majflt); 762 CP(ru_nswap); 763 CP(ru_inblock); 764 CP(ru_oublock); 765 CP(ru_msgsnd); 766 CP(ru_msgrcv); 767 CP(ru_nsignals); 768 CP(ru_nvcsw); 769 CP(ru_nivcsw); 770 return copy_to_user(ru32p, &r32, sizeof r32); 771} 772 773asmlinkage int 774sys32_getrusage(int who, struct rusage32 *ru) 775{ 776 struct rusage r; 777 int ret; 778 extern asmlinkage int sys_getrusage(int who, struct rusage *ru); 779 780 KERNEL_SYSCALL(ret, sys_getrusage, who, &r); 781 if (put_rusage32(ru, &r)) return -EFAULT; 782 return ret; 783} 784 785asmlinkage int 786sys32_wait4(__kernel_pid_t32 pid, unsigned int * stat_addr, int options, 787 struct rusage32 * ru) 788{ 789 if (!ru) 790 return sys_wait4(pid, stat_addr, options, NULL); 791 else { 792 struct rusage r; 793 int ret; 794 unsigned int status; 795 796 KERNEL_SYSCALL(ret, sys_wait4, pid, stat_addr ? &status : NULL, options, &r); 797 if (put_rusage32(ru, &r)) return -EFAULT; 798 if (stat_addr && put_user(status, stat_addr)) 799 return -EFAULT; 800 return ret; 801 } 802} 803 804struct stat32 { 805 __kernel_dev_t32 st_dev; /* dev_t is 32 bits on parisc */ 806 __kernel_ino_t32 st_ino; /* 32 bits */ 807 __kernel_mode_t32 st_mode; /* 16 bits */ 808 __kernel_nlink_t32 st_nlink; /* 16 bits */ 809 unsigned short st_reserved1; /* old st_uid */ 810 unsigned short st_reserved2; /* old st_gid */ 811 __kernel_dev_t32 st_rdev; 812 __kernel_off_t32 st_size; 813 __kernel_time_t32 st_atime; 814 unsigned int st_spare1; 815 __kernel_time_t32 st_mtime; 816 unsigned int st_spare2; 817 __kernel_time_t32 st_ctime; 818 unsigned int st_spare3; 819 int st_blksize; 820 int st_blocks; 821 unsigned int __unused1; /* ACL stuff */ 822 __kernel_dev_t32 __unused2; /* network */ 823 __kernel_ino_t32 __unused3; /* network */ 824 unsigned int __unused4; /* cnodes */ 825 unsigned short __unused5; /* netsite */ 826 short st_fstype; 827 __kernel_dev_t32 st_realdev; 828 unsigned short st_basemode; 829 unsigned short st_spareshort; 830 __kernel_uid_t32 st_uid; 831 __kernel_gid_t32 st_gid; 832 unsigned int st_spare4[3]; 833}; 834 835/* 836 * Revalidate the inode. This is required for proper NFS attribute caching. 837 */ 838static __inline__ int 839do_revalidate(struct dentry *dentry) 840{ 841 struct inode * inode = dentry->d_inode; 842 if (inode->i_op && inode->i_op->revalidate) 843 return inode->i_op->revalidate(dentry); 844 return 0; 845} 846 847 848static int cp_new_stat32(struct inode *inode, struct stat32 *statbuf) 849{ 850 struct stat32 tmp; 851 unsigned int blocks, indirect; 852 853 memset(&tmp, 0, sizeof(tmp)); 854 tmp.st_dev = kdev_t_to_nr(inode->i_dev); 855 tmp.st_ino = inode->i_ino; 856 tmp.st_mode = inode->i_mode; 857 tmp.st_nlink = inode->i_nlink; 858 SET_STAT_UID(tmp, inode->i_uid); 859 SET_STAT_GID(tmp, inode->i_gid); 860 tmp.st_rdev = kdev_t_to_nr(inode->i_rdev); 861#if BITS_PER_LONG == 32 862 if (inode->i_size > 0x7fffffff) 863 return -EOVERFLOW; 864#endif 865 tmp.st_size = inode->i_size; 866 tmp.st_atime = inode->i_atime; 867 tmp.st_mtime = inode->i_mtime; 868 tmp.st_ctime = inode->i_ctime; 869/* 870 * st_blocks and st_blksize are approximated with a simple algorithm if 871 * they aren't supported directly by the filesystem. The minix and msdos 872 * filesystems don't keep track of blocks, so they would either have to 873 * be counted explicitly (by delving into the file itself), or by using 874 * this simple algorithm to get a reasonable (although not 100% accurate) 875 * value. 876 */ 877 878/* 879 * Use minix fs values for the number of direct and indirect blocks. The 880 * count is now exact for the minix fs except that it counts zero blocks. 881 * Everything is in units of BLOCK_SIZE until the assignment to 882 * tmp.st_blksize. 883 */ 884#define D_B 7 885#define I_B (BLOCK_SIZE / sizeof(unsigned short)) 886 887 if (!inode->i_blksize) { 888 blocks = (tmp.st_size + BLOCK_SIZE - 1) / BLOCK_SIZE; 889 if (blocks > D_B) { 890 indirect = (blocks - D_B + I_B - 1) / I_B; 891 blocks += indirect; 892 if (indirect > 1) { 893 indirect = (indirect - 1 + I_B - 1) / I_B; 894 blocks += indirect; 895 if (indirect > 1) 896 blocks++; 897 } 898 } 899 tmp.st_blocks = (BLOCK_SIZE / 512) * blocks; 900 tmp.st_blksize = BLOCK_SIZE; 901 } else { 902 tmp.st_blocks = inode->i_blocks; 903 tmp.st_blksize = inode->i_blksize; 904 } 905 return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0; 906} 907 908asmlinkage long sys32_newstat(char * filename, struct stat32 *statbuf) 909{ 910 struct nameidata nd; 911 int error; 912 913 error = user_path_walk(filename, &nd); 914 if (!error) { 915 error = do_revalidate(nd.dentry); 916 if (!error) 917 error = cp_new_stat32(nd.dentry->d_inode, statbuf); 918 path_release(&nd); 919 } 920 return error; 921} 922 923asmlinkage long sys32_newlstat(char * filename, struct stat32 *statbuf) 924{ 925 struct nameidata nd; 926 int error; 927 928 error = user_path_walk_link(filename, &nd); 929 if (!error) { 930 error = do_revalidate(nd.dentry); 931 if (!error) 932 error = cp_new_stat32(nd.dentry->d_inode, statbuf); 933 path_release(&nd); 934 } 935 return error; 936} 937 938asmlinkage long sys32_newfstat(unsigned int fd, struct stat32 *statbuf) 939{ 940 struct file * f; 941 int err = -EBADF; 942 943 f = fget(fd); 944 if (f) { 945 struct dentry * dentry = f->f_dentry; 946 947 err = do_revalidate(dentry); 948 if (!err) 949 err = cp_new_stat32(dentry->d_inode, statbuf); 950 fput(f); 951 } 952 return err; 953} 954 955struct linux32_dirent { 956 u32 d_ino; 957 __kernel_off_t32 d_off; 958 u16 d_reclen; 959 char d_name[1]; 960}; 961 962struct old_linux32_dirent { 963 u32 d_ino; 964 u32 d_offset; 965 u16 d_namlen; 966 char d_name[1]; 967}; 968 969struct getdents32_callback { 970 struct linux32_dirent * current_dir; 971 struct linux32_dirent * previous; 972 int count; 973 int error; 974}; 975 976struct readdir32_callback { 977 struct old_linux32_dirent * dirent; 978 int count; 979}; 980 981#define ROUND_UP(x,a) ((__typeof__(x))(((unsigned long)(x) + ((a) - 1)) & ~((a) - 1))) 982#define NAME_OFFSET(de) ((int) ((de)->d_name - (char *) (de))) 983static int 984filldir32 (void *__buf, const char *name, int namlen, loff_t offset, ino_t ino, 985 unsigned int d_type) 986{ 987 struct linux32_dirent * dirent; 988 struct getdents32_callback * buf = (struct getdents32_callback *) __buf; 989 int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 1, 4); 990 991 buf->error = -EINVAL; /* only used if we fail.. */ 992 if (reclen > buf->count) 993 return -EINVAL; 994 dirent = buf->previous; 995 if (dirent) 996 put_user(offset, &dirent->d_off); 997 dirent = buf->current_dir; 998 buf->previous = dirent; 999 put_user(ino, &dirent->d_ino); 1000 put_user(reclen, &dirent->d_reclen); 1001 copy_to_user(dirent->d_name, name, namlen); 1002 put_user(0, dirent->d_name + namlen); 1003 ((char *) dirent) += reclen; 1004 buf->current_dir = dirent; 1005 buf->count -= reclen; 1006 return 0; 1007} 1008 1009asmlinkage long 1010sys32_getdents (unsigned int fd, void * dirent, unsigned int count) 1011{ 1012 struct file * file; 1013 struct linux32_dirent * lastdirent; 1014 struct getdents32_callback buf; 1015 int error; 1016 1017 error = -EBADF; 1018 file = fget(fd); 1019 if (!file) 1020 goto out; 1021 1022 buf.current_dir = (struct linux32_dirent *) dirent; 1023 buf.previous = NULL; 1024 buf.count = count; 1025 buf.error = 0; 1026 1027 error = vfs_readdir(file, filldir32, &buf); 1028 if (error < 0) 1029 goto out_putf; 1030 error = buf.error; 1031 lastdirent = buf.previous; 1032 if (lastdirent) { 1033 put_user(file->f_pos, &lastdirent->d_off); 1034 error = count - buf.count; 1035 } 1036 1037out_putf: 1038 fput(file); 1039out: 1040 return error; 1041} 1042 1043static int 1044fillonedir32 (void * __buf, const char * name, int namlen, loff_t offset, ino_t ino, 1045 unsigned int d_type) 1046{ 1047 struct readdir32_callback * buf = (struct readdir32_callback *) __buf; 1048 struct old_linux32_dirent * dirent; 1049 1050 if (buf->count) 1051 return -EINVAL; 1052 buf->count++; 1053 dirent = buf->dirent; 1054 put_user(ino, &dirent->d_ino); 1055 put_user(offset, &dirent->d_offset); 1056 put_user(namlen, &dirent->d_namlen); 1057 copy_to_user(dirent->d_name, name, namlen); 1058 put_user(0, dirent->d_name + namlen); 1059 return 0; 1060} 1061 1062asmlinkage long 1063sys32_readdir (unsigned int fd, void * dirent, unsigned int count) 1064{ 1065 int error; 1066 struct file * file; 1067 struct readdir32_callback buf; 1068 1069 error = -EBADF; 1070 file = fget(fd); 1071 if (!file) 1072 goto out; 1073 1074 buf.count = 0; 1075 buf.dirent = dirent; 1076 1077 error = vfs_readdir(file, fillonedir32, &buf); 1078 if (error >= 0) 1079 error = buf.count; 1080 fput(file); 1081out: 1082 return error; 1083} 1084 1085struct rlimit32 { 1086 __u32 rlim_cur; 1087 __u32 rlim_max; 1088}; 1089 1090#define RLIM32_INFINITY 0xffffffff 1091 1092asmlinkage long sys32_getrlimit(unsigned int resource, struct rlimit32 *rlim) 1093{ 1094 struct rlimit32 rlim32; 1095 struct rlimit *rlimip; 1096 1097 if (resource >= RLIM_NLIMITS) 1098 return -EINVAL; 1099 rlimip = current->rlim + resource; 1100 if (rlimip->rlim_cur >= RLIM32_INFINITY) { 1101 rlim32.rlim_cur = RLIM32_INFINITY; 1102 } else { 1103 rlim32.rlim_cur = rlimip->rlim_cur; 1104 } 1105 if (rlimip->rlim_max >= RLIM32_INFINITY) { 1106 rlim32.rlim_max = RLIM32_INFINITY; 1107 } else { 1108 rlim32.rlim_max = rlimip->rlim_max; 1109 } 1110 return copy_to_user(rlim, &rlim32, sizeof (struct rlimit32)); 1111} 1112 1113asmlinkage long sys32_setrlimit(unsigned int resource, struct rlimit32 *rlim) 1114{ 1115 struct rlimit32 rlim32; 1116 struct rlimit new_rlim, *old_rlim; 1117 1118 if (resource >= RLIM_NLIMITS) 1119 return -EINVAL; 1120 if (copy_from_user(&rlim32, rlim, sizeof(rlim))) 1121 return -EFAULT; 1122 if (rlim32.rlim_cur == RLIM32_INFINITY) { 1123 new_rlim.rlim_cur = RLIM_INFINITY; 1124 } else { 1125 new_rlim.rlim_cur = rlim32.rlim_cur; 1126 } 1127 if (rlim32.rlim_max == RLIM32_INFINITY) { 1128 new_rlim.rlim_max = RLIM_INFINITY; 1129 } else { 1130 new_rlim.rlim_max = rlim32.rlim_max; 1131 } 1132 1133 old_rlim = current->rlim + resource; 1134 if (((new_rlim.rlim_cur > old_rlim->rlim_max) || 1135 (new_rlim.rlim_max > old_rlim->rlim_max)) && 1136 !capable(CAP_SYS_RESOURCE)) 1137 return -EPERM; 1138 if (resource == RLIMIT_NOFILE) { 1139 if (new_rlim.rlim_cur > NR_OPEN || new_rlim.rlim_max > NR_OPEN) 1140 return -EPERM; 1141 } 1142 if (resource == RLIMIT_STACK) { 1143 if (new_rlim.rlim_max > 1024 * 1024 * 1024) { 1144 new_rlim.rlim_max = 1024 * 1024 * 1024; 1145 } 1146 new_rlim.rlim_max = PAGE_ALIGN(new_rlim.rlim_max); 1147 } 1148 1149 *old_rlim = new_rlim; 1150 return 0; 1151} 1152 1153static int copy_mount_stuff_to_kernel(const void *user, unsigned long *kernel) 1154{ 1155 int i; 1156 unsigned long page; 1157 struct vm_area_struct *vma; 1158 1159 *kernel = 0; 1160 if(!user) 1161 return 0; 1162 vma = find_vma(current->mm, (unsigned long)user); 1163 if(!vma || (unsigned long)user < vma->vm_start) 1164 return -EFAULT; 1165 if(!(vma->vm_flags & VM_READ)) 1166 return -EFAULT; 1167 i = vma->vm_end - (unsigned long) user; 1168 if(PAGE_SIZE <= (unsigned long) i) 1169 i = PAGE_SIZE - 1; 1170 if(!(page = __get_free_page(GFP_KERNEL))) 1171 return -ENOMEM; 1172 if(copy_from_user((void *) page, user, i)) { 1173 free_page(page); 1174 return -EFAULT; 1175 } 1176 *kernel = page; 1177 return 0; 1178} 1179 1180#define SMBFS_NAME "smbfs" 1181#define NCPFS_NAME "ncpfs" 1182 1183asmlinkage int sys32_mount(char *dev_name, char *dir_name, char *type, unsigned long new_flags, u32 data) 1184{ 1185 unsigned long type_page = 0; 1186 unsigned long data_page = 0; 1187 unsigned long dev_page = 0; 1188 unsigned long dir_page = 0; 1189 int err, is_smb, is_ncp; 1190 1191 is_smb = is_ncp = 0; 1192 1193 err = copy_mount_stuff_to_kernel((const void *)type, &type_page); 1194 if (err) 1195 goto out; 1196 1197 if (!type_page) { 1198 err = -EINVAL; 1199 goto out; 1200 } 1201 1202 is_smb = !strcmp((char *)type_page, SMBFS_NAME); 1203 is_ncp = !strcmp((char *)type_page, NCPFS_NAME); 1204 1205 err = copy_mount_stuff_to_kernel((const void *)(unsigned long)data, &data_page); 1206 if (err) 1207 goto type_out; 1208 1209 err = copy_mount_stuff_to_kernel(dev_name, &dev_page); 1210 if (err) 1211 goto data_out; 1212 1213 err = copy_mount_stuff_to_kernel(dir_name, &dir_page); 1214 if (err) 1215 goto dev_out; 1216 1217 if (!is_smb && !is_ncp) { 1218 lock_kernel(); 1219 err = do_mount((char*)dev_page, (char*)dir_page, 1220 (char*)type_page, new_flags, (char*)data_page); 1221 unlock_kernel(); 1222 } else { 1223 if (is_ncp) 1224 panic("NCP mounts not yet supported 32/64 parisc"); 1225 /* do_ncp_super_data_conv((void *)data_page); */ 1226 else { 1227 panic("SMB mounts not yet supported 32/64 parisc"); 1228 /* do_smb_super_data_conv((void *)data_page); */ 1229 } 1230 1231 lock_kernel(); 1232 err = do_mount((char*)dev_page, (char*)dir_page, 1233 (char*)type_page, new_flags, (char*)data_page); 1234 unlock_kernel(); 1235 } 1236 free_page(dir_page); 1237 1238dev_out: 1239 free_page(dev_page); 1240 1241data_out: 1242 free_page(data_page); 1243 1244type_out: 1245 free_page(type_page); 1246 1247out: 1248 return err; 1249} 1250 1251 1252#ifdef CONFIG_MODULES 1253 1254struct module_info32 { 1255 u32 addr; 1256 u32 size; 1257 u32 flags; 1258 s32 usecount; 1259}; 1260 1261/* Query various bits about modules. */ 1262 1263static inline long 1264get_mod_name(const char *user_name, char **buf) 1265{ 1266 unsigned long page; 1267 long retval; 1268 1269 if ((unsigned long)user_name >= TASK_SIZE 1270 && !segment_eq(get_fs (), KERNEL_DS)) 1271 return -EFAULT; 1272 1273 page = __get_free_page(GFP_KERNEL); 1274 if (!page) 1275 return -ENOMEM; 1276 1277 retval = strncpy_from_user((char *)page, user_name, PAGE_SIZE); 1278 if (retval > 0) { 1279 if (retval < PAGE_SIZE) { 1280 *buf = (char *)page; 1281 return retval; 1282 } 1283 retval = -ENAMETOOLONG; 1284 } else if (!retval) 1285 retval = -EINVAL; 1286 1287 free_page(page); 1288 return retval; 1289} 1290 1291static inline void 1292put_mod_name(char *buf) 1293{ 1294 free_page((unsigned long)buf); 1295} 1296 1297static __inline__ struct module *find_module(const char *name) 1298{ 1299 struct module *mod; 1300 1301 for (mod = module_list; mod ; mod = mod->next) { 1302 if (mod->flags & MOD_DELETED) 1303 continue; 1304 if (!strcmp(mod->name, name)) 1305 break; 1306 } 1307 1308 return mod; 1309} 1310 1311static int 1312qm_modules(char *buf, size_t bufsize, __kernel_size_t32 *ret) 1313{ 1314 struct module *mod; 1315 size_t nmod, space, len; 1316 1317 nmod = space = 0; 1318 1319 for (mod = module_list; mod->next != NULL; mod = mod->next, ++nmod) { 1320 len = strlen(mod->name)+1; 1321 if (len > bufsize) 1322 goto calc_space_needed; 1323 if (copy_to_user(buf, mod->name, len)) 1324 return -EFAULT; 1325 buf += len; 1326 bufsize -= len; 1327 space += len; 1328 } 1329 1330 if (put_user(nmod, ret)) 1331 return -EFAULT; 1332 else 1333 return 0; 1334 1335calc_space_needed: 1336 space += len; 1337 while ((mod = mod->next)->next != NULL) 1338 space += strlen(mod->name)+1; 1339 1340 if (put_user(space, ret)) 1341 return -EFAULT; 1342 else 1343 return -ENOSPC; 1344} 1345 1346static int 1347qm_deps(struct module *mod, char *buf, size_t bufsize, __kernel_size_t32 *ret) 1348{ 1349 size_t i, space, len; 1350 1351 if (mod->next == NULL) 1352 return -EINVAL; 1353 if (!MOD_CAN_QUERY(mod)) 1354 return put_user(0, ret); 1355 1356 space = 0; 1357 for (i = 0; i < mod->ndeps; ++i) { 1358 const char *dep_name = mod->deps[i].dep->name; 1359 1360 len = strlen(dep_name)+1; 1361 if (len > bufsize) 1362 goto calc_space_needed; 1363 if (copy_to_user(buf, dep_name, len)) 1364 return -EFAULT; 1365 buf += len; 1366 bufsize -= len; 1367 space += len; 1368 } 1369 1370 return put_user(i, ret); 1371 1372calc_space_needed: 1373 space += len; 1374 while (++i < mod->ndeps) 1375 space += strlen(mod->deps[i].dep->name)+1; 1376 1377 if (put_user(space, ret)) 1378 return -EFAULT; 1379 else 1380 return -ENOSPC; 1381} 1382 1383static int 1384qm_refs(struct module *mod, char *buf, size_t bufsize, __kernel_size_t32 *ret) 1385{ 1386 size_t nrefs, space, len; 1387 struct module_ref *ref; 1388 1389 if (mod->next == NULL) 1390 return -EINVAL; 1391 if (!MOD_CAN_QUERY(mod)) 1392 if (put_user(0, ret)) 1393 return -EFAULT; 1394 else 1395 return 0; 1396 1397 space = 0; 1398 for (nrefs = 0, ref = mod->refs; ref ; ++nrefs, ref = ref->next_ref) { 1399 const char *ref_name = ref->ref->name; 1400 1401 len = strlen(ref_name)+1; 1402 if (len > bufsize) 1403 goto calc_space_needed; 1404 if (copy_to_user(buf, ref_name, len)) 1405 return -EFAULT; 1406 buf += len; 1407 bufsize -= len; 1408 space += len; 1409 } 1410 1411 if (put_user(nrefs, ret)) 1412 return -EFAULT; 1413 else 1414 return 0; 1415 1416calc_space_needed: 1417 space += len; 1418 while ((ref = ref->next_ref) != NULL) 1419 space += strlen(ref->ref->name)+1; 1420 1421 if (put_user(space, ret)) 1422 return -EFAULT; 1423 else 1424 return -ENOSPC; 1425} 1426 1427static inline int 1428qm_symbols(struct module *mod, char *buf, size_t bufsize, __kernel_size_t32 *ret) 1429{ 1430 size_t i, space, len; 1431 struct module_symbol *s; 1432 char *strings; 1433 unsigned *vals; 1434 1435 if (!MOD_CAN_QUERY(mod)) 1436 if (put_user(0, ret)) 1437 return -EFAULT; 1438 else 1439 return 0; 1440 1441 space = mod->nsyms * 2*sizeof(u32); 1442 1443 i = len = 0; 1444 s = mod->syms; 1445 1446 if (space > bufsize) 1447 goto calc_space_needed; 1448 1449 if (!access_ok(VERIFY_WRITE, buf, space)) 1450 return -EFAULT; 1451 1452 bufsize -= space; 1453 vals = (unsigned *)buf; 1454 strings = buf+space; 1455 1456 for (; i < mod->nsyms ; ++i, ++s, vals += 2) { 1457 len = strlen(s->name)+1; 1458 if (len > bufsize) 1459 goto calc_space_needed; 1460 1461 if (copy_to_user(strings, s->name, len) 1462 || __put_user(s->value, vals+0) 1463 || __put_user(space, vals+1)) 1464 return -EFAULT; 1465 1466 strings += len; 1467 bufsize -= len; 1468 space += len; 1469 } 1470 1471 if (put_user(i, ret)) 1472 return -EFAULT; 1473 else 1474 return 0; 1475 1476calc_space_needed: 1477 for (; i < mod->nsyms; ++i, ++s) 1478 space += strlen(s->name)+1; 1479 1480 if (put_user(space, ret)) 1481 return -EFAULT; 1482 else 1483 return -ENOSPC; 1484} 1485 1486static inline int 1487qm_info(struct module *mod, char *buf, size_t bufsize, __kernel_size_t32 *ret) 1488{ 1489 int error = 0; 1490 1491 if (mod->next == NULL) 1492 return -EINVAL; 1493 1494 if (sizeof(struct module_info32) <= bufsize) { 1495 struct module_info32 info; 1496 info.addr = (unsigned long)mod; 1497 info.size = mod->size; 1498 info.flags = mod->flags; 1499 info.usecount = 1500 ((mod_member_present(mod, can_unload) 1501 && mod->can_unload) 1502 ? -1 : atomic_read(&mod->uc.usecount)); 1503 1504 if (copy_to_user(buf, &info, sizeof(struct module_info32))) 1505 return -EFAULT; 1506 } else 1507 error = -ENOSPC; 1508 1509 if (put_user(sizeof(struct module_info32), ret)) 1510 return -EFAULT; 1511 1512 return error; 1513} 1514 1515asmlinkage int sys32_query_module(char *name_user, int which, char *buf, __kernel_size_t32 bufsize, __kernel_size_t32 *ret) 1516{ 1517 struct module *mod; 1518 int err; 1519 1520 lock_kernel(); 1521 if (name_user == 0) { 1522 /* This finds "kernel_module" which is not exported. */ 1523 for(mod = module_list; mod->next != NULL; mod = mod->next) 1524 ; 1525 } else { 1526 long namelen; 1527 char *name; 1528 1529 if ((namelen = get_mod_name(name_user, &name)) < 0) { 1530 err = namelen; 1531 goto out; 1532 } 1533 err = -ENOENT; 1534 if (namelen == 0) { 1535 /* This finds "kernel_module" which is not exported. */ 1536 for(mod = module_list; mod->next != NULL; mod = mod->next) 1537 ; 1538 } else if ((mod = find_module(name)) == NULL) { 1539 put_mod_name(name); 1540 goto out; 1541 } 1542 put_mod_name(name); 1543 } 1544 1545 switch (which) 1546 { 1547 case 0: 1548 err = 0; 1549 break; 1550 case QM_MODULES: 1551 err = qm_modules(buf, bufsize, ret); 1552 break; 1553 case QM_DEPS: 1554 err = qm_deps(mod, buf, bufsize, ret); 1555 break; 1556 case QM_REFS: 1557 err = qm_refs(mod, buf, bufsize, ret); 1558 break; 1559 case QM_SYMBOLS: 1560 err = qm_symbols(mod, buf, bufsize, ret); 1561 break; 1562 case QM_INFO: 1563 err = qm_info(mod, buf, bufsize, ret); 1564 break; 1565 default: 1566 err = -EINVAL; 1567 break; 1568 } 1569out: 1570 unlock_kernel(); 1571 return err; 1572} 1573 1574struct kernel_sym32 { 1575 u32 value; 1576 char name[60]; 1577}; 1578 1579extern asmlinkage int sys_get_kernel_syms(struct kernel_sym *table); 1580 1581asmlinkage int sys32_get_kernel_syms(struct kernel_sym32 *table) 1582{ 1583 int len, i; 1584 struct kernel_sym *tbl; 1585 mm_segment_t old_fs; 1586 1587 len = sys_get_kernel_syms(NULL); 1588 if (!table) return len; 1589 tbl = kmalloc (len * sizeof (struct kernel_sym), GFP_KERNEL); 1590 if (!tbl) return -ENOMEM; 1591 old_fs = get_fs(); 1592 set_fs (KERNEL_DS); 1593 sys_get_kernel_syms(tbl); 1594 set_fs (old_fs); 1595 for (i = 0; i < len; i++, table++) { 1596 if (put_user (tbl[i].value, &table->value) || 1597 copy_to_user (table->name, tbl[i].name, 60)) 1598 break; 1599 } 1600 kfree (tbl); 1601 return i; 1602} 1603 1604#else /* CONFIG_MODULES */ 1605 1606asmlinkage int 1607sys32_query_module(const char *name_user, int which, char *buf, size_t bufsize, 1608 size_t *ret) 1609{ 1610 /* Let the program know about the new interface. Not that 1611 it'll do them much good. */ 1612 if (which == 0) 1613 return 0; 1614 1615 return -ENOSYS; 1616} 1617 1618asmlinkage int 1619sys32_get_kernel_syms(struct kernel_sym *table) 1620{ 1621 return -ENOSYS; 1622} 1623 1624#endif /* CONFIG_MODULES */ 1625 1626/* readv/writev stolen from mips64 */ 1627struct iovec32 { unsigned int iov_base; int iov_len; }; 1628 1629typedef ssize_t (*IO_fn_t)(struct file *, char *, size_t, loff_t *); 1630 1631static long 1632do_readv_writev32(int type, struct file *file, const struct iovec32 *vector, 1633 u32 count) 1634{ 1635 unsigned long tot_len; 1636 struct iovec iovstack[UIO_FASTIOV]; 1637 struct iovec *iov=iovstack, *ivp; 1638 struct inode *inode; 1639 long retval, i; 1640 IO_fn_t fn; 1641 1642 /* First get the "struct iovec" from user memory and 1643 * verify all the pointers 1644 */ 1645 if (!count) 1646 return 0; 1647 if(verify_area(VERIFY_READ, vector, sizeof(struct iovec32)*count)) 1648 return -EFAULT; 1649 if (count > UIO_MAXIOV) 1650 return -EINVAL; 1651 if (count > UIO_FASTIOV) { 1652 iov = kmalloc(count*sizeof(struct iovec), GFP_KERNEL); 1653 if (!iov) 1654 return -ENOMEM; 1655 } 1656 1657 tot_len = 0; 1658 i = count; 1659 ivp = iov; 1660 while (i > 0) { 1661 u32 len; 1662 u32 buf; 1663 1664 __get_user(len, &vector->iov_len); 1665 __get_user(buf, &vector->iov_base); 1666 tot_len += len; 1667 ivp->iov_base = (void *)A(buf); 1668 ivp->iov_len = (__kernel_size_t) len; 1669 vector++; 1670 ivp++; 1671 i--; 1672 } 1673 1674 inode = file->f_dentry->d_inode; 1675 /* VERIFY_WRITE actually means a read, as we write to user space */ 1676 retval = locks_verify_area((type == VERIFY_WRITE 1677 ? FLOCK_VERIFY_READ : FLOCK_VERIFY_WRITE), 1678 inode, file, file->f_pos, tot_len); 1679 if (retval) { 1680 if (iov != iovstack) 1681 kfree(iov); 1682 return retval; 1683 } 1684 1685 /* Then do the actual IO. Note that sockets need to be handled 1686 * specially as they have atomicity guarantees and can handle 1687 * iovec's natively 1688 */ 1689 if (inode->i_sock) { 1690 int err; 1691 err = sock_readv_writev(type, inode, file, iov, count, tot_len); 1692 if (iov != iovstack) 1693 kfree(iov); 1694 return err; 1695 } 1696 1697 if (!file->f_op) { 1698 if (iov != iovstack) 1699 kfree(iov); 1700 return -EINVAL; 1701 } 1702 /* VERIFY_WRITE actually means a read, as we write to user space */ 1703 fn = file->f_op->read; 1704 if (type == VERIFY_READ) 1705 fn = (IO_fn_t) file->f_op->write; 1706 ivp = iov; 1707 while (count > 0) { 1708 void * base; 1709 int len, nr; 1710 1711 base = ivp->iov_base; 1712 len = ivp->iov_len; 1713 ivp++; 1714 count--; 1715 nr = fn(file, base, len, &file->f_pos); 1716 if (nr < 0) { 1717 if (retval) 1718 break; 1719 retval = nr; 1720 break; 1721 } 1722 retval += nr; 1723 if (nr != len) 1724 break; 1725 } 1726 if (iov != iovstack) 1727 kfree(iov); 1728 1729 return retval; 1730} 1731 1732asmlinkage long 1733sys32_readv(int fd, struct iovec32 *vector, u32 count) 1734{ 1735 struct file *file; 1736 ssize_t ret; 1737 1738 ret = -EBADF; 1739 file = fget(fd); 1740 if (!file) 1741 goto bad_file; 1742 if (file->f_op && (file->f_mode & FMODE_READ) && 1743 (file->f_op->readv || file->f_op->read)) 1744 ret = do_readv_writev32(VERIFY_WRITE, file, vector, count); 1745 1746 fput(file); 1747 1748bad_file: 1749 return ret; 1750} 1751 1752asmlinkage long 1753sys32_writev(int fd, struct iovec32 *vector, u32 count) 1754{ 1755 struct file *file; 1756 ssize_t ret; 1757 1758 ret = -EBADF; 1759 file = fget(fd); 1760 if(!file) 1761 goto bad_file; 1762 if (file->f_op && (file->f_mode & FMODE_WRITE) && 1763 (file->f_op->writev || file->f_op->write)) 1764 ret = do_readv_writev32(VERIFY_READ, file, vector, count); 1765 fput(file); 1766 1767bad_file: 1768 return ret; 1769} 1770 1771/********** Borrowed from sparc64 -- hardly reviewed, not tested *****/ 1772#include <net/scm.h> 1773#define MAX_SOCK_ADDR 128 /* 108 for Unix domain - 1774 16 for IP, 16 for IPX, 1775 24 for IPv6, 1776 about 80 for AX.25 */ 1777 1778extern struct socket *sockfd_lookup(int fd, int *err); 1779 1780extern __inline__ void sockfd_put(struct socket *sock) 1781{ 1782 fput(sock->file); 1783} 1784 1785struct msghdr32 { 1786 u32 msg_name; 1787 int msg_namelen; 1788 u32 msg_iov; 1789 __kernel_size_t32 msg_iovlen; 1790 u32 msg_control; 1791 __kernel_size_t32 msg_controllen; 1792 unsigned msg_flags; 1793}; 1794 1795struct cmsghdr32 { 1796 __kernel_size_t32 cmsg_len; 1797 int cmsg_level; 1798 int cmsg_type; 1799}; 1800 1801/* Bleech... */ 1802#define __CMSG32_NXTHDR(ctl, len, cmsg, cmsglen) __cmsg32_nxthdr((ctl),(len),(cmsg),(cmsglen)) 1803#define CMSG32_NXTHDR(mhdr, cmsg, cmsglen) cmsg32_nxthdr((mhdr), (cmsg), (cmsglen)) 1804 1805#define CMSG32_ALIGN(len) ( ((len)+sizeof(int)-1) & ~(sizeof(int)-1) ) 1806 1807#define CMSG32_DATA(cmsg) ((void *)((char *)(cmsg) + CMSG32_ALIGN(sizeof(struct cmsghdr32)))) 1808#define CMSG32_SPACE(len) (CMSG32_ALIGN(sizeof(struct cmsghdr32)) + CMSG32_ALIGN(len)) 1809#define CMSG32_LEN(len) (CMSG32_ALIGN(sizeof(struct cmsghdr32)) + (len)) 1810 1811#define __CMSG32_FIRSTHDR(ctl,len) ((len) >= sizeof(struct cmsghdr32) ? \ 1812 (struct cmsghdr32 *)(ctl) : \ 1813 (struct cmsghdr32 *)NULL) 1814#define CMSG32_FIRSTHDR(msg) __CMSG32_FIRSTHDR((msg)->msg_control, (msg)->msg_controllen) 1815 1816__inline__ struct cmsghdr32 *__cmsg32_nxthdr(void *__ctl, __kernel_size_t __size, 1817 struct cmsghdr32 *__cmsg, int __cmsg_len) 1818{ 1819 struct cmsghdr32 * __ptr; 1820 1821 __ptr = (struct cmsghdr32 *)(((unsigned char *) __cmsg) + 1822 CMSG32_ALIGN(__cmsg_len)); 1823 if ((unsigned long)((char*)(__ptr+1) - (char *) __ctl) > __size) 1824 return NULL; 1825 1826 return __ptr; 1827} 1828 1829__inline__ struct cmsghdr32 *cmsg32_nxthdr (struct msghdr *__msg, 1830 struct cmsghdr32 *__cmsg, 1831 int __cmsg_len) 1832{ 1833 return __cmsg32_nxthdr(__msg->msg_control, __msg->msg_controllen, 1834 __cmsg, __cmsg_len); 1835} 1836 1837static inline int iov_from_user32_to_kern(struct iovec *kiov, 1838 struct iovec32 *uiov32, 1839 int niov) 1840{ 1841 int tot_len = 0; 1842 1843 while(niov > 0) { 1844 u32 len, buf; 1845 1846 if(get_user(len, &uiov32->iov_len) || 1847 get_user(buf, &uiov32->iov_base)) { 1848 tot_len = -EFAULT; 1849 break; 1850 } 1851 tot_len += len; 1852 kiov->iov_base = (void *)A(buf); 1853 kiov->iov_len = (__kernel_size_t) len; 1854 uiov32++; 1855 kiov++; 1856 niov--; 1857 } 1858 return tot_len; 1859} 1860 1861static inline int msghdr_from_user32_to_kern(struct msghdr *kmsg, 1862 struct msghdr32 *umsg) 1863{ 1864 u32 tmp1, tmp2, tmp3; 1865 int err; 1866 1867 err = get_user(tmp1, &umsg->msg_name); 1868 err |= __get_user(tmp2, &umsg->msg_iov); 1869 err |= __get_user(tmp3, &umsg->msg_control); 1870 if (err) 1871 return -EFAULT; 1872 1873 kmsg->msg_name = (void *)A(tmp1); 1874 kmsg->msg_iov = (struct iovec *)A(tmp2); 1875 kmsg->msg_control = (void *)A(tmp3); 1876 1877 err = get_user(kmsg->msg_namelen, &umsg->msg_namelen); 1878 err |= get_user(kmsg->msg_iovlen, &umsg->msg_iovlen); 1879 err |= get_user(kmsg->msg_controllen, &umsg->msg_controllen); 1880 err |= get_user(kmsg->msg_flags, &umsg->msg_flags); 1881 1882 return err; 1883} 1884 1885/* I've named the args so it is easy to tell whose space the pointers are in. */ 1886static int verify_iovec32(struct msghdr *kern_msg, struct iovec *kern_iov, 1887 char *kern_address, int mode) 1888{ 1889 int tot_len; 1890 1891 if(kern_msg->msg_namelen) { 1892 if(mode==VERIFY_READ) { 1893 int err = move_addr_to_kernel(kern_msg->msg_name, 1894 kern_msg->msg_namelen, 1895 kern_address); 1896 if(err < 0) 1897 return err; 1898 } 1899 kern_msg->msg_name = kern_address; 1900 } else 1901 kern_msg->msg_name = NULL; 1902 1903 if(kern_msg->msg_iovlen > UIO_FASTIOV) { 1904 kern_iov = kmalloc(kern_msg->msg_iovlen * sizeof(struct iovec), 1905 GFP_KERNEL); 1906 if(!kern_iov) 1907 return -ENOMEM; 1908 } 1909 1910 tot_len = iov_from_user32_to_kern(kern_iov, 1911 (struct iovec32 *)kern_msg->msg_iov, 1912 kern_msg->msg_iovlen); 1913 if(tot_len >= 0) 1914 kern_msg->msg_iov = kern_iov; 1915 else if(kern_msg->msg_iovlen > UIO_FASTIOV) 1916 kfree(kern_iov); 1917 1918 return tot_len; 1919} 1920 1921/* There is a lot of hair here because the alignment rules (and 1922 * thus placement) of cmsg headers and length are different for 1923 * 32-bit apps. -DaveM 1924 */ 1925static int cmsghdr_from_user32_to_kern(struct msghdr *kmsg, 1926 unsigned char *stackbuf, int stackbuf_size) 1927{ 1928 struct cmsghdr32 *ucmsg; 1929 struct cmsghdr *kcmsg, *kcmsg_base; 1930 __kernel_size_t32 ucmlen; 1931 __kernel_size_t kcmlen, tmp; 1932 1933 kcmlen = 0; 1934 kcmsg_base = kcmsg = (struct cmsghdr *)stackbuf; 1935 ucmsg = CMSG32_FIRSTHDR(kmsg); 1936 while(ucmsg != NULL) { 1937 if(get_user(ucmlen, &ucmsg->cmsg_len)) 1938 return -EFAULT; 1939 1940 /* Catch bogons. */ 1941 if(CMSG32_ALIGN(ucmlen) < 1942 CMSG32_ALIGN(sizeof(struct cmsghdr32))) 1943 return -EINVAL; 1944 if((unsigned long)(((char *)ucmsg - (char *)kmsg->msg_control) 1945 + ucmlen) > kmsg->msg_controllen) 1946 return -EINVAL; 1947 1948 tmp = ((ucmlen - CMSG32_ALIGN(sizeof(*ucmsg))) + 1949 CMSG_ALIGN(sizeof(struct cmsghdr))); 1950 kcmlen += tmp; 1951 ucmsg = CMSG32_NXTHDR(kmsg, ucmsg, ucmlen); 1952 } 1953 if(kcmlen == 0) 1954 return -EINVAL; 1955 1956 /* The kcmlen holds the 64-bit version of the control length. 1957 * It may not be modified as we do not stick it into the kmsg 1958 * until we have successfully copied over all of the data 1959 * from the user. 1960 */ 1961 if(kcmlen > stackbuf_size) 1962 kcmsg_base = kcmsg = kmalloc(kcmlen, GFP_KERNEL); 1963 if(kcmsg == NULL) 1964 return -ENOBUFS; 1965 1966 /* Now copy them over neatly. */ 1967 memset(kcmsg, 0, kcmlen); 1968 ucmsg = CMSG32_FIRSTHDR(kmsg); 1969 while(ucmsg != NULL) { 1970 __get_user(ucmlen, &ucmsg->cmsg_len); 1971 tmp = ((ucmlen - CMSG32_ALIGN(sizeof(*ucmsg))) + 1972 CMSG_ALIGN(sizeof(struct cmsghdr))); 1973 kcmsg->cmsg_len = tmp; 1974 __get_user(kcmsg->cmsg_level, &ucmsg->cmsg_level); 1975 __get_user(kcmsg->cmsg_type, &ucmsg->cmsg_type); 1976 1977 /* Copy over the data. */ 1978 if(copy_from_user(CMSG_DATA(kcmsg), 1979 CMSG32_DATA(ucmsg), 1980 (ucmlen - CMSG32_ALIGN(sizeof(*ucmsg))))) 1981 goto out_free_efault; 1982 1983 /* Advance. */ 1984 kcmsg = (struct cmsghdr *)((char *)kcmsg + CMSG_ALIGN(tmp)); 1985 ucmsg = CMSG32_NXTHDR(kmsg, ucmsg, ucmlen); 1986 } 1987 1988 /* Ok, looks like we made it. Hook it up and return success. */ 1989 kmsg->msg_control = kcmsg_base; 1990 kmsg->msg_controllen = kcmlen; 1991 return 0; 1992 1993out_free_efault: 1994 if(kcmsg_base != (struct cmsghdr *)stackbuf) 1995 kfree(kcmsg_base); 1996 return -EFAULT; 1997} 1998 1999static void put_cmsg32(struct msghdr *kmsg, int level, int type, 2000 int len, void *data) 2001{ 2002 struct cmsghdr32 *cm = (struct cmsghdr32 *) kmsg->msg_control; 2003 struct cmsghdr32 cmhdr; 2004 int cmlen = CMSG32_LEN(len); 2005 2006 if(cm == NULL || kmsg->msg_controllen < sizeof(*cm)) { 2007 kmsg->msg_flags |= MSG_CTRUNC; 2008 return; 2009 } 2010 2011 if(kmsg->msg_controllen < cmlen) { 2012 kmsg->msg_flags |= MSG_CTRUNC; 2013 cmlen = kmsg->msg_controllen; 2014 } 2015 cmhdr.cmsg_level = level; 2016 cmhdr.cmsg_type = type; 2017 cmhdr.cmsg_len = cmlen; 2018 2019 if(copy_to_user(cm, &cmhdr, sizeof cmhdr)) 2020 return; 2021 if(copy_to_user(CMSG32_DATA(cm), data, cmlen - sizeof(struct cmsghdr32))) 2022 return; 2023 cmlen = CMSG32_SPACE(len); 2024 kmsg->msg_control += cmlen; 2025 kmsg->msg_controllen -= cmlen; 2026} 2027 2028static void scm_detach_fds32(struct msghdr *kmsg, struct scm_cookie *scm) 2029{ 2030 struct cmsghdr32 *cm = (struct cmsghdr32 *) kmsg->msg_control; 2031 int fdmax = (kmsg->msg_controllen - sizeof(struct cmsghdr32)) / sizeof(int); 2032 int fdnum = scm->fp->count; 2033 struct file **fp = scm->fp->fp; 2034 int *cmfptr; 2035 int err = 0, i; 2036 2037 if (fdnum < fdmax) 2038 fdmax = fdnum; 2039 2040 for (i = 0, cmfptr = (int *) CMSG32_DATA(cm); i < fdmax; i++, cmfptr++) { 2041 int new_fd; 2042 err = get_unused_fd(); 2043 if (err < 0) 2044 break; 2045 new_fd = err; 2046 err = put_user(new_fd, cmfptr); 2047 if (err) { 2048 put_unused_fd(new_fd); 2049 break; 2050 } 2051 /* Bump the usage count and install the file. */ 2052 get_file(fp[i]); 2053 fd_install(new_fd, fp[i]); 2054 } 2055 2056 if (i > 0) { 2057 int cmlen = CMSG32_LEN(i * sizeof(int)); 2058 if (!err) 2059 err = put_user(SOL_SOCKET, &cm->cmsg_level); 2060 if (!err) 2061 err = put_user(SCM_RIGHTS, &cm->cmsg_type); 2062 if (!err) 2063 err = put_user(cmlen, &cm->cmsg_len); 2064 if (!err) { 2065 cmlen = CMSG32_SPACE(i * sizeof(int)); 2066 kmsg->msg_control += cmlen; 2067 kmsg->msg_controllen -= cmlen; 2068 } 2069 } 2070 if (i < fdnum) 2071 kmsg->msg_flags |= MSG_CTRUNC; 2072 2073 /* 2074 * All of the files that fit in the message have had their 2075 * usage counts incremented, so we just free the list. 2076 */ 2077 __scm_destroy(scm); 2078} 2079 2080/* In these cases we (currently) can just copy to data over verbatim 2081 * because all CMSGs created by the kernel have well defined types which 2082 * have the same layout in both the 32-bit and 64-bit API. One must add 2083 * some special cased conversions here if we start sending control messages 2084 * with incompatible types. 2085 * 2086 * SCM_RIGHTS and SCM_CREDENTIALS are done by hand in recvmsg32 right after 2087 * we do our work. The remaining cases are: 2088 * 2089 * SOL_IP IP_PKTINFO struct in_pktinfo 32-bit clean 2090 * IP_TTL int 32-bit clean 2091 * IP_TOS __u8 32-bit clean 2092 * IP_RECVOPTS variable length 32-bit clean 2093 * IP_RETOPTS variable length 32-bit clean 2094 * (these last two are clean because the types are defined 2095 * by the IPv4 protocol) 2096 * IP_RECVERR struct sock_extended_err + 2097 * struct sockaddr_in 32-bit clean 2098 * SOL_IPV6 IPV6_RECVERR struct sock_extended_err + 2099 * struct sockaddr_in6 32-bit clean 2100 * IPV6_PKTINFO struct in6_pktinfo 32-bit clean 2101 * IPV6_HOPLIMIT int 32-bit clean 2102 * IPV6_FLOWINFO u32 32-bit clean 2103 * IPV6_HOPOPTS ipv6 hop exthdr 32-bit clean 2104 * IPV6_DSTOPTS ipv6 dst exthdr(s) 32-bit clean 2105 * IPV6_RTHDR ipv6 routing exthdr 32-bit clean 2106 * IPV6_AUTHHDR ipv6 auth exthdr 32-bit clean 2107 */ 2108static void cmsg32_recvmsg_fixup(struct msghdr *kmsg, unsigned long orig_cmsg_uptr) 2109{ 2110 unsigned char *workbuf, *wp; 2111 unsigned long bufsz, space_avail; 2112 struct cmsghdr *ucmsg; 2113 2114 bufsz = ((unsigned long)kmsg->msg_control) - orig_cmsg_uptr; 2115 space_avail = kmsg->msg_controllen + bufsz; 2116 wp = workbuf = kmalloc(bufsz, GFP_KERNEL); 2117 if(workbuf == NULL) 2118 goto fail; 2119 2120 /* To make this more sane we assume the kernel sends back properly 2121 * formatted control messages. Because of how the kernel will truncate 2122 * the cmsg_len for MSG_TRUNC cases, we need not check that case either. 2123 */ 2124 ucmsg = (struct cmsghdr *) orig_cmsg_uptr; 2125 while(((unsigned long)ucmsg) <= 2126 (((unsigned long)kmsg->msg_control) - sizeof(struct cmsghdr))) { 2127 struct cmsghdr32 *kcmsg32 = (struct cmsghdr32 *) wp; 2128 int clen64, clen32; 2129 2130 /* UCMSG is the 64-bit format CMSG entry in user-space. 2131 * KCMSG32 is within the kernel space temporary buffer 2132 * we use to convert into a 32-bit style CMSG. 2133 */ 2134 __get_user(kcmsg32->cmsg_len, &ucmsg->cmsg_len); 2135 __get_user(kcmsg32->cmsg_level, &ucmsg->cmsg_level); 2136 __get_user(kcmsg32->cmsg_type, &ucmsg->cmsg_type); 2137 2138 clen64 = kcmsg32->cmsg_len; 2139 copy_from_user(CMSG32_DATA(kcmsg32), CMSG_DATA(ucmsg), 2140 clen64 - CMSG_ALIGN(sizeof(*ucmsg))); 2141 clen32 = ((clen64 - CMSG_ALIGN(sizeof(*ucmsg))) + 2142 CMSG32_ALIGN(sizeof(struct cmsghdr32))); 2143 kcmsg32->cmsg_len = clen32; 2144 2145 ucmsg = (struct cmsghdr *) (((char *)ucmsg) + CMSG_ALIGN(clen64)); 2146 wp = (((char *)kcmsg32) + CMSG32_ALIGN(clen32)); 2147 } 2148 2149 /* Copy back fixed up data, and adjust pointers. */ 2150 bufsz = (wp - workbuf); 2151 copy_to_user((void *)orig_cmsg_uptr, workbuf, bufsz); 2152 2153 kmsg->msg_control = (struct cmsghdr *) 2154 (((char *)orig_cmsg_uptr) + bufsz); 2155 kmsg->msg_controllen = space_avail - bufsz; 2156 2157 kfree(workbuf); 2158 return; 2159 2160fail: 2161 /* If we leave the 64-bit format CMSG chunks in there, 2162 * the application could get confused and crash. So to 2163 * ensure greater recovery, we report no CMSGs. 2164 */ 2165 kmsg->msg_controllen += bufsz; 2166 kmsg->msg_control = (void *) orig_cmsg_uptr; 2167} 2168 2169asmlinkage int sys32_sendmsg(int fd, struct msghdr32 *user_msg, unsigned user_flags) 2170{ 2171 struct socket *sock; 2172 char address[MAX_SOCK_ADDR]; 2173 struct iovec iov[UIO_FASTIOV]; 2174 unsigned char ctl[sizeof(struct cmsghdr) + 20]; 2175 unsigned char *ctl_buf = ctl; 2176 struct msghdr kern_msg; 2177 int err, total_len; 2178 2179 if(msghdr_from_user32_to_kern(&kern_msg, user_msg)) 2180 return -EFAULT; 2181 if(kern_msg.msg_iovlen > UIO_MAXIOV) 2182 return -EINVAL; 2183 err = verify_iovec32(&kern_msg, iov, address, VERIFY_READ); 2184 if (err < 0) 2185 goto out; 2186 total_len = err; 2187 2188 if(kern_msg.msg_controllen) { 2189 err = cmsghdr_from_user32_to_kern(&kern_msg, ctl, sizeof(ctl)); 2190 if(err) 2191 goto out_freeiov; 2192 ctl_buf = kern_msg.msg_control; 2193 } 2194 kern_msg.msg_flags = user_flags; 2195 2196 sock = sockfd_lookup(fd, &err); 2197 if (sock != NULL) { 2198 if (sock->file->f_flags & O_NONBLOCK) 2199 kern_msg.msg_flags |= MSG_DONTWAIT; 2200 err = sock_sendmsg(sock, &kern_msg, total_len); 2201 sockfd_put(sock); 2202 } 2203 2204 /* N.B. Use kfree here, as kern_msg.msg_controllen might change? */ 2205 if(ctl_buf != ctl) 2206 kfree(ctl_buf); 2207out_freeiov: 2208 if(kern_msg.msg_iov != iov) 2209 kfree(kern_msg.msg_iov); 2210out: 2211 return err; 2212} 2213 2214asmlinkage int sys32_recvmsg(int fd, struct msghdr32 *user_msg, unsigned int user_flags) 2215{ 2216 struct iovec iovstack[UIO_FASTIOV]; 2217 struct msghdr kern_msg; 2218 char addr[MAX_SOCK_ADDR]; 2219 struct socket *sock; 2220 struct iovec *iov = iovstack; 2221 struct sockaddr *uaddr; 2222 int *uaddr_len; 2223 unsigned long cmsg_ptr; 2224 int err, total_len, len = 0; 2225 2226 if(msghdr_from_user32_to_kern(&kern_msg, user_msg)) 2227 return -EFAULT; 2228 if(kern_msg.msg_iovlen > UIO_MAXIOV) 2229 return -EINVAL; 2230 2231 uaddr = kern_msg.msg_name; 2232 uaddr_len = &user_msg->msg_namelen; 2233 err = verify_iovec32(&kern_msg, iov, addr, VERIFY_WRITE); 2234 if (err < 0) 2235 goto out; 2236 total_len = err; 2237 2238 cmsg_ptr = (unsigned long) kern_msg.msg_control; 2239 kern_msg.msg_flags = 0; 2240 2241 sock = sockfd_lookup(fd, &err); 2242 if (sock != NULL) { 2243 struct scm_cookie scm; 2244 2245 if (sock->file->f_flags & O_NONBLOCK) 2246 user_flags |= MSG_DONTWAIT; 2247 memset(&scm, 0, sizeof(scm)); 2248 err = sock->ops->recvmsg(sock, &kern_msg, total_len, 2249 user_flags, &scm); 2250 if(err >= 0) { 2251 len = err; 2252 if(!kern_msg.msg_control) { 2253 if(sock->passcred || scm.fp) 2254 kern_msg.msg_flags |= MSG_CTRUNC; 2255 if(scm.fp) 2256 __scm_destroy(&scm); 2257 } else { 2258 /* If recvmsg processing itself placed some 2259 * control messages into user space, it's is 2260 * using 64-bit CMSG processing, so we need 2261 * to fix it up before we tack on more stuff. 2262 */ 2263 if((unsigned long) kern_msg.msg_control != cmsg_ptr) 2264 cmsg32_recvmsg_fixup(&kern_msg, cmsg_ptr); 2265 2266 /* Wheee... */ 2267 if(sock->passcred) 2268 put_cmsg32(&kern_msg, 2269 SOL_SOCKET, SCM_CREDENTIALS, 2270 sizeof(scm.creds), &scm.creds); 2271 if(scm.fp != NULL) 2272 scm_detach_fds32(&kern_msg, &scm); 2273 } 2274 } 2275 sockfd_put(sock); 2276 } 2277 2278 if(uaddr != NULL && err >= 0) 2279 err = move_addr_to_user(addr, kern_msg.msg_namelen, uaddr, uaddr_len); 2280 if(cmsg_ptr != 0 && err >= 0) { 2281 unsigned long ucmsg_ptr = ((unsigned long)kern_msg.msg_control); 2282 __kernel_size_t32 uclen = (__kernel_size_t32) (ucmsg_ptr - cmsg_ptr); 2283 err |= __put_user(uclen, &user_msg->msg_controllen); 2284 } 2285 if(err >= 0) 2286 err = __put_user(kern_msg.msg_flags, &user_msg->msg_flags); 2287 if(kern_msg.msg_iov != iov) 2288 kfree(kern_msg.msg_iov); 2289out: 2290 if(err < 0) 2291 return err; 2292 return len; 2293} 2294 2295 2296extern asmlinkage int sys_setsockopt(int fd, int level, int optname, 2297 char *optval, int optlen); 2298 2299static int do_set_attach_filter(int fd, int level, int optname, 2300 char *optval, int optlen) 2301{ 2302 struct sock_fprog32 { 2303 __u16 len; 2304 __u32 filter; 2305 } *fprog32 = (struct sock_fprog32 *)optval; 2306 struct sock_fprog kfprog; 2307 struct sock_filter *kfilter; 2308 unsigned int fsize; 2309 mm_segment_t old_fs; 2310 __u32 uptr; 2311 int ret; 2312 2313 if (get_user(kfprog.len, &fprog32->len) || 2314 __get_user(uptr, &fprog32->filter)) 2315 return -EFAULT; 2316 2317 kfprog.filter = (struct sock_filter *)A(uptr); 2318 fsize = kfprog.len * sizeof(struct sock_filter); 2319 2320 kfilter = (struct sock_filter *)kmalloc(fsize, GFP_KERNEL); 2321 if (kfilter == NULL) 2322 return -ENOMEM; 2323 2324 if (copy_from_user(kfilter, kfprog.filter, fsize)) { 2325 kfree(kfilter); 2326 return -EFAULT; 2327 } 2328 2329 kfprog.filter = kfilter; 2330 2331 old_fs = get_fs(); 2332 set_fs(KERNEL_DS); 2333 ret = sys_setsockopt(fd, level, optname, 2334 (char *)&kfprog, sizeof(kfprog)); 2335 set_fs(old_fs); 2336 2337 kfree(kfilter); 2338 2339 return ret; 2340} 2341 2342static int do_set_icmpv6_filter(int fd, int level, int optname, 2343 char *optval, int optlen) 2344{ 2345 struct icmp6_filter kfilter; 2346 mm_segment_t old_fs; 2347 int ret, i; 2348 2349 if (copy_from_user(&kfilter, optval, sizeof(kfilter))) 2350 return -EFAULT; 2351 2352 2353 for (i = 0; i < 8; i += 2) { 2354 u32 tmp = kfilter.data[i]; 2355 2356 kfilter.data[i] = kfilter.data[i + 1]; 2357 kfilter.data[i + 1] = tmp; 2358 } 2359 2360 old_fs = get_fs(); 2361 set_fs(KERNEL_DS); 2362 ret = sys_setsockopt(fd, level, optname, 2363 (char *) &kfilter, sizeof(kfilter)); 2364 set_fs(old_fs); 2365 2366 return ret; 2367} 2368 2369 2370static int do_ipv4_set_replace(int fd, int level, int optname, 2371 char *optval, int optlen) 2372/* Fields happen to be padded such that this works. 2373** Don't need to change iptables.h:struct ipt_replace 2374*/ 2375{ 2376 struct ipt_replace *repl = (struct ipt_replace *) optval; 2377 unsigned long ptr64; 2378 unsigned int ptr32; 2379 int ret; 2380 2381 if (copy_from_user(&ptr32, &repl->counters, sizeof(ptr32))) 2382 return -EFAULT; 2383 ptr64 = (unsigned long) ptr32; 2384 if (copy_to_user(&repl->counters, &ptr64, sizeof(ptr64))) 2385 return -EFAULT; 2386 2387 ret = sys_setsockopt(fd, level, optname, (char *) optval, optlen); 2388 2389 /* Restore 32-bit ptr */ 2390 if (copy_to_user(&repl->counters, &ptr32, sizeof(ptr32))) 2391 return -EFAULT; 2392 2393 return ret; 2394} 2395 2396 2397asmlinkage int sys32_setsockopt(int fd, int level, int optname, 2398 char *optval, int optlen) 2399{ 2400 if (optname == SO_ATTACH_FILTER) 2401 return do_set_attach_filter(fd, level, optname, optval, optlen); 2402 2403 if (level == SOL_ICMPV6 && optname == ICMPV6_FILTER) 2404 return do_set_icmpv6_filter(fd, level, optname, optval, optlen); 2405 2406 /* 2407 ** Beware: IPT_SO_SET_REPLACE == IP6T_SO_SET_REPLACE 2408 */ 2409 if (level == IPPROTO_IP && optname == IPT_SO_SET_REPLACE) 2410 return do_ipv4_set_replace(fd, level, optname, optval, optlen); 2411 2412 if (level == IPPROTO_IPV6 && optname == IP6T_SO_SET_REPLACE) 2413 { 2414 BUG(); 2415 return -ENXIO; 2416 } 2417 2418 return sys_setsockopt(fd, level, optname, optval, optlen); 2419} 2420 2421 2422/*** copied from mips64 ***/ 2423/* 2424 * Ooo, nasty. We need here to frob 32-bit unsigned longs to 2425 * 64-bit unsigned longs. 2426 */ 2427 2428static inline int 2429get_fd_set32(unsigned long n, u32 *ufdset, unsigned long *fdset) 2430{ 2431 n = (n + 8*sizeof(u32) - 1) / (8*sizeof(u32)); 2432 if (ufdset) { 2433 unsigned long odd; 2434 2435 if (verify_area(VERIFY_WRITE, ufdset, n*sizeof(u32))) 2436 return -EFAULT; 2437 2438 odd = n & 1UL; 2439 n &= ~1UL; 2440 while (n) { 2441 unsigned long h, l; 2442 __get_user(l, ufdset); 2443 __get_user(h, ufdset+1); 2444 ufdset += 2; 2445 *fdset++ = h << 32 | l; 2446 n -= 2; 2447 } 2448 if (odd) 2449 __get_user(*fdset, ufdset); 2450 } else { 2451 /* Tricky, must clear full unsigned long in the 2452 * kernel fdset at the end, this makes sure that 2453 * actually happens. 2454 */ 2455 memset(fdset, 0, ((n + 1) & ~1)*sizeof(u32)); 2456 } 2457 return 0; 2458} 2459 2460static inline void 2461set_fd_set32(unsigned long n, u32 *ufdset, unsigned long *fdset) 2462{ 2463 unsigned long odd; 2464 n = (n + 8*sizeof(u32) - 1) / (8*sizeof(u32)); 2465 2466 if (!ufdset) 2467 return; 2468 2469 odd = n & 1UL; 2470 n &= ~1UL; 2471 while (n) { 2472 unsigned long h, l; 2473 l = *fdset++; 2474 h = l >> 32; 2475 __put_user(l, ufdset); 2476 __put_user(h, ufdset+1); 2477 ufdset += 2; 2478 n -= 2; 2479 } 2480 if (odd) 2481 __put_user(*fdset, ufdset); 2482} 2483 2484/*** This is a virtual copy of sys_select from fs/select.c and probably 2485 *** should be compared to it from time to time 2486 ***/ 2487static inline void *select_bits_alloc(int size) 2488{ 2489 return kmalloc(6 * size, GFP_KERNEL); 2490} 2491 2492static inline void select_bits_free(void *bits, int size) 2493{ 2494 kfree(bits); 2495} 2496 2497/* 2498 * We can actually return ERESTARTSYS instead of EINTR, but I'd 2499 * like to be certain this leads to no problems. So I return 2500 * EINTR just for safety. 2501 * 2502 * Update: ERESTARTSYS breaks at least the xview clock binary, so 2503 * I'm trying ERESTARTNOHAND which restart only when you want to. 2504 */ 2505#define MAX_SELECT_SECONDS \ 2506 ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1) 2507#define DIVIDE_ROUND_UP(x,y) (((x)+(y)-1)/(y)) 2508 2509asmlinkage long 2510sys32_select(int n, u32 *inp, u32 *outp, u32 *exp, struct timeval32 *tvp) 2511{ 2512 fd_set_bits fds; 2513 char *bits; 2514 long timeout; 2515 int ret, size, err; 2516 2517 timeout = MAX_SCHEDULE_TIMEOUT; 2518 if (tvp) { 2519 struct timeval32 tv32; 2520 time_t sec, usec; 2521 2522 if ((ret = copy_from_user(&tv32, tvp, sizeof tv32))) 2523 goto out_nofds; 2524 2525 sec = tv32.tv_sec; 2526 usec = tv32.tv_usec; 2527 2528 ret = -EINVAL; 2529 if (sec < 0 || usec < 0) 2530 goto out_nofds; 2531 2532 if ((unsigned long) sec < MAX_SELECT_SECONDS) { 2533 timeout = DIVIDE_ROUND_UP(usec, 1000000/HZ); 2534 timeout += sec * (unsigned long) HZ; 2535 } 2536 } 2537 2538 ret = -EINVAL; 2539 if (n < 0) 2540 goto out_nofds; 2541 2542 if (n > current->files->max_fdset) 2543 n = current->files->max_fdset; 2544 2545 /* 2546 * We need 6 bitmaps (in/out/ex for both incoming and outgoing), 2547 * since we used fdset we need to allocate memory in units of 2548 * long-words. 2549 */ 2550 ret = -ENOMEM; 2551 size = FDS_BYTES(n); 2552 bits = select_bits_alloc(size); 2553 if (!bits) 2554 goto out_nofds; 2555 fds.in = (unsigned long *) bits; 2556 fds.out = (unsigned long *) (bits + size); 2557 fds.ex = (unsigned long *) (bits + 2*size); 2558 fds.res_in = (unsigned long *) (bits + 3*size); 2559 fds.res_out = (unsigned long *) (bits + 4*size); 2560 fds.res_ex = (unsigned long *) (bits + 5*size); 2561 2562 if ((ret = get_fd_set32(n, inp, fds.in)) || 2563 (ret = get_fd_set32(n, outp, fds.out)) || 2564 (ret = get_fd_set32(n, exp, fds.ex))) 2565 goto out; 2566 zero_fd_set(n, fds.res_in); 2567 zero_fd_set(n, fds.res_out); 2568 zero_fd_set(n, fds.res_ex); 2569 2570 ret = do_select(n, &fds, &timeout); 2571 2572 if (tvp && !(current->personality & STICKY_TIMEOUTS)) { 2573 time_t sec = 0, usec = 0; 2574 if (timeout) { 2575 sec = timeout / HZ; 2576 usec = timeout % HZ; 2577 usec *= (1000000/HZ); 2578 } 2579 err = put_user(sec, &tvp->tv_sec); 2580 err |= __put_user(usec, &tvp->tv_usec); 2581 if (err) 2582 ret = -EFAULT; 2583 } 2584 2585 if (ret < 0) 2586 goto out; 2587 if (!ret) { 2588 ret = -ERESTARTNOHAND; 2589 if (signal_pending(current)) 2590 goto out; 2591 ret = 0; 2592 } 2593 2594 set_fd_set32(n, inp, fds.res_in); 2595 set_fd_set32(n, outp, fds.res_out); 2596 set_fd_set32(n, exp, fds.res_ex); 2597 2598out: 2599 select_bits_free(bits, size); 2600out_nofds: 2601 return ret; 2602} 2603 2604struct msgbuf32 { 2605 int mtype; 2606 char mtext[1]; 2607}; 2608 2609asmlinkage long sys32_msgsnd(int msqid, 2610 struct msgbuf32 *umsgp32, 2611 size_t msgsz, int msgflg) 2612{ 2613 struct msgbuf *mb; 2614 struct msgbuf32 mb32; 2615 int err; 2616 2617 if ((mb = kmalloc(msgsz + sizeof *mb + 4, GFP_KERNEL)) == NULL) 2618 return -ENOMEM; 2619 2620 err = get_user(mb32.mtype, &umsgp32->mtype); 2621 mb->mtype = mb32.mtype; 2622 err |= copy_from_user(mb->mtext, &umsgp32->mtext, msgsz); 2623 2624 if (err) 2625 err = -EFAULT; 2626 else 2627 KERNEL_SYSCALL(err, sys_msgsnd, msqid, mb, msgsz, msgflg); 2628 2629 kfree(mb); 2630 return err; 2631} 2632 2633asmlinkage long sys32_msgrcv(int msqid, 2634 struct msgbuf32 *umsgp32, 2635 size_t msgsz, long msgtyp, int msgflg) 2636{ 2637 struct msgbuf *mb; 2638 struct msgbuf32 mb32; 2639 int err, len; 2640 2641 if ((mb = kmalloc(msgsz + sizeof *mb + 4, GFP_KERNEL)) == NULL) 2642 return -ENOMEM; 2643 2644 KERNEL_SYSCALL(err, sys_msgrcv, msqid, mb, msgsz, msgtyp, msgflg); 2645 2646 if (err >= 0) { 2647 len = err; 2648 mb32.mtype = mb->mtype; 2649 err = put_user(mb32.mtype, &umsgp32->mtype); 2650 err |= copy_to_user(&umsgp32->mtext, mb->mtext, len); 2651 if (err) 2652 err = -EFAULT; 2653 else 2654 err = len; 2655 } 2656 2657 kfree(mb); 2658 return err; 2659} 2660 2661/* LFS */ 2662 2663extern asmlinkage long sys_truncate(const char *, loff_t); 2664extern asmlinkage long sys_ftruncate(unsigned int, loff_t); 2665extern asmlinkage long sys_fcntl(unsigned int, unsigned int, unsigned long); 2666extern asmlinkage ssize_t sys_pread(unsigned int, char *, size_t, loff_t); 2667extern asmlinkage ssize_t sys_pwrite(unsigned int, char *, size_t, loff_t); 2668 2669asmlinkage long sys32_truncate64(const char * path, unsigned int high, unsigned int low) 2670{ 2671 return sys_truncate(path, (loff_t)high << 32 | low); 2672} 2673 2674asmlinkage long sys32_ftruncate64(unsigned int fd, unsigned int high, unsigned int low) 2675{ 2676 return sys_ftruncate(fd, (loff_t)high << 32 | low); 2677} 2678 2679asmlinkage long sys32_fcntl64(unsigned int fd, unsigned int cmd, unsigned long arg) 2680{ 2681 switch (cmd) { 2682 case F_GETLK64: 2683 cmd = F_GETLK; 2684 break; 2685 case F_SETLK64: 2686 cmd = F_SETLK; 2687 break; 2688 case F_SETLKW64: 2689 cmd = F_SETLKW; 2690 break; 2691 default: 2692 break; 2693 } 2694 return sys_fcntl(fd, cmd, arg); 2695} 2696 2697asmlinkage int sys32_pread(int fd, void *buf, size_t count, unsigned int high, unsigned int low) 2698{ 2699 return sys_pread(fd, buf, count, (loff_t)high << 32 | low); 2700} 2701 2702asmlinkage int sys32_pwrite(int fd, void *buf, size_t count, unsigned int high, unsigned int low) 2703{ 2704 return sys_pwrite(fd, buf, count, (loff_t)high << 32 | low); 2705} 2706 2707/* EXPORT/UNEXPORT */ 2708struct nfsctl_export32 { 2709 char ex_client[NFSCLNT_IDMAX+1]; 2710 char ex_path[NFS_MAXPATHLEN+1]; 2711 __kernel_dev_t ex_dev; 2712 __kernel_ino_t32 ex_ino; 2713 int ex_flags; 2714 __kernel_uid_t ex_anon_uid; 2715 __kernel_gid_t ex_anon_gid; 2716}; 2717 2718/* GETFH */ 2719struct nfsctl_fhparm32 { 2720 struct sockaddr gf_addr; 2721 __kernel_dev_t gf_dev; 2722 __kernel_ino_t32 gf_ino; 2723 int gf_version; 2724}; 2725 2726/* UGIDUPDATE */ 2727struct nfsctl_uidmap32 { 2728 __kernel_caddr_t32 ug_ident; 2729 __kernel_uid_t ug_uidbase; 2730 int ug_uidlen; 2731 __kernel_caddr_t32 ug_udimap; 2732 __kernel_gid_t ug_gidbase; 2733 int ug_gidlen; 2734 __kernel_caddr_t32 ug_gdimap; 2735}; 2736 2737struct nfsctl_arg32 { 2738 int ca_version; /* safeguard */ 2739 /* wide kernel places this union on 8-byte boundary, narrow on 4 */ 2740 union { 2741 struct nfsctl_svc u_svc; 2742 struct nfsctl_client u_client; 2743 struct nfsctl_export32 u_export; 2744 struct nfsctl_uidmap32 u_umap; 2745 struct nfsctl_fhparm32 u_getfh; 2746 struct nfsctl_fdparm u_getfd; 2747 struct nfsctl_fsparm u_getfs; 2748 } u; 2749}; 2750 2751asmlinkage int sys32_nfsservctl(int cmd, void *argp, void *resp) 2752{ 2753 int ret, tmp; 2754 struct nfsctl_arg32 n32; 2755 struct nfsctl_arg n; 2756 2757 ret = copy_from_user(&n, argp, sizeof n.ca_version); 2758 if (ret != 0) 2759 return ret; 2760 2761 /* adjust argp to point at the union inside the user's n32 struct */ 2762 tmp = (unsigned long)&n32.u - (unsigned long)&n32; 2763 argp = (void *)((unsigned long)argp + tmp); 2764 switch(cmd) { 2765 case NFSCTL_SVC: 2766 ret = copy_from_user(&n.u, argp, sizeof n.u.u_svc); 2767 break; 2768 2769 case NFSCTL_ADDCLIENT: 2770 case NFSCTL_DELCLIENT: 2771 ret = copy_from_user(&n.u, argp, sizeof n.u.u_client); 2772 break; 2773 2774 case NFSCTL_GETFD: 2775 ret = copy_from_user(&n.u, argp, sizeof n.u.u_getfd); 2776 break; 2777 2778 case NFSCTL_GETFS: 2779 ret = copy_from_user(&n.u, argp, sizeof n.u.u_getfs); 2780 break; 2781 2782 case NFSCTL_GETFH: /* nfsctl_fhparm */ 2783 ret = copy_from_user(&n32.u, argp, sizeof n32.u.u_getfh); 2784#undef CP 2785#define CP(x) n.u.u_getfh.gf_##x = n32.u.u_getfh.gf_##x 2786 CP(addr); 2787 CP(dev); 2788 CP(ino); 2789 CP(version); 2790 break; 2791 2792 case NFSCTL_UGIDUPDATE: /* nfsctl_uidmap */ 2793 ret = copy_from_user(&n32.u, argp, sizeof n32.u.u_umap); 2794#undef CP 2795#define CP(x) n.u.u_umap.ug_##x = n32.u.u_umap.ug_##x 2796 n.u.u_umap.ug_ident = (char *)(u_long)n32.u.u_umap.ug_ident; 2797 CP(uidbase); 2798 CP(uidlen); 2799 n.u.u_umap.ug_udimap = (__kernel_uid_t *)(u_long)n32.u.u_umap.ug_udimap; 2800 CP(gidbase); 2801 CP(gidlen); 2802 n.u.u_umap.ug_gdimap = (__kernel_gid_t *)(u_long)n32.u.u_umap.ug_gdimap; 2803 break; 2804 2805 case NFSCTL_UNEXPORT: /* nfsctl_export */ 2806 case NFSCTL_EXPORT: /* nfsctl_export */ 2807 ret = copy_from_user(&n32.u, argp, sizeof n32.u.u_export); 2808#undef CP 2809#define CP(x) n.u.u_export.ex_##x = n32.u.u_export.ex_##x 2810 memcpy(n.u.u_export.ex_client, n32.u.u_export.ex_client, sizeof n32.u.u_export.ex_client); 2811 memcpy(n.u.u_export.ex_path, n32.u.u_export.ex_path, sizeof n32.u.u_export.ex_path); 2812 CP(dev); 2813 CP(ino); 2814 CP(flags); 2815 CP(anon_uid); 2816 CP(anon_gid); 2817 break; 2818 2819 default: 2820 BUG(); /* new cmd values to be translated... */ 2821 ret = -EINVAL; 2822 break; 2823 } 2824 2825 if (ret == 0) { 2826 unsigned char rbuf[NFS_FHSIZE + sizeof (struct knfsd_fh)]; 2827 KERNEL_SYSCALL(ret, sys_nfsservctl, cmd, &n, &rbuf); 2828 if (cmd == NFSCTL_GETFH || cmd == NFSCTL_GETFD) { 2829 ret = copy_to_user(resp, rbuf, NFS_FHSIZE); 2830 } else if (cmd == NFSCTL_GETFS) { 2831 ret = copy_to_user(resp, rbuf, sizeof (struct knfsd_fh)); 2832 } 2833 } 2834 2835 return ret; 2836} 2837 2838#include <linux/quota.h> 2839 2840struct dqblk32 { 2841 __u32 dqb_bhardlimit; 2842 __u32 dqb_bsoftlimit; 2843 __u32 dqb_curblocks; 2844 __u32 dqb_ihardlimit; 2845 __u32 dqb_isoftlimit; 2846 __u32 dqb_curinodes; 2847 __kernel_time_t32 dqb_btime; 2848 __kernel_time_t32 dqb_itime; 2849}; 2850 2851 2852asmlinkage int sys32_quotactl(int cmd, const char *special, int id, unsigned long addr) 2853{ 2854 extern int sys_quotactl(int cmd, const char *special, int id, caddr_t addr); 2855 int cmds = cmd >> SUBCMDSHIFT; 2856 int err; 2857 struct dqblk d; 2858 char *spec; 2859 2860 switch (cmds) { 2861 case Q_GETQUOTA: 2862 break; 2863 case Q_SETQUOTA: 2864 case Q_SETUSE: 2865 case Q_SETQLIM: 2866 if (copy_from_user (&d, (struct dqblk32 *)addr, 2867 sizeof (struct dqblk32))) 2868 return -EFAULT; 2869 d.dqb_itime = ((struct dqblk32 *)&d)->dqb_itime; 2870 d.dqb_btime = ((struct dqblk32 *)&d)->dqb_btime; 2871 break; 2872 default: 2873 return sys_quotactl(cmd, special, 2874 id, (caddr_t)addr); 2875 } 2876 spec = getname (special); 2877 err = PTR_ERR(spec); 2878 if (IS_ERR(spec)) return err; 2879 KERNEL_SYSCALL(err, sys_quotactl, cmd, (const char *)spec, id, (caddr_t)&d); 2880 putname (spec); 2881 if (cmds == Q_GETQUOTA) { 2882 __kernel_time_t b = d.dqb_btime, i = d.dqb_itime; 2883 ((struct dqblk32 *)&d)->dqb_itime = i; 2884 ((struct dqblk32 *)&d)->dqb_btime = b; 2885 if (copy_to_user ((struct dqblk32 *)addr, &d, 2886 sizeof (struct dqblk32))) 2887 return -EFAULT; 2888 } 2889 return err; 2890} 2891 2892struct timex32 { 2893 unsigned int modes; /* mode selector */ 2894 int offset; /* time offset (usec) */ 2895 int freq; /* frequency offset (scaled ppm) */ 2896 int maxerror; /* maximum error (usec) */ 2897 int esterror; /* estimated error (usec) */ 2898 int status; /* clock command/status */ 2899 int constant; /* pll time constant */ 2900 int precision; /* clock precision (usec) (read only) */ 2901 int tolerance; /* clock frequency tolerance (ppm) 2902 * (read only) 2903 */ 2904 struct timeval32 time; /* (read only) */ 2905 int tick; /* (modified) usecs between clock ticks */ 2906 2907 int ppsfreq; /* pps frequency (scaled ppm) (ro) */ 2908 int jitter; /* pps jitter (us) (ro) */ 2909 int shift; /* interval duration (s) (shift) (ro) */ 2910 int stabil; /* pps stability (scaled ppm) (ro) */ 2911 int jitcnt; /* jitter limit exceeded (ro) */ 2912 int calcnt; /* calibration intervals (ro) */ 2913 int errcnt; /* calibration errors (ro) */ 2914 int stbcnt; /* stability limit exceeded (ro) */ 2915 2916 int :32; int :32; int :32; int :32; 2917 int :32; int :32; int :32; int :32; 2918 int :32; int :32; int :32; int :32; 2919}; 2920 2921asmlinkage long sys32_adjtimex(struct timex32 *txc_p32) 2922{ 2923 struct timex txc; 2924 struct timex32 t32; 2925 int ret; 2926 extern int do_adjtimex(struct timex *txc); 2927 2928 if(copy_from_user(&t32, txc_p32, sizeof(struct timex32))) 2929 return -EFAULT; 2930#undef CP 2931#define CP(x) txc.x = t32.x 2932 CP(modes); CP(offset); CP(freq); CP(maxerror); CP(esterror); 2933 CP(status); CP(constant); CP(precision); CP(tolerance); 2934 CP(time.tv_sec); CP(time.tv_usec); CP(tick); CP(ppsfreq); CP(jitter); 2935 CP(shift); CP(stabil); CP(jitcnt); CP(calcnt); CP(errcnt); 2936 CP(stbcnt); 2937 ret = do_adjtimex(&txc); 2938#define CP(x) t32.x = txc.x 2939 CP(modes); CP(offset); CP(freq); CP(maxerror); CP(esterror); 2940 CP(status); CP(constant); CP(precision); CP(tolerance); 2941 CP(time.tv_sec); CP(time.tv_usec); CP(tick); CP(ppsfreq); CP(jitter); 2942 CP(shift); CP(stabil); CP(jitcnt); CP(calcnt); CP(errcnt); 2943 CP(stbcnt); 2944 return copy_to_user(txc_p32, &t32, sizeof(struct timex32)) ? -EFAULT : ret; 2945} 2946 2947 2948struct sysinfo32 { 2949 s32 uptime; 2950 u32 loads[3]; 2951 u32 totalram; 2952 u32 freeram; 2953 u32 sharedram; 2954 u32 bufferram; 2955 u32 totalswap; 2956 u32 freeswap; 2957 unsigned short procs; 2958 u32 totalhigh; 2959 u32 freehigh; 2960 u32 mem_unit; 2961 char _f[12]; 2962}; 2963 2964/* We used to call sys_sysinfo and translate the result. But sys_sysinfo 2965 * undoes the good work done elsewhere, and rather than undoing the 2966 * damage, I decided to just duplicate the code from sys_sysinfo here. 2967 */ 2968 2969asmlinkage int sys32_sysinfo(struct sysinfo32 *info) 2970{ 2971 struct sysinfo val; 2972 int err; 2973 2974 /* We don't need a memset here because we copy the 2975 * struct to userspace once element at a time. 2976 */ 2977 2978 cli(); 2979 val.uptime = jiffies / HZ; 2980 2981 val.loads[0] = avenrun[0] << (SI_LOAD_SHIFT - FSHIFT); 2982 val.loads[1] = avenrun[1] << (SI_LOAD_SHIFT - FSHIFT); 2983 val.loads[2] = avenrun[2] << (SI_LOAD_SHIFT - FSHIFT); 2984 2985 val.procs = nr_threads-1; 2986 sti(); 2987 2988 si_meminfo(&val); 2989 si_swapinfo(&val); 2990 2991 err = put_user (val.uptime, &info->uptime); 2992 err |= __put_user (val.loads[0], &info->loads[0]); 2993 err |= __put_user (val.loads[1], &info->loads[1]); 2994 err |= __put_user (val.loads[2], &info->loads[2]); 2995 err |= __put_user (val.totalram, &info->totalram); 2996 err |= __put_user (val.freeram, &info->freeram); 2997 err |= __put_user (val.sharedram, &info->sharedram); 2998 err |= __put_user (val.bufferram, &info->bufferram); 2999 err |= __put_user (val.totalswap, &info->totalswap); 3000 err |= __put_user (val.freeswap, &info->freeswap); 3001 err |= __put_user (val.procs, &info->procs); 3002 err |= __put_user (val.totalhigh, &info->totalhigh); 3003 err |= __put_user (val.freehigh, &info->freehigh); 3004 err |= __put_user (val.mem_unit, &info->mem_unit); 3005 return err ? -EFAULT : 0; 3006} 3007 3008 3009/* lseek() needs a wrapper because 'offset' can be negative, but the top 3010 * half of the argument has been zeroed by syscall.S. 3011 */ 3012 3013extern asmlinkage off_t sys_lseek(unsigned int fd, off_t offset, unsigned int origin); 3014 3015asmlinkage int sys32_lseek(unsigned int fd, int offset, unsigned int origin) 3016{ 3017 return sys_lseek(fd, offset, origin); 3018} 3019 3020asmlinkage long sys32_semctl_broken(int semid, int semnum, int cmd, union semun arg) 3021{ 3022 union semun u; 3023 3024 cmd &= ~IPC_64; /* should be removed together with the _broken suffix */ 3025 3026 if (cmd == SETVAL) { 3027 /* Ugh. arg is a union of int,ptr,ptr,ptr, so is 8 bytes. 3028 * The int should be in the first 4, but our argument 3029 * frobbing has left it in the last 4. 3030 */ 3031 u.val = *((int *)&arg + 1); 3032 return sys_semctl (semid, semnum, cmd, u); 3033 } 3034 return sys_semctl (semid, semnum, cmd, arg); 3035} 3036 3037