refactor: Improving code debugability

Some code has been refactored to make debugging easier.

Signed-off-by: Jonathan Woollett-Light <[email protected]>

Author: Jonathan Woollett-Light

src/firecracker/src/api_server_adapter.rs

@@ -149,33 +149,39 @@ pub(crate) fn run_with_api(
     let api_thread = thread::Builder::new()
         .name("fc_api".to_owned())
         .spawn(move || {
-            match ApiServer::new(to_vmm, from_vmm, to_vmm_event_fd).bind_and_run(
+            let res = ApiServer::new(to_vmm, from_vmm, to_vmm_event_fd).bind_and_run(
                 &api_bind_path,
                 process_time_reporter,
                 &api_seccomp_filter,
                 api_payload_limit,
                 socket_ready_sender,
-            ) {
-                Ok(_) => (),
-                Err(api_server::Error::ServerCreation(ServerError::IOError(inner)))
+            );
+
+            let Err(err) = res else {
+                return;
+            };
+
+            match err {
+                api_server::Error::ServerCreation(ServerError::IOError(inner))
                     if inner.kind() == std::io::ErrorKind::AddrInUse =>
                 {
                     let sock_path = api_bind_path.display().to_string();
                     error!(
                         "Failed to open the API socket at: {sock_path}. Check that it is not \
                          already used."
                     );
-                    std::process::exit(vmm::FcExitCode::GenericError as i32);
                 }
-                Err(api_server::Error::ServerCreation(err)) => {
+                api_server::Error::ServerCreation(err) => {
                     error!("Failed to bind and run the HTTP server: {err}");
-                    std::process::exit(vmm::FcExitCode::GenericError as i32);
                 }
             }
+
+            std::process::exit(vmm::FcExitCode::GenericError as i32);
         })
         .expect("API thread spawn failed.");
 
     let mut event_manager = EventManager::new().expect("Unable to create EventManager");
+
     // Create the firecracker metrics object responsible for periodically printing metrics.
     let firecracker_metrics = Arc::new(Mutex::new(super::metrics::PeriodicMetrics::new()));
     event_manager.add_subscriber(firecracker_metrics.clone());
@@ -199,11 +205,13 @@ pub(crate) fn run_with_api(
                 let req = from_api
                     .recv()
                     .expect("The channel's sending half was disconnected. Cannot receive data.");
+
                 // Also consume the API event along with the message. It is safe to unwrap()
                 // because this event_fd is blocking.
                 api_event_fd
                     .read()
                     .expect("VMM: Failed to read the API event_fd");
+
                 *req
             },
             |response| {

src/firecracker/src/main.rs

@@ -383,6 +383,7 @@ fn main_exitable() -> FcExitCode {
 
         let process_time_reporter =
             ProcessTimeReporter::new(start_time_us, start_time_cpu_us, parent_cpu_time_us);
+
         api_server_adapter::run_with_api(
             &mut seccomp_filters,
             vmm_config_json,

src/vmm/src/rpc_interface.rs

@@ -380,12 +380,18 @@ impl<'a> PrebootApiController<'a> {
             &mut vm_resources,
             event_manager,
         );
+
         // Configure and start microVM through successive API calls.
         // Iterate through API calls to configure microVm.
         // The loop breaks when a microVM is successfully started, and a running Vmm is built.
         while preboot_controller.built_vmm.is_none() {
-            // Get request, process it, send back the response.
-            respond(preboot_controller.handle_preboot_request(recv_req()));
+            // Get request
+            let req = recv_req();
+            // Process the request.
+            let res = preboot_controller.handle_preboot_request(req);
+            // Send back the response.
+            respond(res);
+
             // If any fatal errors were encountered, break the loop.
             if let Some(exit_code) = preboot_controller.fatal_error {
                 return Err(exit_code);