1558 lines
45 KiB
C
1558 lines
45 KiB
C
#ifndef _GNU_SOURCE
|
||
#define _GNU_SOURCE
|
||
#endif
|
||
#include "zvfs_hook_fd.h"
|
||
#include "zvfs_hook_init.h"
|
||
#include "zvfs_hook_reentrant.h"
|
||
#include "fs/zvfs.h"
|
||
#include "fs/zvfs_inode.h"
|
||
#include "fs/zvfs_path_entry.h"
|
||
#include "fs/zvfs_open_file.h"
|
||
#include "spdk_engine/io_engine.h"
|
||
|
||
#include <stdarg.h>
|
||
#include <stdlib.h>
|
||
#include <string.h>
|
||
#include <errno.h>
|
||
#include <unistd.h>
|
||
#include <limits.h>
|
||
#include <pthread.h>
|
||
#include <stdio.h>
|
||
|
||
#define zvfs_debug_open_log(...) ((void)0)
|
||
|
||
/* close 路径辅助：在文件后半段实现。 */
|
||
static int zvfs_detach_fd_mapping(int fd, int do_sync_md);
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* 内部：路径判定辅助 */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
/**
|
||
* openat 到达符号链接之后跳转到 /zvfs 下，导致捕获不了。
|
||
*
|
||
* 1. 判断路径是不是 /zvfs
|
||
* 2. 判断readpath是不是 /zvfs
|
||
* 3. 如果O_CREATE并且目标不存在，realpath什么也拿不到。先解析父路径，再拼接看是不是落在 /zvfs
|
||
*/
|
||
static int
|
||
zvfs_classify_path(const char *abspath, int may_create,
|
||
char *normalized_out, size_t out_size)
|
||
{
|
||
char resolved[PATH_MAX];
|
||
char tmp[PATH_MAX];
|
||
char parent[PATH_MAX];
|
||
char candidate[PATH_MAX];
|
||
const char *name;
|
||
char *slash;
|
||
int n;
|
||
|
||
if (!abspath || !normalized_out || out_size == 0) {
|
||
return 0;
|
||
}
|
||
|
||
strncpy(normalized_out, abspath, out_size);
|
||
normalized_out[out_size - 1] = '\0';
|
||
|
||
if (zvfs_is_zvfs_path(abspath)) {
|
||
return 1;
|
||
}
|
||
|
||
if (realpath(abspath, resolved) != NULL) {
|
||
if (zvfs_is_zvfs_path(resolved)) {
|
||
strncpy(normalized_out, resolved, out_size);
|
||
normalized_out[out_size - 1] = '\0';
|
||
return 1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
if (!may_create) {
|
||
return 0;
|
||
}
|
||
|
||
strncpy(tmp, abspath, sizeof(tmp));
|
||
tmp[sizeof(tmp) - 1] = '\0';
|
||
slash = strrchr(tmp, '/');
|
||
if (!slash) {
|
||
return 0;
|
||
}
|
||
|
||
name = slash + 1;
|
||
if (*name == '\0') {
|
||
return 0;
|
||
}
|
||
|
||
if (slash == tmp) {
|
||
strcpy(parent, "/");
|
||
} else {
|
||
*slash = '\0';
|
||
strncpy(parent, tmp, sizeof(parent));
|
||
parent[sizeof(parent) - 1] = '\0';
|
||
}
|
||
|
||
if (realpath(parent, resolved) == NULL) {
|
||
return 0;
|
||
}
|
||
|
||
n = snprintf(candidate, sizeof(candidate), "%s/%s", resolved, name);
|
||
if (n <= 0 || (size_t)n >= sizeof(candidate)) {
|
||
return 0;
|
||
}
|
||
|
||
if (!zvfs_is_zvfs_path(candidate)) {
|
||
return 0;
|
||
}
|
||
|
||
strncpy(normalized_out, candidate, out_size);
|
||
normalized_out[out_size - 1] = '\0';
|
||
return 1;
|
||
}
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* 内部：fopen 模式解析 */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
static int
|
||
zvfs_parse_fopen_mode(const char *mode, int extra_flags, int *flags_out, mode_t *create_mode_out)
|
||
{
|
||
int flags = 0;
|
||
int plus = 0;
|
||
int excl = 0;
|
||
int cloexec = 0;
|
||
const char *p;
|
||
|
||
if (!mode || !*mode || !flags_out || !create_mode_out) {
|
||
errno = EINVAL;
|
||
return -1;
|
||
}
|
||
|
||
for (p = mode + 1; *p && *p != ','; ++p) {
|
||
if (*p == '+') plus = 1;
|
||
else if (*p == 'x') excl = 1;
|
||
else if (*p == 'e') cloexec = 1;
|
||
}
|
||
|
||
switch (mode[0]) {
|
||
case 'r':
|
||
flags = plus ? O_RDWR : O_RDONLY;
|
||
break;
|
||
case 'w':
|
||
flags = (plus ? O_RDWR : O_WRONLY) | O_CREAT | O_TRUNC;
|
||
break;
|
||
case 'a':
|
||
flags = (plus ? O_RDWR : O_WRONLY) | O_CREAT | O_APPEND;
|
||
break;
|
||
default:
|
||
errno = EINVAL;
|
||
return -1;
|
||
}
|
||
|
||
if (excl) {
|
||
flags |= O_EXCL;
|
||
}
|
||
if (cloexec) {
|
||
flags |= O_CLOEXEC;
|
||
}
|
||
flags |= extra_flags;
|
||
|
||
*flags_out = flags;
|
||
*create_mode_out = 0666;
|
||
return 0;
|
||
}
|
||
|
||
static void
|
||
zvfs_sanitize_fdopen_mode(const char *mode, char out[4])
|
||
{
|
||
int i = 0;
|
||
int plus = 0;
|
||
int binary = 0;
|
||
const char *p;
|
||
|
||
out[0] = 'r';
|
||
out[1] = '\0';
|
||
|
||
if (!mode || !*mode) {
|
||
return;
|
||
}
|
||
|
||
for (p = mode + 1; *p && *p != ','; ++p) {
|
||
if (*p == '+') plus = 1;
|
||
else if (*p == 'b') binary = 1;
|
||
}
|
||
|
||
out[i++] = mode[0];
|
||
if (binary && i < 3) out[i++] = 'b';
|
||
if (plus && i < 3) out[i++] = '+';
|
||
out[i] = '\0';
|
||
}
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* 内部：open 的核心逻辑（路径已解析为绝对路径） */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
/**
|
||
* zvfs_open_impl - 对一个确认属于 zvfs 的绝对路径执行 open。
|
||
*
|
||
* real_fd：已经由 real_open* 打开的真实 fd（用于 xattr 读写 + ftruncate）。
|
||
* flags ：open 时传入的 flags。
|
||
* mode ：O_CREAT 时的权限。
|
||
*
|
||
* 成功返回 real_fd（即用户拿到的 fd），失败返回 -1（errno 已设置），
|
||
* 失败时调用方负责 real_close(real_fd)。
|
||
*/
|
||
static int
|
||
zvfs_open_impl(int real_fd, const char *abspath, int flags, mode_t mode)
|
||
{
|
||
struct zvfs_inode *inode = NULL;
|
||
uint64_t blob_id = 0;
|
||
uint64_t handle_id = 0;
|
||
int create_new = 0;
|
||
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open_impl enter real_fd=%d path=%s flags=0x%x mode=%#o",
|
||
real_fd, zvfs_dbg_str(abspath), flags, (unsigned)mode);
|
||
|
||
if (flags & O_CREAT) {
|
||
/*
|
||
* O_CREAT does not imply the file is newly created.
|
||
* fio, for example, may open an existing file with O_CREAT again
|
||
* during the worker phase. Only create a new blob when the backing
|
||
* file does not already carry a ZVFS blob_id xattr.
|
||
*/
|
||
if (zvfs_xattr_read_blob_id(real_fd, &blob_id) == 0) {
|
||
create_new = 0;
|
||
} else if (errno == ENODATA
|
||
#ifdef ENOATTR
|
||
|| errno == ENOATTR
|
||
#endif
|
||
) {
|
||
create_new = 1;
|
||
blob_id = 0;
|
||
} else {
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open_impl xattr probe fail errno=%d(%s)",
|
||
errno, strerror(errno));
|
||
goto fail;
|
||
}
|
||
}
|
||
|
||
if (create_new) {
|
||
/* ---- 创建路径 -------------------------------------------- */
|
||
|
||
/* 1. 创建 blob */
|
||
if (blob_create(0, flags, &blob_id, &handle_id) != 0) {
|
||
int saved = errno;
|
||
if (saved == 0) saved = EIO;
|
||
fprintf(stderr,
|
||
"[zvfs] create blob failed path=%s flags=0x%x errno=%d(%s)\n",
|
||
abspath, flags, saved, strerror(saved));
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"create branch blob_create fail errno=%d(%s)",
|
||
saved, strerror(saved));
|
||
errno = saved;
|
||
goto fail;
|
||
}
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"create branch blob_create ok blob_id=%lu handle_id=%lu",
|
||
(unsigned long)blob_id, (unsigned long)handle_id);
|
||
|
||
/* 2. 把 blob_id 写入真实文件的 xattr */
|
||
if (zvfs_xattr_write_blob_id(real_fd, blob_id) < 0) {
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"create branch xattr_write fail errno=%d(%s)",
|
||
errno, strerror(errno));
|
||
goto fail;
|
||
}
|
||
zvfs_debug_open_log(abspath, NULL, "create branch xattr_write ok");
|
||
|
||
/* 3. logical_size = 0，让 st_size 也为 0 */
|
||
if (real_ftruncate(real_fd, 0) < 0) {
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"create branch real_ftruncate(0) fail errno=%d(%s)",
|
||
errno, strerror(errno));
|
||
goto fail;
|
||
}
|
||
zvfs_debug_open_log(abspath, NULL, "create branch real_ftruncate(0) ok");
|
||
|
||
/* 4. 分配 inode */
|
||
inode = inode_alloc(blob_id, mode ? mode : 0666, ZVFS_ITYPE_FILE);
|
||
if (!inode) {
|
||
errno = ENOMEM;
|
||
zvfs_debug_open_log(abspath, NULL, "create branch inode_alloc fail ENOMEM");
|
||
goto fail;
|
||
}
|
||
|
||
/* 5. 插入全局表 */
|
||
pthread_mutex_lock(&g_fs.inode_mu);
|
||
inode_insert(inode);
|
||
pthread_mutex_unlock(&g_fs.inode_mu);
|
||
|
||
/* 6. 插入 path_cache */
|
||
pthread_mutex_lock(&g_fs.path_mu);
|
||
path_cache_insert(abspath, inode);
|
||
pthread_mutex_unlock(&g_fs.path_mu);
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"create branch inode/path_cache inserted logical_size=%lu",
|
||
(unsigned long)inode->logical_size);
|
||
|
||
} else {
|
||
/* ---- 打开已有文件路径 ------------------------------------- */
|
||
|
||
/* 1. 先查 path_cache，命中说明另一个 fd 已经打开过 */
|
||
pthread_mutex_lock(&g_fs.path_mu);
|
||
struct zvfs_path_entry *pe = path_cache_lookup(abspath);
|
||
if (pe) inode = pe->inode;
|
||
pthread_mutex_unlock(&g_fs.path_mu);
|
||
|
||
if (inode) {
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open existing path_cache hit inode_blob_id=%lu",
|
||
(unsigned long)inode->blob_id);
|
||
/* path_cache 命中：直接用缓存的 inode，重新 blob_open */
|
||
blob_id = inode->blob_id;
|
||
if (blob_open(blob_id, flags, &handle_id) != 0) {
|
||
if (errno == 0) errno = EIO;
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open existing path_cache-hit blob_open fail errno=%d(%s)",
|
||
errno, strerror(errno));
|
||
goto fail;
|
||
}
|
||
/* 共享 inode，增加引用 */
|
||
atomic_fetch_add(&inode->ref_count, 1);
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open existing path_cache-hit blob_open ok handle_id=%lu",
|
||
(unsigned long)handle_id);
|
||
|
||
} else {
|
||
zvfs_debug_open_log(abspath, NULL, "open existing path_cache miss");
|
||
/* 未命中：从 xattr 读 blob_id，可能是进程首次 open */
|
||
if (zvfs_xattr_read_blob_id(real_fd, &blob_id) < 0) {
|
||
/* xattr 不存在：不是 zvfs 管理的文件，降级透传 */
|
||
return real_fd; /* 直接返回，不做任何包装 */
|
||
}
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open existing xattr_read ok blob_id=%lu",
|
||
(unsigned long)blob_id);
|
||
|
||
/* 再查 inode_table（另一个 fd 可能已经 open 但路径未缓存）*/
|
||
pthread_mutex_lock(&g_fs.inode_mu);
|
||
inode = inode_lookup(blob_id);
|
||
pthread_mutex_unlock(&g_fs.inode_mu);
|
||
|
||
if (inode) {
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open existing inode_table hit blob_id=%lu",
|
||
(unsigned long)blob_id);
|
||
if (blob_open(blob_id, flags, &handle_id) != 0) {
|
||
if (errno == 0) errno = EIO;
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open existing inode_table-hit blob_open fail errno=%d(%s)",
|
||
errno, strerror(errno));
|
||
goto fail;
|
||
}
|
||
atomic_fetch_add(&inode->ref_count, 1);
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open existing inode_table-hit blob_open ok handle_id=%lu",
|
||
(unsigned long)handle_id);
|
||
} else {
|
||
/* 全新 inode：需从真实文件 stat 获取 mode/size */
|
||
struct stat st;
|
||
if (zvfs_real_fstat(real_fd, &st) < 0) {
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open existing fstat fail errno=%d(%s)",
|
||
errno, strerror(errno));
|
||
goto fail;
|
||
}
|
||
|
||
inode = inode_alloc(blob_id, st.st_mode, ZVFS_ITYPE_FILE);
|
||
if (!inode) {
|
||
errno = ENOMEM;
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open existing inode_alloc fail ENOMEM");
|
||
goto fail;
|
||
}
|
||
inode->logical_size = (uint64_t)st.st_size;
|
||
|
||
pthread_mutex_lock(&g_fs.inode_mu);
|
||
inode_insert(inode);
|
||
pthread_mutex_unlock(&g_fs.inode_mu);
|
||
|
||
pthread_mutex_lock(&g_fs.path_mu);
|
||
path_cache_insert(abspath, inode);
|
||
pthread_mutex_unlock(&g_fs.path_mu);
|
||
if (blob_open(blob_id, flags, &handle_id) != 0) {
|
||
if (errno == 0) errno = EIO;
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open existing new-inode blob_open fail errno=%d(%s)",
|
||
errno, strerror(errno));
|
||
goto fail;
|
||
}
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open existing new-inode ready handle_id=%lu logical_size=%lu",
|
||
(unsigned long)handle_id,
|
||
(unsigned long)inode->logical_size);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* ---- 分配 openfile，插入 fd_table ---------------------------- */
|
||
struct zvfs_open_file *of = openfile_alloc(real_fd, inode, handle_id);
|
||
if (!of) { errno = ENOMEM; goto fail_handle; }
|
||
|
||
pthread_mutex_lock(&g_fs.fd_mu);
|
||
openfile_insert(of);
|
||
pthread_mutex_unlock(&g_fs.fd_mu);
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open_impl success real_fd=%d handle_id=%lu inode_blob_id=%lu",
|
||
real_fd,
|
||
(unsigned long)handle_id,
|
||
(unsigned long)(inode ? inode->blob_id : 0));
|
||
|
||
return real_fd;
|
||
|
||
fail_handle:
|
||
if (handle_id != 0) {
|
||
blob_close(handle_id);
|
||
}
|
||
fail:
|
||
zvfs_debug_open_log(abspath, NULL,
|
||
"open_impl fail errno=%d(%s) real_fd=%d",
|
||
errno, strerror(errno), real_fd);
|
||
/* inode 若刚分配（ref_count==1）需要回滚 */
|
||
if (inode && atomic_load(&inode->ref_count) == 1) {
|
||
pthread_mutex_lock(&g_fs.inode_mu);
|
||
inode_remove(inode->blob_id);
|
||
pthread_mutex_unlock(&g_fs.inode_mu);
|
||
pthread_mutex_lock(&g_fs.path_mu);
|
||
path_cache_remove(abspath);
|
||
pthread_mutex_unlock(&g_fs.path_mu);
|
||
inode_free(inode);
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* open */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
int
|
||
open(const char *path, int flags, ...)
|
||
{
|
||
ZVFS_HOOK_ENTER();
|
||
|
||
char abspath[PATH_MAX];
|
||
char normpath[PATH_MAX];
|
||
abspath[0] = '\0';
|
||
normpath[0] = '\0';
|
||
int is_zvfs_path = 0;
|
||
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap;
|
||
va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
|
||
if (zvfs_resolve_atpath(AT_FDCWD, path, abspath, sizeof(abspath)) == 0) {
|
||
is_zvfs_path = zvfs_classify_path(abspath, (flags & O_CREAT) != 0,
|
||
normpath, sizeof(normpath));
|
||
zvfs_debug_open_log(path, abspath,
|
||
"open resolve ok path=%s abspath=%s norm=%s flags=0x%x is_zvfs=%d",
|
||
zvfs_dbg_str(path), zvfs_dbg_str(abspath),
|
||
zvfs_dbg_str(normpath), flags, is_zvfs_path);
|
||
} else {
|
||
zvfs_debug_open_log(path, NULL,
|
||
"open resolve fail path=%s flags=0x%x errno=%d(%s)",
|
||
zvfs_dbg_str(path), flags, errno, strerror(errno));
|
||
}
|
||
|
||
int ret;
|
||
if (ZVFS_IN_HOOK() || !is_zvfs_path) {
|
||
zvfs_debug_open_log(path, abspath,
|
||
"open passthrough reason=%s path=%s flags=0x%x",
|
||
ZVFS_IN_HOOK() ? "reentrant" : "non-zvfs",
|
||
zvfs_dbg_str(path), flags);
|
||
ret = real_open(path, flags, mode);
|
||
zvfs_debug_open_log(path, abspath,
|
||
"open passthrough ret=%d errno=%d(%s)",
|
||
ret, (ret < 0) ? errno : 0, (ret < 0) ? strerror(errno) : "OK");
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|
||
|
||
zvfs_ensure_init();
|
||
|
||
/* 先让真实 FS 创建 / 打开文件（获得 real_fd） */
|
||
int real_fd = real_open(path, flags, mode);
|
||
if (real_fd < 0) {
|
||
zvfs_debug_open_log(path, abspath,
|
||
"open real_open fail path=%s flags=0x%x errno=%d(%s)",
|
||
zvfs_dbg_str(path), flags, errno, strerror(errno));
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
zvfs_debug_open_log(path, abspath,
|
||
"open real_open ok real_fd=%d path=%s norm=%s",
|
||
real_fd, zvfs_dbg_str(path), zvfs_dbg_str(normpath));
|
||
|
||
ret = zvfs_open_impl(real_fd, normpath, flags, mode);
|
||
if (ret < 0) {
|
||
int saved = errno;
|
||
real_close(real_fd);
|
||
errno = saved;
|
||
zvfs_debug_open_log(path, abspath,
|
||
"open zvfs_open_impl fail real_fd=%d errno=%d(%s)",
|
||
real_fd, saved, strerror(saved));
|
||
} else {
|
||
zvfs_debug_open_log(path, abspath,
|
||
"open zvfs_open_impl success fd=%d", ret);
|
||
}
|
||
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|
||
|
||
int open64(const char *path, int flags, ...)
|
||
{
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
return open(path, flags | O_LARGEFILE, mode);
|
||
}
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* openat */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
int
|
||
openat(int dirfd, const char *path, int flags, ...)
|
||
{
|
||
ZVFS_HOOK_ENTER();
|
||
|
||
char normpath[PATH_MAX];
|
||
char abspath[PATH_MAX];
|
||
normpath[0] = '\0';
|
||
abspath[0] = '\0';
|
||
int is_zvfs_path = 0;
|
||
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
|
||
/* 解析绝对路径判断是否属于 zvfs */
|
||
if (zvfs_resolve_atpath(dirfd, path, abspath, sizeof(abspath)) < 0) {
|
||
zvfs_debug_open_log(path, NULL,
|
||
"openat resolve fail dirfd=%d path=%s flags=0x%x errno=%d(%s)",
|
||
dirfd, zvfs_dbg_str(path), flags, errno, strerror(errno));
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
is_zvfs_path = zvfs_classify_path(abspath, (flags & O_CREAT) != 0,
|
||
normpath, sizeof(normpath));
|
||
zvfs_debug_open_log(path, abspath,
|
||
"openat resolve ok dirfd=%d path=%s abspath=%s norm=%s flags=0x%x is_zvfs=%d",
|
||
dirfd, zvfs_dbg_str(path), zvfs_dbg_str(abspath),
|
||
zvfs_dbg_str(normpath), flags, is_zvfs_path);
|
||
|
||
int ret;
|
||
if (ZVFS_IN_HOOK() || !is_zvfs_path) {
|
||
zvfs_debug_open_log(path, abspath,
|
||
"openat passthrough reason=%s dirfd=%d path=%s flags=0x%x",
|
||
ZVFS_IN_HOOK() ? "reentrant" : "non-zvfs",
|
||
dirfd, zvfs_dbg_str(path), flags);
|
||
ret = real_openat(dirfd, path, flags, mode);
|
||
zvfs_debug_open_log(path, abspath,
|
||
"openat passthrough ret=%d errno=%d(%s)",
|
||
ret, (ret < 0) ? errno : 0, (ret < 0) ? strerror(errno) : "OK");
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|
||
|
||
zvfs_ensure_init();
|
||
|
||
int real_fd = real_openat(dirfd, path, flags, mode);
|
||
if (real_fd < 0) {
|
||
zvfs_debug_open_log(path, abspath,
|
||
"openat real_openat fail dirfd=%d path=%s flags=0x%x errno=%d(%s)",
|
||
dirfd, zvfs_dbg_str(path), flags, errno, strerror(errno));
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
zvfs_debug_open_log(path, abspath,
|
||
"openat real_openat ok real_fd=%d dirfd=%d path=%s norm=%s",
|
||
real_fd, dirfd, zvfs_dbg_str(path), zvfs_dbg_str(normpath));
|
||
|
||
ret = zvfs_open_impl(real_fd, normpath, flags, mode);
|
||
if (ret < 0) {
|
||
int saved = errno;
|
||
real_close(real_fd);
|
||
errno = saved;
|
||
zvfs_debug_open_log(path, abspath,
|
||
"openat zvfs_open_impl fail real_fd=%d errno=%d(%s)",
|
||
real_fd, saved, strerror(saved));
|
||
} else {
|
||
zvfs_debug_open_log(path, abspath,
|
||
"openat zvfs_open_impl success fd=%d", ret);
|
||
}
|
||
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|
||
|
||
int openat64(int dirfd, const char *path, int flags, ...)
|
||
{
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
return openat(dirfd, path, flags | O_LARGEFILE, mode);
|
||
}
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* fopen / fopen64 */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
static FILE *
|
||
zvfs_fopen_common(const char *path, const char *mode, int extra_open_flags, int use_fopen64)
|
||
{
|
||
char abspath[PATH_MAX];
|
||
char normpath[PATH_MAX];
|
||
char fdopen_mode[4];
|
||
int is_zvfs_path = 0;
|
||
int flags = 0;
|
||
mode_t create_mode = 0666;
|
||
int real_fd = -1;
|
||
FILE *fp = NULL;
|
||
|
||
if (zvfs_parse_fopen_mode(mode, extra_open_flags, &flags, &create_mode) != 0) {
|
||
if (use_fopen64 && real_fopen64) return real_fopen64(path, mode);
|
||
if (real_fopen) return real_fopen(path, mode);
|
||
errno = ENOSYS;
|
||
return NULL;
|
||
}
|
||
|
||
if (zvfs_resolve_atpath(AT_FDCWD, path, abspath, sizeof(abspath)) == 0) {
|
||
is_zvfs_path = zvfs_classify_path(abspath, (flags & O_CREAT) != 0,
|
||
normpath, sizeof(normpath));
|
||
zvfs_debug_open_log(path, abspath,
|
||
"fopen resolve ok path=%s mode=%s norm=%s flags=0x%x is_zvfs=%d",
|
||
zvfs_dbg_str(path), zvfs_dbg_str(mode),
|
||
zvfs_dbg_str(normpath), flags, is_zvfs_path);
|
||
} else {
|
||
zvfs_debug_open_log(path, NULL,
|
||
"fopen resolve fail path=%s mode=%s errno=%d(%s)",
|
||
zvfs_dbg_str(path), zvfs_dbg_str(mode), errno, strerror(errno));
|
||
}
|
||
|
||
if (ZVFS_IN_HOOK() || !is_zvfs_path) {
|
||
if (use_fopen64 && real_fopen64) return real_fopen64(path, mode);
|
||
if (real_fopen) return real_fopen(path, mode);
|
||
errno = ENOSYS;
|
||
return NULL;
|
||
}
|
||
|
||
zvfs_ensure_init();
|
||
|
||
real_fd = real_open(path, flags, create_mode);
|
||
if (real_fd < 0) {
|
||
return NULL;
|
||
}
|
||
|
||
if (zvfs_open_impl(real_fd, normpath, flags, create_mode) < 0) {
|
||
int saved = errno;
|
||
real_close(real_fd);
|
||
errno = saved;
|
||
return NULL;
|
||
}
|
||
zvfs_debug_open_log(path, normpath,
|
||
"fopen mapped-after-open_impl fd=%d mapped=%d",
|
||
real_fd, zvfs_debug_has_fd_mapping(real_fd));
|
||
|
||
zvfs_sanitize_fdopen_mode(mode, fdopen_mode);
|
||
if (real_fdopen) {
|
||
fp = real_fdopen(real_fd, fdopen_mode);
|
||
} else {
|
||
fp = fdopen(real_fd, fdopen_mode);
|
||
}
|
||
if (!fp) {
|
||
int saved = errno;
|
||
close(real_fd);
|
||
errno = saved;
|
||
return NULL;
|
||
}
|
||
zvfs_debug_open_log(path, normpath,
|
||
"fopen mapped-after-fdopen fd=%d mapped=%d",
|
||
real_fd, zvfs_debug_has_fd_mapping(real_fd));
|
||
return fp;
|
||
}
|
||
|
||
FILE *
|
||
fopen(const char *path, const char *mode)
|
||
{
|
||
ZVFS_HOOK_ENTER();
|
||
FILE *fp = zvfs_fopen_common(path, mode, 0, 0);
|
||
ZVFS_HOOK_LEAVE();
|
||
return fp;
|
||
}
|
||
|
||
FILE *
|
||
fopen64(const char *path, const char *mode)
|
||
{
|
||
ZVFS_HOOK_ENTER();
|
||
FILE *fp = zvfs_fopen_common(path, mode, O_LARGEFILE, 1);
|
||
ZVFS_HOOK_LEAVE();
|
||
return fp;
|
||
}
|
||
|
||
int
|
||
fclose(FILE *stream)
|
||
{
|
||
ZVFS_HOOK_ENTER();
|
||
|
||
int ret;
|
||
int ret_errno = 0;
|
||
int bk_rc = 0;
|
||
int bk_errno = 0;
|
||
int fd = -1;
|
||
int need_bookkeeping = 0;
|
||
|
||
if (!stream) {
|
||
errno = EINVAL;
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
if (!ZVFS_IN_HOOK()) {
|
||
fd = fileno(stream);
|
||
if (fd >= 0 && zvfs_is_zvfs_fd(fd)) {
|
||
need_bookkeeping = 1;
|
||
}
|
||
}
|
||
|
||
if (!real_fclose) {
|
||
errno = ENOSYS;
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
if (ZVFS_IN_HOOK() || !need_bookkeeping) {
|
||
ret = real_fclose(stream);
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|
||
|
||
zvfs_ensure_init();
|
||
|
||
ret = real_fclose(stream);
|
||
if (ret < 0) {
|
||
ret_errno = errno;
|
||
}
|
||
|
||
/*
|
||
* 无论 real_fclose 是否报错，都尝试回收 zvfs bookkeeping。
|
||
* 某些 libc 实现即使返回 EOF，也可能已经关闭了底层 fd。
|
||
*/
|
||
if (zvfs_detach_fd_mapping(fd, 1) < 0) {
|
||
bk_rc = -1;
|
||
bk_errno = errno;
|
||
}
|
||
|
||
if (ret < 0) {
|
||
errno = ret_errno;
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
if (bk_rc < 0) {
|
||
errno = bk_errno;
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
ZVFS_HOOK_LEAVE();
|
||
return 0;
|
||
}
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* creat */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
int creat(const char *path, mode_t mode)
|
||
{
|
||
return open(path, O_CREAT | O_WRONLY | O_TRUNC, mode);
|
||
}
|
||
|
||
int creat64(const char *path, mode_t mode)
|
||
{
|
||
return open(path, O_CREAT | O_WRONLY | O_TRUNC | O_LARGEFILE, mode);
|
||
}
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* glibc 别名 */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
int __open(const char *path, int flags, ...)
|
||
{
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
return open(path, flags, mode);
|
||
}
|
||
|
||
int __open64(const char *path, int flags, ...)
|
||
{
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
return open64(path, flags, mode);
|
||
}
|
||
|
||
int __openat(int dirfd, const char *path, int flags, ...)
|
||
{
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
return openat(dirfd, path, flags, mode);
|
||
}
|
||
|
||
int __openat64(int dirfd, const char *path, int flags, ...)
|
||
{
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
return openat64(dirfd, path, flags, mode);
|
||
}
|
||
|
||
int __libc_open(const char *path, int flags, ...)
|
||
{
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
return open(path, flags, mode);
|
||
}
|
||
|
||
int __libc_open64(const char *path, int flags, ...)
|
||
{
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
return open64(path, flags, mode);
|
||
}
|
||
|
||
int __libc_openat(int dirfd, const char *path, int flags, ...)
|
||
{
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
return openat(dirfd, path, flags, mode);
|
||
}
|
||
|
||
int __libc_openat64(int dirfd, const char *path, int flags, ...)
|
||
{
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
return openat64(dirfd, path, flags, mode);
|
||
}
|
||
|
||
int __open_2(const char *path, int flags)
|
||
{
|
||
if ((flags & O_CREAT) || ((flags & O_TMPFILE) == O_TMPFILE)) {
|
||
errno = EINVAL;
|
||
return -1;
|
||
}
|
||
zvfs_debug_open_log(path, NULL,
|
||
"__open_2 called path=%s flags=0x%x",
|
||
zvfs_dbg_str(path), flags);
|
||
return open(path, flags);
|
||
}
|
||
|
||
int __open64_2(const char *path, int flags)
|
||
{
|
||
if ((flags & O_CREAT) || ((flags & O_TMPFILE) == O_TMPFILE)) {
|
||
errno = EINVAL;
|
||
return -1;
|
||
}
|
||
return open64(path, flags);
|
||
}
|
||
|
||
int __openat_2(int dirfd, const char *path, int flags)
|
||
{
|
||
if ((flags & O_CREAT) || ((flags & O_TMPFILE) == O_TMPFILE)) {
|
||
errno = EINVAL;
|
||
return -1;
|
||
}
|
||
zvfs_debug_open_log(path, NULL,
|
||
"__openat_2 called dirfd=%d path=%s flags=0x%x",
|
||
dirfd, zvfs_dbg_str(path), flags);
|
||
return openat(dirfd, path, flags);
|
||
}
|
||
|
||
int __openat64_2(int dirfd, const char *path, int flags)
|
||
{
|
||
if ((flags & O_CREAT) || ((flags & O_TMPFILE) == O_TMPFILE)) {
|
||
errno = EINVAL;
|
||
return -1;
|
||
}
|
||
return openat64(dirfd, path, flags);
|
||
}
|
||
|
||
int __open_nocancel(const char *path, int flags, ...)
|
||
{
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
return open(path, flags, mode);
|
||
}
|
||
|
||
int __open64_nocancel(const char *path, int flags, ...)
|
||
{
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
return open64(path, flags, mode);
|
||
}
|
||
|
||
int __openat_nocancel(int dirfd, const char *path, int flags, ...)
|
||
{
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
return openat(dirfd, path, flags, mode);
|
||
}
|
||
|
||
int __openat64_nocancel(int dirfd, const char *path, int flags, ...)
|
||
{
|
||
mode_t mode = 0;
|
||
if (flags & O_CREAT) {
|
||
va_list ap; va_start(ap, flags);
|
||
mode = (mode_t)va_arg(ap, unsigned int);
|
||
va_end(ap);
|
||
}
|
||
return openat64(dirfd, path, flags, mode);
|
||
}
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* close */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
/*
|
||
* zvfs_release_openfile - 释放一个 openfile 对应的 zvfs 资源。
|
||
* 这里只处理 zvfs bookkeeping，不做 real_close(fd)。
|
||
*/
|
||
static int
|
||
zvfs_release_openfile(struct zvfs_open_file *of, int do_sync_md)
|
||
{
|
||
int saved_errno = 0;
|
||
struct zvfs_inode *inode = of->inode;
|
||
uint64_t handle_id = of->handle_id;
|
||
openfile_free(of);
|
||
|
||
if (do_sync_md && handle_id != 0 && blob_sync_md(handle_id) < 0) {
|
||
saved_errno = (errno != 0) ? errno : EIO;
|
||
}
|
||
if (handle_id != 0 && blob_close(handle_id) < 0 && saved_errno == 0) {
|
||
saved_errno = (errno != 0) ? errno : EIO;
|
||
}
|
||
|
||
/* ---- inode ref_count-- --------------------------------------- */
|
||
int inode_ref = atomic_fetch_sub(&inode->ref_count, 1) - 1;
|
||
|
||
if (inode_ref == 0) {
|
||
/*
|
||
* 最后一个 fd 关闭了这个 inode。
|
||
* 若 deleted：执行延迟 blob_delete。
|
||
*/
|
||
bool do_delete = false;
|
||
pthread_mutex_lock(&inode->mu);
|
||
do_delete = inode->deleted;
|
||
pthread_mutex_unlock(&inode->mu);
|
||
|
||
if (do_delete && blob_delete(inode->blob_id) < 0 && saved_errno == 0)
|
||
saved_errno = (errno != 0) ? errno : EIO;
|
||
|
||
pthread_mutex_lock(&g_fs.inode_mu);
|
||
inode_remove(inode->blob_id);
|
||
pthread_mutex_unlock(&g_fs.inode_mu);
|
||
|
||
/* path_cache 在 unlink 时已经摘除（deleted=true 路径）
|
||
* 或在此处还需摘除（正常关闭最后一个 fd）*/
|
||
if (!do_delete) {
|
||
/* 正常关闭：path 留着，只有 inode 的引用归零时清缓存 */
|
||
/* 注意：path_cache 里的指针指向这个即将释放的 inode，
|
||
* 所以必须把 path_cache 条目也清掉，否则成为悬空指针 */
|
||
pthread_mutex_lock(&g_fs.path_mu);
|
||
/* 遍历找到所有指向这个 inode 的 path entry 并移除
|
||
* （一个 inode 对应一个 path，hardlink 暂不支持）*/
|
||
struct zvfs_path_entry *pe, *tmp; (void)tmp;
|
||
HASH_ITER(hh, g_fs.path_cache, pe, tmp) {
|
||
if (pe->inode == inode) {
|
||
HASH_DEL(g_fs.path_cache, pe);
|
||
free(pe->path);
|
||
free(pe);
|
||
break; /* 一对一关系，找到即退 */
|
||
}
|
||
}
|
||
pthread_mutex_unlock(&g_fs.path_mu);
|
||
}
|
||
|
||
inode_free(inode);
|
||
}
|
||
|
||
if (saved_errno != 0) {
|
||
errno = saved_errno;
|
||
return -1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/*
|
||
* zvfs_detach_fd_mapping - 仅摘除 fd -> openfile 映射并释放 zvfs 资源。
|
||
* 不调用 real_close(fd)，用于 dup2/dup3 中 newfd 旧值清理。
|
||
*/
|
||
static int
|
||
zvfs_detach_fd_mapping(int fd, int do_sync_md)
|
||
{
|
||
pthread_mutex_lock(&g_fs.fd_mu);
|
||
struct zvfs_open_file *of = openfile_lookup(fd);
|
||
if (!of) {
|
||
pthread_mutex_unlock(&g_fs.fd_mu);
|
||
errno = EBADF;
|
||
return -1;
|
||
}
|
||
openfile_remove(fd);
|
||
pthread_mutex_unlock(&g_fs.fd_mu);
|
||
|
||
return zvfs_release_openfile(of, do_sync_md);
|
||
}
|
||
|
||
/*
|
||
* zvfs_close_impl - close(fd) 的 zvfs 路径：
|
||
* 先做 bookkeeping，再做 real_close(fd)。
|
||
*/
|
||
static int
|
||
zvfs_close_impl(int fd)
|
||
{
|
||
int bk_rc = zvfs_detach_fd_mapping(fd, 1);
|
||
int bk_errno = (bk_rc < 0) ? errno : 0;
|
||
|
||
int rc = real_close(fd);
|
||
if (rc < 0)
|
||
return -1;
|
||
|
||
if (bk_rc < 0) {
|
||
errno = bk_errno;
|
||
return -1;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
int
|
||
close(int fd)
|
||
{
|
||
ZVFS_HOOK_ENTER();
|
||
|
||
int ret;
|
||
int is_zvfs_fd = (!ZVFS_IN_HOOK() && zvfs_is_zvfs_fd(fd));
|
||
if (!is_zvfs_fd) {
|
||
ret = real_close(fd);
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|
||
|
||
zvfs_ensure_init();
|
||
|
||
ret = zvfs_close_impl(fd);
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|
||
|
||
int __close(int fd) { return close(fd); }
|
||
int __libc_close(int fd) { return close(fd); }
|
||
int __close_nocancel(int fd) { return close(fd); }
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* dup helper */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
int
|
||
zvfs_dup_attach_newfd(int oldfd, int newfd, int new_fd_flags)
|
||
{
|
||
struct zvfs_open_file *old_of, *new_of;
|
||
int fd_flags;
|
||
int rc;
|
||
int saved;
|
||
|
||
if (oldfd < 0 || newfd < 0) {
|
||
errno = EBADF;
|
||
return -1;
|
||
}
|
||
|
||
pthread_mutex_lock(&g_fs.fd_mu);
|
||
old_of = openfile_lookup(oldfd);
|
||
if (!old_of) {
|
||
pthread_mutex_unlock(&g_fs.fd_mu);
|
||
errno = EBADF;
|
||
return -1;
|
||
}
|
||
if (openfile_lookup(newfd) != NULL) {
|
||
pthread_mutex_unlock(&g_fs.fd_mu);
|
||
errno = EEXIST;
|
||
return -1;
|
||
}
|
||
|
||
rc = blob_add_ref(old_of->handle_id, 1);
|
||
if (rc != 0) {
|
||
pthread_mutex_unlock(&g_fs.fd_mu);
|
||
return -1;
|
||
}
|
||
|
||
new_of = openfile_alloc(newfd, old_of->inode, old_of->handle_id);
|
||
if (!new_of) {
|
||
saved = (errno != 0) ? errno : ENOMEM;
|
||
(void)blob_close(old_of->handle_id);
|
||
pthread_mutex_unlock(&g_fs.fd_mu);
|
||
errno = saved;
|
||
return -1;
|
||
}
|
||
|
||
fd_flags = (new_fd_flags >= 0) ? new_fd_flags : old_of->fd_flags;
|
||
new_of->fd_flags = fd_flags;
|
||
|
||
atomic_fetch_add(&old_of->inode->ref_count, 1);
|
||
openfile_insert(new_of);
|
||
pthread_mutex_unlock(&g_fs.fd_mu);
|
||
return 0;
|
||
}
|
||
|
||
static int
|
||
zvfs_add_ref_batch_or_fallback(const uint64_t *handle_ids,
|
||
const uint32_t *ref_deltas,
|
||
uint32_t count)
|
||
{
|
||
uint32_t i;
|
||
|
||
if (count == 0)
|
||
return 0;
|
||
|
||
if (blob_add_ref_batch(handle_ids, ref_deltas, count) == 0)
|
||
return 0;
|
||
|
||
for (i = 0; i < count; i++) {
|
||
if (blob_add_ref(handle_ids[i], ref_deltas[i]) != 0)
|
||
return -1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
static void
|
||
zvfs_rollback_added_refs(const uint64_t *handle_ids, uint32_t count)
|
||
{
|
||
uint32_t i;
|
||
for (i = 0; i < count; i++) {
|
||
if (handle_ids[i] != 0)
|
||
(void)blob_close(handle_ids[i]);
|
||
}
|
||
}
|
||
|
||
static int
|
||
zvfs_snapshot_fd_handles(uint64_t **handle_ids_out,
|
||
uint32_t **ref_deltas_out,
|
||
uint32_t *count_out)
|
||
{
|
||
struct zvfs_open_file *of, *tmp;
|
||
uint32_t i = 0;
|
||
uint32_t count;
|
||
uint64_t *handle_ids = NULL;
|
||
uint32_t *ref_deltas = NULL;
|
||
|
||
*handle_ids_out = NULL;
|
||
*ref_deltas_out = NULL;
|
||
*count_out = 0;
|
||
|
||
pthread_mutex_lock(&g_fs.fd_mu);
|
||
count = (uint32_t)HASH_COUNT(g_fs.fd_table);
|
||
if (count == 0) {
|
||
pthread_mutex_unlock(&g_fs.fd_mu);
|
||
return 0;
|
||
}
|
||
|
||
handle_ids = calloc(count, sizeof(*handle_ids));
|
||
ref_deltas = calloc(count, sizeof(*ref_deltas));
|
||
if (!handle_ids || !ref_deltas) {
|
||
pthread_mutex_unlock(&g_fs.fd_mu);
|
||
free(handle_ids);
|
||
free(ref_deltas);
|
||
errno = ENOMEM;
|
||
return -1;
|
||
}
|
||
|
||
HASH_ITER(hh, g_fs.fd_table, of, tmp) {
|
||
if (i >= count)
|
||
break;
|
||
handle_ids[i] = of->handle_id;
|
||
ref_deltas[i] = 1;
|
||
i++;
|
||
}
|
||
pthread_mutex_unlock(&g_fs.fd_mu);
|
||
|
||
*handle_ids_out = handle_ids;
|
||
*ref_deltas_out = ref_deltas;
|
||
*count_out = i;
|
||
return 0;
|
||
}
|
||
|
||
static int
|
||
zvfs_snapshot_fds_in_range(unsigned int first, unsigned int last,
|
||
int **fds_out, uint32_t *count_out)
|
||
{
|
||
struct zvfs_open_file *of, *tmp;
|
||
uint32_t cap;
|
||
uint32_t n = 0;
|
||
int *fds = NULL;
|
||
|
||
*fds_out = NULL;
|
||
*count_out = 0;
|
||
|
||
pthread_mutex_lock(&g_fs.fd_mu);
|
||
cap = (uint32_t)HASH_COUNT(g_fs.fd_table);
|
||
if (cap == 0) {
|
||
pthread_mutex_unlock(&g_fs.fd_mu);
|
||
return 0;
|
||
}
|
||
|
||
fds = calloc(cap, sizeof(*fds));
|
||
if (!fds) {
|
||
pthread_mutex_unlock(&g_fs.fd_mu);
|
||
errno = ENOMEM;
|
||
return -1;
|
||
}
|
||
|
||
HASH_ITER(hh, g_fs.fd_table, of, tmp) {
|
||
if (of->fd < 0) {
|
||
continue;
|
||
}
|
||
if ((unsigned int)of->fd < first || (unsigned int)of->fd > last) {
|
||
continue;
|
||
}
|
||
fds[n++] = of->fd;
|
||
}
|
||
pthread_mutex_unlock(&g_fs.fd_mu);
|
||
|
||
*fds_out = fds;
|
||
*count_out = n;
|
||
return 0;
|
||
}
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* close_range */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
int
|
||
close_range(unsigned int first, unsigned int last, int flags)
|
||
{
|
||
ZVFS_HOOK_ENTER();
|
||
|
||
if (ZVFS_IN_HOOK()) {
|
||
int ret = real_close_range ? real_close_range(first, last, flags)
|
||
: (errno = ENOSYS, -1);
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|
||
|
||
if (first > last) {
|
||
errno = EINVAL;
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
/*
|
||
* 只快照当前 zvfs fd_table 中命中的 fd，避免对 [first,last] 做
|
||
* 全范围扫描（last=UINT_MAX 时会非常慢，且旧逻辑存在回绕风险）。
|
||
*/
|
||
int any_err = 0;
|
||
int inited = 0;
|
||
int *zvfs_fds = NULL;
|
||
uint32_t zvfs_fd_count = 0;
|
||
if (zvfs_snapshot_fds_in_range(first, last, &zvfs_fds, &zvfs_fd_count) < 0) {
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
for (uint32_t i = 0; i < zvfs_fd_count; i++) {
|
||
if (!inited) {
|
||
zvfs_ensure_init();
|
||
inited = 1;
|
||
}
|
||
if (zvfs_close_impl(zvfs_fds[i]) < 0) {
|
||
any_err = 1;
|
||
}
|
||
}
|
||
free(zvfs_fds);
|
||
|
||
/* 让内核处理剩余非 zvfs fd（CLOEXEC 等 flags 也在这里生效） */
|
||
if (real_close_range) {
|
||
if (real_close_range(first, last, flags) < 0 && !any_err)
|
||
any_err = 1;
|
||
} else {
|
||
/* 降级：逐个 close 非 zvfs fd（按 open-max 做上界截断） */
|
||
unsigned int upper = last;
|
||
long open_max = sysconf(_SC_OPEN_MAX);
|
||
if (open_max > 0 && upper >= (unsigned int)open_max) {
|
||
upper = (unsigned int)open_max - 1;
|
||
}
|
||
|
||
for (unsigned int fd = first; fd <= upper; fd++) {
|
||
if (!zvfs_is_zvfs_fd((int)fd))
|
||
real_close((int)fd);
|
||
if (fd == upper)
|
||
break;
|
||
}
|
||
}
|
||
|
||
ZVFS_HOOK_LEAVE();
|
||
return any_err ? -1 : 0;
|
||
}
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* dup */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
int
|
||
dup(int oldfd)
|
||
{
|
||
ZVFS_HOOK_ENTER();
|
||
|
||
int is_zvfs_fd = (!ZVFS_IN_HOOK() && zvfs_is_zvfs_fd(oldfd));
|
||
if (!is_zvfs_fd) {
|
||
int ret = real_dup(oldfd);
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|
||
|
||
zvfs_ensure_init();
|
||
|
||
int newfd = real_dup(oldfd);
|
||
if (newfd < 0) {
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
if (zvfs_dup_attach_newfd(oldfd, newfd, 0) < 0) {
|
||
int saved = errno;
|
||
(void)real_close(newfd);
|
||
errno = saved;
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
ZVFS_HOOK_LEAVE();
|
||
return newfd;
|
||
}
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* dup2 */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
int
|
||
dup2(int oldfd, int newfd)
|
||
{
|
||
ZVFS_HOOK_ENTER();
|
||
|
||
int is_zvfs_fd = (!ZVFS_IN_HOOK() && zvfs_is_zvfs_fd(oldfd));
|
||
if (!is_zvfs_fd) {
|
||
int ret = real_dup2(oldfd, newfd);
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|
||
|
||
/* POSIX 兼容：dup2(oldfd, oldfd) 对合法 fd 直接返回 oldfd。 */
|
||
if (oldfd == newfd) {
|
||
ZVFS_HOOK_LEAVE();
|
||
return oldfd;
|
||
}
|
||
|
||
zvfs_ensure_init();
|
||
int newfd_was_zvfs = zvfs_is_zvfs_fd(newfd);
|
||
|
||
int ret = real_dup2(oldfd, newfd);
|
||
if (ret < 0) {
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
if (newfd_was_zvfs && zvfs_detach_fd_mapping(newfd, 1) < 0) {
|
||
int saved = errno;
|
||
(void)real_close(newfd);
|
||
errno = saved;
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
if (zvfs_dup_attach_newfd(oldfd, newfd, 0) < 0) {
|
||
int saved = errno;
|
||
(void)real_close(newfd);
|
||
errno = saved;
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* dup3 */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
int
|
||
dup3(int oldfd, int newfd, int flags)
|
||
{
|
||
ZVFS_HOOK_ENTER();
|
||
|
||
int is_zvfs_fd = (!ZVFS_IN_HOOK() && zvfs_is_zvfs_fd(oldfd));
|
||
if (!is_zvfs_fd) {
|
||
int ret = real_dup3(oldfd, newfd, flags);
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|
||
|
||
if (oldfd == newfd) {
|
||
errno = EINVAL;
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
if ((flags & ~O_CLOEXEC) != 0) {
|
||
errno = EINVAL;
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
zvfs_ensure_init();
|
||
int newfd_was_zvfs = zvfs_is_zvfs_fd(newfd);
|
||
|
||
int ret = real_dup3(oldfd, newfd, flags);
|
||
if (ret < 0) {
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
if (newfd_was_zvfs && zvfs_detach_fd_mapping(newfd, 1) < 0) {
|
||
int saved = errno;
|
||
(void)real_close(newfd);
|
||
errno = saved;
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
int fd_flags = (flags & O_CLOEXEC) ? FD_CLOEXEC : 0;
|
||
if (zvfs_dup_attach_newfd(oldfd, newfd, fd_flags) < 0) {
|
||
int saved = errno;
|
||
(void)real_close(newfd);
|
||
errno = saved;
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|
||
|
||
/* ------------------------------------------------------------------ */
|
||
/* fork */
|
||
/* ------------------------------------------------------------------ */
|
||
|
||
pid_t
|
||
fork(void)
|
||
{
|
||
ZVFS_HOOK_ENTER();
|
||
|
||
if (ZVFS_IN_HOOK()) {
|
||
pid_t ret = real_fork();
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|
||
|
||
uint64_t *handle_ids = NULL;
|
||
uint32_t *ref_deltas = NULL;
|
||
uint32_t count = 0;
|
||
|
||
if (zvfs_snapshot_fd_handles(&handle_ids, &ref_deltas, &count) < 0) {
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
if (count > 0) {
|
||
zvfs_ensure_init();
|
||
if (zvfs_add_ref_batch_or_fallback(handle_ids, ref_deltas, count) < 0) {
|
||
int saved = errno;
|
||
free(handle_ids);
|
||
free(ref_deltas);
|
||
errno = saved;
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
}
|
||
|
||
pid_t ret = real_fork();
|
||
if (ret < 0) {
|
||
int saved = errno;
|
||
if (count > 0)
|
||
zvfs_rollback_added_refs(handle_ids, count);
|
||
free(handle_ids);
|
||
free(ref_deltas);
|
||
errno = saved;
|
||
ZVFS_HOOK_LEAVE();
|
||
return -1;
|
||
}
|
||
|
||
free(handle_ids);
|
||
free(ref_deltas);
|
||
ZVFS_HOOK_LEAVE();
|
||
return ret;
|
||
}
|