sys/kern/sys_timerfd.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2014 Dmitry Chagin <dchagin@FreeBSD.org>
   5  * Copyright (c) 2023 Jake Freeland <jfree@FreeBSD.org>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/systm.h>
  31 #include <sys/callout.h>
  32 #include <sys/fcntl.h>
  33 #include <sys/file.h>
  34 #include <sys/filedesc.h>
  35 #include <sys/filio.h>
  36 #include <sys/kernel.h>
  37 #include <sys/lock.h>
  38 #include <sys/malloc.h>
  39 #include <sys/mount.h>
  40 #include <sys/mutex.h>
  41 #include <sys/poll.h>
  42 #include <sys/proc.h>
  43 #include <sys/queue.h>
  44 #include <sys/selinfo.h>
  45 #include <sys/stat.h>
  46 #include <sys/sx.h>
  47 #include <sys/syscallsubr.h>
  48 #include <sys/sysctl.h>
  49 #include <sys/sysent.h>
  50 #include <sys/sysproto.h>
  51 #include <sys/timerfd.h>
  52 #include <sys/timespec.h>
  53 #include <sys/uio.h>
  54 #include <sys/user.h>
  55
  56 #include <security/audit/audit.h>
  57
  58 static MALLOC_DEFINE(M_TIMERFD, "timerfd", "timerfd structures");
  59
  60 static struct mtx timerfd_list_lock;
  61 static LIST_HEAD(, timerfd) timerfd_list;
  62 MTX_SYSINIT(timerfd, &timerfd_list_lock, "timerfd_list_lock", MTX_DEF);
  63
  64 static struct unrhdr64 tfdino_unr;
  65
  66 #define TFD_NOJUMP      0       /* Realtime clock has not jumped. */
  67 #define TFD_READ        1       /* Jumped, tfd has been read since. */
  68 #define TFD_ZREAD       2       /* Jumped backwards, CANCEL_ON_SET=false. */
  69 #define TFD_CANCELED    4       /* Jumped, CANCEL_ON_SET=true. */
  70 #define TFD_JUMPED      (TFD_ZREAD | TFD_CANCELED)
  71
  72 /*
  73  * One structure allocated per timerfd descriptor.
  74  *
  75  * Locking semantics:
  76  * (t)  locked by tfd_lock mtx
  77  * (l)  locked by timerfd_list_lock sx
  78  * (c)  const until freeing
  79  */
  80 struct timerfd {
  81         /* User specified. */
  82         struct itimerspec tfd_time;     /* (t) tfd timer */
  83         clockid_t       tfd_clockid;    /* (c) timing base */
  84         int             tfd_flags;      /* (c) creation flags */
  85         int             tfd_timflags;   /* (t) timer flags */
  86
  87         /* Used internally. */
  88         timerfd_t       tfd_count;      /* (t) expiration count since read */
  89         bool            tfd_expired;    /* (t) true upon initial expiration */
  90         struct mtx      tfd_lock;       /* tfd mtx lock */
  91         struct callout  tfd_callout;    /* (t) expiration notification */
  92         struct selinfo  tfd_sel;        /* (t) I/O alerts */
  93         struct timespec tfd_boottim;    /* (t) cached boottime */
  94         int             tfd_jumped;     /* (t) timer jump status */
  95         LIST_ENTRY(timerfd) entry;      /* (l) entry in list */
  96
  97         /* For stat(2). */
  98         ino_t           tfd_ino;        /* (c) inode number */
  99         struct timespec tfd_atim;       /* (t) time of last read */
 100         struct timespec tfd_mtim;       /* (t) time of last settime */
 101         struct timespec tfd_birthtim;   /* (c) creation time */
 102 };
 103
 104 static void
 105 timerfd_init(void *data)
 106 {
 107         new_unrhdr64(&tfdino_unr, 1);
 108 }
 109
 110 SYSINIT(timerfd, SI_SUB_VFS, SI_ORDER_ANY, timerfd_init, NULL);
 111
 112 static inline void
 113 timerfd_getboottime(struct timespec *ts)
 114 {
 115         struct timeval tv;
 116
 117         getboottime(&tv);
 118         TIMEVAL_TO_TIMESPEC(&tv, ts);
 119 }
 120
 121 /*
 122  * Call when a discontinuous jump has occured in CLOCK_REALTIME and
 123  * update timerfd's cached boottime. A jump can be triggered using
 124  * functions like clock_settime(2) or settimeofday(2).
 125  *
 126  * Timer is marked TFD_CANCELED if TFD_TIMER_CANCEL_ON_SET is set
 127  * and the realtime clock jumps.
 128  * Timer is marked TFD_ZREAD if TFD_TIMER_CANCEL_ON_SET is not set,
 129  * but the realtime clock jumps backwards.
 130  */
 131 void
 132 timerfd_jumped(void)
 133 {
 134         struct timerfd *tfd;
 135         struct timespec boottime, diff;
 136
 137         if (LIST_EMPTY(&timerfd_list))
 138                 return;
 139
 140         timerfd_getboottime(&boottime);
 141         mtx_lock(&timerfd_list_lock);
 142         LIST_FOREACH(tfd, &timerfd_list, entry) {
 143                 mtx_lock(&tfd->tfd_lock);
 144                 if (tfd->tfd_clockid != CLOCK_REALTIME ||
 145                     (tfd->tfd_timflags & TFD_TIMER_ABSTIME) == 0 ||
 146                     timespeccmp(&boottime, &tfd->tfd_boottim, ==)) {
 147                         mtx_unlock(&tfd->tfd_lock);
 148                         continue;
 149                 }
 150
 151                 if (callout_active(&tfd->tfd_callout)) {
 152                         if ((tfd->tfd_timflags & TFD_TIMER_CANCEL_ON_SET) != 0)
 153                                 tfd->tfd_jumped = TFD_CANCELED;
 154                         else if (timespeccmp(&boottime, &tfd->tfd_boottim, <))
 155                                 tfd->tfd_jumped = TFD_ZREAD;
 156
 157                         /*
 158                          * Do not reschedule callout when
 159                          * inside interval time loop.
 160                          */
 161                         if (!tfd->tfd_expired) {
 162                                 timespecsub(&boottime,
 163                                     &tfd->tfd_boottim, &diff);
 164                                 timespecsub(&tfd->tfd_time.it_value,
 165                                     &diff, &tfd->tfd_time.it_value);
 166                                 if (callout_stop(&tfd->tfd_callout) == 1) {
 167                                         callout_schedule_sbt(&tfd->tfd_callout,
 168                                             tstosbt(tfd->tfd_time.it_value),
 169                                             0, C_ABSOLUTE);
 170                                 }
 171                         }
 172                 }
 173
 174                 tfd->tfd_boottim = boottime;
 175                 mtx_unlock(&tfd->tfd_lock);
 176         }
 177         mtx_unlock(&timerfd_list_lock);
 178 }
 179
 180 static int
 181 timerfd_read(struct file *fp, struct uio *uio, struct ucred *active_cred,
 182     int flags, struct thread *td)
 183 {
 184         struct timerfd *tfd = fp->f_data;
 185         timerfd_t count;
 186         int error = 0;
 187
 188         if (uio->uio_resid < sizeof(timerfd_t))
 189                 return (EINVAL);
 190
 191         mtx_lock(&tfd->tfd_lock);
 192 retry:
 193         getnanotime(&tfd->tfd_atim);
 194         if ((tfd->tfd_jumped & TFD_JUMPED) != 0) {
 195                 if (tfd->tfd_jumped == TFD_CANCELED)
 196                         error = ECANCELED;
 197                 tfd->tfd_jumped = TFD_READ;
 198                 tfd->tfd_count = 0;
 199                 mtx_unlock(&tfd->tfd_lock);
 200                 return (error);
 201         } else {
 202                 tfd->tfd_jumped = TFD_NOJUMP;
 203         }
 204         if (tfd->tfd_count == 0) {
 205                 if ((fp->f_flag & FNONBLOCK) != 0) {
 206                         mtx_unlock(&tfd->tfd_lock);
 207                         return (EAGAIN);
 208                 }
 209                 td->td_rtcgen = atomic_load_acq_int(&rtc_generation);
 210                 error = mtx_sleep(&tfd->tfd_count, &tfd->tfd_lock,
 211                     PCATCH, "tfdrd", 0);
 212                 if (error == 0) {
 213                         goto retry;
 214                 } else {
 215                         mtx_unlock(&tfd->tfd_lock);
 216                         return (error);
 217                 }
 218         }
 219
 220         count = tfd->tfd_count;
 221         tfd->tfd_count = 0;
 222         mtx_unlock(&tfd->tfd_lock);
 223         error = uiomove(&count, sizeof(timerfd_t), uio);
 224
 225         return (error);
 226 }
 227
 228 static int
 229 timerfd_ioctl(struct file *fp, u_long cmd, void *data,
 230     struct ucred *active_cred, struct thread *td)
 231 {
 232         switch (cmd) {
 233         case FIOASYNC:
 234                 if (*(int *)data != 0)
 235                         atomic_set_int(&fp->f_flag, FASYNC);
 236                 else
 237                         atomic_clear_int(&fp->f_flag, FASYNC);
 238                 return (0);
 239         case FIONBIO:
 240                 if (*(int *)data != 0)
 241                         atomic_set_int(&fp->f_flag, FNONBLOCK);
 242                 else
 243                         atomic_clear_int(&fp->f_flag, FNONBLOCK);
 244                 return (0);
 245         }
 246         return (ENOTTY);
 247 }
 248
 249 static int
 250 timerfd_poll(struct file *fp, int events, struct ucred *active_cred,
 251     struct thread *td)
 252 {
 253         struct timerfd *tfd = fp->f_data;
 254         int revents = 0;
 255
 256         mtx_lock(&tfd->tfd_lock);
 257         if ((events & (POLLIN | POLLRDNORM)) != 0 &&
 258             tfd->tfd_count > 0 && tfd->tfd_jumped != TFD_READ)
 259                 revents |= events & (POLLIN | POLLRDNORM);
 260         if (revents == 0)
 261                 selrecord(td, &tfd->tfd_sel);
 262         mtx_unlock(&tfd->tfd_lock);
 263
 264         return (revents);
 265 }
 266
 267 static void
 268 filt_timerfddetach(struct knote *kn)
 269 {
 270         struct timerfd *tfd = kn->kn_hook;
 271
 272         mtx_lock(&tfd->tfd_lock);
 273         knlist_remove(&tfd->tfd_sel.si_note, kn, 1);
 274         mtx_unlock(&tfd->tfd_lock);
 275 }
 276
 277 static int
 278 filt_timerfdread(struct knote *kn, long hint)
 279 {
 280         struct timerfd *tfd = kn->kn_hook;
 281
 282         mtx_assert(&tfd->tfd_lock, MA_OWNED);
 283         kn->kn_data = (int64_t)tfd->tfd_count;
 284         return (tfd->tfd_count > 0);
 285 }
 286
 287 static struct filterops timerfd_rfiltops = {
 288         .f_isfd = 1,
 289         .f_detach = filt_timerfddetach,
 290         .f_event = filt_timerfdread,
 291 };
 292
 293 static int
 294 timerfd_kqfilter(struct file *fp, struct knote *kn)
 295 {
 296         struct timerfd *tfd = fp->f_data;
 297
 298         if (kn->kn_filter != EVFILT_READ)
 299                 return (EINVAL);
 300
 301         kn->kn_fop = &timerfd_rfiltops;
 302         kn->kn_hook = tfd;
 303         knlist_add(&tfd->tfd_sel.si_note, kn, 0);
 304
 305         return (0);
 306 }
 307
 308 static int
 309 timerfd_stat(struct file *fp, struct stat *sb, struct ucred *active_cred)
 310 {
 311         struct timerfd *tfd = fp->f_data;
 312
 313         bzero(sb, sizeof(*sb));
 314         sb->st_nlink = fp->f_count - 1;
 315         sb->st_uid = fp->f_cred->cr_uid;
 316         sb->st_gid = fp->f_cred->cr_gid;
 317         sb->st_blksize = PAGE_SIZE;
 318         mtx_lock(&tfd->tfd_lock);
 319         sb->st_atim = tfd->tfd_atim;
 320         sb->st_mtim = tfd->tfd_mtim;
 321         mtx_unlock(&tfd->tfd_lock);
 322         sb->st_ctim = sb->st_mtim;
 323         sb->st_ino = tfd->tfd_ino;
 324         sb->st_birthtim = tfd->tfd_birthtim;
 325
 326         return (0);
 327 }
 328
 329 static int
 330 timerfd_close(struct file *fp, struct thread *td)
 331 {
 332         struct timerfd *tfd = fp->f_data;
 333
 334         mtx_lock(&timerfd_list_lock);
 335         LIST_REMOVE(tfd, entry);
 336         mtx_unlock(&timerfd_list_lock);
 337
 338         callout_drain(&tfd->tfd_callout);
 339         seldrain(&tfd->tfd_sel);
 340         knlist_destroy(&tfd->tfd_sel.si_note);
 341         mtx_destroy(&tfd->tfd_lock);
 342         free(tfd, M_TIMERFD);
 343         fp->f_ops = &badfileops;
 344
 345         return (0);
 346 }
 347
 348 static int
 349 timerfd_fill_kinfo(struct file *fp, struct kinfo_file *kif,
 350     struct filedesc *fdp)
 351 {
 352         struct timerfd *tfd = fp->f_data;
 353
 354         kif->kf_type = KF_TYPE_TIMERFD;
 355         kif->kf_un.kf_timerfd.kf_timerfd_clockid = tfd->tfd_clockid;
 356         kif->kf_un.kf_timerfd.kf_timerfd_flags = tfd->tfd_flags;
 357         kif->kf_un.kf_timerfd.kf_timerfd_addr = (uintptr_t)tfd;
 358
 359         return (0);
 360 }
 361
 362 static struct fileops timerfdops = {
 363         .fo_read = timerfd_read,
 364         .fo_write = invfo_rdwr,
 365         .fo_truncate = invfo_truncate,
 366         .fo_ioctl = timerfd_ioctl,
 367         .fo_poll = timerfd_poll,
 368         .fo_kqfilter = timerfd_kqfilter,
 369         .fo_stat = timerfd_stat,
 370         .fo_close = timerfd_close,
 371         .fo_chmod = invfo_chmod,
 372         .fo_chown = invfo_chown,
 373         .fo_sendfile = invfo_sendfile,
 374         .fo_fill_kinfo = timerfd_fill_kinfo,
 375         .fo_cmp = file_kcmp_generic,
 376         .fo_flags = DFLAG_PASSABLE,
 377 };
 378
 379 static void
 380 timerfd_curval(struct timerfd *tfd, struct itimerspec *old_value)
 381 {
 382         struct timespec curr_value;
 383
 384         mtx_assert(&tfd->tfd_lock, MA_OWNED);
 385         *old_value = tfd->tfd_time;
 386         if (timespecisset(&tfd->tfd_time.it_value)) {
 387                 nanouptime(&curr_value);
 388                 timespecsub(&tfd->tfd_time.it_value, &curr_value,
 389                     &old_value->it_value);
 390         }
 391 }
 392
 393 static void
 394 timerfd_expire(void *arg)
 395 {
 396         struct timerfd *tfd = (struct timerfd *)arg;
 397         struct timespec uptime;
 398
 399         ++tfd->tfd_count;
 400         tfd->tfd_expired = true;
 401         if (timespecisset(&tfd->tfd_time.it_interval)) {
 402                 /* Count missed events. */
 403                 nanouptime(&uptime);
 404                 if (timespeccmp(&uptime, &tfd->tfd_time.it_value, >)) {
 405                         timespecsub(&uptime, &tfd->tfd_time.it_value, &uptime);
 406                         tfd->tfd_count += tstosbt(uptime) /
 407                             tstosbt(tfd->tfd_time.it_interval);
 408                 }
 409                 timespecadd(&tfd->tfd_time.it_value,
 410                     &tfd->tfd_time.it_interval, &tfd->tfd_time.it_value);
 411                 callout_schedule_sbt(&tfd->tfd_callout,
 412                     tstosbt(tfd->tfd_time.it_value),
 413                     0, C_ABSOLUTE);
 414         } else {
 415                 /* Single shot timer. */
 416                 callout_deactivate(&tfd->tfd_callout);
 417                 timespecclear(&tfd->tfd_time.it_value);
 418         }
 419
 420         wakeup(&tfd->tfd_count);
 421         selwakeup(&tfd->tfd_sel);
 422         KNOTE_LOCKED(&tfd->tfd_sel.si_note, 0);
 423 }
 424
 425 int
 426 kern_timerfd_create(struct thread *td, int clockid, int flags)
 427 {
 428         struct file *fp;
 429         struct timerfd *tfd;
 430         int error, fd, fflags;
 431
 432         AUDIT_ARG_VALUE(clockid);
 433         AUDIT_ARG_FFLAGS(flags);
 434
 435         if (clockid != CLOCK_REALTIME && clockid != CLOCK_MONOTONIC)
 436                 return (EINVAL);
 437         if ((flags & ~(TFD_CLOEXEC | TFD_NONBLOCK)) != 0)
 438                 return (EINVAL);
 439
 440         fflags = FREAD;
 441         if ((flags & TFD_CLOEXEC) != 0)
 442                 fflags |= O_CLOEXEC;
 443         if ((flags & TFD_NONBLOCK) != 0)
 444                 fflags |= FNONBLOCK;
 445
 446         error = falloc(td, &fp, &fd, fflags);
 447         if (error != 0)
 448                 return (error);
 449
 450         tfd = malloc(sizeof(*tfd), M_TIMERFD, M_WAITOK | M_ZERO);
 451         tfd->tfd_clockid = (clockid_t)clockid;
 452         tfd->tfd_flags = flags;
 453         tfd->tfd_ino = alloc_unr64(&tfdino_unr);
 454         mtx_init(&tfd->tfd_lock, "timerfd", NULL, MTX_DEF);
 455         callout_init_mtx(&tfd->tfd_callout, &tfd->tfd_lock, 0);
 456         knlist_init_mtx(&tfd->tfd_sel.si_note, &tfd->tfd_lock);
 457         timerfd_getboottime(&tfd->tfd_boottim);
 458         getnanotime(&tfd->tfd_birthtim);
 459         mtx_lock(&timerfd_list_lock);
 460         LIST_INSERT_HEAD(&timerfd_list, tfd, entry);
 461         mtx_unlock(&timerfd_list_lock);
 462
 463         finit(fp, fflags, DTYPE_TIMERFD, tfd, &timerfdops);
 464
 465         fdrop(fp, td);
 466
 467         td->td_retval[0] = fd;
 468         return (0);
 469 }
 470
 471 int
 472 kern_timerfd_gettime(struct thread *td, int fd, struct itimerspec *curr_value)
 473 {
 474         struct file *fp;
 475         struct timerfd *tfd;
 476         int error;
 477
 478         error = fget(td, fd, &cap_write_rights, &fp);
 479         if (error != 0)
 480                 return (error);
 481         if (fp->f_type != DTYPE_TIMERFD) {
 482                 fdrop(fp, td);
 483                 return (EINVAL);
 484         }
 485         tfd = fp->f_data;
 486
 487         mtx_lock(&tfd->tfd_lock);
 488         timerfd_curval(tfd, curr_value);
 489         mtx_unlock(&tfd->tfd_lock);
 490
 491         fdrop(fp, td);
 492         return (0);
 493 }
 494
 495 int
 496 kern_timerfd_settime(struct thread *td, int fd, int flags,
 497     const struct itimerspec *new_value, struct itimerspec *old_value)
 498 {
 499         struct file *fp;
 500         struct timerfd *tfd;
 501         struct timespec ts;
 502         int error = 0;
 503
 504         if ((flags & ~(TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET)) != 0)
 505                 return (EINVAL);
 506         if (!timespecvalid_interval(&new_value->it_value) ||
 507             !timespecvalid_interval(&new_value->it_interval))
 508                 return (EINVAL);
 509
 510         error = fget(td, fd, &cap_write_rights, &fp);
 511         if (error != 0)
 512                 return (error);
 513         if (fp->f_type != DTYPE_TIMERFD) {
 514                 fdrop(fp, td);
 515                 return (EINVAL);
 516         }
 517         tfd = fp->f_data;
 518
 519         mtx_lock(&tfd->tfd_lock);
 520         getnanotime(&tfd->tfd_mtim);
 521         tfd->tfd_timflags = flags;
 522
 523         /* Store old itimerspec, if applicable. */
 524         if (old_value != NULL)
 525                 timerfd_curval(tfd, old_value);
 526
 527         /* Set new expiration. */
 528         tfd->tfd_time = *new_value;
 529         if (timespecisset(&tfd->tfd_time.it_value)) {
 530                 if ((flags & TFD_TIMER_ABSTIME) == 0) {
 531                         nanouptime(&ts);
 532                         timespecadd(&tfd->tfd_time.it_value, &ts,
 533                             &tfd->tfd_time.it_value);
 534                 } else if (tfd->tfd_clockid == CLOCK_REALTIME) {
 535                         /* ECANCELED if unread jump is pending. */
 536                         if (tfd->tfd_jumped == TFD_CANCELED)
 537                                 error = ECANCELED;
 538                         /* Convert from CLOCK_REALTIME to CLOCK_BOOTTIME. */
 539                         timespecsub(&tfd->tfd_time.it_value, &tfd->tfd_boottim,
 540                             &tfd->tfd_time.it_value);
 541                 }
 542                 callout_reset_sbt(&tfd->tfd_callout,
 543                     tstosbt(tfd->tfd_time.it_value),
 544                     0, timerfd_expire, tfd, C_ABSOLUTE);
 545         } else {
 546                 callout_stop(&tfd->tfd_callout);
 547         }
 548         tfd->tfd_count = 0;
 549         tfd->tfd_expired = false;
 550         tfd->tfd_jumped = TFD_NOJUMP;
 551         mtx_unlock(&tfd->tfd_lock);
 552
 553         fdrop(fp, td);
 554         return (error);
 555 }
 556
 557 int
 558 sys_timerfd_create(struct thread *td, struct timerfd_create_args *uap)
 559 {
 560         return (kern_timerfd_create(td, uap->clockid, uap->flags));
 561 }
 562
 563 int
 564 sys_timerfd_gettime(struct thread *td, struct timerfd_gettime_args *uap)
 565 {
 566         struct itimerspec curr_value;
 567         int error;
 568
 569         error = kern_timerfd_gettime(td, uap->fd, &curr_value);
 570         if (error == 0)
 571                 error = copyout(&curr_value, uap->curr_value,
 572                     sizeof(curr_value));
 573
 574         return (error);
 575 }
 576
 577 int
 578 sys_timerfd_settime(struct thread *td, struct timerfd_settime_args *uap)
 579 {
 580         struct itimerspec new_value, old_value;
 581         int error;
 582
 583         error = copyin(uap->new_value, &new_value, sizeof(new_value));
 584         if (error != 0)
 585                 return (error);
 586         if (uap->old_value == NULL) {
 587                 error = kern_timerfd_settime(td, uap->fd, uap->flags,
 588                     &new_value, NULL);
 589         } else {
 590                 error = kern_timerfd_settime(td, uap->fd, uap->flags,
 591                     &new_value, &old_value);
 592                 if (error == 0)
 593                         error = copyout(&old_value, uap->old_value,
 594                             sizeof(old_value));
 595         }
 596         return (error);
 597 }