Class: UserfaultFD::EventReader

Inherits:

Object

• Object
• UserfaultFD::EventReader

Defined in:

ext/userfaultfd/userfaultfd.c

Instance Method Summary

• #fileno ⇒ Object
• #read_events(*args) ⇒ Object
• #running? ⇒ Boolean
• #stop ⇒ Object

Instance Method Details

#fileno ⇒ Object

# File 'ext/userfaultfd/userfaultfd.c', line 1825

static VALUE
event_reader_fileno(VALUE self)
{
    event_reader_data_t *data;
    TypedData_Get_Struct(self, event_reader_data_t, &event_reader_type, data);
    if (data->output_pipe[0] < 0) rb_raise(eError, "closed event reader");
    return INT2NUM(data->output_pipe[0]);
}

#read_events(*args) ⇒ Object

# File 'ext/userfaultfd/userfaultfd.c', line 1834

static VALUE
event_reader_read_events(int argc, VALUE *argv, VALUE self)
{
    VALUE max_value = Qnil;
    event_reader_data_t *data;
    size_t maximum = 16;
    rb_scan_args(argc, argv, "01", &max_value);
    if (!NIL_P(max_value)) maximum = NUM2SIZET(max_value);
    if (maximum == 0 || maximum > 1024)
        rb_raise(rb_eArgError, "max must be between 1 and 1024");
    TypedData_Get_Struct(self, event_reader_data_t, &event_reader_type, data);
#ifdef __linux__
    {
        struct event_record *records = ALLOC_N(struct event_record, maximum);
        ssize_t count = read(data->output_pipe[0], records,
                             sizeof(struct event_record) * maximum);
        VALUE result = rb_ary_new();
        VALUE owners = rb_ivar_get(self, rb_intern("@owners"));
        size_t length, i;
        if (count < 0) {
            xfree(records);
            if (errno == EAGAIN || errno == EINTR) return result;
            rb_syserr_fail(errno, "read(userfaultfd event pipe)");
        }
        if (count == 0) {
            xfree(records);
            if (data->error) rb_syserr_fail(data->error, "userfaultfd event reader");
            return result;
        }
        if ((size_t)count % sizeof(struct event_record) != 0) {
            xfree(records);
            rb_raise(eError, "short event-reader record");
        }
        length = (size_t)count / sizeof(struct event_record);
        for (i = 0; i < length; i++) {
            VALUE owner = rb_hash_aref(owners, INT2NUM(records[i].source_fd));
            VALUE event;
            if (NIL_P(owner)) {
                xfree(records);
                rb_raise(eError, "unknown userfaultfd event source");
            }
#ifdef UFFD_EVENT_FORK
            if (records[i].message.event == UFFD_EVENT_FORK) {
                int raw_fd = (int)records[i].message.arg.fork.ufd;
                int duplicated = dup(raw_fd);
                if (duplicated < 0) {
                    xfree(records);
                    rb_syserr_fail(errno, "dup(child userfaultfd)");
                }
                records[i].message.arg.fork.ufd = (uint32_t)duplicated;
                event = parse_event(owner, &records[i].message);
                rb_hash_aset(owners, INT2NUM(raw_fd),
                             rb_ivar_get(event, rb_intern("@child_uffd")));
            } else
#endif
            {
                event = parse_event(owner, &records[i].message);
            }
            if (!NIL_P(event)) rb_ary_push(result, event);
        }
        xfree(records);
        return result;
    }
#else
    raise_unsupported("event readers are only available on Linux");
#endif
}

#running? ⇒ Boolean

Returns:

• (Boolean)

# File 'ext/userfaultfd/userfaultfd.c', line 1914

static VALUE
event_reader_running_p(VALUE self)
{
    event_reader_data_t *data;
    TypedData_Get_Struct(self, event_reader_data_t, &event_reader_type, data);
    return data->running ? Qtrue : Qfalse;
}

#stop ⇒ Object

# File 'ext/userfaultfd/userfaultfd.c', line 1902

static VALUE
event_reader_stop(VALUE self)
{
    event_reader_data_t *data;
    TypedData_Get_Struct(self, event_reader_data_t, &event_reader_type, data);
    if (data->pid != getpid()) rb_raise(eError, "event reader cannot be used after fork");
    event_reader_stop_and_join(data);
    event_reader_close_owned(data);
    if (data->error) rb_syserr_fail(data->error, "userfaultfd event reader");
    return self;
}