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