4 * Kernel compatibililty routines for e.g. 32 bit syscall support
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)
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.
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>
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/ncp_mount.h>
33 #include <linux/nfs4_mount.h>
34 #include <linux/syscalls.h>
35 #include <linux/ctype.h>
36 #include <linux/module.h>
37 #include <linux/dirent.h>
38 #include <linux/fsnotify.h>
39 #include <linux/highuid.h>
40 #include <linux/nfsd/syscall.h>
41 #include <linux/personality.h>
42 #include <linux/rwsem.h>
43 #include <linux/tsacct_kern.h>
44 #include <linux/security.h>
45 #include <linux/highmem.h>
46 #include <linux/signal.h>
47 #include <linux/poll.h>
49 #include <linux/eventpoll.h>
50 #include <linux/fs_struct.h>
51 #include <linux/slab.h>
52 #include <linux/pagemap.h>
54 #include <asm/uaccess.h>
55 #include <asm/mmu_context.h>
56 #include <asm/ioctls.h>
61 int compat_printk(const char *fmt
, ...)
68 ret
= vprintk(fmt
, ap
);
73 #include "read_write.h"
76 * Not all architectures have sys_utime, so implement this in terms
79 asmlinkage
long compat_sys_utime(const char __user
*filename
,
80 struct compat_utimbuf __user
*t
)
82 struct timespec tv
[2];
85 if (get_user(tv
[0].tv_sec
, &t
->actime
) ||
86 get_user(tv
[1].tv_sec
, &t
->modtime
))
91 return do_utimes(AT_FDCWD
, filename
, t
? tv
: NULL
, 0);
94 asmlinkage
long compat_sys_utimensat(unsigned int dfd
, const char __user
*filename
, struct compat_timespec __user
*t
, int flags
)
96 struct timespec tv
[2];
99 if (get_compat_timespec(&tv
[0], &t
[0]) ||
100 get_compat_timespec(&tv
[1], &t
[1]))
103 if (tv
[0].tv_nsec
== UTIME_OMIT
&& tv
[1].tv_nsec
== UTIME_OMIT
)
106 return do_utimes(dfd
, filename
, t
? tv
: NULL
, flags
);
109 asmlinkage
long compat_sys_futimesat(unsigned int dfd
, const char __user
*filename
, struct compat_timeval __user
*t
)
111 struct timespec tv
[2];
114 if (get_user(tv
[0].tv_sec
, &t
[0].tv_sec
) ||
115 get_user(tv
[0].tv_nsec
, &t
[0].tv_usec
) ||
116 get_user(tv
[1].tv_sec
, &t
[1].tv_sec
) ||
117 get_user(tv
[1].tv_nsec
, &t
[1].tv_usec
))
119 if (tv
[0].tv_nsec
>= 1000000 || tv
[0].tv_nsec
< 0 ||
120 tv
[1].tv_nsec
>= 1000000 || tv
[1].tv_nsec
< 0)
122 tv
[0].tv_nsec
*= 1000;
123 tv
[1].tv_nsec
*= 1000;
125 return do_utimes(dfd
, filename
, t
? tv
: NULL
, 0);
128 asmlinkage
long compat_sys_utimes(const char __user
*filename
, struct compat_timeval __user
*t
)
130 return compat_sys_futimesat(AT_FDCWD
, filename
, t
);
133 static int cp_compat_stat(struct kstat
*stat
, struct compat_stat __user
*ubuf
)
135 compat_ino_t ino
= stat
->ino
;
136 typeof(ubuf
->st_uid
) uid
= 0;
137 typeof(ubuf
->st_gid
) gid
= 0;
140 SET_UID(uid
, stat
->uid
);
141 SET_GID(gid
, stat
->gid
);
143 if ((u64
) stat
->size
> MAX_NON_LFS
||
144 !old_valid_dev(stat
->dev
) ||
145 !old_valid_dev(stat
->rdev
))
147 if (sizeof(ino
) < sizeof(stat
->ino
) && ino
!= stat
->ino
)
150 if (clear_user(ubuf
, sizeof(*ubuf
)))
153 err
= __put_user(old_encode_dev(stat
->dev
), &ubuf
->st_dev
);
154 err
|= __put_user(ino
, &ubuf
->st_ino
);
155 err
|= __put_user(stat
->mode
, &ubuf
->st_mode
);
156 err
|= __put_user(stat
->nlink
, &ubuf
->st_nlink
);
157 err
|= __put_user(uid
, &ubuf
->st_uid
);
158 err
|= __put_user(gid
, &ubuf
->st_gid
);
159 err
|= __put_user(old_encode_dev(stat
->rdev
), &ubuf
->st_rdev
);
160 err
|= __put_user(stat
->size
, &ubuf
->st_size
);
161 err
|= __put_user(stat
->atime
.tv_sec
, &ubuf
->st_atime
);
162 err
|= __put_user(stat
->atime
.tv_nsec
, &ubuf
->st_atime_nsec
);
163 err
|= __put_user(stat
->mtime
.tv_sec
, &ubuf
->st_mtime
);
164 err
|= __put_user(stat
->mtime
.tv_nsec
, &ubuf
->st_mtime_nsec
);
165 err
|= __put_user(stat
->ctime
.tv_sec
, &ubuf
->st_ctime
);
166 err
|= __put_user(stat
->ctime
.tv_nsec
, &ubuf
->st_ctime_nsec
);
167 err
|= __put_user(stat
->blksize
, &ubuf
->st_blksize
);
168 err
|= __put_user(stat
->blocks
, &ubuf
->st_blocks
);
172 asmlinkage
long compat_sys_newstat(const char __user
* filename
,
173 struct compat_stat __user
*statbuf
)
178 error
= vfs_stat(filename
, &stat
);
181 return cp_compat_stat(&stat
, statbuf
);
184 asmlinkage
long compat_sys_newlstat(const char __user
* filename
,
185 struct compat_stat __user
*statbuf
)
190 error
= vfs_lstat(filename
, &stat
);
193 return cp_compat_stat(&stat
, statbuf
);
196 #ifndef __ARCH_WANT_STAT64
197 asmlinkage
long compat_sys_newfstatat(unsigned int dfd
,
198 const char __user
*filename
,
199 struct compat_stat __user
*statbuf
, int flag
)
204 error
= vfs_fstatat(dfd
, filename
, &stat
, flag
);
207 return cp_compat_stat(&stat
, statbuf
);
211 asmlinkage
long compat_sys_newfstat(unsigned int fd
,
212 struct compat_stat __user
* statbuf
)
215 int error
= vfs_fstat(fd
, &stat
);
218 error
= cp_compat_stat(&stat
, statbuf
);
222 static int put_compat_statfs(struct compat_statfs __user
*ubuf
, struct kstatfs
*kbuf
)
225 if (sizeof ubuf
->f_blocks
== 4) {
226 if ((kbuf
->f_blocks
| kbuf
->f_bfree
| kbuf
->f_bavail
|
227 kbuf
->f_bsize
| kbuf
->f_frsize
) & 0xffffffff00000000ULL
)
229 /* f_files and f_ffree may be -1; it's okay
230 * to stuff that into 32 bits */
231 if (kbuf
->f_files
!= 0xffffffffffffffffULL
232 && (kbuf
->f_files
& 0xffffffff00000000ULL
))
234 if (kbuf
->f_ffree
!= 0xffffffffffffffffULL
235 && (kbuf
->f_ffree
& 0xffffffff00000000ULL
))
238 if (!access_ok(VERIFY_WRITE
, ubuf
, sizeof(*ubuf
)) ||
239 __put_user(kbuf
->f_type
, &ubuf
->f_type
) ||
240 __put_user(kbuf
->f_bsize
, &ubuf
->f_bsize
) ||
241 __put_user(kbuf
->f_blocks
, &ubuf
->f_blocks
) ||
242 __put_user(kbuf
->f_bfree
, &ubuf
->f_bfree
) ||
243 __put_user(kbuf
->f_bavail
, &ubuf
->f_bavail
) ||
244 __put_user(kbuf
->f_files
, &ubuf
->f_files
) ||
245 __put_user(kbuf
->f_ffree
, &ubuf
->f_ffree
) ||
246 __put_user(kbuf
->f_namelen
, &ubuf
->f_namelen
) ||
247 __put_user(kbuf
->f_fsid
.val
[0], &ubuf
->f_fsid
.val
[0]) ||
248 __put_user(kbuf
->f_fsid
.val
[1], &ubuf
->f_fsid
.val
[1]) ||
249 __put_user(kbuf
->f_frsize
, &ubuf
->f_frsize
) ||
250 __put_user(0, &ubuf
->f_spare
[0]) ||
251 __put_user(0, &ubuf
->f_spare
[1]) ||
252 __put_user(0, &ubuf
->f_spare
[2]) ||
253 __put_user(0, &ubuf
->f_spare
[3]) ||
254 __put_user(0, &ubuf
->f_spare
[4]))
260 * The following statfs calls are copies of code from fs/open.c and
261 * should be checked against those from time to time
263 asmlinkage
long compat_sys_statfs(const char __user
*pathname
, struct compat_statfs __user
*buf
)
268 error
= user_path(pathname
, &path
);
271 error
= vfs_statfs(&path
, &tmp
);
273 error
= put_compat_statfs(buf
, &tmp
);
279 asmlinkage
long compat_sys_fstatfs(unsigned int fd
, struct compat_statfs __user
*buf
)
289 error
= vfs_statfs(&file
->f_path
, &tmp
);
291 error
= put_compat_statfs(buf
, &tmp
);
297 static int put_compat_statfs64(struct compat_statfs64 __user
*ubuf
, struct kstatfs
*kbuf
)
299 if (sizeof ubuf
->f_blocks
== 4) {
300 if ((kbuf
->f_blocks
| kbuf
->f_bfree
| kbuf
->f_bavail
|
301 kbuf
->f_bsize
| kbuf
->f_frsize
) & 0xffffffff00000000ULL
)
303 /* f_files and f_ffree may be -1; it's okay
304 * to stuff that into 32 bits */
305 if (kbuf
->f_files
!= 0xffffffffffffffffULL
306 && (kbuf
->f_files
& 0xffffffff00000000ULL
))
308 if (kbuf
->f_ffree
!= 0xffffffffffffffffULL
309 && (kbuf
->f_ffree
& 0xffffffff00000000ULL
))
312 if (!access_ok(VERIFY_WRITE
, ubuf
, sizeof(*ubuf
)) ||
313 __put_user(kbuf
->f_type
, &ubuf
->f_type
) ||
314 __put_user(kbuf
->f_bsize
, &ubuf
->f_bsize
) ||
315 __put_user(kbuf
->f_blocks
, &ubuf
->f_blocks
) ||
316 __put_user(kbuf
->f_bfree
, &ubuf
->f_bfree
) ||
317 __put_user(kbuf
->f_bavail
, &ubuf
->f_bavail
) ||
318 __put_user(kbuf
->f_files
, &ubuf
->f_files
) ||
319 __put_user(kbuf
->f_ffree
, &ubuf
->f_ffree
) ||
320 __put_user(kbuf
->f_namelen
, &ubuf
->f_namelen
) ||
321 __put_user(kbuf
->f_fsid
.val
[0], &ubuf
->f_fsid
.val
[0]) ||
322 __put_user(kbuf
->f_fsid
.val
[1], &ubuf
->f_fsid
.val
[1]) ||
323 __put_user(kbuf
->f_frsize
, &ubuf
->f_frsize
))
328 asmlinkage
long compat_sys_statfs64(const char __user
*pathname
, compat_size_t sz
, struct compat_statfs64 __user
*buf
)
333 if (sz
!= sizeof(*buf
))
336 error
= user_path(pathname
, &path
);
339 error
= vfs_statfs(&path
, &tmp
);
341 error
= put_compat_statfs64(buf
, &tmp
);
347 asmlinkage
long compat_sys_fstatfs64(unsigned int fd
, compat_size_t sz
, struct compat_statfs64 __user
*buf
)
353 if (sz
!= sizeof(*buf
))
360 error
= vfs_statfs(&file
->f_path
, &tmp
);
362 error
= put_compat_statfs64(buf
, &tmp
);
369 * This is a copy of sys_ustat, just dealing with a structure layout.
370 * Given how simple this syscall is that apporach is more maintainable
371 * than the various conversion hacks.
373 asmlinkage
long compat_sys_ustat(unsigned dev
, struct compat_ustat __user
*u
)
375 struct super_block
*sb
;
376 struct compat_ustat tmp
;
380 sb
= user_get_super(new_decode_dev(dev
));
383 err
= statfs_by_dentry(sb
->s_root
, &sbuf
);
388 memset(&tmp
, 0, sizeof(struct compat_ustat
));
389 tmp
.f_tfree
= sbuf
.f_bfree
;
390 tmp
.f_tinode
= sbuf
.f_ffree
;
391 if (copy_to_user(u
, &tmp
, sizeof(struct compat_ustat
)))
396 static int get_compat_flock(struct flock
*kfl
, struct compat_flock __user
*ufl
)
398 if (!access_ok(VERIFY_READ
, ufl
, sizeof(*ufl
)) ||
399 __get_user(kfl
->l_type
, &ufl
->l_type
) ||
400 __get_user(kfl
->l_whence
, &ufl
->l_whence
) ||
401 __get_user(kfl
->l_start
, &ufl
->l_start
) ||
402 __get_user(kfl
->l_len
, &ufl
->l_len
) ||
403 __get_user(kfl
->l_pid
, &ufl
->l_pid
))
408 static int put_compat_flock(struct flock
*kfl
, struct compat_flock __user
*ufl
)
410 if (!access_ok(VERIFY_WRITE
, ufl
, sizeof(*ufl
)) ||
411 __put_user(kfl
->l_type
, &ufl
->l_type
) ||
412 __put_user(kfl
->l_whence
, &ufl
->l_whence
) ||
413 __put_user(kfl
->l_start
, &ufl
->l_start
) ||
414 __put_user(kfl
->l_len
, &ufl
->l_len
) ||
415 __put_user(kfl
->l_pid
, &ufl
->l_pid
))
420 #ifndef HAVE_ARCH_GET_COMPAT_FLOCK64
421 static int get_compat_flock64(struct flock
*kfl
, struct compat_flock64 __user
*ufl
)
423 if (!access_ok(VERIFY_READ
, ufl
, sizeof(*ufl
)) ||
424 __get_user(kfl
->l_type
, &ufl
->l_type
) ||
425 __get_user(kfl
->l_whence
, &ufl
->l_whence
) ||
426 __get_user(kfl
->l_start
, &ufl
->l_start
) ||
427 __get_user(kfl
->l_len
, &ufl
->l_len
) ||
428 __get_user(kfl
->l_pid
, &ufl
->l_pid
))
434 #ifndef HAVE_ARCH_PUT_COMPAT_FLOCK64
435 static int put_compat_flock64(struct flock
*kfl
, struct compat_flock64 __user
*ufl
)
437 if (!access_ok(VERIFY_WRITE
, ufl
, sizeof(*ufl
)) ||
438 __put_user(kfl
->l_type
, &ufl
->l_type
) ||
439 __put_user(kfl
->l_whence
, &ufl
->l_whence
) ||
440 __put_user(kfl
->l_start
, &ufl
->l_start
) ||
441 __put_user(kfl
->l_len
, &ufl
->l_len
) ||
442 __put_user(kfl
->l_pid
, &ufl
->l_pid
))
448 asmlinkage
long compat_sys_fcntl64(unsigned int fd
, unsigned int cmd
,
459 ret
= get_compat_flock(&f
, compat_ptr(arg
));
464 ret
= sys_fcntl(fd
, cmd
, (unsigned long)&f
);
466 if (cmd
== F_GETLK
&& ret
== 0) {
467 /* GETLK was successful and we need to return the data...
468 * but it needs to fit in the compat structure.
469 * l_start shouldn't be too big, unless the original
470 * start + end is greater than COMPAT_OFF_T_MAX, in which
471 * case the app was asking for trouble, so we return
472 * -EOVERFLOW in that case.
473 * l_len could be too big, in which case we just truncate it,
474 * and only allow the app to see that part of the conflicting
475 * lock that might make sense to it anyway
478 if (f
.l_start
> COMPAT_OFF_T_MAX
)
480 if (f
.l_len
> COMPAT_OFF_T_MAX
)
481 f
.l_len
= COMPAT_OFF_T_MAX
;
483 ret
= put_compat_flock(&f
, compat_ptr(arg
));
490 ret
= get_compat_flock64(&f
, compat_ptr(arg
));
495 ret
= sys_fcntl(fd
, (cmd
== F_GETLK64
) ? F_GETLK
:
496 ((cmd
== F_SETLK64
) ? F_SETLK
: F_SETLKW
),
499 if (cmd
== F_GETLK64
&& ret
== 0) {
500 /* need to return lock information - see above for commentary */
501 if (f
.l_start
> COMPAT_LOFF_T_MAX
)
503 if (f
.l_len
> COMPAT_LOFF_T_MAX
)
504 f
.l_len
= COMPAT_LOFF_T_MAX
;
506 ret
= put_compat_flock64(&f
, compat_ptr(arg
));
511 ret
= sys_fcntl(fd
, cmd
, arg
);
517 asmlinkage
long compat_sys_fcntl(unsigned int fd
, unsigned int cmd
,
520 if ((cmd
== F_GETLK64
) || (cmd
== F_SETLK64
) || (cmd
== F_SETLKW64
))
522 return compat_sys_fcntl64(fd
, cmd
, arg
);
526 compat_sys_io_setup(unsigned nr_reqs
, u32 __user
*ctx32p
)
531 mm_segment_t oldfs
= get_fs();
532 if (unlikely(get_user(ctx64
, ctx32p
)))
536 /* The __user pointer cast is valid because of the set_fs() */
537 ret
= sys_io_setup(nr_reqs
, (aio_context_t __user
*) &ctx64
);
539 /* truncating is ok because it's a user address */
541 ret
= put_user((u32
) ctx64
, ctx32p
);
546 compat_sys_io_getevents(aio_context_t ctx_id
,
547 unsigned long min_nr
,
549 struct io_event __user
*events
,
550 struct compat_timespec __user
*timeout
)
554 struct timespec __user
*ut
= NULL
;
557 if (unlikely(!access_ok(VERIFY_WRITE
, events
,
558 nr
* sizeof(struct io_event
))))
561 if (get_compat_timespec(&t
, timeout
))
564 ut
= compat_alloc_user_space(sizeof(*ut
));
565 if (copy_to_user(ut
, &t
, sizeof(t
)) )
568 ret
= sys_io_getevents(ctx_id
, min_nr
, nr
, events
, ut
);
573 /* A write operation does a read from user space and vice versa */
574 #define vrfy_dir(type) ((type) == READ ? VERIFY_WRITE : VERIFY_READ)
576 ssize_t
compat_rw_copy_check_uvector(int type
,
577 const struct compat_iovec __user
*uvector
, unsigned long nr_segs
,
578 unsigned long fast_segs
, struct iovec
*fast_pointer
,
579 struct iovec
**ret_pointer
)
581 compat_ssize_t tot_len
;
582 struct iovec
*iov
= *ret_pointer
= fast_pointer
;
587 * SuS says "The readv() function *may* fail if the iovcnt argument
588 * was less than or equal to 0, or greater than {IOV_MAX}. Linux has
589 * traditionally returned zero for zero segments, so...
595 if (nr_segs
> UIO_MAXIOV
|| nr_segs
< 0)
597 if (nr_segs
> fast_segs
) {
599 iov
= kmalloc(nr_segs
*sizeof(struct iovec
), GFP_KERNEL
);
606 * Single unix specification:
607 * We should -EINVAL if an element length is not >= 0 and fitting an
610 * In Linux, the total length is limited to MAX_RW_COUNT, there is
611 * no overflow possibility.
615 for (seg
= 0; seg
< nr_segs
; seg
++) {
619 if (__get_user(len
, &uvector
->iov_len
) ||
620 __get_user(buf
, &uvector
->iov_base
)) {
624 if (len
< 0) /* size_t not fitting in compat_ssize_t .. */
626 if (!access_ok(vrfy_dir(type
), compat_ptr(buf
), len
)) {
630 if (len
> MAX_RW_COUNT
- tot_len
)
631 len
= MAX_RW_COUNT
- tot_len
;
633 iov
->iov_base
= compat_ptr(buf
);
634 iov
->iov_len
= (compat_size_t
) len
;
645 copy_iocb(long nr
, u32 __user
*ptr32
, struct iocb __user
* __user
*ptr64
)
650 for (i
= 0; i
< nr
; ++i
) {
651 if (get_user(uptr
, ptr32
+ i
))
653 if (put_user(compat_ptr(uptr
), ptr64
+ i
))
659 #define MAX_AIO_SUBMITS (PAGE_SIZE/sizeof(struct iocb *))
662 compat_sys_io_submit(aio_context_t ctx_id
, int nr
, u32 __user
*iocb
)
664 struct iocb __user
* __user
*iocb64
;
667 if (unlikely(nr
< 0))
670 if (nr
> MAX_AIO_SUBMITS
)
671 nr
= MAX_AIO_SUBMITS
;
673 iocb64
= compat_alloc_user_space(nr
* sizeof(*iocb64
));
674 ret
= copy_iocb(nr
, iocb
, iocb64
);
676 ret
= do_io_submit(ctx_id
, nr
, iocb64
, 1);
680 struct compat_ncp_mount_data
{
681 compat_int_t version
;
682 compat_uint_t ncp_fd
;
683 __compat_uid_t mounted_uid
;
684 compat_pid_t wdog_pid
;
685 unsigned char mounted_vol
[NCP_VOLNAME_LEN
+ 1];
686 compat_uint_t time_out
;
687 compat_uint_t retry_count
;
691 compat_mode_t file_mode
;
692 compat_mode_t dir_mode
;
695 struct compat_ncp_mount_data_v4
{
696 compat_int_t version
;
697 compat_ulong_t flags
;
698 compat_ulong_t mounted_uid
;
699 compat_long_t wdog_pid
;
700 compat_uint_t ncp_fd
;
701 compat_uint_t time_out
;
702 compat_uint_t retry_count
;
705 compat_ulong_t file_mode
;
706 compat_ulong_t dir_mode
;
709 static void *do_ncp_super_data_conv(void *raw_data
)
711 int version
= *(unsigned int *)raw_data
;
714 struct compat_ncp_mount_data
*c_n
= raw_data
;
715 struct ncp_mount_data
*n
= raw_data
;
717 n
->dir_mode
= c_n
->dir_mode
;
718 n
->file_mode
= c_n
->file_mode
;
721 memmove (n
->mounted_vol
, c_n
->mounted_vol
, (sizeof (c_n
->mounted_vol
) + 3 * sizeof (unsigned int)));
722 n
->wdog_pid
= c_n
->wdog_pid
;
723 n
->mounted_uid
= c_n
->mounted_uid
;
724 } else if (version
== 4) {
725 struct compat_ncp_mount_data_v4
*c_n
= raw_data
;
726 struct ncp_mount_data_v4
*n
= raw_data
;
728 n
->dir_mode
= c_n
->dir_mode
;
729 n
->file_mode
= c_n
->file_mode
;
732 n
->retry_count
= c_n
->retry_count
;
733 n
->time_out
= c_n
->time_out
;
734 n
->ncp_fd
= c_n
->ncp_fd
;
735 n
->wdog_pid
= c_n
->wdog_pid
;
736 n
->mounted_uid
= c_n
->mounted_uid
;
737 n
->flags
= c_n
->flags
;
738 } else if (version
!= 5) {
746 struct compat_nfs_string
{
751 static inline void compat_nfs_string(struct nfs_string
*dst
,
752 struct compat_nfs_string
*src
)
754 dst
->data
= compat_ptr(src
->data
);
758 struct compat_nfs4_mount_data_v1
{
759 compat_int_t version
;
764 compat_int_t retrans
;
765 compat_int_t acregmin
;
766 compat_int_t acregmax
;
767 compat_int_t acdirmin
;
768 compat_int_t acdirmax
;
769 struct compat_nfs_string client_addr
;
770 struct compat_nfs_string mnt_path
;
771 struct compat_nfs_string hostname
;
772 compat_uint_t host_addrlen
;
773 compat_uptr_t host_addr
;
775 compat_int_t auth_flavourlen
;
776 compat_uptr_t auth_flavours
;
779 static int do_nfs4_super_data_conv(void *raw_data
)
781 int version
= *(compat_uint_t
*) raw_data
;
784 struct compat_nfs4_mount_data_v1
*raw
= raw_data
;
785 struct nfs4_mount_data
*real
= raw_data
;
787 /* copy the fields backwards */
788 real
->auth_flavours
= compat_ptr(raw
->auth_flavours
);
789 real
->auth_flavourlen
= raw
->auth_flavourlen
;
790 real
->proto
= raw
->proto
;
791 real
->host_addr
= compat_ptr(raw
->host_addr
);
792 real
->host_addrlen
= raw
->host_addrlen
;
793 compat_nfs_string(&real
->hostname
, &raw
->hostname
);
794 compat_nfs_string(&real
->mnt_path
, &raw
->mnt_path
);
795 compat_nfs_string(&real
->client_addr
, &raw
->client_addr
);
796 real
->acdirmax
= raw
->acdirmax
;
797 real
->acdirmin
= raw
->acdirmin
;
798 real
->acregmax
= raw
->acregmax
;
799 real
->acregmin
= raw
->acregmin
;
800 real
->retrans
= raw
->retrans
;
801 real
->timeo
= raw
->timeo
;
802 real
->wsize
= raw
->wsize
;
803 real
->rsize
= raw
->rsize
;
804 real
->flags
= raw
->flags
;
805 real
->version
= raw
->version
;
811 #define NCPFS_NAME "ncpfs"
812 #define NFS4_NAME "nfs4"
814 asmlinkage
long compat_sys_mount(const char __user
* dev_name
,
815 const char __user
* dir_name
,
816 const char __user
* type
, unsigned long flags
,
817 const void __user
* data
)
820 unsigned long data_page
;
825 retval
= copy_mount_string(type
, &kernel_type
);
829 dir_page
= getname(dir_name
);
830 retval
= PTR_ERR(dir_page
);
831 if (IS_ERR(dir_page
))
834 retval
= copy_mount_string(dev_name
, &kernel_dev
);
838 retval
= copy_mount_options(data
, &data_page
);
844 if (kernel_type
&& data_page
) {
845 if (!strcmp(kernel_type
, NCPFS_NAME
)) {
846 do_ncp_super_data_conv((void *)data_page
);
847 } else if (!strcmp(kernel_type
, NFS4_NAME
)) {
848 if (do_nfs4_super_data_conv((void *) data_page
))
853 retval
= do_mount(kernel_dev
, dir_page
, kernel_type
,
854 flags
, (void*)data_page
);
857 free_page(data_page
);
868 struct compat_old_linux_dirent
{
869 compat_ulong_t d_ino
;
870 compat_ulong_t d_offset
;
871 unsigned short d_namlen
;
875 struct compat_readdir_callback
{
876 struct compat_old_linux_dirent __user
*dirent
;
880 static int compat_fillonedir(void *__buf
, const char *name
, int namlen
,
881 loff_t offset
, u64 ino
, unsigned int d_type
)
883 struct compat_readdir_callback
*buf
= __buf
;
884 struct compat_old_linux_dirent __user
*dirent
;
885 compat_ulong_t d_ino
;
890 if (sizeof(d_ino
) < sizeof(ino
) && d_ino
!= ino
) {
891 buf
->result
= -EOVERFLOW
;
895 dirent
= buf
->dirent
;
896 if (!access_ok(VERIFY_WRITE
, dirent
,
897 (unsigned long)(dirent
->d_name
+ namlen
+ 1) -
898 (unsigned long)dirent
))
900 if ( __put_user(d_ino
, &dirent
->d_ino
) ||
901 __put_user(offset
, &dirent
->d_offset
) ||
902 __put_user(namlen
, &dirent
->d_namlen
) ||
903 __copy_to_user(dirent
->d_name
, name
, namlen
) ||
904 __put_user(0, dirent
->d_name
+ namlen
))
908 buf
->result
= -EFAULT
;
912 asmlinkage
long compat_sys_old_readdir(unsigned int fd
,
913 struct compat_old_linux_dirent __user
*dirent
, unsigned int count
)
917 struct compat_readdir_callback buf
;
927 error
= vfs_readdir(file
, compat_fillonedir
, &buf
);
936 struct compat_linux_dirent
{
937 compat_ulong_t d_ino
;
938 compat_ulong_t d_off
;
939 unsigned short d_reclen
;
943 struct compat_getdents_callback
{
944 struct compat_linux_dirent __user
*current_dir
;
945 struct compat_linux_dirent __user
*previous
;
950 static int compat_filldir(void *__buf
, const char *name
, int namlen
,
951 loff_t offset
, u64 ino
, unsigned int d_type
)
953 struct compat_linux_dirent __user
* dirent
;
954 struct compat_getdents_callback
*buf
= __buf
;
955 compat_ulong_t d_ino
;
956 int reclen
= ALIGN(offsetof(struct compat_linux_dirent
, d_name
) +
957 namlen
+ 2, sizeof(compat_long_t
));
959 buf
->error
= -EINVAL
; /* only used if we fail.. */
960 if (reclen
> buf
->count
)
963 if (sizeof(d_ino
) < sizeof(ino
) && d_ino
!= ino
) {
964 buf
->error
= -EOVERFLOW
;
967 dirent
= buf
->previous
;
969 if (__put_user(offset
, &dirent
->d_off
))
972 dirent
= buf
->current_dir
;
973 if (__put_user(d_ino
, &dirent
->d_ino
))
975 if (__put_user(reclen
, &dirent
->d_reclen
))
977 if (copy_to_user(dirent
->d_name
, name
, namlen
))
979 if (__put_user(0, dirent
->d_name
+ namlen
))
981 if (__put_user(d_type
, (char __user
*) dirent
+ reclen
- 1))
983 buf
->previous
= dirent
;
984 dirent
= (void __user
*)dirent
+ reclen
;
985 buf
->current_dir
= dirent
;
986 buf
->count
-= reclen
;
989 buf
->error
= -EFAULT
;
993 asmlinkage
long compat_sys_getdents(unsigned int fd
,
994 struct compat_linux_dirent __user
*dirent
, unsigned int count
)
997 struct compat_linux_dirent __user
* lastdirent
;
998 struct compat_getdents_callback buf
;
1002 if (!access_ok(VERIFY_WRITE
, dirent
, count
))
1010 buf
.current_dir
= dirent
;
1011 buf
.previous
= NULL
;
1015 error
= vfs_readdir(file
, compat_filldir
, &buf
);
1018 lastdirent
= buf
.previous
;
1020 if (put_user(file
->f_pos
, &lastdirent
->d_off
))
1023 error
= count
- buf
.count
;
1030 #ifndef __ARCH_OMIT_COMPAT_SYS_GETDENTS64
1032 struct compat_getdents_callback64
{
1033 struct linux_dirent64 __user
*current_dir
;
1034 struct linux_dirent64 __user
*previous
;
1039 static int compat_filldir64(void * __buf
, const char * name
, int namlen
, loff_t offset
,
1040 u64 ino
, unsigned int d_type
)
1042 struct linux_dirent64 __user
*dirent
;
1043 struct compat_getdents_callback64
*buf
= __buf
;
1044 int reclen
= ALIGN(offsetof(struct linux_dirent64
, d_name
) + namlen
+ 1,
1048 buf
->error
= -EINVAL
; /* only used if we fail.. */
1049 if (reclen
> buf
->count
)
1051 dirent
= buf
->previous
;
1054 if (__put_user_unaligned(offset
, &dirent
->d_off
))
1057 dirent
= buf
->current_dir
;
1058 if (__put_user_unaligned(ino
, &dirent
->d_ino
))
1061 if (__put_user_unaligned(off
, &dirent
->d_off
))
1063 if (__put_user(reclen
, &dirent
->d_reclen
))
1065 if (__put_user(d_type
, &dirent
->d_type
))
1067 if (copy_to_user(dirent
->d_name
, name
, namlen
))
1069 if (__put_user(0, dirent
->d_name
+ namlen
))
1071 buf
->previous
= dirent
;
1072 dirent
= (void __user
*)dirent
+ reclen
;
1073 buf
->current_dir
= dirent
;
1074 buf
->count
-= reclen
;
1077 buf
->error
= -EFAULT
;
1081 asmlinkage
long compat_sys_getdents64(unsigned int fd
,
1082 struct linux_dirent64 __user
* dirent
, unsigned int count
)
1085 struct linux_dirent64 __user
* lastdirent
;
1086 struct compat_getdents_callback64 buf
;
1090 if (!access_ok(VERIFY_WRITE
, dirent
, count
))
1098 buf
.current_dir
= dirent
;
1099 buf
.previous
= NULL
;
1103 error
= vfs_readdir(file
, compat_filldir64
, &buf
);
1106 lastdirent
= buf
.previous
;
1108 typeof(lastdirent
->d_off
) d_off
= file
->f_pos
;
1109 if (__put_user_unaligned(d_off
, &lastdirent
->d_off
))
1112 error
= count
- buf
.count
;
1118 #endif /* ! __ARCH_OMIT_COMPAT_SYS_GETDENTS64 */
1120 static ssize_t
compat_do_readv_writev(int type
, struct file
*file
,
1121 const struct compat_iovec __user
*uvector
,
1122 unsigned long nr_segs
, loff_t
*pos
)
1124 compat_ssize_t tot_len
;
1125 struct iovec iovstack
[UIO_FASTIOV
];
1126 struct iovec
*iov
= iovstack
;
1136 if (!access_ok(VERIFY_READ
, uvector
, nr_segs
*sizeof(*uvector
)))
1139 tot_len
= compat_rw_copy_check_uvector(type
, uvector
, nr_segs
,
1140 UIO_FASTIOV
, iovstack
, &iov
);
1146 ret
= rw_verify_area(type
, file
, pos
, tot_len
);
1152 fn
= file
->f_op
->read
;
1153 fnv
= file
->f_op
->aio_read
;
1155 fn
= (io_fn_t
)file
->f_op
->write
;
1156 fnv
= file
->f_op
->aio_write
;
1160 ret
= do_sync_readv_writev(file
, iov
, nr_segs
, tot_len
,
1163 ret
= do_loop_readv_writev(file
, iov
, nr_segs
, pos
, fn
);
1166 if (iov
!= iovstack
)
1168 if ((ret
+ (type
== READ
)) > 0) {
1170 fsnotify_access(file
);
1172 fsnotify_modify(file
);
1177 static size_t compat_readv(struct file
*file
,
1178 const struct compat_iovec __user
*vec
,
1179 unsigned long vlen
, loff_t
*pos
)
1181 ssize_t ret
= -EBADF
;
1183 if (!(file
->f_mode
& FMODE_READ
))
1187 if (!file
->f_op
|| (!file
->f_op
->aio_read
&& !file
->f_op
->read
))
1190 ret
= compat_do_readv_writev(READ
, file
, vec
, vlen
, pos
);
1194 add_rchar(current
, ret
);
1200 compat_sys_readv(unsigned long fd
, const struct compat_iovec __user
*vec
,
1207 file
= fget_light(fd
, &fput_needed
);
1210 ret
= compat_readv(file
, vec
, vlen
, &file
->f_pos
);
1211 fput_light(file
, fput_needed
);
1216 compat_sys_preadv(unsigned long fd
, const struct compat_iovec __user
*vec
,
1217 unsigned long vlen
, u32 pos_low
, u32 pos_high
)
1219 loff_t pos
= ((loff_t
)pos_high
<< 32) | pos_low
;
1226 file
= fget_light(fd
, &fput_needed
);
1229 ret
= compat_readv(file
, vec
, vlen
, &pos
);
1230 fput_light(file
, fput_needed
);
1234 static size_t compat_writev(struct file
*file
,
1235 const struct compat_iovec __user
*vec
,
1236 unsigned long vlen
, loff_t
*pos
)
1238 ssize_t ret
= -EBADF
;
1240 if (!(file
->f_mode
& FMODE_WRITE
))
1244 if (!file
->f_op
|| (!file
->f_op
->aio_write
&& !file
->f_op
->write
))
1247 ret
= compat_do_readv_writev(WRITE
, file
, vec
, vlen
, pos
);
1251 add_wchar(current
, ret
);
1257 compat_sys_writev(unsigned long fd
, const struct compat_iovec __user
*vec
,
1264 file
= fget_light(fd
, &fput_needed
);
1267 ret
= compat_writev(file
, vec
, vlen
, &file
->f_pos
);
1268 fput_light(file
, fput_needed
);
1273 compat_sys_pwritev(unsigned long fd
, const struct compat_iovec __user
*vec
,
1274 unsigned long vlen
, u32 pos_low
, u32 pos_high
)
1276 loff_t pos
= ((loff_t
)pos_high
<< 32) | pos_low
;
1283 file
= fget_light(fd
, &fput_needed
);
1286 ret
= compat_writev(file
, vec
, vlen
, &pos
);
1287 fput_light(file
, fput_needed
);
1292 compat_sys_vmsplice(int fd
, const struct compat_iovec __user
*iov32
,
1293 unsigned int nr_segs
, unsigned int flags
)
1296 struct iovec __user
*iov
;
1297 if (nr_segs
> UIO_MAXIOV
)
1299 iov
= compat_alloc_user_space(nr_segs
* sizeof(struct iovec
));
1300 for (i
= 0; i
< nr_segs
; i
++) {
1301 struct compat_iovec v
;
1302 if (get_user(v
.iov_base
, &iov32
[i
].iov_base
) ||
1303 get_user(v
.iov_len
, &iov32
[i
].iov_len
) ||
1304 put_user(compat_ptr(v
.iov_base
), &iov
[i
].iov_base
) ||
1305 put_user(v
.iov_len
, &iov
[i
].iov_len
))
1308 return sys_vmsplice(fd
, iov
, nr_segs
, flags
);
1312 * Exactly like fs/open.c:sys_open(), except that it doesn't set the
1316 compat_sys_open(const char __user
*filename
, int flags
, int mode
)
1318 return do_sys_open(AT_FDCWD
, filename
, flags
, mode
);
1322 * Exactly like fs/open.c:sys_openat(), except that it doesn't set the
1326 compat_sys_openat(unsigned int dfd
, const char __user
*filename
, int flags
, int mode
)
1328 return do_sys_open(dfd
, filename
, flags
, mode
);
1332 * compat_count() counts the number of arguments/envelopes. It is basically
1333 * a copy of count() from fs/exec.c, except that it works with 32 bit argv
1334 * and envp pointers.
1336 static int compat_count(compat_uptr_t __user
*argv
, int max
)
1344 if (get_user(p
, argv
))
1352 if (fatal_signal_pending(current
))
1353 return -ERESTARTNOHAND
;
1361 * compat_copy_strings() is basically a copy of copy_strings() from fs/exec.c
1362 * except that it works with 32 bit argv and envp pointers.
1364 static int compat_copy_strings(int argc
, compat_uptr_t __user
*argv
,
1365 struct linux_binprm
*bprm
)
1367 struct page
*kmapped_page
= NULL
;
1369 unsigned long kpos
= 0;
1372 while (argc
-- > 0) {
1377 if (get_user(str
, argv
+argc
) ||
1378 !(len
= strnlen_user(compat_ptr(str
), MAX_ARG_STRLEN
))) {
1383 if (len
> MAX_ARG_STRLEN
) {
1388 /* We're going to work our way backwords. */
1394 int offset
, bytes_to_copy
;
1396 if (fatal_signal_pending(current
)) {
1397 ret
= -ERESTARTNOHAND
;
1402 offset
= pos
% PAGE_SIZE
;
1406 bytes_to_copy
= offset
;
1407 if (bytes_to_copy
> len
)
1408 bytes_to_copy
= len
;
1410 offset
-= bytes_to_copy
;
1411 pos
-= bytes_to_copy
;
1412 str
-= bytes_to_copy
;
1413 len
-= bytes_to_copy
;
1415 if (!kmapped_page
|| kpos
!= (pos
& PAGE_MASK
)) {
1418 page
= get_arg_page(bprm
, pos
, 1);
1425 flush_kernel_dcache_page(kmapped_page
);
1426 kunmap(kmapped_page
);
1427 put_page(kmapped_page
);
1429 kmapped_page
= page
;
1430 kaddr
= kmap(kmapped_page
);
1431 kpos
= pos
& PAGE_MASK
;
1432 flush_cache_page(bprm
->vma
, kpos
,
1433 page_to_pfn(kmapped_page
));
1435 if (copy_from_user(kaddr
+offset
, compat_ptr(str
),
1445 flush_kernel_dcache_page(kmapped_page
);
1446 kunmap(kmapped_page
);
1447 put_page(kmapped_page
);
1453 * compat_do_execve() is mostly a copy of do_execve(), with the exception
1454 * that it processes 32 bit argv and envp pointers.
1456 int compat_do_execve(char * filename
,
1457 compat_uptr_t __user
*argv
,
1458 compat_uptr_t __user
*envp
,
1459 struct pt_regs
* regs
)
1461 struct linux_binprm
*bprm
;
1463 struct files_struct
*displaced
;
1467 retval
= unshare_files(&displaced
);
1472 bprm
= kzalloc(sizeof(*bprm
), GFP_KERNEL
);
1476 retval
= prepare_bprm_creds(bprm
);
1480 retval
= check_unsafe_exec(bprm
);
1483 clear_in_exec
= retval
;
1484 current
->in_execve
= 1;
1486 file
= open_exec(filename
);
1487 retval
= PTR_ERR(file
);
1494 bprm
->filename
= filename
;
1495 bprm
->interp
= filename
;
1497 retval
= bprm_mm_init(bprm
);
1501 bprm
->argc
= compat_count(argv
, MAX_ARG_STRINGS
);
1502 if ((retval
= bprm
->argc
) < 0)
1505 bprm
->envc
= compat_count(envp
, MAX_ARG_STRINGS
);
1506 if ((retval
= bprm
->envc
) < 0)
1509 retval
= prepare_binprm(bprm
);
1513 retval
= copy_strings_kernel(1, &bprm
->filename
, bprm
);
1517 bprm
->exec
= bprm
->p
;
1518 retval
= compat_copy_strings(bprm
->envc
, envp
, bprm
);
1522 retval
= compat_copy_strings(bprm
->argc
, argv
, bprm
);
1526 retval
= search_binary_handler(bprm
, regs
);
1530 /* execve succeeded */
1531 current
->fs
->in_exec
= 0;
1532 current
->in_execve
= 0;
1533 acct_update_integrals(current
);
1536 put_files_struct(displaced
);
1541 acct_arg_size(bprm
, 0);
1547 allow_write_access(bprm
->file
);
1553 current
->fs
->in_exec
= 0;
1554 current
->in_execve
= 0;
1561 reset_files_struct(displaced
);
1566 #define __COMPAT_NFDBITS (8 * sizeof(compat_ulong_t))
1568 static int poll_select_copy_remaining(struct timespec
*end_time
, void __user
*p
,
1569 int timeval
, int ret
)
1576 if (current
->personality
& STICKY_TIMEOUTS
)
1579 /* No update for zero timeout */
1580 if (!end_time
->tv_sec
&& !end_time
->tv_nsec
)
1584 ts
= timespec_sub(*end_time
, ts
);
1586 ts
.tv_sec
= ts
.tv_nsec
= 0;
1589 struct compat_timeval rtv
;
1591 rtv
.tv_sec
= ts
.tv_sec
;
1592 rtv
.tv_usec
= ts
.tv_nsec
/ NSEC_PER_USEC
;
1594 if (!copy_to_user(p
, &rtv
, sizeof(rtv
)))
1597 struct compat_timespec rts
;
1599 rts
.tv_sec
= ts
.tv_sec
;
1600 rts
.tv_nsec
= ts
.tv_nsec
;
1602 if (!copy_to_user(p
, &rts
, sizeof(rts
)))
1606 * If an application puts its timeval in read-only memory, we
1607 * don't want the Linux-specific update to the timeval to
1608 * cause a fault after the select has completed
1609 * successfully. However, because we're not updating the
1610 * timeval, we can't restart the system call.
1614 if (ret
== -ERESTARTNOHAND
)
1620 * Ooo, nasty. We need here to frob 32-bit unsigned longs to
1621 * 64-bit unsigned longs.
1624 int compat_get_fd_set(unsigned long nr
, compat_ulong_t __user
*ufdset
,
1625 unsigned long *fdset
)
1627 nr
= DIV_ROUND_UP(nr
, __COMPAT_NFDBITS
);
1631 if (!access_ok(VERIFY_WRITE
, ufdset
, nr
*sizeof(compat_ulong_t
)))
1638 if (__get_user(l
, ufdset
) || __get_user(h
, ufdset
+1))
1641 *fdset
++ = h
<< 32 | l
;
1644 if (odd
&& __get_user(*fdset
, ufdset
))
1647 /* Tricky, must clear full unsigned long in the
1648 * kernel fdset at the end, this makes sure that
1651 memset(fdset
, 0, ((nr
+ 1) & ~1)*sizeof(compat_ulong_t
));
1657 int compat_set_fd_set(unsigned long nr
, compat_ulong_t __user
*ufdset
,
1658 unsigned long *fdset
)
1661 nr
= DIV_ROUND_UP(nr
, __COMPAT_NFDBITS
);
1672 if (__put_user(l
, ufdset
) || __put_user(h
, ufdset
+1))
1677 if (odd
&& __put_user(*fdset
, ufdset
))
1684 * This is a virtual copy of sys_select from fs/select.c and probably
1685 * should be compared to it from time to time
1689 * We can actually return ERESTARTSYS instead of EINTR, but I'd
1690 * like to be certain this leads to no problems. So I return
1691 * EINTR just for safety.
1693 * Update: ERESTARTSYS breaks at least the xview clock binary, so
1694 * I'm trying ERESTARTNOHAND which restart only when you want to.
1696 #define MAX_SELECT_SECONDS \
1697 ((unsigned long) (MAX_SCHEDULE_TIMEOUT / HZ)-1)
1699 int compat_core_sys_select(int n
, compat_ulong_t __user
*inp
,
1700 compat_ulong_t __user
*outp
, compat_ulong_t __user
*exp
,
1701 struct timespec
*end_time
)
1705 int size
, max_fds
, ret
= -EINVAL
;
1706 struct fdtable
*fdt
;
1707 long stack_fds
[SELECT_STACK_ALLOC
/sizeof(long)];
1712 /* max_fds can increase, so grab it once to avoid race */
1714 fdt
= files_fdtable(current
->files
);
1715 max_fds
= fdt
->max_fds
;
1721 * We need 6 bitmaps (in/out/ex for both incoming and outgoing),
1722 * since we used fdset we need to allocate memory in units of
1725 size
= FDS_BYTES(n
);
1727 if (size
> sizeof(stack_fds
) / 6) {
1728 bits
= kmalloc(6 * size
, GFP_KERNEL
);
1733 fds
.in
= (unsigned long *) bits
;
1734 fds
.out
= (unsigned long *) (bits
+ size
);
1735 fds
.ex
= (unsigned long *) (bits
+ 2*size
);
1736 fds
.res_in
= (unsigned long *) (bits
+ 3*size
);
1737 fds
.res_out
= (unsigned long *) (bits
+ 4*size
);
1738 fds
.res_ex
= (unsigned long *) (bits
+ 5*size
);
1740 if ((ret
= compat_get_fd_set(n
, inp
, fds
.in
)) ||
1741 (ret
= compat_get_fd_set(n
, outp
, fds
.out
)) ||
1742 (ret
= compat_get_fd_set(n
, exp
, fds
.ex
)))
1744 zero_fd_set(n
, fds
.res_in
);
1745 zero_fd_set(n
, fds
.res_out
);
1746 zero_fd_set(n
, fds
.res_ex
);
1748 ret
= do_select(n
, &fds
, end_time
);
1753 ret
= -ERESTARTNOHAND
;
1754 if (signal_pending(current
))
1759 if (compat_set_fd_set(n
, inp
, fds
.res_in
) ||
1760 compat_set_fd_set(n
, outp
, fds
.res_out
) ||
1761 compat_set_fd_set(n
, exp
, fds
.res_ex
))
1764 if (bits
!= stack_fds
)
1770 asmlinkage
long compat_sys_select(int n
, compat_ulong_t __user
*inp
,
1771 compat_ulong_t __user
*outp
, compat_ulong_t __user
*exp
,
1772 struct compat_timeval __user
*tvp
)
1774 struct timespec end_time
, *to
= NULL
;
1775 struct compat_timeval tv
;
1779 if (copy_from_user(&tv
, tvp
, sizeof(tv
)))
1783 if (poll_select_set_timeout(to
,
1784 tv
.tv_sec
+ (tv
.tv_usec
/ USEC_PER_SEC
),
1785 (tv
.tv_usec
% USEC_PER_SEC
) * NSEC_PER_USEC
))
1789 ret
= compat_core_sys_select(n
, inp
, outp
, exp
, to
);
1790 ret
= poll_select_copy_remaining(&end_time
, tvp
, 1, ret
);
1795 struct compat_sel_arg_struct
{
1803 asmlinkage
long compat_sys_old_select(struct compat_sel_arg_struct __user
*arg
)
1805 struct compat_sel_arg_struct a
;
1807 if (copy_from_user(&a
, arg
, sizeof(a
)))
1809 return compat_sys_select(a
.n
, compat_ptr(a
.inp
), compat_ptr(a
.outp
),
1810 compat_ptr(a
.exp
), compat_ptr(a
.tvp
));
1813 #ifdef HAVE_SET_RESTORE_SIGMASK
1814 static long do_compat_pselect(int n
, compat_ulong_t __user
*inp
,
1815 compat_ulong_t __user
*outp
, compat_ulong_t __user
*exp
,
1816 struct compat_timespec __user
*tsp
, compat_sigset_t __user
*sigmask
,
1817 compat_size_t sigsetsize
)
1819 compat_sigset_t ss32
;
1820 sigset_t ksigmask
, sigsaved
;
1821 struct compat_timespec ts
;
1822 struct timespec end_time
, *to
= NULL
;
1826 if (copy_from_user(&ts
, tsp
, sizeof(ts
)))
1830 if (poll_select_set_timeout(to
, ts
.tv_sec
, ts
.tv_nsec
))
1835 if (sigsetsize
!= sizeof(compat_sigset_t
))
1837 if (copy_from_user(&ss32
, sigmask
, sizeof(ss32
)))
1839 sigset_from_compat(&ksigmask
, &ss32
);
1841 sigdelsetmask(&ksigmask
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
1842 sigprocmask(SIG_SETMASK
, &ksigmask
, &sigsaved
);
1845 ret
= compat_core_sys_select(n
, inp
, outp
, exp
, to
);
1846 ret
= poll_select_copy_remaining(&end_time
, tsp
, 0, ret
);
1848 if (ret
== -ERESTARTNOHAND
) {
1850 * Don't restore the signal mask yet. Let do_signal() deliver
1851 * the signal on the way back to userspace, before the signal
1855 memcpy(¤t
->saved_sigmask
, &sigsaved
,
1857 set_restore_sigmask();
1860 sigprocmask(SIG_SETMASK
, &sigsaved
, NULL
);
1865 asmlinkage
long compat_sys_pselect6(int n
, compat_ulong_t __user
*inp
,
1866 compat_ulong_t __user
*outp
, compat_ulong_t __user
*exp
,
1867 struct compat_timespec __user
*tsp
, void __user
*sig
)
1869 compat_size_t sigsetsize
= 0;
1870 compat_uptr_t up
= 0;
1873 if (!access_ok(VERIFY_READ
, sig
,
1874 sizeof(compat_uptr_t
)+sizeof(compat_size_t
)) ||
1875 __get_user(up
, (compat_uptr_t __user
*)sig
) ||
1876 __get_user(sigsetsize
,
1877 (compat_size_t __user
*)(sig
+sizeof(up
))))
1880 return do_compat_pselect(n
, inp
, outp
, exp
, tsp
, compat_ptr(up
),
1884 asmlinkage
long compat_sys_ppoll(struct pollfd __user
*ufds
,
1885 unsigned int nfds
, struct compat_timespec __user
*tsp
,
1886 const compat_sigset_t __user
*sigmask
, compat_size_t sigsetsize
)
1888 compat_sigset_t ss32
;
1889 sigset_t ksigmask
, sigsaved
;
1890 struct compat_timespec ts
;
1891 struct timespec end_time
, *to
= NULL
;
1895 if (copy_from_user(&ts
, tsp
, sizeof(ts
)))
1899 if (poll_select_set_timeout(to
, ts
.tv_sec
, ts
.tv_nsec
))
1904 if (sigsetsize
!= sizeof(compat_sigset_t
))
1906 if (copy_from_user(&ss32
, sigmask
, sizeof(ss32
)))
1908 sigset_from_compat(&ksigmask
, &ss32
);
1910 sigdelsetmask(&ksigmask
, sigmask(SIGKILL
)|sigmask(SIGSTOP
));
1911 sigprocmask(SIG_SETMASK
, &ksigmask
, &sigsaved
);
1914 ret
= do_sys_poll(ufds
, nfds
, to
);
1916 /* We can restart this syscall, usually */
1917 if (ret
== -EINTR
) {
1919 * Don't restore the signal mask yet. Let do_signal() deliver
1920 * the signal on the way back to userspace, before the signal
1924 memcpy(¤t
->saved_sigmask
, &sigsaved
,
1926 set_restore_sigmask();
1928 ret
= -ERESTARTNOHAND
;
1930 sigprocmask(SIG_SETMASK
, &sigsaved
, NULL
);
1932 ret
= poll_select_copy_remaining(&end_time
, tsp
, 0, ret
);
1936 #endif /* HAVE_SET_RESTORE_SIGMASK */
1938 #if (defined(CONFIG_NFSD) || defined(CONFIG_NFSD_MODULE)) && !defined(CONFIG_NFSD_DEPRECATED)
1939 /* Stuff for NFS server syscalls... */
1940 struct compat_nfsctl_svc
{
1945 struct compat_nfsctl_client
{
1946 s8 cl32_ident
[NFSCLNT_IDMAX
+1];
1948 struct in_addr cl32_addrlist
[NFSCLNT_ADDRMAX
];
1951 u8 cl32_fhkey
[NFSCLNT_KEYMAX
];
1954 struct compat_nfsctl_export
{
1955 char ex32_client
[NFSCLNT_IDMAX
+1];
1956 char ex32_path
[NFS_MAXPATHLEN
+1];
1957 compat_dev_t ex32_dev
;
1958 compat_ino_t ex32_ino
;
1959 compat_int_t ex32_flags
;
1960 __compat_uid_t ex32_anon_uid
;
1961 __compat_gid_t ex32_anon_gid
;
1964 struct compat_nfsctl_fdparm
{
1965 struct sockaddr gd32_addr
;
1966 s8 gd32_path
[NFS_MAXPATHLEN
+1];
1967 compat_int_t gd32_version
;
1970 struct compat_nfsctl_fsparm
{
1971 struct sockaddr gd32_addr
;
1972 s8 gd32_path
[NFS_MAXPATHLEN
+1];
1973 compat_int_t gd32_maxlen
;
1976 struct compat_nfsctl_arg
{
1977 compat_int_t ca32_version
; /* safeguard */
1979 struct compat_nfsctl_svc u32_svc
;
1980 struct compat_nfsctl_client u32_client
;
1981 struct compat_nfsctl_export u32_export
;
1982 struct compat_nfsctl_fdparm u32_getfd
;
1983 struct compat_nfsctl_fsparm u32_getfs
;
1985 #define ca32_svc u.u32_svc
1986 #define ca32_client u.u32_client
1987 #define ca32_export u.u32_export
1988 #define ca32_getfd u.u32_getfd
1989 #define ca32_getfs u.u32_getfs
1992 union compat_nfsctl_res
{
1993 __u8 cr32_getfh
[NFS_FHSIZE
];
1994 struct knfsd_fh cr32_getfs
;
1997 static int compat_nfs_svc_trans(struct nfsctl_arg
*karg
,
1998 struct compat_nfsctl_arg __user
*arg
)
2000 if (!access_ok(VERIFY_READ
, &arg
->ca32_svc
, sizeof(arg
->ca32_svc
)) ||
2001 get_user(karg
->ca_version
, &arg
->ca32_version
) ||
2002 __get_user(karg
->ca_svc
.svc_port
, &arg
->ca32_svc
.svc32_port
) ||
2003 __get_user(karg
->ca_svc
.svc_nthreads
,
2004 &arg
->ca32_svc
.svc32_nthreads
))
2009 static int compat_nfs_clnt_trans(struct nfsctl_arg
*karg
,
2010 struct compat_nfsctl_arg __user
*arg
)
2012 if (!access_ok(VERIFY_READ
, &arg
->ca32_client
,
2013 sizeof(arg
->ca32_client
)) ||
2014 get_user(karg
->ca_version
, &arg
->ca32_version
) ||
2015 __copy_from_user(&karg
->ca_client
.cl_ident
[0],
2016 &arg
->ca32_client
.cl32_ident
[0],
2018 __get_user(karg
->ca_client
.cl_naddr
,
2019 &arg
->ca32_client
.cl32_naddr
) ||
2020 __copy_from_user(&karg
->ca_client
.cl_addrlist
[0],
2021 &arg
->ca32_client
.cl32_addrlist
[0],
2022 (sizeof(struct in_addr
) * NFSCLNT_ADDRMAX
)) ||
2023 __get_user(karg
->ca_client
.cl_fhkeytype
,
2024 &arg
->ca32_client
.cl32_fhkeytype
) ||
2025 __get_user(karg
->ca_client
.cl_fhkeylen
,
2026 &arg
->ca32_client
.cl32_fhkeylen
) ||
2027 __copy_from_user(&karg
->ca_client
.cl_fhkey
[0],
2028 &arg
->ca32_client
.cl32_fhkey
[0],
2035 static int compat_nfs_exp_trans(struct nfsctl_arg
*karg
,
2036 struct compat_nfsctl_arg __user
*arg
)
2038 if (!access_ok(VERIFY_READ
, &arg
->ca32_export
,
2039 sizeof(arg
->ca32_export
)) ||
2040 get_user(karg
->ca_version
, &arg
->ca32_version
) ||
2041 __copy_from_user(&karg
->ca_export
.ex_client
[0],
2042 &arg
->ca32_export
.ex32_client
[0],
2044 __copy_from_user(&karg
->ca_export
.ex_path
[0],
2045 &arg
->ca32_export
.ex32_path
[0],
2047 __get_user(karg
->ca_export
.ex_dev
,
2048 &arg
->ca32_export
.ex32_dev
) ||
2049 __get_user(karg
->ca_export
.ex_ino
,
2050 &arg
->ca32_export
.ex32_ino
) ||
2051 __get_user(karg
->ca_export
.ex_flags
,
2052 &arg
->ca32_export
.ex32_flags
) ||
2053 __get_user(karg
->ca_export
.ex_anon_uid
,
2054 &arg
->ca32_export
.ex32_anon_uid
) ||
2055 __get_user(karg
->ca_export
.ex_anon_gid
,
2056 &arg
->ca32_export
.ex32_anon_gid
))
2058 SET_UID(karg
->ca_export
.ex_anon_uid
, karg
->ca_export
.ex_anon_uid
);
2059 SET_GID(karg
->ca_export
.ex_anon_gid
, karg
->ca_export
.ex_anon_gid
);
2064 static int compat_nfs_getfd_trans(struct nfsctl_arg
*karg
,
2065 struct compat_nfsctl_arg __user
*arg
)
2067 if (!access_ok(VERIFY_READ
, &arg
->ca32_getfd
,
2068 sizeof(arg
->ca32_getfd
)) ||
2069 get_user(karg
->ca_version
, &arg
->ca32_version
) ||
2070 __copy_from_user(&karg
->ca_getfd
.gd_addr
,
2071 &arg
->ca32_getfd
.gd32_addr
,
2072 (sizeof(struct sockaddr
))) ||
2073 __copy_from_user(&karg
->ca_getfd
.gd_path
,
2074 &arg
->ca32_getfd
.gd32_path
,
2075 (NFS_MAXPATHLEN
+1)) ||
2076 __get_user(karg
->ca_getfd
.gd_version
,
2077 &arg
->ca32_getfd
.gd32_version
))
2083 static int compat_nfs_getfs_trans(struct nfsctl_arg
*karg
,
2084 struct compat_nfsctl_arg __user
*arg
)
2086 if (!access_ok(VERIFY_READ
,&arg
->ca32_getfs
,sizeof(arg
->ca32_getfs
)) ||
2087 get_user(karg
->ca_version
, &arg
->ca32_version
) ||
2088 __copy_from_user(&karg
->ca_getfs
.gd_addr
,
2089 &arg
->ca32_getfs
.gd32_addr
,
2090 (sizeof(struct sockaddr
))) ||
2091 __copy_from_user(&karg
->ca_getfs
.gd_path
,
2092 &arg
->ca32_getfs
.gd32_path
,
2093 (NFS_MAXPATHLEN
+1)) ||
2094 __get_user(karg
->ca_getfs
.gd_maxlen
,
2095 &arg
->ca32_getfs
.gd32_maxlen
))
2101 /* This really doesn't need translations, we are only passing
2102 * back a union which contains opaque nfs file handle data.
2104 static int compat_nfs_getfh_res_trans(union nfsctl_res
*kres
,
2105 union compat_nfsctl_res __user
*res
)
2109 err
= copy_to_user(res
, kres
, sizeof(*res
));
2111 return (err
) ? -EFAULT
: 0;
2114 asmlinkage
long compat_sys_nfsservctl(int cmd
,
2115 struct compat_nfsctl_arg __user
*arg
,
2116 union compat_nfsctl_res __user
*res
)
2118 struct nfsctl_arg
*karg
;
2119 union nfsctl_res
*kres
;
2123 karg
= kmalloc(sizeof(*karg
), GFP_USER
);
2124 kres
= kmalloc(sizeof(*kres
), GFP_USER
);
2125 if(!karg
|| !kres
) {
2132 err
= compat_nfs_svc_trans(karg
, arg
);
2135 case NFSCTL_ADDCLIENT
:
2136 err
= compat_nfs_clnt_trans(karg
, arg
);
2139 case NFSCTL_DELCLIENT
:
2140 err
= compat_nfs_clnt_trans(karg
, arg
);
2144 case NFSCTL_UNEXPORT
:
2145 err
= compat_nfs_exp_trans(karg
, arg
);
2149 err
= compat_nfs_getfd_trans(karg
, arg
);
2153 err
= compat_nfs_getfs_trans(karg
, arg
);
2166 /* The __user pointer casts are valid because of the set_fs() */
2167 err
= sys_nfsservctl(cmd
, (void __user
*) karg
, (void __user
*) kres
);
2173 if((cmd
== NFSCTL_GETFD
) ||
2174 (cmd
== NFSCTL_GETFS
))
2175 err
= compat_nfs_getfh_res_trans(kres
, res
);
2183 long asmlinkage
compat_sys_nfsservctl(int cmd
, void *notused
, void *notused2
)
2185 return sys_ni_syscall();
2191 #ifdef HAVE_SET_RESTORE_SIGMASK
2192 asmlinkage
long compat_sys_epoll_pwait(int epfd
,
2193 struct compat_epoll_event __user
*events
,
2194 int maxevents
, int timeout
,
2195 const compat_sigset_t __user
*sigmask
,
2196 compat_size_t sigsetsize
)
2199 compat_sigset_t csigmask
;
2200 sigset_t ksigmask
, sigsaved
;
2203 * If the caller wants a certain signal mask to be set during the wait,
2207 if (sigsetsize
!= sizeof(compat_sigset_t
))
2209 if (copy_from_user(&csigmask
, sigmask
, sizeof(csigmask
)))
2211 sigset_from_compat(&ksigmask
, &csigmask
);
2212 sigdelsetmask(&ksigmask
, sigmask(SIGKILL
) | sigmask(SIGSTOP
));
2213 sigprocmask(SIG_SETMASK
, &ksigmask
, &sigsaved
);
2216 err
= sys_epoll_wait(epfd
, events
, maxevents
, timeout
);
2219 * If we changed the signal mask, we need to restore the original one.
2220 * In case we've got a signal while waiting, we do not restore the
2221 * signal mask yet, and we allow do_signal() to deliver the signal on
2222 * the way back to userspace, before the signal mask is restored.
2225 if (err
== -EINTR
) {
2226 memcpy(¤t
->saved_sigmask
, &sigsaved
,
2228 set_restore_sigmask();
2230 sigprocmask(SIG_SETMASK
, &sigsaved
, NULL
);
2235 #endif /* HAVE_SET_RESTORE_SIGMASK */
2237 #endif /* CONFIG_EPOLL */
2239 #ifdef CONFIG_SIGNALFD
2241 asmlinkage
long compat_sys_signalfd4(int ufd
,
2242 const compat_sigset_t __user
*sigmask
,
2243 compat_size_t sigsetsize
, int flags
)
2245 compat_sigset_t ss32
;
2247 sigset_t __user
*ksigmask
;
2249 if (sigsetsize
!= sizeof(compat_sigset_t
))
2251 if (copy_from_user(&ss32
, sigmask
, sizeof(ss32
)))
2253 sigset_from_compat(&tmp
, &ss32
);
2254 ksigmask
= compat_alloc_user_space(sizeof(sigset_t
));
2255 if (copy_to_user(ksigmask
, &tmp
, sizeof(sigset_t
)))
2258 return sys_signalfd4(ufd
, ksigmask
, sizeof(sigset_t
), flags
);
2261 asmlinkage
long compat_sys_signalfd(int ufd
,
2262 const compat_sigset_t __user
*sigmask
,
2263 compat_size_t sigsetsize
)
2265 return compat_sys_signalfd4(ufd
, sigmask
, sigsetsize
, 0);
2267 #endif /* CONFIG_SIGNALFD */
2269 #ifdef CONFIG_TIMERFD
2271 asmlinkage
long compat_sys_timerfd_settime(int ufd
, int flags
,
2272 const struct compat_itimerspec __user
*utmr
,
2273 struct compat_itimerspec __user
*otmr
)
2276 struct itimerspec t
;
2277 struct itimerspec __user
*ut
;
2279 if (get_compat_itimerspec(&t
, utmr
))
2281 ut
= compat_alloc_user_space(2 * sizeof(struct itimerspec
));
2282 if (copy_to_user(&ut
[0], &t
, sizeof(t
)))
2284 error
= sys_timerfd_settime(ufd
, flags
, &ut
[0], &ut
[1]);
2286 error
= (copy_from_user(&t
, &ut
[1], sizeof(struct itimerspec
)) ||
2287 put_compat_itimerspec(otmr
, &t
)) ? -EFAULT
: 0;
2292 asmlinkage
long compat_sys_timerfd_gettime(int ufd
,
2293 struct compat_itimerspec __user
*otmr
)
2296 struct itimerspec t
;
2297 struct itimerspec __user
*ut
;
2299 ut
= compat_alloc_user_space(sizeof(struct itimerspec
));
2300 error
= sys_timerfd_gettime(ufd
, ut
);
2302 error
= (copy_from_user(&t
, ut
, sizeof(struct itimerspec
)) ||
2303 put_compat_itimerspec(otmr
, &t
)) ? -EFAULT
: 0;
2308 #endif /* CONFIG_TIMERFD */