Merge branch 'cloud-hypervisor:main' into dev

Author: CMGS

cloud-hypervisor/src/bin/ch-remote.rs

@@ -72,7 +72,7 @@ enum Error {
     #[error("Invalid disk size")]
     InvalidDiskSize(#[source] ByteSizedParseError),
     #[error("Error parsing send migration configuration")]
-    SendMigrationConfig(#[from] vmm::api::VmSendMigrationParseError),
+    SendMigrationConfig(#[from] vmm::api::VmSendMigrationConfigError),
 }
 
 enum TargetApi<'a> {

cloud-hypervisor/tests/integration.rs

@@ -8528,6 +8528,8 @@ mod vfio {
 }
 
 mod live_migration {
+    use std::num::NonZeroU32;
+
     use vmm::api::TimeoutStrategy;
 
     use crate::*;
@@ -9701,7 +9703,11 @@ mod live_migration {
             .port()
     }
 
-    fn start_live_migration_tcp(src_api_socket: &str, dest_api_socket: &str) -> bool {
+    fn start_live_migration_tcp(
+        src_api_socket: &str,
+        dest_api_socket: &str,
+        connections: NonZeroU32,
+    ) -> bool {
         // Get an available TCP port
         let migration_port = get_available_port();
         let host_ip = "127.0.0.1";
@@ -9723,11 +9729,14 @@ mod live_migration {
         thread::sleep(Duration::from_secs(1));
 
         // Start the 'send-migration' command on the source
+        let connections = connections.get();
         let mut send_migration = Command::new(clh_command("ch-remote"))
             .args([
                 &format!("--api-socket={src_api_socket}"),
                 "send-migration",
-                &format!("destination_url=tcp:{host_ip}:{migration_port}"),
+                &format!(
+                    "destination_url=tcp:{host_ip}:{migration_port},connections={connections}"
+                ),
             ])
             .stdin(Stdio::null())
             .stderr(Stdio::piped())
@@ -9778,7 +9787,7 @@ mod live_migration {
         send_success && receive_success
     }
 
-    fn _test_live_migration_tcp() {
+    fn _test_live_migration_tcp(connections: NonZeroU32) {
         let disk_config = UbuntuDiskConfig::new(JAMMY_IMAGE_NAME.to_string());
         let guest = Guest::new(Box::new(disk_config));
         let kernel_path = direct_kernel_boot_path();
@@ -9860,7 +9869,7 @@ mod live_migration {
             }
             // Start TCP live migration
             assert!(
-                start_live_migration_tcp(&src_api_socket, &dest_api_socket),
+                start_live_migration_tcp(&src_api_socket, &dest_api_socket, connections),
                 "Unsuccessful command: 'send-migration' or 'receive-migration'."
             );
         });
@@ -10249,7 +10258,12 @@ mod live_migration {
 
         #[test]
         fn test_live_migration_tcp() {
-            _test_live_migration_tcp();
+            _test_live_migration_tcp(NonZeroU32::new(1).unwrap());
+        }
+
+        #[test]
+        fn test_live_migration_tcp_parallel_connections() {
+            _test_live_migration_tcp(NonZeroU32::new(8).unwrap());
         }
 
         #[test]

docs/live_migration.md

@@ -207,3 +207,7 @@ migration process. Via the API or `ch-remote`, you may specify:
   Cancel will abort the migration and keep the VM running on the source.
   Ignore will proceed with the migration regardless of the downtime requirement.
   Defaults to `cancel`.
+- `connections <amount>`: \
+  The number of parallel TCP connections to use for migration.
+  Must be between `1` and `128`. Defaults to `1`.
+  Multiple connections are not supported with local UNIX-socket migration.

pci/src/vfio.rs

@@ -158,6 +158,10 @@ impl VfioMsix {
         // Update "Message Control" word
         if offset == 2 && data.len() == 2 {
             self.bar.set_msg_ctl(LittleEndian::read_u16(data));
+        } else if offset == 0 && data.len() == 4 {
+            // Some guests update MSI-X control through the dword config write path.
+            self.bar
+                .set_msg_ctl((LittleEndian::read_u32(data) >> 16) as u16);
         }
 
         let new_enabled = self.bar.enabled();

vm-migration/src/protocol.rs

@@ -272,12 +272,99 @@ pub struct MemoryRange {
     pub length: u64,
 }
 
-#[derive(Clone, Default, Serialize, Deserialize)]
+/// A set of guest-memory ranges to transfer as one migration payload.
+#[derive(Clone, Default, Debug, Serialize, Deserialize)]
 pub struct MemoryRangeTable {
     data: Vec<MemoryRange>,
 }
 
+/// Iterator returned by [`MemoryRangeTable::partition`].
+///
+/// Each item contains at most `chunk_size` bytes. A range may be split across
+/// multiple items.
+///
+/// The iterator may reorder ranges for efficiency, so callers must not rely on
+/// the order in which chunks or ranges are yielded.
+#[derive(Clone, Default, Debug)]
+struct MemoryRangeTableIterator {
+    chunk_size: u64,
+    data: Vec<MemoryRange>,
+}
+
+impl MemoryRangeTableIterator {
+    /// Create an iterator that partitions `table` into chunks of at most
+    /// `chunk_size` bytes.
+    pub fn new(table: MemoryRangeTable, chunk_size: u64) -> Self {
+        MemoryRangeTableIterator {
+            chunk_size,
+            data: table.data,
+        }
+    }
+}
+
+impl Iterator for MemoryRangeTableIterator {
+    type Item = MemoryRangeTable;
+
+    /// Return the next memory range in the table, making sure that
+    /// the returned range is not larger than `chunk_size`.
+    ///
+    /// **Note**: Do not rely on the order of the ranges returned by this
+    /// iterator. This allows for a more efficient implementation.
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut ranges: Vec<MemoryRange> = vec![];
+        let mut ranges_size: u64 = 0;
+
+        loop {
+            assert!(ranges_size <= self.chunk_size);
+
+            if ranges_size == self.chunk_size || self.data.is_empty() {
+                break;
+            }
+
+            if let Some(range) = self.data.pop() {
+                let next_range: MemoryRange = if ranges_size + range.length > self.chunk_size {
+                    // How many bytes we need to put back into the table.
+                    let leftover_bytes = ranges_size + range.length - self.chunk_size;
+                    assert!(leftover_bytes <= range.length);
+                    let returned_bytes = range.length - leftover_bytes;
+                    assert!(returned_bytes <= range.length);
+                    assert_eq!(leftover_bytes + returned_bytes, range.length);
+
+                    self.data.push(MemoryRange {
+                        gpa: range.gpa,
+                        length: leftover_bytes,
+                    });
+                    MemoryRange {
+                        gpa: range.gpa + leftover_bytes,
+                        length: returned_bytes,
+                    }
+                } else {
+                    range
+                };
+
+                ranges_size += next_range.length;
+                ranges.push(next_range);
+            }
+        }
+
+        if ranges.is_empty() {
+            None
+        } else {
+            Some(MemoryRangeTable { data: ranges })
+        }
+    }
+}
+
 impl MemoryRangeTable {
+    pub fn ranges(&self) -> &[MemoryRange] {
+        &self.data
+    }
+
+    /// Partitions the table into chunks of at most `chunk_size` bytes.
+    pub fn partition(self, chunk_size: u64) -> impl Iterator<Item = MemoryRangeTable> {
+        MemoryRangeTableIterator::new(self, chunk_size)
+    }
+
     /// Converts an iterator over a dirty bitmap into an iterator of dirty
     /// [`MemoryRange`]s, merging consecutive dirty pages into contiguous ranges.
     ///
@@ -413,4 +500,144 @@ mod unit_tests {
             ]
         );
     }
+
+    #[test]
+    fn test_memory_range_table_partition() {
+        // We start the test similar as the one above, but with a input that is simpler to parse for
+        // developers.
+        let input = [0b11_0011_0011_0011];
+
+        let start_gpa = 0x1000;
+        let page_size = 0x1000;
+
+        let table = MemoryRangeTable::from_dirty_bitmap(input, start_gpa, page_size);
+        let expected_regions = [
+            MemoryRange {
+                gpa: start_gpa,
+                length: page_size * 2,
+            },
+            MemoryRange {
+                gpa: start_gpa + 4 * page_size,
+                length: page_size * 2,
+            },
+            MemoryRange {
+                gpa: start_gpa + 8 * page_size,
+                length: page_size * 2,
+            },
+            MemoryRange {
+                gpa: start_gpa + 12 * page_size,
+                length: page_size * 2,
+            },
+        ];
+        assert_eq!(table.regions(), &expected_regions);
+
+        // In the first test, we expect to see the exact same result as above, as we use the length
+        // of every region (which is fixed!).
+        {
+            let chunks = table
+                .clone()
+                .partition(page_size * 2)
+                .map(|table| table.data)
+                .collect::<Vec<_>>();
+
+            // The implementation currently returns the ranges in reverse order.
+            // For better testability, we reverse it.
+            let chunks = chunks
+                .into_iter()
+                .map(|vec| vec.into_iter().rev().collect::<Vec<_>>())
+                .rev()
+                .collect::<Vec<_>>();
+
+            assert_eq!(
+                chunks,
+                &[
+                    [expected_regions[0].clone()].to_vec(),
+                    [expected_regions[1].clone()].to_vec(),
+                    [expected_regions[2].clone()].to_vec(),
+                    [expected_regions[3].clone()].to_vec(),
+                ]
+            );
+        }
+
+        // Next, we have a more sophisticated test with a chunk size of 5 pages.
+        {
+            let chunks = table
+                .clone()
+                .partition(page_size * 5)
+                .map(|table| table.data)
+                .collect::<Vec<_>>();
+
+            // The implementation currently returns the ranges in reverse order.
+            // For better testability, we reverse it.
+            let chunks = chunks
+                .into_iter()
+                .map(|vec| vec.into_iter().rev().collect::<Vec<_>>())
+                .rev()
+                .collect::<Vec<_>>();
+
+            assert_eq!(
+                chunks,
+                &[
+                    vec![
+                        MemoryRange {
+                            gpa: start_gpa,
+                            length: 2 * page_size
+                        },
+                        MemoryRange {
+                            gpa: start_gpa + 4 * page_size,
+                            length: page_size
+                        }
+                    ],
+                    vec![
+                        MemoryRange {
+                            gpa: start_gpa + 5 * page_size,
+                            length: page_size
+                        },
+                        MemoryRange {
+                            gpa: start_gpa + 8 * page_size,
+                            length: 2 * page_size
+                        },
+                        MemoryRange {
+                            gpa: start_gpa + 12 * page_size,
+                            length: 2 * page_size
+                        }
+                    ]
+                ]
+            );
+        }
+    }
+
+    #[test]
+    fn test_memory_range_table_partition_uneven_split() {
+        // Three consecutive dirty pages produce one 3-page range, which lets
+        // us test an uneven 1+2 page split while using the same helper as the
+        // other partition tests above.
+        let input = [0b111];
+        let start_gpa = 0x1000;
+        let page_size = 0x1000;
+
+        let table = MemoryRangeTable::from_dirty_bitmap(input, start_gpa, page_size);
+
+        let chunks = table
+            .partition(page_size * 2)
+            .map(|table| table.data)
+            .collect::<Vec<_>>();
+
+        // The implementation currently returns ranges in reverse order.
+        let chunks = chunks.into_iter().rev().collect::<Vec<_>>();
+
+        assert_eq!(
+            chunks,
+            &[
+                vec![MemoryRange {
+                    gpa: start_gpa,
+                    length: page_size,
+                }],
+                vec![MemoryRange {
+                    gpa: start_gpa + page_size,
+                    length: page_size * 2,
+                }],
+            ]
+        );
+    }
 }