2 * linux/kernel/compat.c
4 * Kernel compatibililty routines for e.g. 32 bit syscall support
7 * Copyright (C) 2002-2003 Stephen Rothwell, IBM Corporation
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
14 #include <linux/linkage.h>
15 #include <linux/compat.h>
16 #include <linux/errno.h>
17 #include <linux/time.h>
18 #include <linux/signal.h>
19 #include <linux/sched.h> /* for MAX_SCHEDULE_TIMEOUT */
20 #include <linux/futex.h> /* for FUTEX_WAIT */
21 #include <linux/unistd.h>
23 #include <asm/uaccess.h>
25 int get_compat_timespec(struct timespec
*ts
, struct compat_timespec
*cts
)
27 return (verify_area(VERIFY_READ
, cts
, sizeof(*cts
)) ||
28 __get_user(ts
->tv_sec
, &cts
->tv_sec
) ||
29 __get_user(ts
->tv_nsec
, &cts
->tv_nsec
)) ? -EFAULT
: 0;
32 int put_compat_timespec(struct timespec
*ts
, struct compat_timespec
*cts
)
34 return (verify_area(VERIFY_WRITE
, cts
, sizeof(*cts
)) ||
35 __put_user(ts
->tv_sec
, &cts
->tv_sec
) ||
36 __put_user(ts
->tv_nsec
, &cts
->tv_nsec
)) ? -EFAULT
: 0;
39 static long compat_nanosleep_restart(struct restart_block
*restart
)
41 unsigned long expire
= restart
->arg0
, now
= jiffies
;
42 struct compat_timespec
*rmtp
;
44 /* Did it expire while we handled signals? */
45 if (!time_after(expire
, now
))
48 current
->state
= TASK_INTERRUPTIBLE
;
49 expire
= schedule_timeout(expire
- now
);
53 rmtp
= (struct compat_timespec
*)restart
->arg1
;
55 struct compat_timespec ct
;
58 jiffies_to_timespec(expire
, &t
);
60 ct
.tv_nsec
= t
.tv_nsec
;
61 if (copy_to_user(rmtp
, &ct
, sizeof(ct
)))
64 /* The 'restart' block is already filled in */
65 return -ERESTART_RESTARTBLOCK
;
68 asmlinkage
long compat_sys_nanosleep(struct compat_timespec
*rqtp
,
69 struct compat_timespec
*rmtp
)
72 struct restart_block
*restart
;
75 if (get_compat_timespec(&t
, rqtp
))
78 if ((t
.tv_nsec
>= 1000000000L) || (t
.tv_nsec
< 0) || (t
.tv_sec
< 0))
81 expire
= timespec_to_jiffies(&t
) + (t
.tv_sec
|| t
.tv_nsec
);
82 current
->state
= TASK_INTERRUPTIBLE
;
83 expire
= schedule_timeout(expire
);
88 jiffies_to_timespec(expire
, &t
);
89 if (put_compat_timespec(&t
, rmtp
))
92 restart
= ¤t_thread_info()->restart_block
;
93 restart
->fn
= compat_nanosleep_restart
;
94 restart
->arg0
= jiffies
+ expire
;
95 restart
->arg1
= (unsigned long) rmtp
;
96 return -ERESTART_RESTARTBLOCK
;
99 static inline long get_compat_itimerval(struct itimerval
*o
,
100 struct compat_itimerval
*i
)
102 return (!access_ok(VERIFY_READ
, i
, sizeof(*i
)) ||
103 (__get_user(o
->it_interval
.tv_sec
, &i
->it_interval
.tv_sec
) |
104 __get_user(o
->it_interval
.tv_usec
, &i
->it_interval
.tv_usec
) |
105 __get_user(o
->it_value
.tv_sec
, &i
->it_value
.tv_sec
) |
106 __get_user(o
->it_value
.tv_usec
, &i
->it_value
.tv_usec
)));
109 static inline long put_compat_itimerval(struct compat_itimerval
*o
,
112 return (!access_ok(VERIFY_WRITE
, o
, sizeof(*o
)) ||
113 (__put_user(i
->it_interval
.tv_sec
, &o
->it_interval
.tv_sec
) |
114 __put_user(i
->it_interval
.tv_usec
, &o
->it_interval
.tv_usec
) |
115 __put_user(i
->it_value
.tv_sec
, &o
->it_value
.tv_sec
) |
116 __put_user(i
->it_value
.tv_usec
, &o
->it_value
.tv_usec
)));
119 extern int do_getitimer(int which
, struct itimerval
*value
);
121 asmlinkage
long compat_sys_getitimer(int which
, struct compat_itimerval
*it
)
123 struct itimerval kit
;
126 error
= do_getitimer(which
, &kit
);
127 if (!error
&& put_compat_itimerval(it
, &kit
))
132 extern int do_setitimer(int which
, struct itimerval
*, struct itimerval
*);
134 asmlinkage
long compat_sys_setitimer(int which
, struct compat_itimerval
*in
,
135 struct compat_itimerval
*out
)
137 struct itimerval kin
, kout
;
141 if (get_compat_itimerval(&kin
, in
))
144 memset(&kin
, 0, sizeof(kin
));
146 error
= do_setitimer(which
, &kin
, out
? &kout
: NULL
);
149 if (put_compat_itimerval(out
, &kout
))
154 asmlinkage
long compat_sys_times(struct compat_tms
*tbuf
)
157 * In the SMP world we might just be unlucky and have one of
158 * the times increment as we use it. Since the value is an
159 * atomically safe type this is just fine. Conceptually its
160 * as if the syscall took an instant longer to occur.
163 struct compat_tms tmp
;
164 tmp
.tms_utime
= compat_jiffies_to_clock_t(current
->utime
);
165 tmp
.tms_stime
= compat_jiffies_to_clock_t(current
->stime
);
166 tmp
.tms_cutime
= compat_jiffies_to_clock_t(current
->cutime
);
167 tmp
.tms_cstime
= compat_jiffies_to_clock_t(current
->cstime
);
168 if (copy_to_user(tbuf
, &tmp
, sizeof(tmp
)))
171 return compat_jiffies_to_clock_t(jiffies
);
175 * Assumption: old_sigset_t and compat_old_sigset_t are both
176 * types that can be passed to put_user()/get_user().
179 extern asmlinkage
long sys_sigpending(old_sigset_t
*);
181 asmlinkage
long compat_sys_sigpending(compat_old_sigset_t
*set
)
185 mm_segment_t old_fs
= get_fs();
188 ret
= sys_sigpending(&s
);
191 ret
= put_user(s
, set
);
195 extern asmlinkage
long sys_sigprocmask(int, old_sigset_t
*, old_sigset_t
*);
197 asmlinkage
long compat_sys_sigprocmask(int how
, compat_old_sigset_t
*set
,
198 compat_old_sigset_t
*oset
)
204 if (set
&& get_user(s
, set
))
208 ret
= sys_sigprocmask(how
, set
? &s
: NULL
, oset
? &s
: NULL
);
211 ret
= put_user(s
, oset
);
216 asmlinkage
long compat_sys_futex(u32
*uaddr
, int op
, int val
,
217 struct compat_timespec
*utime
, u32
*uaddr2
)
220 unsigned long timeout
= MAX_SCHEDULE_TIMEOUT
;
223 if ((op
== FUTEX_WAIT
) && utime
) {
224 if (get_compat_timespec(&t
, utime
))
226 timeout
= timespec_to_jiffies(&t
) + 1;
228 if (op
== FUTEX_REQUEUE
)
229 val2
= (int) (long) utime
;
231 return do_futex((unsigned long)uaddr
, op
, val
, timeout
,
232 (unsigned long)uaddr2
, val2
);
236 asmlinkage
long sys_setrlimit(unsigned int resource
, struct rlimit
*rlim
);
238 asmlinkage
long compat_sys_setrlimit(unsigned int resource
, struct compat_rlimit
*rlim
)
242 mm_segment_t old_fs
= get_fs ();
244 if (resource
>= RLIM_NLIMITS
)
247 if (!access_ok(VERIFY_READ
, rlim
, sizeof(*rlim
)) ||
248 __get_user(r
.rlim_cur
, &rlim
->rlim_cur
) ||
249 __get_user(r
.rlim_max
, &rlim
->rlim_max
))
252 if (r
.rlim_cur
== COMPAT_RLIM_INFINITY
)
253 r
.rlim_cur
= RLIM_INFINITY
;
254 if (r
.rlim_max
== COMPAT_RLIM_INFINITY
)
255 r
.rlim_max
= RLIM_INFINITY
;
257 ret
= sys_setrlimit(resource
, &r
);
262 #ifdef COMPAT_RLIM_OLD_INFINITY
263 asmlinkage
long sys_old_getrlimit(unsigned int resource
, struct rlimit
*rlim
);
265 asmlinkage
long compat_sys_old_getrlimit(unsigned int resource
, struct compat_rlimit
*rlim
)
269 mm_segment_t old_fs
= get_fs();
272 ret
= sys_old_getrlimit(resource
, &r
);
276 if (r
.rlim_cur
> COMPAT_RLIM_OLD_INFINITY
)
277 r
.rlim_cur
= COMPAT_RLIM_INFINITY
;
278 if (r
.rlim_max
> COMPAT_RLIM_OLD_INFINITY
)
279 r
.rlim_max
= COMPAT_RLIM_INFINITY
;
281 if (!access_ok(VERIFY_WRITE
, rlim
, sizeof(*rlim
)) ||
282 __put_user(r
.rlim_cur
, &rlim
->rlim_cur
) ||
283 __put_user(r
.rlim_max
, &rlim
->rlim_max
))
290 asmlinkage
long sys_getrlimit (unsigned int resource
, struct rlimit
*rlim
);
292 asmlinkage
long compat_sys_getrlimit (unsigned int resource
, struct compat_rlimit
*rlim
)
296 mm_segment_t old_fs
= get_fs();
299 ret
= sys_getrlimit(resource
, &r
);
302 if (r
.rlim_cur
> COMPAT_RLIM_INFINITY
)
303 r
.rlim_cur
= COMPAT_RLIM_INFINITY
;
304 if (r
.rlim_max
> COMPAT_RLIM_INFINITY
)
305 r
.rlim_max
= COMPAT_RLIM_INFINITY
;
307 if (!access_ok(VERIFY_WRITE
, rlim
, sizeof(*rlim
)) ||
308 __put_user(r
.rlim_cur
, &rlim
->rlim_cur
) ||
309 __put_user(r
.rlim_max
, &rlim
->rlim_max
))
315 static long put_compat_rusage (struct compat_rusage
*ru
, struct rusage
*r
)
317 if (!access_ok(VERIFY_WRITE
, ru
, sizeof(*ru
)) ||
318 __put_user(r
->ru_utime
.tv_sec
, &ru
->ru_utime
.tv_sec
) ||
319 __put_user(r
->ru_utime
.tv_usec
, &ru
->ru_utime
.tv_usec
) ||
320 __put_user(r
->ru_stime
.tv_sec
, &ru
->ru_stime
.tv_sec
) ||
321 __put_user(r
->ru_stime
.tv_usec
, &ru
->ru_stime
.tv_usec
) ||
322 __put_user(r
->ru_maxrss
, &ru
->ru_maxrss
) ||
323 __put_user(r
->ru_ixrss
, &ru
->ru_ixrss
) ||
324 __put_user(r
->ru_idrss
, &ru
->ru_idrss
) ||
325 __put_user(r
->ru_isrss
, &ru
->ru_isrss
) ||
326 __put_user(r
->ru_minflt
, &ru
->ru_minflt
) ||
327 __put_user(r
->ru_majflt
, &ru
->ru_majflt
) ||
328 __put_user(r
->ru_nswap
, &ru
->ru_nswap
) ||
329 __put_user(r
->ru_inblock
, &ru
->ru_inblock
) ||
330 __put_user(r
->ru_oublock
, &ru
->ru_oublock
) ||
331 __put_user(r
->ru_msgsnd
, &ru
->ru_msgsnd
) ||
332 __put_user(r
->ru_msgrcv
, &ru
->ru_msgrcv
) ||
333 __put_user(r
->ru_nsignals
, &ru
->ru_nsignals
) ||
334 __put_user(r
->ru_nvcsw
, &ru
->ru_nvcsw
) ||
335 __put_user(r
->ru_nivcsw
, &ru
->ru_nivcsw
))
340 asmlinkage
long sys_getrusage(int who
, struct rusage
*ru
);
342 asmlinkage
long compat_sys_getrusage(int who
, struct compat_rusage
*ru
)
346 mm_segment_t old_fs
= get_fs();
349 ret
= sys_getrusage(who
, &r
);
352 return ret
|| put_compat_rusage(ru
, &r
);
356 compat_sys_wait4(compat_pid_t pid
, compat_uint_t
* stat_addr
, int options
,
357 struct compat_rusage
*ru
)
360 return sys_wait4(pid
, stat_addr
, options
, NULL
);
365 mm_segment_t old_fs
= get_fs();
368 ret
= sys_wait4(pid
, stat_addr
? &status
: NULL
, options
, &r
);
373 if (put_compat_rusage(ru
, &r
))
375 if (stat_addr
&& put_user(status
, stat_addr
))
382 extern asmlinkage
long sys_sched_setaffinity(pid_t pid
, unsigned int len
,
383 unsigned long *user_mask_ptr
);
385 asmlinkage
long compat_sys_sched_setaffinity(compat_pid_t pid
,
387 compat_ulong_t
*user_mask_ptr
)
389 unsigned long kernel_mask
;
393 if (get_user(kernel_mask
, user_mask_ptr
))
398 ret
= sys_sched_setaffinity(pid
,
406 extern asmlinkage
long sys_sched_getaffinity(pid_t pid
, unsigned int len
,
407 unsigned long *user_mask_ptr
);
409 asmlinkage
int compat_sys_sched_getaffinity(compat_pid_t pid
, unsigned int len
,
410 compat_ulong_t
*user_mask_ptr
)
412 unsigned long kernel_mask
;
418 ret
= sys_sched_getaffinity(pid
,
424 if (put_user(kernel_mask
, user_mask_ptr
))
426 ret
= sizeof(compat_ulong_t
);