linux-loader: Create linux-loader crate

This crate is derived from upstream project:
    firecracker project commit 223bdb64d3eb445f55872e63d9ed2518d2235759

The following changes are made after code ported from firecracker:
    - Return the offset in memory where kernel image loading is finished,
      add the related logic in load function also, according to upstream project
      crosvm commit 4133b0120d1e16cafbb373b2ae17a214b594038b
    - Ported to vm-memory, remove dependency on firecrakcer memory-model
    - Remove dependency on sys_util, use read_util instead

Signed-off-by: Cathy Zhang <cathy.zhang@intel.com>

Author: bjzhjing

Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "linux-loader"
+version = "0.1.0"
+authors = ["Cathy Zhang <cathy.zhang@intel.com>"]
+edition = "2018"
+license = "Apache-2.0"
+
+[dependencies.vm-memory]
+git = "https://github.com/rust-vmm/vm-memory"
+features = ["backend-mmap"]

DESIGN.md

@@ -0,0 +1,38 @@
+# ELF Image parsing and loading
+
+The boot process is explained from the following two sides.
+
+## Loader side
+
+It follows ELF standard which is specified in elf.rs.
+The entry header and program headers will be inerpreted, and PT_LOAD segments
+will be loaded into guest memory.
+
+### Where kernel is loaded
+
+There are two ways on deciding where the program segments will be loaded.
+
+- One way is to provide an option and allow vmm to specify where to load the
+  image, considering its memory layout.
+
+- The other way is to load image into phdr.p_paddr by default.
+
+## VMM side
+
+### Construct zero page
+
+According to the 64-bit boot protocol, the boot parameters (traditionally known
+as "zero page") should be setup, including setup_header, e820 table and other
+stuff. However, ELF has no setup_header, nothing returned from ELF loader could
+be used to fill boot parameters, vmm is totally responsible for the construction.
+
+### Configure vCPU
+
+- RIP, the start offset of guest memory where kernel is loaded, which is
+  returned from loader
+
+- 64 bit mode with paging enabled
+
+- GDT must be configured and loaded
+
+

README.md

@@ -0,0 +1,27 @@
+# Linux-loader
+
+## Short-description
+
+* Parsing and loading vmlinux (raw ELF image) and bzImage images
+* Linux command line parsing and generation
+* Definitions and helpers for the Linux boot protocol
+
+## How to build
+
+```
+cd linux-loader
+cargo build
+```
+
+## How to run test
+
+```
+cd linux-loader
+cargo test
+cargo test -- --nocapture
+```
+
+## Platform Support
+- Arch: x86
+- OS: Linux/Unix
+

src/cmdline/mod.rs

@@ -0,0 +1,234 @@
+// Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+//
+// Portions Copyright 2017 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the THIRD-PARTY file.
+
+//! Helper for creating valid kernel command line strings.
+
+use std::fmt;
+use std::result;
+
+/// The error type for command line building operations.
+#[derive(PartialEq, Debug)]
+pub enum Error {
+    /// Operation would have resulted in a non-printable ASCII character.
+    InvalidAscii,
+    /// Key/Value Operation would have had a space in it.
+    HasSpace,
+    /// Key/Value Operation would have had an equals sign in it.
+    HasEquals,
+    /// Operation would have made the command line too large.
+    TooLarge,
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{}",
+            match *self {
+                Error::InvalidAscii => "string contains non-printable ASCII character",
+                Error::HasSpace => "string contains a space",
+                Error::HasEquals => "string contains an equals sign",
+                Error::TooLarge => "inserting string would make command line too long",
+            }
+        )
+    }
+}
+
+/// Specialized Result type for command line operations.
+pub type Result<T> = result::Result<T, Error>;
+
+fn valid_char(c: char) -> bool {
+    match c {
+        ' '...'~' => true,
+        _ => false,
+    }
+}
+
+fn valid_str(s: &str) -> Result<()> {
+    if s.chars().all(valid_char) {
+        Ok(())
+    } else {
+        Err(Error::InvalidAscii)
+    }
+}
+
+fn valid_element(s: &str) -> Result<()> {
+    if !s.chars().all(valid_char) {
+        Err(Error::InvalidAscii)
+    } else if s.contains(' ') {
+        Err(Error::HasSpace)
+    } else if s.contains('=') {
+        Err(Error::HasEquals)
+    } else {
+        Ok(())
+    }
+}
+
+/// A builder for a kernel command line string that validates the string as its being built. A
+/// `CString` can be constructed from this directly using `CString::new`.
+#[derive(Clone)]
+pub struct Cmdline {
+    line: String,
+    capacity: usize,
+}
+
+impl Cmdline {
+    /// Constructs an empty Cmdline with the given capacity, which includes the nul terminator.
+    /// Capacity must be greater than 0.
+    pub fn new(capacity: usize) -> Cmdline {
+        assert_ne!(capacity, 0);
+        Cmdline {
+            line: String::with_capacity(capacity),
+            capacity: capacity,
+        }
+    }
+
+    fn has_capacity(&self, more: usize) -> Result<()> {
+        let needs_space = if self.line.is_empty() { 0 } else { 1 };
+        if self.line.len() + more + needs_space < self.capacity {
+            Ok(())
+        } else {
+            Err(Error::TooLarge)
+        }
+    }
+
+    fn start_push(&mut self) {
+        if !self.line.is_empty() {
+            self.line.push(' ');
+        }
+    }
+
+    fn end_push(&mut self) {
+        // This assert is always true because of the `has_capacity` check that each insert method
+        // uses.
+        assert!(self.line.len() < self.capacity);
+    }
+
+    /// Validates and inserts a key value pair into this command line
+    pub fn insert<T: AsRef<str>>(&mut self, key: T, val: T) -> Result<()> {
+        let k = key.as_ref();
+        let v = val.as_ref();
+
+        valid_element(k)?;
+        valid_element(v)?;
+        self.has_capacity(k.len() + v.len() + 1)?;
+
+        self.start_push();
+        self.line.push_str(k);
+        self.line.push('=');
+        self.line.push_str(v);
+        self.end_push();
+
+        Ok(())
+    }
+
+    /// Validates and inserts a string to the end of the current command line
+    pub fn insert_str<T: AsRef<str>>(&mut self, slug: T) -> Result<()> {
+        let s = slug.as_ref();
+        valid_str(s)?;
+
+        self.has_capacity(s.len())?;
+
+        self.start_push();
+        self.line.push_str(s);
+        self.end_push();
+
+        Ok(())
+    }
+
+    /// Returns the cmdline in progress without nul termination
+    pub fn as_str(&self) -> &str {
+        self.line.as_str()
+    }
+}
+
+impl Into<Vec<u8>> for Cmdline {
+    fn into(self) -> Vec<u8> {
+        self.line.into_bytes()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::ffi::CString;
+
+    #[test]
+    fn insert_hello_world() {
+        let mut cl = Cmdline::new(100);
+        assert_eq!(cl.as_str(), "");
+        assert!(cl.insert("hello", "world").is_ok());
+        assert_eq!(cl.as_str(), "hello=world");
+
+        let s = CString::new(cl).expect("failed to create CString from Cmdline");
+        assert_eq!(s, CString::new("hello=world").unwrap());
+    }
+
+    #[test]
+    fn insert_multi() {
+        let mut cl = Cmdline::new(100);
+        assert!(cl.insert("hello", "world").is_ok());
+        assert!(cl.insert("foo", "bar").is_ok());
+        assert_eq!(cl.as_str(), "hello=world foo=bar");
+    }
+
+    #[test]
+    fn insert_space() {
+        let mut cl = Cmdline::new(100);
+        assert_eq!(cl.insert("a ", "b"), Err(Error::HasSpace));
+        assert_eq!(cl.insert("a", "b "), Err(Error::HasSpace));
+        assert_eq!(cl.insert("a ", "b "), Err(Error::HasSpace));
+        assert_eq!(cl.insert(" a", "b"), Err(Error::HasSpace));
+        assert_eq!(cl.as_str(), "");
+    }
+
+    #[test]
+    fn insert_equals() {
+        let mut cl = Cmdline::new(100);
+        assert_eq!(cl.insert("a=", "b"), Err(Error::HasEquals));
+        assert_eq!(cl.insert("a", "b="), Err(Error::HasEquals));
+        assert_eq!(cl.insert("a=", "b "), Err(Error::HasEquals));
+        assert_eq!(cl.insert("=a", "b"), Err(Error::HasEquals));
+        assert_eq!(cl.insert("a", "=b"), Err(Error::HasEquals));
+        assert_eq!(cl.as_str(), "");
+    }
+
+    #[test]
+    fn insert_emoji() {
+        let mut cl = Cmdline::new(100);
+        assert_eq!(cl.insert("heart", "💖"), Err(Error::InvalidAscii));
+        assert_eq!(cl.insert("💖", "love"), Err(Error::InvalidAscii));
+        assert_eq!(cl.as_str(), "");
+    }
+
+    #[test]
+    fn insert_string() {
+        let mut cl = Cmdline::new(13);
+        assert_eq!(cl.as_str(), "");
+        assert!(cl.insert_str("noapic").is_ok());
+        assert_eq!(cl.as_str(), "noapic");
+        assert!(cl.insert_str("nopci").is_ok());
+        assert_eq!(cl.as_str(), "noapic nopci");
+    }
+
+    #[test]
+    fn insert_too_large() {
+        let mut cl = Cmdline::new(4);
+        assert_eq!(cl.insert("hello", "world"), Err(Error::TooLarge));
+        assert_eq!(cl.insert("a", "world"), Err(Error::TooLarge));
+        assert_eq!(cl.insert("hello", "b"), Err(Error::TooLarge));
+        assert!(cl.insert("a", "b").is_ok());
+        assert_eq!(cl.insert("a", "b"), Err(Error::TooLarge));
+        assert_eq!(cl.insert_str("a"), Err(Error::TooLarge));
+        assert_eq!(cl.as_str(), "a=b");
+
+        let mut cl = Cmdline::new(10);
+        assert!(cl.insert("ab", "ba").is_ok()); // adds 5 length
+        assert_eq!(cl.insert("c", "da"), Err(Error::TooLarge)); // adds 5 (including space) length
+        assert!(cl.insert("c", "d").is_ok()); // adds 4 (including space) length
+    }
+}

src/lib.rs

@@ -0,0 +1,13 @@
+// Copyright (c) 2019 Intel Corporation. All rights reserved.
+// Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0 
+//
+// Copyright 2017 The Chromium OS Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+pub mod cmdline;
+pub mod loader;
+
+extern crate vm_memory;
+