feat(proto/server)!: 升级至协议 v2（统一错误模型）；全面替换 Request/Response 并移除 ret

- Breaking change: 协议不向后兼容，旧客户端需同步升级
- Proto: 新增 FsOp/ErrorCause/FsError/RpcStatus；为所有 FS 接口定义 <Op>Request/<Op>Response；删除历史 ret 字段
- Server: 所有 RPC 返回统一的 RpcStatus；成功 ok=true，失败填充 FsError（operation/paths/sys_msg 等）
  - Open/Read/Write 对齐新字段（fi/data/written）；Readdir/Opendir/Releasedir 等返回类型调整
  - Rename 传回 from/to；OpendirRequest 不再输入 fi，服务端生成并回传
- Docs: 新增 docs/protocol_v2.md；README 标注 v2 破坏性升级与用法
- Build: 主要面向 Windows（winapi）。Linux 环境类型检查可能失败

后续：完善 errno 抽取与 context 填充；可选引入流式 read/write 以优化大文件传输。

README.md

@@ -1,4 +1,13 @@
 # wls_vfs
 
-windows linux文件共享，使用fuse + grpc + protobuffer 
+Windows/Linux 文件共享服务端（gRPC + Protobuf）。
-语言：rust
+
+本仓库已升级至协议 v2（统一错误模型）：
+
+- 所有 RPC 使用显式的 `Request`/`Response` 类型；
+- 响应统一携带 `RpcStatus { ok, error }`；
+- 删除历史 `ret` 字段；失败信息通过 `FsError` 完整承载（`code`/`sys_msg`/`operation`/`paths`/`context` 等）。
+
+协议详情见：`proto/lws.proto` 与 `docs/protocol_v2.md`。
+
+注意：本项目主要在 Windows 上构建运行（依赖 `winapi`）。在非 Windows 平台构建仅用于类型检查，可能失败。

docs/protocol_v2.md

@@ -0,0 +1,14 @@
+# LWS 协议 v2（统一错误模型）
+
+- RpcStatus { ok, error }
+- FsError { code, message, sys_msg, grpc_code, grpc_message, operation(FsOp), paths[], context{...}, causes[], server, timestamp_ms, retriable }
+
+成功：ok = true；失败：ok = false 且 error.code 为正数 POSIX errno。
+
+常用 context keys: flags, offset, size, uid, gid, mode, fh, mask, xattr_name, xattr_size。
+
+FsOp 与 RPC 映射：与客户端 docs 相同（参见 proto/lws.proto 中的 service 定义）。
+
+服务端返回建议：
+- 失败时设置 error.code 与 sys_msg，并补充 operation/paths/context。
+- 传输层错误由客户端据 gRPC `Status` 统一映射。

proto/lws.proto

@@ -16,43 +16,62 @@ syntax = "proto3";
 
 package lws_vfs;
 
-service LwsVfs {
+// Filesystem operation types for diagnostics and observability.
-  // Sends a greeting
+enum FsOp {
-  rpc SayHello(HelloRequest) returns (HelloReply) {}
+  FSOP_UNKNOWN = 0;
-  rpc GetConfig(get_config) returns (get_config) {}
+  FSOP_GETATTR = 1;
-
+  FSOP_SETXATTR = 2;
-  rpc fgetattr(getattr) returns (getattr) {}
+  FSOP_ACCESS = 3;
-  rpc fsetxattr(setxattr) returns (setxattr) {}
+  FSOP_READDIR = 4;
-  rpc faccess(access) returns (access) {}
+  FSOP_READ = 5;
-  rpc freaddir(readdir) returns (readdir) {}
+  FSOP_OPEN = 6;
-  rpc fread(read) returns (read) {}
+  FSOP_WRITE = 7;
-  rpc fopen(open) returns (open) {}
+  FSOP_GETXATTR = 8;
-  rpc fwrite(write) returns (write) {}
+  FSOP_TRUNCATE = 9;
-  rpc fgetxattr(getxattr) returns (getxattr) {}
+  FSOP_UTIMENS = 10;
-  rpc ftruncate(truncate) returns (truncate) {}
+  FSOP_CHOWN = 11;
-  rpc futimens(utimens) returns (utimens) {}
+  FSOP_RELEASE = 12;
-  rpc fchown(chown) returns (chown) {}
+  FSOP_MKDIR = 13;
-  rpc frelease(release) returns (release) {}
+  FSOP_RMDIR = 14;
-  rpc fmkdir(mkdir) returns (mkdir) {}
+  FSOP_FLUSH = 15;
-  rpc frmdir(rmdir) returns (rmdir) {}
+  FSOP_OPENDIR = 16;
-  rpc fflush(flush) returns (flush) {}
+  FSOP_RELEASEDIR = 17;
-  rpc fopendir(opendir) returns (opendir) {}
+  FSOP_CREATE = 18;
-  rpc freleasedir(releasedir) returns (releasedir) {}
+  FSOP_UNLINK = 19;
-  rpc fcreate(create) returns (create) {}
+  FSOP_RENAME = 20;
-  rpc funlink(unlink) returns (unlink) {}
+  FSOP_HELLO = 21;
-  rpc frename(rename) returns (rename) {}
+  FSOP_GET_CONFIG = 22;
 }
 
-// The request message containing the user's name.
+// Optional chained cause for nested errors.
-message HelloRequest { string name = 1; }
+message ErrorCause {
-
+  int32 code = 1;                  // POSIX errno if available
-// The response message containing the greetings
+  string message = 2;              // human-readable message
-message HelloReply { string message = 1; }
+  string type = 3;                 // error type/category from server implementation
-
-message get_config {
-  string config = 1;
 }
 
+// Rich error payload carried by all responses.
+message FsError {
+  int32 code = 1;                  // POSIX errno (>0)
+  string message = 2;              // application error message
+  string sys_msg = 3;              // strerror(code) or OS message
+  uint32 grpc_code = 4;            // gRPC status code (if applicable)
+  string grpc_message = 5;         // gRPC status message
+  FsOp operation = 6;              // which fs op failed
+  repeated string paths = 7;       // involved paths (e.g. [from, to])
+  map<string, string> context = 8; // flags/size/offset/uid/gid ...
+  repeated ErrorCause causes = 9;  // nested causes
+  string server = 10;              // server id/hostname
+  uint64 timestamp_ms = 11;        // server time when error occurred
+  bool retriable = 12;             // whether retry may succeed
+}
+
+message RpcStatus {
+  bool ok = 1;                     // true if the call succeeded
+  FsError error = 2;               // populated when ok == false
+}
+
+// Common structs
 message file_info {
   uint32 flags = 1;
   uint32 fh_old = 2;
@@ -77,34 +96,9 @@ message fstat {
   uint64 fst_blocks = 13;
 }
 
-// fuse api function message define:
+message timespec {
-message getattr {
+  int32 tv_sec = 1;
-  string path = 1;
+  int64 tv_nsec = 2;
-  fstat stat = 2;
-  file_info fi = 3;
-  int32 ret = 15;
-}
-
-message setxattr {
-  string path = 1;
-  string name = 2;
-  bytes value = 3;
-  int64 size = 4;
-  uint32 flags = 5;
-  int32 ret = 15;
-}
-message getxattr {
-  string path = 1;
-  string name = 2;
-  bytes value = 3;
-  int64 size = 4;
-  int32 ret = 15;
-}
-
-message access {
-  string path = 1;
-  uint32 mask = 2;
-  int32 ret = 15;
 }
 
 message direntry {
@@ -112,112 +106,100 @@ message direntry {
   uint32 kind = 2;
 }
 
-message readdir {
+// Service and RPCs
-  string path = 1;
+service LwsVfs {
-  repeated direntry dirs = 2;
+  rpc SayHello(HelloRequest) returns (HelloReply) {}
-  uint32 offset = 3;
+  rpc GetConfig(GetConfigRequest) returns (GetConfigResponse) {}
-  file_info fi = 4;
+
-  int32 ret = 15;
+  rpc fgetattr(GetattrRequest) returns (GetattrResponse) {}
+  rpc fsetxattr(SetxattrRequest) returns (EmptyResponse) {}
+  rpc faccess(AccessRequest) returns (EmptyResponse) {}
+  rpc freaddir(ReaddirRequest) returns (ReaddirResponse) {}
+  rpc fread(ReadRequest) returns (ReadResponse) {}
+  rpc fopen(OpenRequest) returns (OpenResponse) {}
+  rpc fwrite(WriteRequest) returns (WriteResponse) {}
+  rpc fgetxattr(GetxattrRequest) returns (GetxattrResponse) {}
+  rpc ftruncate(TruncateRequest) returns (EmptyResponse) {}
+  rpc futimens(UtimensRequest) returns (EmptyResponse) {}
+  rpc fchown(ChownRequest) returns (EmptyResponse) {}
+  rpc frelease(ReleaseRequest) returns (EmptyResponse) {}
+  rpc fmkdir(MkdirRequest) returns (EmptyResponse) {}
+  rpc frmdir(RmdirRequest) returns (EmptyResponse) {}
+  rpc fflush(FlushRequest) returns (EmptyResponse) {}
+  rpc fopendir(OpendirRequest) returns (OpendirResponse) {}
+  rpc freleasedir(ReleasedirRequest) returns (EmptyResponse) {}
+  rpc fcreate(CreateRequest) returns (CreateResponse) {}
+  rpc funlink(UnlinkRequest) returns (EmptyResponse) {}
+  rpc frename(RenameRequest) returns (EmptyResponse) {}
 }
 
-message open {
+// Hello
-  string path = 1;
+message HelloRequest { string name = 1; }
-  file_info fi = 2;
+message HelloReply { string message = 1; RpcStatus status = 2; }
-  int32 ret = 15;
-}
 
-message read {
+// Config
-  string path = 1;
+message GetConfigRequest {}
-  bytes buff = 2;
+message GetConfigResponse { string config = 1; RpcStatus status = 2; }
-  int64 size = 3;
-  uint64 offset = 4;
-  file_info fi = 5;
-  int32 ret = 15;
-}
 
-message write {
+// getattr
-  string path = 1;
+message GetattrRequest { string path = 1; file_info fi = 2; }
-  bytes buff = 2;
+message GetattrResponse { fstat stat = 1; RpcStatus status = 2; }
-  uint64 size = 3;
-  uint64 offset = 4;
-  file_info fi = 5;
-  int32 ret = 15;
-}
 
-message truncate {
+// xattr
-  string path = 1;
+message SetxattrRequest { string path = 1; string name = 2; bytes value = 3; int64 size = 4; uint32 flags = 5; }
-  int64 size = 3;
+message GetxattrRequest { string path = 1; string name = 2; int64 size = 3; }
-  int32 ret = 15;
+message GetxattrResponse { bytes value = 1; RpcStatus status = 2; }
-}
 
-message timespec {
+// access
-  int32 tv_sec = 1;
+message AccessRequest { string path = 1; uint32 mask = 2; }
-  int64 tv_nsec = 2;
-}
-message utimens {
-  string path = 1;
-  repeated timespec ts = 2; // const struct timespec ts[2]
-  int32 ret = 15;
-}
 
-message chown {
+// readdir
-  string path = 1;
+message ReaddirRequest { string path = 1; uint32 offset = 2; file_info fi = 3; }
-  int32 uid = 2;
+message ReaddirResponse { repeated direntry dirs = 1; RpcStatus status = 2; }
-  int32 gid = 3;
-  int32 ret = 15;
-}
 
-message release {
+// open
-  string path = 1;
+message OpenRequest { string path = 1; file_info fi = 2; }
-  file_info fi = 2;
+message OpenResponse { file_info fi = 1; RpcStatus status = 2; }
-  uint32 flush = 3;
-  int32 ret = 15;
-}
 
-message mkdir {
+// read
-  string path = 1;
+message ReadRequest { string path = 1; uint64 offset = 2; int64 size = 3; file_info fi = 4; }
-  file_info fi = 2;
+message ReadResponse { bytes data = 1; RpcStatus status = 2; }
-  uint32 mode = 3;
-  int32 ret = 15;
-}
 
-message rmdir {
+// write
-  string path = 1;
+message WriteRequest { string path = 1; uint64 offset = 2; bytes data = 3; file_info fi = 4; }
-  int32 ret = 15;
+message WriteResponse { uint64 written = 1; RpcStatus status = 2; }
-}
 
-message flush {
+// truncate
-  string path = 1;
+message TruncateRequest { string path = 1; int64 size = 2; }
-  file_info fi = 2;
-  int32 ret = 15;
-}
 
-message opendir {
+// utimens
-  string path = 1;
+message UtimensRequest { string path = 1; repeated timespec ts = 2; }
-  file_info fi = 2;
-  int32 ret = 15;
-}
 
-message releasedir {
+// chown
-  string path = 1;
+message ChownRequest { string path = 1; int32 uid = 2; int32 gid = 3; }
-  file_info fi = 2;
-  int32 ret = 15;
-}
 
-message create {
+// release/flush
-  string path = 1;
+message ReleaseRequest { string path = 1; file_info fi = 2; uint32 flush = 3; }
-  uint32 mode = 2;
+message FlushRequest { string path = 1; file_info fi = 2; }
-  file_info fi = 3;
-  int32 ret = 15;
-}
 
-message unlink {
+// mkdir/rmdir
-  string path = 1;
+message MkdirRequest { string path = 1; uint32 mode = 2; }
-  int32 ret = 15;
+message RmdirRequest { string path = 1; }
-}
 
-message rename {
+// opendir/releasedir
-  string path = 1;
+message OpendirRequest { string path = 1; }
-  string new = 2;
+message OpendirResponse { file_info fi = 1; RpcStatus status = 2; }
-  int32 ret = 15;
+message ReleasedirRequest { string path = 1; file_info fi = 2; }
-}
+
+// create
+message CreateRequest { string path = 1; uint32 mode = 2; }
+message CreateResponse { file_info fi = 1; RpcStatus status = 2; }
+
+// unlink
+message UnlinkRequest { string path = 1; }
+
+// rename
+message RenameRequest { string path = 1; string new = 2; }
+
+// Empty response with status only
+message EmptyResponse { RpcStatus status = 1; }

src/lib.rs

@@ -1,8 +1,10 @@
-
 use lws_vfs::lws_vfs_server::LwsVfs;
 use lws_vfs::{
-    Access, Chown, FileInfo, Flush, Fstat, Getattr, Getxattr, HelloReply, HelloRequest, Mkdir,
+    AccessRequest, ChownRequest, CreateRequest, CreateResponse, Direntry, EmptyResponse, FileInfo,
-    Open, Read, Readdir, Release, Rmdir, Setxattr, Truncate, Utimens, Write, Create, Unlink, Opendir, Releasedir, Rename, GetConfig,
+    FlushRequest, FsError, FsOp, Fstat, GetConfigRequest, GetConfigResponse, GetattrRequest, GetattrResponse,
+    GetxattrRequest, GetxattrResponse, HelloReply, HelloRequest, MkdirRequest, OpenRequest, OpenResponse,
+    OpendirRequest, OpendirResponse, ReadRequest, ReadResponse, ReaddirRequest, ReaddirResponse, ReleaseRequest, ReleasedirRequest,
+    RenameRequest, RpcStatus, RmdirRequest, SetxattrRequest, TruncateRequest, UnlinkRequest, UtimensRequest, WriteRequest, WriteResponse,
 };
 
 use self::fs_impl::FSImpl;
@@ -16,6 +18,7 @@ use std::collections::HashMap;
 extern crate log;
 
 use std::path::{Path, PathBuf};
+use std::time::{SystemTime, UNIX_EPOCH};
 
 mod fs_impl;
 mod disk;
@@ -58,53 +61,44 @@ impl Config {
                 )))
             }
         };
-         let mut mount_map: HashMap<String, String> = mounts.iter().filter(|(key, _)| {
+        let mut mount_map: HashMap<String, String> = mounts
-            match disk::get_disk_info(&key) {
+            .iter()
+            .filter(|(key, _)| match disk::get_disk_info(&key) {
                 None => false,
                 Some(_) => true,
-            }
+            })
-        }).map(|(key, value)| (key.to_string(), value.as_str().unwrap().to_string())).collect();
+            .map(|(key, value)| (key.to_string(), value.as_str().unwrap().to_string()))
+            .collect();
         log::debug!("mounts is {:?}", mounts);
 
         let mut volume_names = HashMap::new();
 
-        // 获取所有的盘符对应的卷标便于后续进行比对
         for drive in 'C'..='Z' {
             let drive = format!("{}:\\", drive);
             if let Some((volume, _, _)) = disk::get_disk_info(&drive) {
-                //TODO: 这里如果存在同名的卷标会出现问题
                 volume_names.insert(volume, drive);
             }
         }
         log::info!("local disk info: {:?}", volume_names);
 
-        // 遍历配置的盘符和卷标，将配置的盘符和卷标映射到实际盘符上
         for (key, value) in mounts.iter() {
-            // 直接看下是不是盘符
             if let Some((drive, _, _)) = disk::get_disk_info(&key) {
                 mount_map.insert(drive.to_string(), value.as_str().unwrap().to_string());
-            } else {
+            } else if let Some(drive) = volume_names.get(key.as_str()) {
-                // 看下是不是卷标
-                if let Some(drive) = volume_names.get(key.as_str()) {
-                    // log::info!("value is {:?} {}", value, value.as_str().unwrap());
                 mount_map.insert(drive.to_string(), value.as_str().unwrap().to_string());
             } else {
                 log::error!("mount volume name [{}] not found in disk list", key);
                 return Err(Box::new(std::io::Error::new(
                     std::io::ErrorKind::Other,
                     "mount map unavailable",
-                    )))
+                )));
-                }
-
             }
         }
         log::info!("after local search&match: {:?}", mount_map);
         Ok(Config { port, mount_map })
     }
 
-    pub fn get_port(&self) -> u16 {
+    pub fn get_port(&self) -> u16 { self.port }
-        self.port
-    }
 }
 
 /// server 的基础结构
@@ -115,412 +109,317 @@ pub struct LwsVfsIns {
 }
 
 fn linux_to_windows_path(linux_path: &str) -> String {
-    let path: PathBuf = Path::new(linux_path)
+    let path: PathBuf = Path::new(linux_path).components().collect();
-        .components()
-        // .filter(|component| component.as_os_str() != Component::RootDir.as_os_str())
-        // .map(|component| component.as_os_str().to_string_lossy().into_owned())
-        .collect();
     path.to_string_lossy().to_string()
 }
 
 impl LwsVfsIns {
     pub fn new(json: &str) -> Result<LwsVfsIns, Box<dyn Error>> {
-        Ok(LwsVfsIns {
+        Ok(LwsVfsIns { config: Config::new(json)?, fs: FSImpl::new() })
-            config: Config::new(json)?,
-            fs: FSImpl::new(),
-        })
     }
     fn lpath(&self, path: &String) -> String {
         let mut ret = String::new();
-        // log::trace!("try to convert {}", path);
-        // /l0e -> w:
         for (k, v) in &self.config.mount_map {
-            if path.starts_with(v) {
+            if path.starts_with(v) { ret = path.replace(v, k); break; }
-                ret = path.replace(v, k);
-                break;
-            }
         }
         linux_to_windows_path(&ret)
     }
 }
 
-/// 将result 转换成 i32返回给rpc使用
+fn ok_status() -> Option<RpcStatus> { Some(RpcStatus{ ok: true, error: None }) }
-macro_rules! result2ret {
+
-    ($fun_name:expr, $path:expr, $ret:expr) => {
+fn now_ms() -> u64 {
-        match $ret {
+    SystemTime::now().duration_since(UNIX_EPOCH).map(|d| d.as_millis() as u64).unwrap_or(0)
-            Ok(ret) => ret,
-            Err(e) => {
-                log::error!("{} [{}]: {:?}", $fun_name, $path, e);
-                if let Some(e) = e.downcast_ref::<std::io::Error>() {
-                    e.raw_os_error().unwrap_or(-1) as i32
-                }  else {
-                    -1
 }
+
+fn err_status(op: FsOp, paths: Vec<String>, err: &(dyn std::error::Error)) -> Option<RpcStatus> {
+    let (code, sys_msg) = (libc::EIO, format!("{}", err));
+    Some(RpcStatus{
+        ok: false,
+        error: Some(FsError{
+            code,
+            message: String::new(),
+            sys_msg,
+            grpc_code: 0,
+            grpc_message: String::new(),
+            operation: op as i32,
+            paths,
+            context: Default::default(),
+            causes: vec![],
+            server: std::env::var("HOSTNAME").unwrap_or_default(),
+            timestamp_ms: now_ms(),
+            retriable: false,
+        })
+    })
 }
-        }
-    };
-}
-    // match e.downcast_ref::<std::io::Error>() {
-    //     Some(e) => match e.kind() {
-    //         std::io::ErrorKind::NotFound => libc::ENOENT,
-    //         std::io::ErrorKind::PermissionDenied => libc::EACCES,
-    //         std::io::ErrorKind::AlreadyExists => libc::EEXIST,
-    //     }
-    // }
 
 #[tonic::async_trait]
 impl LwsVfs for LwsVfsIns {
-    async fn say_hello(
+    async fn say_hello(&self, request: Request<HelloRequest>) -> Result<Response<HelloReply>, Status> {
-        &self,
-        request: Request<HelloRequest>,
-    ) -> Result<Response<HelloReply>, Status> {
         let request = request.into_inner();
         log::trace!("Got a request: {:?}", request);
-
+        let reply = HelloReply { message: format!("Hello {}!", request.name), status: ok_status() };
-        let reply = HelloReply {
-            message: format!("Hello {}!", request.name),
-        };
-
         Ok(Response::new(reply))
     }
-    async fn get_config(&self, _req: Request<GetConfig>) -> Result<Response<GetConfig>, Status> {
+
+    async fn get_config(&self, _req: Request<GetConfigRequest>) -> Result<Response<GetConfigResponse>, Status> {
         log::info!("{:?}", self.config);
         let config = serde_json::to_string(&self.config).unwrap();
         log::info!("reply config: {}", config);
-        let reply = GetConfig {
+        Ok(Response::new(GetConfigResponse{ config, status: ok_status() }))
-            config,
-        };
-        Ok(Response::new(reply))
     }
-    async fn fgetattr(&self, request: Request<Getattr>) -> Result<Response<Getattr>, Status> {
+
+    async fn fgetattr(&self, request: Request<GetattrRequest>) -> Result<Response<GetattrResponse>, Status> {
         let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
         let path = &self.lpath(&request.path);
         let mut fstat = Fstat::default();
         let mut fi = FileInfo::default();
-        let ret = self.fs.fgetattr(path, &mut fstat, &mut fi);
+        let reply = match self.fs.fgetattr(path, &mut fstat, &mut fi) {
-        let ret = result2ret!("fgetattr", path, ret);
+            Ok(0) => GetattrResponse { stat: Some(fstat), status: ok_status() },
-        let reply = Getattr {
+            Ok(_) => GetattrResponse { stat: None, status: err_status(FsOp::FSOP_GETATTR, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
-            path: path.to_string(),
+            Err(e) => GetattrResponse { stat: None, status: err_status(FsOp::FSOP_GETATTR, vec![path.to_string()], &*e) },
-            stat: Some(fstat),
-            ret,
-            ..Getattr::default()
         };
         Ok(Response::new(reply))
     }
-    async fn fopen(&self, request: Request<Open>) -> Result<Response<Open>, Status> {
+
+    async fn fopen(&self, request: Request<OpenRequest>) -> Result<Response<OpenResponse>, Status> {
         let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
         let path = &self.lpath(&request.path);
-        let mut fi = match request.fi{
+        let mut fi = FileInfo::default();
-            Some(fi) => fi,
+        let reply = match self.fs.fopen(path, &mut fi) {
-            None => FileInfo::default(),
+            Ok(0) => OpenResponse{ fi: Some(fi), status: ok_status() },
-        };
+            Ok(_) => OpenResponse{ fi: None, status: err_status(FsOp::FSOP_OPEN, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
-        let ret =  self.fs.fopen(path, &mut fi);
+            Err(e) => OpenResponse{ fi: None, status: err_status(FsOp::FSOP_OPEN, vec![path.to_string()], &*e) },
-        let ret = result2ret!("fopen", path, ret);
-        let reply = Open {
-            path: path.to_string(),
-            fi: Some(fi),
-            ret,
         };
         Ok(Response::new(reply))
     }
-    async fn fread(&self, request: Request<Read>) -> Result<Response<Read>, Status> {
+
+    async fn fread(&self, request: Request<ReadRequest>) -> Result<Response<ReadResponse>, Status> {
         let request = request.into_inner();
-        let mut fi = match request.fi{
+        let mut fi = FileInfo::default();
-            Some(fi) => fi,
-            None => FileInfo::default(),
-        };
         let path = &self.lpath(&request.path);
         let mut size: usize = request.size as usize;
-        let mut offset: usize = request.offset as usize;
+        let offset: usize = request.offset as usize;
-        let mut buff: Vec<u8> = Vec::with_capacity(size);
+        let mut buff: Vec<u8> = vec![0; size];
-        unsafe {
+        let reply = match self.fs.fread(path, &mut buff, &mut size, offset, &mut fi) {
-            buff.set_len(size);
+            Ok(0) => ReadResponse { data: buff, status: ok_status() },
-        }
+            Ok(_) => ReadResponse { data: Vec::new(), status: err_status(FsOp::FSOP_READ, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
-        log::trace!("Got a request: fread {}, size {} offset {}", path, request.size, offset);
+            Err(e) => ReadResponse { data: Vec::new(), status: err_status(FsOp::FSOP_READ, vec![path.to_string()], &*e) },
-        let ret = self.fs.fread(path, &mut buff, &mut size, offset, &mut fi);
-        let ret = result2ret!("fread", path, ret);
-        if ret != 0 {
-            buff = Vec::new();
-            offset = 0;
-        }
-        Ok(Response::new(Read {
-            path: request.path,
-            size: buff.len() as i64,
-            buff,
-            offset: offset as u64,
-            fi: None,
-            ret,
-        }))
-    }
-
-    async fn fwrite(&self, request: Request<Write>) -> Result<Response<Write>, Status> {
-        let request = request.into_inner();
-        let mut fi = match request.fi{
-            Some(fi) => fi,
-            None => FileInfo::default(),
-        };
-        let path = &self.lpath(&request.path);
-        let buff = request.buff;
-        let mut size = request.size as usize;
-        let offset = request.offset as usize;
-        log::trace!("Got a request: Write {}, size {} offset {}", path, request.size, offset);
-        let ret = self.fs.fwrite(path, &buff, &mut size, offset, &mut fi);
-        let ret = result2ret!("fwrite", path, ret);
-        let reply = Write {
-            ret,
-            path: path.to_string(),
-            size: size as u64,
-            ..Default::default()
         };
         Ok(Response::new(reply))
     }
-    async fn faccess(&self, request: Request<Access>) -> Result<Response<Access>, Status> {
+
+    async fn fwrite(&self, request: Request<WriteRequest>) -> Result<Response<WriteResponse>, Status> {
+        let request = request.into_inner();
+        let mut fi = FileInfo::default();
+        let path = &self.lpath(&request.path);
+        let buff = request.data;
+        let mut size = buff.len();
+        let offset = request.offset as usize;
+        let reply = match self.fs.fwrite(path, &buff, &mut size, offset, &mut fi) {
+            Ok(0) => WriteResponse { written: size as u64, status: ok_status() },
+            Ok(_) => WriteResponse { written: 0, status: err_status(FsOp::FSOP_WRITE, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
+            Err(e) => WriteResponse { written: 0, status: err_status(FsOp::FSOP_WRITE, vec![path.to_string()], &*e) },
+        };
+        Ok(Response::new(reply))
+    }
+
+    async fn faccess(&self, request: Request<AccessRequest>) -> Result<Response<EmptyResponse>, Status> {
         let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
         let path = &self.lpath(&request.path);
         let mask = request.mask;
-        let ret = self.fs.faccess(path, mask);
+        let reply = match self.fs.faccess(path, mask) {
-        let ret = result2ret!("faccess", path, ret);
+            Ok(0) => EmptyResponse { status: ok_status() },
-        let reply = Access {
+            Ok(_) => EmptyResponse { status: err_status(FsOp::FSOP_ACCESS, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
-            ret,
+            Err(e) => EmptyResponse { status: err_status(FsOp::FSOP_ACCESS, vec![path.to_string()], &*e) },
-            path: path.to_string(),
-            mask,
         };
         Ok(Response::new(reply))
     }
 
-    async fn fsetxattr(&self, request: Request<Setxattr>) -> Result<Response<Setxattr>, Status> {
+    async fn fsetxattr(&self, request: Request<SetxattrRequest>) -> Result<Response<EmptyResponse>, Status> {
         let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
         let path = &self.lpath(&request.path);
         let name = request.name.as_ref();
         let value = request.value;
         let size = request.size as usize;
         let flags = request.flags;
-        let ret = self.fs.fsetxattr(path, name, &value, size, flags);
+        let reply = match self.fs.fsetxattr(path, name, &value, size, flags) {
-        let ret = result2ret!("fsetxattr", path, ret);
+            Ok(0) => EmptyResponse { status: ok_status() },
-        let reply = Setxattr {
+            Ok(_) => EmptyResponse { status: err_status(FsOp::FSOP_SETXATTR, vec![path.to_string()], &std::io::Error::from_raw_os_error(libc::ENOSYS)) },
-            ret: ret,
+            Err(e) => EmptyResponse { status: err_status(FsOp::FSOP_SETXATTR, vec![path.to_string()], &*e) },
-            ..Setxattr::default()
         };
         Ok(Response::new(reply))
     }
-    async fn fgetxattr(&self, request: Request<Getxattr>) -> Result<Response<Getxattr>, Status> {
+
+    async fn fgetxattr(&self, request: Request<GetxattrRequest>) -> Result<Response<GetxattrResponse>, Status> {
         let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
         let path = &self.lpath(&request.path);
         let name = request.name.as_ref();
         let size = request.size as usize;
-        let ret = self.fs.fgetxattr(path, name, size);
+        let reply = match self.fs.fgetxattr(path, name, size) {
-        let ret = result2ret!("fgetxattr", path, ret);
+            Ok(0) => GetxattrResponse { value: Vec::new(), status: ok_status() },
-        let reply = Getxattr {
+            Ok(_) => GetxattrResponse { value: Vec::new(), status: err_status(FsOp::FSOP_GETXATTR, vec![path.to_string()], &std::io::Error::from_raw_os_error(libc::ENOSYS)) },
-            ret,
+            Err(e) => GetxattrResponse { value: Vec::new(), status: err_status(FsOp::FSOP_GETXATTR, vec![path.to_string()], &*e) },
-            ..Getxattr::default()
         };
         Ok(Response::new(reply))
     }
 
-    async fn freaddir(&self, request: Request<Readdir>) -> Result<Response<Readdir>, Status> {
+    async fn freaddir(&self, request: Request<ReaddirRequest>) -> Result<Response<ReaddirResponse>, Status> {
         let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
+        let mut fi = FileInfo::default();
-        let mut fi = match request.fi{
-            Some(fi) => fi,
-            None => FileInfo::default(),
-        };
         let path = &self.lpath(&request.path);
         let offset = request.offset as usize;
-        let mut dirs = vec![];
+        let mut dirs: Vec<Direntry> = vec![];
         let size = 0;
-        let ret = self.fs.freaddir(path, &mut dirs, size, offset, &mut fi);
+        let reply = match self.fs.freaddir(path, &mut dirs, size, offset, &mut fi) {
-        let ret = result2ret!("freaddir", path, ret);
+            Ok(0) => ReaddirResponse { dirs, status: ok_status() },
-        let reply = Readdir {
+            Ok(_) => ReaddirResponse { dirs: vec![], status: err_status(FsOp::FSOP_READDIR, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
-            ret,
+            Err(e) => ReaddirResponse { dirs: vec![], status: err_status(FsOp::FSOP_READDIR, vec![path.to_string()], &*e) },
-            dirs,
-            ..Readdir::default()
-        };
-        Ok(Response::new(reply))
-    }
-    async fn fmkdir(&self, request: Request<Mkdir>) -> Result<Response<Mkdir>, Status> {
-        let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
-        let path = &self.lpath(&request.path);
-        let mode = request.mode;
-        let ret = self.fs.fmkdir(&path, mode);
-        let ret = result2ret!("fmkdir", path, ret);
-        let reply = Mkdir {
-            ret,
-            ..Mkdir::default()
-        };
-        Ok(Response::new(reply))
-    }
-    async fn ftruncate(&self, request: Request<Truncate>) -> Result<Response<Truncate>, Status> {
-        let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
-        let path = &self.lpath(&request.path);
-        let size = request.size as u64;
-        let ret = self.fs.ftruncate(path, size);
-        let ret = result2ret!("ftruncate", path, ret);
-        let reply = Truncate {
-            ret,
-            ..Truncate::default()
         };
         Ok(Response::new(reply))
     }
 
-    async fn futimens(&self, request: Request<Utimens>) -> Result<Response<Utimens>, Status> {
+    async fn fmkdir(&self, request: Request<MkdirRequest>) -> Result<Response<EmptyResponse>, Status> {
+        let request = request.into_inner();
+        let path = &self.lpath(&request.path);
+        let mode = request.mode;
+        let reply = match self.fs.fmkdir(&path, mode) {
+            Ok(0) => EmptyResponse { status: ok_status() },
+            Ok(_) => EmptyResponse { status: err_status(FsOp::FSOP_MKDIR, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
+            Err(e) => EmptyResponse { status: err_status(FsOp::FSOP_MKDIR, vec![path.to_string()], &*e) },
+        };
+        Ok(Response::new(reply))
+    }
+
+    async fn ftruncate(&self, request: Request<TruncateRequest>) -> Result<Response<EmptyResponse>, Status> {
+        let request = request.into_inner();
+        let path = &self.lpath(&request.path);
+        let size = request.size as u64;
+        let reply = match self.fs.ftruncate(path, size) {
+            Ok(0) => EmptyResponse { status: ok_status() },
+            Ok(_) => EmptyResponse { status: err_status(FsOp::FSOP_TRUNCATE, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
+            Err(e) => EmptyResponse { status: err_status(FsOp::FSOP_TRUNCATE, vec![path.to_string()], &*e) },
+        };
+        Ok(Response::new(reply))
+    }
+
+    async fn futimens(&self, request: Request<UtimensRequest>) -> Result<Response<EmptyResponse>, Status> {
         let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
         let path = &self.lpath(&request.path);
         let a_time = vec![request.ts[0].tv_sec as u64, request.ts[0].tv_nsec as u64];
         let m_time = vec![request.ts[1].tv_sec as u64, request.ts[1].tv_nsec as u64];
-        let ret = self.fs.futimens(path, &a_time, &m_time);
+        let reply = match self.fs.futimens(path, &a_time, &m_time) {
-        let ret = result2ret!("futimens", path, ret);
+            Ok(0) => EmptyResponse { status: ok_status() },
-        let reply = Utimens {
+            Ok(_) => EmptyResponse { status: err_status(FsOp::FSOP_UTIMENS, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
-            ret,
+            Err(e) => EmptyResponse { status: err_status(FsOp::FSOP_UTIMENS, vec![path.to_string()], &*e) },
-            ..Utimens::default()
         };
         Ok(Response::new(reply))
     }
 
-    async fn fchown(&self, request: Request<Chown>) -> Result<Response<Chown>, Status> {
+    async fn fchown(&self, request: Request<ChownRequest>) -> Result<Response<EmptyResponse>, Status> {
         let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
         let path = &self.lpath(&request.path);
         let uid = request.uid as u32;
         let gid = request.gid as u32;
-        let ret = self.fs.fchown(path, uid, gid);
+        let reply = match self.fs.fchown(path, uid, gid) {
-        let ret = result2ret!("fchown", path, ret);
+            Ok(0) => EmptyResponse { status: ok_status() },
-        let reply = Chown {
+            Ok(_) => EmptyResponse { status: err_status(FsOp::FSOP_CHOWN, vec![path.to_string()], &std::io::Error::from_raw_os_error(libc::ENOSYS)) },
-            ret,
+            Err(e) => EmptyResponse { status: err_status(FsOp::FSOP_CHOWN, vec![path.to_string()], &*e) },
-            ..Chown::default()
-        };
-        Ok(Response::new(reply))
-    }
-    async fn frelease(&self, request: Request<Release>) -> Result<Response<Release>, Status> {
-        let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
-        let path = &self.lpath(&request.path);
-        let mut fi = match request.fi{
-            Some(fi) => fi,
-            None => FileInfo::default(),
-        };
-        let ret = self.fs.frelease(path, &mut fi, request.flush != 0);
-        let ret = result2ret!("frelease", path, ret);
-        let reply = Release {
-            ret,
-            ..Release::default()
-        };
-        Ok(Response::new(reply))
-    }
-    async fn frmdir(&self, request: Request<Rmdir>) -> Result<Response<Rmdir>, Status> {
-        let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
-        let path = &self.lpath(&request.path);
-        let ret = self.fs.frmdir(path);
-        let ret = result2ret!("frmdir", path, ret);
-        let reply = Rmdir {
-            ret,
-            path: request.path,
         };
         Ok(Response::new(reply))
     }
 
-    async fn fflush(&self, request: Request<Flush>) -> Result<Response<Flush>, Status> {
+    async fn frelease(&self, request: Request<ReleaseRequest>) -> Result<Response<EmptyResponse>, Status> {
         let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
         let path = &self.lpath(&request.path);
-        let mut fi = match request.fi{
+        let mut fi = FileInfo::default();
-            Some(fi) => fi,
+        let reply = match self.fs.frelease(path, &mut fi, request.flush != 0) {
-            None => FileInfo::default(),
+            Ok(0) => EmptyResponse { status: ok_status() },
-        };
+            Ok(_) => EmptyResponse { status: err_status(FsOp::FSOP_RELEASE, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
-        let ret = self.fs.fflush(path, &mut fi);
+            Err(e) => EmptyResponse { status: err_status(FsOp::FSOP_RELEASE, vec![path.to_string()], &*e) },
-        let ret = result2ret!("fflush", path, ret);
-        let reply = Flush {
-            ret,
-            ..Flush::default()
         };
         Ok(Response::new(reply))
     }
 
-    async fn fcreate(&self, request: Request<Create>) -> Result<Response<Create>, Status> {
+    async fn frmdir(&self, request: Request<RmdirRequest>) -> Result<Response<EmptyResponse>, Status> {
+        let request = request.into_inner();
+        let path = &self.lpath(&request.path);
+        let reply = match self.fs.frmdir(path) {
+            Ok(0) => EmptyResponse { status: ok_status() },
+            Ok(_) => EmptyResponse { status: err_status(FsOp::FSOP_RMDIR, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
+            Err(e) => EmptyResponse { status: err_status(FsOp::FSOP_RMDIR, vec![path.to_string()], &*e) },
+        };
+        Ok(Response::new(reply))
+    }
+
+    async fn fflush(&self, request: Request<FlushRequest>) -> Result<Response<EmptyResponse>, Status> {
+        let request = request.into_inner();
+        let path = &self.lpath(&request.path);
+        let mut fi = FileInfo::default();
+        let reply = match self.fs.fflush(path, &mut fi) {
+            Ok(0) => EmptyResponse { status: ok_status() },
+            Ok(_) => EmptyResponse { status: err_status(FsOp::FSOP_FLUSH, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
+            Err(e) => EmptyResponse { status: err_status(FsOp::FSOP_FLUSH, vec![path.to_string()], &*e) },
+        };
+        Ok(Response::new(reply))
+    }
+
+    async fn fcreate(&self, request: Request<CreateRequest>) -> Result<Response<CreateResponse>, Status> {
         let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
         let path = &self.lpath(&request.path);
         let mode = request.mode as u32;
-        let mut fi = match request.fi{
+        let mut fi = FileInfo::default();
-            Some(fi) => fi,
+        let reply = match self.fs.fcreate(path, mode, &mut fi) {
-            None => FileInfo::default(),
+            Ok(0) => CreateResponse { fi: Some(fi), status: ok_status() },
-        };
+            Ok(_) => CreateResponse { fi: None, status: err_status(FsOp::FSOP_CREATE, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
-        let ret = self.fs.fcreate(path, mode, &mut fi);
+            Err(e) => CreateResponse { fi: None, status: err_status(FsOp::FSOP_CREATE, vec![path.to_string()], &*e) },
-        let ret = result2ret!("fcreate", path, ret);
-        let reply = Create {
-            ret,
-            fi:Some(fi),
-            ..Create::default()
         };
         Ok(Response::new(reply))
     }
 
-    async fn funlink(&self, request: Request<Unlink>) -> Result<Response<Unlink>, Status> {
+    async fn funlink(&self, request: Request<UnlinkRequest>) -> Result<Response<EmptyResponse>, Status> {
         let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
         let path = &self.lpath(&request.path);
-        let ret = self.fs.funlink(path);
+        let reply = match self.fs.funlink(path) {
-        let ret = result2ret!("funlink", path, ret);
+            Ok(0) => EmptyResponse { status: ok_status() },
-        let reply = Unlink {
+            Ok(_) => EmptyResponse { status: err_status(FsOp::FSOP_UNLINK, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
-            ret,
+            Err(e) => EmptyResponse { status: err_status(FsOp::FSOP_UNLINK, vec![path.to_string()], &*e) },
-            path: request.path,
         };
         Ok(Response::new(reply))
     }
 
-    async fn fopendir(&self,request: Request<Opendir>) -> Result<Response<Opendir>, Status> {
+    async fn fopendir(&self, request: Request<OpendirRequest>) -> Result<Response<OpendirResponse>, Status> {
         let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
         let path = &self.lpath(&request.path);
-        let mut fi = match request.fi{
+        let mut fi = FileInfo::default();
-            Some(fi) => fi,
+        let reply = match self.fs.fopendir(path, &mut fi) {
-            None => FileInfo::default(),
+            Ok(0) => OpendirResponse { fi: Some(fi), status: ok_status() },
-        };
+            Ok(_) => OpendirResponse { fi: None, status: err_status(FsOp::FSOP_OPENDIR, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
-        let ret = self.fs.fopendir(path, &mut fi);
+            Err(e) => OpendirResponse { fi: None, status: err_status(FsOp::FSOP_OPENDIR, vec![path.to_string()], &*e) },
-        let ret = result2ret!("fopendir", path, ret);
-        let reply = Opendir {
-            ret,
-            fi: Some(fi),
-            ..Opendir::default()
         };
         Ok(Response::new(reply))
     }
 
-    async fn freleasedir(&self, request: Request<Releasedir>) -> Result<Response<Releasedir>, Status> {
+    async fn freleasedir(&self, request: Request<ReleasedirRequest>) -> Result<Response<EmptyResponse>, Status> {
         let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
         let path = &self.lpath(&request.path);
-        let mut fi = match request.fi{
+        let mut fi = FileInfo::default();
-            Some(fi) => fi,
+        let reply = match self.fs.freleasedir(path, &mut fi) {
-            None => FileInfo::default(),
+            Ok(0) => EmptyResponse { status: ok_status() },
-        };
+            Ok(_) => EmptyResponse { status: err_status(FsOp::FSOP_RELEASEDIR, vec![path.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
-        let ret = self.fs.freleasedir(path, &mut fi);
+            Err(e) => EmptyResponse { status: err_status(FsOp::FSOP_RELEASEDIR, vec![path.to_string()], &*e) },
-        let ret = result2ret!("freleasedir", path, ret);
-        let reply = Releasedir {
-            ret,
-            ..Releasedir::default()
         };
         Ok(Response::new(reply))
     }
 
-    async fn frename(&self, request: Request<Rename>) -> Result<Response<Rename>, Status> {
+    async fn frename(&self, request: Request<RenameRequest>) -> Result<Response<EmptyResponse>, Status> {
         let request = request.into_inner();
-        log::trace!("Got a request: {:?}", request);
         let from = &self.lpath(&request.path);
         let to = &self.lpath(&request.new);
-        let ret = self.fs.frename(from, to);
+        let reply = match self.fs.frename(from, to) {
-        let ret = result2ret!("frename", from, ret);
+            Ok(0) => EmptyResponse { status: ok_status() },
-        let reply = Rename {
+            Ok(_) => EmptyResponse { status: err_status(FsOp::FSOP_RENAME, vec![from.to_string(), to.to_string()], &std::io::Error::new(std::io::ErrorKind::Other, "op failed")) },
-            ret,
+            Err(e) => EmptyResponse { status: err_status(FsOp::FSOP_RENAME, vec![from.to_string(), to.to_string()], &*e) },
-            ..Rename::default()
         };
         Ok(Response::new(reply))
     }
@@ -528,7 +427,7 @@ impl LwsVfs for LwsVfsIns {
 
 #[test]
 fn test_config_new() {
-    env_logger::init();
+    let _ = env_logger::try_init();
     let _config = Config::new("config.json").unwrap();
     println!("Config: {:#?}", _config);
 }
@@ -548,21 +447,13 @@ mod test_macros {
         };
     }
 
-
     struct MyStruct;
-
+    impl MyStruct { fn example_function(&self, _:i32) -> Result<i32, Box<dyn Error>> { Err("模拟错误".into()) } }
-    impl MyStruct {
-        fn example_function(&self, _:i32) -> Result<i32, Box<dyn Error>> {
-            // 这里模拟一个可能的错误
-            Err("模拟错误".into())
-        }
-    }
 
     #[test]
     fn test_() -> Result<(), Box<dyn Error>> {
+        let _ = env_logger::try_init();
         let my_struct = MyStruct;
-
-        // 使用宏处理返回值
         assert_ne!(handle_result!(my_struct.example_function(32), "调用 example_function 时发生错误"), 32);
         Ok(())
     }
@@ -570,7 +461,7 @@ mod test_macros {
 
 #[test]
 fn test_path() {
-    env_logger::init();
+    let _ = env_logger::try_init();
     let path = linux_to_windows_path(r"p:\/test/dir/tree");
     assert_eq!(path, r"p:\test\dir\tree");
     let path = linux_to_windows_path(r"p:\/");