sys/compat/linux32/common/linux32_time.c

   1 /*      $NetBSD: linux32_time.c,v 1.17 2008/03/27 19:06:51 ad Exp $ */
   2
   3 /*-
   4  * Copyright (c) 2006 Emmanuel Dreyfus, all rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. All advertising materials mentioning features or use of this software
  15  *    must display the following acknowledgement:
  16  *      This product includes software developed by Emmanuel Dreyfus
  17  * 4. The name of the author may not be used to endorse or promote
  18  *    products derived from this software without specific prior written
  19  *    permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE THE AUTHOR AND CONTRIBUTORS ``AS IS''
  22  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  23  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  24  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS
  25  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31  * POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 #include <sys/cdefs.h>
  35
  36 __KERNEL_RCSID(0, "$NetBSD: linux32_time.c,v 1.17 2008/03/27 19:06:51 ad Exp $");
  37
  38 #include <sys/types.h>
  39 #include <sys/param.h>
  40 #include <sys/fstypes.h>
  41 #include <sys/signal.h>
  42 #include <sys/dirent.h>
  43 #include <sys/kauth.h>
  44 #include <sys/kernel.h>
  45 #include <sys/fcntl.h>
  46 #include <sys/namei.h>
  47 #include <sys/select.h>
  48 #include <sys/proc.h>
  49 #include <sys/resourcevar.h>
  50 #include <sys/ucred.h>
  51 #include <sys/swap.h>
  52 #include <sys/vfs_syscalls.h>
  53 #include <sys/timetc.h>
  54
  55 #include <machine/types.h>
  56
  57 #include <sys/syscallargs.h>
  58
  59 #include <compat/netbsd32/netbsd32.h>
  60 #include <compat/netbsd32/netbsd32_conv.h>
  61 #include <compat/netbsd32/netbsd32_syscallargs.h>
  62
  63 #include <compat/linux/common/linux_types.h>
  64 #include <compat/linux/common/linux_signal.h>
  65 #include <compat/linux/common/linux_machdep.h>
  66 #include <compat/linux/common/linux_misc.h>
  67 #include <compat/linux/common/linux_oldolduname.h>
  68 #include <compat/linux/common/linux_sched.h>
  69 #include <compat/linux/linux_syscallargs.h>
  70
  71 #include <compat/linux32/common/linux32_types.h>
  72 #include <compat/linux32/common/linux32_signal.h>
  73 #include <compat/linux32/common/linux32_machdep.h>
  74 #include <compat/linux32/common/linux32_sysctl.h>
  75 #include <compat/linux32/common/linux32_socketcall.h>
  76 #include <compat/linux32/linux32_syscallargs.h>
  77
  78 extern struct timezone linux_sys_tz;
  79
  80 static __inline void
  81 native_to_linux32_timespec(struct linux32_timespec *, struct timespec *);
  82 static __inline void
  83 linux32_to_native_timespec(struct timespec *, struct linux32_timespec *);
  84
  85 int
  86 linux32_sys_gettimeofday(struct lwp *l, const struct linux32_sys_gettimeofday_args *uap, register_t *retval)
  87 {
  88         /* {
  89                 syscallarg(netbsd32_timevalp_t) tp;
  90                 syscallarg(netbsd32_timezonep_t) tzp;
  91         } */
  92         struct timeval tv;
  93         struct netbsd32_timeval tv32;
  94         int error;
  95
  96         if (SCARG_P32(uap, tp) != NULL) {
  97                 microtime(&tv);
  98                 netbsd32_from_timeval(&tv, &tv32);
  99                 if ((error = copyout(&tv32, SCARG_P32(uap, tp),
 100                     sizeof(tv32))) != 0)
 101                         return error;
 102         }
 103
 104         /* timezone size does not change */
 105         if (SCARG_P32(uap, tzp) != NULL) {
 106                 if ((error = copyout(&linux_sys_tz, SCARG_P32(uap, tzp),
 107                     sizeof(linux_sys_tz))) != 0)
 108                         return error;
 109         }
 110
 111         return 0;
 112 }
 113
 114 int
 115 linux32_sys_settimeofday(struct lwp *l, const struct linux32_sys_settimeofday_args *uap, register_t *retval)
 116 {
 117         /* {
 118                 syscallarg(netbsd32_timevalp_t) tp;
 119                 syscallarg(netbsd32_timezonep_t) tzp;
 120         } */
 121         struct linux_sys_settimeofday_args ua;
 122
 123         NETBSD32TOP_UAP(tp, struct timeval);
 124         NETBSD32TOP_UAP(tzp, struct timezone);
 125
 126         return linux_sys_settimeofday(l, &ua, retval);
 127 }
 128
 129 int
 130 linux32_sys_time(struct lwp *l, const struct linux32_sys_time_args *uap, register_t *retval)
 131 {
 132         /* {
 133                 syscallcarg(linux32_timep_t) t;
 134         } */
 135         struct timeval atv;
 136         linux32_time_t tt;
 137         int error;
 138
 139         microtime(&atv);
 140
 141         tt = (linux32_time_t)atv.tv_sec;
 142
 143         if (SCARG_P32(uap, t) && (error = copyout(&tt,
 144             SCARG_P32(uap, t), sizeof(tt))))
 145                 return error;
 146
 147         retval[0] = tt;
 148
 149         return 0;
 150 }
 151
 152
 153 static inline linux32_clock_t
 154 timeval_to_clock_t(struct timeval *tv)
 155 {
 156         return tv->tv_sec * hz + tv->tv_usec / (1000000 / hz);
 157 }
 158
 159 int
 160 linux32_sys_times(struct lwp *l, const struct linux32_sys_times_args *uap, register_t *retval)
 161 {
 162         /* {
 163                 syscallarg(linux32_tmsp_t) tms;
 164         } */
 165         struct linux32_tms ltms32;
 166
 167         struct timeval           t;
 168         struct rusage            ru;
 169         struct proc              *p = l->l_proc;
 170
 171         mutex_enter(&p->p_smutex);
 172         ru = p->p_stats->p_ru;
 173         calcru(p, &ru.ru_utime, &ru.ru_stime, NULL, NULL);
 174         rulwps(p, &ru);
 175         mutex_exit(&p->p_smutex);
 176
 177         ltms32.ltms32_utime = timeval_to_clock_t(&ru.ru_utime);
 178         ltms32.ltms32_stime = timeval_to_clock_t(&ru.ru_stime);
 179
 180         ru = p->p_stats->p_cru;
 181         ltms32.ltms32_cutime = timeval_to_clock_t(&ru.ru_utime);
 182         ltms32.ltms32_cstime = timeval_to_clock_t(&ru.ru_stime);
 183
 184         microtime(&t);
 185         *retval = timeval_to_clock_t(&t);
 186
 187         return copyout(&ltms32, SCARG_P32(uap, tms), sizeof(ltms32));
 188 }
 189
 190 int
 191 linux32_sys_stime(struct lwp *l, const struct linux32_sys_stime_args *uap, register_t *retval)
 192 {
 193         /* {
 194                 syscallarg(linux32_timep_t) t;
 195         } */
 196         struct timespec ts;
 197         linux32_time_t tt32;
 198         int error;
 199
 200         if ((error = copyin(&tt32, SCARG_P32(uap, t), sizeof tt32)) != 0)
 201                 return error;
 202
 203         ts.tv_sec = (long)tt32;
 204         ts.tv_nsec = 0;
 205
 206         return settime(l->l_proc, &ts);
 207 }
 208
 209 int
 210 linux32_sys_utime(struct lwp *l, const struct linux32_sys_utime_args *uap, register_t *retval)
 211 {
 212         /* {
 213                 syscallarg(const netbsd32_charp) path;
 214                 syscallarg(linux32_utimbufp_t) times;
 215         } */
 216         struct timeval tv[2], *tvp;
 217         struct linux32_utimbuf lut;
 218         int error;
 219
 220         if (SCARG_P32(uap, times) != NULL) {
 221                 if ((error = copyin(SCARG_P32(uap, times), &lut, sizeof lut)))
 222                         return error;
 223
 224                 tv[0].tv_sec = (long)lut.l_actime;
 225                 tv[0].tv_usec = 0;
 226                 tv[1].tv_sec = (long)lut.l_modtime;
 227                 tv[1].tv_usec = 0;
 228                 tvp = tv;
 229         } else {
 230                 tvp = NULL;
 231         }
 232
 233         return do_sys_utimes(l, NULL, SCARG_P32(uap, path), FOLLOW,
 234                             tvp, UIO_SYSSPACE);
 235 }
 236
 237 static __inline void
 238 native_to_linux32_timespec(struct linux32_timespec *ltp, struct timespec *ntp)
 239 {
 240         ltp->tv_sec = ntp->tv_sec;
 241         ltp->tv_nsec = ntp->tv_nsec;
 242 }
 243
 244 static __inline void
 245 linux32_to_native_timespec(struct timespec *ntp, struct linux32_timespec *ltp)
 246 {
 247         ntp->tv_sec = ltp->tv_sec;
 248         ntp->tv_nsec = ltp->tv_nsec;
 249 }
 250
 251 int
 252 linux32_sys_clock_settime(struct lwp *l,
 253     const struct linux32_sys_clock_settime_args *uap, register_t *retval)
 254 {
 255         /* {
 256                 syscallarg(clockid_t) which;
 257                 syscallarg(linux32_timespecp_t) tp;
 258         } */
 259         int error;
 260         struct timespec ts;
 261         struct linux32_timespec lts;
 262
 263         switch (SCARG(uap, which)) {
 264         case LINUX_CLOCK_REALTIME:
 265                 break;
 266         default:
 267                 return EINVAL;
 268         }
 269
 270         if ((error = copyin(SCARG_P32(uap, tp), &lts, sizeof lts)))
 271                 return error;
 272
 273         linux32_to_native_timespec(&ts, &lts);
 274         return settime(l->l_proc, &ts);
 275 }
 276
 277 int
 278 linux32_sys_clock_gettime(struct lwp *l,
 279     const struct linux32_sys_clock_gettime_args *uap, register_t *retval)
 280 {
 281         /* {
 282                 syscallarg(clockid_t) which;
 283                 syscallarg(linux32_timespecp_t) tp;
 284         } */
 285         struct timespec ts;
 286         struct linux32_timespec lts;
 287
 288         switch (SCARG(uap, which)) {
 289         case LINUX_CLOCK_REALTIME:
 290                 nanotime(&ts);
 291                 break;
 292         case LINUX_CLOCK_MONOTONIC:
 293                 nanouptime(&ts);
 294                 break;
 295         default:
 296                 return EINVAL;
 297         }
 298
 299         native_to_linux32_timespec(&lts, &ts);
 300         return copyout(&lts, SCARG_P32(uap, tp), sizeof lts);
 301 }
 302
 303 int
 304 linux32_sys_clock_getres(struct lwp *l,
 305     const struct linux32_sys_clock_getres_args *uap, register_t *retval)
 306 {
 307         /* {
 308                 syscallarg(clockid_t) which;
 309                 syscallarg(linux32_timespecp_t) tp;
 310         } */
 311         int error;
 312         clockid_t id;
 313         struct timespec ts;
 314         struct linux32_timespec lts;
 315
 316         error = linux_to_native_clockid(&id, SCARG(uap, which));
 317         if (error != 0 || SCARG_P32(uap, tp) == NULL)
 318                 return error;
 319
 320         ts.tv_sec = 0;
 321         ts.tv_nsec = 1000000000 / tc_getfrequency();
 322         native_to_linux32_timespec(&lts, &ts);
 323         return copyout(&lts, SCARG_P32(uap, tp), sizeof lts);
 324
 325         return 0;
 326 }