Switch to rust-vmm-ci

.buildkite/pipeline.yml

@@ -10,7 +10,7 @@ steps:
       platform: x86_64.metal
     plugins:
       - docker#v3.0.1:
-          image: "rustvmm/dev:v2"
+          image: "rustvmm/dev:v5"
           always-pull: true
 
   - label: "build-musl-x86-bzimage"
@@ -22,5 +22,5 @@ steps:
       platform: x86_64.metal
     plugins:
       - docker#v3.0.1:
-          image: "rustvmm/dev:v2"
+          image: "rustvmm/dev:v5"
           always-pull: true

.gitignore/.gitignore → .gitignore

@@ -1,3 +1,4 @@
 /target
 **/*.rs.bk
 Cargo.lock
+.idea/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "rust-vmm-ci"]
+	path = rust-vmm-ci
+	url = https://github.com/rust-vmm/rust-vmm-ci.git

README.md

@@ -18,88 +18,40 @@ cargo build
 Our Continuous Integration (CI) pipeline is implemented on top of
 [Buildkite](https://buildkite.com/).
 For the complete list of tests, check our
-[CI pipeline](https://buildkite.com/rust-vmm/vm-virtio-ci).
+[CI pipeline](https://buildkite.com/rust-vmm/rust-vmm-ci).
 
 Each individual test runs in a container. To reproduce a test locally, you can
 use the dev-container on both x86 and arm64.
 
 ```bash
+container_version=5
 docker run -it \
            --security-opt seccomp=unconfined \
            --volume $(pwd):/linux-loader \
-           rustvmm/dev:v2
+           rustvmm/dev:v${container_version}
 cd linux-loader/
 cargo test
 ```
 
-### Test Profiles
-
-The integration tests support two test profiles:
-- **devel**: this is the recommended profile for running the integration tests
-  on a local development machine.
-- **ci** (default option): this is the profile used when running the
-  integration tests as part of the the Continuous Integration (CI).
-
-The test profiles are applicable to tests that run using pytest. Currently only
-the [coverage test](tests/test_coverage.py) follows this model as all the other
-integration tests are run using the
-[Buildkite pipeline](https://buildkite.com/rust-vmm/vm-virtio-ci).
-
-The difference between is declaring tests as passed or failed:
-- with the **devel** profile the coverage test passes if the current coverage
-  is equal or higher than the upstream coverage value. In case the current
-  coverage is higher, the coverage file is updated to the new coverage value.
-- with the **ci** profile the coverage test passes only if the current coverage
-  is equal to the upstream coverage value.
-
-Further details about the coverage test can be found in the
-[Adaptive Coverage](#adaptive-coverage) section.
-
-### Adaptive Coverage
+### bzImage test
 
-The line coverage is saved in [tests/coverage](tests/coverage). To update the
-coverage before submitting a PR, run the coverage test:
+As we don't want to distribute an entire kernel bzImage, the `load_bzImage`
+test is ignored by default. In order to test the bzImage support, one needs to
+locally build a bzImage, copy it to the `src/loader` directory and run
+`cargo test`:
 
 ```bash
+# Assuming your linux-loader and linux-stable are both under ${LINUX_LOADER}:
+git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git ${LINUX_LOADER}/linux-stable
+cd linux-stable
+make bzImage 
+cp linux-stable/arch/x86/boot/bzImage ${LINUX_LOADER}/linux-loader/src/loader/
+cd ${LINUX_LOADER}/linux-loader
+container_version=5
 docker run -it \
            --security-opt seccomp=unconfined \
            --volume $(pwd):/linux-loader \
-           rustvmm/dev:v2
+           rustvmm/dev:v${container_version}
 cd linux-loader/
-pytest --profile=devel tests/test_coverage.py
-```
-
-If the PR coverage is higher than the upstream coverage, the coverage file
-needs to be manually added to the commit before submitting the PR:
-
-```bash
-git add tests/coverage
-```
-
-Failing to do so will generate a fail on the CI pipeline when publishing the
-PR.
-
-**NOTE:** The coverage file is only updated in the `devel` test profile. In
-the `ci` profile the coverage test will fail if the current coverage is higher
-than the coverage reported in [tests/coverage](tests/coverage).
-
-### bzImage test
-
-As we don't want to distribute an entire kernel bzImage, the `load_bzImage` test is ignored by
-default. In order to test the bzImage support, one needs to locally build a bzImage, copy it
-to the `src/loader` directory and run cargo test:
-
-```shell
-# Assuming your linux-loader and linux-stable are both under $LINUX_LOADER
-$ git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git $LINUX_LOADER/linux-stable
-$ cd linux-stable
-$ make bzImage 
-$ cp linux-stable/arch/x86/boot/bzImage $LINUX_LOADER/linux-loader/src/loader/
-$ cd $LINUX_LOADER/linux-loader
-$ docker run -it \
-           --security-opt seccomp=unconfined \
-           --volume $(pwd):/linux-loader \
-           rustvmm/dev:v2
-$ cd linux-loader/
-$ cargo test 
+cargo test 
 ```

coverage_config_aarch64.json

@@ -0,0 +1,5 @@
+{
+  "coverage_score": 71,
+  "exclude_path": "",
+  "crate_features": ""
+}

coverage_config_x86_64.json

@@ -0,0 +1,5 @@
+{
+  "coverage_score": 75.9,
+  "exclude_path": "",
+  "crate_features": ""
+}

src/loader/mod.rs

@@ -399,7 +399,7 @@ pub fn load_cmdline<M: GuestMemory>(
         .checked_add(len as u64 + 1)
         .ok_or(Error::CommandLineOverflow)?; // Extra for null termination.
     if end > guest_mem.last_addr() {
-        return Err(Error::CommandLineOverflow)?;
+        return Err(Error::CommandLineOverflow);
     }
 
     guest_mem

src/loader/struct_util.rs

@@ -18,13 +18,16 @@ pub enum Error {
 pub type Result<T> = std::result::Result<T, Error>;
 
 /// Reads a struct from an input buffer.
-/// This is unsafe because the struct is initialized to unverified data read from the input.
-/// `read_struct` should only be called to fill plain old data structs.  It is not endian safe.
 ///
 /// # Arguments
 ///
 /// * `f` - The input to read from.  Often this is a file.
 /// * `out` - The struct to fill with data read from `f`.
+///
+/// # Safety
+///
+/// This is unsafe because the struct is initialized to unverified data read from the input.
+/// `read_struct` should only be called to fill plain data structs. It is not endian safe.
 pub unsafe fn read_struct<T: Copy, F: Read>(f: &mut F, out: &mut T) -> Result<()> {
     let out_slice = std::slice::from_raw_parts_mut(out as *mut T as *mut u8, mem::size_of::<T>());
     f.read_exact(out_slice).map_err(|_| Error::ReadStruct)?;
@@ -33,13 +36,16 @@ pub unsafe fn read_struct<T: Copy, F: Read>(f: &mut F, out: &mut T) -> Result<()
 
 /// Reads an array of structs from an input buffer.  Returns a Vec of structs initialized with data
 /// from the specified input.
-/// This is unsafe because the structs are initialized to unverified data read from the input.
-/// `read_struct_slice` should only be called for plain old data structs.  It is not endian safe.
 ///
 /// # Arguments
 ///
 /// * `f` - The input to read from.  Often this is a file.
 /// * `len` - The number of structs to fill with data read from `f`.
+///
+/// # Safety
+///
+/// This is unsafe because the struct is initialized to unverified data read from the input.
+/// `read_struct_slice` should only be called to fill plain data structs. It is not endian safe.
 #[cfg(feature = "elf")]
 pub unsafe fn read_struct_slice<T: Copy, F: Read>(f: &mut F, len: usize) -> Result<Vec<T>> {
     let mut out: Vec<T> = Vec::with_capacity(len);