1/*
2 *  arch/arm/kernel/sys_oabi-compat.c
3 *
4 *  Compatibility wrappers for syscalls that are used from
5 *  old ABI user space binaries with an EABI kernel.
6 *
7 *  Author:	Nicolas Pitre
8 *  Created:	Oct 7, 2005
9 *  Copyright:	MontaVista Software, Inc.
10 *
11 *  This program is free software; you can redistribute it and/or modify
12 *  it under the terms of the GNU General Public License version 2 as
13 *  published by the Free Software Foundation.
14 */
15
16/*
17 * The legacy ABI and the new ARM EABI have different rules making some
18 * syscalls incompatible especially with structure arguments.
19 * Most notably, Eabi says 64-bit members should be 64-bit aligned instead of
20 * simply word aligned.  EABI also pads structures to the size of the largest
21 * member it contains instead of the invariant 32-bit.
22 *
23 * The following syscalls are affected:
24 *
25 * sys_stat64:
26 * sys_lstat64:
27 * sys_fstat64:
28 * sys_fstatat64:
29 *
30 *   struct stat64 has different sizes and some members are shifted
31 *   Compatibility wrappers are needed for them and provided below.
32 *
33 * sys_fcntl64:
34 *
35 *   struct flock64 has different sizes and some members are shifted
36 *   A compatibility wrapper is needed and provided below.
37 *
38 * sys_statfs64:
39 * sys_fstatfs64:
40 *
41 *   struct statfs64 has extra padding with EABI growing its size from
42 *   84 to 88.  This struct is now __attribute__((packed,aligned(4)))
43 *   with a small assembly wrapper to force the sz argument to 84 if it is 88
44 *   to avoid copying the extra padding over user space unexpecting it.
45 *
46 * sys_newuname:
47 *
48 *   struct new_utsname has no padding with EABI.  No problem there.
49 *
50 * sys_epoll_ctl:
51 * sys_epoll_wait:
52 *
53 *   struct epoll_event has its second member shifted also affecting the
54 *   structure size. Compatibility wrappers are needed and provided below.
55 *
56 * sys_ipc:
57 * sys_semop:
58 * sys_semtimedop:
59 *
60 *   struct sembuf loses its padding with EABI.  Since arrays of them are
61 *   used they have to be copyed to remove the padding. Compatibility wrappers
62 *   provided below.
63 *
64 * sys_bind:
65 * sys_connect:
66 * sys_sendmsg:
67 * sys_sendto:
68 * sys_socketcall:
69 *
70 *   struct sockaddr_un loses its padding with EABI.  Since the size of the
71 *   structure is used as a validation test in unix_mkname(), we need to
72 *   change the length argument to 110 whenever it is 112.  Compatibility
73 *   wrappers provided below.
74 */
75
76#include <linux/syscalls.h>
77#include <linux/errno.h>
78#include <linux/fs.h>
79#include <linux/fcntl.h>
80#include <linux/eventpoll.h>
81#include <linux/sem.h>
82#include <linux/socket.h>
83#include <linux/net.h>
84#include <linux/ipc.h>
85#include <linux/uaccess.h>
86#include <linux/slab.h>
87
88struct oldabi_stat64 {
89	unsigned long long st_dev;
90	unsigned int	__pad1;
91	unsigned long	__st_ino;
92	unsigned int	st_mode;
93	unsigned int	st_nlink;
94
95	unsigned long	st_uid;
96	unsigned long	st_gid;
97
98	unsigned long long st_rdev;
99	unsigned int	__pad2;
100
101	long long	st_size;
102	unsigned long	st_blksize;
103	unsigned long long st_blocks;
104
105	unsigned long	st_atime;
106	unsigned long	st_atime_nsec;
107
108	unsigned long	st_mtime;
109	unsigned long	st_mtime_nsec;
110
111	unsigned long	st_ctime;
112	unsigned long	st_ctime_nsec;
113
114	unsigned long long st_ino;
115} __attribute__ ((packed,aligned(4)));
116
117static long cp_oldabi_stat64(struct kstat *stat,
118			     struct oldabi_stat64 __user *statbuf)
119{
120	struct oldabi_stat64 tmp;
121
122	tmp.st_dev = huge_encode_dev(stat->dev);
123	tmp.__pad1 = 0;
124	tmp.__st_ino = stat->ino;
125	tmp.st_mode = stat->mode;
126	tmp.st_nlink = stat->nlink;
127	tmp.st_uid = from_kuid_munged(current_user_ns(), stat->uid);
128	tmp.st_gid = from_kgid_munged(current_user_ns(), stat->gid);
129	tmp.st_rdev = huge_encode_dev(stat->rdev);
130	tmp.st_size = stat->size;
131	tmp.st_blocks = stat->blocks;
132	tmp.__pad2 = 0;
133	tmp.st_blksize = stat->blksize;
134	tmp.st_atime = stat->atime.tv_sec;
135	tmp.st_atime_nsec = stat->atime.tv_nsec;
136	tmp.st_mtime = stat->mtime.tv_sec;
137	tmp.st_mtime_nsec = stat->mtime.tv_nsec;
138	tmp.st_ctime = stat->ctime.tv_sec;
139	tmp.st_ctime_nsec = stat->ctime.tv_nsec;
140	tmp.st_ino = stat->ino;
141	return copy_to_user(statbuf,&tmp,sizeof(tmp)) ? -EFAULT : 0;
142}
143
144asmlinkage long sys_oabi_stat64(const char __user * filename,
145				struct oldabi_stat64 __user * statbuf)
146{
147	struct kstat stat;
148	int error = vfs_stat(filename, &stat);
149	if (!error)
150		error = cp_oldabi_stat64(&stat, statbuf);
151	return error;
152}
153
154asmlinkage long sys_oabi_lstat64(const char __user * filename,
155				 struct oldabi_stat64 __user * statbuf)
156{
157	struct kstat stat;
158	int error = vfs_lstat(filename, &stat);
159	if (!error)
160		error = cp_oldabi_stat64(&stat, statbuf);
161	return error;
162}
163
164asmlinkage long sys_oabi_fstat64(unsigned long fd,
165				 struct oldabi_stat64 __user * statbuf)
166{
167	struct kstat stat;
168	int error = vfs_fstat(fd, &stat);
169	if (!error)
170		error = cp_oldabi_stat64(&stat, statbuf);
171	return error;
172}
173
174asmlinkage long sys_oabi_fstatat64(int dfd,
175				   const char __user *filename,
176				   struct oldabi_stat64  __user *statbuf,
177				   int flag)
178{
179	struct kstat stat;
180	int error;
181
182	error = vfs_fstatat(dfd, filename, &stat, flag);
183	if (error)
184		return error;
185	return cp_oldabi_stat64(&stat, statbuf);
186}
187
188struct oabi_flock64 {
189	short	l_type;
190	short	l_whence;
191	loff_t	l_start;
192	loff_t	l_len;
193	pid_t	l_pid;
194} __attribute__ ((packed,aligned(4)));
195
196asmlinkage long sys_oabi_fcntl64(unsigned int fd, unsigned int cmd,
197				 unsigned long arg)
198{
199	struct oabi_flock64 user;
200	struct flock64 kernel;
201	mm_segment_t fs = USER_DS; /* initialized to kill a warning */
202	unsigned long local_arg = arg;
203	int ret;
204
205	switch (cmd) {
206	case F_OFD_GETLK:
207	case F_OFD_SETLK:
208	case F_OFD_SETLKW:
209	case F_GETLK64:
210	case F_SETLK64:
211	case F_SETLKW64:
212		if (copy_from_user(&user, (struct oabi_flock64 __user *)arg,
213				   sizeof(user)))
214			return -EFAULT;
215		kernel.l_type	= user.l_type;
216		kernel.l_whence	= user.l_whence;
217		kernel.l_start	= user.l_start;
218		kernel.l_len	= user.l_len;
219		kernel.l_pid	= user.l_pid;
220		local_arg = (unsigned long)&kernel;
221		fs = get_fs();
222		set_fs(KERNEL_DS);
223	}
224
225	ret = sys_fcntl64(fd, cmd, local_arg);
226
227	switch (cmd) {
228	case F_GETLK64:
229		if (!ret) {
230			user.l_type	= kernel.l_type;
231			user.l_whence	= kernel.l_whence;
232			user.l_start	= kernel.l_start;
233			user.l_len	= kernel.l_len;
234			user.l_pid	= kernel.l_pid;
235			if (copy_to_user((struct oabi_flock64 __user *)arg,
236					 &user, sizeof(user)))
237				ret = -EFAULT;
238		}
239	case F_SETLK64:
240	case F_SETLKW64:
241		set_fs(fs);
242	}
243
244	return ret;
245}
246
247struct oabi_epoll_event {
248	__u32 events;
249	__u64 data;
250} __attribute__ ((packed,aligned(4)));
251
252asmlinkage long sys_oabi_epoll_ctl(int epfd, int op, int fd,
253				   struct oabi_epoll_event __user *event)
254{
255	struct oabi_epoll_event user;
256	struct epoll_event kernel;
257	mm_segment_t fs;
258	long ret;
259
260	if (op == EPOLL_CTL_DEL)
261		return sys_epoll_ctl(epfd, op, fd, NULL);
262	if (copy_from_user(&user, event, sizeof(user)))
263		return -EFAULT;
264	kernel.events = user.events;
265	kernel.data   = user.data;
266	fs = get_fs();
267	set_fs(KERNEL_DS);
268	ret = sys_epoll_ctl(epfd, op, fd, &kernel);
269	set_fs(fs);
270	return ret;
271}
272
273asmlinkage long sys_oabi_epoll_wait(int epfd,
274				    struct oabi_epoll_event __user *events,
275				    int maxevents, int timeout)
276{
277	struct epoll_event *kbuf;
278	mm_segment_t fs;
279	long ret, err, i;
280
281	if (maxevents <= 0 || maxevents > (INT_MAX/sizeof(struct epoll_event)))
282		return -EINVAL;
283	kbuf = kmalloc(sizeof(*kbuf) * maxevents, GFP_KERNEL);
284	if (!kbuf)
285		return -ENOMEM;
286	fs = get_fs();
287	set_fs(KERNEL_DS);
288	ret = sys_epoll_wait(epfd, kbuf, maxevents, timeout);
289	set_fs(fs);
290	err = 0;
291	for (i = 0; i < ret; i++) {
292		__put_user_error(kbuf[i].events, &events->events, err);
293		__put_user_error(kbuf[i].data,   &events->data,   err);
294		events++;
295	}
296	kfree(kbuf);
297	return err ? -EFAULT : ret;
298}
299
300struct oabi_sembuf {
301	unsigned short	sem_num;
302	short		sem_op;
303	short		sem_flg;
304	unsigned short	__pad;
305};
306
307asmlinkage long sys_oabi_semtimedop(int semid,
308				    struct oabi_sembuf __user *tsops,
309				    unsigned nsops,
310				    const struct timespec __user *timeout)
311{
312	struct sembuf *sops;
313	struct timespec local_timeout;
314	long err;
315	int i;
316
317	if (nsops < 1 || nsops > SEMOPM)
318		return -EINVAL;
319	sops = kmalloc(sizeof(*sops) * nsops, GFP_KERNEL);
320	if (!sops)
321		return -ENOMEM;
322	err = 0;
323	for (i = 0; i < nsops; i++) {
324		__get_user_error(sops[i].sem_num, &tsops->sem_num, err);
325		__get_user_error(sops[i].sem_op,  &tsops->sem_op,  err);
326		__get_user_error(sops[i].sem_flg, &tsops->sem_flg, err);
327		tsops++;
328	}
329	if (timeout) {
330		/* copy this as well before changing domain protection */
331		err |= copy_from_user(&local_timeout, timeout, sizeof(*timeout));
332		timeout = &local_timeout;
333	}
334	if (err) {
335		err = -EFAULT;
336	} else {
337		mm_segment_t fs = get_fs();
338		set_fs(KERNEL_DS);
339		err = sys_semtimedop(semid, sops, nsops, timeout);
340		set_fs(fs);
341	}
342	kfree(sops);
343	return err;
344}
345
346asmlinkage long sys_oabi_semop(int semid, struct oabi_sembuf __user *tsops,
347			       unsigned nsops)
348{
349	return sys_oabi_semtimedop(semid, tsops, nsops, NULL);
350}
351
352asmlinkage int sys_oabi_ipc(uint call, int first, int second, int third,
353			    void __user *ptr, long fifth)
354{
355	switch (call & 0xffff) {
356	case SEMOP:
357		return  sys_oabi_semtimedop(first,
358					    (struct oabi_sembuf __user *)ptr,
359					    second, NULL);
360	case SEMTIMEDOP:
361		return  sys_oabi_semtimedop(first,
362					    (struct oabi_sembuf __user *)ptr,
363					    second,
364					    (const struct timespec __user *)fifth);
365	default:
366		return sys_ipc(call, first, second, third, ptr, fifth);
367	}
368}
369
370asmlinkage long sys_oabi_bind(int fd, struct sockaddr __user *addr, int addrlen)
371{
372	sa_family_t sa_family;
373	if (addrlen == 112 &&
374	    get_user(sa_family, &addr->sa_family) == 0 &&
375	    sa_family == AF_UNIX)
376			addrlen = 110;
377	return sys_bind(fd, addr, addrlen);
378}
379
380asmlinkage long sys_oabi_connect(int fd, struct sockaddr __user *addr, int addrlen)
381{
382	sa_family_t sa_family;
383	if (addrlen == 112 &&
384	    get_user(sa_family, &addr->sa_family) == 0 &&
385	    sa_family == AF_UNIX)
386			addrlen = 110;
387	return sys_connect(fd, addr, addrlen);
388}
389
390asmlinkage long sys_oabi_sendto(int fd, void __user *buff,
391				size_t len, unsigned flags,
392				struct sockaddr __user *addr,
393				int addrlen)
394{
395	sa_family_t sa_family;
396	if (addrlen == 112 &&
397	    get_user(sa_family, &addr->sa_family) == 0 &&
398	    sa_family == AF_UNIX)
399			addrlen = 110;
400	return sys_sendto(fd, buff, len, flags, addr, addrlen);
401}
402
403asmlinkage long sys_oabi_sendmsg(int fd, struct user_msghdr __user *msg, unsigned flags)
404{
405	struct sockaddr __user *addr;
406	int msg_namelen;
407	sa_family_t sa_family;
408	if (msg &&
409	    get_user(msg_namelen, &msg->msg_namelen) == 0 &&
410	    msg_namelen == 112 &&
411	    get_user(addr, &msg->msg_name) == 0 &&
412	    get_user(sa_family, &addr->sa_family) == 0 &&
413	    sa_family == AF_UNIX)
414	{
415		/*
416		 * HACK ALERT: there is a limit to how much backward bending
417		 * we should do for what is actually a transitional
418		 * compatibility layer.  This already has known flaws with
419		 * a few ioctls that we don't intend to fix.  Therefore
420		 * consider this blatent hack as another one... and take care
421		 * to run for cover.  In most cases it will "just work fine".
422		 * If it doesn't, well, tough.
423		 */
424		put_user(110, &msg->msg_namelen);
425	}
426	return sys_sendmsg(fd, msg, flags);
427}
428
429asmlinkage long sys_oabi_socketcall(int call, unsigned long __user *args)
430{
431	unsigned long r = -EFAULT, a[6];
432
433	switch (call) {
434	case SYS_BIND:
435		if (copy_from_user(a, args, 3 * sizeof(long)) == 0)
436			r = sys_oabi_bind(a[0], (struct sockaddr __user *)a[1], a[2]);
437		break;
438	case SYS_CONNECT:
439		if (copy_from_user(a, args, 3 * sizeof(long)) == 0)
440			r = sys_oabi_connect(a[0], (struct sockaddr __user *)a[1], a[2]);
441		break;
442	case SYS_SENDTO:
443		if (copy_from_user(a, args, 6 * sizeof(long)) == 0)
444			r = sys_oabi_sendto(a[0], (void __user *)a[1], a[2], a[3],
445					    (struct sockaddr __user *)a[4], a[5]);
446		break;
447	case SYS_SENDMSG:
448		if (copy_from_user(a, args, 3 * sizeof(long)) == 0)
449			r = sys_oabi_sendmsg(a[0], (struct user_msghdr __user *)a[1], a[2]);
450		break;
451	default:
452		r = sys_socketcall(call, args);
453	}
454
455	return r;
456}
457