Quelle eventfd.c Sprache: C

// SPDX-License-Identifier: GPL-2.0
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <linux/eventfd.h>
#include <linux/eventpoll.h>
#include <linux/io_uring.h>
#include <linux/io_uring_types.h>

#include "io-wq.h"
#include "eventfd.h"

struct io_ev_fd {
struct eventfd_ctx *cq_ev_fd;
unsigned int  eventfd_async;
/* protected by ->completion_lock */
unsigned  last_cq_tail;
refcount_t  refs;
atomic_t  ops;
struct rcu_head  rcu;
};

enum {
IO_EVENTFD_OP_SIGNAL_BIT,
};

static void io_eventfd_free(struct rcu_head *rcu)
{
struct io_ev_fd *ev_fd = container_of(rcu, struct io_ev_fd, rcu);

eventfd_ctx_put(ev_fd->cq_ev_fd);
kfree(ev_fd);
}

static void io_eventfd_put(struct io_ev_fd *ev_fd)
{
if (refcount_dec_and_test(&ev_fd->refs))
  call_rcu(&ev_fd->rcu, io_eventfd_free);
}

static void io_eventfd_do_signal(struct rcu_head *rcu)
{
struct io_ev_fd *ev_fd = container_of(rcu, struct io_ev_fd, rcu);

eventfd_signal_mask(ev_fd->cq_ev_fd, EPOLL_URING_WAKE);
io_eventfd_put(ev_fd);
}

/*
* Returns true if the caller should put the ev_fd reference, false if not.
*/
static bool __io_eventfd_signal(struct io_ev_fd *ev_fd)
{
if (eventfd_signal_allowed()) {
  eventfd_signal_mask(ev_fd->cq_ev_fd, EPOLL_URING_WAKE);
  return true;
}
if (!atomic_fetch_or(BIT(IO_EVENTFD_OP_SIGNAL_BIT), &ev_fd->ops)) {
  call_rcu_hurry(&ev_fd->rcu, io_eventfd_do_signal);
  return false;
}
return true;
}

/*
* Trigger if eventfd_async isn't set, or if it's set and the caller is
* an async worker.
*/
static bool io_eventfd_trigger(struct io_ev_fd *ev_fd)
{
return !ev_fd->eventfd_async || io_wq_current_is_worker();
}

void io_eventfd_signal(struct io_ring_ctx *ctx, bool cqe_event)
{
bool skip = false;
struct io_ev_fd *ev_fd;

if (READ_ONCE(ctx->rings->cq_flags) & IORING_CQ_EVENTFD_DISABLED)
  return;

guard(rcu)();
ev_fd = rcu_dereference(ctx->io_ev_fd);
/*
* Check again if ev_fd exists in case an io_eventfd_unregister call
* completed between the NULL check of ctx->io_ev_fd at the start of
* the function and rcu_read_lock.
*/
if (!ev_fd)
  return;
if (!io_eventfd_trigger(ev_fd) || !refcount_inc_not_zero(&ev_fd->refs))
  return;

if (cqe_event) {
  /*
* Eventfd should only get triggered when at least one event
* has been posted. Some applications rely on the eventfd
* notification count only changing IFF a new CQE has been
* added to the CQ ring. There's no dependency on 1:1
* relationship between how many times this function is called
* (and hence the eventfd count) and number of CQEs posted to
* the CQ ring.
*/
  spin_lock(&ctx->completion_lock);
  skip = ctx->cached_cq_tail == ev_fd->last_cq_tail;
  ev_fd->last_cq_tail = ctx->cached_cq_tail;
  spin_unlock(&ctx->completion_lock);
}

if (skip || __io_eventfd_signal(ev_fd))
  io_eventfd_put(ev_fd);
}

int io_eventfd_register(struct io_ring_ctx *ctx, void __user *arg,
   unsigned int eventfd_async)
{
struct io_ev_fd *ev_fd;
__s32 __user *fds = arg;
int fd;

ev_fd = rcu_dereference_protected(ctx->io_ev_fd,
     lockdep_is_held(&ctx->uring_lock));
if (ev_fd)
  return -EBUSY;

if (copy_from_user(&fd, fds, sizeof(*fds)))
  return -EFAULT;

ev_fd = kmalloc(sizeof(*ev_fd), GFP_KERNEL);
if (!ev_fd)
  return -ENOMEM;

ev_fd->cq_ev_fd = eventfd_ctx_fdget(fd);
if (IS_ERR(ev_fd->cq_ev_fd)) {
  int ret = PTR_ERR(ev_fd->cq_ev_fd);

  kfree(ev_fd);
  return ret;
}

spin_lock(&ctx->completion_lock);
ev_fd->last_cq_tail = ctx->cached_cq_tail;
spin_unlock(&ctx->completion_lock);

ev_fd->eventfd_async = eventfd_async;
ctx->has_evfd = true;
refcount_set(&ev_fd->refs, 1);
atomic_set(&ev_fd->ops, 0);
rcu_assign_pointer(ctx->io_ev_fd, ev_fd);
return 0;
}

int io_eventfd_unregister(struct io_ring_ctx *ctx)
{
struct io_ev_fd *ev_fd;

ev_fd = rcu_dereference_protected(ctx->io_ev_fd,
     lockdep_is_held(&ctx->uring_lock));
if (ev_fd) {
  ctx->has_evfd = false;
  rcu_assign_pointer(ctx->io_ev_fd, NULL);
  io_eventfd_put(ev_fd);
  return 0;
}

return -ENXIO;
}

quality100%

¤ Dauer der Verarbeitung: 0.13 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.