1/* 2 * linux/fs/compat.c 3 * 4 * Kernel compatibililty routines for e.g. 32 bit syscall support 5 * on 64 bit kernels. 6 * 7 * Copyright (C) 2002 Stephen Rothwell, IBM Corporation 8 * Copyright (C) 1997-2000 Jakub Jelinek (jakub@redhat.com) 9 * Copyright (C) 1998 Eddie C. Dost (ecd@skynet.be) 10 * Copyright (C) 2001,2002 Andi Kleen, SuSE Labs 11 * Copyright (C) 2003 Pavel Machek (pavel@suse.cz) 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License version 2 as 15 * published by the Free Software Foundation. 16 */ 17 18#include <linux/kernel.h> 19#include <linux/linkage.h> 20#include <linux/compat.h> 21#include <linux/errno.h> 22#include <linux/time.h> 23#include <linux/fs.h> 24#include <linux/fcntl.h> 25#include <linux/namei.h> 26#include <linux/file.h> 27#include <linux/vfs.h> 28#include <linux/ioctl.h> 29#include <linux/init.h> 30#include <linux/smb.h> 31#include <linux/smb_mount.h> 32#include <linux/ncp_mount.h> 33#include <linux/nfs4_mount.h> 34#include <linux/smp_lock.h> 35#include <linux/syscalls.h> 36#include <linux/ctype.h> 37#include <linux/module.h> 38#include <linux/dirent.h> 39#include <linux/fsnotify.h> 40#include <linux/highuid.h> 41#include <linux/sunrpc/svc.h> 42#include <linux/nfsd/nfsd.h> 43#include <linux/nfsd/syscall.h> 44#include <linux/personality.h> 45#include <linux/rwsem.h> 46#include <linux/tsacct_kern.h> 47#include <linux/security.h> 48#include <linux/highmem.h> 49#include <linux/signal.h> 50#include <linux/poll.h> 51#include <linux/mm.h> 52#include <linux/eventpoll.h> 53 54#include <asm/uaccess.h> 55#include <asm/mmu_context.h> 56#include <asm/ioctls.h> 57#include "internal.h" 58 59int compat_log = 1; 60 61int compat_printk(const char *fmt, ...) 62{ 63 va_list ap; 64 int ret; 65 if (!compat_log) 66 return 0; 67 va_start(ap, fmt); 68 ret = vprintk(fmt, ap); 69 va_end(ap); 70 return ret; 71} 72 73#include "read_write.h" 74 75/* 76 * Not all architectures have sys_utime, so implement this in terms 77 * of sys_utimes. 78 */ 79asmlinkage long compat_sys_utime(char __user *filename, struct compat_utimbuf __user *t) 80{ 81 struct timespec tv[2]; 82 83 if (t) { 84 if (get_user(tv[0].tv_sec, &t->actime) || 85 get_user(tv[1].tv_sec, &t->modtime)) 86 return -EFAULT; 87 tv[0].tv_nsec = 0; 88 tv[1].tv_nsec = 0; 89 } 90 return do_utimes(AT_FDCWD, filename, t ? tv : NULL, 0); 91} 92 93asmlinkage long compat_sys_utimensat(unsigned int dfd, char __user *filename, struct compat_timespec __user *t, int flags) 94{ 95 struct timespec tv[2]; 96 97 if (t) { 98 if (get_compat_timespec(&tv[0], &t[0]) || 99 get_compat_timespec(&tv[1], &t[1])) 100 return -EFAULT; 101 102 if ((tv[0].tv_nsec == UTIME_OMIT || tv[0].tv_nsec == UTIME_NOW) 103 && tv[0].tv_sec != 0) 104 return -EINVAL; 105 if ((tv[1].tv_nsec == UTIME_OMIT || tv[1].tv_nsec == UTIME_NOW) 106 && tv[1].tv_sec != 0) 107 return -EINVAL; 108 109 if (tv[0].tv_nsec == UTIME_OMIT && tv[1].tv_nsec == UTIME_OMIT) 110 return 0; 111 } 112 return do_utimes(dfd, filename, t ? tv : NULL, flags); 113} 114 115asmlinkage long compat_sys_futimesat(unsigned int dfd, char __user *filename, struct compat_timeval __user *t) 116{ 117 struct timespec tv[2]; 118 119 if (t) { 120 if (get_user(tv[0].tv_sec, &t[0].tv_sec) || 121 get_user(tv[0].tv_nsec, &t[0].tv_usec) || 122 get_user(tv[1].tv_sec, &t[1].tv_sec) || 123 get_user(tv[1].tv_nsec, &t[1].tv_usec)) 124 return -EFAULT; 125 if (tv[0].tv_nsec >= 1000000 || tv[0].tv_nsec < 0 || 126 tv[1].tv_nsec >= 1000000 || tv[1].tv_nsec < 0) 127 return -EINVAL; 128 tv[0].tv_nsec *= 1000; 129 tv[1].tv_nsec *= 1000; 130 } 131 return do_utimes(dfd, filename, t ? tv : NULL, 0); 132} 133 134asmlinkage long compat_sys_utimes(char __user *filename, struct compat_timeval __user *t) 135{ 136 return compat_sys_futimesat(AT_FDCWD, filename, t); 137} 138 139asmlinkage long compat_sys_newstat(char __user * filename, 140 struct compat_stat __user *statbuf) 141{ 142 struct kstat stat; 143 int error = vfs_stat_fd(AT_FDCWD, filename, &stat); 144 145 if (!error) 146 error = cp_compat_stat(&stat, statbuf); 147 return error; 148} 149 150asmlinkage long compat_sys_newlstat(char __user * filename, 151 struct compat_stat __user *statbuf) 152{ 153 struct kstat stat; 154 int error = vfs_lstat_fd(AT_FDCWD, filename, &stat); 155 156 if (!error) 157 error = cp_compat_stat(&stat, statbuf); 158 return error; 159} 160 161#ifndef __ARCH_WANT_STAT64 162asmlinkage long compat_sys_newfstatat(unsigned int dfd, char __user *filename, 163 struct compat_stat __user *statbuf, int flag) 164{ 165 struct kstat stat; 166 int error = -EINVAL; 167 168 if ((flag & ~AT_SYMLINK_NOFOLLOW) != 0) 169 goto out; 170 171 if (flag & AT_SYMLINK_NOFOLLOW) 172 error = vfs_lstat_fd(dfd, filename, &stat); 173 else 174 error = vfs_stat_fd(dfd, filename, &stat); 175 176 if (!error) 177 error = cp_compat_stat(&stat, statbuf); 178 179out: 180 return error; 181} 182#endif 183 184asmlinkage long compat_sys_newfstat(unsigned int fd, 185 struct compat_stat __user * statbuf) 186{ 187 struct kstat stat; 188 int error = vfs_fstat(fd, &stat); 189 190 if (!error) 191 error = cp_compat_stat(&stat, statbuf); 192 return error; 193} 194 195static int put_compat_statfs(struct compat_statfs __user *ubuf, struct kstatfs *kbuf) 196{ 197 198 if (sizeof ubuf->f_blocks == 4) { 199 if ((kbuf->f_blocks | kbuf->f_bfree | kbuf->f_bavail) & 200 0xffffffff00000000ULL) 201 return -EOVERFLOW; 202 /* f_files and f_ffree may be -1; it's okay 203 * to stuff that into 32 bits */ 204 if (kbuf->f_files != 0xffffffffffffffffULL 205 && (kbuf->f_files & 0xffffffff00000000ULL)) 206 return -EOVERFLOW; 207 if (kbuf->f_ffree != 0xffffffffffffffffULL 208 && (kbuf->f_ffree & 0xffffffff00000000ULL)) 209 return -EOVERFLOW; 210 } 211 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)) || 212 __put_user(kbuf->f_type, &ubuf->f_type) || 213 __put_user(kbuf->f_bsize, &ubuf->f_bsize) || 214 __put_user(kbuf->f_blocks, &ubuf->f_blocks) || 215 __put_user(kbuf->f_bfree, &ubuf->f_bfree) || 216 __put_user(kbuf->f_bavail, &ubuf->f_bavail) || 217 __put_user(kbuf->f_files, &ubuf->f_files) || 218 __put_user(kbuf->f_ffree, &ubuf->f_ffree) || 219 __put_user(kbuf->f_namelen, &ubuf->f_namelen) || 220 __put_user(kbuf->f_fsid.val[0], &ubuf->f_fsid.val[0]) || 221 __put_user(kbuf->f_fsid.val[1], &ubuf->f_fsid.val[1]) || 222 __put_user(kbuf->f_frsize, &ubuf->f_frsize) || 223 __put_user(0, &ubuf->f_spare[0]) || 224 __put_user(0, &ubuf->f_spare[1]) || 225 __put_user(0, &ubuf->f_spare[2]) || 226 __put_user(0, &ubuf->f_spare[3]) || 227 __put_user(0, &ubuf->f_spare[4])) 228 return -EFAULT; 229 return 0; 230} 231 232/* 233 * The following statfs calls are copies of code from fs/open.c and 234 * should be checked against those from time to time 235 */ 236asmlinkage long compat_sys_statfs(const char __user *path, struct compat_statfs __user *buf) 237{ 238 struct nameidata nd; 239 int error; 240 241 error = user_path_walk(path, &nd); 242 if (!error) { 243 struct kstatfs tmp; 244 error = vfs_statfs(nd.dentry, &tmp); 245 if (!error) 246 error = put_compat_statfs(buf, &tmp); 247 path_release(&nd); 248 } 249 return error; 250} 251 252asmlinkage long compat_sys_fstatfs(unsigned int fd, struct compat_statfs __user *buf) 253{ 254 struct file * file; 255 struct kstatfs tmp; 256 int error; 257 258 error = -EBADF; 259 file = fget(fd); 260 if (!file) 261 goto out; 262 error = vfs_statfs(file->f_path.dentry, &tmp); 263 if (!error) 264 error = put_compat_statfs(buf, &tmp); 265 fput(file); 266out: 267 return error; 268} 269 270static int put_compat_statfs64(struct compat_statfs64 __user *ubuf, struct kstatfs *kbuf) 271{ 272 if (sizeof ubuf->f_blocks == 4) { 273 if ((kbuf->f_blocks | kbuf->f_bfree | kbuf->f_bavail) & 274 0xffffffff00000000ULL) 275 return -EOVERFLOW; 276 /* f_files and f_ffree may be -1; it's okay 277 * to stuff that into 32 bits */ 278 if (kbuf->f_files != 0xffffffffffffffffULL 279 && (kbuf->f_files & 0xffffffff00000000ULL)) 280 return -EOVERFLOW; 281 if (kbuf->f_ffree != 0xffffffffffffffffULL 282 && (kbuf->f_ffree & 0xffffffff00000000ULL)) 283 return -EOVERFLOW; 284 } 285 if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)) || 286 __put_user(kbuf->f_type, &ubuf->f_type) || 287 __put_user(kbuf->f_bsize, &ubuf->f_bsize) || 288 __put_user(kbuf->f_blocks, &ubuf->f_blocks) || 289 __put_user(kbuf->f_bfree, &ubuf->f_bfree) || 290 __put_user(kbuf->f_bavail, &ubuf->f_bavail) || 291 __put_user(kbuf->f_files, &ubuf->f_files) || 292 __put_user(kbuf->f_ffree, &ubuf->f_ffree) || 293 __put_user(kbuf->f_namelen, &ubuf->f_namelen) || 294 __put_user(kbuf->f_fsid.val[0], &ubuf->f_fsid.val[0]) || 295 __put_user(kbuf->f_fsid.val[1], &ubuf->f_fsid.val[1]) || 296 __put_user(kbuf->f_frsize, &ubuf->f_frsize)) 297 return -EFAULT; 298 return 0; 299} 300 301asmlinkage long compat_sys_statfs64(const char __user *path, compat_size_t sz, struct compat_statfs64 __user *buf) 302{ 303 struct nameidata nd; 304 int error; 305 306 if (sz != sizeof(*buf)) 307 return -EINVAL; 308 309 error = user_path_walk(path, &nd); 310 if (!error) { 311 struct kstatfs tmp; 312 error = vfs_statfs(nd.dentry, &tmp); 313 if (!error) 314 error = put_compat_statfs64(buf, &tmp); 315 path_release(&nd); 316 } 317 return error; 318} 319 320asmlinkage long compat_sys_fstatfs64(unsigned int fd, compat_size_t sz, struct compat_statfs64 __user *buf) 321{ 322 struct file * file; 323 struct kstatfs tmp; 324 int error; 325 326 if (sz != sizeof(*buf)) 327 return -EINVAL; 328 329 error = -EBADF; 330 file = fget(fd); 331 if (!file) 332 goto out; 333 error = vfs_statfs(file->f_path.dentry, &tmp); 334 if (!error) 335 error = put_compat_statfs64(buf, &tmp); 336 fput(file); 337out: 338 return error; 339} 340 341static int get_compat_flock(struct flock *kfl, struct compat_flock __user *ufl) 342{ 343 if (!access_ok(VERIFY_READ, ufl, sizeof(*ufl)) || 344 __get_user(kfl->l_type, &ufl->l_type) || 345 __get_user(kfl->l_whence, &ufl->l_whence) || 346 __get_user(kfl->l_start, &ufl->l_start) || 347 __get_user(kfl->l_len, &ufl->l_len) || 348 __get_user(kfl->l_pid, &ufl->l_pid)) 349 return -EFAULT; 350 return 0; 351} 352 353static int put_compat_flock(struct flock *kfl, struct compat_flock __user *ufl) 354{ 355 if (!access_ok(VERIFY_WRITE, ufl, sizeof(*ufl)) || 356 __put_user(kfl->l_type, &ufl->l_type) || 357 __put_user(kfl->l_whence, &ufl->l_whence) || 358 __put_user(kfl->l_start, &ufl->l_start) || 359 __put_user(kfl->l_len, &ufl->l_len) || 360 __put_user(kfl->l_pid, &ufl->l_pid)) 361 return -EFAULT; 362 return 0; 363} 364 365#ifndef HAVE_ARCH_GET_COMPAT_FLOCK64 366static int get_compat_flock64(struct flock *kfl, struct compat_flock64 __user *ufl) 367{ 368 if (!access_ok(VERIFY_READ, ufl, sizeof(*ufl)) || 369 __get_user(kfl->l_type, &ufl->l_type) || 370 __get_user(kfl->l_whence, &ufl->l_whence) || 371 __get_user(kfl->l_start, &ufl->l_start) || 372 __get_user(kfl->l_len, &ufl->l_len) || 373 __get_user(kfl->l_pid, &ufl->l_pid)) 374 return -EFAULT; 375 return 0; 376} 377#endif 378 379#ifndef HAVE_ARCH_PUT_COMPAT_FLOCK64 380static int put_compat_flock64(struct flock *kfl, struct compat_flock64 __user *ufl) 381{ 382 if (!access_ok(VERIFY_WRITE, ufl, sizeof(*ufl)) || 383 __put_user(kfl->l_type, &ufl->l_type) || 384 __put_user(kfl->l_whence, &ufl->l_whence) || 385 __put_user(kfl->l_start, &ufl->l_start) || 386 __put_user(kfl->l_len, &ufl->l_len) || 387 __put_user(kfl->l_pid, &ufl->l_pid)) 388 return -EFAULT; 389 return 0; 390} 391#endif 392 393asmlinkage long compat_sys_fcntl64(unsigned int fd, unsigned int cmd, 394 unsigned long arg) 395{ 396 mm_segment_t old_fs; 397 struct flock f; 398 long ret; 399 400 switch (cmd) { 401 case F_GETLK: 402 case F_SETLK: 403 case F_SETLKW: 404 ret = get_compat_flock(&f, compat_ptr(arg)); 405 if (ret != 0) 406 break; 407 old_fs = get_fs(); 408 set_fs(KERNEL_DS); 409 ret = sys_fcntl(fd, cmd, (unsigned long)&f); 410 set_fs(old_fs); 411 if (cmd == F_GETLK && ret == 0) { 412 /* GETLK was successfule and we need to return the data... 413 * but it needs to fit in the compat structure. 414 * l_start shouldn't be too big, unless the original 415 * start + end is greater than COMPAT_OFF_T_MAX, in which 416 * case the app was asking for trouble, so we return 417 * -EOVERFLOW in that case. 418 * l_len could be too big, in which case we just truncate it, 419 * and only allow the app to see that part of the conflicting 420 * lock that might make sense to it anyway 421 */ 422 423 if (f.l_start > COMPAT_OFF_T_MAX) 424 ret = -EOVERFLOW; 425 if (f.l_len > COMPAT_OFF_T_MAX) 426 f.l_len = COMPAT_OFF_T_MAX; 427 if (ret == 0) 428 ret = put_compat_flock(&f, compat_ptr(arg)); 429 } 430 break; 431 432 case F_GETLK64: 433 case F_SETLK64: 434 case F_SETLKW64: 435 ret = get_compat_flock64(&f, compat_ptr(arg)); 436 if (ret != 0) 437 break; 438 old_fs = get_fs(); 439 set_fs(KERNEL_DS); 440 ret = sys_fcntl(fd, (cmd == F_GETLK64) ? F_GETLK : 441 ((cmd == F_SETLK64) ? F_SETLK : F_SETLKW), 442 (unsigned long)&f); 443 set_fs(old_fs); 444 if (cmd == F_GETLK64 && ret == 0) { 445 /* need to return lock information - see above for commentary */ 446 if (f.l_start > COMPAT_LOFF_T_MAX) 447 ret = -EOVERFLOW; 448 if (f.l_len > COMPAT_LOFF_T_MAX) 449 f.l_len = COMPAT_LOFF_T_MAX; 450 if (ret == 0) 451 ret = put_compat_flock64(&f, compat_ptr(arg)); 452 } 453 break; 454 455 default: 456 ret = sys_fcntl(fd, cmd, arg); 457 break; 458 } 459 return ret; 460} 461 462asmlinkage long compat_sys_fcntl(unsigned int fd, unsigned int cmd, 463 unsigned long arg) 464{ 465 if ((cmd == F_GETLK64) || (cmd == F_SETLK64) || (cmd == F_SETLKW64)) 466 return -EINVAL; 467 return compat_sys_fcntl64(fd, cmd, arg); 468} 469 470asmlinkage long 471compat_sys_io_setup(unsigned nr_reqs, u32 __user *ctx32p) 472{ 473 long ret; 474 aio_context_t ctx64; 475 476 mm_segment_t oldfs = get_fs(); 477 if (unlikely(get_user(ctx64, ctx32p))) 478 return -EFAULT; 479 480 set_fs(KERNEL_DS); 481 /* The __user pointer cast is valid because of the set_fs() */ 482 ret = sys_io_setup(nr_reqs, (aio_context_t __user *) &ctx64); 483 set_fs(oldfs); 484 /* truncating is ok because it's a user address */ 485 if (!ret) 486 ret = put_user((u32) ctx64, ctx32p); 487 return ret; 488} 489 490asmlinkage long 491compat_sys_io_getevents(aio_context_t ctx_id, 492 unsigned long min_nr, 493 unsigned long nr, 494 struct io_event __user *events, 495 struct compat_timespec __user *timeout) 496{ 497 long ret; 498 struct timespec t; 499 struct timespec __user *ut = NULL; 500 501 ret = -EFAULT; 502 if (unlikely(!access_ok(VERIFY_WRITE, events, 503 nr * sizeof(struct io_event)))) 504 goto out; 505 if (timeout) { 506 if (get_compat_timespec(&t, timeout)) 507 goto out; 508 509 ut = compat_alloc_user_space(sizeof(*ut)); 510 if (copy_to_user(ut, &t, sizeof(t)) ) 511 goto out; 512 } 513 ret = sys_io_getevents(ctx_id, min_nr, nr, events, ut); 514out: 515 return ret; 516} 517 518static inline long 519copy_iocb(long nr, u32 __user *ptr32, struct iocb __user * __user *ptr64) 520{ 521 compat_uptr_t uptr; 522 int i; 523 524 for (i = 0; i < nr; ++i) { 525 if (get_user(uptr, ptr32 + i)) 526 return -EFAULT; 527 if (put_user(compat_ptr(uptr), ptr64 + i)) 528 return -EFAULT; 529 } 530 return 0; 531} 532 533#define MAX_AIO_SUBMITS (PAGE_SIZE/sizeof(struct iocb *)) 534 535asmlinkage long 536compat_sys_io_submit(aio_context_t ctx_id, int nr, u32 __user *iocb) 537{ 538 struct iocb __user * __user *iocb64; 539 long ret; 540 541 if (unlikely(nr < 0)) 542 return -EINVAL; 543 544 if (nr > MAX_AIO_SUBMITS) 545 nr = MAX_AIO_SUBMITS; 546 547 iocb64 = compat_alloc_user_space(nr * sizeof(*iocb64)); 548 ret = copy_iocb(nr, iocb, iocb64); 549 if (!ret) 550 ret = sys_io_submit(ctx_id, nr, iocb64); 551 return ret; 552} 553 554struct compat_ncp_mount_data { 555 compat_int_t version; 556 compat_uint_t ncp_fd; 557 __compat_uid_t mounted_uid; 558 compat_pid_t wdog_pid; 559 unsigned char mounted_vol[NCP_VOLNAME_LEN + 1]; 560 compat_uint_t time_out; 561 compat_uint_t retry_count; 562 compat_uint_t flags; 563 __compat_uid_t uid; 564 __compat_gid_t gid; 565 compat_mode_t file_mode; 566 compat_mode_t dir_mode; 567}; 568 569struct compat_ncp_mount_data_v4 { 570 compat_int_t version; 571 compat_ulong_t flags; 572 compat_ulong_t mounted_uid; 573 compat_long_t wdog_pid; 574 compat_uint_t ncp_fd; 575 compat_uint_t time_out; 576 compat_uint_t retry_count; 577 compat_ulong_t uid; 578 compat_ulong_t gid; 579 compat_ulong_t file_mode; 580 compat_ulong_t dir_mode; 581}; 582 583static void *do_ncp_super_data_conv(void *raw_data) 584{ 585 int version = *(unsigned int *)raw_data; 586 587 if (version == 3) { 588 struct compat_ncp_mount_data *c_n = raw_data; 589 struct ncp_mount_data *n = raw_data; 590 591 n->dir_mode = c_n->dir_mode; 592 n->file_mode = c_n->file_mode; 593 n->gid = c_n->gid; 594 n->uid = c_n->uid; 595 memmove (n->mounted_vol, c_n->mounted_vol, (sizeof (c_n->mounted_vol) + 3 * sizeof (unsigned int))); 596 n->wdog_pid = c_n->wdog_pid; 597 n->mounted_uid = c_n->mounted_uid; 598 } else if (version == 4) { 599 struct compat_ncp_mount_data_v4 *c_n = raw_data; 600 struct ncp_mount_data_v4 *n = raw_data; 601 602 n->dir_mode = c_n->dir_mode; 603 n->file_mode = c_n->file_mode; 604 n->gid = c_n->gid; 605 n->uid = c_n->uid; 606 n->retry_count = c_n->retry_count; 607 n->time_out = c_n->time_out; 608 n->ncp_fd = c_n->ncp_fd; 609 n->wdog_pid = c_n->wdog_pid; 610 n->mounted_uid = c_n->mounted_uid; 611 n->flags = c_n->flags; 612 } else if (version != 5) { 613 return NULL; 614 } 615 616 return raw_data; 617} 618 619struct compat_smb_mount_data { 620 compat_int_t version; 621 __compat_uid_t mounted_uid; 622 __compat_uid_t uid; 623 __compat_gid_t gid; 624 compat_mode_t file_mode; 625 compat_mode_t dir_mode; 626}; 627 628static void *do_smb_super_data_conv(void *raw_data) 629{ 630 struct smb_mount_data *s = raw_data; 631 struct compat_smb_mount_data *c_s = raw_data; 632 633 if (c_s->version != SMB_MOUNT_OLDVERSION) 634 goto out; 635 s->dir_mode = c_s->dir_mode; 636 s->file_mode = c_s->file_mode; 637 s->gid = c_s->gid; 638 s->uid = c_s->uid; 639 s->mounted_uid = c_s->mounted_uid; 640 out: 641 return raw_data; 642} 643 644struct compat_nfs_string { 645 compat_uint_t len; 646 compat_uptr_t data; 647}; 648 649static inline void compat_nfs_string(struct nfs_string *dst, 650 struct compat_nfs_string *src) 651{ 652 dst->data = compat_ptr(src->data); 653 dst->len = src->len; 654} 655 656struct compat_nfs4_mount_data_v1 { 657 compat_int_t version; 658 compat_int_t flags; 659 compat_int_t rsize; 660 compat_int_t wsize; 661 compat_int_t timeo; 662 compat_int_t retrans; 663 compat_int_t acregmin; 664 compat_int_t acregmax; 665 compat_int_t acdirmin; 666 compat_int_t acdirmax; 667 struct compat_nfs_string client_addr; 668 struct compat_nfs_string mnt_path; 669 struct compat_nfs_string hostname; 670 compat_uint_t host_addrlen; 671 compat_uptr_t host_addr; 672 compat_int_t proto; 673 compat_int_t auth_flavourlen; 674 compat_uptr_t auth_flavours; 675}; 676 677static int do_nfs4_super_data_conv(void *raw_data) 678{ 679 int version = *(compat_uint_t *) raw_data; 680 681 if (version == 1) { 682 struct compat_nfs4_mount_data_v1 *raw = raw_data; 683 struct nfs4_mount_data *real = raw_data; 684 685 /* copy the fields backwards */ 686 real->auth_flavours = compat_ptr(raw->auth_flavours); 687 real->auth_flavourlen = raw->auth_flavourlen; 688 real->proto = raw->proto; 689 real->host_addr = compat_ptr(raw->host_addr); 690 real->host_addrlen = raw->host_addrlen; 691 compat_nfs_string(&real->hostname, &raw->hostname); 692 compat_nfs_string(&real->mnt_path, &raw->mnt_path); 693 compat_nfs_string(&real->client_addr, &raw->client_addr); 694 real->acdirmax = raw->acdirmax; 695 real->acdirmin = raw->acdirmin; 696 real->acregmax = raw->acregmax; 697 real->acregmin = raw->acregmin; 698 real->retrans = raw->retrans; 699 real->timeo = raw->timeo; 700 real->wsize = raw->wsize; 701 real->rsize = raw->rsize; 702 real->flags = raw->flags; 703 real->version = raw->version; 704 } 705 else { 706 return -EINVAL; 707 } 708 709 return 0; 710} 711 712#define SMBFS_NAME "smbfs" 713#define NCPFS_NAME "ncpfs" 714#define NFS4_NAME "nfs4" 715 716asmlinkage long compat_sys_mount(char __user * dev_name, char __user * dir_name, 717 char __user * type, unsigned long flags, 718 void __user * data) 719{ 720 unsigned long type_page; 721 unsigned long data_page; 722 unsigned long dev_page; 723 char *dir_page; 724 int retval; 725 726 retval = copy_mount_options (type, &type_page); 727 if (retval < 0) 728 goto out; 729 730 dir_page = getname(dir_name); 731 retval = PTR_ERR(dir_page); 732 if (IS_ERR(dir_page)) 733 goto out1; 734 735 retval = copy_mount_options (dev_name, &dev_page); 736 if (retval < 0) 737 goto out2; 738 739 retval = copy_mount_options (data, &data_page); 740 if (retval < 0) 741 goto out3; 742 743 retval = -EINVAL; 744 745 if (type_page && data_page) { 746 if (!strcmp((char *)type_page, SMBFS_NAME)) { 747 do_smb_super_data_conv((void *)data_page); 748 } else if (!strcmp((char *)type_page, NCPFS_NAME)) { 749 do_ncp_super_data_conv((void *)data_page); 750 } else if (!strcmp((char *)type_page, NFS4_NAME)) { 751 if (do_nfs4_super_data_conv((void *) data_page)) 752 goto out4; 753 } 754 } 755 756 lock_kernel(); 757 retval = do_mount((char*)dev_page, dir_page, (char*)type_page, 758 flags, (void*)data_page); 759 unlock_kernel(); 760 761 out4: 762 free_page(data_page); 763 out3: 764 free_page(dev_page); 765 out2: 766 putname(dir_page); 767 out1: 768 free_page(type_page); 769 out: 770 return retval; 771} 772 773#define NAME_OFFSET(de) ((int) ((de)->d_name - (char __user *) (de))) 774 775struct compat_old_linux_dirent { 776 compat_ulong_t d_ino; 777 compat_ulong_t d_offset; 778 unsigned short d_namlen; 779 char d_name[1]; 780}; 781 782struct compat_readdir_callback { 783 struct compat_old_linux_dirent __user *dirent; 784 int result; 785}; 786 787static int compat_fillonedir(void *__buf, const char *name, int namlen, 788 loff_t offset, u64 ino, unsigned int d_type) 789{ 790 struct compat_readdir_callback *buf = __buf; 791 struct compat_old_linux_dirent __user *dirent; 792 compat_ulong_t d_ino; 793 794 if (buf->result) 795 return -EINVAL; 796 d_ino = ino; 797 if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) 798 return -EOVERFLOW; 799 buf->result++; 800 dirent = buf->dirent; 801 if (!access_ok(VERIFY_WRITE, dirent, 802 (unsigned long)(dirent->d_name + namlen + 1) - 803 (unsigned long)dirent)) 804 goto efault; 805 if ( __put_user(d_ino, &dirent->d_ino) || 806 __put_user(offset, &dirent->d_offset) || 807 __put_user(namlen, &dirent->d_namlen) || 808 __copy_to_user(dirent->d_name, name, namlen) || 809 __put_user(0, dirent->d_name + namlen)) 810 goto efault; 811 return 0; 812efault: 813 buf->result = -EFAULT; 814 return -EFAULT; 815} 816 817asmlinkage long compat_sys_old_readdir(unsigned int fd, 818 struct compat_old_linux_dirent __user *dirent, unsigned int count) 819{ 820 int error; 821 struct file *file; 822 struct compat_readdir_callback buf; 823 824 error = -EBADF; 825 file = fget(fd); 826 if (!file) 827 goto out; 828 829 buf.result = 0; 830 buf.dirent = dirent; 831 832 error = vfs_readdir(file, compat_fillonedir, &buf); 833 if (error >= 0) 834 error = buf.result; 835 836 fput(file); 837out: 838 return error; 839} 840 841struct compat_linux_dirent { 842 compat_ulong_t d_ino; 843 compat_ulong_t d_off; 844 unsigned short d_reclen; 845 char d_name[1]; 846}; 847 848struct compat_getdents_callback { 849 struct compat_linux_dirent __user *current_dir; 850 struct compat_linux_dirent __user *previous; 851 int count; 852 int error; 853}; 854 855static int compat_filldir(void *__buf, const char *name, int namlen, 856 loff_t offset, u64 ino, unsigned int d_type) 857{ 858 struct compat_linux_dirent __user * dirent; 859 struct compat_getdents_callback *buf = __buf; 860 compat_ulong_t d_ino; 861 int reclen = ALIGN(NAME_OFFSET(dirent) + namlen + 2, sizeof(compat_long_t)); 862 863 buf->error = -EINVAL; /* only used if we fail.. */ 864 if (reclen > buf->count) 865 return -EINVAL; 866 d_ino = ino; 867 if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) 868 return -EOVERFLOW; 869 dirent = buf->previous; 870 if (dirent) { 871 if (__put_user(offset, &dirent->d_off)) 872 goto efault; 873 } 874 dirent = buf->current_dir; 875 if (__put_user(d_ino, &dirent->d_ino)) 876 goto efault; 877 if (__put_user(reclen, &dirent->d_reclen)) 878 goto efault; 879 if (copy_to_user(dirent->d_name, name, namlen)) 880 goto efault; 881 if (__put_user(0, dirent->d_name + namlen)) 882 goto efault; 883 if (__put_user(d_type, (char __user *) dirent + reclen - 1)) 884 goto efault; 885 buf->previous = dirent; 886 dirent = (void __user *)dirent + reclen; 887 buf->current_dir = dirent; 888 buf->count -= reclen; 889 return 0; 890efault: 891 buf->error = -EFAULT; 892 return -EFAULT; 893} 894 895asmlinkage long compat_sys_getdents(unsigned int fd, 896 struct compat_linux_dirent __user *dirent, unsigned int count) 897{ 898 struct file * file; 899 struct compat_linux_dirent __user * lastdirent; 900 struct compat_getdents_callback buf; 901 int error; 902 903 error = -EFAULT; 904 if (!access_ok(VERIFY_WRITE, dirent, count)) 905 goto out; 906 907 error = -EBADF; 908 file = fget(fd); 909 if (!file) 910 goto out; 911 912 buf.current_dir = dirent; 913 buf.previous = NULL; 914 buf.count = count; 915 buf.error = 0; 916 917 error = vfs_readdir(file, compat_filldir, &buf); 918 if (error < 0) 919 goto out_putf; 920 error = buf.error; 921 lastdirent = buf.previous; 922 if (lastdirent) { 923 if (put_user(file->f_pos, &lastdirent->d_off)) 924 error = -EFAULT; 925 else 926 error = count - buf.count; 927 } 928 929out_putf: 930 fput(file); 931out: 932 return error; 933} 934 935#ifndef __ARCH_OMIT_COMPAT_SYS_GETDENTS64 936 937struct compat_getdents_callback64 { 938 struct linux_dirent64 __user *current_dir; 939 struct linux_dirent64 __user *previous; 940 int count; 941 int error; 942}; 943 944static int compat_filldir64(void * __buf, const char * name, int namlen, loff_t offset, 945 u64 ino, unsigned int d_type) 946{ 947 struct linux_dirent64 __user *dirent; 948 struct compat_getdents_callback64 *buf = __buf; 949 int jj = NAME_OFFSET(dirent); 950 int reclen = ALIGN(jj + namlen + 1, sizeof(u64)); 951 u64 off; 952 953 buf->error = -EINVAL; /* only used if we fail.. */ 954 if (reclen > buf->count) 955 return -EINVAL; 956 dirent = buf->previous; 957 958 if (dirent) { 959 if (__put_user_unaligned(offset, &dirent->d_off)) 960 goto efault; 961 } 962 dirent = buf->current_dir; 963 if (__put_user_unaligned(ino, &dirent->d_ino)) 964 goto efault; 965 off = 0; 966 if (__put_user_unaligned(off, &dirent->d_off)) 967 goto efault; 968 if (__put_user(reclen, &dirent->d_reclen)) 969 goto efault; 970 if (__put_user(d_type, &dirent->d_type)) 971 goto efault; 972 if (copy_to_user(dirent->d_name, name, namlen)) 973 goto efault; 974 if (__put_user(0, dirent->d_name + namlen)) 975 goto efault; 976 buf->previous = dirent; 977 dirent = (void __user *)dirent + reclen; 978 buf->current_dir = dirent; 979 buf->count -= reclen; 980 return 0; 981efault: 982 buf->error = -EFAULT; 983 return -EFAULT; 984} 985 986asmlinkage long compat_sys_getdents64(unsigned int fd, 987 struct linux_dirent64 __user * dirent, unsigned int count) 988{ 989 struct file * file; 990 struct linux_dirent64 __user * lastdirent; 991 struct compat_getdents_callback64 buf; 992 int error; 993 994 error = -EFAULT; 995 if (!access_ok(VERIFY_WRITE, dirent, count)) 996 goto out; 997 998 error = -EBADF; 999 file = fget(fd); 1000 if (!file) 1001 goto out; 1002 1003 buf.current_dir = dirent; 1004 buf.previous = NULL; 1005 buf.count = count; 1006 buf.error = 0; 1007 1008 error = vfs_readdir(file, compat_filldir64, &buf); 1009 if (error < 0) 1010 goto out_putf; 1011 error = buf.error; 1012 lastdirent = buf.previous; 1013 if (lastdirent) { 1014 typeof(lastdirent->d_off) d_off = file->f_pos; 1015 error = -EFAULT; 1016 if (__put_user_unaligned(d_off, &lastdirent->d_off)) 1017 goto out_putf; 1018 error = count - buf.count; 1019 } 1020 1021out_putf: 1022 fput(file); 1023out: 1024 return error; 1025} 1026#endif /* ! __ARCH_OMIT_COMPAT_SYS_GETDENTS64 */ 1027 1028static ssize_t compat_do_readv_writev(int type, struct file *file, 1029 const struct compat_iovec __user *uvector, 1030 unsigned long nr_segs, loff_t *pos) 1031{ 1032 compat_ssize_t tot_len; 1033 struct iovec iovstack[UIO_FASTIOV]; 1034 struct iovec *iov=iovstack, *vector; 1035 ssize_t ret; 1036 int seg; 1037 io_fn_t fn; 1038 iov_fn_t fnv; 1039 1040 /* 1041 * SuS says "The readv() function *may* fail if the iovcnt argument 1042 * was less than or equal to 0, or greater than {IOV_MAX}. Linux has 1043 * traditionally returned zero for zero segments, so... 1044 */ 1045 ret = 0; 1046 if (nr_segs == 0) 1047 goto out; 1048 1049 /* 1050 * First get the "struct iovec" from user memory and 1051 * verify all the pointers 1052 */ 1053 ret = -EINVAL; 1054 if ((nr_segs > UIO_MAXIOV) || (nr_segs <= 0)) 1055 goto out; 1056 if (!file->f_op) 1057 goto out; 1058 if (nr_segs > UIO_FASTIOV) { 1059 ret = -ENOMEM; 1060 iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL); 1061 if (!iov) 1062 goto out; 1063 } 1064 ret = -EFAULT; 1065 if (!access_ok(VERIFY_READ, uvector, nr_segs*sizeof(*uvector))) 1066 goto out; 1067 1068 /* 1069 * Single unix specification: 1070 * We should -EINVAL if an element length is not >= 0 and fitting an 1071 * ssize_t. The total length is fitting an ssize_t 1072 * 1073 * Be careful here because iov_len is a size_t not an ssize_t 1074 */ 1075 tot_len = 0; 1076 vector = iov; 1077 ret = -EINVAL; 1078 for (seg = 0 ; seg < nr_segs; seg++) { 1079 compat_ssize_t tmp = tot_len; 1080 compat_ssize_t len; 1081 compat_uptr_t buf; 1082 1083 if (__get_user(len, &uvector->iov_len) || 1084 __get_user(buf, &uvector->iov_base)) { 1085 ret = -EFAULT; 1086 goto out; 1087 } 1088 if (len < 0) /* size_t not fitting an compat_ssize_t .. */ 1089 goto out; 1090 tot_len += len; 1091 if (tot_len < tmp) /* maths overflow on the compat_ssize_t */ 1092 goto out; 1093 vector->iov_base = compat_ptr(buf); 1094 vector->iov_len = (compat_size_t) len; 1095 uvector++; 1096 vector++; 1097 } 1098 if (tot_len == 0) { 1099 ret = 0; 1100 goto out; 1101 } 1102 1103 ret = rw_verify_area(type, file, pos, tot_len); 1104 if (ret < 0) 1105 goto out; 1106 1107 ret = security_file_permission(file, type == READ ? MAY_READ:MAY_WRITE); 1108 if (ret) 1109 goto out; 1110 1111 fnv = NULL; 1112 if (type == READ) { 1113 fn = file->f_op->read; 1114 fnv = file->f_op->aio_read; 1115 } else { 1116 fn = (io_fn_t)file->f_op->write; 1117 fnv = file->f_op->aio_write; 1118 } 1119 1120 if (fnv) 1121 ret = do_sync_readv_writev(file, iov, nr_segs, tot_len, 1122 pos, fnv); 1123 else 1124 ret = do_loop_readv_writev(file, iov, nr_segs, pos, fn); 1125 1126out: 1127 if (iov != iovstack) 1128 kfree(iov); 1129 if ((ret + (type == READ)) > 0) { 1130 struct dentry *dentry = file->f_path.dentry; 1131 if (type == READ) 1132 fsnotify_access(dentry); 1133 else 1134 fsnotify_modify(dentry); 1135 } 1136 return ret; 1137} 1138 1139asmlinkage ssize_t 1140compat_sys_readv(unsigned long fd, const struct compat_iovec __user *vec, unsigned long vlen) 1141{ 1142 struct file *file; 1143 ssize_t ret = -EBADF; 1144 1145 file = fget(fd); 1146 if (!file) 1147 return -EBADF; 1148 1149 if (!(file->f_mode & FMODE_READ)) 1150 goto out; 1151 1152 ret = -EINVAL; 1153 if (!file->f_op || (!file->f_op->aio_read && !file->f_op->read)) 1154 goto out; 1155 1156 ret = compat_do_readv_writev(READ, file, vec, vlen, &file->f_pos); 1157 1158out: 1159 fput(file); 1160 return ret; 1161} 1162 1163asmlinkage ssize_t 1164compat_sys_writev(unsigned long fd, const struct compat_iovec __user *vec, unsigned long vlen) 1165{ 1166 struct file *file; 1167 ssize_t ret = -EBADF; 1168 1169 file = fget(fd); 1170 if (!file) 1171 return -EBADF; 1172 if (!(file->f_mode & FMODE_WRITE)) 1173 goto out; 1174 1175 ret = -EINVAL; 1176 if (!file->f_op || (!file->f_op->aio_write && !file->f_op->write)) 1177 goto out; 1178 1179 ret = compat_do_readv_writev(WRITE, file, vec, vlen, &file->f_pos); 1180 1181out: 1182 fput(file); 1183 return ret; 1184} 1185 1186asmlinkage long 1187compat_sys_vmsplice(int fd, const struct compat_iovec __user *iov32, 1188 unsigned int nr_segs, unsigned int flags) 1189{ 1190 unsigned i; 1191 struct iovec __user *iov; 1192 if (nr_segs > UIO_MAXIOV) 1193 return -EINVAL; 1194 iov = compat_alloc_user_space(nr_segs * sizeof(struct iovec)); 1195 for (i = 0; i < nr_segs; i++) { 1196 struct compat_iovec v; 1197 if (get_user(v.iov_base, &iov32[i].iov_base) || 1198 get_user(v.iov_len, &iov32[i].iov_len) || 1199 put_user(compat_ptr(v.iov_base), &iov[i].iov_base) || 1200 put_user(v.iov_len, &iov[i].iov_len)) 1201 return -EFAULT; 1202 } 1203 return sys_vmsplice(fd, iov, nr_segs, flags); 1204} 1205 1206/* 1207 * Exactly like fs/open.c:sys_open(), except that it doesn't set the 1208 * O_LARGEFILE flag. 1209 */ 1210asmlinkage long 1211compat_sys_open(const char __user *filename, int flags, int mode) 1212{ 1213 return do_sys_open(AT_FDCWD, filename, flags, mode); 1214} 1215 1216/* 1217 * Exactly like fs/open.c:sys_openat(), except that it doesn't set the 1218 * O_LARGEFILE flag. 1219 */ 1220asmlinkage long 1221compat_sys_openat(unsigned int dfd, const char __user *filename, int flags, int mode) 1222{ 1223 return do_sys_open(dfd, filename, flags, mode); 1224} 1225 1226/* 1227 * compat_count() counts the number of arguments/envelopes. It is basically 1228 * a copy of count() from fs/exec.c, except that it works with 32 bit argv 1229 * and envp pointers. 1230 */ 1231static int compat_count(compat_uptr_t __user *argv, int max) 1232{ 1233 int i = 0; 1234 1235 if (argv != NULL) { 1236 for (;;) { 1237 compat_uptr_t p; 1238 1239 if (get_user(p, argv)) 1240 return -EFAULT; 1241 if (!p) 1242 break; 1243 argv++; 1244 if(++i > max) 1245 return -E2BIG; 1246 } 1247 } 1248 return i; 1249} 1250 1251/* 1252 * compat_copy_strings() is basically a copy of copy_strings() from fs/exec.c 1253 * except that it works with 32 bit argv and envp pointers. 1254 */ 1255static int compat_copy_strings(int argc, compat_uptr_t __user *argv, 1256 struct linux_binprm *bprm) 1257{ 1258 struct page *kmapped_page = NULL; 1259 char *kaddr = NULL; 1260 int ret; 1261 1262 while (argc-- > 0) { 1263 compat_uptr_t str; 1264 int len; 1265 unsigned long pos; 1266 1267 if (get_user(str, argv+argc) || 1268 !(len = strnlen_user(compat_ptr(str), bprm->p))) { 1269 ret = -EFAULT; 1270 goto out; 1271 } 1272 1273 if (bprm->p < len) { 1274 ret = -E2BIG; 1275 goto out; 1276 } 1277 1278 bprm->p -= len; 1279 pos = bprm->p; 1280 1281 while (len > 0) { 1282 int i, new, err; 1283 int offset, bytes_to_copy; 1284 struct page *page; 1285 1286 offset = pos % PAGE_SIZE; 1287 i = pos/PAGE_SIZE; 1288 page = bprm->page[i]; 1289 new = 0; 1290 if (!page) { 1291 page = alloc_page(GFP_HIGHUSER); 1292 bprm->page[i] = page; 1293 if (!page) { 1294 ret = -ENOMEM; 1295 goto out; 1296 } 1297 new = 1; 1298 } 1299 1300 if (page != kmapped_page) { 1301 if (kmapped_page) 1302 kunmap(kmapped_page); 1303 kmapped_page = page; 1304 kaddr = kmap(kmapped_page); 1305 } 1306 if (new && offset) 1307 memset(kaddr, 0, offset); 1308 bytes_to_copy = PAGE_SIZE - offset; 1309 if (bytes_to_copy > len) { 1310 bytes_to_copy = len; 1311 if (new) 1312 memset(kaddr+offset+len, 0, 1313 PAGE_SIZE-offset-len); 1314 } 1315 err = copy_from_user(kaddr+offset, compat_ptr(str), 1316 bytes_to_copy); 1317 if (err) { 1318 ret = -EFAULT; 1319 goto out; 1320 } 1321 1322 pos += bytes_to_copy; 1323 str += bytes_to_copy; 1324 len -= bytes_to_copy; 1325 } 1326 } 1327 ret = 0; 1328out: 1329 if (kmapped_page) 1330 kunmap(kmapped_page); 1331 return ret; 1332} 1333 1334#ifdef CONFIG_MMU 1335 1336#define free_arg_pages(bprm) do { } while (0) 1337 1338#else 1339 1340static inline void free_arg_pages(struct linux_binprm *bprm) 1341{ 1342 int i; 1343 1344 for (i = 0; i < MAX_ARG_PAGES; i++) { 1345 if (bprm->page[i]) 1346 __free_page(bprm->page[i]); 1347 bprm->page[i] = NULL; 1348 } 1349} 1350 1351#endif /* CONFIG_MMU */ 1352 1353/* 1354 * compat_do_execve() is mostly a copy of do_execve(), with the exception 1355 * that it processes 32 bit argv and envp pointers. 1356 */ 1357int compat_do_execve(char * filename, 1358 compat_uptr_t __user *argv, 1359 compat_uptr_t __user *envp, 1360 struct pt_regs * regs) 1361{ 1362 struct linux_binprm *bprm; 1363 struct file *file; 1364 int retval; 1365 int i; 1366 1367 retval = -ENOMEM; 1368 bprm = kzalloc(sizeof(*bprm), GFP_KERNEL); 1369 if (!bprm) 1370 goto out_ret; 1371 1372 file = open_exec(filename); 1373 retval = PTR_ERR(file); 1374 if (IS_ERR(file)) 1375 goto out_kfree; 1376 1377 sched_exec(); 1378 1379 bprm->p = PAGE_SIZE*MAX_ARG_PAGES-sizeof(void *); 1380 bprm->file = file; 1381 bprm->filename = filename; 1382 bprm->interp = filename; 1383 bprm->mm = mm_alloc(); 1384 retval = -ENOMEM; 1385 if (!bprm->mm) 1386 goto out_file; 1387 1388 retval = init_new_context(current, bprm->mm); 1389 if (retval < 0) 1390 goto out_mm; 1391 1392 bprm->argc = compat_count(argv, bprm->p / sizeof(compat_uptr_t)); 1393 if ((retval = bprm->argc) < 0) 1394 goto out_mm; 1395 1396 bprm->envc = compat_count(envp, bprm->p / sizeof(compat_uptr_t)); 1397 if ((retval = bprm->envc) < 0) 1398 goto out_mm; 1399 1400 retval = security_bprm_alloc(bprm); 1401 if (retval) 1402 goto out; 1403 1404 retval = prepare_binprm(bprm); 1405 if (retval < 0) 1406 goto out; 1407 1408 retval = copy_strings_kernel(1, &bprm->filename, bprm); 1409 if (retval < 0) 1410 goto out; 1411 1412 bprm->exec = bprm->p; 1413 retval = compat_copy_strings(bprm->envc, envp, bprm); 1414 if (retval < 0) 1415 goto out; 1416 1417 retval = compat_copy_strings(bprm->argc, argv, bprm); 1418 if (retval < 0) 1419 goto out; 1420 1421 retval = search_binary_handler(bprm, regs); 1422 if (retval >= 0) { 1423 free_arg_pages(bprm); 1424 1425 /* execve success */ 1426 security_bprm_free(bprm); 1427 acct_update_integrals(current); 1428 kfree(bprm); 1429 return retval; 1430 } 1431 1432out: 1433 /* Something went wrong, return the inode and free the argument pages*/ 1434 for (i = 0 ; i < MAX_ARG_PAGES ; i++) { 1435 struct page * page = bprm->page[i]; 1436 if (page) 1437 __free_page(page); 1438 } 1439 1440 if (bprm->security) 1441 security_bprm_free(bprm); 1442 1443out_mm: 1444 if (bprm->mm) 1445 mmdrop(bprm->mm); 1446 1447out_file: 1448 if (bprm->file) { 1449 allow_write_access(bprm->file); 1450 fput(bprm->file); 1451 } 1452 1453out_kfree: 1454 kfree(bprm); 1455 1456out_ret: 1457 return retval; 1458} 1459 1460#define __COMPAT_NFDBITS (8 * sizeof(compat_ulong_t)) 1461 1462/* 1463 * Ooo, nasty. We need here to frob 32-bit unsigned longs to 1464 * 64-bit unsigned longs. 1465 */ 1466static 1467int compat_get_fd_set(unsigned long nr, compat_ulong_t __user *ufdset, 1468 unsigned long *fdset) 1469{ 1470 nr = DIV_ROUND_UP(nr, __COMPAT_NFDBITS); 1471 if (ufdset) { 1472 unsigned long odd; 1473 1474 if (!access_ok(VERIFY_WRITE, ufdset, nr*sizeof(compat_ulong_t))) 1475 return -EFAULT; 1476 1477 odd = nr & 1UL; 1478 nr &= ~1UL; 1479 while (nr) { 1480 unsigned long h, l; 1481 if (__get_user(l, ufdset) || __get_user(h, ufdset+1)) 1482 return -EFAULT; 1483 ufdset += 2; 1484 *fdset++ = h << 32 | l; 1485 nr -= 2; 1486 } 1487 if (odd && __get_user(*fdset, ufdset)) 1488 return -EFAULT; 1489 } else { 1490 /* Tricky, must clear full unsigned long in the 1491 * kernel fdset at the end, this makes sure that 1492 * actually happens. 1493 */ 1494 memset(fdset, 0, ((nr + 1) & ~1)*sizeof(compat_ulong_t)); 1495 } 1496 return 0; 1497} 1498 1499static 1500int compat_set_fd_set(unsigned long nr, compat_ulong_t __user *ufdset, 1501 unsigned long *fdset) 1502{ 1503 unsigned long odd; 1504 nr = DIV_ROUND_UP(nr, __COMPAT_NFDBITS); 1505 1506 if (!ufdset) 1507 return 0; 1508 1509 odd = nr & 1UL; 1510 nr &= ~1UL; 1511 while (nr) { 1512 unsigned long h, l; 1513 l = *fdset++; 1514 h = l >> 32; 1515 if (__put_user(l, ufdset) || __put_user(h, ufdset+1)) 1516 return -EFAULT; 1517 ufdset += 2; 1518 nr -= 2; 1519 } 1520 if (odd && __put_user(*fdset, ufdset)) 1521 return -EFAULT; 1522 return 0; 1523} 1524 1525 1526/* 1527 * This is a virtual copy of sys_select from fs/select.c and probably 1528 * should be compared to it from time to time 1529 */ 1530 1531/* 1532 * We can actually return ERESTARTSYS instead of EINTR, but I'd 1533 * like to be certain this leads to no problems. So I return 1534 * EINTR just for safety. 1535 * 1536 * Update: ERESTARTSYS breaks at least the xview clock binary, so 1537 * I'm trying ERESTARTNOHAND which restart only when you want to. 1538 */ 1539#define MAX_SELECT_SECONDS \ 1540 ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1) 1541 1542int compat_core_sys_select(int n, compat_ulong_t __user *inp, 1543 compat_ulong_t __user *outp, compat_ulong_t __user *exp, s64 *timeout) 1544{ 1545 fd_set_bits fds; 1546 void *bits; 1547 int size, max_fds, ret = -EINVAL; 1548 struct fdtable *fdt; 1549 long stack_fds[SELECT_STACK_ALLOC/sizeof(long)]; 1550 1551 if (n < 0) 1552 goto out_nofds; 1553 1554 /* max_fds can increase, so grab it once to avoid race */ 1555 rcu_read_lock(); 1556 fdt = files_fdtable(current->files); 1557 max_fds = fdt->max_fds; 1558 rcu_read_unlock(); 1559 if (n > max_fds) 1560 n = max_fds; 1561 1562 /* 1563 * We need 6 bitmaps (in/out/ex for both incoming and outgoing), 1564 * since we used fdset we need to allocate memory in units of 1565 * long-words. 1566 */ 1567 size = FDS_BYTES(n); 1568 bits = stack_fds; 1569 if (size > sizeof(stack_fds) / 6) { 1570 bits = kmalloc(6 * size, GFP_KERNEL); 1571 ret = -ENOMEM; 1572 if (!bits) 1573 goto out_nofds; 1574 } 1575 fds.in = (unsigned long *) bits; 1576 fds.out = (unsigned long *) (bits + size); 1577 fds.ex = (unsigned long *) (bits + 2*size); 1578 fds.res_in = (unsigned long *) (bits + 3*size); 1579 fds.res_out = (unsigned long *) (bits + 4*size); 1580 fds.res_ex = (unsigned long *) (bits + 5*size); 1581 1582 if ((ret = compat_get_fd_set(n, inp, fds.in)) || 1583 (ret = compat_get_fd_set(n, outp, fds.out)) || 1584 (ret = compat_get_fd_set(n, exp, fds.ex))) 1585 goto out; 1586 zero_fd_set(n, fds.res_in); 1587 zero_fd_set(n, fds.res_out); 1588 zero_fd_set(n, fds.res_ex); 1589 1590 ret = do_select(n, &fds, timeout); 1591 1592 if (ret < 0) 1593 goto out; 1594 if (!ret) { 1595 ret = -ERESTARTNOHAND; 1596 if (signal_pending(current)) 1597 goto out; 1598 ret = 0; 1599 } 1600 1601 if (compat_set_fd_set(n, inp, fds.res_in) || 1602 compat_set_fd_set(n, outp, fds.res_out) || 1603 compat_set_fd_set(n, exp, fds.res_ex)) 1604 ret = -EFAULT; 1605out: 1606 if (bits != stack_fds) 1607 kfree(bits); 1608out_nofds: 1609 return ret; 1610} 1611 1612asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp, 1613 compat_ulong_t __user *outp, compat_ulong_t __user *exp, 1614 struct compat_timeval __user *tvp) 1615{ 1616 s64 timeout = -1; 1617 struct compat_timeval tv; 1618 int ret; 1619 1620 if (tvp) { 1621 if (copy_from_user(&tv, tvp, sizeof(tv))) 1622 return -EFAULT; 1623 1624 if (tv.tv_sec < 0 || tv.tv_usec < 0) 1625 return -EINVAL; 1626 1627 /* Cast to u64 to make GCC stop complaining */ 1628 if ((u64)tv.tv_sec >= (u64)MAX_INT64_SECONDS) 1629 timeout = -1; /* infinite */ 1630 else { 1631 timeout = DIV_ROUND_UP(tv.tv_usec, 1000000/HZ); 1632 timeout += tv.tv_sec * HZ; 1633 } 1634 } 1635 1636 ret = compat_core_sys_select(n, inp, outp, exp, &timeout); 1637 1638 if (tvp) { 1639 struct compat_timeval rtv; 1640 1641 if (current->personality & STICKY_TIMEOUTS) 1642 goto sticky; 1643 rtv.tv_usec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)); 1644 rtv.tv_sec = timeout; 1645 if (compat_timeval_compare(&rtv, &tv) >= 0) 1646 rtv = tv; 1647 if (copy_to_user(tvp, &rtv, sizeof(rtv))) { 1648sticky: 1649 /* 1650 * If an application puts its timeval in read-only 1651 * memory, we don't want the Linux-specific update to 1652 * the timeval to cause a fault after the select has 1653 * completed successfully. However, because we're not 1654 * updating the timeval, we can't restart the system 1655 * call. 1656 */ 1657 if (ret == -ERESTARTNOHAND) 1658 ret = -EINTR; 1659 } 1660 } 1661 1662 return ret; 1663} 1664 1665#ifdef TIF_RESTORE_SIGMASK 1666asmlinkage long compat_sys_pselect7(int n, compat_ulong_t __user *inp, 1667 compat_ulong_t __user *outp, compat_ulong_t __user *exp, 1668 struct compat_timespec __user *tsp, compat_sigset_t __user *sigmask, 1669 compat_size_t sigsetsize) 1670{ 1671 compat_sigset_t ss32; 1672 sigset_t ksigmask, sigsaved; 1673 s64 timeout = MAX_SCHEDULE_TIMEOUT; 1674 struct compat_timespec ts; 1675 int ret; 1676 1677 if (tsp) { 1678 if (copy_from_user(&ts, tsp, sizeof(ts))) 1679 return -EFAULT; 1680 1681 if (ts.tv_sec < 0 || ts.tv_nsec < 0) 1682 return -EINVAL; 1683 } 1684 1685 if (sigmask) { 1686 if (sigsetsize != sizeof(compat_sigset_t)) 1687 return -EINVAL; 1688 if (copy_from_user(&ss32, sigmask, sizeof(ss32))) 1689 return -EFAULT; 1690 sigset_from_compat(&ksigmask, &ss32); 1691 1692 sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP)); 1693 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved); 1694 } 1695 1696 do { 1697 if (tsp) { 1698 if ((unsigned long)ts.tv_sec < MAX_SELECT_SECONDS) { 1699 timeout = DIV_ROUND_UP(ts.tv_nsec, 1000000000/HZ); 1700 timeout += ts.tv_sec * (unsigned long)HZ; 1701 ts.tv_sec = 0; 1702 ts.tv_nsec = 0; 1703 } else { 1704 ts.tv_sec -= MAX_SELECT_SECONDS; 1705 timeout = MAX_SELECT_SECONDS * HZ; 1706 } 1707 } 1708 1709 ret = compat_core_sys_select(n, inp, outp, exp, &timeout); 1710 1711 } while (!ret && !timeout && tsp && (ts.tv_sec || ts.tv_nsec)); 1712 1713 if (tsp) { 1714 struct compat_timespec rts; 1715 1716 if (current->personality & STICKY_TIMEOUTS) 1717 goto sticky; 1718 1719 rts.tv_sec = timeout / HZ; 1720 rts.tv_nsec = (timeout % HZ) * (NSEC_PER_SEC/HZ); 1721 if (rts.tv_nsec >= NSEC_PER_SEC) { 1722 rts.tv_sec++; 1723 rts.tv_nsec -= NSEC_PER_SEC; 1724 } 1725 if (compat_timespec_compare(&rts, &ts) >= 0) 1726 rts = ts; 1727 if (copy_to_user(tsp, &rts, sizeof(rts))) { 1728sticky: 1729 /* 1730 * If an application puts its timeval in read-only 1731 * memory, we don't want the Linux-specific update to 1732 * the timeval to cause a fault after the select has 1733 * completed successfully. However, because we're not 1734 * updating the timeval, we can't restart the system 1735 * call. 1736 */ 1737 if (ret == -ERESTARTNOHAND) 1738 ret = -EINTR; 1739 } 1740 } 1741 1742 if (ret == -ERESTARTNOHAND) { 1743 /* 1744 * Don't restore the signal mask yet. Let do_signal() deliver 1745 * the signal on the way back to userspace, before the signal 1746 * mask is restored. 1747 */ 1748 if (sigmask) { 1749 memcpy(¤t->saved_sigmask, &sigsaved, 1750 sizeof(sigsaved)); 1751 set_thread_flag(TIF_RESTORE_SIGMASK); 1752 } 1753 } else if (sigmask) 1754 sigprocmask(SIG_SETMASK, &sigsaved, NULL); 1755 1756 return ret; 1757} 1758 1759asmlinkage long compat_sys_pselect6(int n, compat_ulong_t __user *inp, 1760 compat_ulong_t __user *outp, compat_ulong_t __user *exp, 1761 struct compat_timespec __user *tsp, void __user *sig) 1762{ 1763 compat_size_t sigsetsize = 0; 1764 compat_uptr_t up = 0; 1765 1766 if (sig) { 1767 if (!access_ok(VERIFY_READ, sig, 1768 sizeof(compat_uptr_t)+sizeof(compat_size_t)) || 1769 __get_user(up, (compat_uptr_t __user *)sig) || 1770 __get_user(sigsetsize, 1771 (compat_size_t __user *)(sig+sizeof(up)))) 1772 return -EFAULT; 1773 } 1774 return compat_sys_pselect7(n, inp, outp, exp, tsp, compat_ptr(up), 1775 sigsetsize); 1776} 1777 1778asmlinkage long compat_sys_ppoll(struct pollfd __user *ufds, 1779 unsigned int nfds, struct compat_timespec __user *tsp, 1780 const compat_sigset_t __user *sigmask, compat_size_t sigsetsize) 1781{ 1782 compat_sigset_t ss32; 1783 sigset_t ksigmask, sigsaved; 1784 struct compat_timespec ts; 1785 s64 timeout = -1; 1786 int ret; 1787 1788 if (tsp) { 1789 if (copy_from_user(&ts, tsp, sizeof(ts))) 1790 return -EFAULT; 1791 1792 /* We assume that ts.tv_sec is always lower than 1793 the number of seconds that can be expressed in 1794 an s64. Otherwise the compiler bitches at us */ 1795 timeout = DIV_ROUND_UP(ts.tv_nsec, 1000000000/HZ); 1796 timeout += ts.tv_sec * HZ; 1797 } 1798 1799 if (sigmask) { 1800 if (sigsetsize != sizeof(compat_sigset_t)) 1801 return -EINVAL; 1802 if (copy_from_user(&ss32, sigmask, sizeof(ss32))) 1803 return -EFAULT; 1804 sigset_from_compat(&ksigmask, &ss32); 1805 1806 sigdelsetmask(&ksigmask, sigmask(SIGKILL)|sigmask(SIGSTOP)); 1807 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved); 1808 } 1809 1810 ret = do_sys_poll(ufds, nfds, &timeout); 1811 1812 /* We can restart this syscall, usually */ 1813 if (ret == -EINTR) { 1814 /* 1815 * Don't restore the signal mask yet. Let do_signal() deliver 1816 * the signal on the way back to userspace, before the signal 1817 * mask is restored. 1818 */ 1819 if (sigmask) { 1820 memcpy(¤t->saved_sigmask, &sigsaved, 1821 sizeof(sigsaved)); 1822 set_thread_flag(TIF_RESTORE_SIGMASK); 1823 } 1824 ret = -ERESTARTNOHAND; 1825 } else if (sigmask) 1826 sigprocmask(SIG_SETMASK, &sigsaved, NULL); 1827 1828 if (tsp && timeout >= 0) { 1829 struct compat_timespec rts; 1830 1831 if (current->personality & STICKY_TIMEOUTS) 1832 goto sticky; 1833 /* Yes, we know it's actually an s64, but it's also positive. */ 1834 rts.tv_nsec = jiffies_to_usecs(do_div((*(u64*)&timeout), HZ)) * 1835 1000; 1836 rts.tv_sec = timeout; 1837 if (compat_timespec_compare(&rts, &ts) >= 0) 1838 rts = ts; 1839 if (copy_to_user(tsp, &rts, sizeof(rts))) { 1840sticky: 1841 /* 1842 * If an application puts its timeval in read-only 1843 * memory, we don't want the Linux-specific update to 1844 * the timeval to cause a fault after the select has 1845 * completed successfully. However, because we're not 1846 * updating the timeval, we can't restart the system 1847 * call. 1848 */ 1849 if (ret == -ERESTARTNOHAND && timeout >= 0) 1850 ret = -EINTR; 1851 } 1852 } 1853 1854 return ret; 1855} 1856#endif /* TIF_RESTORE_SIGMASK */ 1857 1858#if defined(CONFIG_NFSD) || defined(CONFIG_NFSD_MODULE) 1859/* Stuff for NFS server syscalls... */ 1860struct compat_nfsctl_svc { 1861 u16 svc32_port; 1862 s32 svc32_nthreads; 1863}; 1864 1865struct compat_nfsctl_client { 1866 s8 cl32_ident[NFSCLNT_IDMAX+1]; 1867 s32 cl32_naddr; 1868 struct in_addr cl32_addrlist[NFSCLNT_ADDRMAX]; 1869 s32 cl32_fhkeytype; 1870 s32 cl32_fhkeylen; 1871 u8 cl32_fhkey[NFSCLNT_KEYMAX]; 1872}; 1873 1874struct compat_nfsctl_export { 1875 char ex32_client[NFSCLNT_IDMAX+1]; 1876 char ex32_path[NFS_MAXPATHLEN+1]; 1877 compat_dev_t ex32_dev; 1878 compat_ino_t ex32_ino; 1879 compat_int_t ex32_flags; 1880 __compat_uid_t ex32_anon_uid; 1881 __compat_gid_t ex32_anon_gid; 1882}; 1883 1884struct compat_nfsctl_fdparm { 1885 struct sockaddr gd32_addr; 1886 s8 gd32_path[NFS_MAXPATHLEN+1]; 1887 compat_int_t gd32_version; 1888}; 1889 1890struct compat_nfsctl_fsparm { 1891 struct sockaddr gd32_addr; 1892 s8 gd32_path[NFS_MAXPATHLEN+1]; 1893 compat_int_t gd32_maxlen; 1894}; 1895 1896struct compat_nfsctl_arg { 1897 compat_int_t ca32_version; /* safeguard */ 1898 union { 1899 struct compat_nfsctl_svc u32_svc; 1900 struct compat_nfsctl_client u32_client; 1901 struct compat_nfsctl_export u32_export; 1902 struct compat_nfsctl_fdparm u32_getfd; 1903 struct compat_nfsctl_fsparm u32_getfs; 1904 } u; 1905#define ca32_svc u.u32_svc 1906#define ca32_client u.u32_client 1907#define ca32_export u.u32_export 1908#define ca32_getfd u.u32_getfd 1909#define ca32_getfs u.u32_getfs 1910}; 1911 1912union compat_nfsctl_res { 1913 __u8 cr32_getfh[NFS_FHSIZE]; 1914 struct knfsd_fh cr32_getfs; 1915}; 1916 1917static int compat_nfs_svc_trans(struct nfsctl_arg *karg, 1918 struct compat_nfsctl_arg __user *arg) 1919{ 1920 if (!access_ok(VERIFY_READ, &arg->ca32_svc, sizeof(arg->ca32_svc)) || 1921 get_user(karg->ca_version, &arg->ca32_version) || 1922 __get_user(karg->ca_svc.svc_port, &arg->ca32_svc.svc32_port) || 1923 __get_user(karg->ca_svc.svc_nthreads, 1924 &arg->ca32_svc.svc32_nthreads)) 1925 return -EFAULT; 1926 return 0; 1927} 1928 1929static int compat_nfs_clnt_trans(struct nfsctl_arg *karg, 1930 struct compat_nfsctl_arg __user *arg) 1931{ 1932 if (!access_ok(VERIFY_READ, &arg->ca32_client, 1933 sizeof(arg->ca32_client)) || 1934 get_user(karg->ca_version, &arg->ca32_version) || 1935 __copy_from_user(&karg->ca_client.cl_ident[0], 1936 &arg->ca32_client.cl32_ident[0], 1937 NFSCLNT_IDMAX) || 1938 __get_user(karg->ca_client.cl_naddr, 1939 &arg->ca32_client.cl32_naddr) || 1940 __copy_from_user(&karg->ca_client.cl_addrlist[0], 1941 &arg->ca32_client.cl32_addrlist[0], 1942 (sizeof(struct in_addr) * NFSCLNT_ADDRMAX)) || 1943 __get_user(karg->ca_client.cl_fhkeytype, 1944 &arg->ca32_client.cl32_fhkeytype) || 1945 __get_user(karg->ca_client.cl_fhkeylen, 1946 &arg->ca32_client.cl32_fhkeylen) || 1947 __copy_from_user(&karg->ca_client.cl_fhkey[0], 1948 &arg->ca32_client.cl32_fhkey[0], 1949 NFSCLNT_KEYMAX)) 1950 return -EFAULT; 1951 1952 return 0; 1953} 1954 1955static int compat_nfs_exp_trans(struct nfsctl_arg *karg, 1956 struct compat_nfsctl_arg __user *arg) 1957{ 1958 if (!access_ok(VERIFY_READ, &arg->ca32_export, 1959 sizeof(arg->ca32_export)) || 1960 get_user(karg->ca_version, &arg->ca32_version) || 1961 __copy_from_user(&karg->ca_export.ex_client[0], 1962 &arg->ca32_export.ex32_client[0], 1963 NFSCLNT_IDMAX) || 1964 __copy_from_user(&karg->ca_export.ex_path[0], 1965 &arg->ca32_export.ex32_path[0], 1966 NFS_MAXPATHLEN) || 1967 __get_user(karg->ca_export.ex_dev, 1968 &arg->ca32_export.ex32_dev) || 1969 __get_user(karg->ca_export.ex_ino, 1970 &arg->ca32_export.ex32_ino) || 1971 __get_user(karg->ca_export.ex_flags, 1972 &arg->ca32_export.ex32_flags) || 1973 __get_user(karg->ca_export.ex_anon_uid, 1974 &arg->ca32_export.ex32_anon_uid) || 1975 __get_user(karg->ca_export.ex_anon_gid, 1976 &arg->ca32_export.ex32_anon_gid)) 1977 return -EFAULT; 1978 SET_UID(karg->ca_export.ex_anon_uid, karg->ca_export.ex_anon_uid); 1979 SET_GID(karg->ca_export.ex_anon_gid, karg->ca_export.ex_anon_gid); 1980 1981 return 0; 1982} 1983 1984static int compat_nfs_getfd_trans(struct nfsctl_arg *karg, 1985 struct compat_nfsctl_arg __user *arg) 1986{ 1987 if (!access_ok(VERIFY_READ, &arg->ca32_getfd, 1988 sizeof(arg->ca32_getfd)) || 1989 get_user(karg->ca_version, &arg->ca32_version) || 1990 __copy_from_user(&karg->ca_getfd.gd_addr, 1991 &arg->ca32_getfd.gd32_addr, 1992 (sizeof(struct sockaddr))) || 1993 __copy_from_user(&karg->ca_getfd.gd_path, 1994 &arg->ca32_getfd.gd32_path, 1995 (NFS_MAXPATHLEN+1)) || 1996 __get_user(karg->ca_getfd.gd_version, 1997 &arg->ca32_getfd.gd32_version)) 1998 return -EFAULT; 1999 2000 return 0; 2001} 2002 2003static int compat_nfs_getfs_trans(struct nfsctl_arg *karg, 2004 struct compat_nfsctl_arg __user *arg) 2005{ 2006 if (!access_ok(VERIFY_READ,&arg->ca32_getfs,sizeof(arg->ca32_getfs)) || 2007 get_user(karg->ca_version, &arg->ca32_version) || 2008 __copy_from_user(&karg->ca_getfs.gd_addr, 2009 &arg->ca32_getfs.gd32_addr, 2010 (sizeof(struct sockaddr))) || 2011 __copy_from_user(&karg->ca_getfs.gd_path, 2012 &arg->ca32_getfs.gd32_path, 2013 (NFS_MAXPATHLEN+1)) || 2014 __get_user(karg->ca_getfs.gd_maxlen, 2015 &arg->ca32_getfs.gd32_maxlen)) 2016 return -EFAULT; 2017 2018 return 0; 2019} 2020 2021/* This really doesn't need translations, we are only passing 2022 * back a union which contains opaque nfs file handle data. 2023 */ 2024static int compat_nfs_getfh_res_trans(union nfsctl_res *kres, 2025 union compat_nfsctl_res __user *res) 2026{ 2027 int err; 2028 2029 err = copy_to_user(res, kres, sizeof(*res)); 2030 2031 return (err) ? -EFAULT : 0; 2032} 2033 2034asmlinkage long compat_sys_nfsservctl(int cmd, 2035 struct compat_nfsctl_arg __user *arg, 2036 union compat_nfsctl_res __user *res) 2037{ 2038 struct nfsctl_arg *karg; 2039 union nfsctl_res *kres; 2040 mm_segment_t oldfs; 2041 int err; 2042 2043 karg = kmalloc(sizeof(*karg), GFP_USER); 2044 kres = kmalloc(sizeof(*kres), GFP_USER); 2045 if(!karg || !kres) { 2046 err = -ENOMEM; 2047 goto done; 2048 } 2049 2050 switch(cmd) { 2051 case NFSCTL_SVC: 2052 err = compat_nfs_svc_trans(karg, arg); 2053 break; 2054 2055 case NFSCTL_ADDCLIENT: 2056 err = compat_nfs_clnt_trans(karg, arg); 2057 break; 2058 2059 case NFSCTL_DELCLIENT: 2060 err = compat_nfs_clnt_trans(karg, arg); 2061 break; 2062 2063 case NFSCTL_EXPORT: 2064 case NFSCTL_UNEXPORT: 2065 err = compat_nfs_exp_trans(karg, arg); 2066 break; 2067 2068 case NFSCTL_GETFD: 2069 err = compat_nfs_getfd_trans(karg, arg); 2070 break; 2071 2072 case NFSCTL_GETFS: 2073 err = compat_nfs_getfs_trans(karg, arg); 2074 break; 2075 2076 default: 2077 err = -EINVAL; 2078 break; 2079 } 2080 2081 if (err) 2082 goto done; 2083 2084 oldfs = get_fs(); 2085 set_fs(KERNEL_DS); 2086 /* The __user pointer casts are valid because of the set_fs() */ 2087 err = sys_nfsservctl(cmd, (void __user *) karg, (void __user *) kres); 2088 set_fs(oldfs); 2089 2090 if (err) 2091 goto done; 2092 2093 if((cmd == NFSCTL_GETFD) || 2094 (cmd == NFSCTL_GETFS)) 2095 err = compat_nfs_getfh_res_trans(kres, res); 2096 2097done: 2098 kfree(karg); 2099 kfree(kres); 2100 return err; 2101} 2102#else /* !NFSD */ 2103long asmlinkage compat_sys_nfsservctl(int cmd, void *notused, void *notused2) 2104{ 2105 return sys_ni_syscall(); 2106} 2107#endif 2108 2109#ifdef CONFIG_EPOLL 2110 2111#ifdef CONFIG_HAS_COMPAT_EPOLL_EVENT 2112asmlinkage long compat_sys_epoll_ctl(int epfd, int op, int fd, 2113 struct compat_epoll_event __user *event) 2114{ 2115 long err = 0; 2116 struct compat_epoll_event user; 2117 struct epoll_event __user *kernel = NULL; 2118 2119 if (event) { 2120 if (copy_from_user(&user, event, sizeof(user))) 2121 return -EFAULT; 2122 kernel = compat_alloc_user_space(sizeof(struct epoll_event)); 2123 err |= __put_user(user.events, &kernel->events); 2124 err |= __put_user(user.data, &kernel->data); 2125 } 2126 2127 return err ? err : sys_epoll_ctl(epfd, op, fd, kernel); 2128} 2129 2130 2131asmlinkage long compat_sys_epoll_wait(int epfd, 2132 struct compat_epoll_event __user *events, 2133 int maxevents, int timeout) 2134{ 2135 long i, ret, err = 0; 2136 struct epoll_event __user *kbuf; 2137 struct epoll_event ev; 2138 2139 if ((maxevents <= 0) || 2140 (maxevents > (INT_MAX / sizeof(struct epoll_event)))) 2141 return -EINVAL; 2142 kbuf = compat_alloc_user_space(sizeof(struct epoll_event) * maxevents); 2143 ret = sys_epoll_wait(epfd, kbuf, maxevents, timeout); 2144 for (i = 0; i < ret; i++) { 2145 err |= __get_user(ev.events, &kbuf[i].events); 2146 err |= __get_user(ev.data, &kbuf[i].data); 2147 err |= __put_user(ev.events, &events->events); 2148 err |= __put_user_unaligned(ev.data, &events->data); 2149 events++; 2150 } 2151 2152 return err ? -EFAULT: ret; 2153} 2154#endif /* CONFIG_HAS_COMPAT_EPOLL_EVENT */ 2155 2156#ifdef TIF_RESTORE_SIGMASK 2157asmlinkage long compat_sys_epoll_pwait(int epfd, 2158 struct compat_epoll_event __user *events, 2159 int maxevents, int timeout, 2160 const compat_sigset_t __user *sigmask, 2161 compat_size_t sigsetsize) 2162{ 2163 long err; 2164 compat_sigset_t csigmask; 2165 sigset_t ksigmask, sigsaved; 2166 2167 /* 2168 * If the caller wants a certain signal mask to be set during the wait, 2169 * we apply it here. 2170 */ 2171 if (sigmask) { 2172 if (sigsetsize != sizeof(compat_sigset_t)) 2173 return -EINVAL; 2174 if (copy_from_user(&csigmask, sigmask, sizeof(csigmask))) 2175 return -EFAULT; 2176 sigset_from_compat(&ksigmask, &csigmask); 2177 sigdelsetmask(&ksigmask, sigmask(SIGKILL) | sigmask(SIGSTOP)); 2178 sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved); 2179 } 2180 2181#ifdef CONFIG_HAS_COMPAT_EPOLL_EVENT 2182 err = compat_sys_epoll_wait(epfd, events, maxevents, timeout); 2183#else 2184 err = sys_epoll_wait(epfd, events, maxevents, timeout); 2185#endif 2186 2187 /* 2188 * If we changed the signal mask, we need to restore the original one. 2189 * In case we've got a signal while waiting, we do not restore the 2190 * signal mask yet, and we allow do_signal() to deliver the signal on 2191 * the way back to userspace, before the signal mask is restored. 2192 */ 2193 if (sigmask) { 2194 if (err == -EINTR) { 2195 memcpy(¤t->saved_sigmask, &sigsaved, 2196 sizeof(sigsaved)); 2197 set_thread_flag(TIF_RESTORE_SIGMASK); 2198 } else 2199 sigprocmask(SIG_SETMASK, &sigsaved, NULL); 2200 } 2201 2202 return err; 2203} 2204#endif /* TIF_RESTORE_SIGMASK */ 2205 2206#endif /* CONFIG_EPOLL */ 2207 2208#ifdef CONFIG_SIGNALFD 2209 2210asmlinkage long compat_sys_signalfd(int ufd, 2211 const compat_sigset_t __user *sigmask, 2212 compat_size_t sigsetsize) 2213{ 2214 compat_sigset_t ss32; 2215 sigset_t tmp; 2216 sigset_t __user *ksigmask; 2217 2218 if (sigsetsize != sizeof(compat_sigset_t)) 2219 return -EINVAL; 2220 if (copy_from_user(&ss32, sigmask, sizeof(ss32))) 2221 return -EFAULT; 2222 sigset_from_compat(&tmp, &ss32); 2223 ksigmask = compat_alloc_user_space(sizeof(sigset_t)); 2224 if (copy_to_user(ksigmask, &tmp, sizeof(sigset_t))) 2225 return -EFAULT; 2226 2227 return sys_signalfd(ufd, ksigmask, sizeof(sigset_t)); 2228} 2229 2230#endif /* CONFIG_SIGNALFD */ 2231 2232#ifdef CONFIG_TIMERFD 2233 2234asmlinkage long compat_sys_timerfd(int ufd, int clockid, int flags, 2235 const struct compat_itimerspec __user *utmr) 2236{ 2237 struct itimerspec t; 2238 struct itimerspec __user *ut; 2239 2240 if (get_compat_itimerspec(&t, utmr)) 2241 return -EFAULT; 2242 ut = compat_alloc_user_space(sizeof(*ut)); 2243 if (copy_to_user(ut, &t, sizeof(t))) 2244 return -EFAULT; 2245 2246 return sys_timerfd(ufd, clockid, flags, ut); 2247} 2248 2249#endif /* CONFIG_TIMERFD */ 2250