lian/zvfs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
15d6a90e2fbcee8811c024fbba6411e0b802cbf2
zvfs/src/spdk_engine/io_engine.c
1iaan 15d6a90e2f bugfix: OFD:FLAGS
2026-04-14 07:40:56 +00:00

907 lines
23 KiB
C
Raw Blame History

#include "spdk_engine/io_engine.h"
#include "common/config.h"
#include "proto/ipc_proto.h"
#include <errno.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <sys/socket.h>
#include <sys/uio.h>
#include <sys/un.h>
#include <time.h>
#include <unistd.h>
struct ipc_client_ctx {
int fd;
uint8_t *rx_buf;
uint8_t *tx_buf;
size_t rx_len;
};
static __thread struct ipc_client_ctx g_ipc_tls = {
.fd = -1,
.rx_buf = NULL,
.tx_buf = NULL,
.rx_len = 0,
};
static uint64_t now_mono_ns(void) {
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return (uint64_t)ts.tv_sec * 1000000000ULL + (uint64_t)ts.tv_nsec;
}
static int latency_trace_enabled(void) {
static int inited = 0;
static int enabled = 0;
const char *v;
if (!inited) {
v = getenv("ZVFS_TRACE_LATENCY");
enabled = (v && v[0] != '\0' && strcmp(v, "0") != 0);
inited = 1;
}
return enabled;
}
static uint64_t ns_to_us(uint64_t ns) {
return ns / 1000ULL;
}
static uint64_t ns_diff(uint64_t end, uint64_t start) {
return (end >= start) ? (end - start) : 0;
}
static void maybe_log_latency_trace(const struct zvfs_req *req, const struct zvfs_resp *resp,
uint64_t client_start_ns, uint64_t client_send_done_ns,
uint64_t client_recv_ns,
uint64_t client_parse_done_ns) {
uint64_t total_ns;
uint64_t server_ns;
uint64_t residual_ns;
uint64_t client_to_server_ns;
uint64_t client_send_ns;
uint64_t server_rx_wait_ns;
uint64_t server_to_client_ns;
uint64_t resp_wait_ns;
uint64_t client_parse_ns;
uint64_t rx_to_dispatch_ns;
uint64_t dispatch_to_spdk_ns;
uint64_t spdk_ns;
uint64_t spdk_post_ns;
uint64_t wake_write_ns;
uint64_t wake_sched_ns;
uint64_t wake_to_tx_ns;
uint64_t reply_q_ns;
uint64_t cq_wait_ns;
if (!latency_trace_enabled() || !req || !resp) {
return;
}
if (resp->status != 0 || (resp->trace.flags & ZVFS_RESP_TRACE_F_VALID) == 0) {
return;
}
if (req->opcode != ZVFS_OP_WRITE && req->opcode != ZVFS_OP_SYNC_MD) {
return;
}
total_ns = ns_diff(client_parse_done_ns, client_start_ns);
server_ns = ns_diff(resp->trace.resp_tx_ns, resp->trace.req_rx_ns);
residual_ns = (total_ns >= server_ns) ? (total_ns - server_ns) : 0;
client_to_server_ns = ns_diff(resp->trace.req_rx_ns, client_start_ns);
client_send_ns = ns_diff(client_send_done_ns, client_start_ns);
server_rx_wait_ns = ns_diff(resp->trace.req_rx_ns, client_send_done_ns);
server_to_client_ns = ns_diff(client_parse_done_ns, resp->trace.resp_tx_ns);
resp_wait_ns = ns_diff(client_recv_ns, resp->trace.resp_tx_ns);
client_parse_ns = ns_diff(client_parse_done_ns, client_recv_ns);
rx_to_dispatch_ns = ns_diff(resp->trace.dispatch_ns, resp->trace.req_rx_ns);
dispatch_to_spdk_ns = ns_diff(resp->trace.spdk_start_ns, resp->trace.dispatch_ns);
spdk_ns = ns_diff(resp->trace.spdk_done_ns, resp->trace.spdk_start_ns);
spdk_post_ns = ns_diff(resp->trace.cq_push_ns, resp->trace.spdk_done_ns);
wake_write_ns = ns_diff(resp->trace.wake_write_ns, resp->trace.cq_push_ns);
wake_sched_ns = ns_diff(resp->trace.reactor_wake_ns, resp->trace.wake_write_ns);
wake_to_tx_ns = ns_diff(resp->trace.resp_tx_ns, resp->trace.reactor_wake_ns);
reply_q_ns = ns_diff(resp->trace.resp_tx_ns, resp->trace.spdk_done_ns);
cq_wait_ns = ns_diff(resp->trace.resp_tx_ns, resp->trace.cq_push_ns);
if (req->opcode == ZVFS_OP_WRITE) {
uint64_t phase1_ns = 0;
uint64_t phase2_ns = spdk_ns;
if ((resp->trace.flags & ZVFS_RESP_TRACE_F_PHASE1_VALID) != 0) {
phase1_ns = ns_diff(resp->trace.phase1_done_ns, resp->trace.spdk_start_ns);
phase2_ns = ns_diff(resp->trace.spdk_done_ns, resp->trace.phase1_done_ns);
}
fprintf(stderr,
"[zvfs][trace][WRITE] total=%luus server=%luus residual=%luus "
"c2s=%luus send=%luus server_rx_wait=%luus "
"s2c=%luus resp_wait=%luus parse=%luus "
"rx_dispatch=%luus dispatch_spdk=%luus spdk=%luus "
"phase1=%luus phase2=%luus spdk_post=%luus "
"kick=%luus wake_sched=%luus wake_to_tx=%luus "
"reply_q=%luus cq_wait=%luus\n",
(unsigned long)ns_to_us(total_ns),
(unsigned long)ns_to_us(server_ns),
(unsigned long)ns_to_us(residual_ns),
(unsigned long)ns_to_us(client_to_server_ns),
(unsigned long)ns_to_us(client_send_ns),
(unsigned long)ns_to_us(server_rx_wait_ns),
(unsigned long)ns_to_us(server_to_client_ns),
(unsigned long)ns_to_us(resp_wait_ns),
(unsigned long)ns_to_us(client_parse_ns),
(unsigned long)ns_to_us(rx_to_dispatch_ns),
(unsigned long)ns_to_us(dispatch_to_spdk_ns),
(unsigned long)ns_to_us(spdk_ns),
(unsigned long)ns_to_us(phase1_ns),
(unsigned long)ns_to_us(phase2_ns),
(unsigned long)ns_to_us(spdk_post_ns),
(unsigned long)ns_to_us(wake_write_ns),
(unsigned long)ns_to_us(wake_sched_ns),
(unsigned long)ns_to_us(wake_to_tx_ns),
(unsigned long)ns_to_us(reply_q_ns),
(unsigned long)ns_to_us(cq_wait_ns));
return;
}
fprintf(stderr,
"[zvfs][trace][SYNC_MD] total=%luus server=%luus residual=%luus "
"c2s=%luus send=%luus server_rx_wait=%luus "
"s2c=%luus resp_wait=%luus parse=%luus "
"rx_dispatch=%luus dispatch_spdk=%luus spdk=%luus "
"spdk_post=%luus kick=%luus wake_sched=%luus wake_to_tx=%luus "
"reply_q=%luus cq_wait=%luus\n",
(unsigned long)ns_to_us(total_ns),
(unsigned long)ns_to_us(server_ns),
(unsigned long)ns_to_us(residual_ns),
(unsigned long)ns_to_us(client_to_server_ns),
(unsigned long)ns_to_us(client_send_ns),
(unsigned long)ns_to_us(server_rx_wait_ns),
(unsigned long)ns_to_us(server_to_client_ns),
(unsigned long)ns_to_us(resp_wait_ns),
(unsigned long)ns_to_us(client_parse_ns),
(unsigned long)ns_to_us(rx_to_dispatch_ns),
(unsigned long)ns_to_us(dispatch_to_spdk_ns),
(unsigned long)ns_to_us(spdk_ns),
(unsigned long)ns_to_us(spdk_post_ns),
(unsigned long)ns_to_us(wake_write_ns),
(unsigned long)ns_to_us(wake_sched_ns),
(unsigned long)ns_to_us(wake_to_tx_ns),
(unsigned long)ns_to_us(reply_q_ns),
(unsigned long)ns_to_us(cq_wait_ns));
}
static const char *zvfs_ipc_socket_path(void) {
const char *path = getenv("ZVFS_SOCKET_PATH");
if (path && path[0] != '\0') {
return path;
}
path = getenv("ZVFS_IPC_SOCKET_PATH");
if (path && path[0] != '\0') {
return path;
}
return ZVFS_IPC_DEFAULT_SOCKET_PATH;
}
static void ipc_close_conn(struct ipc_client_ctx *ctx) {
if (ctx->fd >= 0) {
close(ctx->fd);
}
ctx->fd = -1;
ctx->rx_len = 0;
}
static int ipc_ensure_buffers(struct ipc_client_ctx *ctx) {
if (!ctx->rx_buf) {
ctx->rx_buf = (uint8_t *)malloc(ZVFS_IPC_BUF_SIZE);
if (!ctx->rx_buf) {
errno = ENOMEM;
return -1;
}
}
if (!ctx->tx_buf) {
ctx->tx_buf = (uint8_t *)malloc(ZVFS_IPC_BUF_SIZE);
if (!ctx->tx_buf) {
errno = ENOMEM;
return -1;
}
}
return 0;
}
static int ipc_connect(struct ipc_client_ctx *ctx) {
int fd = socket(AF_UNIX, SOCK_STREAM, 0);
if (fd < 0) {
return -1;
}
struct sockaddr_un addr;
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, zvfs_ipc_socket_path(), sizeof(addr.sun_path) - 1);
if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
int saved = errno;
close(fd);
errno = saved;
return -1;
}
ctx->fd = fd;
ctx->rx_len = 0;
return 0;
}
static int ipc_ensure_connected(struct ipc_client_ctx *ctx) {
if (ctx->fd >= 0) {
return 0;
}
return ipc_connect(ctx);
}
static int write_all(int fd, const uint8_t *buf, size_t len) {
size_t off = 0;
while (off < len) {
ssize_t n = write(fd, buf + off, len - off);
if (n > 0) {
off += (size_t)n;
continue;
}
if (n < 0 && errno == EINTR) {
continue;
}
if (n == 0) {
errno = EPIPE;
}
return -1;
}
return 0;
}
static int writev_all(int fd, struct iovec *iov, int iovcnt) {
int idx = 0;
while (idx < iovcnt) {
ssize_t n = writev(fd, &iov[idx], iovcnt - idx);
if (n > 0) {
size_t remaining = (size_t)n;
while (idx < iovcnt && remaining >= iov[idx].iov_len) {
remaining -= iov[idx].iov_len;
idx++;
}
if (idx < iovcnt && remaining > 0) {
iov[idx].iov_base = (uint8_t *)iov[idx].iov_base + remaining;
iov[idx].iov_len -= remaining;
}
continue;
}
if (n < 0 && errno == EINTR) {
continue;
}
if (n == 0) {
errno = EPIPE;
}
return -1;
}
return 0;
}
static int try_pop_resp(struct ipc_client_ctx *ctx, struct zvfs_resp *resp) {
size_t consumed = zvfs_deserialize_resp(ctx->rx_buf, ctx->rx_len, resp);
if (consumed == 0) {
return 0;
}
if (consumed < ctx->rx_len) {
memmove(ctx->rx_buf, ctx->rx_buf + consumed, ctx->rx_len - consumed);
}
ctx->rx_len -= consumed;
return 1;
}
static int read_into_rx(struct ipc_client_ctx *ctx) {
while (1) {
if (ctx->rx_len >= ZVFS_IPC_BUF_SIZE) {
errno = EOVERFLOW;
return -1;
}
ssize_t n = read(ctx->fd, ctx->rx_buf + ctx->rx_len, ZVFS_IPC_BUF_SIZE - ctx->rx_len);
if (n > 0) {
ctx->rx_len += (size_t)n;
return 0;
}
if (n == 0) {
errno = ECONNRESET;
return -1;
}
if (errno == EINTR) {
continue;
}
return -1;
}
}
static int recv_one_resp(struct ipc_client_ctx *ctx, struct zvfs_resp *resp_out) {
while (1) {
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
int has_resp = try_pop_resp(ctx, &resp);
if (has_resp == 1) {
*resp_out = resp;
return 0;
}
if (read_into_rx(ctx) != 0) {
return -1;
}
if (ctx->rx_len == ZVFS_IPC_BUF_SIZE) {
struct zvfs_resp probe;
memset(&probe, 0, sizeof(probe));
if (zvfs_deserialize_resp(ctx->rx_buf, ctx->rx_len, &probe) == 0) {
errno = EPROTO;
return -1;
}
if (probe.data) {
free(probe.data);
}
}
}
}
static int set_errno_by_status(int status) {
if (status == 0) {
return 0;
}
if (status < 0) {
errno = -status;
} else {
errno = status;
}
if (errno == 0) {
errno = EIO;
}
return -1;
}
static int ipc_do_req(struct zvfs_req *req, struct zvfs_resp *resp_out) {
struct ipc_client_ctx *ctx = &g_ipc_tls;
uint64_t client_start_ns;
uint64_t client_send_done_ns;
uint64_t client_recv_ns;
uint64_t client_done_ns;
if (ipc_ensure_buffers(ctx) != 0) {
return -1;
}
if (ipc_ensure_connected(ctx) != 0) {
return -1;
}
client_start_ns = now_mono_ns();
if (req->opcode == ZVFS_OP_WRITE) {
struct zvfs_req_header header = {
.opcode = req->opcode,
.payload_len = (uint32_t)(ZVFS_REQ_WRITE_FIXED_WIRE_SIZE + req->length),
};
struct zvfs_req_write_body body = {
.handle_id = req->handle_id,
.offset = req->offset,
.length = req->length,
.flags = req->write_flags,
.data = req->data,
};
uint8_t hdr_buf[ZVFS_REQ_HEADER_WIRE_SIZE];
uint8_t meta_buf[ZVFS_REQ_WRITE_FIXED_WIRE_SIZE];
struct iovec iov[3];
if (req->length > UINT32_MAX) {
errno = EMSGSIZE;
return -1;
}
if (zvfs_serialize_req_header(&header, hdr_buf, sizeof(hdr_buf)) != sizeof(hdr_buf) ||
zvfs_serialize_req_write_fixed(&body, meta_buf, sizeof(meta_buf)) != sizeof(meta_buf)) {
errno = EMSGSIZE;
return -1;
}
iov[0].iov_base = hdr_buf;
iov[0].iov_len = sizeof(hdr_buf);
iov[1].iov_base = meta_buf;
iov[1].iov_len = sizeof(meta_buf);
iov[2].iov_base = req->data;
iov[2].iov_len = (size_t)req->length;
if (writev_all(ctx->fd, iov, 3) != 0) {
ipc_close_conn(ctx);
return -1;
}
} else {
size_t tx_len = zvfs_serialize_req(req, ctx->tx_buf, ZVFS_IPC_BUF_SIZE);
if (tx_len == 0) {
errno = EMSGSIZE;
return -1;
}
if (write_all(ctx->fd, ctx->tx_buf, tx_len) != 0) {
ipc_close_conn(ctx);
return -1;
}
}
client_send_done_ns = now_mono_ns();
if (recv_one_resp(ctx, resp_out) != 0) {
ipc_close_conn(ctx);
return -1;
}
client_recv_ns = now_mono_ns();
client_done_ns = now_mono_ns();
maybe_log_latency_trace(req, resp_out, client_start_ns, client_send_done_ns,
client_recv_ns, client_done_ns);
return set_errno_by_status(resp_out->status);
}
int io_engine_init(void) {
return 0;
}
int blob_create(uint64_t size_hint, int open_flags, uint64_t *blob_id_out, uint64_t *handle_id_out) {
if (!blob_id_out || !handle_id_out) {
errno = EINVAL;
return -1;
}
struct zvfs_req req;
memset(&req, 0, sizeof(req));
req.opcode = ZVFS_OP_CREATE;
req.size_hint = size_hint;
req.open_flags = (uint32_t)open_flags;
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
if (ipc_do_req(&req, &resp) != 0) {
return -1;
}
*blob_id_out = resp.blob_id;
*handle_id_out = resp.handle_id;
if (resp.data) {
free(resp.data);
}
return 0;
}
int blob_open(uint64_t blob_id, int open_flags, uint64_t *handle_id_out) {
if (!handle_id_out) {
errno = EINVAL;
return -1;
}
struct zvfs_req req;
memset(&req, 0, sizeof(req));
req.opcode = ZVFS_OP_OPEN;
req.blob_id = blob_id;
req.open_flags = (uint32_t)open_flags;
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
if (ipc_do_req(&req, &resp) != 0) {
return -1;
}
*handle_id_out = resp.handle_id;
if (resp.data) {
free(resp.data);
}
return 0;
}
int blob_write_ex(uint64_t handle_id, uint64_t offset, const void *buf, size_t len, uint32_t write_flags) {
if (len == 0) {
return 0;
}
if (!buf || handle_id == 0) {
errno = EINVAL;
return -1;
}
struct zvfs_req req;
memset(&req, 0, sizeof(req));
req.opcode = ZVFS_OP_WRITE;
req.handle_id = handle_id;
req.offset = offset;
req.length = (uint64_t)len;
req.write_flags = write_flags;
req.data = (void *)buf;
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
if (ipc_do_req(&req, &resp) != 0) {
return -1;
}
if (resp.bytes_written != (uint64_t)len) {
if (resp.data) {
free(resp.data);
}
errno = EIO;
return -1;
}
if (resp.data) {
free(resp.data);
}
return 0;
}
int blob_write(uint64_t handle_id, uint64_t offset, const void *buf, size_t len) {
return blob_write_ex(handle_id, offset, buf, len, 0);
}
int blob_write_shared(uint64_t handle_id, uint64_t logical_size, const void *buf, size_t len, uint32_t write_flags) {
return blob_write_ex(handle_id, logical_size, buf, len,
write_flags | ZVFS_RW_F_USE_HANDLE_POS);
}
ssize_t blob_read_ex(uint64_t handle_id, uint64_t offset, void *buf, size_t len, uint32_t read_flags) {
if (len == 0) {
return 0;
}
if (!buf || handle_id == 0) {
errno = EINVAL;
return -1;
}
struct zvfs_req req;
memset(&req, 0, sizeof(req));
req.opcode = ZVFS_OP_READ;
req.handle_id = handle_id;
req.offset = offset;
req.length = (uint64_t)len;
req.write_flags = read_flags;
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
if (ipc_do_req(&req, &resp) != 0) {
return -1;
}
if (!resp.data && resp.length != 0) {
if (resp.data) {
free(resp.data);
}
errno = EPROTO;
return -1;
}
if (resp.length > len) {
free(resp.data);
errno = EPROTO;
return -1;
}
if (resp.length > 0) {
memcpy(buf, resp.data, (size_t)resp.length);
}
free(resp.data);
return (ssize_t)resp.length;
}
int blob_read(uint64_t handle_id, uint64_t offset, void *buf, size_t len) {
ssize_t nr = blob_read_ex(handle_id, offset, buf, len, 0);
if (nr < 0) {
return -1;
}
if ((size_t)nr != len) {
errno = EPROTO;
return -1;
}
return 0;
}
ssize_t blob_read_shared(uint64_t handle_id, uint64_t logical_size, void *buf, size_t len) {
return blob_read_ex(handle_id, logical_size, buf, len, ZVFS_RW_F_USE_HANDLE_POS);
}
int blob_resize(uint64_t handle_id, uint64_t new_size) {
if (handle_id == 0) {
errno = EINVAL;
return -1;
}
struct zvfs_req req;
memset(&req, 0, sizeof(req));
req.opcode = ZVFS_OP_RESIZE;
req.handle_id = handle_id;
req.size_hint = new_size;
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
if (ipc_do_req(&req, &resp) != 0) {
return -1;
}
if (resp.data) {
free(resp.data);
}
return 0;
}
int blob_sync_md(uint64_t handle_id) {
if (handle_id == 0) {
errno = EINVAL;
return -1;
}
struct zvfs_req req;
memset(&req, 0, sizeof(req));
req.opcode = ZVFS_OP_SYNC_MD;
req.handle_id = handle_id;
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
if (ipc_do_req(&req, &resp) != 0) {
return -1;
}
if (resp.data) {
free(resp.data);
}
return 0;
}
int blob_close(uint64_t handle_id) {
if (handle_id == 0) {
errno = EINVAL;
return -1;
}
struct zvfs_req req;
memset(&req, 0, sizeof(req));
req.opcode = ZVFS_OP_CLOSE;
req.handle_id = handle_id;
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
if (ipc_do_req(&req, &resp) != 0) {
return -1;
}
if (resp.data) {
free(resp.data);
}
return 0;
}
int blob_delete(uint64_t blob_id) {
struct zvfs_req req;
memset(&req, 0, sizeof(req));
req.opcode = ZVFS_OP_DELETE;
req.blob_id = blob_id;
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
if (ipc_do_req(&req, &resp) != 0) {
return -1;
}
if (resp.data) {
free(resp.data);
}
return 0;
}
int blob_add_ref(uint64_t handle_id, uint32_t ref_delta) {
if (handle_id == 0 || ref_delta == 0) {
errno = EINVAL;
return -1;
}
struct zvfs_req req;
memset(&req, 0, sizeof(req));
req.opcode = ZVFS_OP_ADD_REF;
req.handle_id = handle_id;
req.ref_delta = ref_delta;
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
if (ipc_do_req(&req, &resp) != 0) {
return -1;
}
if (resp.data) {
free(resp.data);
}
return 0;
}
int blob_add_ref_batch(const uint64_t *handle_ids, const uint32_t *ref_deltas, uint32_t count) {
uint32_t i;
struct zvfs_add_ref_item *items = NULL;
if (!handle_ids || !ref_deltas || count == 0) {
errno = EINVAL;
return -1;
}
items = calloc(count, sizeof(*items));
if (!items) {
errno = ENOMEM;
return -1;
}
for (i = 0; i < count; i++) {
if (handle_ids[i] == 0 || ref_deltas[i] == 0) {
free(items);
errno = EINVAL;
return -1;
}
items[i].handle_id = handle_ids[i];
items[i].ref_delta = ref_deltas[i];
}
struct zvfs_req req;
memset(&req, 0, sizeof(req));
req.opcode = ZVFS_OP_ADD_REF_BATCH;
req.add_ref_count = count;
req.add_ref_items = items;
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
if (ipc_do_req(&req, &resp) != 0) {
free(items);
return -1;
}
free(items);
if (resp.data) {
free(resp.data);
}
return 0;
}
int blob_seek(uint64_t handle_id, int64_t offset, int whence, uint64_t logical_size, uint64_t *new_offset_out) {
if (handle_id == 0 || !new_offset_out) {
errno = EINVAL;
return -1;
}
struct zvfs_req req;
memset(&req, 0, sizeof(req));
req.opcode = ZVFS_OP_SEEK;
req.handle_id = handle_id;
req.seek_offset = offset;
req.seek_whence = (uint32_t)whence;
req.size_hint = logical_size;
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
if (ipc_do_req(&req, &resp) != 0) {
return -1;
}
*new_offset_out = resp.offset;
if (resp.data) {
free(resp.data);
}
return 0;
}
int blob_get_pos(uint64_t handle_id, uint64_t *offset_out) {
if (handle_id == 0 || !offset_out) {
errno = EINVAL;
return -1;
}
struct zvfs_req req;
memset(&req, 0, sizeof(req));
req.opcode = ZVFS_OP_GET_POS;
req.handle_id = handle_id;
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
if (ipc_do_req(&req, &resp) != 0) {
return -1;
}
*offset_out = resp.offset;
if (resp.data) {
free(resp.data);
}
return 0;
}
int blob_get_flags(uint64_t handle_id, uint32_t *flags_out) {
if (handle_id == 0 || !flags_out) {
errno = EINVAL;
return -1;
}
struct zvfs_req req;
memset(&req, 0, sizeof(req));
req.opcode = ZVFS_OP_GET_FLAGS;
req.handle_id = handle_id;
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
if (ipc_do_req(&req, &resp) != 0) {
return -1;
}
*flags_out = resp.handle_flags;
if (resp.data) {
free(resp.data);
}
return 0;
}
int blob_set_flags(uint64_t handle_id, uint32_t flags) {
if (handle_id == 0) {
errno = EINVAL;
return -1;
}
struct zvfs_req req;
memset(&req, 0, sizeof(req));
req.opcode = ZVFS_OP_SET_FLAGS;
req.handle_id = handle_id;
req.handle_flags = flags;
struct zvfs_resp resp;
memset(&resp, 0, sizeof(resp));
if (ipc_do_req(&req, &resp) != 0) {
return -1;
}
if (resp.data) {
free(resp.data);
}
return 0;
}
Reference in New Issue View Git Blame Copy Permalink