/*      $NetBSD: sys_eventfd.c,v 1.11 2023/11/19 17:16:00 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_eventfd.c,v 1.11 2023/11/19 17:16:00 riastradh Exp $");

/*
* eventfd
*
* Eventfd objects present a simple counting object associated with a
* file descriptor.  Writes and reads to this file descriptor increment
* and decrement the count, respectively.  When the count is non-zero,
* the descriptor is considered "readable", and when less than the max
* value (EVENTFD_MAXVAL), is considered "writable".
*
* This implementation is API compatible with the Linux eventfd(2)
* interface.
*/

#include <sys/param.h>
#include <sys/types.h>
#include <sys/condvar.h>
#include <sys/eventfd.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/uio.h>

struct eventfd {
       kmutex_t        efd_lock;
       kcondvar_t      efd_read_wait;
       kcondvar_t      efd_write_wait;
       struct selinfo  efd_read_sel;
       struct selinfo  efd_write_sel;
       eventfd_t       efd_val;
       int64_t         efd_nwaiters;
       bool            efd_restarting;
       bool            efd_is_semaphore;

       /*
        * Information kept for stat(2).
        */
       struct timespec efd_btime;      /* time created */
       struct timespec efd_mtime;      /* last write */
       struct timespec efd_atime;      /* last read */
};

#define EVENTFD_MAXVAL  (UINT64_MAX - 1)

/*
* eventfd_create:
*
*      Create an eventfd object.
*/
static struct eventfd *
eventfd_create(unsigned int const val, int const flags)
{
       struct eventfd * const efd = kmem_zalloc(sizeof(*efd), KM_SLEEP);

       mutex_init(&efd->efd_lock, MUTEX_DEFAULT, IPL_NONE);
       cv_init(&efd->efd_read_wait, "efdread");
       cv_init(&efd->efd_write_wait, "efdwrite");
       selinit(&efd->efd_read_sel);
       selinit(&efd->efd_write_sel);
       efd->efd_val = val;
       efd->efd_is_semaphore = !!(flags & EFD_SEMAPHORE);
       getnanotime(&efd->efd_btime);

       /* Caller deals with EFD_CLOEXEC and EFD_NONBLOCK. */

       return efd;
}

/*
* eventfd_destroy:
*
*      Destroy an eventfd object.
*/
static void
eventfd_destroy(struct eventfd * const efd)
{

       KASSERT(efd->efd_nwaiters == 0);

       cv_destroy(&efd->efd_read_wait);
       cv_destroy(&efd->efd_write_wait);

       seldestroy(&efd->efd_read_sel);
       seldestroy(&efd->efd_write_sel);

       mutex_destroy(&efd->efd_lock);

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

/*
* eventfd_wait:
*
*      Block on an eventfd.  Handles non-blocking, as well as
*      the restart cases.
*/
static int
eventfd_wait(struct eventfd * const efd, int const fflag, bool const is_write)
{
       kcondvar_t *waitcv;
       int error;

       if (fflag & FNONBLOCK) {
               return EAGAIN;
       }

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

       if (is_write) {
               waitcv = &efd->efd_write_wait;
       } else {
               waitcv = &efd->efd_read_wait;
       }

       efd->efd_nwaiters++;
       KASSERT(efd->efd_nwaiters > 0);
       error = cv_wait_sig(waitcv, &efd->efd_lock);
       efd->efd_nwaiters--;
       KASSERT(efd->efd_nwaiters >= 0);

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

       return error;
}

/*
* eventfd_wake:
*
*      Wake LWPs block on an eventfd.
*/
static void
eventfd_wake(struct eventfd * const efd, bool const is_write)
{
       kcondvar_t *waitcv = NULL;
       struct selinfo *sel;
       int pollev;

       if (is_write) {
               waitcv = &efd->efd_read_wait;
               sel = &efd->efd_read_sel;
               pollev = POLLIN | POLLRDNORM;
       } else {
               waitcv = &efd->efd_write_wait;
               sel = &efd->efd_write_sel;
               pollev = POLLOUT | POLLWRNORM;
       }
       cv_broadcast(waitcv);
       selnotify(sel, pollev, NOTE_SUBMIT);
}

/*
* eventfd file operations
*/

static int
eventfd_fop_read(file_t * const fp, off_t * const offset,
   struct uio * const uio, kauth_cred_t const cred, int const flags)
{
       struct eventfd * const efd = fp->f_eventfd;
       int const fflag = fp->f_flag;
       eventfd_t return_value;
       int error;

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

       mutex_enter(&efd->efd_lock);

       while (efd->efd_val == 0) {
               if ((error = eventfd_wait(efd, fflag, false)) != 0) {
                       mutex_exit(&efd->efd_lock);
                       return error;
               }
       }

       if (efd->efd_is_semaphore) {
               return_value = 1;
               efd->efd_val--;
       } else {
               return_value = efd->efd_val;
               efd->efd_val = 0;
       }

       getnanotime(&efd->efd_atime);
       eventfd_wake(efd, false);

       mutex_exit(&efd->efd_lock);

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

       return error;
}

static int
eventfd_fop_write(file_t * const fp, off_t * const offset,
   struct uio * const uio, kauth_cred_t const cred, int const flags)
{
       struct eventfd * const efd = fp->f_eventfd;
       int const fflag = fp->f_flag;
       eventfd_t write_value;
       int error;

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

       if ((error = uiomove(&write_value, sizeof(write_value), uio)) != 0) {
               return error;
       }

       if (write_value > EVENTFD_MAXVAL) {
               error = EINVAL;
               goto out;
       }

       mutex_enter(&efd->efd_lock);

       KASSERT(efd->efd_val <= EVENTFD_MAXVAL);
       while ((EVENTFD_MAXVAL - efd->efd_val) < write_value) {
               if ((error = eventfd_wait(efd, fflag, true)) != 0) {
                       mutex_exit(&efd->efd_lock);
                       goto out;
               }
       }

       efd->efd_val += write_value;
       KASSERT(efd->efd_val <= EVENTFD_MAXVAL);

       getnanotime(&efd->efd_mtime);
       eventfd_wake(efd, true);

       mutex_exit(&efd->efd_lock);

out:
       if (error) {
               /*
                * Undo the effect of uiomove() so that the error
                * gets reported correctly; see dofilewrite().
                */
               uio->uio_resid += sizeof(write_value);
       }
       return error;
}

static int
eventfd_ioctl(file_t * const fp, u_long const cmd, void * const data)
{
       struct eventfd * const efd = fp->f_eventfd;

       switch (cmd) {
       case FIONBIO:
               return 0;

       case FIONREAD:
               mutex_enter(&efd->efd_lock);
               *(int *)data = efd->efd_val != 0 ? sizeof(eventfd_t) : 0;
               mutex_exit(&efd->efd_lock);
               return 0;

       case FIONWRITE:
               *(int *)data = 0;
               return 0;

       case FIONSPACE:
               /*
                * FIONSPACE doesn't really work for eventfd, because the
                * writability depends on the contents (value) being written.
                */
               break;

       default:
               break;
       }

       return EPASSTHROUGH;
}

static int
eventfd_fop_poll(file_t * const fp, int const events)
{
       struct eventfd * const efd = fp->f_eventfd;
       int revents = 0;

       /*
        * Note that Linux will return POLLERR if the eventfd count
        * overflows, but that is not possible in the normal read/write
        * API, only with Linux kernel-internal interfaces.  So, this
        * implementation never returns POLLERR.
        *
        * Also note that the Linux eventfd(2) man page does not
        * specifically discuss returning POLLRDNORM, but we check
        * for that event in addition to POLLIN.
        */

       mutex_enter(&efd->efd_lock);

       if (events & (POLLIN | POLLRDNORM)) {
               if (efd->efd_val != 0) {
                       revents |= events & (POLLIN | POLLRDNORM);
               } else {
                       selrecord(curlwp, &efd->efd_read_sel);
               }
       }

       if (events & (POLLOUT | POLLWRNORM)) {
               if (efd->efd_val < EVENTFD_MAXVAL) {
                       revents |= events & (POLLOUT | POLLWRNORM);
               } else {
                       selrecord(curlwp, &efd->efd_write_sel);
               }
       }

       mutex_exit(&efd->efd_lock);

       return revents;
}

static int
eventfd_fop_stat(file_t * const fp, struct stat * const st)
{
       struct eventfd * const efd = fp->f_eventfd;

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

       mutex_enter(&efd->efd_lock);
       st->st_size = (off_t)efd->efd_val;
       st->st_blksize = sizeof(eventfd_t);
       st->st_mode = S_IFIFO | S_IRUSR | S_IWUSR;
       st->st_blocks = 1;
       st->st_birthtimespec = st->st_ctimespec = efd->efd_btime;
       st->st_atimespec = efd->efd_atime;
       st->st_mtimespec = efd->efd_mtime;
       st->st_uid = kauth_cred_geteuid(fp->f_cred);
       st->st_gid = kauth_cred_getegid(fp->f_cred);
       mutex_exit(&efd->efd_lock);

       return 0;
}

static int
eventfd_fop_close(file_t * const fp)
{
       struct eventfd * const efd = fp->f_eventfd;

       fp->f_eventfd = NULL;
       eventfd_destroy(efd);

       return 0;
}

static void
eventfd_filt_read_detach(struct knote * const kn)
{
       struct eventfd * const efd = ((file_t *)kn->kn_obj)->f_eventfd;

       mutex_enter(&efd->efd_lock);
       KASSERT(kn->kn_hook == efd);
       selremove_knote(&efd->efd_read_sel, kn);
       mutex_exit(&efd->efd_lock);
}

static int
eventfd_filt_read(struct knote * const kn, long const hint)
{
       struct eventfd * const efd = ((file_t *)kn->kn_obj)->f_eventfd;
       int rv;

       if (hint & NOTE_SUBMIT) {
               KASSERT(mutex_owned(&efd->efd_lock));
       } else {
               mutex_enter(&efd->efd_lock);
       }

       kn->kn_data = (int64_t)efd->efd_val;
       rv = (eventfd_t)kn->kn_data > 0;

       if ((hint & NOTE_SUBMIT) == 0) {
               mutex_exit(&efd->efd_lock);
       }

       return rv;
}

static const struct filterops eventfd_read_filterops = {
       .f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE,
       .f_detach = eventfd_filt_read_detach,
       .f_event = eventfd_filt_read,
};

static void
eventfd_filt_write_detach(struct knote * const kn)
{
       struct eventfd * const efd = ((file_t *)kn->kn_obj)->f_eventfd;

       mutex_enter(&efd->efd_lock);
       KASSERT(kn->kn_hook == efd);
       selremove_knote(&efd->efd_write_sel, kn);
       mutex_exit(&efd->efd_lock);
}

static int
eventfd_filt_write(struct knote * const kn, long const hint)
{
       struct eventfd * const efd = ((file_t *)kn->kn_obj)->f_eventfd;
       int rv;

       if (hint & NOTE_SUBMIT) {
               KASSERT(mutex_owned(&efd->efd_lock));
       } else {
               mutex_enter(&efd->efd_lock);
       }

       kn->kn_data = (int64_t)efd->efd_val;
       rv = (eventfd_t)kn->kn_data < EVENTFD_MAXVAL;

       if ((hint & NOTE_SUBMIT) == 0) {
               mutex_exit(&efd->efd_lock);
       }

       return rv;
}

static const struct filterops eventfd_write_filterops = {
       .f_flags = FILTEROP_ISFD | FILTEROP_MPSAFE,
       .f_detach = eventfd_filt_write_detach,
       .f_event = eventfd_filt_write,
};

static int
eventfd_fop_kqfilter(file_t * const fp, struct knote * const kn)
{
       struct eventfd * const efd = ((file_t *)kn->kn_obj)->f_eventfd;
       struct selinfo *sel;

       switch (kn->kn_filter) {
       case EVFILT_READ:
               sel = &efd->efd_read_sel;
               kn->kn_fop = &eventfd_read_filterops;
               break;

       case EVFILT_WRITE:
               sel = &efd->efd_write_sel;
               kn->kn_fop = &eventfd_write_filterops;
               break;

       default:
               return EINVAL;
       }

       kn->kn_hook = efd;

       mutex_enter(&efd->efd_lock);
       selrecord_knote(sel, kn);
       mutex_exit(&efd->efd_lock);

       return 0;
}

static void
eventfd_fop_restart(file_t * const fp)
{
       struct eventfd * const efd = fp->f_eventfd;

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

       mutex_enter(&efd->efd_lock);

       if (efd->efd_nwaiters != 0) {
               efd->efd_restarting = true;
               cv_broadcast(&efd->efd_read_wait);
               cv_broadcast(&efd->efd_write_wait);
       }

       mutex_exit(&efd->efd_lock);
}

static const struct fileops eventfd_fileops = {
       .fo_name = "eventfd",
       .fo_read = eventfd_fop_read,
       .fo_write = eventfd_fop_write,
       .fo_ioctl = eventfd_ioctl,
       .fo_fcntl = fnullop_fcntl,
       .fo_poll = eventfd_fop_poll,
       .fo_stat = eventfd_fop_stat,
       .fo_close = eventfd_fop_close,
       .fo_kqfilter = eventfd_fop_kqfilter,
       .fo_restart = eventfd_fop_restart,
};

/*
* eventfd(2) system call
*/
int
do_eventfd(struct lwp * const l, unsigned int const val, int const flags,
   register_t *retval)
{
       file_t *fp;
       int fd, error;

       if (flags & ~(EFD_CLOEXEC | EFD_NONBLOCK | EFD_SEMAPHORE)) {
               return EINVAL;
       }

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

       fp->f_flag = FREAD | FWRITE;
       if (flags & EFD_NONBLOCK) {
               fp->f_flag |= FNONBLOCK;
       }
       fp->f_type = DTYPE_EVENTFD;
       fp->f_ops = &eventfd_fileops;
       fp->f_eventfd = eventfd_create(val, flags);
       fd_set_exclose(l, fd, !!(flags & EFD_CLOEXEC));
       fd_affix(curproc, fp, fd);

       *retval = fd;
       return 0;
}

int
sys_eventfd(struct lwp *l, const struct sys_eventfd_args *uap,
   register_t *retval)
{
       /* {
               syscallarg(unsigned int) val;
               syscallarg(int) flags;
       } */

       return do_eventfd(l, SCARG(uap, val), SCARG(uap, flags), retval);
}

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.