Kernel

Kernel Git Source Tree

Root/fs/compat.c

Source at commit 9845c1745d3d531a5b9544f5322c62bfb4d4e9bc created 1 year 2 months ago. By Xiangfu, rtc: jz4740 fix hwclock give time out
1	/*
2	* linux/fs/compat.c
3	*
4	* Kernel compatibililty routines for e.g. 32 bit syscall support
5	* on 64 bit kernels.
6	*
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)
12	*
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.
16	*/
17
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>
24	#include <linux/fs.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/personality.h>
41	#include <linux/rwsem.h>
42	#include <linux/tsacct_kern.h>
43	#include <linux/security.h>
44	#include <linux/highmem.h>
45	#include <linux/signal.h>
46	#include <linux/poll.h>
47	#include <linux/mm.h>
48	#include <linux/eventpoll.h>
49	#include <linux/fs_struct.h>
50	#include <linux/slab.h>
51	#include <linux/pagemap.h>
52
53	#include <asm/uaccess.h>
54	#include <asm/mmu_context.h>
55	#include <asm/ioctls.h>
56	#include "internal.h"
57
58	int compat_log = 1;
59
60	int compat_printk(const char *fmt, ...)
61	{
62	va_list ap;
63	int ret;
64	if (!compat_log)
65	return 0;
66	va_start(ap, fmt);
67	ret = vprintk(fmt, ap);
68	va_end(ap);
69	return ret;
70	}
71
72	#include "read_write.h"
73
74	/*
75	* Not all architectures have sys_utime, so implement this in terms
76	* of sys_utimes.
77	*/
78	asmlinkage long compat_sys_utime(const char __user *filename,
79	struct compat_utimbuf __user *t)
80	{
81	struct timespec tv[2];
82
83	if (t) {
84	if (get_user(tv[0].tv_sec, &t->actime) \|\|
85	get_user(tv[1].tv_sec, &t->modtime))
86	return -EFAULT;
87	tv[0].tv_nsec = 0;
88	tv[1].tv_nsec = 0;
89	}
90	return do_utimes(AT_FDCWD, filename, t ? tv : NULL, 0);
91	}
92
93	asmlinkage long compat_sys_utimensat(unsigned int dfd, const char __user filename, struct compat_timespec __user t, int flags)
94	{
95	struct timespec tv[2];
96
97	if (t) {
98	if (get_compat_timespec(&tv[0], &t[0]) \|\|
99	get_compat_timespec(&tv[1], &t[1]))
100	return -EFAULT;
101
102	if (tv[0].tv_nsec == UTIME_OMIT && tv[1].tv_nsec == UTIME_OMIT)
103	return 0;
104	}
105	return do_utimes(dfd, filename, t ? tv : NULL, flags);
106	}
107
108	asmlinkage long compat_sys_futimesat(unsigned int dfd, const char __user filename, struct compat_timeval __user t)
109	{
110	struct timespec tv[2];
111
112	if (t) {
113	if (get_user(tv[0].tv_sec, &t[0].tv_sec) \|\|
114	get_user(tv[0].tv_nsec, &t[0].tv_usec) \|\|
115	get_user(tv[1].tv_sec, &t[1].tv_sec) \|\|
116	get_user(tv[1].tv_nsec, &t[1].tv_usec))
117	return -EFAULT;
118	if (tv[0].tv_nsec >= 1000000 \|\| tv[0].tv_nsec < 0 \|\|
119	tv[1].tv_nsec >= 1000000 \|\| tv[1].tv_nsec < 0)
120	return -EINVAL;
121	tv[0].tv_nsec *= 1000;
122	tv[1].tv_nsec *= 1000;
123	}
124	return do_utimes(dfd, filename, t ? tv : NULL, 0);
125	}
126
127	asmlinkage long compat_sys_utimes(const char __user filename, struct compat_timeval __user t)
128	{
129	return compat_sys_futimesat(AT_FDCWD, filename, t);
130	}
131
132	static int cp_compat_stat(struct kstat stat, struct compat_stat __user ubuf)
133	{
134	compat_ino_t ino = stat->ino;
135	typeof(ubuf->st_uid) uid = 0;
136	typeof(ubuf->st_gid) gid = 0;
137	int err;
138
139	SET_UID(uid, stat->uid);
140	SET_GID(gid, stat->gid);
141
142	if ((u64) stat->size > MAX_NON_LFS \|\|
143	!old_valid_dev(stat->dev) \|\|
144	!old_valid_dev(stat->rdev))
145	return -EOVERFLOW;
146	if (sizeof(ino) < sizeof(stat->ino) && ino != stat->ino)
147	return -EOVERFLOW;
148
149	if (clear_user(ubuf, sizeof(*ubuf)))
150	return -EFAULT;
151
152	err = __put_user(old_encode_dev(stat->dev), &ubuf->st_dev);
153	err \|= __put_user(ino, &ubuf->st_ino);
154	err \|= __put_user(stat->mode, &ubuf->st_mode);
155	err \|= __put_user(stat->nlink, &ubuf->st_nlink);
156	err \|= __put_user(uid, &ubuf->st_uid);
157	err \|= __put_user(gid, &ubuf->st_gid);
158	err \|= __put_user(old_encode_dev(stat->rdev), &ubuf->st_rdev);
159	err \|= __put_user(stat->size, &ubuf->st_size);
160	err \|= __put_user(stat->atime.tv_sec, &ubuf->st_atime);
161	err \|= __put_user(stat->atime.tv_nsec, &ubuf->st_atime_nsec);
162	err \|= __put_user(stat->mtime.tv_sec, &ubuf->st_mtime);
163	err \|= __put_user(stat->mtime.tv_nsec, &ubuf->st_mtime_nsec);
164	err \|= __put_user(stat->ctime.tv_sec, &ubuf->st_ctime);
165	err \|= __put_user(stat->ctime.tv_nsec, &ubuf->st_ctime_nsec);
166	err \|= __put_user(stat->blksize, &ubuf->st_blksize);
167	err \|= __put_user(stat->blocks, &ubuf->st_blocks);
168	return err;
169	}
170
171	asmlinkage long compat_sys_newstat(const char __user * filename,
172	struct compat_stat __user *statbuf)
173	{
174	struct kstat stat;
175	int error;
176
177	error = vfs_stat(filename, &stat);
178	if (error)
179	return error;
180	return cp_compat_stat(&stat, statbuf);
181	}
182
183	asmlinkage long compat_sys_newlstat(const char __user * filename,
184	struct compat_stat __user *statbuf)
185	{
186	struct kstat stat;
187	int error;
188
189	error = vfs_lstat(filename, &stat);
190	if (error)
191	return error;
192	return cp_compat_stat(&stat, statbuf);
193	}
194
195	#ifndef __ARCH_WANT_STAT64
196	asmlinkage long compat_sys_newfstatat(unsigned int dfd,
197	const char __user *filename,
198	struct compat_stat __user *statbuf, int flag)
199	{
200	struct kstat stat;
201	int error;
202
203	error = vfs_fstatat(dfd, filename, &stat, flag);
204	if (error)
205	return error;
206	return cp_compat_stat(&stat, statbuf);
207	}
208	#endif
209
210	asmlinkage long compat_sys_newfstat(unsigned int fd,
211	struct compat_stat __user * statbuf)
212	{
213	struct kstat stat;
214	int error = vfs_fstat(fd, &stat);
215
216	if (!error)
217	error = cp_compat_stat(&stat, statbuf);
218	return error;
219	}
220
221	static int put_compat_statfs(struct compat_statfs __user ubuf, struct kstatfs kbuf)
222	{
223
224	if (sizeof ubuf->f_blocks == 4) {
225	if ((kbuf->f_blocks \| kbuf->f_bfree \| kbuf->f_bavail \|
226	kbuf->f_bsize \| kbuf->f_frsize) & 0xffffffff00000000ULL)
227	return -EOVERFLOW;
228	/* f_files and f_ffree may be -1; it's okay
229	* to stuff that into 32 bits */
230	if (kbuf->f_files != 0xffffffffffffffffULL
231	&& (kbuf->f_files & 0xffffffff00000000ULL))
232	return -EOVERFLOW;
233	if (kbuf->f_ffree != 0xffffffffffffffffULL
234	&& (kbuf->f_ffree & 0xffffffff00000000ULL))
235	return -EOVERFLOW;
236	}
237	if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)) \|\|
238	__put_user(kbuf->f_type, &ubuf->f_type) \|\|
239	__put_user(kbuf->f_bsize, &ubuf->f_bsize) \|\|
240	__put_user(kbuf->f_blocks, &ubuf->f_blocks) \|\|
241	__put_user(kbuf->f_bfree, &ubuf->f_bfree) \|\|
242	__put_user(kbuf->f_bavail, &ubuf->f_bavail) \|\|
243	__put_user(kbuf->f_files, &ubuf->f_files) \|\|
244	__put_user(kbuf->f_ffree, &ubuf->f_ffree) \|\|
245	__put_user(kbuf->f_namelen, &ubuf->f_namelen) \|\|
246	__put_user(kbuf->f_fsid.val[0], &ubuf->f_fsid.val[0]) \|\|
247	__put_user(kbuf->f_fsid.val[1], &ubuf->f_fsid.val[1]) \|\|
248	__put_user(kbuf->f_frsize, &ubuf->f_frsize) \|\|
249	__put_user(kbuf->f_flags, &ubuf->f_flags) \|\|
250	__clear_user(ubuf->f_spare, sizeof(ubuf->f_spare)))
251	return -EFAULT;
252	return 0;
253	}
254
255	/*
256	* The following statfs calls are copies of code from fs/statfs.c and
257	* should be checked against those from time to time
258	*/
259	asmlinkage long compat_sys_statfs(const char __user pathname, struct compat_statfs __user buf)
260	{
261	struct kstatfs tmp;
262	int error = user_statfs(pathname, &tmp);
263	if (!error)
264	error = put_compat_statfs(buf, &tmp);
265	return error;
266	}
267
268	asmlinkage long compat_sys_fstatfs(unsigned int fd, struct compat_statfs __user *buf)
269	{
270	struct kstatfs tmp;
271	int error = fd_statfs(fd, &tmp);
272	if (!error)
273	error = put_compat_statfs(buf, &tmp);
274	return error;
275	}
276
277	static int put_compat_statfs64(struct compat_statfs64 __user ubuf, struct kstatfs kbuf)
278	{
279	if (sizeof ubuf->f_blocks == 4) {
280	if ((kbuf->f_blocks \| kbuf->f_bfree \| kbuf->f_bavail \|
281	kbuf->f_bsize \| kbuf->f_frsize) & 0xffffffff00000000ULL)
282	return -EOVERFLOW;
283	/* f_files and f_ffree may be -1; it's okay
284	* to stuff that into 32 bits */
285	if (kbuf->f_files != 0xffffffffffffffffULL
286	&& (kbuf->f_files & 0xffffffff00000000ULL))
287	return -EOVERFLOW;
288	if (kbuf->f_ffree != 0xffffffffffffffffULL
289	&& (kbuf->f_ffree & 0xffffffff00000000ULL))
290	return -EOVERFLOW;
291	}
292	if (!access_ok(VERIFY_WRITE, ubuf, sizeof(*ubuf)) \|\|
293	__put_user(kbuf->f_type, &ubuf->f_type) \|\|
294	__put_user(kbuf->f_bsize, &ubuf->f_bsize) \|\|
295	__put_user(kbuf->f_blocks, &ubuf->f_blocks) \|\|
296	__put_user(kbuf->f_bfree, &ubuf->f_bfree) \|\|
297	__put_user(kbuf->f_bavail, &ubuf->f_bavail) \|\|
298	__put_user(kbuf->f_files, &ubuf->f_files) \|\|
299	__put_user(kbuf->f_ffree, &ubuf->f_ffree) \|\|
300	__put_user(kbuf->f_namelen, &ubuf->f_namelen) \|\|
301	__put_user(kbuf->f_fsid.val[0], &ubuf->f_fsid.val[0]) \|\|
302	__put_user(kbuf->f_fsid.val[1], &ubuf->f_fsid.val[1]) \|\|
303	__put_user(kbuf->f_frsize, &ubuf->f_frsize) \|\|
304	__put_user(kbuf->f_flags, &ubuf->f_flags) \|\|
305	__clear_user(ubuf->f_spare, sizeof(ubuf->f_spare)))
306	return -EFAULT;
307	return 0;
308	}
309
310	asmlinkage long compat_sys_statfs64(const char __user pathname, compat_size_t sz, struct compat_statfs64 __user buf)
311	{
312	struct kstatfs tmp;
313	int error;
314
315	if (sz != sizeof(*buf))
316	return -EINVAL;
317
318	error = user_statfs(pathname, &tmp);
319	if (!error)
320	error = put_compat_statfs64(buf, &tmp);
321	return error;
322	}
323
324	asmlinkage long compat_sys_fstatfs64(unsigned int fd, compat_size_t sz, struct compat_statfs64 __user *buf)
325	{
326	struct kstatfs tmp;
327	int error;
328
329	if (sz != sizeof(*buf))
330	return -EINVAL;
331
332	error = fd_statfs(fd, &tmp);
333	if (!error)
334	error = put_compat_statfs64(buf, &tmp);
335	return error;
336	}
337
338	/*
339	* This is a copy of sys_ustat, just dealing with a structure layout.
340	* Given how simple this syscall is that apporach is more maintainable
341	* than the various conversion hacks.
342	*/
343	asmlinkage long compat_sys_ustat(unsigned dev, struct compat_ustat __user *u)
344	{
345	struct super_block *sb;
346	struct compat_ustat tmp;
347	struct kstatfs sbuf;
348	int err;
349
350	sb = user_get_super(new_decode_dev(dev));
351	if (!sb)
352	return -EINVAL;
353	err = statfs_by_dentry(sb->s_root, &sbuf);
354	drop_super(sb);
355	if (err)
356	return err;
357
358	memset(&tmp, 0, sizeof(struct compat_ustat));
359	tmp.f_tfree = sbuf.f_bfree;
360	tmp.f_tinode = sbuf.f_ffree;
361	if (copy_to_user(u, &tmp, sizeof(struct compat_ustat)))
362	return -EFAULT;
363	return 0;
364	}
365
366	static int get_compat_flock(struct flock kfl, struct compat_flock __user ufl)
367	{
368	if (!access_ok(VERIFY_READ, ufl, sizeof(*ufl)) \|\|
369	__get_user(kfl->l_type, &ufl->l_type) \|\|
370	__get_user(kfl->l_whence, &ufl->l_whence) \|\|
371	__get_user(kfl->l_start, &ufl->l_start) \|\|
372	__get_user(kfl->l_len, &ufl->l_len) \|\|
373	__get_user(kfl->l_pid, &ufl->l_pid))
374	return -EFAULT;
375	return 0;
376	}
377
378	static int put_compat_flock(struct flock kfl, struct compat_flock __user ufl)
379	{
380	if (!access_ok(VERIFY_WRITE, ufl, sizeof(*ufl)) \|\|
381	__put_user(kfl->l_type, &ufl->l_type) \|\|
382	__put_user(kfl->l_whence, &ufl->l_whence) \|\|
383	__put_user(kfl->l_start, &ufl->l_start) \|\|
384	__put_user(kfl->l_len, &ufl->l_len) \|\|
385	__put_user(kfl->l_pid, &ufl->l_pid))
386	return -EFAULT;
387	return 0;
388	}
389
390	#ifndef HAVE_ARCH_GET_COMPAT_FLOCK64
391	static int get_compat_flock64(struct flock kfl, struct compat_flock64 __user ufl)
392	{
393	if (!access_ok(VERIFY_READ, ufl, sizeof(*ufl)) \|\|
394	__get_user(kfl->l_type, &ufl->l_type) \|\|
395	__get_user(kfl->l_whence, &ufl->l_whence) \|\|
396	__get_user(kfl->l_start, &ufl->l_start) \|\|
397	__get_user(kfl->l_len, &ufl->l_len) \|\|
398	__get_user(kfl->l_pid, &ufl->l_pid))
399	return -EFAULT;
400	return 0;
401	}
402	#endif
403
404	#ifndef HAVE_ARCH_PUT_COMPAT_FLOCK64
405	static int put_compat_flock64(struct flock kfl, struct compat_flock64 __user ufl)
406	{
407	if (!access_ok(VERIFY_WRITE, ufl, sizeof(*ufl)) \|\|
408	__put_user(kfl->l_type, &ufl->l_type) \|\|
409	__put_user(kfl->l_whence, &ufl->l_whence) \|\|
410	__put_user(kfl->l_start, &ufl->l_start) \|\|
411	__put_user(kfl->l_len, &ufl->l_len) \|\|
412	__put_user(kfl->l_pid, &ufl->l_pid))
413	return -EFAULT;
414	return 0;
415	}
416	#endif
417
418	asmlinkage long compat_sys_fcntl64(unsigned int fd, unsigned int cmd,
419	unsigned long arg)
420	{
421	mm_segment_t old_fs;
422	struct flock f;
423	long ret;
424
425	switch (cmd) {
426	case F_GETLK:
427	case F_SETLK:
428	case F_SETLKW:
429	ret = get_compat_flock(&f, compat_ptr(arg));
430	if (ret != 0)
431	break;
432	old_fs = get_fs();
433	set_fs(KERNEL_DS);
434	ret = sys_fcntl(fd, cmd, (unsigned long)&f);
435	set_fs(old_fs);
436	if (cmd == F_GETLK && ret == 0) {
437	/* GETLK was successful and we need to return the data...
438	* but it needs to fit in the compat structure.
439	* l_start shouldn't be too big, unless the original
440	* start + end is greater than COMPAT_OFF_T_MAX, in which
441	* case the app was asking for trouble, so we return
442	* -EOVERFLOW in that case.
443	* l_len could be too big, in which case we just truncate it,
444	* and only allow the app to see that part of the conflicting
445	* lock that might make sense to it anyway
446	*/
447
448	if (f.l_start > COMPAT_OFF_T_MAX)
449	ret = -EOVERFLOW;
450	if (f.l_len > COMPAT_OFF_T_MAX)
451	f.l_len = COMPAT_OFF_T_MAX;
452	if (ret == 0)
453	ret = put_compat_flock(&f, compat_ptr(arg));
454	}
455	break;
456
457	case F_GETLK64:
458	case F_SETLK64:
459	case F_SETLKW64:
460	ret = get_compat_flock64(&f, compat_ptr(arg));
461	if (ret != 0)
462	break;
463	old_fs = get_fs();
464	set_fs(KERNEL_DS);
465	ret = sys_fcntl(fd, (cmd == F_GETLK64) ? F_GETLK :
466	((cmd == F_SETLK64) ? F_SETLK : F_SETLKW),
467	(unsigned long)&f);
468	set_fs(old_fs);
469	if (cmd == F_GETLK64 && ret == 0) {
470	/* need to return lock information - see above for commentary */
471	if (f.l_start > COMPAT_LOFF_T_MAX)
472	ret = -EOVERFLOW;
473	if (f.l_len > COMPAT_LOFF_T_MAX)
474	f.l_len = COMPAT_LOFF_T_MAX;
475	if (ret == 0)
476	ret = put_compat_flock64(&f, compat_ptr(arg));
477	}
478	break;
479
480	default:
481	ret = sys_fcntl(fd, cmd, arg);
482	break;
483	}
484	return ret;
485	}
486
487	asmlinkage long compat_sys_fcntl(unsigned int fd, unsigned int cmd,
488	unsigned long arg)
489	{
490	if ((cmd == F_GETLK64) \|\| (cmd == F_SETLK64) \|\| (cmd == F_SETLKW64))
491	return -EINVAL;
492	return compat_sys_fcntl64(fd, cmd, arg);
493	}
494
495	asmlinkage long
496	compat_sys_io_setup(unsigned nr_reqs, u32 __user *ctx32p)
497	{
498	long ret;
499	aio_context_t ctx64;
500
501	mm_segment_t oldfs = get_fs();
502	if (unlikely(get_user(ctx64, ctx32p)))
503	return -EFAULT;
504
505	set_fs(KERNEL_DS);
506	/* The __user pointer cast is valid because of the set_fs() */
507	ret = sys_io_setup(nr_reqs, (aio_context_t __user *) &ctx64);
508	set_fs(oldfs);
509	/* truncating is ok because it's a user address */
510	if (!ret)
511	ret = put_user((u32) ctx64, ctx32p);
512	return ret;
513	}
514
515	asmlinkage long
516	compat_sys_io_getevents(aio_context_t ctx_id,
517	unsigned long min_nr,
518	unsigned long nr,
519	struct io_event __user *events,
520	struct compat_timespec __user *timeout)
521	{
522	long ret;
523	struct timespec t;
524	struct timespec __user *ut = NULL;
525
526	ret = -EFAULT;
527	if (unlikely(!access_ok(VERIFY_WRITE, events,
528	nr * sizeof(struct io_event))))
529	goto out;
530	if (timeout) {
531	if (get_compat_timespec(&t, timeout))
532	goto out;
533
534	ut = compat_alloc_user_space(sizeof(*ut));
535	if (copy_to_user(ut, &t, sizeof(t)) )
536	goto out;
537	}
538	ret = sys_io_getevents(ctx_id, min_nr, nr, events, ut);
539	out:
540	return ret;
541	}
542
543	/* A write operation does a read from user space and vice versa */
544	#define vrfy_dir(type) ((type) == READ ? VERIFY_WRITE : VERIFY_READ)
545
546	ssize_t compat_rw_copy_check_uvector(int type,
547	const struct compat_iovec __user *uvector, unsigned long nr_segs,
548	unsigned long fast_segs, struct iovec *fast_pointer,
549	struct iovec **ret_pointer, int check_access)
550	{
551	compat_ssize_t tot_len;
552	struct iovec iov = ret_pointer = fast_pointer;
553	ssize_t ret = 0;
554	int seg;
555
556	/*
557	* SuS says "The readv() function may fail if the iovcnt argument
558	* was less than or equal to 0, or greater than {IOV_MAX}. Linux has
559	* traditionally returned zero for zero segments, so...
560	*/
561	if (nr_segs == 0)
562	goto out;
563
564	ret = -EINVAL;
565	if (nr_segs > UIO_MAXIOV \|\| nr_segs < 0)
566	goto out;
567	if (nr_segs > fast_segs) {
568	ret = -ENOMEM;
569	iov = kmalloc(nr_segs*sizeof(struct iovec), GFP_KERNEL);
570	if (iov == NULL)
571	goto out;
572	}
573	*ret_pointer = iov;
574
575	/*
576	* Single unix specification:
577	* We should -EINVAL if an element length is not >= 0 and fitting an
578	* ssize_t.
579	*
580	* In Linux, the total length is limited to MAX_RW_COUNT, there is
581	* no overflow possibility.
582	*/
583	tot_len = 0;
584	ret = -EINVAL;
585	for (seg = 0; seg < nr_segs; seg++) {
586	compat_uptr_t buf;
587	compat_ssize_t len;
588
589	if (__get_user(len, &uvector->iov_len) \|\|
590	__get_user(buf, &uvector->iov_base)) {
591	ret = -EFAULT;
592	goto out;
593	}
594	if (len < 0) /* size_t not fitting in compat_ssize_t .. */
595	goto out;
596	if (check_access &&
597	!access_ok(vrfy_dir(type), compat_ptr(buf), len)) {
598	ret = -EFAULT;
599	goto out;
600	}
601	if (len > MAX_RW_COUNT - tot_len)
602	len = MAX_RW_COUNT - tot_len;
603	tot_len += len;
604	iov->iov_base = compat_ptr(buf);
605	iov->iov_len = (compat_size_t) len;
606	uvector++;
607	iov++;
608	}
609	ret = tot_len;
610
611	out:
612	return ret;
613	}
614
615	static inline long
616	copy_iocb(long nr, u32 __user ptr32, struct iocb __user __user *ptr64)
617	{
618	compat_uptr_t uptr;
619	int i;
620
621	for (i = 0; i < nr; ++i) {
622	if (get_user(uptr, ptr32 + i))
623	return -EFAULT;
624	if (put_user(compat_ptr(uptr), ptr64 + i))
625	return -EFAULT;
626	}
627	return 0;
628	}
629
630	#define MAX_AIO_SUBMITS (PAGE_SIZE/sizeof(struct iocb *))
631
632	asmlinkage long
633	compat_sys_io_submit(aio_context_t ctx_id, int nr, u32 __user *iocb)
634	{
635	struct iocb __user * __user *iocb64;
636	long ret;
637
638	if (unlikely(nr < 0))
639	return -EINVAL;
640
641	if (nr > MAX_AIO_SUBMITS)
642	nr = MAX_AIO_SUBMITS;
643
644	iocb64 = compat_alloc_user_space(nr * sizeof(*iocb64));
645	ret = copy_iocb(nr, iocb, iocb64);
646	if (!ret)
647	ret = do_io_submit(ctx_id, nr, iocb64, 1);
648	return ret;
649	}
650
651	struct compat_ncp_mount_data {
652	compat_int_t version;
653	compat_uint_t ncp_fd;
654	__compat_uid_t mounted_uid;
655	compat_pid_t wdog_pid;
656	unsigned char mounted_vol[NCP_VOLNAME_LEN + 1];
657	compat_uint_t time_out;
658	compat_uint_t retry_count;
659	compat_uint_t flags;
660	__compat_uid_t uid;
661	__compat_gid_t gid;
662	compat_mode_t file_mode;
663	compat_mode_t dir_mode;
664	};
665
666	struct compat_ncp_mount_data_v4 {
667	compat_int_t version;
668	compat_ulong_t flags;
669	compat_ulong_t mounted_uid;
670	compat_long_t wdog_pid;
671	compat_uint_t ncp_fd;
672	compat_uint_t time_out;
673	compat_uint_t retry_count;
674	compat_ulong_t uid;
675	compat_ulong_t gid;
676	compat_ulong_t file_mode;
677	compat_ulong_t dir_mode;
678	};
679
680	static void do_ncp_super_data_conv(void raw_data)
681	{
682	int version = (unsigned int )raw_data;
683
684	if (version == 3) {
685	struct compat_ncp_mount_data *c_n = raw_data;
686	struct ncp_mount_data *n = raw_data;
687
688	n->dir_mode = c_n->dir_mode;
689	n->file_mode = c_n->file_mode;
690	n->gid = c_n->gid;
691	n->uid = c_n->uid;
692	memmove (n->mounted_vol, c_n->mounted_vol, (sizeof (c_n->mounted_vol) + 3 * sizeof (unsigned int)));
693	n->wdog_pid = c_n->wdog_pid;
694	n->mounted_uid = c_n->mounted_uid;
695	} else if (version == 4) {
696	struct compat_ncp_mount_data_v4 *c_n = raw_data;
697	struct ncp_mount_data_v4 *n = raw_data;
698
699	n->dir_mode = c_n->dir_mode;
700	n->file_mode = c_n->file_mode;
701	n->gid = c_n->gid;
702	n->uid = c_n->uid;
703	n->retry_count = c_n->retry_count;
704	n->time_out = c_n->time_out;
705	n->ncp_fd = c_n->ncp_fd;
706	n->wdog_pid = c_n->wdog_pid;
707	n->mounted_uid = c_n->mounted_uid;
708	n->flags = c_n->flags;
709	} else if (version != 5) {
710	return NULL;
711	}
712
713	return raw_data;
714	}
715
716
717	struct compat_nfs_string {
718	compat_uint_t len;
719	compat_uptr_t data;
720	};
721
722	static inline void compat_nfs_string(struct nfs_string *dst,
723	struct compat_nfs_string *src)
724	{
725	dst->data = compat_ptr(src->data);
726	dst->len = src->len;
727	}
728
729	struct compat_nfs4_mount_data_v1 {
730	compat_int_t version;
731	compat_int_t flags;
732	compat_int_t rsize;
733	compat_int_t wsize;
734	compat_int_t timeo;
735	compat_int_t retrans;
736	compat_int_t acregmin;
737	compat_int_t acregmax;
738	compat_int_t acdirmin;
739	compat_int_t acdirmax;
740	struct compat_nfs_string client_addr;
741	struct compat_nfs_string mnt_path;
742	struct compat_nfs_string hostname;
743	compat_uint_t host_addrlen;
744	compat_uptr_t host_addr;
745	compat_int_t proto;
746	compat_int_t auth_flavourlen;
747	compat_uptr_t auth_flavours;
748	};
749
750	static int do_nfs4_super_data_conv(void *raw_data)
751	{
752	int version = (compat_uint_t ) raw_data;
753
754	if (version == 1) {
755	struct compat_nfs4_mount_data_v1 *raw = raw_data;
756	struct nfs4_mount_data *real = raw_data;
757
758	/* copy the fields backwards */
759	real->auth_flavours = compat_ptr(raw->auth_flavours);
760	real->auth_flavourlen = raw->auth_flavourlen;
761	real->proto = raw->proto;
762	real->host_addr = compat_ptr(raw->host_addr);
763	real->host_addrlen = raw->host_addrlen;
764	compat_nfs_string(&real->hostname, &raw->hostname);
765	compat_nfs_string(&real->mnt_path, &raw->mnt_path);
766	compat_nfs_string(&real->client_addr, &raw->client_addr);
767	real->acdirmax = raw->acdirmax;
768	real->acdirmin = raw->acdirmin;
769	real->acregmax = raw->acregmax;
770	real->acregmin = raw->acregmin;
771	real->retrans = raw->retrans;
772	real->timeo = raw->timeo;
773	real->wsize = raw->wsize;
774	real->rsize = raw->rsize;
775	real->flags = raw->flags;
776	real->version = raw->version;
777	}
778
779	return 0;
780	}
781
782	#define NCPFS_NAME "ncpfs"
783	#define NFS4_NAME "nfs4"
784
785	asmlinkage long compat_sys_mount(const char __user * dev_name,
786	const char __user * dir_name,
787	const char __user * type, unsigned long flags,
788	const void __user * data)
789	{
790	char *kernel_type;
791	unsigned long data_page;
792	char *kernel_dev;
793	char *dir_page;
794	int retval;
795
796	retval = copy_mount_string(type, &kernel_type);
797	if (retval < 0)
798	goto out;
799
800	dir_page = getname(dir_name);
801	retval = PTR_ERR(dir_page);
802	if (IS_ERR(dir_page))
803	goto out1;
804
805	retval = copy_mount_string(dev_name, &kernel_dev);
806	if (retval < 0)
807	goto out2;
808
809	retval = copy_mount_options(data, &data_page);
810	if (retval < 0)
811	goto out3;
812
813	retval = -EINVAL;
814
815	if (kernel_type && data_page) {
816	if (!strcmp(kernel_type, NCPFS_NAME)) {
817	do_ncp_super_data_conv((void *)data_page);
818	} else if (!strcmp(kernel_type, NFS4_NAME)) {
819	if (do_nfs4_super_data_conv((void *) data_page))
820	goto out4;
821	}
822	}
823
824	retval = do_mount(kernel_dev, dir_page, kernel_type,
825	flags, (void*)data_page);
826
827	out4:
828	free_page(data_page);
829	out3:
830	kfree(kernel_dev);
831	out2:
832	putname(dir_page);
833	out1:
834	kfree(kernel_type);
835	out:
836	return retval;
837	}
838
839	struct compat_old_linux_dirent {
840	compat_ulong_t d_ino;
841	compat_ulong_t d_offset;
842	unsigned short d_namlen;
843	char d_name[1];
844	};
845
846	struct compat_readdir_callback {
847	struct compat_old_linux_dirent __user *dirent;
848	int result;
849	};
850
851	static int compat_fillonedir(void __buf, const char name, int namlen,
852	loff_t offset, u64 ino, unsigned int d_type)
853	{
854	struct compat_readdir_callback *buf = __buf;
855	struct compat_old_linux_dirent __user *dirent;
856	compat_ulong_t d_ino;
857
858	if (buf->result)
859	return -EINVAL;
860	d_ino = ino;
861	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
862	buf->result = -EOVERFLOW;
863	return -EOVERFLOW;
864	}
865	buf->result++;
866	dirent = buf->dirent;
867	if (!access_ok(VERIFY_WRITE, dirent,
868	(unsigned long)(dirent->d_name + namlen + 1) -
869	(unsigned long)dirent))
870	goto efault;
871	if ( __put_user(d_ino, &dirent->d_ino) \|\|
872	__put_user(offset, &dirent->d_offset) \|\|
873	__put_user(namlen, &dirent->d_namlen) \|\|
874	__copy_to_user(dirent->d_name, name, namlen) \|\|
875	__put_user(0, dirent->d_name + namlen))
876	goto efault;
877	return 0;
878	efault:
879	buf->result = -EFAULT;
880	return -EFAULT;
881	}
882
883	asmlinkage long compat_sys_old_readdir(unsigned int fd,
884	struct compat_old_linux_dirent __user *dirent, unsigned int count)
885	{
886	int error;
887	struct file *file;
888	struct compat_readdir_callback buf;
889
890	error = -EBADF;
891	file = fget(fd);
892	if (!file)
893	goto out;
894
895	buf.result = 0;
896	buf.dirent = dirent;
897
898	error = vfs_readdir(file, compat_fillonedir, &buf);
899	if (buf.result)
900	error = buf.result;
901
902	fput(file);
903	out:
904	return error;
905	}
906
907	struct compat_linux_dirent {
908	compat_ulong_t d_ino;
909	compat_ulong_t d_off;
910	unsigned short d_reclen;
911	char d_name[1];
912	};
913
914	struct compat_getdents_callback {
915	struct compat_linux_dirent __user *current_dir;
916	struct compat_linux_dirent __user *previous;
917	int count;
918	int error;
919	};
920
921	static int compat_filldir(void __buf, const char name, int namlen,
922	loff_t offset, u64 ino, unsigned int d_type)
923	{
924	struct compat_linux_dirent __user * dirent;
925	struct compat_getdents_callback *buf = __buf;
926	compat_ulong_t d_ino;
927	int reclen = ALIGN(offsetof(struct compat_linux_dirent, d_name) +
928	namlen + 2, sizeof(compat_long_t));
929
930	buf->error = -EINVAL; /* only used if we fail.. */
931	if (reclen > buf->count)
932	return -EINVAL;
933	d_ino = ino;
934	if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) {
935	buf->error = -EOVERFLOW;
936	return -EOVERFLOW;
937	}
938	dirent = buf->previous;
939	if (dirent) {
940	if (__put_user(offset, &dirent->d_off))
941	goto efault;
942	}
943	dirent = buf->current_dir;
944	if (__put_user(d_ino, &dirent->d_ino))
945	goto efault;
946	if (__put_user(reclen, &dirent->d_reclen))
947	goto efault;
948	if (copy_to_user(dirent->d_name, name, namlen))
949	goto efault;
950	if (__put_user(0, dirent->d_name + namlen))
951	goto efault;
952	if (__put_user(d_type, (char __user *) dirent + reclen - 1))
953	goto efault;
954	buf->previous = dirent;
955	dirent = (void __user *)dirent + reclen;
956	buf->current_dir = dirent;
957	buf->count -= reclen;
958	return 0;
959	efault:
960	buf->error = -EFAULT;
961	return -EFAULT;
962	}
963
964	asmlinkage long compat_sys_getdents(unsigned int fd,
965	struct compat_linux_dirent __user *dirent, unsigned int count)
966	{
967	struct file * file;
968	struct compat_linux_dirent __user * lastdirent;
969	struct compat_getdents_callback buf;
970	int error;
971
972	error = -EFAULT;
973	if (!access_ok(VERIFY_WRITE, dirent, count))
974	goto out;
975
976	error = -EBADF;
977	file = fget(fd);
978	if (!file)
979	goto out;
980
981	buf.current_dir = dirent;
982	buf.previous = NULL;
983	buf.count = count;
984	buf.error = 0;
985
986	error = vfs_readdir(file, compat_filldir, &buf);
987	if (error >= 0)
988	error = buf.error;
989	lastdirent = buf.previous;
990	if (lastdirent) {
991	if (put_user(file->f_pos, &lastdirent->d_off))
992	error = -EFAULT;
993	else
994	error = count - buf.count;
995	}
996	fput(file);
997	out:
998	return error;
999	}
1000
1001	#ifndef __ARCH_OMIT_COMPAT_SYS_GETDENTS64
1002
1003	struct compat_getdents_callback64 {
1004	struct linux_dirent64 __user *current_dir;
1005	struct linux_dirent64 __user *previous;
1006	int count;
1007	int error;
1008	};
1009
1010	static int compat_filldir64(void * __buf, const char * name, int namlen, loff_t offset,
1011	u64 ino, unsigned int d_type)
1012	{
1013	struct linux_dirent64 __user *dirent;
1014	struct compat_getdents_callback64 *buf = __buf;
1015	int reclen = ALIGN(offsetof(struct linux_dirent64, d_name) + namlen + 1,
1016	sizeof(u64));
1017	u64 off;
1018
1019	buf->error = -EINVAL; /* only used if we fail.. */
1020	if (reclen > buf->count)
1021	return -EINVAL;
1022	dirent = buf->previous;
1023
1024	if (dirent) {
1025	if (__put_user_unaligned(offset, &dirent->d_off))
1026	goto efault;
1027	}
1028	dirent = buf->current_dir;
1029	if (__put_user_unaligned(ino, &dirent->d_ino))
1030	goto efault;
1031	off = 0;
1032	if (__put_user_unaligned(off, &dirent->d_off))
1033	goto efault;
1034	if (__put_user(reclen, &dirent->d_reclen))
1035	goto efault;
1036	if (__put_user(d_type, &dirent->d_type))
1037	goto efault;
1038	if (copy_to_user(dirent->d_name, name, namlen))
1039	goto efault;
1040	if (__put_user(0, dirent->d_name + namlen))
1041	goto efault;
1042	buf->previous = dirent;
1043	dirent = (void __user *)dirent + reclen;
1044	buf->current_dir = dirent;
1045	buf->count -= reclen;
1046	return 0;
1047	efault:
1048	buf->error = -EFAULT;
1049	return -EFAULT;
1050	}
1051
1052	asmlinkage long compat_sys_getdents64(unsigned int fd,
1053	struct linux_dirent64 __user * dirent, unsigned int count)
1054	{
1055	struct file * file;
1056	struct linux_dirent64 __user * lastdirent;
1057	struct compat_getdents_callback64 buf;
1058	int error;
1059
1060	error = -EFAULT;
1061	if (!access_ok(VERIFY_WRITE, dirent, count))
1062	goto out;
1063
1064	error = -EBADF;
1065	file = fget(fd);
1066	if (!file)
1067	goto out;
1068
1069	buf.current_dir = dirent;
1070	buf.previous = NULL;
1071	buf.count = count;
1072	buf.error = 0;
1073
1074	error = vfs_readdir(file, compat_filldir64, &buf);
1075	if (error >= 0)
1076	error = buf.error;
1077	lastdirent = buf.previous;
1078	if (lastdirent) {
1079	typeof(lastdirent->d_off) d_off = file->f_pos;
1080	if (__put_user_unaligned(d_off, &lastdirent->d_off))
1081	error = -EFAULT;
1082	else
1083	error = count - buf.count;
1084	}
1085	fput(file);
1086	out:
1087	return error;
1088	}
1089	#endif /* ! __ARCH_OMIT_COMPAT_SYS_GETDENTS64 */
1090
1091	static ssize_t compat_do_readv_writev(int type, struct file *file,
1092	const struct compat_iovec __user *uvector,
1093	unsigned long nr_segs, loff_t *pos)
1094	{
1095	compat_ssize_t tot_len;
1096	struct iovec iovstack[UIO_FASTIOV];
1097	struct iovec *iov = iovstack;
1098	ssize_t ret;
1099	io_fn_t fn;
1100	iov_fn_t fnv;
1101
1102	ret = -EINVAL;
1103	if (!file->f_op)
1104	goto out;
1105
1106	ret = -EFAULT;
1107	if (!access_ok(VERIFY_READ, uvector, nr_segssizeof(uvector)))
1108	goto out;
1109
1110	tot_len = compat_rw_copy_check_uvector(type, uvector, nr_segs,
1111	UIO_FASTIOV, iovstack, &iov, 1);
1112	if (tot_len == 0) {
1113	ret = 0;
1114	goto out;
1115	}
1116
1117	ret = rw_verify_area(type, file, pos, tot_len);
1118	if (ret < 0)
1119	goto out;
1120
1121	fnv = NULL;
1122	if (type == READ) {
1123	fn = file->f_op->read;
1124	fnv = file->f_op->aio_read;
1125	} else {
1126	fn = (io_fn_t)file->f_op->write;
1127	fnv = file->f_op->aio_write;
1128	}
1129
1130	if (fnv)
1131	ret = do_sync_readv_writev(file, iov, nr_segs, tot_len,
1132	pos, fnv);
1133	else
1134	ret = do_loop_readv_writev(file, iov, nr_segs, pos, fn);
1135
1136	out:
1137	if (iov != iovstack)
1138	kfree(iov);
1139	if ((ret + (type == READ)) > 0) {
1140	if (type == READ)
1141	fsnotify_access(file);
1142	else
1143	fsnotify_modify(file);
1144	}
1145	return ret;
1146	}
1147
1148	static size_t compat_readv(struct file *file,
1149	const struct compat_iovec __user *vec,
1150	unsigned long vlen, loff_t *pos)
1151	{
1152	ssize_t ret = -EBADF;
1153
1154	if (!(file->f_mode & FMODE_READ))
1155	goto out;
1156
1157	ret = -EINVAL;
1158	if (!file->f_op \|\| (!file->f_op->aio_read && !file->f_op->read))
1159	goto out;
1160
1161	ret = compat_do_readv_writev(READ, file, vec, vlen, pos);
1162
1163	out:
1164	if (ret > 0)
1165	add_rchar(current, ret);
1166	inc_syscr(current);
1167	return ret;
1168	}
1169
1170	asmlinkage ssize_t
1171	compat_sys_readv(unsigned long fd, const struct compat_iovec __user *vec,
1172	unsigned long vlen)
1173	{
1174	struct file *file;
1175	int fput_needed;
1176	ssize_t ret;
1177
1178	file = fget_light(fd, &fput_needed);
1179	if (!file)
1180	return -EBADF;
1181	ret = compat_readv(file, vec, vlen, &file->f_pos);
1182	fput_light(file, fput_needed);
1183	return ret;
1184	}
1185
1186	asmlinkage ssize_t
1187	compat_sys_preadv(unsigned long fd, const struct compat_iovec __user *vec,
1188	unsigned long vlen, u32 pos_low, u32 pos_high)
1189	{
1190	loff_t pos = ((loff_t)pos_high << 32) \| pos_low;
1191	struct file *file;
1192	int fput_needed;
1193	ssize_t ret;
1194
1195	if (pos < 0)
1196	return -EINVAL;
1197	file = fget_light(fd, &fput_needed);
1198	if (!file)
1199	return -EBADF;
1200	ret = -ESPIPE;
1201	if (file->f_mode & FMODE_PREAD)
1202	ret = compat_readv(file, vec, vlen, &pos);
1203	fput_light(file, fput_needed);
1204	return ret;
1205	}
1206
1207	static size_t compat_writev(struct file *file,
1208	const struct compat_iovec __user *vec,
1209	unsigned long vlen, loff_t *pos)
1210	{
1211	ssize_t ret = -EBADF;
1212
1213	if (!(file->f_mode & FMODE_WRITE))
1214	goto out;
1215
1216	ret = -EINVAL;
1217	if (!file->f_op \|\| (!file->f_op->aio_write && !file->f_op->write))
1218	goto out;
1219
1220	ret = compat_do_readv_writev(WRITE, file, vec, vlen, pos);
1221
1222	out:
1223	if (ret > 0)
1224	add_wchar(current, ret);
1225	inc_syscw(current);
1226	return ret;
1227	}
1228
1229	asmlinkage ssize_t
1230	compat_sys_writev(unsigned long fd, const struct compat_iovec __user *vec,
1231	unsigned long vlen)
1232	{
1233	struct file *file;
1234	int fput_needed;
1235	ssize_t ret;
1236
1237	file = fget_light(fd, &fput_needed);
1238	if (!file)
1239	return -EBADF;
1240	ret = compat_writev(file, vec, vlen, &file->f_pos);
1241	fput_light(file, fput_needed);
1242	return ret;
1243	}
1244
1245	asmlinkage ssize_t
1246	compat_sys_pwritev(unsigned long fd, const struct compat_iovec __user *vec,
1247	unsigned long vlen, u32 pos_low, u32 pos_high)
1248	{
1249	loff_t pos = ((loff_t)pos_high << 32) \| pos_low;
1250	struct file *file;
1251	int fput_needed;
1252	ssize_t ret;
1253
1254	if (pos < 0)
1255	return -EINVAL;
1256	file = fget_light(fd, &fput_needed);
1257	if (!file)
1258	return -EBADF;
1259	ret = -ESPIPE;
1260	if (file->f_mode & FMODE_PWRITE)
1261	ret = compat_writev(file, vec, vlen, &pos);
1262	fput_light(file, fput_needed);
1263	return ret;
1264	}
1265
1266	asmlinkage long
1267	compat_sys_vmsplice(int fd, const struct compat_iovec __user *iov32,
1268	unsigned int nr_segs, unsigned int flags)
1269	{
1270	unsigned i;
1271	struct iovec __user *iov;
1272	if (nr_segs > UIO_MAXIOV)
1273	return -EINVAL;
1274	iov = compat_alloc_user_space(nr_segs * sizeof(struct iovec));
1275	for (i = 0; i < nr_segs; i++) {
1276	struct compat_iovec v;
1277	if (get_user(v.iov_base, &iov32[i].iov_base) \|\|
1278	get_user(v.iov_len, &iov32[i].iov_len) \|\|
1279	put_user(compat_ptr(v.iov_base), &iov[i].iov_base) \|\|
1280	put_user(v.iov_len, &iov[i].iov_len))
1281	return -EFAULT;
1282	}
1283	return sys_vmsplice(fd, iov, nr_segs, flags);
1284	}
1285
1286	/*
1287	* Exactly like fs/open.c:sys_open(), except that it doesn't set the
1288	* O_LARGEFILE flag.
1289	*/
1290	asmlinkage long
1291	compat_sys_open(const char __user *filename, int flags, int mode)
1292	{
1293	return do_sys_open(AT_FDCWD, filename, flags, mode);
1294	}
1295
1296	/*
1297	* Exactly like fs/open.c:sys_openat(), except that it doesn't set the
1298	* O_LARGEFILE flag.
1299	*/
1300	asmlinkage long
1301	compat_sys_openat(unsigned int dfd, const char __user *filename, int flags, int mode)
1302	{
1303	return do_sys_open(dfd, filename, flags, mode);
1304	}
1305
1306	#define __COMPAT_NFDBITS (8 * sizeof(compat_ulong_t))
1307
1308	static int poll_select_copy_remaining(struct timespec end_time, void __user p,
1309	int timeval, int ret)
1310	{
1311	struct timespec ts;
1312
1313	if (!p)
1314	return ret;
1315
1316	if (current->personality & STICKY_TIMEOUTS)
1317	goto sticky;
1318
1319	/* No update for zero timeout */
1320	if (!end_time->tv_sec && !end_time->tv_nsec)
1321	return ret;
1322
1323	ktime_get_ts(&ts);
1324	ts = timespec_sub(*end_time, ts);
1325	if (ts.tv_sec < 0)
1326	ts.tv_sec = ts.tv_nsec = 0;
1327
1328	if (timeval) {
1329	struct compat_timeval rtv;
1330
1331	rtv.tv_sec = ts.tv_sec;
1332	rtv.tv_usec = ts.tv_nsec / NSEC_PER_USEC;
1333
1334	if (!copy_to_user(p, &rtv, sizeof(rtv)))
1335	return ret;
1336	} else {
1337	struct compat_timespec rts;
1338
1339	rts.tv_sec = ts.tv_sec;
1340	rts.tv_nsec = ts.tv_nsec;
1341
1342	if (!copy_to_user(p, &rts, sizeof(rts)))
1343	return ret;
1344	}
1345	/*
1346	* If an application puts its timeval in read-only memory, we
1347	* don't want the Linux-specific update to the timeval to
1348	* cause a fault after the select has completed
1349	* successfully. However, because we're not updating the
1350	* timeval, we can't restart the system call.
1351	*/
1352
1353	sticky:
1354	if (ret == -ERESTARTNOHAND)
1355	ret = -EINTR;
1356	return ret;
1357	}
1358
1359	/*
1360	* Ooo, nasty. We need here to frob 32-bit unsigned longs to
1361	* 64-bit unsigned longs.
1362	*/
1363	static
1364	int compat_get_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
1365	unsigned long *fdset)
1366	{
1367	nr = DIV_ROUND_UP(nr, __COMPAT_NFDBITS);
1368	if (ufdset) {
1369	unsigned long odd;
1370
1371	if (!access_ok(VERIFY_WRITE, ufdset, nr*sizeof(compat_ulong_t)))
1372	return -EFAULT;
1373
1374	odd = nr & 1UL;
1375	nr &= ~1UL;
1376	while (nr) {
1377	unsigned long h, l;
1378	if (__get_user(l, ufdset) \|\| __get_user(h, ufdset+1))
1379	return -EFAULT;
1380	ufdset += 2;
1381	*fdset++ = h << 32 \| l;
1382	nr -= 2;
1383	}
1384	if (odd && __get_user(*fdset, ufdset))
1385	return -EFAULT;
1386	} else {
1387	/* Tricky, must clear full unsigned long in the
1388	* kernel fdset at the end, this makes sure that
1389	* actually happens.
1390	*/
1391	memset(fdset, 0, ((nr + 1) & ~1)*sizeof(compat_ulong_t));
1392	}
1393	return 0;
1394	}
1395
1396	static
1397	int compat_set_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
1398	unsigned long *fdset)
1399	{
1400	unsigned long odd;
1401	nr = DIV_ROUND_UP(nr, __COMPAT_NFDBITS);
1402
1403	if (!ufdset)
1404	return 0;
1405
1406	odd = nr & 1UL;
1407	nr &= ~1UL;
1408	while (nr) {
1409	unsigned long h, l;
1410	l = *fdset++;
1411	h = l >> 32;
1412	if (__put_user(l, ufdset) \|\| __put_user(h, ufdset+1))
1413	return -EFAULT;
1414	ufdset += 2;
1415	nr -= 2;
1416	}
1417	if (odd && __put_user(*fdset, ufdset))
1418	return -EFAULT;
1419	return 0;
1420	}
1421
1422
1423	/*
1424	* This is a virtual copy of sys_select from fs/select.c and probably
1425	* should be compared to it from time to time
1426	*/
1427
1428	/*
1429	* We can actually return ERESTARTSYS instead of EINTR, but I'd
1430	* like to be certain this leads to no problems. So I return
1431	* EINTR just for safety.
1432	*
1433	* Update: ERESTARTSYS breaks at least the xview clock binary, so
1434	* I'm trying ERESTARTNOHAND which restart only when you want to.
1435	*/
1436	int compat_core_sys_select(int n, compat_ulong_t __user *inp,
1437	compat_ulong_t __user outp, compat_ulong_t __user exp,
1438	struct timespec *end_time)
1439	{
1440	fd_set_bits fds;
1441	void *bits;
1442	int size, max_fds, ret = -EINVAL;
1443	struct fdtable *fdt;
1444	long stack_fds[SELECT_STACK_ALLOC/sizeof(long)];
1445
1446	if (n < 0)
1447	goto out_nofds;
1448
1449	/* max_fds can increase, so grab it once to avoid race */
1450	rcu_read_lock();
1451	fdt = files_fdtable(current->files);
1452	max_fds = fdt->max_fds;
1453	rcu_read_unlock();
1454	if (n > max_fds)
1455	n = max_fds;
1456
1457	/*
1458	* We need 6 bitmaps (in/out/ex for both incoming and outgoing),
1459	* since we used fdset we need to allocate memory in units of
1460	* long-words.
1461	*/
1462	size = FDS_BYTES(n);
1463	bits = stack_fds;
1464	if (size > sizeof(stack_fds) / 6) {
1465	bits = kmalloc(6 * size, GFP_KERNEL);
1466	ret = -ENOMEM;
1467	if (!bits)
1468	goto out_nofds;
1469	}
1470	fds.in = (unsigned long *) bits;
1471	fds.out = (unsigned long *) (bits + size);
1472	fds.ex = (unsigned long ) (bits + 2size);
1473	fds.res_in = (unsigned long ) (bits + 3size);
1474	fds.res_out = (unsigned long ) (bits + 4size);
1475	fds.res_ex = (unsigned long ) (bits + 5size);
1476
1477	if ((ret = compat_get_fd_set(n, inp, fds.in)) \|\|
1478	(ret = compat_get_fd_set(n, outp, fds.out)) \|\|
1479	(ret = compat_get_fd_set(n, exp, fds.ex)))
1480	goto out;
1481	zero_fd_set(n, fds.res_in);
1482	zero_fd_set(n, fds.res_out);
1483	zero_fd_set(n, fds.res_ex);
1484
1485	ret = do_select(n, &fds, end_time);
1486
1487	if (ret < 0)
1488	goto out;
1489	if (!ret) {
1490	ret = -ERESTARTNOHAND;
1491	if (signal_pending(current))
1492	goto out;
1493	ret = 0;
1494	}
1495
1496	if (compat_set_fd_set(n, inp, fds.res_in) \|\|
1497	compat_set_fd_set(n, outp, fds.res_out) \|\|
1498	compat_set_fd_set(n, exp, fds.res_ex))
1499	ret = -EFAULT;
1500	out:
1501	if (bits != stack_fds)
1502	kfree(bits);
1503	out_nofds:
1504	return ret;
1505	}
1506
1507	asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
1508	compat_ulong_t __user outp, compat_ulong_t __user exp,
1509	struct compat_timeval __user *tvp)
1510	{
1511	struct timespec end_time, *to = NULL;
1512	struct compat_timeval tv;
1513	int ret;
1514
1515	if (tvp) {
1516	if (copy_from_user(&tv, tvp, sizeof(tv)))
1517	return -EFAULT;
1518
1519	to = &end_time;
1520	if (poll_select_set_timeout(to,
1521	tv.tv_sec + (tv.tv_usec / USEC_PER_SEC),
1522	(tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC))
1523	return -EINVAL;
1524	}
1525
1526	ret = compat_core_sys_select(n, inp, outp, exp, to);
1527	ret = poll_select_copy_remaining(&end_time, tvp, 1, ret);
1528
1529	return ret;
1530	}
1531
1532	struct compat_sel_arg_struct {
1533	compat_ulong_t n;
1534	compat_uptr_t inp;
1535	compat_uptr_t outp;
1536	compat_uptr_t exp;
1537	compat_uptr_t tvp;
1538	};
1539
1540	asmlinkage long compat_sys_old_select(struct compat_sel_arg_struct __user *arg)
1541	{
1542	struct compat_sel_arg_struct a;
1543
1544	if (copy_from_user(&a, arg, sizeof(a)))
1545	return -EFAULT;
1546	return compat_sys_select(a.n, compat_ptr(a.inp), compat_ptr(a.outp),
1547	compat_ptr(a.exp), compat_ptr(a.tvp));
1548	}
1549
1550	#ifdef HAVE_SET_RESTORE_SIGMASK
1551	static long do_compat_pselect(int n, compat_ulong_t __user *inp,
1552	compat_ulong_t __user outp, compat_ulong_t __user exp,
1553	struct compat_timespec __user tsp, compat_sigset_t __user sigmask,
1554	compat_size_t sigsetsize)
1555	{
1556	compat_sigset_t ss32;
1557	sigset_t ksigmask, sigsaved;
1558	struct compat_timespec ts;
1559	struct timespec end_time, *to = NULL;
1560	int ret;
1561
1562	if (tsp) {
1563	if (copy_from_user(&ts, tsp, sizeof(ts)))
1564	return -EFAULT;
1565
1566	to = &end_time;
1567	if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
1568	return -EINVAL;
1569	}
1570
1571	if (sigmask) {
1572	if (sigsetsize != sizeof(compat_sigset_t))
1573	return -EINVAL;
1574	if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
1575	return -EFAULT;
1576	sigset_from_compat(&ksigmask, &ss32);
1577
1578	sigdelsetmask(&ksigmask, sigmask(SIGKILL)\|sigmask(SIGSTOP));
1579	sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
1580	}
1581
1582	ret = compat_core_sys_select(n, inp, outp, exp, to);
1583	ret = poll_select_copy_remaining(&end_time, tsp, 0, ret);
1584
1585	if (ret == -ERESTARTNOHAND) {
1586	/*
1587	* Don't restore the signal mask yet. Let do_signal() deliver
1588	* the signal on the way back to userspace, before the signal
1589	* mask is restored.
1590	*/
1591	if (sigmask) {
1592	memcpy(&current->saved_sigmask, &sigsaved,
1593	sizeof(sigsaved));
1594	set_restore_sigmask();
1595	}
1596	} else if (sigmask)
1597	sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1598
1599	return ret;
1600	}
1601
1602	asmlinkage long compat_sys_pselect6(int n, compat_ulong_t __user *inp,
1603	compat_ulong_t __user outp, compat_ulong_t __user exp,
1604	struct compat_timespec __user tsp, void __user sig)
1605	{
1606	compat_size_t sigsetsize = 0;
1607	compat_uptr_t up = 0;
1608
1609	if (sig) {
1610	if (!access_ok(VERIFY_READ, sig,
1611	sizeof(compat_uptr_t)+sizeof(compat_size_t)) \|\|
1612	__get_user(up, (compat_uptr_t __user *)sig) \|\|
1613	__get_user(sigsetsize,
1614	(compat_size_t __user *)(sig+sizeof(up))))
1615	return -EFAULT;
1616	}
1617	return do_compat_pselect(n, inp, outp, exp, tsp, compat_ptr(up),
1618	sigsetsize);
1619	}
1620
1621	asmlinkage long compat_sys_ppoll(struct pollfd __user *ufds,
1622	unsigned int nfds, struct compat_timespec __user *tsp,
1623	const compat_sigset_t __user *sigmask, compat_size_t sigsetsize)
1624	{
1625	compat_sigset_t ss32;
1626	sigset_t ksigmask, sigsaved;
1627	struct compat_timespec ts;
1628	struct timespec end_time, *to = NULL;
1629	int ret;
1630
1631	if (tsp) {
1632	if (copy_from_user(&ts, tsp, sizeof(ts)))
1633	return -EFAULT;
1634
1635	to = &end_time;
1636	if (poll_select_set_timeout(to, ts.tv_sec, ts.tv_nsec))
1637	return -EINVAL;
1638	}
1639
1640	if (sigmask) {
1641	if (sigsetsize != sizeof(compat_sigset_t))
1642	return -EINVAL;
1643	if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
1644	return -EFAULT;
1645	sigset_from_compat(&ksigmask, &ss32);
1646
1647	sigdelsetmask(&ksigmask, sigmask(SIGKILL)\|sigmask(SIGSTOP));
1648	sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
1649	}
1650
1651	ret = do_sys_poll(ufds, nfds, to);
1652
1653	/* We can restart this syscall, usually */
1654	if (ret == -EINTR) {
1655	/*
1656	* Don't restore the signal mask yet. Let do_signal() deliver
1657	* the signal on the way back to userspace, before the signal
1658	* mask is restored.
1659	*/
1660	if (sigmask) {
1661	memcpy(&current->saved_sigmask, &sigsaved,
1662	sizeof(sigsaved));
1663	set_restore_sigmask();
1664	}
1665	ret = -ERESTARTNOHAND;
1666	} else if (sigmask)
1667	sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1668
1669	ret = poll_select_copy_remaining(&end_time, tsp, 0, ret);
1670
1671	return ret;
1672	}
1673	#endif /* HAVE_SET_RESTORE_SIGMASK */
1674
1675	#ifdef CONFIG_EPOLL
1676
1677	#ifdef HAVE_SET_RESTORE_SIGMASK
1678	asmlinkage long compat_sys_epoll_pwait(int epfd,
1679	struct compat_epoll_event __user *events,
1680	int maxevents, int timeout,
1681	const compat_sigset_t __user *sigmask,
1682	compat_size_t sigsetsize)
1683	{
1684	long err;
1685	compat_sigset_t csigmask;
1686	sigset_t ksigmask, sigsaved;
1687
1688	/*
1689	* If the caller wants a certain signal mask to be set during the wait,
1690	* we apply it here.
1691	*/
1692	if (sigmask) {
1693	if (sigsetsize != sizeof(compat_sigset_t))
1694	return -EINVAL;
1695	if (copy_from_user(&csigmask, sigmask, sizeof(csigmask)))
1696	return -EFAULT;
1697	sigset_from_compat(&ksigmask, &csigmask);
1698	sigdelsetmask(&ksigmask, sigmask(SIGKILL) \| sigmask(SIGSTOP));
1699	sigprocmask(SIG_SETMASK, &ksigmask, &sigsaved);
1700	}
1701
1702	err = sys_epoll_wait(epfd, events, maxevents, timeout);
1703
1704	/*
1705	* If we changed the signal mask, we need to restore the original one.
1706	* In case we've got a signal while waiting, we do not restore the
1707	* signal mask yet, and we allow do_signal() to deliver the signal on
1708	* the way back to userspace, before the signal mask is restored.
1709	*/
1710	if (sigmask) {
1711	if (err == -EINTR) {
1712	memcpy(&current->saved_sigmask, &sigsaved,
1713	sizeof(sigsaved));
1714	set_restore_sigmask();
1715	} else
1716	sigprocmask(SIG_SETMASK, &sigsaved, NULL);
1717	}
1718
1719	return err;
1720	}
1721	#endif /* HAVE_SET_RESTORE_SIGMASK */
1722
1723	#endif /* CONFIG_EPOLL */
1724
1725	#ifdef CONFIG_SIGNALFD
1726
1727	asmlinkage long compat_sys_signalfd4(int ufd,
1728	const compat_sigset_t __user *sigmask,
1729	compat_size_t sigsetsize, int flags)
1730	{
1731	compat_sigset_t ss32;
1732	sigset_t tmp;
1733	sigset_t __user *ksigmask;
1734
1735	if (sigsetsize != sizeof(compat_sigset_t))
1736	return -EINVAL;
1737	if (copy_from_user(&ss32, sigmask, sizeof(ss32)))
1738	return -EFAULT;
1739	sigset_from_compat(&tmp, &ss32);
1740	ksigmask = compat_alloc_user_space(sizeof(sigset_t));
1741	if (copy_to_user(ksigmask, &tmp, sizeof(sigset_t)))
1742	return -EFAULT;
1743
1744	return sys_signalfd4(ufd, ksigmask, sizeof(sigset_t), flags);
1745	}
1746
1747	asmlinkage long compat_sys_signalfd(int ufd,
1748	const compat_sigset_t __user *sigmask,
1749	compat_size_t sigsetsize)
1750	{
1751	return compat_sys_signalfd4(ufd, sigmask, sigsetsize, 0);
1752	}
1753	#endif /* CONFIG_SIGNALFD */
1754
1755	#ifdef CONFIG_TIMERFD
1756
1757	asmlinkage long compat_sys_timerfd_settime(int ufd, int flags,
1758	const struct compat_itimerspec __user *utmr,
1759	struct compat_itimerspec __user *otmr)
1760	{
1761	int error;
1762	struct itimerspec t;
1763	struct itimerspec __user *ut;
1764
1765	if (get_compat_itimerspec(&t, utmr))
1766	return -EFAULT;
1767	ut = compat_alloc_user_space(2 * sizeof(struct itimerspec));
1768	if (copy_to_user(&ut[0], &t, sizeof(t)))
1769	return -EFAULT;
1770	error = sys_timerfd_settime(ufd, flags, &ut[0], &ut[1]);
1771	if (!error && otmr)
1772	error = (copy_from_user(&t, &ut[1], sizeof(struct itimerspec)) \|\|
1773	put_compat_itimerspec(otmr, &t)) ? -EFAULT: 0;
1774
1775	return error;
1776	}
1777
1778	asmlinkage long compat_sys_timerfd_gettime(int ufd,
1779	struct compat_itimerspec __user *otmr)
1780	{
1781	int error;
1782	struct itimerspec t;
1783	struct itimerspec __user *ut;
1784
1785	ut = compat_alloc_user_space(sizeof(struct itimerspec));
1786	error = sys_timerfd_gettime(ufd, ut);
1787	if (!error)
1788	error = (copy_from_user(&t, ut, sizeof(struct itimerspec)) \|\|
1789	put_compat_itimerspec(otmr, &t)) ? -EFAULT: 0;
1790
1791	return error;
1792	}
1793
1794	#endif /* CONFIG_TIMERFD */
1795
1796	#ifdef CONFIG_FHANDLE
1797	/*
1798	* Exactly like fs/open.c:sys_open_by_handle_at(), except that it
1799	* doesn't set the O_LARGEFILE flag.
1800	*/
1801	asmlinkage long
1802	compat_sys_open_by_handle_at(int mountdirfd,
1803	struct file_handle __user *handle, int flags)
1804	{
1805	return do_handle_open(mountdirfd, handle, flags);
1806	}
1807	#endif
1808

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/fs/compat.c

interactive