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 31 #include <sys/cdefs.h> 32 #include <sys/param.h> 33 #include <sys/proc.h> 34 #include <sys/signal.h> 35 #include <sys/syscallsubr.h> 36 #include <sys/time.h> 37 38 #ifdef COMPAT_LINUX32 39 #include <machine/../linux32/linux.h> 40 #include <machine/../linux32/linux32_proto.h> 41 #else 42 #include <machine/../linux/linux.h> 43 #include <machine/../linux/linux_proto.h> 44 #endif 45 #include <compat/linux/linux_time.h> 46 47 static int 48 linux_convert_l_sigevent(struct l_sigevent *l_sig, struct sigevent *sig) 49 { 50 51 CP(*l_sig, *sig, sigev_notify); 52 switch (l_sig->sigev_notify) { 53 case L_SIGEV_SIGNAL: 54 if (!LINUX_SIG_VALID(l_sig->sigev_signo)) 55 return (EINVAL); 56 sig->sigev_notify = SIGEV_SIGNAL; 57 sig->sigev_signo = linux_to_bsd_signal(l_sig->sigev_signo); 58 PTRIN_CP(*l_sig, *sig, sigev_value.sival_ptr); 59 break; 60 case L_SIGEV_NONE: 61 sig->sigev_notify = SIGEV_NONE; 62 break; 63 case L_SIGEV_THREAD: 64 #if 0 65 /* Seems to not be used anywhere (anymore)? */ 66 sig->sigev_notify = SIGEV_THREAD; 67 return (ENOSYS); 68 #else 69 return (EINVAL); 70 #endif 71 case L_SIGEV_THREAD_ID: 72 if (!LINUX_SIG_VALID(l_sig->sigev_signo)) 73 return (EINVAL); 74 sig->sigev_notify = SIGEV_THREAD_ID; 75 CP2(*l_sig, *sig, _l_sigev_un._tid, sigev_notify_thread_id); 76 sig->sigev_signo = linux_to_bsd_signal(l_sig->sigev_signo); 77 PTRIN_CP(*l_sig, *sig, sigev_value.sival_ptr); 78 break; 79 default: 80 return (EINVAL); 81 } 82 return (0); 83 } 84 85 int 86 linux_timer_create(struct thread *td, struct linux_timer_create_args *uap) 87 { 88 struct l_sigevent l_ev; 89 struct sigevent ev, *evp; 90 clockid_t nwhich; 91 int error, id; 92 93 if (uap->evp == NULL) { 94 evp = NULL; 95 } else { 96 error = copyin(uap->evp, &l_ev, sizeof(l_ev)); 97 if (error != 0) 98 return (error); 99 error = linux_convert_l_sigevent(&l_ev, &ev); 100 if (error != 0) 101 return (error); 102 evp = &ev; 103 } 104 error = linux_to_native_clockid(&nwhich, uap->clock_id); 105 if (error != 0) 106 return (error); 107 error = kern_ktimer_create(td, nwhich, evp, &id, -1); 108 if (error == 0) { 109 error = copyout(&id, uap->timerid, sizeof(int)); 110 if (error != 0) 111 kern_ktimer_delete(td, id); 112 } 113 return (error); 114 } 115 116 int 117 linux_timer_settime(struct thread *td, struct linux_timer_settime_args *uap) 118 { 119 struct l_itimerspec l_val, l_oval; 120 struct itimerspec val, oval, *ovalp; 121 int flags, error; 122 123 error = copyin(uap->new, &l_val, sizeof(l_val)); 124 if (error != 0) 125 return (error); 126 error = linux_to_native_itimerspec(&val, &l_val); 127 if (error != 0) 128 return (error); 129 ovalp = uap->old != NULL ? &oval : NULL; 130 error = linux_to_native_timerflags(&flags, uap->flags); 131 if (error != 0) 132 return (error); 133 error = kern_ktimer_settime(td, uap->timerid, flags, &val, ovalp); 134 if (error == 0 && uap->old != NULL) { 135 error = native_to_linux_itimerspec(&l_val, &val); 136 if (error == 0) 137 error = copyout(&l_oval, uap->old, sizeof(l_oval)); 138 } 139 return (error); 140 } 141 142 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) 143 int 144 linux_timer_settime64(struct thread *td, struct linux_timer_settime64_args *uap) 145 { 146 struct l_itimerspec64 l_val, l_oval; 147 struct itimerspec val, oval, *ovalp; 148 int flags, error; 149 150 error = copyin(uap->new, &l_val, sizeof(l_val)); 151 if (error != 0) 152 return (error); 153 error = linux_to_native_itimerspec64(&val, &l_val); 154 if (error != 0) 155 return (error); 156 ovalp = uap->old != NULL ? &oval : NULL; 157 error = linux_to_native_timerflags(&flags, uap->flags); 158 if (error != 0) 159 return (error); 160 error = kern_ktimer_settime(td, uap->timerid, flags, &val, ovalp); 161 if (error == 0 && uap->old != NULL) { 162 error = native_to_linux_itimerspec64(&l_val, &val); 163 if (error == 0) 164 error = copyout(&l_oval, uap->old, sizeof(l_oval)); 165 } 166 return (error); 167 } 168 #endif 169 170 int 171 linux_timer_gettime(struct thread *td, struct linux_timer_gettime_args *uap) 172 { 173 struct l_itimerspec l_val; 174 struct itimerspec val; 175 int error; 176 177 error = kern_ktimer_gettime(td, uap->timerid, &val); 178 if (error == 0) 179 error = native_to_linux_itimerspec(&l_val, &val); 180 if (error == 0) 181 error = copyout(&l_val, uap->setting, sizeof(l_val)); 182 return (error); 183 } 184 185 #if defined(__i386__) || (defined(__amd64__) && defined(COMPAT_LINUX32)) 186 int 187 linux_timer_gettime64(struct thread *td, struct linux_timer_gettime64_args *uap) 188 { 189 struct l_itimerspec64 l_val; 190 struct itimerspec val; 191 int error; 192 193 error = kern_ktimer_gettime(td, uap->timerid, &val); 194 if (error == 0) 195 error = native_to_linux_itimerspec64(&l_val, &val); 196 if (error == 0) 197 error = copyout(&l_val, uap->setting, sizeof(l_val)); 198 return (error); 199 } 200 #endif 201 202 int 203 linux_timer_getoverrun(struct thread *td, struct linux_timer_getoverrun_args *uap) 204 { 205 206 return (kern_ktimer_getoverrun(td, uap->timerid)); 207 } 208 209 int 210 linux_timer_delete(struct thread *td, struct linux_timer_delete_args *uap) 211 { 212 213 return (kern_ktimer_delete(td, uap->timerid)); 214 } 215