add virtio-fs device

Author: zmlcc

Cargo.lock

@@ -26,4 +26,7 @@ panic = "abort"
 lto = true
 panic = "abort"
 
+[features]
+vtfs = ["api_server/vtfs"]
+
 [workspace]

Cargo.toml

@@ -26,3 +26,6 @@ kernel = { path = "../kernel" }
 memory_model = { path = "../memory_model" }
 net_util = { path = "../net_util" }
 rate_limiter = { path = "../rate_limiter" }
+
+[features]
+vtfs = ["vmm/vtfs"]

api_server/Cargo.toml

@@ -27,6 +27,8 @@ use vmm::vmm_config::logger::LoggerConfig;
 use vmm::vmm_config::machine_config::VmConfig;
 use vmm::vmm_config::net::{NetworkInterfaceConfig, NetworkInterfaceUpdateConfig};
 use vmm::vmm_config::vsock::VsockDeviceConfig;
+#[cfg(feature = "vtfs")]
+use vmm::vmm_config::vtfs::VtfsDeviceConfig;
 
 fn build_response_base<B: Into<hyper::Body>>(
     status: StatusCode,
@@ -380,6 +382,35 @@ fn parse_vsock_req<'a>(path: &'a str, method: Method, body: &Chunk) -> Result<'a
     }
 }
 
+#[cfg(feature = "vtfs")]
+// Turns a GET/PUT /vtfs HTTP request into a ParsedRequest.
+fn parse_vtfs_req<'a>(path: &'a str, method: Method, body: &Chunk) -> Result<'a, ParsedRequest> {
+    let path_tokens: Vec<&str> = path[1..].split_terminator('/').collect();
+    let id_from_path = if path_tokens.len() > 1 {
+        checked_id(path_tokens[1])?
+    } else {
+        return Err(Error::EmptyID);
+    };
+
+    match path_tokens[1..].len() {
+        1 if method == Method::Put => {
+            METRICS.put_api_requests.drive_count.inc();
+
+            let vtfs_cfg = serde_json::from_slice::<VtfsDeviceConfig>(body).map_err(|e| {
+                METRICS.put_api_requests.drive_fails.inc();
+                Error::SerdeJson(e)
+            })?;
+            Ok(vtfs_cfg
+                .into_parsed_request(Some(id_from_path.to_string()), method)
+                .map_err(|s| {
+                    METRICS.put_api_requests.drive_fails.inc();
+                    Error::Generic(StatusCode::BadRequest, s)
+                })?)
+        }
+        _ => Err(Error::InvalidPathMethod(path, method)),
+    }
+}
+
 // This turns an incoming HTTP request into a ParsedRequest, which is an item containing both the
 // message to be passed to the VMM, and associated entities, such as channels which allow the
 // reception of the response back from the VMM.
@@ -426,6 +457,8 @@ fn parse_request<'a>(method: Method, path: &'a str, body: &Chunk) -> Result<'a,
         "network-interfaces" => parse_netif_req(path, method, body),
         "mmds" => parse_mmds_request(path, method, body),
         "vsock" => parse_vsock_req(path, method, body),
+        #[cfg(feature = "vtfs")]
+        "vtfs" => parse_vtfs_req(path, method, body),
         _ => Err(Error::InvalidPathMethod(path, method)),
     }
 }

api_server/src/http_service.rs

@@ -44,6 +44,9 @@ use vmm::vmm_config::logger::LoggerConfig;
 use vmm::vmm_config::machine_config::VmConfig;
 use vmm::vmm_config::net::{NetworkInterfaceConfig, NetworkInterfaceUpdateConfig};
 use vmm::vmm_config::vsock::VsockDeviceConfig;
+#[cfg(feature = "vtfs")]
+use vmm::vmm_config::vtfs::VtfsDeviceConfig;
+
 use vmm::VmmActionError;
 
 /// This enum represents the public interface of the VMM. Each action contains various
@@ -71,6 +74,9 @@ pub enum VmmAction {
     /// `VsockDeviceConfig` as input. This action can only be called before the microVM has
     /// booted.
     SetVsockDevice(VsockDeviceConfig),
+    #[cfg(feature = "vtfs")]
+    /// Add a vtfs device config
+    InsertVtfsDevice(VtfsDeviceConfig),
     /// Update the size of an existing block device specified by an ID. The ID is the first data
     /// associated with this enum variant. This action can only be called after the microVM is
     /// started.

api_server/src/lib.rs

@@ -8,6 +8,8 @@ pub mod logger;
 pub mod machine_configuration;
 pub mod net;
 pub mod vsock;
+#[cfg(feature = "vtfs")]
+pub mod vtfs;
 
 use serde_json::Value;
 use std::result;

api_server/src/request/mod.rs

@@ -0,0 +1,38 @@
+// Copyright 2019 UCloud.cn, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use std::result;
+
+use futures::sync::oneshot;
+use hyper::Method;
+
+use request::{IntoParsedRequest, ParsedRequest};
+use vmm::vmm_config::vtfs::VtfsDeviceConfig;
+use super::{VmmAction, VmmRequest};
+
+impl IntoParsedRequest for VtfsDeviceConfig {
+    fn into_parsed_request(
+        self,
+        id_from_path: Option<String>,
+        _: Method,
+    ) -> result::Result<ParsedRequest, String> {
+        let id_from_path = id_from_path.unwrap_or_default();
+        if id_from_path != self.drive_id.as_str() {
+            return Err(String::from(
+                "The id from the path does not match the id from the body!",
+            ));
+        }
+
+        let (sender, receiver) = oneshot::channel();
+        Ok(ParsedRequest::Sync(
+            VmmRequest::new(
+            VmmAction::InsertVtfsDevice(self), sender),
+            receiver,
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+}

api_server/src/request/vtfs.rs

@@ -18,6 +18,10 @@ net_gen = { path = "../net_gen" }
 rate_limiter = { path = "../rate_limiter" }
 sys_util = { path = "../sys_util" }
 virtio_gen = { path = "../virtio_gen" }
+fuse_gen = { path = "../fuse_gen", optional = true}
 
 [dev-dependencies]
 tempfile = ">=3.0.2"
+
+[features]
+vtfs = ["fuse_gen", "sys_util/vtfs"]

devices/Cargo.toml

@@ -13,6 +13,8 @@ extern crate libc;
 extern crate dumbo;
 #[macro_use]
 extern crate logger;
+#[cfg(feature = "vtfs")]
+extern crate fuse_gen;
 extern crate memory_model;
 extern crate net_gen;
 extern crate net_util;

devices/src/lib.rs

@@ -17,12 +17,16 @@ mod mmio;
 pub mod net;
 mod queue;
 pub mod vsock;
+#[cfg(feature = "vtfs")]
+pub mod vtfs;
 
 pub use self::block::*;
 pub use self::mmio::*;
 pub use self::net::*;
 pub use self::queue::*;
 pub use self::vsock::*;
+#[cfg(feature = "vtfs")]
+pub use self::vtfs::*;
 
 use super::EpollHandler;