Merge tag 'drm-misc-next-fixes-2018-04-11' of git://anongit.freedesktop.org/drm/drm...
[linux-2.6-microblaze.git] / arch / x86 / ia32 / sys_ia32.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * sys_ia32.c: Conversion between 32bit and 64bit native syscalls. Based on
4  *             sys_sparc32
5  *
6  * Copyright (C) 2000           VA Linux Co
7  * Copyright (C) 2000           Don Dugger <n0ano@valinux.com>
8  * Copyright (C) 1999           Arun Sharma <arun.sharma@intel.com>
9  * Copyright (C) 1997,1998      Jakub Jelinek (jj@sunsite.mff.cuni.cz)
10  * Copyright (C) 1997           David S. Miller (davem@caip.rutgers.edu)
11  * Copyright (C) 2000           Hewlett-Packard Co.
12  * Copyright (C) 2000           David Mosberger-Tang <davidm@hpl.hp.com>
13  * Copyright (C) 2000,2001,2002 Andi Kleen, SuSE Labs (x86-64 port)
14  *
15  * These routines maintain argument size conversion between 32bit and 64bit
16  * environment. In 2.5 most of this should be moved to a generic directory.
17  *
18  * This file assumes that there is a hole at the end of user address space.
19  *
20  * Some of the functions are LE specific currently. These are
21  * hopefully all marked.  This should be fixed.
22  */
23
24 #include <linux/kernel.h>
25 #include <linux/sched.h>
26 #include <linux/fs.h>
27 #include <linux/file.h>
28 #include <linux/signal.h>
29 #include <linux/syscalls.h>
30 #include <linux/times.h>
31 #include <linux/utsname.h>
32 #include <linux/mm.h>
33 #include <linux/uio.h>
34 #include <linux/poll.h>
35 #include <linux/personality.h>
36 #include <linux/stat.h>
37 #include <linux/rwsem.h>
38 #include <linux/compat.h>
39 #include <linux/vfs.h>
40 #include <linux/ptrace.h>
41 #include <linux/highuid.h>
42 #include <linux/sysctl.h>
43 #include <linux/slab.h>
44 #include <asm/mman.h>
45 #include <asm/types.h>
46 #include <linux/uaccess.h>
47 #include <linux/atomic.h>
48 #include <asm/vgtod.h>
49 #include <asm/sys_ia32.h>
50
51 #define AA(__x)         ((unsigned long)(__x))
52
53
54 COMPAT_SYSCALL_DEFINE3(x86_truncate64, const char __user *, filename,
55                        unsigned long, offset_low, unsigned long, offset_high)
56 {
57        return sys_truncate(filename, ((loff_t) offset_high << 32) | offset_low);
58 }
59
60 COMPAT_SYSCALL_DEFINE3(x86_ftruncate64, unsigned int, fd,
61                        unsigned long, offset_low, unsigned long, offset_high)
62 {
63        return sys_ftruncate(fd, ((loff_t) offset_high << 32) | offset_low);
64 }
65
66 /*
67  * Another set for IA32/LFS -- x86_64 struct stat is different due to
68  * support for 64bit inode numbers.
69  */
70 static int cp_stat64(struct stat64 __user *ubuf, struct kstat *stat)
71 {
72         typeof(ubuf->st_uid) uid = 0;
73         typeof(ubuf->st_gid) gid = 0;
74         SET_UID(uid, from_kuid_munged(current_user_ns(), stat->uid));
75         SET_GID(gid, from_kgid_munged(current_user_ns(), stat->gid));
76         if (!access_ok(VERIFY_WRITE, ubuf, sizeof(struct stat64)) ||
77             __put_user(huge_encode_dev(stat->dev), &ubuf->st_dev) ||
78             __put_user(stat->ino, &ubuf->__st_ino) ||
79             __put_user(stat->ino, &ubuf->st_ino) ||
80             __put_user(stat->mode, &ubuf->st_mode) ||
81             __put_user(stat->nlink, &ubuf->st_nlink) ||
82             __put_user(uid, &ubuf->st_uid) ||
83             __put_user(gid, &ubuf->st_gid) ||
84             __put_user(huge_encode_dev(stat->rdev), &ubuf->st_rdev) ||
85             __put_user(stat->size, &ubuf->st_size) ||
86             __put_user(stat->atime.tv_sec, &ubuf->st_atime) ||
87             __put_user(stat->atime.tv_nsec, &ubuf->st_atime_nsec) ||
88             __put_user(stat->mtime.tv_sec, &ubuf->st_mtime) ||
89             __put_user(stat->mtime.tv_nsec, &ubuf->st_mtime_nsec) ||
90             __put_user(stat->ctime.tv_sec, &ubuf->st_ctime) ||
91             __put_user(stat->ctime.tv_nsec, &ubuf->st_ctime_nsec) ||
92             __put_user(stat->blksize, &ubuf->st_blksize) ||
93             __put_user(stat->blocks, &ubuf->st_blocks))
94                 return -EFAULT;
95         return 0;
96 }
97
98 COMPAT_SYSCALL_DEFINE2(x86_stat64, const char __user *, filename,
99                        struct stat64 __user *, statbuf)
100 {
101         struct kstat stat;
102         int ret = vfs_stat(filename, &stat);
103
104         if (!ret)
105                 ret = cp_stat64(statbuf, &stat);
106         return ret;
107 }
108
109 COMPAT_SYSCALL_DEFINE2(x86_lstat64, const char __user *, filename,
110                        struct stat64 __user *, statbuf)
111 {
112         struct kstat stat;
113         int ret = vfs_lstat(filename, &stat);
114         if (!ret)
115                 ret = cp_stat64(statbuf, &stat);
116         return ret;
117 }
118
119 COMPAT_SYSCALL_DEFINE2(x86_fstat64, unsigned int, fd,
120                        struct stat64 __user *, statbuf)
121 {
122         struct kstat stat;
123         int ret = vfs_fstat(fd, &stat);
124         if (!ret)
125                 ret = cp_stat64(statbuf, &stat);
126         return ret;
127 }
128
129 COMPAT_SYSCALL_DEFINE4(x86_fstatat, unsigned int, dfd,
130                        const char __user *, filename,
131                        struct stat64 __user *, statbuf, int, flag)
132 {
133         struct kstat stat;
134         int error;
135
136         error = vfs_fstatat(dfd, filename, &stat, flag);
137         if (error)
138                 return error;
139         return cp_stat64(statbuf, &stat);
140 }
141
142 /*
143  * Linux/i386 didn't use to be able to handle more than
144  * 4 system call parameters, so these system calls used a memory
145  * block for parameter passing..
146  */
147
148 struct mmap_arg_struct32 {
149         unsigned int addr;
150         unsigned int len;
151         unsigned int prot;
152         unsigned int flags;
153         unsigned int fd;
154         unsigned int offset;
155 };
156
157 COMPAT_SYSCALL_DEFINE1(x86_mmap, struct mmap_arg_struct32 __user *, arg)
158 {
159         struct mmap_arg_struct32 a;
160
161         if (copy_from_user(&a, arg, sizeof(a)))
162                 return -EFAULT;
163
164         if (a.offset & ~PAGE_MASK)
165                 return -EINVAL;
166
167         return sys_mmap_pgoff(a.addr, a.len, a.prot, a.flags, a.fd,
168                                a.offset>>PAGE_SHIFT);
169 }
170
171 COMPAT_SYSCALL_DEFINE3(x86_waitpid, compat_pid_t, pid, unsigned int __user *,
172                        stat_addr, int, options)
173 {
174         return compat_sys_wait4(pid, stat_addr, options, NULL);
175 }
176
177 /* warning: next two assume little endian */
178 COMPAT_SYSCALL_DEFINE5(x86_pread, unsigned int, fd, char __user *, ubuf,
179                        u32, count, u32, poslo, u32, poshi)
180 {
181         return sys_pread64(fd, ubuf, count,
182                          ((loff_t)AA(poshi) << 32) | AA(poslo));
183 }
184
185 COMPAT_SYSCALL_DEFINE5(x86_pwrite, unsigned int, fd, const char __user *, ubuf,
186                        u32, count, u32, poslo, u32, poshi)
187 {
188         return sys_pwrite64(fd, ubuf, count,
189                           ((loff_t)AA(poshi) << 32) | AA(poslo));
190 }
191
192
193 /*
194  * Some system calls that need sign extended arguments. This could be
195  * done by a generic wrapper.
196  */
197 COMPAT_SYSCALL_DEFINE6(x86_fadvise64_64, int, fd, __u32, offset_low,
198                        __u32, offset_high, __u32, len_low, __u32, len_high,
199                        int, advice)
200 {
201         return sys_fadvise64_64(fd,
202                                (((u64)offset_high)<<32) | offset_low,
203                                (((u64)len_high)<<32) | len_low,
204                                 advice);
205 }
206
207 COMPAT_SYSCALL_DEFINE4(x86_readahead, int, fd, unsigned int, off_lo,
208                        unsigned int, off_hi, size_t, count)
209 {
210         return sys_readahead(fd, ((u64)off_hi << 32) | off_lo, count);
211 }
212
213 COMPAT_SYSCALL_DEFINE6(x86_sync_file_range, int, fd, unsigned int, off_low,
214                        unsigned int, off_hi, unsigned int, n_low,
215                        unsigned int, n_hi, int, flags)
216 {
217         return sys_sync_file_range(fd,
218                                    ((u64)off_hi << 32) | off_low,
219                                    ((u64)n_hi << 32) | n_low, flags);
220 }
221
222 COMPAT_SYSCALL_DEFINE5(x86_fadvise64, int, fd, unsigned int, offset_lo,
223                        unsigned int, offset_hi, size_t, len, int, advice)
224 {
225         return sys_fadvise64_64(fd, ((u64)offset_hi << 32) | offset_lo,
226                                 len, advice);
227 }
228
229 COMPAT_SYSCALL_DEFINE6(x86_fallocate, int, fd, int, mode,
230                        unsigned int, offset_lo, unsigned int, offset_hi,
231                        unsigned int, len_lo, unsigned int, len_hi)
232 {
233         return sys_fallocate(fd, mode, ((u64)offset_hi << 32) | offset_lo,
234                              ((u64)len_hi << 32) | len_lo);
235 }
236
237 /*
238  * The 32-bit clone ABI is CONFIG_CLONE_BACKWARDS
239  */
240 COMPAT_SYSCALL_DEFINE5(x86_clone, unsigned long, clone_flags,
241                        unsigned long, newsp, int __user *, parent_tidptr,
242                        unsigned long, tls_val, int __user *, child_tidptr)
243 {
244         return sys_clone(clone_flags, newsp, parent_tidptr, child_tidptr,
245                         tls_val);
246 }