sys/compat/linux/linux_time.c

   1 /*      $NetBSD: linux_time.c,v 1.14 2006/05/14 03:40:54 christos Exp $ */
   2
   3 /*-
   4  * Copyright (c) 2001 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Emmanuel Dreyfus.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34 #if 0
  35 __KERNEL_RCSID(0, "$NetBSD: linux_time.c,v 1.14 2006/05/14 03:40:54 christos Exp $");
  36 #endif
  37
  38 #include "opt_compat.h"
  39
  40 #include <sys/param.h>
  41 #include <sys/kernel.h>
  42 #include <sys/lock.h>
  43 #include <sys/ucred.h>
  44 #include <sys/limits.h>
  45 #include <sys/mount.h>
  46 #include <sys/mutex.h>
  47 #include <sys/resourcevar.h>
  48 #include <sys/sdt.h>
  49 #include <sys/signal.h>
  50 #include <sys/stdint.h>
  51 #include <sys/syscallsubr.h>
  52 #include <sys/sysproto.h>
  53 #include <sys/time.h>
  54 #include <sys/systm.h>
  55 #include <sys/proc.h>
  56
  57 #ifdef COMPAT_LINUX32
  58 #include <machine/../linux32/linux.h>
  59 #include <machine/../linux32/linux32_proto.h>
  60 #else
  61 #include <machine/../linux/linux.h>
  62 #include <machine/../linux/linux_proto.h>
  63 #endif
  64
  65 #include <compat/linux/linux_dtrace.h>
  66 #include <compat/linux/linux_timer.h>
  67
  68 /* DTrace init */
  69 LIN_SDT_PROVIDER_DECLARE(LINUX_DTRACE);
  70
  71 /**
  72  * DTrace probes in this module.
  73  */
  74 LIN_SDT_PROBE_DEFINE2(time, native_to_linux_timespec, entry,
  75     "struct l_timespec *", "struct timespec *");
  76 LIN_SDT_PROBE_DEFINE0(time, native_to_linux_timespec, return);
  77 LIN_SDT_PROBE_DEFINE2(time, linux_to_native_timespec, entry,
  78     "struct timespec *", "struct l_timespec *");
  79 LIN_SDT_PROBE_DEFINE1(time, linux_to_native_timespec, return, "int");
  80 LIN_SDT_PROBE_DEFINE2(time, linux_to_native_clockid, entry, "clockid_t *",
  81     "clockid_t");
  82 LIN_SDT_PROBE_DEFINE1(time, linux_to_native_clockid, unsupported_clockid,
  83     "clockid_t");
  84 LIN_SDT_PROBE_DEFINE1(time, linux_to_native_clockid, unknown_clockid,
  85     "clockid_t");
  86 LIN_SDT_PROBE_DEFINE1(time, linux_to_native_clockid, return, "int");
  87 LIN_SDT_PROBE_DEFINE2(time, linux_clock_gettime, entry, "clockid_t",
  88     "struct l_timespec *");
  89 LIN_SDT_PROBE_DEFINE1(time, linux_clock_gettime, conversion_error, "int");
  90 LIN_SDT_PROBE_DEFINE1(time, linux_clock_gettime, gettime_error, "int");
  91 LIN_SDT_PROBE_DEFINE1(time, linux_clock_gettime, copyout_error, "int");
  92 LIN_SDT_PROBE_DEFINE1(time, linux_clock_gettime, return, "int");
  93 LIN_SDT_PROBE_DEFINE2(time, linux_clock_settime, entry, "clockid_t",
  94     "struct l_timespec *");
  95 LIN_SDT_PROBE_DEFINE1(time, linux_clock_settime, conversion_error, "int");
  96 LIN_SDT_PROBE_DEFINE1(time, linux_clock_settime, settime_error, "int");
  97 LIN_SDT_PROBE_DEFINE1(time, linux_clock_settime, copyin_error, "int");
  98 LIN_SDT_PROBE_DEFINE1(time, linux_clock_settime, return, "int");
  99 LIN_SDT_PROBE_DEFINE2(time, linux_clock_getres, entry, "clockid_t",
 100     "struct l_timespec *");
 101 LIN_SDT_PROBE_DEFINE0(time, linux_clock_getres, nullcall);
 102 LIN_SDT_PROBE_DEFINE1(time, linux_clock_getres, conversion_error, "int");
 103 LIN_SDT_PROBE_DEFINE1(time, linux_clock_getres, getres_error, "int");
 104 LIN_SDT_PROBE_DEFINE1(time, linux_clock_getres, copyout_error, "int");
 105 LIN_SDT_PROBE_DEFINE1(time, linux_clock_getres, return, "int");
 106 LIN_SDT_PROBE_DEFINE2(time, linux_nanosleep, entry, "const struct l_timespec *",
 107     "struct l_timespec *");
 108 LIN_SDT_PROBE_DEFINE1(time, linux_nanosleep, conversion_error, "int");
 109 LIN_SDT_PROBE_DEFINE1(time, linux_nanosleep, copyout_error, "int");
 110 LIN_SDT_PROBE_DEFINE1(time, linux_nanosleep, copyin_error, "int");
 111 LIN_SDT_PROBE_DEFINE1(time, linux_nanosleep, return, "int");
 112 LIN_SDT_PROBE_DEFINE4(time, linux_clock_nanosleep, entry, "clockid_t", "int",
 113     "struct l_timespec *", "struct l_timespec *");
 114 LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, conversion_error, "int");
 115 LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, copyout_error, "int");
 116 LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, copyin_error, "int");
 117 LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, unsupported_flags, "int");
 118 LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, unsupported_clockid, "int");
 119 LIN_SDT_PROBE_DEFINE1(time, linux_clock_nanosleep, return, "int");
 120
 121
 122 int
 123 native_to_linux_timespec(struct l_timespec *ltp, struct timespec *ntp)
 124 {
 125
 126         LIN_SDT_PROBE2(time, native_to_linux_timespec, entry, ltp, ntp);
 127 #ifdef COMPAT_LINUX32
 128         if (ntp->tv_sec > INT_MAX &&
 129             sizeof(ltp->tv_sec) != sizeof(ntp->tv_sec))
 130                 return (EOVERFLOW);
 131 #endif
 132         ltp->tv_sec = ntp->tv_sec;
 133         ltp->tv_nsec = ntp->tv_nsec;
 134
 135         LIN_SDT_PROBE0(time, native_to_linux_timespec, return);
 136         return (0);
 137 }
 138
 139 int
 140 linux_to_native_timespec(struct timespec *ntp, struct l_timespec *ltp)
 141 {
 142
 143         LIN_SDT_PROBE2(time, linux_to_native_timespec, entry, ntp, ltp);
 144
 145         if (ltp->tv_sec < 0 || (l_ulong)ltp->tv_nsec > 999999999L) {
 146                 LIN_SDT_PROBE1(time, linux_to_native_timespec, return, EINVAL);
 147                 return (EINVAL);
 148         }
 149         ntp->tv_sec = ltp->tv_sec;
 150         ntp->tv_nsec = ltp->tv_nsec;
 151
 152         LIN_SDT_PROBE1(time, linux_to_native_timespec, return, 0);
 153         return (0);
 154 }
 155
 156 int
 157 native_to_linux_itimerspec(struct l_itimerspec *ltp, struct itimerspec *ntp)
 158 {
 159         int error;
 160
 161         error = native_to_linux_timespec(&ltp->it_interval, &ntp->it_interval);
 162         if (error == 0)
 163                 error = native_to_linux_timespec(&ltp->it_value, &ntp->it_interval);
 164         return (error);
 165 }
 166
 167 int
 168 linux_to_native_itimerspec(struct itimerspec *ntp, struct l_itimerspec *ltp)
 169 {
 170         int error;
 171
 172         error = linux_to_native_timespec(&ntp->it_interval, &ltp->it_interval);
 173         if (error == 0)
 174                 error = linux_to_native_timespec(&ntp->it_value, &ltp->it_value);
 175         return (error);
 176 }
 177
 178 int
 179 linux_to_native_clockid(clockid_t *n, clockid_t l)
 180 {
 181
 182         LIN_SDT_PROBE2(time, linux_to_native_clockid, entry, n, l);
 183
 184         if (l < 0) {
 185                 /* cpu-clock */
 186                 if ((l & LINUX_CLOCKFD_MASK) == LINUX_CLOCKFD)
 187                         return (EINVAL);
 188                 if (LINUX_CPUCLOCK_WHICH(l) >= LINUX_CPUCLOCK_MAX)
 189                         return (EINVAL);
 190
 191                 if (LINUX_CPUCLOCK_PERTHREAD(l))
 192                         *n = CLOCK_THREAD_CPUTIME_ID;
 193                 else
 194                         *n = CLOCK_PROCESS_CPUTIME_ID;
 195                 return (0);
 196         }
 197
 198         switch (l) {
 199         case LINUX_CLOCK_REALTIME:
 200                 *n = CLOCK_REALTIME;
 201                 break;
 202         case LINUX_CLOCK_MONOTONIC:
 203                 *n = CLOCK_MONOTONIC;
 204                 break;
 205         case LINUX_CLOCK_REALTIME_COARSE:
 206                 *n = CLOCK_REALTIME_FAST;
 207                 break;
 208         case LINUX_CLOCK_MONOTONIC_COARSE:
 209                 *n = CLOCK_MONOTONIC_FAST;
 210                 break;
 211         case LINUX_CLOCK_MONOTONIC_RAW:
 212         case LINUX_CLOCK_BOOTTIME:
 213         case LINUX_CLOCK_REALTIME_ALARM:
 214         case LINUX_CLOCK_BOOTTIME_ALARM:
 215         case LINUX_CLOCK_SGI_CYCLE:
 216         case LINUX_CLOCK_TAI:
 217                 LIN_SDT_PROBE1(time, linux_to_native_clockid,
 218                     unsupported_clockid, l);
 219                 LIN_SDT_PROBE1(time, linux_to_native_clockid, return, EINVAL);
 220                 return (EINVAL);
 221         default:
 222                 LIN_SDT_PROBE1(time, linux_to_native_clockid,
 223                     unknown_clockid, l);
 224                 LIN_SDT_PROBE1(time, linux_to_native_clockid, return, EINVAL);
 225                 return (EINVAL);
 226         }
 227
 228         LIN_SDT_PROBE1(time, linux_to_native_clockid, return, 0);
 229         return (0);
 230 }
 231
 232 int
 233 linux_clock_gettime(struct thread *td, struct linux_clock_gettime_args *args)
 234 {
 235         struct l_timespec lts;
 236         struct timespec tp;
 237         struct rusage ru;
 238         struct thread *targettd;
 239         struct proc *p;
 240         int error, clockwhich;
 241         clockid_t nwhich = 0;   /* XXX: GCC */
 242         pid_t pid;
 243         lwpid_t tid;
 244
 245         LIN_SDT_PROBE2(time, linux_clock_gettime, entry, args->which, args->tp);
 246
 247         error = linux_to_native_clockid(&nwhich, args->which);
 248         if (error != 0) {
 249                 LIN_SDT_PROBE1(time, linux_clock_gettime, conversion_error,
 250                     error);
 251                 LIN_SDT_PROBE1(time, linux_clock_gettime, return, error);
 252                 return (error);
 253         }
 254
 255         switch (nwhich) {
 256         case CLOCK_PROCESS_CPUTIME_ID:
 257                 clockwhich = LINUX_CPUCLOCK_WHICH(args->which);
 258                 pid = LINUX_CPUCLOCK_ID(args->which);
 259                 if (pid == 0) {
 260                         p = td->td_proc;
 261                         PROC_LOCK(p);
 262                 } else {
 263                         error = pget(pid, PGET_CANSEE, &p);
 264                         if (error != 0)
 265                                 return (EINVAL);
 266                 }
 267                 switch (clockwhich) {
 268                 case LINUX_CPUCLOCK_PROF:
 269                         PROC_STATLOCK(p);
 270                         calcru(p, &ru.ru_utime, &ru.ru_stime);
 271                         PROC_STATUNLOCK(p);
 272                         PROC_UNLOCK(p);
 273                         timevaladd(&ru.ru_utime, &ru.ru_stime);
 274                         TIMEVAL_TO_TIMESPEC(&ru.ru_utime, &tp);
 275                         break;
 276                 case LINUX_CPUCLOCK_VIRT:
 277                         PROC_STATLOCK(p);
 278                         calcru(p, &ru.ru_utime, &ru.ru_stime);
 279                         PROC_STATUNLOCK(p);
 280                         PROC_UNLOCK(p);
 281                         TIMEVAL_TO_TIMESPEC(&ru.ru_utime, &tp);
 282                         break;
 283                 case LINUX_CPUCLOCK_SCHED:
 284                         PROC_UNLOCK(p);
 285                         error = kern_clock_getcpuclockid2(td, pid,
 286                             CPUCLOCK_WHICH_PID, &nwhich);
 287                         if (error != 0)
 288                                 return (EINVAL);
 289                         error = kern_clock_gettime(td, nwhich, &tp);
 290                         break;
 291                 default:
 292                         PROC_UNLOCK(p);
 293                         return (EINVAL);
 294                 }
 295
 296                 break;
 297
 298         case CLOCK_THREAD_CPUTIME_ID:
 299                 clockwhich = LINUX_CPUCLOCK_WHICH(args->which);
 300                 p = td->td_proc;
 301                 tid = LINUX_CPUCLOCK_ID(args->which);
 302                 if (tid == 0) {
 303                         targettd = td;
 304                         PROC_LOCK(p);
 305                 } else {
 306                         targettd = tdfind(tid, p->p_pid);
 307                         if (targettd == NULL)
 308                                 return (EINVAL);
 309                 }
 310                 switch (clockwhich) {
 311                 case LINUX_CPUCLOCK_PROF:
 312                         PROC_STATLOCK(p);
 313                         thread_lock(targettd);
 314                         rufetchtd(targettd, &ru);
 315                         thread_unlock(targettd);
 316                         PROC_STATUNLOCK(p);
 317                         PROC_UNLOCK(p);
 318                         timevaladd(&ru.ru_utime, &ru.ru_stime);
 319                         TIMEVAL_TO_TIMESPEC(&ru.ru_utime, &tp);
 320                         break;
 321                 case LINUX_CPUCLOCK_VIRT:
 322                         PROC_STATLOCK(p);
 323                         thread_lock(targettd);
 324                         rufetchtd(targettd, &ru);
 325                         thread_unlock(targettd);
 326                         PROC_STATUNLOCK(p);
 327                         PROC_UNLOCK(p);
 328                         TIMEVAL_TO_TIMESPEC(&ru.ru_utime, &tp);
 329                         break;
 330                 case LINUX_CPUCLOCK_SCHED:
 331                         error = kern_clock_getcpuclockid2(td, tid,
 332                             CPUCLOCK_WHICH_TID, &nwhich);
 333                         PROC_UNLOCK(p);
 334                         if (error != 0)
 335                                 return (EINVAL);
 336                         error = kern_clock_gettime(td, nwhich, &tp);
 337                         break;
 338                 default:
 339                         PROC_UNLOCK(p);
 340                         return (EINVAL);
 341                 }
 342                 break;
 343
 344         default:
 345                 error = kern_clock_gettime(td, nwhich, &tp);
 346                 break;
 347         }
 348         if (error != 0) {
 349                 LIN_SDT_PROBE1(time, linux_clock_gettime, gettime_error, error);
 350                 LIN_SDT_PROBE1(time, linux_clock_gettime, return, error);
 351                 return (error);
 352         }
 353         error = native_to_linux_timespec(&lts, &tp);
 354         if (error != 0)
 355                 return (error);
 356         error = copyout(&lts, args->tp, sizeof lts);
 357         if (error != 0)
 358                 LIN_SDT_PROBE1(time, linux_clock_gettime, copyout_error, error);
 359
 360         LIN_SDT_PROBE1(time, linux_clock_gettime, return, error);
 361         return (error);
 362 }
 363
 364 int
 365 linux_clock_settime(struct thread *td, struct linux_clock_settime_args *args)
 366 {
 367         struct timespec ts;
 368         struct l_timespec lts;
 369         int error;
 370         clockid_t nwhich = 0;   /* XXX: GCC */
 371
 372         LIN_SDT_PROBE2(time, linux_clock_settime, entry, args->which, args->tp);
 373
 374         error = linux_to_native_clockid(&nwhich, args->which);
 375         if (error != 0) {
 376                 LIN_SDT_PROBE1(time, linux_clock_settime, conversion_error,
 377                     error);
 378                 LIN_SDT_PROBE1(time, linux_clock_settime, return, error);
 379                 return (error);
 380         }
 381         error = copyin(args->tp, &lts, sizeof lts);
 382         if (error != 0) {
 383                 LIN_SDT_PROBE1(time, linux_clock_settime, copyin_error, error);
 384                 LIN_SDT_PROBE1(time, linux_clock_settime, return, error);
 385                 return (error);
 386         }
 387         error = linux_to_native_timespec(&ts, &lts);
 388         if (error != 0) {
 389                 LIN_SDT_PROBE1(time, linux_clock_settime, conversion_error,
 390                     error);
 391                 LIN_SDT_PROBE1(time, linux_clock_settime, return, error);
 392                 return (error);
 393         }
 394
 395         error = kern_clock_settime(td, nwhich, &ts);
 396         if (error != 0)
 397                 LIN_SDT_PROBE1(time, linux_clock_settime, settime_error, error);
 398
 399         LIN_SDT_PROBE1(time, linux_clock_settime, return, error);
 400         return (error);
 401 }
 402
 403 int
 404 linux_clock_getres(struct thread *td, struct linux_clock_getres_args *args)
 405 {
 406         struct proc *p;
 407         struct timespec ts;
 408         struct l_timespec lts;
 409         int error, clockwhich;
 410         clockid_t nwhich = 0;   /* XXX: GCC */
 411         pid_t pid;
 412         lwpid_t tid;
 413
 414         LIN_SDT_PROBE2(time, linux_clock_getres, entry, args->which, args->tp);
 415
 416         error = linux_to_native_clockid(&nwhich, args->which);
 417         if (error != 0) {
 418                 LIN_SDT_PROBE1(time, linux_clock_getres, conversion_error,
 419                     error);
 420                 LIN_SDT_PROBE1(time, linux_clock_getres, return, error);
 421                 return (error);
 422         }
 423
 424         /*
 425          * Check user supplied clock id in case of per-process
 426          * or thread-specific cpu-time clock.
 427          */
 428         switch (nwhich) {
 429         case CLOCK_THREAD_CPUTIME_ID:
 430                 tid = LINUX_CPUCLOCK_ID(args->which);
 431                 if (tid != 0) {
 432                         p = td->td_proc;
 433                         if (tdfind(tid, p->p_pid) == NULL)
 434                                 return (ESRCH);
 435                         PROC_UNLOCK(p);
 436                 }
 437                 break;
 438         case CLOCK_PROCESS_CPUTIME_ID:
 439                 pid = LINUX_CPUCLOCK_ID(args->which);
 440                 if (pid != 0) {
 441                         error = pget(pid, PGET_CANSEE, &p);
 442                         if (error != 0)
 443                                 return (EINVAL);
 444                         PROC_UNLOCK(p);
 445                 }
 446                 break;
 447         }
 448
 449         if (args->tp == NULL) {
 450                 LIN_SDT_PROBE0(time, linux_clock_getres, nullcall);
 451                 LIN_SDT_PROBE1(time, linux_clock_getres, return, 0);
 452                 return (0);
 453         }
 454
 455         switch (nwhich) {
 456         case CLOCK_THREAD_CPUTIME_ID:
 457         case CLOCK_PROCESS_CPUTIME_ID:
 458                 clockwhich = LINUX_CPUCLOCK_WHICH(args->which);
 459                 switch (clockwhich) {
 460                 case LINUX_CPUCLOCK_PROF:
 461                         nwhich = CLOCK_PROF;
 462                         break;
 463                 case LINUX_CPUCLOCK_VIRT:
 464                         nwhich = CLOCK_VIRTUAL;
 465                         break;
 466                 case LINUX_CPUCLOCK_SCHED:
 467                         break;
 468                 default:
 469                         return (EINVAL);
 470                 }
 471                 break;
 472
 473         default:
 474                 break;
 475         }
 476         error = kern_clock_getres(td, nwhich, &ts);
 477         if (error != 0) {
 478                 LIN_SDT_PROBE1(time, linux_clock_getres, getres_error, error);
 479                 LIN_SDT_PROBE1(time, linux_clock_getres, return, error);
 480                 return (error);
 481         }
 482         error = native_to_linux_timespec(&lts, &ts);
 483         if (error != 0)
 484                 return (error);
 485         error = copyout(&lts, args->tp, sizeof lts);
 486         if (error != 0)
 487                 LIN_SDT_PROBE1(time, linux_clock_getres, copyout_error, error);
 488
 489         LIN_SDT_PROBE1(time, linux_clock_getres, return, error);
 490         return (error);
 491 }
 492
 493 int
 494 linux_nanosleep(struct thread *td, struct linux_nanosleep_args *args)
 495 {
 496         struct timespec *rmtp;
 497         struct l_timespec lrqts, lrmts;
 498         struct timespec rqts, rmts;
 499         int error, error2;
 500
 501         LIN_SDT_PROBE2(time, linux_nanosleep, entry, args->rqtp, args->rmtp);
 502
 503         error = copyin(args->rqtp, &lrqts, sizeof lrqts);
 504         if (error != 0) {
 505                 LIN_SDT_PROBE1(time, linux_nanosleep, copyin_error, error);
 506                 LIN_SDT_PROBE1(time, linux_nanosleep, return, error);
 507                 return (error);
 508         }
 509
 510         if (args->rmtp != NULL)
 511                 rmtp = &rmts;
 512         else
 513                 rmtp = NULL;
 514
 515         error = linux_to_native_timespec(&rqts, &lrqts);
 516         if (error != 0) {
 517                 LIN_SDT_PROBE1(time, linux_nanosleep, conversion_error, error);
 518                 LIN_SDT_PROBE1(time, linux_nanosleep, return, error);
 519                 return (error);
 520         }
 521         error = kern_nanosleep(td, &rqts, rmtp);
 522         if (error == EINTR && args->rmtp != NULL) {
 523                 error2 = native_to_linux_timespec(&lrmts, rmtp);
 524                 if (error2 != 0)
 525                         return (error2);
 526                 error2 = copyout(&lrmts, args->rmtp, sizeof(lrmts));
 527                 if (error2 != 0) {
 528                         LIN_SDT_PROBE1(time, linux_nanosleep, copyout_error,
 529                             error2);
 530                         LIN_SDT_PROBE1(time, linux_nanosleep, return, error2);
 531                         return (error2);
 532                 }
 533         }
 534
 535         LIN_SDT_PROBE1(time, linux_nanosleep, return, error);
 536         return (error);
 537 }
 538
 539 int
 540 linux_clock_nanosleep(struct thread *td, struct linux_clock_nanosleep_args *args)
 541 {
 542         struct timespec *rmtp;
 543         struct l_timespec lrqts, lrmts;
 544         struct timespec rqts, rmts;
 545         int error, error2;
 546
 547         LIN_SDT_PROBE4(time, linux_clock_nanosleep, entry, args->which,
 548             args->flags, args->rqtp, args->rmtp);
 549
 550         if (args->flags != 0) {
 551                 /* XXX deal with TIMER_ABSTIME */
 552                 LIN_SDT_PROBE1(time, linux_clock_nanosleep, unsupported_flags,
 553                     args->flags);
 554                 LIN_SDT_PROBE1(time, linux_clock_nanosleep, return, EINVAL);
 555                 return (EINVAL);        /* XXX deal with TIMER_ABSTIME */
 556         }
 557
 558         if (args->which != LINUX_CLOCK_REALTIME) {
 559                 LIN_SDT_PROBE1(time, linux_clock_nanosleep, unsupported_clockid,
 560                     args->which);
 561                 LIN_SDT_PROBE1(time, linux_clock_nanosleep, return, EINVAL);
 562                 return (EINVAL);
 563         }
 564
 565         error = copyin(args->rqtp, &lrqts, sizeof(lrqts));
 566         if (error != 0) {
 567                 LIN_SDT_PROBE1(time, linux_clock_nanosleep, copyin_error,
 568                     error);
 569                 LIN_SDT_PROBE1(time, linux_clock_nanosleep, return, error);
 570                 return (error);
 571         }
 572
 573         if (args->rmtp != NULL)
 574                 rmtp = &rmts;
 575         else
 576                 rmtp = NULL;
 577
 578         error = linux_to_native_timespec(&rqts, &lrqts);
 579         if (error != 0) {
 580                 LIN_SDT_PROBE1(time, linux_clock_nanosleep, conversion_error,
 581                     error);
 582                 LIN_SDT_PROBE1(time, linux_clock_nanosleep, return, error);
 583                 return (error);
 584         }
 585         error = kern_nanosleep(td, &rqts, rmtp);
 586         if (error == EINTR && args->rmtp != NULL) {
 587                 /* XXX. Not for TIMER_ABSTIME */
 588                 error2 = native_to_linux_timespec(&lrmts, rmtp);
 589                 if (error2 != 0)
 590                         return (error2);
 591                 error2 = copyout(&lrmts, args->rmtp, sizeof(lrmts));
 592                 if (error2 != 0) {
 593                         LIN_SDT_PROBE1(time, linux_clock_nanosleep,
 594                             copyout_error, error2);
 595                         LIN_SDT_PROBE1(time, linux_clock_nanosleep,
 596                             return, error2);
 597                         return (error2);
 598                 }
 599         }
 600
 601         LIN_SDT_PROBE1(time, linux_clock_nanosleep, return, error);
 602         return (error);
 603 }