!1156 Sync the patches from the dev branch to the master branch

From: @Flyking001 
Reviewed-by: @kevinzhu1 
Signed-off-by: @kevinzhu1

Author: openeuler-ci-bot

_typos.toml

@@ -0,0 +1,32 @@
+[files]
+extend-exclude = ["docs/kernel_config/*", "_typos.toml"]
+
+[default.extend-identifiers]
+APIC_MODE_EXTINT = "APIC_MODE_EXTINT"
+baInterfaceNr = "baInterfaceNr"
+BARs = "BARs"
+DESCRIPTION_HEADERs = "DESCRIPTION_HEADERs"
+E6GgSyMd0oQtUGFyNf5pRHlYqlx3s7PMPVUtRJP0bBnNd5eDwWAotInu33h6UI0zfKgckAxeVdEROKAExx5xWK = "E6GgSyMd0oQtUGFyNf5pRHlYqlx3s7PMPVUtRJP0bBnNd5eDwWAotInu33h6UI0zfKgckAxeVdEROKAExx5xWK"
+fldXlNNdCeqMvoIfEFogBxlL = "fldXlNNdCeqMvoIfEFogBxlL"
+INTERRUPT_TYPE_EXTINT = "INTERRUPT_TYPE_EXTINT"
+ist_info = "ist_info"
+KVM_CPUID_FLAG_SIGNIFCANT_INDEX = "KVM_CPUID_FLAG_SIGNIFCANT_INDEX"
+MODE_PAGE_ALLS = "MODE_PAGE_ALLS"
+n_subtiles = "n_subtiles"
+O_WRONLY = "O_WRONLY"
+RTC_MIS = "RTC_MIS"
+SECCOMP_FILETER_FLAG_TSYNC = "SECCOMP_FILETER_FLAG_TSYNC"
+test_ths = "test_ths"
+UART_LSR_THRE = "UART_LSR_THRE"
+
+[default.extend-words]
+ba = "ba"
+deactive = "deactive"
+Deactive = "Deactive"
+fpr = "fpr"
+fullfill = "fullfill"
+hda = "hda"
+inout = "inout"
+IST = "IST"
+NCE = "NCE"
+parm = "parm"

block_backend/src/qcow2/header.rs

@@ -236,7 +236,7 @@ impl QcowHeader {
 mod test {
     use crate::qcow2::header::*;
 
-    const DEFUALT_CLUSTER_SIZE: u64 = 64 * 1024;
+    const DEFAULT_CLUSTER_SIZE: u64 = 64 * 1024;
 
     fn valid_header_v3() -> Vec<u8> {
         // 10G
@@ -302,23 +302,23 @@ mod test {
         let header = QcowHeader::from_vec(&buf).unwrap();
         assert_eq!(header.magic, QCOW_MAGIC);
         assert_eq!(header.version, 2);
-        assert_eq!(header.cluster_size(), DEFUALT_CLUSTER_SIZE);
+        assert_eq!(header.cluster_size(), DEFAULT_CLUSTER_SIZE);
         assert_eq!(header.header_length, QCOW_VERSION_2_MIN_LEN as u32);
         assert_eq!(buf, header.to_vec());
 
         let buf = valid_header_v3();
         let header = QcowHeader::from_vec(&buf).unwrap();
         assert_eq!(header.magic, QCOW_MAGIC);
         assert_eq!(header.version, 3);
-        assert_eq!(header.cluster_size(), DEFUALT_CLUSTER_SIZE);
+        assert_eq!(header.cluster_size(), DEFAULT_CLUSTER_SIZE);
         assert_eq!(header.header_length, QCOW_VERSION_3_MIN_LEN as u32);
         assert_eq!(buf, header.to_vec());
 
         let buf = extended_header_v3();
         let header = QcowHeader::from_vec(&buf).unwrap();
         assert_eq!(header.magic, QCOW_MAGIC);
         assert_eq!(header.version, 3);
-        assert_eq!(header.cluster_size(), DEFUALT_CLUSTER_SIZE);
+        assert_eq!(header.cluster_size(), DEFAULT_CLUSTER_SIZE);
         assert_eq!(header.header_length, 112);
         // NOTE: only care the length we supported.
         assert_eq!(buf[0..QcowHeader::len()], header.to_vec());

block_backend/src/qcow2/mod.rs

@@ -677,12 +677,6 @@ impl<T: Clone + 'static> Qcow2Driver<T> {
                 break;
             }
 
-            if let Err(e) = self.refcount.flush_refcount_block_cache() {
-                err_msg = format!("{:?}", e);
-                error_stage = 5;
-                break;
-            }
-
             let mut new_header = self.header.clone();
             new_header.snapshots_offset = new_snapshot_table_offset;
             new_header.nb_snapshots -= 1;
@@ -711,6 +705,7 @@ impl<T: Clone + 'static> Qcow2Driver<T> {
         }
 
         // Error handling, to revert some operation.
+        self.refcount.discard_list.clear();
         if error_stage >= 6 {
             self.refcount.update_refcount(
                 self.header.snapshots_offset,
@@ -882,6 +877,7 @@ impl<T: Clone + 'static> Qcow2Driver<T> {
         }
 
         // Error handling, to revert some operation.
+        self.refcount.discard_list.clear();
         if error_stage >= 5 && self.header.snapshots_offset != 0 {
             self.refcount.update_refcount(
                 self.header.snapshots_offset,
@@ -1069,7 +1065,7 @@ impl<T: Clone + 'static> Qcow2Driver<T> {
 
             let date = get_format_time(snap.date_sec as i64);
             let date_str = format!(
-                "{:04}-{:02}-{:02} {:02}-{:02}-{:02}",
+                "{:04}-{:02}-{:02} {:02}:{:02}:{:02}",
                 date[0], date[1], date[2], date[3], date[4], date[5]
             );
 
@@ -1334,10 +1330,10 @@ impl<T: Clone + Send + Sync> BlockDriverOps<T> for Qcow2Driver<T> {
         let mut left = iovec.to_vec();
         let total = std::cmp::min(nbytes, self.virtual_disk_size() - offset as u64);
         let mut req_list = Vec::new();
-        let mut copyed = 0;
-        while copyed < total {
-            let pos = offset as u64 + copyed;
-            let count = self.cluster_aligned_bytes(pos, total - copyed);
+        let mut copied = 0;
+        while copied < total {
+            let pos = offset as u64 + copied;
+            let count = self.cluster_aligned_bytes(pos, total - copied);
             let (begin, end) = iovecs_split(left, count);
             left = end;
             if let HostOffset::DataAddress(host_offset) = self.host_offset_for_read(pos)? {
@@ -1350,7 +1346,7 @@ impl<T: Clone + Send + Sync> BlockDriverOps<T> for Qcow2Driver<T> {
             } else {
                 iov_from_buf_direct(&begin, &vec![0_u8; count as usize])?;
             }
-            copyed += count;
+            copied += count;
         }
 
         self.driver.read_vectored(req_list, completecb)
@@ -1364,10 +1360,10 @@ impl<T: Clone + Send + Sync> BlockDriverOps<T> for Qcow2Driver<T> {
         let mut left = iovec.to_vec();
         let total = std::cmp::min(nbytes, self.virtual_disk_size() - offset as u64);
         let mut req_list = Vec::new();
-        let mut copyed = 0;
-        while copyed < total {
-            let pos = offset as u64 + copyed;
-            let count = self.cluster_aligned_bytes(pos, total - copyed);
+        let mut copied = 0;
+        while copied < total {
+            let pos = offset as u64 + copied;
+            let count = self.cluster_aligned_bytes(pos, total - copied);
             let (begin, end) = iovecs_split(left, count);
             left = end;
             if let HostOffset::DataAddress(host_offset) = self.host_offset_for_write(pos)? {
@@ -1377,7 +1373,7 @@ impl<T: Clone + Send + Sync> BlockDriverOps<T> for Qcow2Driver<T> {
                     offset: host_offset,
                     nbytes,
                 });
-                copyed += count;
+                copied += count;
             }
         }
 
@@ -2045,4 +2041,216 @@ mod test {
         assert!(qcow2_read(&mut qcow2_driver, &mut test_buf, offset_start).is_ok());
         assert!(vec_is_zero(&test_buf));
     }
+
+    #[test]
+    fn test_snapshot_basic() {
+        // TODO:
+        // 1) add check step when stratovirt-img works.
+        // 2) add snapshot apply step to check function.
+        let path = "/tmp/snashot_test.qcow2";
+        let cluster_bits = 16;
+        let cluster_size = 1 << cluster_bits;
+        let (_, mut qcow2) = create_qcow2(path);
+
+        let guest_offsets = [
+            cluster_size * 0,
+            cluster_size * 10,
+            cluster_size * 100,
+            cluster_size * 1000,
+            cluster_size * 10000,
+        ];
+
+        let wbuf = vec![1_u8; CLUSTER_SIZE as usize];
+        // Write data and create snapshot 'snap1'.
+        for offset in guest_offsets {
+            qcow2_write(&mut qcow2, &wbuf, offset).unwrap();
+        }
+        qcow2.qcow2_create_snapshot("snap1".to_string(), 0).unwrap();
+
+        let wbuf = vec![2_u8; CLUSTER_SIZE as usize];
+        // Write data and create snapshot 'snap2'.
+        for offset in guest_offsets {
+            qcow2_write(&mut qcow2, &wbuf, offset).unwrap();
+        }
+        qcow2.qcow2_create_snapshot("snap2".to_string(), 0).unwrap();
+
+        // Read 1 byte for checking. Add more checks after implementing snapshot restore.
+        let mut rbuf = vec![0_u8; 1];
+        for offset in guest_offsets {
+            qcow2_read(&mut qcow2, &mut rbuf, offset).unwrap();
+            assert_eq!(rbuf, [2]);
+        }
+
+        // Delete snapshot 'snap2'.
+        qcow2.qcow2_delete_snapshot("snap2".to_string()).unwrap();
+
+        // Delete snapshot 'snap1'.
+        qcow2.qcow2_delete_snapshot("snap1".to_string()).unwrap();
+    }
+
+    fn get_host_offset(qcow2_driver: &mut Qcow2Driver<()>, guest_offset: u64) -> u64 {
+        let l2_index = qcow2_driver.table.get_l2_table_index(guest_offset);
+        // All used l2 table will be cached for it's little data size in these tests.
+        let l2_table = qcow2_driver
+            .table
+            .get_l2_table_cache_entry(guest_offset)
+            .unwrap();
+        let l2_entry = l2_table
+            .borrow_mut()
+            .get_entry_map(l2_index as usize)
+            .unwrap();
+        let host_offset = l2_entry & L2_TABLE_OFFSET_MASK;
+
+        host_offset
+    }
+
+    // Change snapshot table offset to unaligned address which will lead to error in refcount update process.
+    #[test]
+    fn simulate_revert_snapshot_creation() {
+        let path = "/tmp/revert_create.qcow2";
+        let (_image, mut qcow2_driver) = create_qcow2(path);
+
+        // Write some random data.
+        let (case_list, _buf_list) = generate_rw_random_list();
+        for case in &case_list {
+            qcow2_driver
+                .write_vectored(&case.wiovec, case.offset, ())
+                .unwrap();
+        }
+
+        // Change snapshot table offset to a fake address which is not align to cluster size and
+        // it will fail in update_refcount.
+        qcow2_driver.header.snapshots_offset = 0x1111;
+        let result = qcow2_driver.create_snapshot("snapshot1".to_string(), 0);
+        assert!(result.is_err());
+
+        // Check
+        // 1) No snapshot.
+        assert_eq!(qcow2_driver.header.nb_snapshots, 0);
+        // 2) Refcount is right.
+        for case in &case_list {
+            let host_offset = get_host_offset(&mut qcow2_driver, case.offset as u64);
+            assert_eq!(qcow2_driver.refcount.get_refcount(host_offset).unwrap(), 1);
+        }
+        // 3) L1 table refcount is right.
+        assert_eq!(
+            qcow2_driver
+                .refcount
+                .get_refcount(qcow2_driver.header.l1_table_offset)
+                .unwrap(),
+            1
+        );
+        // 4) L2 table refcount is right.
+        let mut l1_table = qcow2_driver.table.l1_table.clone();
+        for l1_entry in l1_table.iter_mut() {
+            if *l1_entry == 0 {
+                // No l2 table.
+                continue;
+            }
+            assert_eq!(
+                qcow2_driver
+                    .refcount
+                    .get_refcount(*l1_entry & L1_TABLE_OFFSET_MASK)
+                    .unwrap(),
+                1
+            );
+        }
+    }
+
+    // Change snapshot table offset to unaligned address which will lead to error in refcount update process.
+    #[test]
+    fn simulate_revert_snapshot_deletion() {
+        let path = "/tmp/revert_delete.qcow2";
+        let (_image, mut qcow2_driver) = create_qcow2(path);
+
+        // Write some random data.
+        let (case_list, _buf_list) = generate_rw_random_list();
+        for case in &case_list {
+            qcow2_driver
+                .write_vectored(&case.wiovec, case.offset, ())
+                .unwrap();
+        }
+
+        // Create two new snapshots.
+        qcow2_driver
+            .qcow2_create_snapshot("snaptest1".to_string(), 0)
+            .unwrap();
+        qcow2_driver
+            .qcow2_create_snapshot("snaptest2".to_string(), 0)
+            .unwrap();
+
+        // Check.
+        // 1) 2 snapshots: snaptest1, snaptest2.
+        assert_eq!(qcow2_driver.header.nb_snapshots, 2);
+        assert_eq!(qcow2_driver.snapshot.snapshots[0].name, "snaptest1");
+        assert_eq!(qcow2_driver.snapshot.snapshots[1].name, "snaptest2");
+        // 2) Data cluster refcount is right.
+        for case in &case_list {
+            let host_offset = get_host_offset(&mut qcow2_driver, case.offset as u64);
+            assert_eq!(qcow2_driver.refcount.get_refcount(host_offset).unwrap(), 3);
+        }
+        // 3) L1 table refcount is right.
+        assert_eq!(
+            qcow2_driver
+                .refcount
+                .get_refcount(qcow2_driver.header.l1_table_offset)
+                .unwrap(),
+            1
+        );
+        // 4) L2 table refcount is right.
+        let mut l1_table = qcow2_driver.table.l1_table.clone();
+        for l1_entry in l1_table.iter_mut() {
+            if *l1_entry == 0 {
+                // No l2 table.
+                continue;
+            }
+            assert_eq!(
+                qcow2_driver
+                    .refcount
+                    .get_refcount(*l1_entry & L1_TABLE_OFFSET_MASK)
+                    .unwrap(),
+                3
+            );
+        }
+
+        // Change snapshot table offset to a fake address which is not align to cluster size and
+        // it will fail in update_refcount.
+        qcow2_driver.header.snapshots_offset = 0x1111;
+        let result = qcow2_driver.delete_snapshot("snapshot1".to_string());
+        assert!(result.is_err());
+
+        // Check again.
+        // 1) 2 snapshots: snaptest1, snaptest2.
+        assert_eq!(qcow2_driver.header.nb_snapshots, 2);
+        assert_eq!(qcow2_driver.snapshot.snapshots[0].name, "snaptest1");
+        assert_eq!(qcow2_driver.snapshot.snapshots[1].name, "snaptest2");
+        // 2) Data cluster refcount is right.
+        for case in &case_list {
+            let host_offset = get_host_offset(&mut qcow2_driver, case.offset as u64);
+            assert_eq!(qcow2_driver.refcount.get_refcount(host_offset).unwrap(), 3);
+        }
+        // 3) L1 table refcount is right.
+        assert_eq!(
+            qcow2_driver
+                .refcount
+                .get_refcount(qcow2_driver.header.l1_table_offset)
+                .unwrap(),
+            1
+        );
+        // 4) L2 table refcount is right.
+        let mut l1_table = qcow2_driver.table.l1_table.clone();
+        for l1_entry in l1_table.iter_mut() {
+            if *l1_entry == 0 {
+                // No l2 table.
+                continue;
+            }
+            assert_eq!(
+                qcow2_driver
+                    .refcount
+                    .get_refcount(*l1_entry & L1_TABLE_OFFSET_MASK)
+                    .unwrap(),
+                3
+            );
+        }
+    }
 }

devices/src/acpi/ged.rs

@@ -191,8 +191,8 @@ impl AmlBuilder for Ged {
             AmlFieldUpdateRule::WriteAsZeros,
         );
 
-        let elemt = AmlFieldUnit::new(Some(AML_GED_EVT_SEL), 32);
-        field.append_child(elemt);
+        let element = AmlFieldUnit::new(Some(AML_GED_EVT_SEL), 32);
+        field.append_child(element);
         acpi_dev.append_child(field);
 
         let mut method = AmlMethod::new("_EVT", 1, true);