1 /*- 2 * Copyright (c) 2014 Bjoern A. Zeeb 3 * All rights reserved. 4 * 5 * This software was developed by SRI International and the University of 6 * Cambridge Computer Laboratory under DARPA/AFRL contract FA8750-11-C-0249 7 * ("MRC2"), as part of the DARPA MRC research programme. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 28 * SUCH DAMAGE. 29 */ 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 #include "opt_compat.h" 34 35 #include <sys/param.h> 36 #include <sys/errno.h> 37 #include <sys/signal.h> 38 #include <sys/syscallsubr.h> 39 #include <sys/systm.h> 40 #include <sys/time.h> 41 #include <sys/types.h> 42 43 #ifdef COMPAT_LINUX32 44 #include <machine/../linux32/linux.h> 45 #include <machine/../linux32/linux32_proto.h> 46 #else 47 #include <machine/../linux/linux.h> 48 #include <machine/../linux/linux_proto.h> 49 #endif 50 #include <compat/linux/linux_timer.h> 51 52 static int 53 linux_convert_l_sigevent(struct l_sigevent *l_sig, struct sigevent *sig) 54 { 55 56 CP(*l_sig, *sig, sigev_notify); 57 switch (l_sig->sigev_notify) { 58 case L_SIGEV_SIGNAL: 59 if (!LINUX_SIG_VALID(l_sig->sigev_signo)) 60 return (EINVAL); 61 sig->sigev_notify = SIGEV_SIGNAL; 62 sig->sigev_signo = linux_to_bsd_signal(l_sig->sigev_signo); 63 PTRIN_CP(*l_sig, *sig, sigev_value.sival_ptr); 64 break; 65 case L_SIGEV_NONE: 66 sig->sigev_notify = SIGEV_NONE; 67 break; 68 case L_SIGEV_THREAD: 69 #if 0 70 /* Seems to not be used anywhere (anymore)? */ 71 sig->sigev_notify = SIGEV_THREAD; 72 return (ENOSYS); 73 #else 74 return (EINVAL); 75 #endif 76 case L_SIGEV_THREAD_ID: 77 if (!LINUX_SIG_VALID(l_sig->sigev_signo)) 78 return (EINVAL); 79 sig->sigev_notify = SIGEV_THREAD_ID; 80 CP2(*l_sig, *sig, _l_sigev_un._tid, sigev_notify_thread_id); 81 sig->sigev_signo = linux_to_bsd_signal(l_sig->sigev_signo); 82 PTRIN_CP(*l_sig, *sig, sigev_value.sival_ptr); 83 break; 84 default: 85 return (EINVAL); 86 } 87 return (0); 88 } 89 90 int 91 linux_timer_create(struct thread *td, struct linux_timer_create_args *uap) 92 { 93 struct l_sigevent l_ev; 94 struct sigevent ev, *evp; 95 clockid_t nwhich; 96 int error, id; 97 98 if (uap->evp == NULL) { 99 evp = NULL; 100 } else { 101 error = copyin(uap->evp, &l_ev, sizeof(l_ev)); 102 if (error != 0) 103 return (error); 104 error = linux_convert_l_sigevent(&l_ev, &ev); 105 if (error != 0) 106 return (error); 107 evp = &ev; 108 } 109 error = linux_to_native_clockid(&nwhich, uap->clock_id); 110 if (error != 0) 111 return (error); 112 error = kern_ktimer_create(td, nwhich, evp, &id, -1); 113 if (error == 0) { 114 error = copyout(&id, uap->timerid, sizeof(int)); 115 if (error != 0) 116 kern_ktimer_delete(td, id); 117 } 118 return (error); 119 } 120 121 int 122 linux_timer_settime(struct thread *td, struct linux_timer_settime_args *uap) 123 { 124 struct l_itimerspec l_val, l_oval; 125 struct itimerspec val, oval, *ovalp; 126 int flags, error; 127 128 error = copyin(uap->new, &l_val, sizeof(l_val)); 129 if (error != 0) 130 return (error); 131 error = linux_to_native_itimerspec(&val, &l_val); 132 if (error != 0) 133 return (error); 134 ovalp = uap->old != NULL ? &oval : NULL; 135 error = linux_to_native_timerflags(&flags, uap->flags); 136 if (error != 0) 137 return (error); 138 error = kern_ktimer_settime(td, uap->timerid, flags, &val, ovalp); 139 if (error == 0 && uap->old != NULL) { 140 error = native_to_linux_itimerspec(&l_val, &val); 141 if (error == 0) 142 error = copyout(&l_oval, uap->old, sizeof(l_oval)); 143 } 144 return (error); 145 } 146 147 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) 148 int 149 linux_timer_settime64(struct thread *td, struct linux_timer_settime64_args *uap) 150 { 151 struct l_itimerspec64 l_val, l_oval; 152 struct itimerspec val, oval, *ovalp; 153 int flags, error; 154 155 error = copyin(uap->new, &l_val, sizeof(l_val)); 156 if (error != 0) 157 return (error); 158 error = linux_to_native_itimerspec64(&val, &l_val); 159 if (error != 0) 160 return (error); 161 ovalp = uap->old != NULL ? &oval : NULL; 162 error = linux_to_native_timerflags(&flags, uap->flags); 163 if (error != 0) 164 return (error); 165 error = kern_ktimer_settime(td, uap->timerid, flags, &val, ovalp); 166 if (error == 0 && uap->old != NULL) { 167 error = native_to_linux_itimerspec64(&l_val, &val); 168 if (error == 0) 169 error = copyout(&l_oval, uap->old, sizeof(l_oval)); 170 } 171 return (error); 172 } 173 #endif 174 175 int 176 linux_timer_gettime(struct thread *td, struct linux_timer_gettime_args *uap) 177 { 178 struct l_itimerspec l_val; 179 struct itimerspec val; 180 int error; 181 182 error = kern_ktimer_gettime(td, uap->timerid, &val); 183 if (error == 0) 184 error = native_to_linux_itimerspec(&l_val, &val); 185 if (error == 0) 186 error = copyout(&l_val, uap->setting, sizeof(l_val)); 187 return (error); 188 } 189 190 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) 191 int 192 linux_timer_gettime64(struct thread *td, struct linux_timer_gettime64_args *uap) 193 { 194 struct l_itimerspec64 l_val; 195 struct itimerspec val; 196 int error; 197 198 error = kern_ktimer_gettime(td, uap->timerid, &val); 199 if (error == 0) 200 error = native_to_linux_itimerspec64(&l_val, &val); 201 if (error == 0) 202 error = copyout(&l_val, uap->setting, sizeof(l_val)); 203 return (error); 204 } 205 #endif 206 207 int 208 linux_timer_getoverrun(struct thread *td, struct linux_timer_getoverrun_args *uap) 209 { 210 211 return (kern_ktimer_getoverrun(td, uap->timerid)); 212 } 213 214 int 215 linux_timer_delete(struct thread *td, struct linux_timer_delete_args *uap) 216 { 217 218 return (kern_ktimer_delete(td, uap->timerid)); 219 } 220