ublk 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bba0d82a93398079b7ed866556fcc9e6b6d7c88f16a6afcf0c254bd4b18d8a5b
+  data.tar.gz: 52f2b58dd1fae0a22fbfe1d2bffd28f139f4e8cc34b1f6f7b22a040b92f01052
+SHA512:
+  metadata.gz: b8d17740f6692d5cbd4a0f159c3f715348e909daf499cf1e899d1fc426a5fcf20f002186744fda7d7f22ea3eb69f734b7a2c050c687ca206e5164b1808e45f84
+  data.tar.gz: 23c5cf0c070cd73825935f7531bf43e2e3d9b5e08f93875a14b9c24fb1544887d608b3050532af464d5fd143163ff48c947a1f25223424b5e0908255851e7002

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Yudai Takada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,148 @@
+# UBLK
+
+Write Linux block-device targets in Ruby. UBLK uses a C extension, liburing,
+and the kernel's `UBLK_F_USER_COPY` interface so target implementations only
+exchange Ruby strings.
+
+> [!WARNING]
+> This is experimental. Never use it for a root filesystem, swap, or data you
+> cannot recreate. A Ruby GC pause stops device I/O, and a crashed server makes
+> outstanding I/O fail unless recovery was enabled.
+
+## Requirements
+
+- Linux 6.6 or newer with `CONFIG_BLK_DEV_UBLK`
+- `/dev/ublk-control` and normally `CAP_SYS_ADMIN`
+- Ruby 3.2 or newer
+- liburing headers (`liburing-dev` on Debian/Ubuntu, `liburing-devel` on Fedora)
+
+The gem deliberately fails to build without liburing. Once installed,
+`require "ublk"` remains safe on unsupported hosts and `UBLK.supported?`
+reports whether the running kernel exposes USER_COPY.
+
+```sh
+bundle install
+bundle exec rake compile
+```
+
+## RAM disk
+
+```ruby
+require "ublk"
+
+class RamDisk < UBLK::Target
+  def initialize(size)
+    @data = "\0".b * size
+    super(size:)
+  end
+
+  def read(offset, length) = @data.byteslice(offset, length)
+
+  def write(offset, data)
+    @data[offset, data.bytesize] = data
+    data.bytesize
+  end
+end
+
+device = UBLK::Device.create(RamDisk.new(256 * 1024 * 1024))
+puts device.path
+device.run
+```
+
+`run` blocks until another thread calls `stop` or the process receives an
+interrupt. For a background server, call `start`, use `device.path`, then call
+`delete`. Created devices are also deleted by an `at_exit` hook.
+
+Targets must implement `read` and `write`. `flush` succeeds by default;
+`discard` and `write_zeroes` default to `EOPNOTSUPP`. Raising an `Errno::*`
+exception returns that errno to the kernel; other exceptions become `EIO`.
+
+`Device.create` locks current and future memory by default to avoid a paging
+deadlock. Pass `mlock: false` only for disposable development devices. Multiple
+hardware queues use one Ruby thread each, but callbacks remain serialized by
+the GVL.
+
+See `examples/` for RAM, file-backed, HTTP read-only, encrypted, tracing, and
+fault-injection targets.
+
+## Recovery
+
+Create with `recovery: true`, then reconnect after a server restart:
+
+```ruby
+device = UBLK::Device.recover(target, id: 0)
+device.run
+```
+
+Outstanding requests fail during this v1 recovery mode; they are not reissued.
+
+## Unsupported environments
+
+- macOS and Windows: no Linux ublk driver
+- Docker Desktop: its VM normally does not expose `/dev/ublk-control`
+- containers without the host ublk device and the required capability
+- WSL2 kernels without `CONFIG_BLK_DEV_UBLK`
+- Linux before 6.6: no required USER_COPY interface
+- standard GitHub-hosted jobs: no usable privileged ublk device
+
+## Tests
+
+```sh
+bundle exec rake compile
+bundle exec rake test:unit
+bundle exec rbs validate
+```
+
+The destructive system suite only runs when explicitly enabled inside a VM.
+It covers 64 MiB raw reads, maximum-I/O boundary crossing, ext4 and fsck,
+flush/discard callbacks, errno propagation, device deletion, SIGKILL recovery,
+four-way verified fio, a one-minute RSS leak check, and 1,000 control opens.
+
+```sh
+tools/vm/run.sh v6.6
+tools/vm/run.sh v6.12
+```
+
+Run 4K random-read, random-write, and sequential-read fio workloads in the
+same VM:
+
+```sh
+UBLK_BENCH=1 bundle exec ruby tools/bench.rb
+UBLK_BENCH=1 UBLK_BENCH_GC_STRESS=1 bundle exec ruby tools/bench.rb
+UBLK_BENCH=1 UBLK_BENCH_DEVICE=/dev/ublkb0 bundle exec ruby tools/bench.rb
+```
+
+The last form measures an externally started device, such as `ublksrv`'s C
+loop target, with the identical fio arguments. fio's JSON includes IOPS and
+p99 latency. No hardware-independent number is claimed: CPU, Ruby, GC, and VM
+acceleration materially change the result, and Ruby callbacks remain bounded
+by the GVL.
+
+### Reference benchmark
+
+One reproducible comparison was run on Linux 6.12.0 under QEMU TCG (2 vCPUs,
+1.5 GiB RAM), using Ruby 3.2, fio 3.36, and upstream ublksrv 1.6.1
+(`abbfea2b5918`). Both loop targets used a 256 MiB sparse file on `/tmp`, one
+queue of depth 128, and buffered backing-file I/O. fio used its io_uring engine,
+4 KiB direct I/O, iodepth 32, and one 30-second run per workload.
+
+| Target | Workload | IOPS | completion p99 |
+|---|---:|---:|---:|
+| Ruby loop | random read | 33,774 | 2.900 ms |
+| Ruby loop | random write | 33,896 | 2.376 ms |
+| Ruby loop | sequential read | 26,801 | 3.850 ms |
+| C ublksrv loop | random read | 64,213 | 0.938 ms |
+| C ublksrv loop | random write | 56,456 | 1.090 ms |
+| C ublksrv loop | sequential read | 62,011 | 0.987 ms |
+| Ruby loop, `GC.stress` | random read | 9.72 | 6.610 s |
+| Ruby loop, `GC.stress` | random write | 12.61 | 4.178 s |
+| Ruby loop, `GC.stress` | sequential read | 7.42 | 7.952 s |
+
+These are diagnostic VM results, not production performance claims. In this
+run the C loop target delivered roughly 1.7–2.3 times the IOPS of normal Ruby,
+while `GC.stress` demonstrated that stop-the-world GC can make latency
+unacceptable for block storage.
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "fileutils"
+require "rake/extensiontask"
+require "rspec/core/rake_task"
+require "yard"
+
+Rake::ExtensionTask.new("ublk") do |ext|
+  ext.lib_dir = "lib/ublk"
+end
+
+YARD::Rake::YardocTask.new
+
+namespace :test do
+  RSpec::Core::RakeTask.new(:unit) { |task| task.pattern = "spec/unit/**/*_spec.rb" }
+  RSpec::Core::RakeTask.new(:system) { |task| task.pattern = "spec/system/**/*_spec.rb" }
+end
+
+namespace :gen do
+  desc "Regenerate Ruby constants from the installed Linux ublk headers"
+  task :constants do
+    executable = "tmp/dump_ublk_constants"
+    FileUtils.mkdir_p("tmp")
+    sh RbConfig::CONFIG.fetch("CC"), "-Iext/ublk", "tools/dump_constants.c", "-o", executable
+    names = IO.popen([executable], &:read).lines.map { |line| line.split("=", 2).first }
+    body = names.map { |name| "  UBLK_CONST(#{name});" }.join("\n")
+    File.write("ext/ublk/constants.c", <<~C)
+      /* Generated by rake gen:constants. */
+      #include "internal.h"
+
+      #define UBLK_CONST(name) rb_define_const(ublk_native_module, #name, ULL2NUM(name))
+
+      void ublk_init_constants(void)
+      {
+      #{body}
+      }
+    C
+  end
+end
+
+task default: "test:unit"

data/examples/encrypted.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "openssl"
+require "ublk"
+
+class EncryptedDisk < UBLK::Target
+  def initialize(path, size:, key:)
+    raise ArgumentError, "key must be 32 bytes" unless key.bytesize == 32
+
+    @file = File.open(path, File::RDWR | File::CREAT, 0o600)
+    @file.truncate(size)
+    @key = key
+    super(size:)
+  end
+
+  def read(offset, length) = crypt(offset, @file.pread(length, offset))
+
+  def write(offset, data)
+    @file.pwrite(crypt(offset, data), offset)
+  end
+
+  def flush = @file.fsync
+
+  def discard(offset, length)
+    write(offset, "\0".b * length)
+    0
+  end
+
+  alias write_zeroes discard
+
+  private
+
+  def crypt(offset, data)
+    cipher = OpenSSL::Cipher.new("aes-256-ctr")
+    cipher.encrypt
+    cipher.key = @key
+    cipher.iv = [0, offset / 16].pack("Q>Q>")
+    cipher.update(data) + cipher.final
+  end
+end
+
+abort "usage: UBLK_KEY_HEX=<64 hex chars> #{$PROGRAM_NAME} FILE SIZE" unless ARGV.size == 2 && ENV["UBLK_KEY_HEX"]
+key = [ENV.fetch("UBLK_KEY_HEX")].pack("H*")
+UBLK::Device.create(EncryptedDisk.new(ARGV.fetch(0), size: Integer(ARGV.fetch(1), 10), key:)).run

data/examples/fault_injection.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "ramdisk"
+
+class FaultInjectionDisk < RamDisk
+  def initialize(size, failing_range)
+    @failing_range = failing_range
+    super(size)
+  end
+
+  def read(offset, length)
+    fail_if_needed(offset, length)
+    super
+  end
+
+  def write(offset, data)
+    fail_if_needed(offset, data.bytesize)
+    super
+  end
+
+  private
+
+  def fail_if_needed(offset, length)
+    raise Errno::EIO if offset < @failing_range.end && offset + length > @failing_range.begin
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  disk = FaultInjectionDisk.new(256 * 1024 * 1024, (64 * 1024 * 1024)...(65 * 1024 * 1024))
+  UBLK::Device.create(disk).run
+end

data/examples/http_disk.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "ublk"
+
+class HTTPDisk < UBLK::Target
+  def initialize(url)
+    @uri = URI(url)
+    response = Net::HTTP.start(@uri.host, @uri.port, use_ssl: @uri.scheme == "https") { |http| http.head(@uri.request_uri) }
+    super(size: Integer(response.fetch("content-length"), 10))
+  end
+
+  def read(offset, length)
+    request = Net::HTTP::Get.new(@uri)
+    request["Range"] = "bytes=#{offset}-#{offset + length - 1}"
+    response = Net::HTTP.start(@uri.host, @uri.port, use_ssl: @uri.scheme == "https") { |http| http.request(request) }
+    raise Errno::EIO, "HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+    response.body
+  end
+
+  def read_only? = true
+end
+
+abort "usage: #{$PROGRAM_NAME} URL" unless ARGV.one?
+UBLK::Device.create(HTTPDisk.new(ARGV.fetch(0))).run

data/examples/loop.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "ublk"
+
+class LoopTarget < UBLK::Target
+  def initialize(path, size: File.size(path), read_only: false)
+    @file = File.open(path, read_only ? "rb" : "r+b")
+    @read_only = read_only
+    super(size:)
+  end
+
+  def read(offset, length) = @file.pread(length, offset)
+  def write(offset, data) = @file.pwrite(data, offset)
+  def flush = @file.fsync
+  def read_only? = @read_only
+end
+
+if $PROGRAM_NAME == __FILE__
+  abort "usage: #{$PROGRAM_NAME} IMAGE" unless ARGV.one?
+  UBLK::Device.create(LoopTarget.new(ARGV.fetch(0))).run
+end

data/examples/ramdisk.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "ublk"
+
+class RamDisk < UBLK::Target
+  def initialize(size)
+    @data = "\0".b * size
+    super(size:)
+  end
+
+  def read(offset, length) = @data.byteslice(offset, length)
+
+  def write(offset, data)
+    @data[offset, data.bytesize] = data
+    data.bytesize
+  end
+
+  def discard(offset, length)
+    @data[offset, length] = "\0".b * length
+    0
+  end
+
+  alias write_zeroes discard
+end
+
+UBLK::Device.create(RamDisk.new(256 * 1024 * 1024)).run if $PROGRAM_NAME == __FILE__

data/examples/tracing.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "ramdisk"
+
+class TracingTarget < UBLK::Target
+  def initialize(target, output: $stderr)
+    @target = target
+    @output = output
+    super(size: target.size, queues: target.queues, depth: target.depth)
+  end
+
+  %i[read write discard write_zeroes].each do |operation|
+    define_method(operation) do |offset, value|
+      @output.puts("#{operation} offset=#{offset} length=#{value.respond_to?(:bytesize) ? value.bytesize : value}")
+      @target.public_send(operation, offset, value)
+    end
+  end
+
+  def flush
+    @output.puts("flush")
+    @target.flush
+  end
+end
+
+UBLK::Device.create(TracingTarget.new(RamDisk.new(256 * 1024 * 1024))).run

data/ext/ublk/compat.h

@@ -0,0 +1,188 @@
+#ifndef UBLK_COMPAT_H
+#define UBLK_COMPAT_H
+
+#include <linux/ioctl.h>
+#include <linux/types.h>
+#include <stddef.h>
+
+#if !defined(UBLK_FORCE_COMPAT) && defined(__has_include)
+#if __has_include(<linux/ublk_cmd.h>)
+#include <linux/ublk_cmd.h>
+#define UBLK_HAVE_UAPI_HEADER 1
+#endif
+#endif
+
+#ifndef UBLK_HAVE_UAPI_HEADER
+#define UBLK_CMD_GET_QUEUE_AFFINITY 0x01
+#define UBLK_CMD_GET_DEV_INFO 0x02
+#define UBLK_CMD_ADD_DEV 0x04
+#define UBLK_CMD_DEL_DEV 0x05
+#define UBLK_CMD_START_DEV 0x06
+#define UBLK_CMD_STOP_DEV 0x07
+#define UBLK_CMD_SET_PARAMS 0x08
+#define UBLK_CMD_GET_PARAMS 0x09
+#define UBLK_CMD_START_USER_RECOVERY 0x10
+#define UBLK_CMD_END_USER_RECOVERY 0x11
+#define UBLK_CMD_GET_DEV_INFO2 0x12
+
+#define UBLK_IO_FETCH_REQ 0x20
+#define UBLK_IO_COMMIT_AND_FETCH_REQ 0x21
+#define UBLK_IO_NEED_GET_DATA 0x22
+
+#define UBLK_F_USER_RECOVERY (1ULL << 3)
+
+#define UBLK_IO_OP_READ 0
+#define UBLK_IO_OP_WRITE 1
+#define UBLK_IO_OP_FLUSH 2
+#define UBLK_IO_OP_DISCARD 3
+#define UBLK_IO_OP_WRITE_SAME 4
+#define UBLK_IO_OP_WRITE_ZEROES 5
+
+#define UBLK_ATTR_READ_ONLY (1U << 0)
+#define UBLK_ATTR_ROTATIONAL (1U << 1)
+#define UBLK_ATTR_VOLATILE_CACHE (1U << 2)
+#define UBLK_ATTR_FUA (1U << 3)
+#define UBLK_PARAM_TYPE_BASIC (1U << 0)
+#define UBLK_PARAM_TYPE_DISCARD (1U << 1)
+
+struct ublksrv_io_desc {
+  __u32 op_flags;
+  __u32 nr_sectors;
+  __u64 start_sector;
+  __u64 addr;
+};
+
+struct ublksrv_io_cmd {
+  __u16 q_id;
+  __u16 tag;
+  __s32 result;
+  __u64 addr;
+};
+
+struct ublk_param_basic {
+  __u32 attrs;
+  __u8 logical_bs_shift;
+  __u8 physical_bs_shift;
+  __u8 io_opt_shift;
+  __u8 io_min_shift;
+  __u32 max_sectors;
+  __u32 chunk_sectors;
+  __u64 dev_sectors;
+  __u64 virt_boundary_mask;
+};
+
+struct ublk_param_discard {
+  __u32 discard_alignment;
+  __u32 discard_granularity;
+  __u32 max_discard_sectors;
+  __u32 max_write_zeroes_sectors;
+  __u16 max_discard_segments;
+  __u16 reserved0;
+};
+#endif
+
+#ifndef UBLK_F_CMD_IOCTL_ENCODE
+#define UBLK_F_CMD_IOCTL_ENCODE (1ULL << 6)
+#endif
+#ifndef UBLK_F_USER_COPY
+#define UBLK_F_USER_COPY (1ULL << 7)
+#endif
+#ifndef UBLK_MAX_QUEUE_DEPTH
+#define UBLK_MAX_QUEUE_DEPTH 4096
+#endif
+#ifndef UBLK_MAX_NR_QUEUES
+#define UBLK_MAX_NR_QUEUES 4096
+#endif
+#ifndef UBLKSRV_CMD_BUF_OFFSET
+#define UBLKSRV_CMD_BUF_OFFSET 0
+#endif
+#ifndef UBLKSRV_IO_BUF_OFFSET
+#define UBLKSRV_IO_BUF_OFFSET 0x80000000ULL
+#endif
+#ifndef UBLK_CMD_GET_FEATURES
+#define UBLK_CMD_GET_FEATURES 0x13
+#endif
+#ifndef UBLK_IO_BUF_BITS
+#define UBLK_IO_BUF_BITS 25
+#endif
+#ifndef UBLK_TAG_OFF
+#define UBLK_TAG_OFF UBLK_IO_BUF_BITS
+#endif
+#ifndef UBLK_QID_OFF
+#define UBLK_QID_OFF (UBLK_TAG_OFF + 16)
+#endif
+
+struct ublk_rb_ctrl_cmd {
+  __u32 dev_id;
+  __u16 queue_id;
+  __u16 len;
+  __u64 addr;
+  __u64 data[1];
+  __u16 dev_path_len;
+  __u16 pad;
+  __u32 reserved;
+};
+
+struct ublk_rb_dev_info {
+  __u16 nr_hw_queues;
+  __u16 queue_depth;
+  __u16 state;
+  __u16 pad0;
+  __u32 max_io_buf_bytes;
+  __u32 dev_id;
+  __s32 ublksrv_pid;
+  __u32 pad1;
+  __u64 flags;
+  __u64 ublksrv_flags;
+  __u32 owner_uid;
+  __u32 owner_gid;
+  __u64 reserved1;
+  __u64 reserved2;
+};
+
+struct ublk_rb_params {
+  __u32 len;
+  __u32 types;
+  struct ublk_param_basic basic;
+  struct ublk_param_discard discard;
+};
+
+#define UBLK_RB_U_READ_CMD(op) _IOR('u', (op), struct ublk_rb_ctrl_cmd)
+#define UBLK_RB_U_RDWR_CMD(op) _IOWR('u', (op), struct ublk_rb_ctrl_cmd)
+#define UBLK_RB_U_IO_CMD(op) _IOWR('u', (op), struct ublksrv_io_cmd)
+
+_Static_assert(sizeof(struct ublk_rb_ctrl_cmd) == 32, "unexpected ublk control command layout");
+_Static_assert(sizeof(struct ublk_rb_dev_info) == 64, "unexpected ublk device info layout");
+_Static_assert(sizeof(struct ublk_rb_params) == 64, "unexpected ublk parameter layout");
+_Static_assert(sizeof(struct ublksrv_io_desc) == 24, "unexpected ublk I/O descriptor layout");
+_Static_assert(sizeof(struct ublksrv_io_cmd) == 16, "unexpected ublk I/O command layout");
+
+#ifdef UBLK_U_CMD_GET_FEATURES
+_Static_assert(UBLK_RB_U_READ_CMD(UBLK_CMD_GET_FEATURES) == UBLK_U_CMD_GET_FEATURES,
+               "GET_FEATURES command encoding mismatch");
+#endif
+#ifdef UBLK_U_CMD_GET_DEV_INFO
+_Static_assert(UBLK_RB_U_READ_CMD(UBLK_CMD_GET_DEV_INFO) == UBLK_U_CMD_GET_DEV_INFO,
+               "GET_DEV_INFO command encoding mismatch");
+#endif
+#ifdef UBLK_U_CMD_ADD_DEV
+_Static_assert(UBLK_RB_U_RDWR_CMD(UBLK_CMD_ADD_DEV) == UBLK_U_CMD_ADD_DEV,
+               "ADD_DEV command encoding mismatch");
+#endif
+
+#ifdef UBLK_HAVE_UAPI_HEADER
+_Static_assert(sizeof(struct ublk_rb_ctrl_cmd) == sizeof(struct ublksrv_ctrl_cmd),
+               "control command size differs from Linux UAPI");
+_Static_assert(offsetof(struct ublk_rb_ctrl_cmd, addr) == offsetof(struct ublksrv_ctrl_cmd, addr),
+               "control command address offset differs from Linux UAPI");
+_Static_assert(sizeof(struct ublk_rb_dev_info) == sizeof(struct ublksrv_ctrl_dev_info),
+               "device info size differs from Linux UAPI");
+_Static_assert(offsetof(struct ublk_rb_dev_info, flags) == offsetof(struct ublksrv_ctrl_dev_info, flags),
+               "device info flags offset differs from Linux UAPI");
+_Static_assert(offsetof(struct ublk_rb_params, basic) == offsetof(struct ublk_params, basic),
+               "basic parameter offset differs from Linux UAPI");
+_Static_assert(offsetof(struct ublk_rb_params, discard) == offsetof(struct ublk_params, discard),
+               "discard parameter offset differs from Linux UAPI");
+#endif
+
+#endif

data/ext/ublk/constants.c

@@ -0,0 +1,18 @@
+/* Generated by rake gen:constants. */
+#include "internal.h"
+
+#define UBLK_CONST(name) rb_define_const(ublk_native_module, #name, ULL2NUM(name))
+
+void ublk_init_constants(void)
+{
+  UBLK_CONST(UBLK_F_USER_COPY);
+  UBLK_CONST(UBLK_F_CMD_IOCTL_ENCODE);
+  UBLK_CONST(UBLK_F_USER_RECOVERY);
+  UBLK_CONST(UBLK_MAX_QUEUE_DEPTH);
+  UBLK_CONST(UBLKSRV_IO_BUF_OFFSET);
+  UBLK_CONST(UBLK_IO_OP_READ);
+  UBLK_CONST(UBLK_IO_OP_WRITE);
+  UBLK_CONST(UBLK_IO_OP_FLUSH);
+  UBLK_CONST(UBLK_IO_OP_DISCARD);
+  UBLK_CONST(UBLK_IO_OP_WRITE_ZEROES);
+}