Add support for the permission TBF header

alistair23 · alistair23 · commit b3c1e832d3a0 · 2020-10-22T17:32:10.000-07:00
Signed-off-by: Alistair Francis &lt;alistair.francis@wdc.com&gt;
diff --git a/src/cmdline.rs b/src/cmdline.rs
@@ -1,14 +1,27 @@
 //! Command line parser setup for elf2tab.
 
+use std::error::Error;
 use std::path::PathBuf;
-
 use structopt::StructOpt;
 
 fn usage() -> &'static str {
     "elf2tab [FLAGS] [OPTIONS] ELF...
 Converts Tock userspace programs from .elf files to Tock Application Bundles."
 }
 
+fn parse_perms<T, U>(s: &str) -> Result<(T, U), Box<dyn Error>>
+where
+    T: std::str::FromStr,
+    T::Err: Error + 'static,
+    U: std::str::FromStr,
+    U::Err: Error + 'static,
+{
+    let pos = s
+        .find(',')
+        .ok_or_else(|| format!("invalid number,option: no `,` found in `{}`", s))?;
+    Ok((s[..pos].parse()?, s[pos + 1..].parse()?))
+}
+
 #[derive(StructOpt, Debug)]
 #[structopt(
     about = "Convert Tock userland apps from .elf files to Tock Application Bundles (TABs or .tab files).",
@@ -88,6 +101,14 @@ pub struct Opt {
         help = "Size of the protected region (including headers)"
     )]
     pub protected_region_size: Option<u32>,
+
+    #[structopt(
+        long = "permissions",
+        name = "permissions",
+        help = "A list of driver numbers and options",
+        parse(try_from_str = parse_perms),
+    )]
+    pub permissions: Vec<(u32, u16)>,
 }
 
 mod test {
diff --git a/src/header.rs b/src/header.rs
@@ -15,6 +15,7 @@ enum TbfHeaderTypes {
     PackageName = 3,
     PicOption1 = 4,
     FixedAddresses = 5,
+    Permissions = 6,
 }
 
 #[repr(C)]
@@ -59,6 +60,22 @@ struct TbfHeaderFixedAddresses {
     start_process_flash: u32,
 }
 
+#[repr(C)]
+#[derive(Clone, Copy, Debug)]
+struct TbfHeaderDriverPermission {
+    driver_number: u32,
+    // Bit 0 of `driver_options` indicates exclusive.
+    driver_options: u16,
+}
+
+#[repr(C)]
+#[derive(Debug)]
+struct TbfHeaderPermissions {
+    base: TbfHeaderTlv,
+    array_length: u16,
+    perms: Vec<TbfHeaderDriverPermission>,
+}
+
 impl fmt::Display for TbfHeaderBase {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         writeln!(
@@ -111,12 +128,34 @@ impl fmt::Display for TbfHeaderFixedAddresses {
     }
 }
 
+impl fmt::Display for TbfHeaderPermissions {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        writeln!(
+            f,
+            "
+          array_length: {0:>8} {0:>#10X}
+           permissions:   Number    Options",
+            self.array_length,
+        )?;
+
+        for perm in &self.perms {
+            writeln!(
+                f,
+                "                      : {0:>#8X} {1:>#10X}",
+                perm.driver_number, perm.driver_options,
+            )?;
+        }
+        Ok(())
+    }
+}
+
 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>,
     package_name: String,
     package_name_pad: usize,
 }
@@ -144,6 +183,7 @@ impl TbfHeader {
             hdr_pkg_name_tlv: None,
             hdr_wfr: Vec::new(),
             hdr_fixed_addresses: None,
+            hdr_permissions: None,
             package_name: String::new(),
             package_name_pad: 0,
         }
@@ -163,6 +203,7 @@ impl TbfHeader {
         package_name: String,
         fixed_address_ram: Option<u32>,
         fixed_address_flash: Option<u32>,
+        permissions: Vec<(u32, u16)>,
     ) -> usize {
         // Need to calculate lengths ahead of time.
         // Need the base and the main section.
@@ -232,6 +273,25 @@ impl TbfHeader {
             });
         }
 
+        let mut perms: Vec<TbfHeaderDriverPermission> = Vec::new();
+        for perm in permissions {
+            perms.push(TbfHeaderDriverPermission {
+                driver_number: perm.0,
+                driver_options: perm.1,
+            })
+        }
+
+        if perms.len() > 0 {
+            self.hdr_permissions = Some(TbfHeaderPermissions {
+                base: TbfHeaderTlv {
+                    tipe: TbfHeaderTypes::Permissions,
+                    length: 8,
+                },
+                array_length: perms.len() as u16,
+                perms,
+            });
+        }
+
         // Return the length by generating the header and seeing how long it is.
         self.generate()
             .expect("No header was generated")
@@ -348,6 +408,9 @@ impl fmt::Display for TbfHeader {
         }
         self.hdr_fixed_addresses
             .map_or(Ok(()), |hdr| write!(f, "{}", hdr))?;
+        self.hdr_permissions
+            .as_ref()
+            .map_or(Ok(()), |hdr| write!(f, "{}", hdr))?;
         Ok(())
     }
 }
diff --git a/src/main.rs b/src/main.rs
@@ -80,6 +80,7 @@ fn main() {
             opt.app_heap_size,
             opt.kernel_heap_size,
             opt.protected_region_size,
+            opt.permissions.to_vec(),
         )
         .unwrap();
         if opt.verbose {
@@ -120,6 +121,7 @@ fn elf_to_tbf<W: Write>(
     app_heap_len: u32,
     kernel_heap_len: u32,
     protected_region_size_arg: Option<u32>,
+    permissions: Vec<(u32, u16)>,
 ) -> io::Result<()> {
     let package_name = package_name.unwrap_or_default();
 
@@ -320,6 +322,7 @@ fn elf_to_tbf<W: Write>(
         package_name,
         fixed_address_ram,
         fixed_address_flash,
+        permissions,
     );
     // If a protected region size was passed, confirm the header will fit.
     // Otherwise, use the header size as the protected region size.
