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