diff --git a/src/governor/mod.rs b/src/governor/mod.rs
index c9747c97ae71b0a778d970b8ba4756f7adb4dd8e..ae89d8d1c7e2eb9f8f7d7255ddaa7f775662cf1a 100644
--- a/src/governor/mod.rs
+++ b/src/governor/mod.rs
@@ -38,11 +38,9 @@ impl Loop {
     const UPDATE_INSTANCE_TIMEOUT: Duration = Duration::from_secs(3);
 
     async fn iter_fn(
-        Args {
+        State {
             storage,
             raft_storage,
-        }: &Args,
-        State {
             status,
             waker,
             pool,
@@ -527,21 +525,18 @@ impl Loop {
         storage: Clusterwide,
         raft_storage: RaftSpaceAccess,
     ) -> Self {
-        let args = Args {
-            storage,
-            raft_storage,
-        };
-
         let (waker_tx, waker_rx) = watch::channel(());
 
         let state = State {
+            storage,
+            raft_storage,
             status,
             waker: waker_rx,
             pool,
         };
 
         Self {
-            _loop: crate::loop_start!("governor_loop", Self::iter_fn, args, state),
+            _loop: crate::loop_start!("governor_loop", Self::iter_fn, state),
             waker: waker_tx,
         }
     }
@@ -556,12 +551,9 @@ pub struct Loop {
     waker: watch::Sender<()>,
 }
 
-struct Args {
+struct State {
     storage: Clusterwide,
     raft_storage: RaftSpaceAccess,
-}
-
-struct State {
     status: watch::Receiver<Status>,
     waker: watch::Receiver<()>,
     pool: Rc<ConnectionPool>,
diff --git a/src/loop.rs b/src/loop.rs
index 1b12b972126a661772cd59b11d0a28d23f16f02c..dd40f37f34e4627c5ca3eaa14ae7273947035d94 100644
--- a/src/loop.rs
+++ b/src/loop.rs
@@ -5,18 +5,17 @@ pub enum FlowControl {
 
 #[macro_export]
 macro_rules! loop_start {
-    ($name:expr, $fn:expr, $args:expr, $state:expr $(,)?) => {
+    ($name:expr, $fn:expr, $state:expr $(,)?) => {
         ::tarantool::fiber::Builder::new()
             .name($name)
             .proc(move || {
                 ::tarantool::fiber::block_on(async {
-                    let args = $args;
                     let mut state = $state;
                     let iter_fn = $fn;
                     loop {
-                        match iter_fn(&args, &mut state).await {
-                            FlowControl::Continue => continue,
-                            FlowControl::Break => break,
+                        match iter_fn(&mut state).await {
+                            $crate::r#loop::FlowControl::Continue => continue,
+                            $crate::r#loop::FlowControl::Break => break,
                         };
                     }
                 })
diff --git a/src/traft/node.rs b/src/traft/node.rs
index cd91b956cecb249777d19ae2c785a3b637ba38d0..c1577da67454b7d312799a0a54c3c0fbb102e25b 100644
--- a/src/traft/node.rs
+++ b/src/traft/node.rs
@@ -1461,11 +1461,8 @@ pub(crate) struct MainLoop {
     stop_flag: Rc<Cell<bool>>,
 }
 
-struct MainLoopArgs {
-    node_impl: Rc<Mutex<NodeImpl>>,
-}
-
 struct MainLoopState {
+    node_impl: Rc<Mutex<NodeImpl>>,
     next_tick: Instant,
     loop_waker: watch::Receiver<()>,
     stop_flag: Rc<Cell<bool>>,
@@ -1479,8 +1476,8 @@ impl MainLoop {
         let (loop_waker_tx, loop_waker_rx) = watch::channel(());
         let stop_flag: Rc<Cell<bool>> = Default::default();
 
-        let args = MainLoopArgs { node_impl };
-        let initial_state = MainLoopState {
+        let state = MainLoopState {
+            node_impl,
             next_tick: Instant::now(),
             loop_waker: loop_waker_rx,
             stop_flag: stop_flag.clone(),
@@ -1489,7 +1486,7 @@ impl MainLoop {
 
         Self {
             // implicit yield
-            _loop: loop_start!("raft_main_loop", Self::iter_fn, args, initial_state),
+            _loop: loop_start!("raft_main_loop", Self::iter_fn, state),
             loop_waker: loop_waker_tx,
             stop_flag,
         }
@@ -1499,14 +1496,14 @@ impl MainLoop {
         let _ = self.loop_waker.send(());
     }
 
-    async fn iter_fn(args: &MainLoopArgs, state: &mut MainLoopState) -> FlowControl {
+    async fn iter_fn(state: &mut MainLoopState) -> FlowControl {
         let _ = state.loop_waker.changed().timeout(Self::TICK).await;
         if state.stop_flag.take() {
             return FlowControl::Break;
         }
 
         // FIXME: potential deadlock - can't use sync mutex in async fn
-        let mut node_impl = args.node_impl.lock(); // yields
+        let mut node_impl = state.node_impl.lock(); // yields
         if state.stop_flag.take() {
             return FlowControl::Break;
         }