/*      $NetBSD: sys_timerfd.c,v 1.11 2024/12/19 23:50:22 riastradh Exp $       */

/*-
* Copyright (c) 2020 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Jason R. Thorpe.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: sys_timerfd.c,v 1.11 2024/12/19 23:50:22 riastradh Exp $");

/*
* timerfd
*
* Timerfd objects are similar to POSIX timers, except they are associated
* with a file descriptor rather than a process.  Timerfd objects are
* created with the timerfd_create(2) system call, similar to timer_create(2).
* The timerfd analogues for timer_gettime(2) and timer_settime(2) are
* timerfd_gettime(2) and timerfd_settime(2), respectively.
*
* When a timerfd object's timer fires, an internal counter is incremented.
* When this counter is non-zero, the descriptor associated with the timerfd
* object is "readable".  Note that this is slightly different than the
* POSIX timer "overrun" counter, which only increments if the timer fires
* again while the notification signal is already pending.  Thus, we are
* responsible for incrementing the "overrun" counter each time the timerfd
* timer fires.
*
* This implementation is API compatible with the Linux timerfd interface.
*/

#include <sys/param.h>
#include <sys/types.h>
#include <sys/condvar.h>
#include <sys/file.h>
#include <sys/filedesc.h>
#include <sys/kauth.h>
#include <sys/mutex.h>
#include <sys/poll.h>
#include <sys/proc.h>
#include <sys/select.h>
#include <sys/stat.h>
#include <sys/syscallargs.h>
#include <sys/timerfd.h>
#include <sys/uio.h>

/* N.B. all timerfd state is protected by itimer_lock() */
struct timerfd {
       struct itimer   tfd_itimer;
       kcondvar_t      tfd_read_wait;
       struct selinfo  tfd_read_sel;
       int64_t         tfd_nwaiters;
       bool            tfd_cancel_on_set;
       bool            tfd_cancelled;
       bool            tfd_restarting;

       /*
        * Information kept for stat(2).
        */
       struct timespec tfd_btime;      /* time created */
       struct timespec tfd_mtime;      /* last timerfd_settime() */
       struct timespec tfd_atime;      /* last read */
};

static void     timerfd_wake(struct timerfd *);

static inline uint64_t
timerfd_fire_count(const struct timerfd * const tfd)
{
       return (unsigned int)tfd->tfd_itimer.it_overruns;
}

static inline bool
timerfd_is_readable(const struct timerfd * const tfd)
{
       return tfd->tfd_itimer.it_overruns != 0 || tfd->tfd_cancelled;
}

/*
* timerfd_fire:
*
*      Called when the timerfd's timer fires.
*
*      Called from a callout with itimer lock held.
*/
static void
timerfd_fire(struct itimer * const it)
{
       struct timerfd * const tfd =
           container_of(it, struct timerfd, tfd_itimer);

       it->it_overruns++;
       timerfd_wake(tfd);
}

/*
* timerfd_realtime_changed:
*
*      Called when CLOCK_REALTIME is changed with clock_settime()
*      or settimeofday().
*
*      Called with itimer lock held.
*/
static void
timerfd_realtime_changed(struct itimer * const it)
{
       struct timerfd * const tfd =
           container_of(it, struct timerfd, tfd_itimer);

       /* Should only be called when timer is armed. */
       KASSERT(timespecisset(&it->it_time.it_value));

       if (tfd->tfd_cancel_on_set) {
               tfd->tfd_cancelled = true;
               timerfd_wake(tfd);
       }
}

static const struct itimer_ops timerfd_itimer_monotonic_ops = {
       .ito_fire = timerfd_fire,
};

static const struct itimer_ops timerfd_itimer_realtime_ops = {
       .ito_fire = timerfd_fire,
       .ito_realtime_changed = timerfd_realtime_changed,
};

/*
* timerfd_create:
*
*      Create a timerfd object.
*/
static struct timerfd *
timerfd_create(clockid_t const clock_id, int const flags)
{
       struct timerfd * const tfd = kmem_zalloc(sizeof(*tfd), KM_SLEEP);

       KASSERT(clock_id == CLOCK_REALTIME || clock_id == CLOCK_MONOTONIC);

       cv_init(&tfd->tfd_read_wait, "tfdread");
       selinit(&tfd->tfd_read_sel);
       getnanotime(&tfd->tfd_btime);

       /* Caller deals with TFD_CLOEXEC and TFD_NONBLOCK. */

       itimer_lock();
       itimer_init(&tfd->tfd_itimer,
           clock_id == CLOCK_REALTIME ? &timerfd_itimer_realtime_ops
                                      : &timerfd_itimer_monotonic_ops,
           clock_id, NULL);
       itimer_unlock();

       return tfd;
}

/*
* timerfd_destroy:
*
*      Destroy a timerfd object.
*/
static void
timerfd_destroy(struct timerfd * const tfd)
{

       KASSERT(tfd->tfd_nwaiters == 0);

       itimer_lock();
       itimer_poison(&tfd->tfd_itimer);
       itimer_fini(&tfd->tfd_itimer);  /* drops itimer lock */

       cv_destroy(&tfd->tfd_read_wait);

       seldestroy(&tfd->tfd_read_sel);

       kmem_free(tfd, sizeof(*tfd));
}

/*
* timerfd_wait:
*
*      Block on a timerfd.  Handles non-blocking, as well as
*      the restart cases.
*/
static int
timerfd_wait(struct timerfd * const tfd, int const fflag)
{
       extern kmutex_t itimer_mutex;   /* XXX */
       int error;

       if (fflag & FNONBLOCK) {
               return EAGAIN;
       }

       /*
        * We're going to block.  Check if we need to return ERESTART.
        */
       if (tfd->tfd_restarting) {
               return ERESTART;
       }

       tfd->tfd_nwaiters++;
       KASSERT(tfd->tfd_nwaiters > 0);
       error = cv_wait_sig(&tfd->tfd_read_wait, &itimer_mutex);
       tfd->tfd_nwaiters--;
       KASSERT(tfd->tfd_nwaiters >= 0);

       /*
        * If a restart was triggered while we were asleep, we need
        * to return ERESTART if no other error was returned.
        */
       if (tfd->tfd_restarting) {
               if (error == 0) {
                       error = ERESTART;
               }
       }

       return error;
}

/*
* timerfd_wake:
*
*      Wake LWPs blocked on a timerfd.
*/
static void
timerfd_wake(struct timerfd * const tfd)
{

       if (tfd->tfd_nwaiters) {
               cv_broadcast(&tfd->tfd_read_wait);
       }
       selnotify(&tfd->tfd_read_sel, POLLIN | POLLRDNORM, NOTE_SUBMIT);
}

/*
* timerfd file operations
*/

static int
timerfd_fop_read(file_t * const fp, off_t * const offset,
   struct uio * const uio, kauth_cred_t const cred, int const flags)
{
       struct timerfd * const tfd = fp->f_timerfd;
       struct itimer * const it = &tfd->tfd_itimer;
       int const fflag = fp->f_flag;
       uint64_t return_value;
       int error;

       if (uio->uio_resid < sizeof(uint64_t)) {
               return EINVAL;
       }

       itimer_lock();

       while (!timerfd_is_readable(tfd)) {
               if ((error = timerfd_wait(tfd, fflag)) != 0) {
                       itimer_unlock();
                       return error;
               }
       }

       if (tfd->tfd_cancelled) {
               itimer_unlock();
               return ECANCELED;
       }

       return_value = timerfd_fire_count(tfd);
       it->it_overruns = 0;

       getnanotime(&tfd->tfd_atime);

       itimer_unlock();

       error = uiomove(&return_value, sizeof(return_value), uio);

       return error;
}

static int
timerfd_fop_ioctl(file_t * const fp, unsigned long const cmd, void * const data)
{
       struct timerfd * const tfd = fp->f_timerfd;
       int error = 0;

       switch (cmd) {
       case FIONBIO:
               break;

       case FIONREAD:
               itimer_lock();
               *(int *)data = timerfd_is_readable(tfd) ? sizeof(uint64_t) : 0;
               itimer_unlock();
               break;

       case TFD_IOC_SET_TICKS: {
               const uint64_t * const new_ticksp = data;
               if (*new_ticksp > INT_MAX) {
                       return EINVAL;
               }
               itimer_lock();
               tfd->tfd_itimer.it_overruns = (int)*new_ticksp;
               itimer_unlock();
               break;
           }

       default:
               error = EPASSTHROUGH;
       }

       return error;
}

static int
timerfd_fop_poll(file_t * const fp, int const events)
{
       struct timerfd * const tfd = fp->f_timerfd;
       int revents = 0;

       if (events & (POLLIN | POLLRDNORM)) {
               itimer_lock();
               if (timerfd_is_readable(tfd)) {
                       revents |= events & (POLLIN | POLLRDNORM);
               } else {
                       selrecord(curlwp, &tfd->tfd_read_sel);
               }
               itimer_unlock();
       }

       return revents;
}

static int
timerfd_fop_stat(file_t * const fp, struct stat * const st)
{
       struct timerfd * const tfd = fp->f_timerfd;

       memset(st, 0, sizeof(*st));

       itimer_lock();
       st->st_size = (off_t)timerfd_fire_count(tfd);
       st->st_atimespec = tfd->tfd_atime;
       st->st_mtimespec = tfd->tfd_mtime;
       itimer_unlock();

       st->st_blksize = sizeof(uint64_t);
       st->st_mode = S_IFIFO | S_IRUSR | S_IWUSR;
       st->st_blocks = 1;
       st->st_birthtimespec = tfd->tfd_btime;
       st->st_ctimespec = st->st_mtimespec;
       st->st_uid = kauth_cred_geteuid(fp->f_cred);
       st->st_gid = kauth_cred_getegid(fp->f_cred);

       return 0;
}

static int
timerfd_fop_close(file_t * const fp)
{
       struct timerfd * const tfd = fp->f_timerfd;

       fp->f_timerfd = NULL;
       timerfd_destroy(tfd);

       return 0;
}

static void
timerfd_filt_read_detach(struct knote * const kn)
{
       struct timerfd * const tfd = ((file_t *)kn->kn_obj)->f_timerfd;

       itimer_lock();
       KASSERT(kn->kn_hook == tfd);
       selremove_knote(&tfd->tfd_read_sel, kn);
       itimer_unlock();
}

static int
timerfd_filt_read(struct knote * const kn, long const hint)
{
       struct timerfd * const tfd = ((file_t *)kn->kn_obj)->f_timerfd;
       int rv;

       if (hint & NOTE_SUBMIT) {
               KASSERT(itimer_lock_held());
       } else {
               itimer_lock();
       }

       kn->kn_data = (int64_t)timerfd_fire_count(tfd);
       rv = kn->kn_data != 0;

       if ((hint & NOTE_SUBMIT) == 0) {
               itimer_unlock();
       }

       return rv;
}

static const struct filterops timerfd_read_filterops = {
       .f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE,
       .f_detach = timerfd_filt_read_detach,
       .f_event = timerfd_filt_read,
};

static int
timerfd_fop_kqfilter(file_t * const fp, struct knote * const kn)
{
       struct timerfd * const tfd = ((file_t *)kn->kn_obj)->f_timerfd;
       struct selinfo *sel;

       switch (kn->kn_filter) {
       case EVFILT_READ:
               sel = &tfd->tfd_read_sel;
               kn->kn_fop = &timerfd_read_filterops;
               break;

       default:
               return EINVAL;
       }

       kn->kn_hook = tfd;

       itimer_lock();
       selrecord_knote(sel, kn);
       itimer_unlock();

       return 0;
}

static void
timerfd_fop_restart(file_t * const fp)
{
       struct timerfd * const tfd = fp->f_timerfd;

       /*
        * Unblock blocked reads in order to allow close() to complete.
        * System calls return ERESTART so that the fd is revalidated.
        */

       itimer_lock();

       if (tfd->tfd_nwaiters != 0) {
               tfd->tfd_restarting = true;
               cv_broadcast(&tfd->tfd_read_wait);
       }

       itimer_unlock();
}

static const struct fileops timerfd_fileops = {
       .fo_name = "timerfd",
       .fo_read = timerfd_fop_read,
       .fo_write = fbadop_write,
       .fo_ioctl = timerfd_fop_ioctl,
       .fo_fcntl = fnullop_fcntl,
       .fo_poll = timerfd_fop_poll,
       .fo_stat = timerfd_fop_stat,
       .fo_close = timerfd_fop_close,
       .fo_kqfilter = timerfd_fop_kqfilter,
       .fo_restart = timerfd_fop_restart,
};

/*
* timerfd_create(2) system call
*/
int
do_timerfd_create(struct lwp * const l, clockid_t const clock_id,
   int const flags, register_t *retval)
{
       file_t *fp;
       int fd, error;

       if (flags & ~(TFD_CLOEXEC | TFD_NONBLOCK)) {
               return EINVAL;
       }

       switch (clock_id) {
       case CLOCK_REALTIME:
       case CLOCK_MONOTONIC:
               /* allowed */
               break;

       default:
               return EINVAL;
       }

       if ((error = fd_allocfile(&fp, &fd)) != 0) {
               return error;
       }

       fp->f_flag = FREAD;
       if (flags & TFD_NONBLOCK) {
               fp->f_flag |= FNONBLOCK;
       }
       fp->f_type = DTYPE_TIMERFD;
       fp->f_ops = &timerfd_fileops;
       fp->f_timerfd = timerfd_create(clock_id, flags);
       fd_set_exclose(l, fd, !!(flags & TFD_CLOEXEC));
       fd_affix(curproc, fp, fd);

       *retval = fd;
       return 0;
}

int
sys_timerfd_create(struct lwp *l, const struct sys_timerfd_create_args *uap,
   register_t *retval)
{
       /* {
               syscallarg(clockid_t) clock_id;
               syscallarg(int) flags;
       } */

       return do_timerfd_create(l, SCARG(uap, clock_id), SCARG(uap, flags),
           retval);
}

/*
* timerfd_gettime(2) system call.
*/
int
do_timerfd_gettime(struct lwp *l, int fd, struct itimerspec *curr_value,
   register_t *retval)
{
       file_t *fp;

       if ((fp = fd_getfile(fd)) == NULL) {
               return EBADF;
       }

       if (fp->f_ops != &timerfd_fileops) {
               fd_putfile(fd);
               return EINVAL;
       }

       struct timerfd * const tfd = fp->f_timerfd;
       itimer_lock();
       itimer_gettime(&tfd->tfd_itimer, curr_value);
       itimer_unlock();

       fd_putfile(fd);
       return 0;
}

int
sys_timerfd_gettime(struct lwp *l, const struct sys_timerfd_gettime_args *uap,
   register_t *retval)
{
       /* {
               syscallarg(int) fd;
               syscallarg(struct itimerspec *) curr_value;
       } */

       struct itimerspec oits;
       int error;

       error = do_timerfd_gettime(l, SCARG(uap, fd), &oits, retval);
       if (error == 0) {
               error = copyout(&oits, SCARG(uap, curr_value), sizeof(oits));
       }
       return error;
}

/*
* timerfd_settime(2) system call.
*/
int
do_timerfd_settime(struct lwp *l, int fd, int flags,
   const struct itimerspec *new_value, struct itimerspec *old_value,
   register_t *retval)
{
       struct itimerspec value = *new_value;
       file_t *fp;
       int error;

       if (flags & ~(TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET)) {
               return EINVAL;
       }
       if (itimespecfix(&value.it_value) != 0 ||
           itimespecfix(&value.it_interval) != 0) {
               return EINVAL;
       }

       if ((fp = fd_getfile(fd)) == NULL) {
               return EBADF;
       }

       if (fp->f_ops != &timerfd_fileops) {
               fd_putfile(fd);
               return EINVAL;
       }

       struct timerfd * const tfd = fp->f_timerfd;
       struct itimer * const it = &tfd->tfd_itimer;

       itimer_lock();

restart:
       if (old_value != NULL) {
               itimer_gettime(it, old_value);
       }
       it->it_time = value;

       /*
        * If we've been passed a relative value, convert it to an
        * absolute, as that's what the itimer facility expects for
        * non-virtual timers.  Also ensure that this doesn't set it
        * to zero or lets it go negative.
        * XXXJRT re-factor.
        */
       if (timespecisset(&it->it_time.it_value) &&
           (flags & TFD_TIMER_ABSTIME) == 0) {
               struct timespec now;
               if (it->it_clockid == CLOCK_REALTIME) {
                       getnanotime(&now);
               } else { /* CLOCK_MONOTONIC */
                       getnanouptime(&now);
               }
               timespecadd(&it->it_time.it_value, &now,
                   &it->it_time.it_value);
       }

       error = itimer_settime(it);
       if (error == ERESTART) {
               goto restart;
       }
       KASSERT(error == 0);

       /* Reset the expirations counter. */
       it->it_overruns = 0;

       if (it->it_clockid == CLOCK_REALTIME) {
               tfd->tfd_cancelled = false;
               tfd->tfd_cancel_on_set = !!(flags & TFD_TIMER_CANCEL_ON_SET);
       }

       getnanotime(&tfd->tfd_mtime);
       itimer_unlock();

       fd_putfile(fd);
       return error;
}

int
sys_timerfd_settime(struct lwp *l, const struct sys_timerfd_settime_args *uap,
   register_t *retval)
{
       /* {
               syscallarg(int) fd;
               syscallarg(int) flags;
               syscallarg(const struct itimerspec *) new_value;
               syscallarg(struct itimerspec *) old_value;
       } */

       struct itimerspec nits, oits, *oitsp = NULL;
       int error;

       error = copyin(SCARG(uap, new_value), &nits, sizeof(nits));
       if (error) {
               return error;
       }

       if (SCARG(uap, old_value) != NULL) {
               oitsp = &oits;
       }

       error = do_timerfd_settime(l, SCARG(uap, fd), SCARG(uap, flags),
           &nits, oitsp, retval);
       if (error == 0 && oitsp != NULL) {
               error = copyout(oitsp, SCARG(uap, old_value), sizeof(*oitsp));
       }
       return error;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.