reduce the number of args.

Signed-off-by: utam0k <[email protected]>

crates/libcontainer/src/container/builder_impl.rs

@@ -105,7 +105,7 @@ impl<'a> ContainerBuilderImpl<'a> {
             prctl::set_dumpable(false).unwrap();
         }
 
-        // This intermediate_args will be passed to the container intermediate process,
+        // This container_args will be passed to the container processes,
         // therefore we will have to move all the variable by value. Since self
         // is a shared reference, we have to clone these variables here.
         let container_args = ContainerArgs {

crates/libcontainer/src/process/container_intermediate_process.rs

@@ -11,12 +11,12 @@ use super::container_init_process::container_init_process;
 
 pub fn container_intermediate_process(
     args: &ContainerArgs,
-    intermediate_sender: &mut channel::IntermediateSender,
-    intermediate_receiver: &mut channel::IntermediateReceiver,
-    init_sender: &mut channel::InitSender,
-    init_receiver: &mut channel::InitReceiver,
+    intermediate_chan: &mut (channel::IntermediateSender, channel::IntermediateReceiver),
+    init_chan: &mut (channel::InitSender, channel::InitReceiver),
     main_sender: &mut channel::MainSender,
 ) -> Result<()> {
+    let (inter_sender, inter_receiver) = intermediate_chan;
+    let (init_sender, init_receiver) = init_chan;
     let command = &args.syscall;
     let spec = &args.spec;
     let linux = spec.linux().as_ref().context("no linux in spec")?;
@@ -53,7 +53,7 @@ pub fn container_intermediate_process(
             // allowed to write the uid/gid maps
             prctl::set_dumpable(true).unwrap();
             main_sender.identifier_mapping_request()?;
-            intermediate_receiver.wait_for_mapping_ack()?;
+            inter_receiver.wait_for_mapping_ack()?;
             prctl::set_dumpable(false).unwrap();
         }
 
@@ -92,7 +92,7 @@ pub fn container_intermediate_process(
         init_sender
             .close()
             .context("failed to close receiver in init process")?;
-        intermediate_sender
+        inter_sender
             .close()
             .context("failed to close sender in the intermediate process")?;
         container_init_process(args, main_sender, init_receiver)
@@ -108,7 +108,7 @@ pub fn container_intermediate_process(
     main_sender
         .close()
         .context("failed to close unused main sender")?;
-    intermediate_sender
+    inter_sender
         .close()
         .context("failed to close sender in the intermediate process")?;
     init_sender

crates/libcontainer/src/process/container_main_process.rs

@@ -19,16 +19,14 @@ pub fn container_main_process(container_args: &ContainerArgs) -> Result<Pid> {
     // At minimum, we have to close down any unused senders. The corresponding
     // receivers will be cleaned up once the senders are closed down.
     let (main_sender, main_receiver) = &mut channel::main_channel()?;
-    let (intermediate_sender, intermediate_receiver) = &mut channel::intermediate_channel()?;
-    let (init_sender, init_receiver) = &mut channel::init_channel()?;
+    let inter_chan = &mut channel::intermediate_channel()?;
+    let init_chan = &mut channel::init_channel()?;
 
     let intermediate_pid = fork::container_fork(|| {
         container_intermediate_process::container_intermediate_process(
             container_args,
-            intermediate_sender,
-            intermediate_receiver,
-            init_sender,
-            init_receiver,
+            inter_chan,
+            init_chan,
             main_sender,
         )
     })?;
@@ -38,18 +36,21 @@ pub fn container_main_process(container_args: &ContainerArgs) -> Result<Pid> {
         .close()
         .context("failed to close unused sender")?;
 
+    let (inter_sender, _) = inter_chan;
+    let (init_sender, _) = init_chan;
+
     // If creating a rootless container, the intermediate process will ask
     // the main process to set up uid and gid mapping, once the intermediate
     // process enters into a new user namespace.
     if let Some(rootless) = &container_args.rootless {
         main_receiver.wait_for_mapping_request()?;
         setup_mapping(rootless, intermediate_pid)?;
-        intermediate_sender.mapping_written()?;
+        inter_sender.mapping_written()?;
     }
 
     // At this point, we don't need to send any message to intermediate process anymore,
     // so we want to close this sender at the earliest point.
-    intermediate_sender
+    inter_sender
         .close()
         .context("failed to close unused intermediate sender")?;