diff --git a/sys/compat/linux/linux_time.h b/sys/compat/linux/linux_time.h index d99684db1cbf..bb23105f4f23 100644 --- a/sys/compat/linux/linux_time.h +++ b/sys/compat/linux/linux_time.h @@ -1,142 +1,143 @@ /*- * Copyright (c) 2014 Bjoern A. Zeeb * All rights reserved. * * This software was developed by SRI International and the University of * Cambridge Computer Laboratory under DARPA/AFRL contract FA8750-11-C-0249 * ("MRC2"), as part of the DARPA MRC research programme. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef _LINUX_TIME_H #define _LINUX_TIME_H #ifndef __LINUX_ARCH_SIGEV_PREAMBLE_SIZE #define __LINUX_ARCH_SIGEV_PREAMBLE_SIZE \ (sizeof(l_int) * 2 + sizeof(l_sigval_t)) #endif #define LINUX_SIGEV_MAX_SIZE 64 #define LINUX_SIGEV_PAD_SIZE \ ((LINUX_SIGEV_MAX_SIZE - __LINUX_ARCH_SIGEV_PREAMBLE_SIZE) / \ sizeof(l_int)) #define LINUX_CLOCK_REALTIME 0 #define LINUX_CLOCK_MONOTONIC 1 #define LINUX_CLOCK_PROCESS_CPUTIME_ID 2 #define LINUX_CLOCK_THREAD_CPUTIME_ID 3 #define LINUX_CLOCK_MONOTONIC_RAW 4 #define LINUX_CLOCK_REALTIME_COARSE 5 #define LINUX_CLOCK_MONOTONIC_COARSE 6 #define LINUX_CLOCK_BOOTTIME 7 #define LINUX_CLOCK_REALTIME_ALARM 8 #define LINUX_CLOCK_BOOTTIME_ALARM 9 #define LINUX_CLOCK_SGI_CYCLE 10 #define LINUX_CLOCK_TAI 11 #define LINUX_CPUCLOCK_PERTHREAD_MASK 4 #define LINUX_CPUCLOCK_MASK 3 #define LINUX_CPUCLOCK_WHICH(clock) \ ((clock) & (clockid_t) LINUX_CPUCLOCK_MASK) #define LINUX_CPUCLOCK_PROF 0 #define LINUX_CPUCLOCK_VIRT 1 #define LINUX_CPUCLOCK_SCHED 2 #define LINUX_CPUCLOCK_MAX 3 #define LINUX_CLOCKFD LINUX_CPUCLOCK_MAX #define LINUX_CLOCKFD_MASK \ (LINUX_CPUCLOCK_PERTHREAD_MASK|LINUX_CPUCLOCK_MASK) #define LINUX_CPUCLOCK_ID(clock) ((pid_t) ~((clock) >> 3)) #define LINUX_CPUCLOCK_PERTHREAD(clock) \ (((clock) & (clockid_t) LINUX_CPUCLOCK_PERTHREAD_MASK) != 0) #define LINUX_TIMER_ABSTIME 0x01 #define L_SIGEV_SIGNAL 0 #define L_SIGEV_NONE 1 #define L_SIGEV_THREAD 2 #define L_SIGEV_THREAD_ID 4 struct l_sigevent { l_sigval_t sigev_value; l_int sigev_signo; l_int sigev_notify; union { l_int _pad[LINUX_SIGEV_PAD_SIZE]; l_int _tid; struct { l_uintptr_t _function; l_uintptr_t _attribute; } _l_sigev_thread; } _l_sigev_un; } #if defined(__amd64__) && defined(COMPAT_LINUX32) __packed #endif ; struct l_itimerspec { struct l_timespec it_interval; struct l_timespec it_value; }; #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) struct l_itimerspec64 { struct l_timespec64 it_interval; struct l_timespec64 it_value; }; #endif int native_to_linux_timespec(struct l_timespec *, struct timespec *); int linux_to_native_timespec(struct timespec *, struct l_timespec *); int linux_put_timespec(struct timespec *, struct l_timespec *); int linux_get_timespec(struct timespec *, const struct l_timespec *); #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) int native_to_linux_timespec64(struct l_timespec64 *, struct timespec *); int linux_to_native_timespec64(struct timespec *, struct l_timespec64 *); int linux_put_timespec64(struct timespec *, struct l_timespec64 *); int linux_get_timespec64(struct timespec *, const struct l_timespec64 *); #endif int linux_to_native_clockid(clockid_t *, clockid_t); int native_to_linux_itimerspec(struct l_itimerspec *, struct itimerspec *); int linux_to_native_itimerspec(struct itimerspec *, struct l_itimerspec *); #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) int native_to_linux_itimerspec64(struct l_itimerspec64 *, struct itimerspec *); int linux_to_native_itimerspec64(struct itimerspec *, struct l_itimerspec64 *); #endif +int linux_convert_l_sigevent(const struct l_sigevent *l_sig, struct sigevent *sig); int linux_to_native_timerflags(int *, int); #endif /* _LINUX_TIME_H */ diff --git a/sys/compat/linux/linux_timer.c b/sys/compat/linux/linux_timer.c index 2188006ec38f..ed9133359302 100644 --- a/sys/compat/linux/linux_timer.c +++ b/sys/compat/linux/linux_timer.c @@ -1,213 +1,213 @@ /*- * Copyright (c) 2014 Bjoern A. Zeeb * All rights reserved. * * This software was developed by SRI International and the University of * Cambridge Computer Laboratory under DARPA/AFRL contract FA8750-11-C-0249 * ("MRC2"), as part of the DARPA MRC research programme. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include #include #include #include #include #ifdef COMPAT_LINUX32 #include #include #else #include #include #endif #include -static int -linux_convert_l_sigevent(struct l_sigevent *l_sig, struct sigevent *sig) +int +linux_convert_l_sigevent(const struct l_sigevent *l_sig, struct sigevent *sig) { CP(*l_sig, *sig, sigev_notify); switch (l_sig->sigev_notify) { case L_SIGEV_SIGNAL: if (!LINUX_SIG_VALID(l_sig->sigev_signo)) return (EINVAL); sig->sigev_notify = SIGEV_SIGNAL; sig->sigev_signo = linux_to_bsd_signal(l_sig->sigev_signo); PTRIN_CP(*l_sig, *sig, sigev_value.sival_ptr); break; case L_SIGEV_NONE: sig->sigev_notify = SIGEV_NONE; break; case L_SIGEV_THREAD: #if 0 /* Seems to not be used anywhere (anymore)? */ sig->sigev_notify = SIGEV_THREAD; return (ENOSYS); #else return (EINVAL); #endif case L_SIGEV_THREAD_ID: if (!LINUX_SIG_VALID(l_sig->sigev_signo)) return (EINVAL); sig->sigev_notify = SIGEV_THREAD_ID; CP2(*l_sig, *sig, _l_sigev_un._tid, sigev_notify_thread_id); sig->sigev_signo = linux_to_bsd_signal(l_sig->sigev_signo); PTRIN_CP(*l_sig, *sig, sigev_value.sival_ptr); break; default: return (EINVAL); } return (0); } int linux_timer_create(struct thread *td, struct linux_timer_create_args *uap) { struct l_sigevent l_ev; struct sigevent ev, *evp; clockid_t nwhich; int error, id; if (uap->evp == NULL) { evp = NULL; } else { error = copyin(uap->evp, &l_ev, sizeof(l_ev)); if (error != 0) return (error); error = linux_convert_l_sigevent(&l_ev, &ev); if (error != 0) return (error); evp = &ev; } error = linux_to_native_clockid(&nwhich, uap->clock_id); if (error != 0) return (error); error = kern_ktimer_create(td, nwhich, evp, &id, -1); if (error == 0) { error = copyout(&id, uap->timerid, sizeof(int)); if (error != 0) kern_ktimer_delete(td, id); } return (error); } int linux_timer_settime(struct thread *td, struct linux_timer_settime_args *uap) { struct l_itimerspec l_val, l_oval; struct itimerspec val, oval, *ovalp; int flags, error; error = copyin(uap->new, &l_val, sizeof(l_val)); if (error != 0) return (error); error = linux_to_native_itimerspec(&val, &l_val); if (error != 0) return (error); ovalp = uap->old != NULL ? &oval : NULL; error = linux_to_native_timerflags(&flags, uap->flags); if (error != 0) return (error); error = kern_ktimer_settime(td, uap->timerid, flags, &val, ovalp); if (error == 0 && uap->old != NULL) { error = native_to_linux_itimerspec(&l_val, &val); if (error == 0) error = copyout(&l_oval, uap->old, sizeof(l_oval)); } return (error); } #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) int linux_timer_settime64(struct thread *td, struct linux_timer_settime64_args *uap) { struct l_itimerspec64 l_val, l_oval; struct itimerspec val, oval, *ovalp; int flags, error; error = copyin(uap->new, &l_val, sizeof(l_val)); if (error != 0) return (error); error = linux_to_native_itimerspec64(&val, &l_val); if (error != 0) return (error); ovalp = uap->old != NULL ? &oval : NULL; error = linux_to_native_timerflags(&flags, uap->flags); if (error != 0) return (error); error = kern_ktimer_settime(td, uap->timerid, flags, &val, ovalp); if (error == 0 && uap->old != NULL) { error = native_to_linux_itimerspec64(&l_val, &val); if (error == 0) error = copyout(&l_oval, uap->old, sizeof(l_oval)); } return (error); } #endif int linux_timer_gettime(struct thread *td, struct linux_timer_gettime_args *uap) { struct l_itimerspec l_val; struct itimerspec val; int error; error = kern_ktimer_gettime(td, uap->timerid, &val); if (error == 0) error = native_to_linux_itimerspec(&l_val, &val); if (error == 0) error = copyout(&l_val, uap->setting, sizeof(l_val)); return (error); } #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) int linux_timer_gettime64(struct thread *td, struct linux_timer_gettime64_args *uap) { struct l_itimerspec64 l_val; struct itimerspec val; int error; error = kern_ktimer_gettime(td, uap->timerid, &val); if (error == 0) error = native_to_linux_itimerspec64(&l_val, &val); if (error == 0) error = copyout(&l_val, uap->setting, sizeof(l_val)); return (error); } #endif int linux_timer_getoverrun(struct thread *td, struct linux_timer_getoverrun_args *uap) { return (kern_ktimer_getoverrun(td, uap->timerid)); } int linux_timer_delete(struct thread *td, struct linux_timer_delete_args *uap) { return (kern_ktimer_delete(td, uap->timerid)); }