From 1ee41a98de7533513f9a5c44ad4d6198551f2af2 Mon Sep 17 00:00:00 2001
From: Bo Chen <chen.bo@intel.com>
Date: Thu, 18 Aug 2022 12:27:57 -0700
Subject: [PATCH] virtio-devices: net: Refactor 'handle_event' for readability

Signed-off-by: Bo Chen <chen.bo@intel.com>
---
 virtio-devices/src/net.rs | 71 ++++++++++++++++++---------------------
 1 file changed, 32 insertions(+), 39 deletions(-)

diff --git a/virtio-devices/src/net.rs b/virtio-devices/src/net.rs
index e812c6f75..63e2210e7 100644
--- a/virtio-devices/src/net.rs
+++ b/virtio-devices/src/net.rs
@@ -342,29 +342,28 @@ impl EpollHelperHandler for NetEpollHandler {
                 if let Some(rate_limiter) = &mut self.net.rx_rate_limiter {
                     // Upon rate limiter event, call the rate limiter handler and register the
                     // TAP fd for further processing if some RX buffers are available
-                    match rate_limiter.event_handler() {
-                        Ok(_) => {
-                            if !self.net.rx_tap_listening && self.net.rx_desc_avail {
-                                if let Err(e) = net_util::register_listener(
-                                    self.net.epoll_fd.unwrap(),
-                                    self.net.tap.as_raw_fd(),
-                                    epoll::Events::EPOLLIN,
-                                    u64::from(self.net.tap_rx_event_id),
-                                ) {
-                                    return Err(EpollHelperError::HandleEvent(anyhow!(
-                                        "Error register_listener with `RX_RATE_LIMITER_EVENT`: {:?}",
-                                        e
-                                    )));
-                                }
-                                self.net.rx_tap_listening = true;
-                            }
-                        }
-                        Err(e) => {
-                            return Err(EpollHelperError::HandleEvent(anyhow!(
-                                "Error from 'rate_limiter.event_handler()': {:?}",
+                    rate_limiter.event_handler().map_err(|e| {
+                        EpollHelperError::HandleEvent(anyhow!(
+                            "Error from 'rate_limiter.event_handler()': {:?}",
+                            e
+                        ))
+                    })?;
+
+                    if !self.net.rx_tap_listening && self.net.rx_desc_avail {
+                        net_util::register_listener(
+                            self.net.epoll_fd.unwrap(),
+                            self.net.tap.as_raw_fd(),
+                            epoll::Events::EPOLLIN,
+                            u64::from(self.net.tap_rx_event_id),
+                        )
+                        .map_err(|e| {
+                            EpollHelperError::HandleEvent(anyhow!(
+                                "Error register_listener with `RX_RATE_LIMITER_EVENT`: {:?}",
                                 e
-                            )));
-                        }
+                            ))
+                        })?;
+
+                        self.net.rx_tap_listening = true;
                     }
                 } else {
                     return Err(EpollHelperError::HandleEvent(anyhow!(
@@ -376,23 +375,17 @@ impl EpollHelperHandler for NetEpollHandler {
                 if let Some(rate_limiter) = &mut self.net.tx_rate_limiter {
                     // Upon rate limiter event, call the rate limiter handler
                     // and restart processing the queue.
-                    match rate_limiter.event_handler() {
-                        Ok(_) => {
-                            self.driver_awake = true;
-                            if let Err(e) = self.process_tx() {
-                                return Err(EpollHelperError::HandleEvent(anyhow!(
-                                    "Error processing TX queue: {:?}",
-                                    e
-                                )));
-                            }
-                        }
-                        Err(e) => {
-                            return Err(EpollHelperError::HandleEvent(anyhow!(
-                                "Error from 'rate_limiter.event_handler()': {:?}",
-                                e
-                            )));
-                        }
-                    }
+                    rate_limiter.event_handler().map_err(|e| {
+                        EpollHelperError::HandleEvent(anyhow!(
+                            "Error from 'rate_limiter.event_handler()': {:?}",
+                            e
+                        ))
+                    })?;
+
+                    self.driver_awake = true;
+                    self.process_tx().map_err(|e| {
+                        EpollHelperError::HandleEvent(anyhow!("Error processing TX queue: {:?}", e))
+                    })?;
                 } else {
                     return Err(EpollHelperError::HandleEvent(anyhow!(
                         "Unexpected TX_RATE_LIMITER_EVENT"