Add kernel version header implementation

README.md

@@ -25,15 +25,17 @@ FLAGS:
     -v, --verbose    Be verbose
 
 OPTIONS:
-        --deterministic                      Produce a deterministic TAB file
-    -o, --output-file <filename>             Output file name [default: TockApp.tab]
-    -n, --package-name <pkg-name>            Package name [default: empty]
+        --deterministic                         Produce a deterministic TAB file
+    -o, --output-file <filename>                Output file name [default: TockApp.tab]
+    -n, --package-name <pkg-name>               Package name [default: empty]
         --protected-region-size <protected-region-size>
-                                             Size of the protected region (including headers)
-        --minimum-ram-size <min-ram-size>    In bytes [default: from RAM sections in ELF]
-        --app-heap <heap-size>               In bytes [default: 1024]
-        --kernel-heap <kernel-heap-size>     In bytes [default: 1024]
-        --stack <stack-size>                 In bytes [default: 2048]
+                                                Size of the protected region (including headers)
+        --minimum-ram-size <min-ram-size>       In bytes [default: from RAM sections in ELF]
+        --app-heap <heap-size>                  In bytes [default: 1024]
+        --kernel-heap <kernel-heap-size>        In bytes [default: 1024]
+        --stack <stack-size>                    In bytes [default: 2048]
+        --kernel-major <kernel-major-version>   The kernel version that the app requires
+        --kernel-minor <kernel-minor-version>   The minimum kernel minor version that the app requires
 
 ARGS:
     <elf>...    application file(s) to package

src/cmdline.rs

@@ -109,6 +109,21 @@ pub struct Opt {
         parse(try_from_str = parse_perms),
     )]
     pub permissions: Vec<(u32, u32)>,
+
+    #[structopt(
+        long = "kernel-major",
+        name = "kernel-major-version",
+        help = "The kernel version that the app requires"
+    )]
+    pub kernel_major: Option<u16>,
+
+    #[structopt(
+        long = "kernel-minor",
+        name = "kernel-minor-version",
+        requires = "kernel-major-version",
+        help = "The minimum kernel minor version that the app requires"
+    )]
+    pub kernel_minor: Option<u16>,
 }
 
 mod test {

src/header.rs

@@ -16,6 +16,7 @@ enum TbfHeaderTypes {
     PicOption1 = 4,
     FixedAddresses = 5,
     Permissions = 6,
+    KernelVersion = 8,
 }
 
 #[repr(C)]
@@ -76,6 +77,14 @@ struct TbfHeaderPermissions {
     perms: Vec<TbfHeaderDriverPermission>,
 }
 
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+struct TbfHeaderKernelVersion {
+    base: TbfHeaderTlv,
+    major: u16,
+    minor: u16,
+}
+
 impl fmt::Display for TbfHeaderBase {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         writeln!(
@@ -149,13 +158,26 @@ impl fmt::Display for TbfHeaderPermissions {
     }
 }
 
+impl fmt::Display for TbfHeaderKernelVersion {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // ^x.y means >= x.y, < (x+1).0
+        writeln!(
+            f,
+            "
+    kernel version: ^{}.{}",
+            self.major, self.minor
+        )
+    }
+}
+
 pub struct TbfHeader {
     hdr_base: TbfHeaderBase,
     hdr_main: TbfHeaderMain,
     hdr_pkg_name_tlv: Option<TbfHeaderTlv>,
     hdr_wfr: Vec<TbfHeaderWriteableFlashRegion>,
     hdr_fixed_addresses: Option<TbfHeaderFixedAddresses>,
     hdr_permissions: Option<TbfHeaderPermissions>,
+    hdr_kernel_version: Option<TbfHeaderKernelVersion>,
     package_name: String,
     package_name_pad: usize,
 }
@@ -184,6 +206,7 @@ impl TbfHeader {
             hdr_wfr: Vec::new(),
             hdr_fixed_addresses: None,
             hdr_permissions: None,
+            hdr_kernel_version: None,
             package_name: String::new(),
             package_name_pad: 0,
         }
@@ -204,6 +227,7 @@ impl TbfHeader {
         fixed_address_ram: Option<u32>,
         fixed_address_flash: Option<u32>,
         permissions: Vec<(u32, u32)>,
+        kernel_version: Option<(u16, u16)>,
     ) -> usize {
         // Need to calculate lengths ahead of time.
         // Need the base and the main section.
@@ -232,6 +256,11 @@ impl TbfHeader {
             header_length += mem::size_of::<TbfHeaderFixedAddresses>();
         }
 
+        // Check if we have to include a kernel version header.
+        if kernel_version.is_some() {
+            header_length += mem::size_of::<TbfHeaderKernelVersion>();
+        }
+
         // Flags default to app is enabled.
         let flags = 0x0000_0001;
 
@@ -306,6 +335,18 @@ impl TbfHeader {
             });
         }
 
+        // If the kernel version is set, we have to include the header.
+        if let Some((kernel_major, kernel_minor)) = kernel_version {
+            self.hdr_kernel_version = Some(TbfHeaderKernelVersion {
+                base: TbfHeaderTlv {
+                    tipe: TbfHeaderTypes::KernelVersion,
+                    length: 4,
+                },
+                major: kernel_major,
+                minor: kernel_minor,
+            });
+        }
+
         // Return the length by generating the header and seeing how long it is.
         self.generate()
             .expect("No header was generated")
@@ -365,6 +406,11 @@ impl TbfHeader {
             header_buf.write_all(unsafe { util::as_byte_slice(&self.hdr_fixed_addresses) })?;
         }
 
+        // If the kernel version is set, include that TLV
+        if self.hdr_kernel_version.is_some() {
+            header_buf.write_all(unsafe { util::as_byte_slice(&self.hdr_kernel_version) })?;
+        }
+
         let current_length = header_buf.get_ref().len();
         util::do_pad(
             &mut header_buf,
@@ -425,6 +471,8 @@ impl fmt::Display for TbfHeader {
         self.hdr_permissions
             .as_ref()
             .map_or(Ok(()), |hdr| write!(f, "{}", hdr))?;
+        self.hdr_kernel_version
+            .map_or(Ok(()), |hdr| write!(f, "{}", hdr))?;
         Ok(())
     }
 }