File Coverage

blib/lib/Linux/Event/Backend/Epoll.pm

Criterion	Covered	Total	%
statement	123	134	91.7
branch	23	52	44.2
condition	1	3	33.3
subroutine	20	21	95.2
pod	7	7	100.0
total	174	217	80.1

package Linux::Event::Backend::Epoll;
use v5.36;
use strict;
use warnings;

our $VERSION = '0.012';

use Carp qw(croak);
use Linux::Event::XS ();

use constant READABLE => 0x01;
use constant WRITABLE => 0x02;
use constant PRIO     => 0x04;
use constant RDHUP    => 0x08;
use constant ET       => 0x10;
use constant ONESHOT  => 0x20;
use constant ERR      => 0x40;
use constant HUP      => 0x80;

sub new ($class, %args) {
  # Optional backend defaults (not part of Loop's public API):
  my $edge    = delete $args{edge};
  my $oneshot = delete $args{oneshot};
  croak "unknown args: " . join(", ", sort keys %args) if %args;

  my $ep = Linux::Event::XS::epoll_new();

  return bless {
    ep      => $ep, # XS epoll fd + reusable event buffer
    watch   => Linux::Event::XS::registry_new(), # fd -> XS backend watch record
    edge    => $edge ? 1 : 0,
    oneshot => $oneshot ? 1 : 0,
  }, $class;
}

sub name ($self) { return 'epoll' }

sub watch ($self, $fh, $mask, $cb, %opt) {
  croak "fh is required" if !$fh;
  croak "mask is required" if !defined $mask;
  croak "cb is required" if !$cb;
  croak "cb must be a coderef" if ref($cb) ne 'CODE';

  my $fd = fileno($fh);
  croak "fh has no fileno" if !defined $fd;
  $fd = int($fd);

  croak "fd already watched: $fd" if Linux::Event::XS::registry_get($self->{watch}, $fd);

  my $events = _mask_to_events($self, $mask);
  my $rec = Linux::Event::XS::backend_watch_new(
    'Linux::Event::XS::BackendWatch',
    $fd,
    $fh,
    $cb,
    int($mask),
    $opt{_loop},
    $opt{tag},
  );

  Linux::Event::XS::epoll_add($self->{ep}, $fd, $events);
  Linux::Event::XS::registry_set($self->{watch}, $fd, $rec);

  return $fd;
}


sub watch_watcher ($self, $fh, $mask, $watcher, %opt) {
  croak "fh is required" if !$fh;
  croak "mask is required" if !defined $mask;
  croak "watcher is required" if !$watcher;

  my $fd = fileno($fh);
  croak "fh has no fileno" if !defined $fd;
  $fd = int($fd);

  croak "fd already watched: $fd" if Linux::Event::XS::registry_get($self->{watch}, $fd);

  my $events = _mask_to_events($self, $mask);
  my $rec = Linux::Event::XS::backend_watch_new_watcher(
    'Linux::Event::XS::BackendWatch',
    $fd,
    $fh,
    $watcher,
    int($mask),
    $opt{_loop},
    $opt{tag},
  );

  Linux::Event::XS::epoll_add($self->{ep}, $fd, $events);
  Linux::Event::XS::registry_set($self->{watch}, $fd, $rec);

  return $fd;
}

sub modify ($self, $fh_or_fd, $mask, %opt) {
  croak "mask is required" if !defined $mask;

  my $fd = ref($fh_or_fd) ? fileno($fh_or_fd) : $fh_or_fd;
  return 0 if !defined $fd;
  $fd = int($fd);

  my $rec = Linux::Event::XS::registry_get($self->{watch}, $fd) or return 0;

  my $loop = exists $opt{_loop} ? $opt{_loop} : undef;
  my $tag  = exists $opt{tag}   ? $opt{tag}   : undef;
  Linux::Event::XS::backend_watch_set_loop_tag($rec, $loop, $tag)
    if exists($opt{_loop}) || exists($opt{tag});

  my $new_mask = int($mask);
  Linux::Event::XS::backend_watch_set_mask($rec, $new_mask);

  my $events = _mask_to_events($self, $new_mask);
  Linux::Event::XS::epoll_modify($self->{ep}, $fd, $events);
  return 1;
}

sub unwatch ($self, $fh_or_fd) {
  my $fd = ref($fh_or_fd) ? fileno($fh_or_fd) : $fh_or_fd;
  return 0 if !defined $fd;
  $fd = int($fd);

  my $rec = Linux::Event::XS::registry_get($self->{watch}, $fd) or return 0;
  Linux::Event::XS::epoll_delete($self->{ep}, $fd);
  Linux::Event::XS::registry_delete($self->{watch}, $fd);
  return 1;
}

sub run_once ($self, $loop, $timeout_s = undef) {
  # XS owns the epoll fd and reuses a fixed epoll_event buffer across waits.
  return Linux::Event::XS::epoll_wait_dispatch($self->{ep}, $self->{watch}, $timeout_s);
}

sub _mask_to_events ($self, $mask) {
  $mask = int($mask);
  $mask |= ET      if $self->{edge};
  $mask |= ONESHOT if $self->{oneshot};
  return $mask;
}

1;

__END__