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 
88 struct 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 
117 static 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 
144 asmlinkage 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 
154 asmlinkage 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 
164 asmlinkage 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 
174 asmlinkage 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 
188 struct 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 
196 asmlinkage 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 
247 struct oabi_epoll_event {
248 	__u32 events;
249 	__u64 data;
250 } __attribute__ ((packed,aligned(4)));
251 
252 asmlinkage 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 
273 asmlinkage 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 
300 struct oabi_sembuf {
301 	unsigned short	sem_num;
302 	short		sem_op;
303 	short		sem_flg;
304 	unsigned short	__pad;
305 };
306 
307 asmlinkage 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 
346 asmlinkage 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 
352 asmlinkage 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 
370 asmlinkage 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 
380 asmlinkage 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 
390 asmlinkage 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 
403 asmlinkage long sys_oabi_sendmsg(int fd, struct 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 
429 asmlinkage 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 msghdr __user *)a[1], a[2]);
450 		break;
451 	default:
452 		r = sys_socketcall(call, args);
453 	}
454 
455 	return r;
456 }
457