2015-05-24 16:41:39 +00:00
|
|
|
/*-
|
|
|
|
* Copyright (c) 2007 Roman Divacky
|
|
|
|
* Copyright (c) 2014 Dmitry Chagin
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* 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 AUTHOR 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 AUTHOR 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>
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
|
|
#include "opt_compat.h"
|
|
|
|
|
|
|
|
#include <sys/param.h>
|
|
|
|
#include <sys/systm.h>
|
|
|
|
#include <sys/imgact.h>
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
#include <sys/limits.h>
|
|
|
|
#include <sys/lock.h>
|
|
|
|
#include <sys/mutex.h>
|
2017-02-26 09:48:18 +00:00
|
|
|
#include <sys/callout.h>
|
2016-09-19 18:44:43 +00:00
|
|
|
#include <sys/capsicum.h>
|
2015-05-24 16:41:39 +00:00
|
|
|
#include <sys/types.h>
|
2015-05-24 17:40:14 +00:00
|
|
|
#include <sys/user.h>
|
2015-05-24 16:41:39 +00:00
|
|
|
#include <sys/file.h>
|
|
|
|
#include <sys/filedesc.h>
|
2016-03-26 19:15:23 +00:00
|
|
|
#include <sys/filio.h>
|
2015-05-24 16:41:39 +00:00
|
|
|
#include <sys/errno.h>
|
|
|
|
#include <sys/event.h>
|
2015-05-24 16:49:14 +00:00
|
|
|
#include <sys/poll.h>
|
2015-05-24 16:41:39 +00:00
|
|
|
#include <sys/proc.h>
|
2015-05-24 16:49:14 +00:00
|
|
|
#include <sys/selinfo.h>
|
2015-05-24 16:41:39 +00:00
|
|
|
#include <sys/sx.h>
|
|
|
|
#include <sys/syscallsubr.h>
|
|
|
|
#include <sys/timespec.h>
|
|
|
|
|
|
|
|
#ifdef COMPAT_LINUX32
|
|
|
|
#include <machine/../linux32/linux.h>
|
|
|
|
#include <machine/../linux32/linux32_proto.h>
|
|
|
|
#else
|
|
|
|
#include <machine/../linux/linux.h>
|
|
|
|
#include <machine/../linux/linux_proto.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <compat/linux/linux_emul.h>
|
|
|
|
#include <compat/linux/linux_event.h>
|
|
|
|
#include <compat/linux/linux_file.h>
|
2017-02-26 09:48:18 +00:00
|
|
|
#include <compat/linux/linux_timer.h>
|
2015-05-24 16:41:39 +00:00
|
|
|
#include <compat/linux/linux_util.h>
|
|
|
|
|
|
|
|
/*
|
|
|
|
* epoll defines 'struct epoll_event' with the field 'data' as 64 bits
|
|
|
|
* on all architectures. But on 32 bit architectures BSD 'struct kevent' only
|
|
|
|
* has 32 bit opaque pointer as 'udata' field. So we can't pass epoll supplied
|
|
|
|
* data verbatuim. Therefore we allocate 64-bit memory block to pass
|
|
|
|
* user supplied data for every file descriptor.
|
|
|
|
*/
|
|
|
|
|
|
|
|
typedef uint64_t epoll_udata_t;
|
|
|
|
|
|
|
|
struct epoll_emuldata {
|
|
|
|
uint32_t fdc; /* epoll udata max index */
|
|
|
|
epoll_udata_t udata[1]; /* epoll user data vector */
|
|
|
|
};
|
|
|
|
|
|
|
|
#define EPOLL_DEF_SZ 16
|
|
|
|
#define EPOLL_SIZE(fdn) \
|
|
|
|
(sizeof(struct epoll_emuldata)+(fdn) * sizeof(epoll_udata_t))
|
|
|
|
|
|
|
|
struct epoll_event {
|
|
|
|
uint32_t events;
|
|
|
|
epoll_udata_t data;
|
|
|
|
}
|
|
|
|
#if defined(__amd64__)
|
|
|
|
__attribute__((packed))
|
|
|
|
#endif
|
|
|
|
;
|
|
|
|
|
|
|
|
#define LINUX_MAX_EVENTS (INT_MAX / sizeof(struct epoll_event))
|
|
|
|
|
|
|
|
static void epoll_fd_install(struct thread *td, int fd, epoll_udata_t udata);
|
|
|
|
static int epoll_to_kevent(struct thread *td, struct file *epfp,
|
|
|
|
int fd, struct epoll_event *l_event, int *kev_flags,
|
|
|
|
struct kevent *kevent, int *nkevents);
|
|
|
|
static void kevent_to_epoll(struct kevent *kevent, struct epoll_event *l_event);
|
|
|
|
static int epoll_kev_copyout(void *arg, struct kevent *kevp, int count);
|
|
|
|
static int epoll_kev_copyin(void *arg, struct kevent *kevp, int count);
|
|
|
|
static int epoll_delete_event(struct thread *td, struct file *epfp,
|
|
|
|
int fd, int filter);
|
|
|
|
static int epoll_delete_all_events(struct thread *td, struct file *epfp,
|
|
|
|
int fd);
|
|
|
|
|
|
|
|
struct epoll_copyin_args {
|
|
|
|
struct kevent *changelist;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct epoll_copyout_args {
|
|
|
|
struct epoll_event *leventlist;
|
|
|
|
struct proc *p;
|
|
|
|
uint32_t count;
|
|
|
|
int error;
|
|
|
|
};
|
|
|
|
|
2015-05-24 16:49:14 +00:00
|
|
|
/* eventfd */
|
|
|
|
typedef uint64_t eventfd_t;
|
|
|
|
|
|
|
|
static fo_rdwr_t eventfd_read;
|
|
|
|
static fo_rdwr_t eventfd_write;
|
|
|
|
static fo_ioctl_t eventfd_ioctl;
|
|
|
|
static fo_poll_t eventfd_poll;
|
|
|
|
static fo_kqfilter_t eventfd_kqfilter;
|
|
|
|
static fo_stat_t eventfd_stat;
|
|
|
|
static fo_close_t eventfd_close;
|
2015-05-24 17:40:14 +00:00
|
|
|
static fo_fill_kinfo_t eventfd_fill_kinfo;
|
2015-05-24 16:49:14 +00:00
|
|
|
|
|
|
|
static struct fileops eventfdops = {
|
|
|
|
.fo_read = eventfd_read,
|
|
|
|
.fo_write = eventfd_write,
|
2017-02-26 09:42:34 +00:00
|
|
|
.fo_truncate = invfo_truncate,
|
2015-05-24 16:49:14 +00:00
|
|
|
.fo_ioctl = eventfd_ioctl,
|
|
|
|
.fo_poll = eventfd_poll,
|
|
|
|
.fo_kqfilter = eventfd_kqfilter,
|
|
|
|
.fo_stat = eventfd_stat,
|
|
|
|
.fo_close = eventfd_close,
|
|
|
|
.fo_chmod = invfo_chmod,
|
|
|
|
.fo_chown = invfo_chown,
|
|
|
|
.fo_sendfile = invfo_sendfile,
|
2015-05-24 17:40:14 +00:00
|
|
|
.fo_fill_kinfo = eventfd_fill_kinfo,
|
2015-05-24 16:49:14 +00:00
|
|
|
.fo_flags = DFLAG_PASSABLE
|
|
|
|
};
|
|
|
|
|
|
|
|
static void filt_eventfddetach(struct knote *kn);
|
|
|
|
static int filt_eventfdread(struct knote *kn, long hint);
|
|
|
|
static int filt_eventfdwrite(struct knote *kn, long hint);
|
|
|
|
|
|
|
|
static struct filterops eventfd_rfiltops = {
|
|
|
|
.f_isfd = 1,
|
|
|
|
.f_detach = filt_eventfddetach,
|
|
|
|
.f_event = filt_eventfdread
|
|
|
|
};
|
|
|
|
static struct filterops eventfd_wfiltops = {
|
|
|
|
.f_isfd = 1,
|
|
|
|
.f_detach = filt_eventfddetach,
|
|
|
|
.f_event = filt_eventfdwrite
|
|
|
|
};
|
|
|
|
|
2017-02-26 09:48:18 +00:00
|
|
|
/* timerfd */
|
|
|
|
typedef uint64_t timerfd_t;
|
|
|
|
|
|
|
|
static fo_rdwr_t timerfd_read;
|
|
|
|
static fo_poll_t timerfd_poll;
|
|
|
|
static fo_kqfilter_t timerfd_kqfilter;
|
|
|
|
static fo_stat_t timerfd_stat;
|
|
|
|
static fo_close_t timerfd_close;
|
|
|
|
static fo_fill_kinfo_t timerfd_fill_kinfo;
|
|
|
|
|
|
|
|
static struct fileops timerfdops = {
|
|
|
|
.fo_read = timerfd_read,
|
|
|
|
.fo_write = invfo_rdwr,
|
|
|
|
.fo_truncate = invfo_truncate,
|
2017-02-27 16:53:52 +00:00
|
|
|
.fo_ioctl = eventfd_ioctl,
|
2017-02-26 09:48:18 +00:00
|
|
|
.fo_poll = timerfd_poll,
|
|
|
|
.fo_kqfilter = timerfd_kqfilter,
|
|
|
|
.fo_stat = timerfd_stat,
|
|
|
|
.fo_close = timerfd_close,
|
|
|
|
.fo_chmod = invfo_chmod,
|
|
|
|
.fo_chown = invfo_chown,
|
|
|
|
.fo_sendfile = invfo_sendfile,
|
|
|
|
.fo_fill_kinfo = timerfd_fill_kinfo,
|
|
|
|
.fo_flags = DFLAG_PASSABLE
|
|
|
|
};
|
|
|
|
|
|
|
|
static void filt_timerfddetach(struct knote *kn);
|
|
|
|
static int filt_timerfdread(struct knote *kn, long hint);
|
|
|
|
|
|
|
|
static struct filterops timerfd_rfiltops = {
|
|
|
|
.f_isfd = 1,
|
|
|
|
.f_detach = filt_timerfddetach,
|
|
|
|
.f_event = filt_timerfdread
|
|
|
|
};
|
|
|
|
|
2015-05-24 16:49:14 +00:00
|
|
|
struct eventfd {
|
|
|
|
eventfd_t efd_count;
|
|
|
|
uint32_t efd_flags;
|
|
|
|
struct selinfo efd_sel;
|
|
|
|
struct mtx efd_lock;
|
|
|
|
};
|
|
|
|
|
2017-02-26 09:48:18 +00:00
|
|
|
struct timerfd {
|
|
|
|
clockid_t tfd_clockid;
|
|
|
|
struct itimerspec tfd_time;
|
|
|
|
struct callout tfd_callout;
|
|
|
|
timerfd_t tfd_count;
|
|
|
|
bool tfd_canceled;
|
|
|
|
struct selinfo tfd_sel;
|
|
|
|
struct mtx tfd_lock;
|
|
|
|
};
|
|
|
|
|
2015-05-24 16:49:14 +00:00
|
|
|
static int eventfd_create(struct thread *td, uint32_t initval, int flags);
|
2017-02-26 09:48:18 +00:00
|
|
|
static void linux_timerfd_expire(void *);
|
|
|
|
static void linux_timerfd_curval(struct timerfd *, struct itimerspec *);
|
2015-05-24 16:49:14 +00:00
|
|
|
|
2015-05-24 16:41:39 +00:00
|
|
|
|
|
|
|
static void
|
|
|
|
epoll_fd_install(struct thread *td, int fd, epoll_udata_t udata)
|
|
|
|
{
|
|
|
|
struct linux_pemuldata *pem;
|
|
|
|
struct epoll_emuldata *emd;
|
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
p = td->td_proc;
|
|
|
|
|
|
|
|
pem = pem_find(p);
|
|
|
|
KASSERT(pem != NULL, ("epoll proc emuldata not found.\n"));
|
|
|
|
|
|
|
|
LINUX_PEM_XLOCK(pem);
|
|
|
|
if (pem->epoll == NULL) {
|
|
|
|
emd = malloc(EPOLL_SIZE(fd), M_EPOLL, M_WAITOK);
|
|
|
|
emd->fdc = fd;
|
|
|
|
pem->epoll = emd;
|
|
|
|
} else {
|
|
|
|
emd = pem->epoll;
|
|
|
|
if (fd > emd->fdc) {
|
|
|
|
emd = realloc(emd, EPOLL_SIZE(fd), M_EPOLL, M_WAITOK);
|
|
|
|
emd->fdc = fd;
|
|
|
|
pem->epoll = emd;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
emd->udata[fd] = udata;
|
|
|
|
LINUX_PEM_XUNLOCK(pem);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
epoll_create_common(struct thread *td, int flags)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2015-08-05 07:36:50 +00:00
|
|
|
error = kern_kqueue(td, flags, NULL);
|
2017-02-26 09:42:34 +00:00
|
|
|
if (error != 0)
|
2015-05-24 16:41:39 +00:00
|
|
|
return (error);
|
|
|
|
|
|
|
|
epoll_fd_install(td, EPOLL_DEF_SZ, 0);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2018-06-15 14:41:51 +00:00
|
|
|
#ifdef LINUX_LEGACY_SYSCALLS
|
2015-05-24 16:41:39 +00:00
|
|
|
int
|
|
|
|
linux_epoll_create(struct thread *td, struct linux_epoll_create_args *args)
|
|
|
|
{
|
|
|
|
|
|
|
|
/*
|
|
|
|
* args->size is unused. Linux just tests it
|
|
|
|
* and then forgets it as well.
|
|
|
|
*/
|
|
|
|
if (args->size <= 0)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
return (epoll_create_common(td, 0));
|
|
|
|
}
|
2018-06-15 14:41:51 +00:00
|
|
|
#endif
|
2015-05-24 16:41:39 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
linux_epoll_create1(struct thread *td, struct linux_epoll_create1_args *args)
|
|
|
|
{
|
|
|
|
int flags;
|
|
|
|
|
|
|
|
if ((args->flags & ~(LINUX_O_CLOEXEC)) != 0)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
flags = 0;
|
|
|
|
if ((args->flags & LINUX_O_CLOEXEC) != 0)
|
|
|
|
flags |= O_CLOEXEC;
|
|
|
|
|
|
|
|
return (epoll_create_common(td, flags));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Structure converting function from epoll to kevent. */
|
|
|
|
static int
|
|
|
|
epoll_to_kevent(struct thread *td, struct file *epfp,
|
|
|
|
int fd, struct epoll_event *l_event, int *kev_flags,
|
|
|
|
struct kevent *kevent, int *nkevents)
|
|
|
|
{
|
|
|
|
uint32_t levents = l_event->events;
|
|
|
|
struct linux_pemuldata *pem;
|
|
|
|
struct proc *p;
|
|
|
|
|
|
|
|
/* flags related to how event is registered */
|
|
|
|
if ((levents & LINUX_EPOLLONESHOT) != 0)
|
2019-11-24 20:41:47 +00:00
|
|
|
*kev_flags |= EV_DISPATCH;
|
2015-05-24 16:41:39 +00:00
|
|
|
if ((levents & LINUX_EPOLLET) != 0)
|
|
|
|
*kev_flags |= EV_CLEAR;
|
2015-05-24 17:42:45 +00:00
|
|
|
if ((levents & LINUX_EPOLLERR) != 0)
|
|
|
|
*kev_flags |= EV_ERROR;
|
2015-06-20 05:40:35 +00:00
|
|
|
if ((levents & LINUX_EPOLLRDHUP) != 0)
|
|
|
|
*kev_flags |= EV_EOF;
|
2015-05-24 16:41:39 +00:00
|
|
|
|
|
|
|
/* flags related to what event is registered */
|
|
|
|
if ((levents & LINUX_EPOLL_EVRD) != 0) {
|
|
|
|
EV_SET(kevent++, fd, EVFILT_READ, *kev_flags, 0, 0, 0);
|
|
|
|
++(*nkevents);
|
|
|
|
}
|
|
|
|
if ((levents & LINUX_EPOLL_EVWR) != 0) {
|
|
|
|
EV_SET(kevent++, fd, EVFILT_WRITE, *kev_flags, 0, 0, 0);
|
|
|
|
++(*nkevents);
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((levents & ~(LINUX_EPOLL_EVSUP)) != 0) {
|
|
|
|
p = td->td_proc;
|
|
|
|
|
|
|
|
pem = pem_find(p);
|
|
|
|
KASSERT(pem != NULL, ("epoll proc emuldata not found.\n"));
|
|
|
|
KASSERT(pem->epoll != NULL, ("epoll proc epolldata not found.\n"));
|
|
|
|
|
|
|
|
LINUX_PEM_XLOCK(pem);
|
|
|
|
if ((pem->flags & LINUX_XUNSUP_EPOLL) == 0) {
|
|
|
|
pem->flags |= LINUX_XUNSUP_EPOLL;
|
|
|
|
LINUX_PEM_XUNLOCK(pem);
|
|
|
|
linux_msg(td, "epoll_ctl unsupported flags: 0x%x\n",
|
|
|
|
levents);
|
|
|
|
} else
|
|
|
|
LINUX_PEM_XUNLOCK(pem);
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
2018-02-05 17:29:12 +00:00
|
|
|
/*
|
2015-05-24 16:41:39 +00:00
|
|
|
* Structure converting function from kevent to epoll. In a case
|
|
|
|
* this is called on error in registration we store the error in
|
|
|
|
* event->data and pick it up later in linux_epoll_ctl().
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
kevent_to_epoll(struct kevent *kevent, struct epoll_event *l_event)
|
|
|
|
{
|
|
|
|
|
2015-05-24 17:42:45 +00:00
|
|
|
if ((kevent->flags & EV_ERROR) != 0) {
|
|
|
|
l_event->events = LINUX_EPOLLERR;
|
2015-05-24 16:41:39 +00:00
|
|
|
return;
|
2015-05-24 17:42:45 +00:00
|
|
|
}
|
2015-05-24 16:41:39 +00:00
|
|
|
|
2017-02-28 19:49:21 +00:00
|
|
|
/* XXX EPOLLPRI, EPOLLHUP */
|
2015-05-24 16:41:39 +00:00
|
|
|
switch (kevent->filter) {
|
|
|
|
case EVFILT_READ:
|
2017-02-28 19:49:21 +00:00
|
|
|
l_event->events = LINUX_EPOLLIN;
|
2015-06-20 05:40:35 +00:00
|
|
|
if ((kevent->flags & EV_EOF) != 0)
|
|
|
|
l_event->events |= LINUX_EPOLLRDHUP;
|
2015-05-24 16:41:39 +00:00
|
|
|
break;
|
|
|
|
case EVFILT_WRITE:
|
2017-02-28 19:49:21 +00:00
|
|
|
l_event->events = LINUX_EPOLLOUT;
|
2015-05-24 16:41:39 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-05 17:29:12 +00:00
|
|
|
/*
|
2015-05-24 16:41:39 +00:00
|
|
|
* Copyout callback used by kevent. This converts kevent
|
|
|
|
* events to epoll events and copies them back to the
|
|
|
|
* userspace. This is also called on error on registering
|
|
|
|
* of the filter.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
epoll_kev_copyout(void *arg, struct kevent *kevp, int count)
|
|
|
|
{
|
|
|
|
struct epoll_copyout_args *args;
|
|
|
|
struct linux_pemuldata *pem;
|
|
|
|
struct epoll_emuldata *emd;
|
|
|
|
struct epoll_event *eep;
|
|
|
|
int error, fd, i;
|
|
|
|
|
|
|
|
args = (struct epoll_copyout_args*) arg;
|
|
|
|
eep = malloc(sizeof(*eep) * count, M_EPOLL, M_WAITOK | M_ZERO);
|
|
|
|
|
|
|
|
pem = pem_find(args->p);
|
|
|
|
KASSERT(pem != NULL, ("epoll proc emuldata not found.\n"));
|
|
|
|
LINUX_PEM_SLOCK(pem);
|
|
|
|
emd = pem->epoll;
|
|
|
|
KASSERT(emd != NULL, ("epoll proc epolldata not found.\n"));
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++) {
|
|
|
|
kevent_to_epoll(&kevp[i], &eep[i]);
|
|
|
|
|
|
|
|
fd = kevp[i].ident;
|
|
|
|
KASSERT(fd <= emd->fdc, ("epoll user data vector"
|
|
|
|
" is too small.\n"));
|
|
|
|
eep[i].data = emd->udata[fd];
|
|
|
|
}
|
|
|
|
LINUX_PEM_SUNLOCK(pem);
|
|
|
|
|
|
|
|
error = copyout(eep, args->leventlist, count * sizeof(*eep));
|
|
|
|
if (error == 0) {
|
|
|
|
args->leventlist += count;
|
|
|
|
args->count += count;
|
|
|
|
} else if (args->error == 0)
|
|
|
|
args->error = error;
|
|
|
|
|
|
|
|
free(eep, M_EPOLL);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copyin callback used by kevent. This copies already
|
2018-02-05 17:29:12 +00:00
|
|
|
* converted filters from kernel memory to the kevent
|
2015-05-24 16:41:39 +00:00
|
|
|
* internal kernel memory. Hence the memcpy instead of
|
|
|
|
* copyin.
|
|
|
|
*/
|
|
|
|
static int
|
|
|
|
epoll_kev_copyin(void *arg, struct kevent *kevp, int count)
|
|
|
|
{
|
|
|
|
struct epoll_copyin_args *args;
|
|
|
|
|
|
|
|
args = (struct epoll_copyin_args*) arg;
|
2017-02-26 09:42:34 +00:00
|
|
|
|
2015-05-24 16:41:39 +00:00
|
|
|
memcpy(kevp, args->changelist, count * sizeof(*kevp));
|
|
|
|
args->changelist += count;
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Load epoll filter, convert it to kevent filter
|
|
|
|
* and load it into kevent subsystem.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
linux_epoll_ctl(struct thread *td, struct linux_epoll_ctl_args *args)
|
|
|
|
{
|
|
|
|
struct file *epfp, *fp;
|
|
|
|
struct epoll_copyin_args ciargs;
|
|
|
|
struct kevent kev[2];
|
|
|
|
struct kevent_copyops k_ops = { &ciargs,
|
|
|
|
NULL,
|
|
|
|
epoll_kev_copyin};
|
|
|
|
struct epoll_event le;
|
|
|
|
cap_rights_t rights;
|
|
|
|
int kev_flags;
|
|
|
|
int nchanges = 0;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (args->op != LINUX_EPOLL_CTL_DEL) {
|
|
|
|
error = copyin(args->event, &le, sizeof(le));
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
error = fget(td, args->epfd,
|
|
|
|
cap_rights_init(&rights, CAP_KQUEUE_CHANGE), &epfp);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
2017-02-26 19:51:44 +00:00
|
|
|
if (epfp->f_type != DTYPE_KQUEUE) {
|
|
|
|
error = EINVAL;
|
2015-05-24 16:41:39 +00:00
|
|
|
goto leave1;
|
2017-02-26 19:51:44 +00:00
|
|
|
}
|
2015-05-24 16:41:39 +00:00
|
|
|
|
|
|
|
/* Protect user data vector from incorrectly supplied fd. */
|
|
|
|
error = fget(td, args->fd, cap_rights_init(&rights, CAP_POLL_EVENT), &fp);
|
|
|
|
if (error != 0)
|
|
|
|
goto leave1;
|
|
|
|
|
|
|
|
/* Linux disallows spying on himself */
|
|
|
|
if (epfp == fp) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto leave0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ciargs.changelist = kev;
|
|
|
|
|
2017-02-28 19:55:16 +00:00
|
|
|
if (args->op != LINUX_EPOLL_CTL_DEL) {
|
|
|
|
kev_flags = EV_ADD | EV_ENABLE;
|
|
|
|
error = epoll_to_kevent(td, epfp, args->fd, &le,
|
|
|
|
&kev_flags, kev, &nchanges);
|
|
|
|
if (error != 0)
|
|
|
|
goto leave0;
|
|
|
|
}
|
|
|
|
|
2015-05-24 16:41:39 +00:00
|
|
|
switch (args->op) {
|
|
|
|
case LINUX_EPOLL_CTL_MOD:
|
|
|
|
error = epoll_delete_all_events(td, epfp, args->fd);
|
2017-02-26 09:42:34 +00:00
|
|
|
if (error != 0)
|
2015-05-24 16:41:39 +00:00
|
|
|
goto leave0;
|
2017-02-28 19:55:16 +00:00
|
|
|
break;
|
2015-05-24 16:41:39 +00:00
|
|
|
|
|
|
|
case LINUX_EPOLL_CTL_ADD:
|
2017-02-28 19:55:16 +00:00
|
|
|
/*
|
|
|
|
* kqueue_register() return ENOENT if event does not exists
|
2019-11-24 20:41:47 +00:00
|
|
|
* and the EV_ADD flag is not set. Reset EV_ENABLE flag to
|
|
|
|
* avoid accidental activation of fired oneshot events.
|
2017-02-28 19:55:16 +00:00
|
|
|
*/
|
2019-11-24 20:41:47 +00:00
|
|
|
kev[0].flags &= ~(EV_ADD | EV_ENABLE);
|
2018-11-24 17:06:01 +00:00
|
|
|
error = kqfd_register(args->epfd, &kev[0], td, M_WAITOK);
|
2017-02-28 19:55:16 +00:00
|
|
|
if (error != ENOENT) {
|
|
|
|
error = EEXIST;
|
|
|
|
goto leave0;
|
|
|
|
}
|
|
|
|
error = 0;
|
2019-11-24 20:41:47 +00:00
|
|
|
kev[0].flags |= (EV_ADD | EV_ENABLE);
|
2015-05-24 16:41:39 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case LINUX_EPOLL_CTL_DEL:
|
|
|
|
/* CTL_DEL means unregister this fd with this epoll */
|
|
|
|
error = epoll_delete_all_events(td, epfp, args->fd);
|
|
|
|
goto leave0;
|
|
|
|
|
|
|
|
default:
|
|
|
|
error = EINVAL;
|
|
|
|
goto leave0;
|
|
|
|
}
|
|
|
|
|
|
|
|
epoll_fd_install(td, args->fd, le.data);
|
|
|
|
|
|
|
|
error = kern_kevent_fp(td, epfp, nchanges, 0, &k_ops, NULL);
|
|
|
|
|
|
|
|
leave0:
|
|
|
|
fdrop(fp, td);
|
|
|
|
|
|
|
|
leave1:
|
|
|
|
fdrop(epfp, td);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for a filter to be triggered on the epoll file descriptor.
|
|
|
|
*/
|
2015-05-24 18:00:14 +00:00
|
|
|
static int
|
|
|
|
linux_epoll_wait_common(struct thread *td, int epfd, struct epoll_event *events,
|
|
|
|
int maxevents, int timeout, sigset_t *uset)
|
2015-05-24 16:41:39 +00:00
|
|
|
{
|
|
|
|
struct epoll_copyout_args coargs;
|
|
|
|
struct kevent_copyops k_ops = { &coargs,
|
|
|
|
epoll_kev_copyout,
|
|
|
|
NULL};
|
2017-02-26 19:54:17 +00:00
|
|
|
struct timespec ts, *tsp;
|
|
|
|
cap_rights_t rights;
|
|
|
|
struct file *epfp;
|
|
|
|
sigset_t omask;
|
2015-05-24 16:41:39 +00:00
|
|
|
int error;
|
|
|
|
|
2015-05-24 18:00:14 +00:00
|
|
|
if (maxevents <= 0 || maxevents > LINUX_MAX_EVENTS)
|
2015-05-24 16:41:39 +00:00
|
|
|
return (EINVAL);
|
|
|
|
|
2017-02-26 19:54:17 +00:00
|
|
|
error = fget(td, epfd,
|
|
|
|
cap_rights_init(&rights, CAP_KQUEUE_EVENT), &epfp);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
if (epfp->f_type != DTYPE_KQUEUE) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto leave1;
|
|
|
|
}
|
2015-05-24 18:00:14 +00:00
|
|
|
if (uset != NULL) {
|
|
|
|
error = kern_sigprocmask(td, SIG_SETMASK, uset,
|
2017-02-26 19:54:17 +00:00
|
|
|
&omask, 0);
|
2015-05-24 18:00:14 +00:00
|
|
|
if (error != 0)
|
2017-02-26 19:54:17 +00:00
|
|
|
goto leave1;
|
2015-05-24 18:00:14 +00:00
|
|
|
td->td_pflags |= TDP_OLDMASK;
|
|
|
|
/*
|
|
|
|
* Make sure that ast() is called on return to
|
|
|
|
* usermode and TDP_OLDMASK is cleared, restoring old
|
|
|
|
* sigmask.
|
|
|
|
*/
|
|
|
|
thread_lock(td);
|
|
|
|
td->td_flags |= TDF_ASTPENDING;
|
|
|
|
thread_unlock(td);
|
|
|
|
}
|
|
|
|
|
2015-05-24 16:41:39 +00:00
|
|
|
|
2015-05-24 18:00:14 +00:00
|
|
|
coargs.leventlist = events;
|
2015-05-24 16:41:39 +00:00
|
|
|
coargs.p = td->td_proc;
|
|
|
|
coargs.count = 0;
|
|
|
|
coargs.error = 0;
|
|
|
|
|
2015-05-24 18:00:14 +00:00
|
|
|
if (timeout != -1) {
|
|
|
|
if (timeout < 0) {
|
2015-05-24 16:41:39 +00:00
|
|
|
error = EINVAL;
|
2017-02-26 19:54:17 +00:00
|
|
|
goto leave0;
|
2015-05-24 16:41:39 +00:00
|
|
|
}
|
|
|
|
/* Convert from milliseconds to timespec. */
|
2015-05-24 18:00:14 +00:00
|
|
|
ts.tv_sec = timeout / 1000;
|
|
|
|
ts.tv_nsec = (timeout % 1000) * 1000000;
|
2015-05-24 16:41:39 +00:00
|
|
|
tsp = &ts;
|
|
|
|
} else {
|
|
|
|
tsp = NULL;
|
|
|
|
}
|
|
|
|
|
2015-05-24 18:00:14 +00:00
|
|
|
error = kern_kevent_fp(td, epfp, 0, maxevents, &k_ops, tsp);
|
2015-05-24 16:41:39 +00:00
|
|
|
if (error == 0 && coargs.error != 0)
|
|
|
|
error = coargs.error;
|
|
|
|
|
2018-02-05 17:29:12 +00:00
|
|
|
/*
|
2015-05-24 16:41:39 +00:00
|
|
|
* kern_kevent might return ENOMEM which is not expected from epoll_wait.
|
|
|
|
* Maybe we should translate that but I don't think it matters at all.
|
|
|
|
*/
|
|
|
|
if (error == 0)
|
|
|
|
td->td_retval[0] = coargs.count;
|
2017-02-26 19:54:17 +00:00
|
|
|
|
|
|
|
leave0:
|
|
|
|
if (uset != NULL)
|
|
|
|
error = kern_sigprocmask(td, SIG_SETMASK, &omask,
|
|
|
|
NULL, 0);
|
|
|
|
leave1:
|
2015-05-24 16:41:39 +00:00
|
|
|
fdrop(epfp, td);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2018-06-15 14:41:51 +00:00
|
|
|
#ifdef LINUX_LEGACY_SYSCALLS
|
2015-05-24 18:00:14 +00:00
|
|
|
int
|
|
|
|
linux_epoll_wait(struct thread *td, struct linux_epoll_wait_args *args)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (linux_epoll_wait_common(td, args->epfd, args->events,
|
|
|
|
args->maxevents, args->timeout, NULL));
|
|
|
|
}
|
2018-06-15 14:41:51 +00:00
|
|
|
#endif
|
2015-05-24 18:00:14 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
linux_epoll_pwait(struct thread *td, struct linux_epoll_pwait_args *args)
|
|
|
|
{
|
|
|
|
sigset_t mask, *pmask;
|
|
|
|
l_sigset_t lmask;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if (args->mask != NULL) {
|
2017-02-26 20:01:58 +00:00
|
|
|
if (args->sigsetsize != sizeof(l_sigset_t))
|
|
|
|
return (EINVAL);
|
2015-05-24 18:00:14 +00:00
|
|
|
error = copyin(args->mask, &lmask, sizeof(l_sigset_t));
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
linux_to_bsd_sigset(&lmask, &mask);
|
|
|
|
pmask = &mask;
|
|
|
|
} else
|
|
|
|
pmask = NULL;
|
|
|
|
return (linux_epoll_wait_common(td, args->epfd, args->events,
|
|
|
|
args->maxevents, args->timeout, pmask));
|
|
|
|
}
|
|
|
|
|
2015-05-24 16:41:39 +00:00
|
|
|
static int
|
|
|
|
epoll_delete_event(struct thread *td, struct file *epfp, int fd, int filter)
|
|
|
|
{
|
|
|
|
struct epoll_copyin_args ciargs;
|
|
|
|
struct kevent kev;
|
|
|
|
struct kevent_copyops k_ops = { &ciargs,
|
|
|
|
NULL,
|
|
|
|
epoll_kev_copyin};
|
|
|
|
|
|
|
|
ciargs.changelist = &kev;
|
|
|
|
EV_SET(&kev, fd, filter, EV_DELETE | EV_DISABLE, 0, 0, 0);
|
|
|
|
|
2017-02-28 19:54:22 +00:00
|
|
|
return (kern_kevent_fp(td, epfp, 1, 0, &k_ops, NULL));
|
2015-05-24 16:41:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
epoll_delete_all_events(struct thread *td, struct file *epfp, int fd)
|
|
|
|
{
|
|
|
|
int error1, error2;
|
|
|
|
|
|
|
|
error1 = epoll_delete_event(td, epfp, fd, EVFILT_READ);
|
|
|
|
error2 = epoll_delete_event(td, epfp, fd, EVFILT_WRITE);
|
|
|
|
|
2017-02-28 19:54:22 +00:00
|
|
|
/* return 0 if at least one result positive */
|
|
|
|
return (error1 == 0 ? 0 : error2);
|
2015-05-24 16:41:39 +00:00
|
|
|
}
|
2015-05-24 16:49:14 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
eventfd_create(struct thread *td, uint32_t initval, int flags)
|
|
|
|
{
|
|
|
|
struct filedesc *fdp;
|
|
|
|
struct eventfd *efd;
|
|
|
|
struct file *fp;
|
|
|
|
int fflags, fd, error;
|
|
|
|
|
|
|
|
fflags = 0;
|
|
|
|
if ((flags & LINUX_O_CLOEXEC) != 0)
|
|
|
|
fflags |= O_CLOEXEC;
|
|
|
|
|
|
|
|
fdp = td->td_proc->p_fd;
|
|
|
|
error = falloc(td, &fp, &fd, fflags);
|
2017-02-26 09:42:34 +00:00
|
|
|
if (error != 0)
|
2015-05-24 16:49:14 +00:00
|
|
|
return (error);
|
|
|
|
|
|
|
|
efd = malloc(sizeof(*efd), M_EPOLL, M_WAITOK | M_ZERO);
|
|
|
|
efd->efd_flags = flags;
|
|
|
|
efd->efd_count = initval;
|
|
|
|
mtx_init(&efd->efd_lock, "eventfd", NULL, MTX_DEF);
|
|
|
|
|
|
|
|
knlist_init_mtx(&efd->efd_sel.si_note, &efd->efd_lock);
|
|
|
|
|
2018-02-05 17:29:12 +00:00
|
|
|
fflags = FREAD | FWRITE;
|
2015-05-24 16:49:14 +00:00
|
|
|
if ((flags & LINUX_O_NONBLOCK) != 0)
|
|
|
|
fflags |= FNONBLOCK;
|
|
|
|
|
|
|
|
finit(fp, fflags, DTYPE_LINUXEFD, efd, &eventfdops);
|
|
|
|
fdrop(fp, td);
|
|
|
|
|
|
|
|
td->td_retval[0] = fd;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
2018-06-15 14:41:51 +00:00
|
|
|
#ifdef LINUX_LEGACY_SYSCALLS
|
2015-05-24 16:49:14 +00:00
|
|
|
int
|
|
|
|
linux_eventfd(struct thread *td, struct linux_eventfd_args *args)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (eventfd_create(td, args->initval, 0));
|
|
|
|
}
|
2018-06-15 14:41:51 +00:00
|
|
|
#endif
|
2015-05-24 16:49:14 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
linux_eventfd2(struct thread *td, struct linux_eventfd2_args *args)
|
|
|
|
{
|
|
|
|
|
|
|
|
if ((args->flags & ~(LINUX_O_CLOEXEC|LINUX_O_NONBLOCK|LINUX_EFD_SEMAPHORE)) != 0)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
return (eventfd_create(td, args->initval, args->flags));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
eventfd_close(struct file *fp, struct thread *td)
|
|
|
|
{
|
|
|
|
struct eventfd *efd;
|
|
|
|
|
|
|
|
efd = fp->f_data;
|
|
|
|
if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
|
2017-02-27 16:55:09 +00:00
|
|
|
return (EINVAL);
|
2015-05-24 16:49:14 +00:00
|
|
|
|
|
|
|
seldrain(&efd->efd_sel);
|
|
|
|
knlist_destroy(&efd->efd_sel.si_note);
|
|
|
|
|
|
|
|
fp->f_ops = &badfileops;
|
|
|
|
mtx_destroy(&efd->efd_lock);
|
|
|
|
free(efd, M_EPOLL);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
eventfd_read(struct file *fp, struct uio *uio, struct ucred *active_cred,
|
2017-02-26 09:42:34 +00:00
|
|
|
int flags, struct thread *td)
|
2015-05-24 16:49:14 +00:00
|
|
|
{
|
|
|
|
struct eventfd *efd;
|
|
|
|
eventfd_t count;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
efd = fp->f_data;
|
|
|
|
if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
|
2017-02-27 16:55:09 +00:00
|
|
|
return (EINVAL);
|
2015-05-24 16:49:14 +00:00
|
|
|
|
|
|
|
if (uio->uio_resid < sizeof(eventfd_t))
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
mtx_lock(&efd->efd_lock);
|
|
|
|
retry:
|
|
|
|
if (efd->efd_count == 0) {
|
2017-02-27 16:53:52 +00:00
|
|
|
if ((fp->f_flag & FNONBLOCK) != 0) {
|
2015-05-24 16:49:14 +00:00
|
|
|
mtx_unlock(&efd->efd_lock);
|
|
|
|
return (EAGAIN);
|
|
|
|
}
|
|
|
|
error = mtx_sleep(&efd->efd_count, &efd->efd_lock, PCATCH, "lefdrd", 0);
|
|
|
|
if (error == 0)
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
if ((efd->efd_flags & LINUX_EFD_SEMAPHORE) != 0) {
|
|
|
|
count = 1;
|
|
|
|
--efd->efd_count;
|
|
|
|
} else {
|
|
|
|
count = efd->efd_count;
|
|
|
|
efd->efd_count = 0;
|
|
|
|
}
|
|
|
|
KNOTE_LOCKED(&efd->efd_sel.si_note, 0);
|
|
|
|
selwakeup(&efd->efd_sel);
|
|
|
|
wakeup(&efd->efd_count);
|
|
|
|
mtx_unlock(&efd->efd_lock);
|
|
|
|
error = uiomove(&count, sizeof(eventfd_t), uio);
|
|
|
|
} else
|
|
|
|
mtx_unlock(&efd->efd_lock);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
eventfd_write(struct file *fp, struct uio *uio, struct ucred *active_cred,
|
2017-02-26 09:42:34 +00:00
|
|
|
int flags, struct thread *td)
|
2015-05-24 16:49:14 +00:00
|
|
|
{
|
|
|
|
struct eventfd *efd;
|
|
|
|
eventfd_t count;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
efd = fp->f_data;
|
|
|
|
if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
|
2017-02-27 16:55:09 +00:00
|
|
|
return (EINVAL);
|
2015-05-24 16:49:14 +00:00
|
|
|
|
|
|
|
if (uio->uio_resid < sizeof(eventfd_t))
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
error = uiomove(&count, sizeof(eventfd_t), uio);
|
2017-02-26 09:42:34 +00:00
|
|
|
if (error != 0)
|
2015-05-24 16:49:14 +00:00
|
|
|
return (error);
|
|
|
|
if (count == UINT64_MAX)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
mtx_lock(&efd->efd_lock);
|
|
|
|
retry:
|
|
|
|
if (UINT64_MAX - efd->efd_count <= count) {
|
2017-02-27 16:53:52 +00:00
|
|
|
if ((fp->f_flag & FNONBLOCK) != 0) {
|
2015-05-24 16:49:14 +00:00
|
|
|
mtx_unlock(&efd->efd_lock);
|
2016-03-26 19:16:53 +00:00
|
|
|
/* Do not not return the number of bytes written */
|
|
|
|
uio->uio_resid += sizeof(eventfd_t);
|
2015-05-24 16:49:14 +00:00
|
|
|
return (EAGAIN);
|
|
|
|
}
|
|
|
|
error = mtx_sleep(&efd->efd_count, &efd->efd_lock,
|
|
|
|
PCATCH, "lefdwr", 0);
|
|
|
|
if (error == 0)
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
efd->efd_count += count;
|
|
|
|
KNOTE_LOCKED(&efd->efd_sel.si_note, 0);
|
|
|
|
selwakeup(&efd->efd_sel);
|
|
|
|
wakeup(&efd->efd_count);
|
|
|
|
}
|
|
|
|
mtx_unlock(&efd->efd_lock);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
eventfd_poll(struct file *fp, int events, struct ucred *active_cred,
|
2017-02-26 09:42:34 +00:00
|
|
|
struct thread *td)
|
2015-05-24 16:49:14 +00:00
|
|
|
{
|
|
|
|
struct eventfd *efd;
|
|
|
|
int revents = 0;
|
|
|
|
|
|
|
|
efd = fp->f_data;
|
|
|
|
if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
|
|
|
|
return (POLLERR);
|
|
|
|
|
|
|
|
mtx_lock(&efd->efd_lock);
|
|
|
|
if ((events & (POLLIN|POLLRDNORM)) && efd->efd_count > 0)
|
|
|
|
revents |= events & (POLLIN|POLLRDNORM);
|
|
|
|
if ((events & (POLLOUT|POLLWRNORM)) && UINT64_MAX - 1 > efd->efd_count)
|
|
|
|
revents |= events & (POLLOUT|POLLWRNORM);
|
|
|
|
if (revents == 0)
|
|
|
|
selrecord(td, &efd->efd_sel);
|
|
|
|
mtx_unlock(&efd->efd_lock);
|
|
|
|
|
|
|
|
return (revents);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
eventfd_kqfilter(struct file *fp, struct knote *kn)
|
|
|
|
{
|
|
|
|
struct eventfd *efd;
|
|
|
|
|
|
|
|
efd = fp->f_data;
|
|
|
|
if (fp->f_type != DTYPE_LINUXEFD || efd == NULL)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
mtx_lock(&efd->efd_lock);
|
|
|
|
switch (kn->kn_filter) {
|
|
|
|
case EVFILT_READ:
|
|
|
|
kn->kn_fop = &eventfd_rfiltops;
|
|
|
|
break;
|
|
|
|
case EVFILT_WRITE:
|
|
|
|
kn->kn_fop = &eventfd_wfiltops;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
mtx_unlock(&efd->efd_lock);
|
|
|
|
return (EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
kn->kn_hook = efd;
|
|
|
|
knlist_add(&efd->efd_sel.si_note, kn, 1);
|
|
|
|
mtx_unlock(&efd->efd_lock);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
filt_eventfddetach(struct knote *kn)
|
|
|
|
{
|
|
|
|
struct eventfd *efd = kn->kn_hook;
|
|
|
|
|
|
|
|
mtx_lock(&efd->efd_lock);
|
|
|
|
knlist_remove(&efd->efd_sel.si_note, kn, 1);
|
|
|
|
mtx_unlock(&efd->efd_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
filt_eventfdread(struct knote *kn, long hint)
|
|
|
|
{
|
|
|
|
struct eventfd *efd = kn->kn_hook;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mtx_assert(&efd->efd_lock, MA_OWNED);
|
|
|
|
ret = (efd->efd_count > 0);
|
|
|
|
|
|
|
|
return (ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
filt_eventfdwrite(struct knote *kn, long hint)
|
|
|
|
{
|
|
|
|
struct eventfd *efd = kn->kn_hook;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
mtx_assert(&efd->efd_lock, MA_OWNED);
|
|
|
|
ret = (UINT64_MAX - 1 > efd->efd_count);
|
|
|
|
|
|
|
|
return (ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
eventfd_ioctl(struct file *fp, u_long cmd, void *data,
|
2017-02-26 09:42:34 +00:00
|
|
|
struct ucred *active_cred, struct thread *td)
|
2015-05-24 16:49:14 +00:00
|
|
|
{
|
|
|
|
|
2017-02-27 16:53:52 +00:00
|
|
|
if (fp->f_data == NULL || (fp->f_type != DTYPE_LINUXEFD &&
|
|
|
|
fp->f_type != DTYPE_LINUXTFD))
|
2016-03-26 19:15:23 +00:00
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
switch (cmd)
|
|
|
|
{
|
|
|
|
case FIONBIO:
|
2017-02-27 16:53:52 +00:00
|
|
|
if ((*(int *)data))
|
|
|
|
atomic_set_int(&fp->f_flag, FNONBLOCK);
|
2016-03-26 19:15:23 +00:00
|
|
|
else
|
2017-02-27 16:53:52 +00:00
|
|
|
atomic_clear_int(&fp->f_flag, FNONBLOCK);
|
2016-03-26 19:15:23 +00:00
|
|
|
case FIOASYNC:
|
|
|
|
return (0);
|
|
|
|
default:
|
|
|
|
return (ENXIO);
|
|
|
|
}
|
2015-05-24 16:49:14 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
eventfd_stat(struct file *fp, struct stat *st, struct ucred *active_cred,
|
2017-02-26 09:42:34 +00:00
|
|
|
struct thread *td)
|
2015-05-24 16:49:14 +00:00
|
|
|
{
|
|
|
|
|
|
|
|
return (ENXIO);
|
|
|
|
}
|
2015-05-24 17:40:14 +00:00
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
eventfd_fill_kinfo(struct file *fp, struct kinfo_file *kif, struct filedesc *fdp)
|
|
|
|
{
|
|
|
|
|
|
|
|
kif->kf_type = KF_TYPE_UNKNOWN;
|
|
|
|
return (0);
|
|
|
|
}
|
2017-02-26 09:48:18 +00:00
|
|
|
|
|
|
|
int
|
|
|
|
linux_timerfd_create(struct thread *td, struct linux_timerfd_create_args *args)
|
|
|
|
{
|
|
|
|
struct filedesc *fdp;
|
|
|
|
struct timerfd *tfd;
|
|
|
|
struct file *fp;
|
|
|
|
clockid_t clockid;
|
|
|
|
int fflags, fd, error;
|
|
|
|
|
|
|
|
if ((args->flags & ~LINUX_TFD_CREATE_FLAGS) != 0)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
error = linux_to_native_clockid(&clockid, args->clockid);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
if (clockid != CLOCK_REALTIME && clockid != CLOCK_MONOTONIC)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
fflags = 0;
|
|
|
|
if ((args->flags & LINUX_TFD_CLOEXEC) != 0)
|
|
|
|
fflags |= O_CLOEXEC;
|
|
|
|
|
|
|
|
fdp = td->td_proc->p_fd;
|
|
|
|
error = falloc(td, &fp, &fd, fflags);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
|
|
|
|
tfd = malloc(sizeof(*tfd), M_EPOLL, M_WAITOK | M_ZERO);
|
|
|
|
tfd->tfd_clockid = clockid;
|
|
|
|
mtx_init(&tfd->tfd_lock, "timerfd", NULL, MTX_DEF);
|
|
|
|
|
|
|
|
callout_init_mtx(&tfd->tfd_callout, &tfd->tfd_lock, 0);
|
|
|
|
knlist_init_mtx(&tfd->tfd_sel.si_note, &tfd->tfd_lock);
|
|
|
|
|
|
|
|
fflags = FREAD;
|
|
|
|
if ((args->flags & LINUX_O_NONBLOCK) != 0)
|
|
|
|
fflags |= FNONBLOCK;
|
|
|
|
|
|
|
|
finit(fp, fflags, DTYPE_LINUXTFD, tfd, &timerfdops);
|
|
|
|
fdrop(fp, td);
|
|
|
|
|
|
|
|
td->td_retval[0] = fd;
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
timerfd_close(struct file *fp, struct thread *td)
|
|
|
|
{
|
|
|
|
struct timerfd *tfd;
|
|
|
|
|
|
|
|
tfd = fp->f_data;
|
|
|
|
if (fp->f_type != DTYPE_LINUXTFD || tfd == NULL)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
timespecclear(&tfd->tfd_time.it_value);
|
|
|
|
timespecclear(&tfd->tfd_time.it_interval);
|
|
|
|
|
|
|
|
mtx_lock(&tfd->tfd_lock);
|
|
|
|
callout_drain(&tfd->tfd_callout);
|
|
|
|
mtx_unlock(&tfd->tfd_lock);
|
|
|
|
|
|
|
|
seldrain(&tfd->tfd_sel);
|
|
|
|
knlist_destroy(&tfd->tfd_sel.si_note);
|
|
|
|
|
|
|
|
fp->f_ops = &badfileops;
|
|
|
|
mtx_destroy(&tfd->tfd_lock);
|
|
|
|
free(tfd, M_EPOLL);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
timerfd_read(struct file *fp, struct uio *uio, struct ucred *active_cred,
|
|
|
|
int flags, struct thread *td)
|
|
|
|
{
|
|
|
|
struct timerfd *tfd;
|
|
|
|
timerfd_t count;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
tfd = fp->f_data;
|
|
|
|
if (fp->f_type != DTYPE_LINUXTFD || tfd == NULL)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
if (uio->uio_resid < sizeof(timerfd_t))
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
error = 0;
|
|
|
|
mtx_lock(&tfd->tfd_lock);
|
|
|
|
retry:
|
|
|
|
if (tfd->tfd_canceled) {
|
|
|
|
tfd->tfd_count = 0;
|
|
|
|
mtx_unlock(&tfd->tfd_lock);
|
|
|
|
return (ECANCELED);
|
|
|
|
}
|
|
|
|
if (tfd->tfd_count == 0) {
|
|
|
|
if ((fp->f_flag & FNONBLOCK) != 0) {
|
|
|
|
mtx_unlock(&tfd->tfd_lock);
|
|
|
|
return (EAGAIN);
|
|
|
|
}
|
|
|
|
error = mtx_sleep(&tfd->tfd_count, &tfd->tfd_lock, PCATCH, "ltfdrd", 0);
|
|
|
|
if (error == 0)
|
|
|
|
goto retry;
|
|
|
|
}
|
|
|
|
if (error == 0) {
|
|
|
|
count = tfd->tfd_count;
|
|
|
|
tfd->tfd_count = 0;
|
|
|
|
mtx_unlock(&tfd->tfd_lock);
|
|
|
|
error = uiomove(&count, sizeof(timerfd_t), uio);
|
|
|
|
} else
|
|
|
|
mtx_unlock(&tfd->tfd_lock);
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
timerfd_poll(struct file *fp, int events, struct ucred *active_cred,
|
|
|
|
struct thread *td)
|
|
|
|
{
|
|
|
|
struct timerfd *tfd;
|
|
|
|
int revents = 0;
|
|
|
|
|
|
|
|
tfd = fp->f_data;
|
|
|
|
if (fp->f_type != DTYPE_LINUXTFD || tfd == NULL)
|
|
|
|
return (POLLERR);
|
|
|
|
|
|
|
|
mtx_lock(&tfd->tfd_lock);
|
|
|
|
if ((events & (POLLIN|POLLRDNORM)) && tfd->tfd_count > 0)
|
|
|
|
revents |= events & (POLLIN|POLLRDNORM);
|
|
|
|
if (revents == 0)
|
|
|
|
selrecord(td, &tfd->tfd_sel);
|
|
|
|
mtx_unlock(&tfd->tfd_lock);
|
|
|
|
|
|
|
|
return (revents);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
timerfd_kqfilter(struct file *fp, struct knote *kn)
|
|
|
|
{
|
|
|
|
struct timerfd *tfd;
|
|
|
|
|
|
|
|
tfd = fp->f_data;
|
|
|
|
if (fp->f_type != DTYPE_LINUXTFD || tfd == NULL)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
if (kn->kn_filter == EVFILT_READ)
|
|
|
|
kn->kn_fop = &timerfd_rfiltops;
|
|
|
|
else
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
kn->kn_hook = tfd;
|
|
|
|
knlist_add(&tfd->tfd_sel.si_note, kn, 0);
|
|
|
|
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
filt_timerfddetach(struct knote *kn)
|
|
|
|
{
|
|
|
|
struct timerfd *tfd = kn->kn_hook;
|
|
|
|
|
|
|
|
mtx_lock(&tfd->tfd_lock);
|
|
|
|
knlist_remove(&tfd->tfd_sel.si_note, kn, 1);
|
|
|
|
mtx_unlock(&tfd->tfd_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
filt_timerfdread(struct knote *kn, long hint)
|
|
|
|
{
|
|
|
|
struct timerfd *tfd = kn->kn_hook;
|
|
|
|
|
|
|
|
return (tfd->tfd_count > 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
timerfd_stat(struct file *fp, struct stat *st, struct ucred *active_cred,
|
|
|
|
struct thread *td)
|
|
|
|
{
|
|
|
|
|
|
|
|
return (ENXIO);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*ARGSUSED*/
|
|
|
|
static int
|
|
|
|
timerfd_fill_kinfo(struct file *fp, struct kinfo_file *kif, struct filedesc *fdp)
|
|
|
|
{
|
|
|
|
|
|
|
|
kif->kf_type = KF_TYPE_UNKNOWN;
|
|
|
|
return (0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
linux_timerfd_clocktime(struct timerfd *tfd, struct timespec *ts)
|
|
|
|
{
|
|
|
|
|
|
|
|
if (tfd->tfd_clockid == CLOCK_REALTIME)
|
|
|
|
getnanotime(ts);
|
|
|
|
else /* CLOCK_MONOTONIC */
|
|
|
|
getnanouptime(ts);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
linux_timerfd_curval(struct timerfd *tfd, struct itimerspec *ots)
|
|
|
|
{
|
|
|
|
struct timespec cts;
|
|
|
|
|
|
|
|
linux_timerfd_clocktime(tfd, &cts);
|
|
|
|
*ots = tfd->tfd_time;
|
|
|
|
if (ots->it_value.tv_sec != 0 || ots->it_value.tv_nsec != 0) {
|
Make timespecadd(3) and friends public
The timespecadd(3) family of macros were imported from NetBSD back in
r35029. However, they were initially guarded by #ifdef _KERNEL. In the
meantime, we have grown at least 28 syscalls that use timespecs in some
way, leading many programs both inside and outside of the base system to
redefine those macros. It's better just to make the definitions public.
Our kernel currently defines two-argument versions of timespecadd and
timespecsub. NetBSD, OpenBSD, and FreeDesktop.org's libbsd, however, define
three-argument versions. Solaris also defines a three-argument version, but
only in its kernel. This revision changes our definition to match the
common three-argument version.
Bump _FreeBSD_version due to the breaking KPI change.
Discussed with: cem, jilles, ian, bde
Differential Revision: https://reviews.freebsd.org/D14725
2018-07-30 15:46:40 +00:00
|
|
|
timespecsub(&ots->it_value, &cts, &ots->it_value);
|
2017-02-26 09:48:18 +00:00
|
|
|
if (ots->it_value.tv_sec < 0 ||
|
|
|
|
(ots->it_value.tv_sec == 0 &&
|
|
|
|
ots->it_value.tv_nsec == 0)) {
|
|
|
|
ots->it_value.tv_sec = 0;
|
|
|
|
ots->it_value.tv_nsec = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
linux_timerfd_gettime(struct thread *td, struct linux_timerfd_gettime_args *args)
|
|
|
|
{
|
|
|
|
struct l_itimerspec lots;
|
|
|
|
struct itimerspec ots;
|
|
|
|
struct timerfd *tfd;
|
|
|
|
struct file *fp;
|
|
|
|
int error;
|
|
|
|
|
2018-05-09 18:47:24 +00:00
|
|
|
error = fget(td, args->fd, &cap_read_rights, &fp);
|
2017-02-26 09:48:18 +00:00
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
tfd = fp->f_data;
|
|
|
|
if (fp->f_type != DTYPE_LINUXTFD || tfd == NULL) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
mtx_lock(&tfd->tfd_lock);
|
|
|
|
linux_timerfd_curval(tfd, &ots);
|
|
|
|
mtx_unlock(&tfd->tfd_lock);
|
|
|
|
|
|
|
|
error = native_to_linux_itimerspec(&lots, &ots);
|
|
|
|
if (error == 0)
|
|
|
|
error = copyout(&lots, args->old_value, sizeof(lots));
|
|
|
|
|
|
|
|
out:
|
|
|
|
fdrop(fp, td);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
linux_timerfd_settime(struct thread *td, struct linux_timerfd_settime_args *args)
|
|
|
|
{
|
|
|
|
struct l_itimerspec lots;
|
|
|
|
struct itimerspec nts, ots;
|
|
|
|
struct timespec cts, ts;
|
|
|
|
struct timerfd *tfd;
|
|
|
|
struct timeval tv;
|
|
|
|
struct file *fp;
|
|
|
|
int error;
|
|
|
|
|
|
|
|
if ((args->flags & ~LINUX_TFD_SETTIME_FLAGS) != 0)
|
|
|
|
return (EINVAL);
|
|
|
|
|
|
|
|
error = copyin(args->new_value, &lots, sizeof(lots));
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
error = linux_to_native_itimerspec(&nts, &lots);
|
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
|
2018-05-09 18:47:24 +00:00
|
|
|
error = fget(td, args->fd, &cap_write_rights, &fp);
|
2017-02-26 09:48:18 +00:00
|
|
|
if (error != 0)
|
|
|
|
return (error);
|
|
|
|
tfd = fp->f_data;
|
|
|
|
if (fp->f_type != DTYPE_LINUXTFD || tfd == NULL) {
|
|
|
|
error = EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
mtx_lock(&tfd->tfd_lock);
|
|
|
|
if (!timespecisset(&nts.it_value))
|
|
|
|
timespecclear(&nts.it_interval);
|
|
|
|
if (args->old_value != NULL)
|
|
|
|
linux_timerfd_curval(tfd, &ots);
|
|
|
|
|
|
|
|
tfd->tfd_time = nts;
|
|
|
|
if (timespecisset(&nts.it_value)) {
|
|
|
|
linux_timerfd_clocktime(tfd, &cts);
|
|
|
|
ts = nts.it_value;
|
|
|
|
if ((args->flags & LINUX_TFD_TIMER_ABSTIME) == 0) {
|
Make timespecadd(3) and friends public
The timespecadd(3) family of macros were imported from NetBSD back in
r35029. However, they were initially guarded by #ifdef _KERNEL. In the
meantime, we have grown at least 28 syscalls that use timespecs in some
way, leading many programs both inside and outside of the base system to
redefine those macros. It's better just to make the definitions public.
Our kernel currently defines two-argument versions of timespecadd and
timespecsub. NetBSD, OpenBSD, and FreeDesktop.org's libbsd, however, define
three-argument versions. Solaris also defines a three-argument version, but
only in its kernel. This revision changes our definition to match the
common three-argument version.
Bump _FreeBSD_version due to the breaking KPI change.
Discussed with: cem, jilles, ian, bde
Differential Revision: https://reviews.freebsd.org/D14725
2018-07-30 15:46:40 +00:00
|
|
|
timespecadd(&tfd->tfd_time.it_value, &cts,
|
|
|
|
&tfd->tfd_time.it_value);
|
2017-02-26 09:48:18 +00:00
|
|
|
} else {
|
Make timespecadd(3) and friends public
The timespecadd(3) family of macros were imported from NetBSD back in
r35029. However, they were initially guarded by #ifdef _KERNEL. In the
meantime, we have grown at least 28 syscalls that use timespecs in some
way, leading many programs both inside and outside of the base system to
redefine those macros. It's better just to make the definitions public.
Our kernel currently defines two-argument versions of timespecadd and
timespecsub. NetBSD, OpenBSD, and FreeDesktop.org's libbsd, however, define
three-argument versions. Solaris also defines a three-argument version, but
only in its kernel. This revision changes our definition to match the
common three-argument version.
Bump _FreeBSD_version due to the breaking KPI change.
Discussed with: cem, jilles, ian, bde
Differential Revision: https://reviews.freebsd.org/D14725
2018-07-30 15:46:40 +00:00
|
|
|
timespecsub(&ts, &cts, &ts);
|
2017-02-26 09:48:18 +00:00
|
|
|
}
|
|
|
|
TIMESPEC_TO_TIMEVAL(&tv, &ts);
|
|
|
|
callout_reset(&tfd->tfd_callout, tvtohz(&tv),
|
|
|
|
linux_timerfd_expire, tfd);
|
|
|
|
tfd->tfd_canceled = false;
|
|
|
|
} else {
|
|
|
|
tfd->tfd_canceled = true;
|
|
|
|
callout_stop(&tfd->tfd_callout);
|
|
|
|
}
|
|
|
|
mtx_unlock(&tfd->tfd_lock);
|
|
|
|
|
|
|
|
if (args->old_value != NULL) {
|
|
|
|
error = native_to_linux_itimerspec(&lots, &ots);
|
|
|
|
if (error == 0)
|
|
|
|
error = copyout(&lots, args->old_value, sizeof(lots));
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
fdrop(fp, td);
|
|
|
|
return (error);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
linux_timerfd_expire(void *arg)
|
|
|
|
{
|
|
|
|
struct timespec cts, ts;
|
|
|
|
struct timeval tv;
|
|
|
|
struct timerfd *tfd;
|
|
|
|
|
|
|
|
tfd = (struct timerfd *)arg;
|
|
|
|
|
|
|
|
linux_timerfd_clocktime(tfd, &cts);
|
|
|
|
if (timespeccmp(&cts, &tfd->tfd_time.it_value, >=)) {
|
|
|
|
if (timespecisset(&tfd->tfd_time.it_interval))
|
|
|
|
timespecadd(&tfd->tfd_time.it_value,
|
Make timespecadd(3) and friends public
The timespecadd(3) family of macros were imported from NetBSD back in
r35029. However, they were initially guarded by #ifdef _KERNEL. In the
meantime, we have grown at least 28 syscalls that use timespecs in some
way, leading many programs both inside and outside of the base system to
redefine those macros. It's better just to make the definitions public.
Our kernel currently defines two-argument versions of timespecadd and
timespecsub. NetBSD, OpenBSD, and FreeDesktop.org's libbsd, however, define
three-argument versions. Solaris also defines a three-argument version, but
only in its kernel. This revision changes our definition to match the
common three-argument version.
Bump _FreeBSD_version due to the breaking KPI change.
Discussed with: cem, jilles, ian, bde
Differential Revision: https://reviews.freebsd.org/D14725
2018-07-30 15:46:40 +00:00
|
|
|
&tfd->tfd_time.it_interval,
|
|
|
|
&tfd->tfd_time.it_value);
|
2017-02-26 09:48:18 +00:00
|
|
|
else
|
|
|
|
/* single shot timer */
|
|
|
|
timespecclear(&tfd->tfd_time.it_value);
|
|
|
|
if (timespecisset(&tfd->tfd_time.it_value)) {
|
Make timespecadd(3) and friends public
The timespecadd(3) family of macros were imported from NetBSD back in
r35029. However, they were initially guarded by #ifdef _KERNEL. In the
meantime, we have grown at least 28 syscalls that use timespecs in some
way, leading many programs both inside and outside of the base system to
redefine those macros. It's better just to make the definitions public.
Our kernel currently defines two-argument versions of timespecadd and
timespecsub. NetBSD, OpenBSD, and FreeDesktop.org's libbsd, however, define
three-argument versions. Solaris also defines a three-argument version, but
only in its kernel. This revision changes our definition to match the
common three-argument version.
Bump _FreeBSD_version due to the breaking KPI change.
Discussed with: cem, jilles, ian, bde
Differential Revision: https://reviews.freebsd.org/D14725
2018-07-30 15:46:40 +00:00
|
|
|
timespecsub(&tfd->tfd_time.it_value, &cts, &ts);
|
2017-02-26 09:48:18 +00:00
|
|
|
TIMESPEC_TO_TIMEVAL(&tv, &ts);
|
|
|
|
callout_reset(&tfd->tfd_callout, tvtohz(&tv),
|
|
|
|
linux_timerfd_expire, tfd);
|
|
|
|
}
|
|
|
|
tfd->tfd_count++;
|
|
|
|
KNOTE_LOCKED(&tfd->tfd_sel.si_note, 0);
|
|
|
|
selwakeup(&tfd->tfd_sel);
|
|
|
|
wakeup(&tfd->tfd_count);
|
|
|
|
} else if (timespecisset(&tfd->tfd_time.it_value)) {
|
Make timespecadd(3) and friends public
The timespecadd(3) family of macros were imported from NetBSD back in
r35029. However, they were initially guarded by #ifdef _KERNEL. In the
meantime, we have grown at least 28 syscalls that use timespecs in some
way, leading many programs both inside and outside of the base system to
redefine those macros. It's better just to make the definitions public.
Our kernel currently defines two-argument versions of timespecadd and
timespecsub. NetBSD, OpenBSD, and FreeDesktop.org's libbsd, however, define
three-argument versions. Solaris also defines a three-argument version, but
only in its kernel. This revision changes our definition to match the
common three-argument version.
Bump _FreeBSD_version due to the breaking KPI change.
Discussed with: cem, jilles, ian, bde
Differential Revision: https://reviews.freebsd.org/D14725
2018-07-30 15:46:40 +00:00
|
|
|
timespecsub(&tfd->tfd_time.it_value, &cts, &ts);
|
2017-02-26 09:48:18 +00:00
|
|
|
TIMESPEC_TO_TIMEVAL(&tv, &ts);
|
|
|
|
callout_reset(&tfd->tfd_callout, tvtohz(&tv),
|
|
|
|
linux_timerfd_expire, tfd);
|
|
|
|
}
|
|
|
|
}
|