refine README.md with usage examples

Signed-off-by: Liu Jiang <[email protected]>

Author: jiangliu

.github/workflows/rust.yml

@@ -19,18 +19,8 @@ jobs:
     - name: clippy and format
       run: |
         cargo clippy --features "fusedev" -- -Dclippy::all
-#        cargo clippy --features "virtiofs" -- -Dclippy::all
-#        cargo clippy --features "vhost-user-fs" -- -Dclippy::all
         cargo fmt -- --check
     - name: Build fusedev
       run: cargo build --verbose --features "fusedev"
-#    - name: Build virtiofs
-#      run: cargo build --verbose --features "virtiofs"
-#    - name: Build vhost-user-fs
-#      run: cargo build --verbose --features "vhost-user-fs"
     - name: Run tests fusedev
       run: cargo test --verbose --features "fusedev"
-#    - name: Run tests virtiofs
-#      run: cargo test --verbose --features "virtiofs"
-#    - name: Run tests vhost-user-fs
-#      run: cargo test --verbose --features "vhost-user-fs"

README.md

@@ -1,8 +1,8 @@
-# Fuse-rs
+# Fuse-backend-rs
 
 ## Design
 
-The Fuse-rs crate is an rust library to implement Fuse daemons based on the
+The fuse-backend-rs crate is an rust library to implement Fuse daemons based on the
 [Linux FUSE device (/dev/fuse)](https://www.kernel.org/doc/html/latest/filesystems/fuse.html)
 or the [virtiofs](https://stefanha.github.io/virtio/virtio-fs.html#x1-41500011) draft specification.
 
@@ -23,16 +23,55 @@ So the fuse-rs crate is a library to communicate with the Linux FUSE clients, wh
 
 ## Usage
 
-TODO: This section describes how the crate is used.
+Please refer to [dragonflyoss/image-service](https://github.com/dragonflyoss/image-service/blob/master/src/bin/nydusd/fusedev.rs)
+for an example to use the fusedev framework.
 
 ## Examples
 
-TODO: Usage examples.
-
 ```rust
-use fuse_rs;
+use fuse_backend_rs::api::{server::Server, Vfs, VfsOptions};
+use fuse_backend_rs::transport::fusedev::{FuseSession, FuseChannel};
+
+struct FuseServer {
+    server: Arc<Server<Arc<Vfs>>>,
+    ch: FuseChannel,
+}
+
+impl FuseServer {
+    fn svc_loop(&self) -> Result<()> {
+        let mut buf = vec![0x0u8; 1024 * 1024];
 
-...
+        // Given error EBADF, it means kernel has shut down this session.
+        let _ebadf = std::io::Error::from_raw_os_error(libc::EBADF);
+        loop {
+            if let Some(reader) = self
+                .ch
+                .get_reader(&mut buf)
+                .map_err(|_| std::io::Error::from_raw_os_error(libc::EINVAL))?
+            {
+                let writer = self
+                    .ch
+                    .get_writer()
+                    .map_err(|_| std::io::Error::from_raw_os_error(libc::EINVAL))?;
+                if let Err(e) = self.server.handle_message(reader, writer, None, None) {
+                    match e {
+                        fuse_backend_rs::Error::EncodeMessage(_ebadf) => {
+                            break;
+                        }
+                        _ => {
+                            error!("Handling fuse message failed");
+                            continue;
+                        }
+                    }
+                }
+            } else {
+                info!("fuse server exits");
+                break;
+            }
+        }
+        Ok(())
+    }
+}
 ```
 
 ## License

tests/example/passthroughfs.rs

@@ -9,17 +9,17 @@ use std::thread;
 
 use vmm_sys_util::eventfd::EventFd;
 
-use fuse_rs::api::{server::Server, Vfs, VfsOptions};
-use fuse_rs::passthrough::{Config, PassthroughFs};
-use fuse_rs::transport::fusedev;
+use fuse_backend_rs::api::{server::Server, Vfs, VfsOptions};
+use fuse_backend_rs::passthrough::{Config, PassthroughFs};
+use fuse_backend_rs::transport::fusedev::{FuseChannel, FuseSession};
 
 /// A fusedev daemon example
 pub struct Daemon {
     mountpoint: String,
     server: Arc<Server<Arc<Vfs>>>,
     thread_cnt: u32,
     event_fd: EventFd,
-    session: Option<fusedev::FuseSession>,
+    session: Option<FuseSession>,
 }
 
 impl Daemon {
@@ -54,8 +54,7 @@ impl Daemon {
     /// Mounts a fusedev daemon to the mountpoint, then start service threads to handle
     /// FUSE requests.
     pub fn mount(&mut self) -> Result<()> {
-        let mut se =
-            fusedev::FuseSession::new(Path::new(&self.mountpoint), "passthru_example", "").unwrap();
+        let mut se = FuseSession::new(Path::new(&self.mountpoint), "passthru_example", "").unwrap();
         se.mount().unwrap();
         for _ in 0..self.thread_cnt {
             let server = FuseServer {
@@ -93,15 +92,12 @@ impl Drop for Daemon {
 
 struct FuseServer {
     server: Arc<Server<Arc<Vfs>>>,
-    ch: fusedev::FuseChannel,
+    ch: FuseChannel,
 }
 
 impl FuseServer {
     fn svc_loop(&self) -> Result<()> {
-        let mut buf = Vec::with_capacity(1024 * 1024);
-        unsafe {
-            buf.set_len(1024 * 1024);
-        }
+        let mut buf = vec![0x0u8; 1024 * 1024];
 
         // Given error EBADF, it means kernel has shut down this session.
         let _ebadf = std::io::Error::from_raw_os_error(libc::EBADF);
@@ -117,7 +113,7 @@ impl FuseServer {
                     .map_err(|_| std::io::Error::from_raw_os_error(libc::EINVAL))?;
                 if let Err(e) = self.server.handle_message(reader, writer, None, None) {
                     match e {
-                        fuse_rs::Error::EncodeMessage(_ebadf) => {
+                        fuse_backend_rs::Error::EncodeMessage(_ebadf) => {
                             break;
                         }
                         _ => {