uringmachine 0.29.2 → 0.31.0

data/ext/um/um.h

@@ -48,6 +48,9 @@ enum um_op_kind {
   OP_CLOSE,
   OP_CLOSE_ASYNC,
   OP_STATX,
+  OP_SPLICE,
+  OP_TEE,
+  OP_FSYNC,
 
   OP_ACCEPT,
   OP_RECV,
@@ -77,12 +80,12 @@ enum um_op_kind {
   OP_TIMEOUT_MULTISHOT,
 };
 
-enum um_stream_mode {
-  STREAM_BP_READ,
-  STREAM_BP_RECV,
-  STREAM_SSL,
-  STREAM_STRING,
-  STREAM_IO_BUFFER
+enum um_connection_mode {
+  CONNECTION_FD,
+  CONNECTION_SOCKET,
+  CONNECTION_SSL,
+  CONNECTION_STRING,
+  CONNECTION_IO_BUFFER
 };
 
 #define OP_F_CQE_SEEN       (1U << 0) // CQE has been seen
@@ -161,7 +164,7 @@ struct um_op {
     struct iovec *iovecs; // used for vectorized write/send
     siginfo_t siginfo; // used for waitid
     int int_value; // used for getsockopt
-    size_t bp_commit_level; // buffer pool commit threshold
+    size_t bp_commit_level; // buffer pool commit level
   };
 };
 
@@ -269,11 +272,11 @@ struct um_async_op {
   struct um_op *op;
 };
 
-struct um_stream {
+struct um_connection {
   VALUE self;
   struct um *machine;
 
-  enum um_stream_mode mode;
+  enum um_connection_mode mode;
   union {
     int fd;
     VALUE target;
@@ -301,7 +304,7 @@ extern VALUE eUMError;
 extern VALUE cMutex;
 extern VALUE cQueue;
 extern VALUE cAsyncOp;
-extern VALUE eStreamRESPError;
+extern VALUE eConnectionRESPError;
 
 struct um *um_get_machine(VALUE self);
 void um_setup(VALUE self, struct um *machine, uint size, uint sqpoll_timeout_msec, int sidecar_mode);
@@ -325,7 +328,6 @@ void um_op_list_compact(struct um *machine, struct um_op *head);
 void um_op_multishot_results_push(struct um *machine, struct um_op *op, __s32 res, __u32 flags);
 void um_op_multishot_results_clear(struct um *machine, struct um_op *op);
 
-struct um_segment *um_segment_alloc(struct um *machine);
 void um_segment_free(struct um *machine, struct um_segment *segment);
 
 void um_runqueue_push(struct um *machine, struct um_op *op);
@@ -350,7 +352,7 @@ int um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size_t *siz
 void * um_prepare_read_buffer(VALUE buffer, ssize_t len, ssize_t ofs);
 void um_update_read_buffer(VALUE buffer, ssize_t buffer_offset, __s32 result);
 int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count);
-VALUE um_get_string_from_buffer_ring(struct um *machine, int bgid, __s32 result, __u32 flags);
+VALUE um_read_from_buffer_ring(struct um *machine, int bgid, __s32 result, __u32 flags);
 void um_add_strings_to_buffer_ring(struct um *machine, int bgid, VALUE strings);
 struct iovec *um_alloc_iovecs_for_writing(int argc, VALUE *argv, size_t *total_len);
 void um_advance_iovecs_for_writing(struct iovec **ptr, int *len, size_t adv);
@@ -376,7 +378,7 @@ VALUE um_read(struct um *machine, int fd, VALUE buffer, size_t maxlen, ssize_t b
 size_t um_read_raw(struct um *machine, int fd, char *buffer, size_t maxlen);
 VALUE um_read_each(struct um *machine, int fd, int bgid);
 VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset);
-size_t um_write_raw(struct um *machine, int fd, const char *buffer, size_t maxlen);
+size_t um_write_raw(struct um *machine, int fd, const char *buffer, size_t len);
 VALUE um_writev(struct um *machine, int fd, int argc, VALUE *argv);
 VALUE um_write_async(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset);
 VALUE um_close(struct um *machine, int fd);
@@ -391,6 +393,9 @@ VALUE um_waitid_status(struct um *machine, int idtype, int id, int options);
 #endif
 
 VALUE um_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned int mask);
+VALUE um_splice(struct um *machine, int in_fd, int out_fd, uint nbytes);
+VALUE um_tee(struct um *machine, int in_fd, int out_fd, uint nbytes);
+VALUE um_fsync(struct um *machine, int fd);
 
 VALUE um_accept(struct um *machine, int fd);
 VALUE um_accept_each(struct um *machine, int fd);
@@ -398,6 +403,7 @@ VALUE um_accept_into_queue(struct um *machine, int fd, VALUE queue);
 VALUE um_socket(struct um *machine, int domain, int type, int protocol, uint flags);
 VALUE um_connect(struct um *machine, int fd, const struct sockaddr *addr, socklen_t addrlen);
 VALUE um_send(struct um *machine, int fd, VALUE buffer, size_t len, int flags);
+size_t um_send_raw(struct um *machine, int fd, const char *buffer, size_t len, int flags);
 VALUE um_sendv(struct um *machine, int fd, int argc, VALUE *argv);
 VALUE um_send_bundle(struct um *machine, int fd, int bgid, VALUE strings);
 VALUE um_recv(struct um *machine, int fd, VALUE buffer, size_t maxlen, int flags);
@@ -432,12 +438,16 @@ VALUE um_queue_pop(struct um *machine, struct um_queue *queue);
 VALUE um_queue_unshift(struct um *machine, struct um_queue *queue, VALUE value);
 VALUE um_queue_shift(struct um *machine, struct um_queue *queue);
 
-void stream_teardown(struct um_stream *stream);
-void stream_clear(struct um_stream *stream);
-VALUE stream_get_line(struct um_stream *stream, VALUE buf, size_t maxlen);
-VALUE stream_get_string(struct um_stream *stream, VALUE out_buffer, ssize_t len, size_t inc, int safe_inc);
-void stream_skip(struct um_stream *stream, size_t inc, int safe_inc);
-VALUE resp_decode(struct um_stream *stream, VALUE out_buffer);
+void connection_teardown(struct um_connection *conn);
+void connection_clear(struct um_connection *conn);
+VALUE connection_read_line(struct um_connection *conn, VALUE out_buffer, size_t maxlen);
+VALUE connection_read(struct um_connection *conn, VALUE out_buffer, ssize_t len, size_t inc, int safe_inc);
+VALUE connection_read_to_delim(struct um_connection *conn, VALUE out_buffer, VALUE delim, ssize_t maxlen);
+void connection_skip(struct um_connection *conn, size_t inc, int safe_inc);
+void connection_read_each(struct um_connection *conn);
+size_t connection_write_raw(struct um_connection *conn, const char *buffer, size_t len);
+VALUE connection_writev(struct um_connection *conn, int argc, VALUE *argv);
+VALUE resp_read(struct um_connection *conn, VALUE out_buffer);
 void resp_encode(struct um_write_buffer *buf, VALUE obj);
 void resp_encode_cmd(struct um_write_buffer *buf, int argc, VALUE *argv);
 
@@ -454,9 +464,11 @@ void um_sidecar_signal_wait(struct um *machine);
 void um_sidecar_signal_wake(struct um *machine);
 
 void um_ssl_set_bio(struct um *machine, VALUE ssl_obj);
-int um_ssl_read(struct um *machine, VALUE ssl, VALUE buf, int maxlen);
-int um_ssl_read_raw(struct um *machine, VALUE ssl_obj, char *ptr, int maxlen);
-int um_ssl_write(struct um *machine, VALUE ssl, VALUE buf, int len);
+int um_ssl_read(struct um *machine, VALUE ssl, VALUE buf, size_t maxlen);
+int um_ssl_read_raw(struct um *machine, VALUE ssl_obj, char *ptr, size_t maxlen);
+int um_ssl_write(struct um *machine, VALUE ssl, VALUE buf, size_t len);
+int um_ssl_write_raw(struct um *machine, VALUE ssl, const char *buffer, size_t len);
+int um_ssl_writev(struct um *machine, VALUE ssl, int argc, VALUE *argv);
 
 void bp_setup(struct um *machine);
 void bp_teardown(struct um *machine);

data/ext/um/um_buffer_pool.c

@@ -18,7 +18,7 @@ inline struct um_buffer *buffer_alloc(struct um *machine) {
   return buffer;
 }
 
-inline struct um_buffer *bp_buffer_checkout(struct um *machine) {
+struct um_buffer *bp_buffer_checkout(struct um *machine) {
   struct um_buffer *buffer = machine->bp_buffer_freelist;
   if (buffer) {
     struct um_buffer *next = buffer->next;
@@ -50,13 +50,13 @@ inline void buffer_free(struct um *machine, struct um_buffer *buffer) {
   }
 }
 
-inline void bp_buffer_checkin(struct um *machine, struct um_buffer *buffer) {
+void bp_buffer_checkin(struct um *machine, struct um_buffer *buffer) {
   assert(buffer->ref_count > 0);
   buffer->ref_count--;
   if (!buffer->ref_count) buffer_free(machine, buffer);
 }
 
-inline void bp_discard_buffer_freelist(struct um *machine) {
+void bp_discard_buffer_freelist(struct um *machine) {
   while (machine->bp_buffer_freelist) {
     struct um_buffer *buffer = machine->bp_buffer_freelist;
     struct um_buffer *next = buffer->next;
@@ -69,7 +69,7 @@ inline void bp_discard_buffer_freelist(struct um *machine) {
   }
 }
 
-inline void bp_setup(struct um *machine) {
+void bp_setup(struct um *machine) {
   int ret;
   machine->bp_br = io_uring_setup_buf_ring(&machine->ring, BP_BR_ENTRIES, BP_BGID, IOU_PBUF_RING_INC, &ret);
   if (unlikely(!machine->bp_br)) rb_syserr_fail(ret, strerror(ret));
@@ -85,7 +85,7 @@ inline void bp_setup(struct um *machine) {
   machine->bp_total_commited = 0;
 }
 
-inline void bp_teardown(struct um *machine) {
+void bp_teardown(struct um *machine) {
   bp_discard_buffer_freelist(machine);
   for (int i = 0; i < BP_BR_ENTRIES; i++) {
     struct um_buffer *buffer = machine->bp_commited_buffers[i];
@@ -162,7 +162,7 @@ inline int should_commit_more_p(struct um *machine) {
          (machine->bp_total_commited < machine->bp_commit_level);
 }
 
-inline void bp_ensure_commit_level(struct um *machine) {
+void bp_ensure_commit_level(struct um *machine) {
   if (machine->bp_total_commited > (machine->bp_commit_level / 2))
     return;
 
@@ -179,7 +179,7 @@ inline void bp_ensure_commit_level(struct um *machine) {
   // size.
 }
 
-inline void bp_handle_enobufs(struct um *machine) {
+void bp_handle_enobufs(struct um *machine) {
   if (unlikely(machine->bp_commit_level >= BP_MAX_COMMIT_LEVEL))
     rb_raise(eUMError, "Buffer starvation");
 
@@ -189,7 +189,7 @@ inline void bp_handle_enobufs(struct um *machine) {
   bp_discard_buffer_freelist(machine);
 }
 
-inline struct um_segment *um_segment_alloc(struct um *machine) {
+inline struct um_segment *segment_alloc(struct um *machine) {
   if (machine->segment_freelist) {
     struct um_segment *segment = machine->segment_freelist;
     machine->segment_freelist = segment->next;
@@ -208,14 +208,14 @@ inline struct um_segment *um_segment_alloc(struct um *machine) {
   return batch;
 }
 
-inline void um_segment_free(struct um *machine, struct um_segment *segment) {
+void um_segment_free(struct um *machine, struct um_segment *segment) {
   segment->next = machine->segment_freelist;
   machine->segment_freelist = segment;
   machine->metrics.segments_free++;
 }
 
-inline struct um_segment *bp_buffer_consume(struct um *machine, struct um_buffer *buffer, size_t len) {
-  struct um_segment *segment = um_segment_alloc(machine);
+struct um_segment *bp_buffer_consume(struct um *machine, struct um_buffer *buffer, size_t len) {
+  struct um_segment *segment = segment_alloc(machine);
   segment->ptr = buffer->buf + buffer->pos;
   segment->len = len;
   segment->buffer = buffer;

data/ext/um/um_class.c

@@ -534,6 +534,60 @@ VALUE UM_statx(VALUE self, VALUE dirfd, VALUE path, VALUE flags, VALUE mask) {
   return um_statx(machine, NUM2INT(dirfd), path, NUM2INT(flags), NUM2UINT(mask));
 }
 
+/* call-seq:
+ *   machine.splice(in_fd, out_fd, nbytes) -> len
+ *
+ * Splices bytes from in_fd to out_fd. At least one of the given fds must be a
+ * pipe.
+ *
+ * - https://www.man7.org/linux/man-pages/man2/splice.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_splice.3.html
+ *
+ * @param in_fd [Integer] fd to splice from
+ * @param out_fd [Integer] fd to splice to
+ * @param nbytes [Integer] number of bytes to splice
+ * @return [Integer] number of bytes spliced
+ */
+VALUE UM_splice(VALUE self, VALUE in_fd, VALUE out_fd, VALUE nbytes) {
+  struct um *machine = um_get_machine(self);
+  return um_splice(machine, NUM2INT(in_fd), NUM2INT(out_fd), NUM2UINT(nbytes));
+}
+
+/* call-seq:
+ *   machine.tee(in_fd, out_fd, nbytes) -> len
+ *
+ * Duplicates bytes from in_fd to out_fd. At least one of the given fds must be
+ * a pipe.
+ *
+ * - https://www.man7.org/linux/man-pages/man2/tee.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_tee.3.html
+ *
+ * @param in_fd [Integer] fd to copy from
+ * @param out_fd [Integer] fd to copy to
+ * @param nbytes [Integer] number of bytes to duplicate
+ * @return [Integer] number of bytes duplicated
+ */
+VALUE UM_tee(VALUE self, VALUE in_fd, VALUE out_fd, VALUE nbytes) {
+  struct um *machine = um_get_machine(self);
+  return um_tee(machine, NUM2INT(in_fd), NUM2INT(out_fd), NUM2UINT(nbytes));
+}
+
+/* call-seq:
+ *   machine.fsync(fd) -> 0
+ *
+ * Flushes all modified file data to the storage device.
+ *
+ * - https://www.man7.org/linux/man-pages/man2/fsync.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_fsync.3.html
+ *
+ * @param fd [Integer] fd
+ * @return [Integer] 0 if successful
+ */
+VALUE UM_fsync(VALUE self, VALUE fd) {
+  struct um *machine = um_get_machine(self);
+  return um_fsync(machine, NUM2INT(fd));
+}
+
 /* call-seq:
  *   machine.close(fd) -> 0
  *
@@ -1480,6 +1534,9 @@ void Init_UM(void) {
   rb_define_method(cUM, "writev", UM_writev, -1);
   rb_define_method(cUM, "write_async", UM_write_async, -1);
   rb_define_method(cUM, "statx", UM_statx, 4);
+  rb_define_method(cUM, "splice", UM_splice, 3);
+  rb_define_method(cUM, "tee", UM_tee, 3);
+  rb_define_method(cUM, "fsync", UM_fsync, 1);
 
   rb_define_method(cUM, "poll", UM_poll, 2);
   rb_define_method(cUM, "select", UM_select, 3);