1 // Copyright 2020 The Chromium OS Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 use std::fs::File;
6 use std::io::{ErrorKind, Read, Result};
7 use std::path::PathBuf;
8 
9 use data_model::DataInit;
10 
11 /// SDT represents for System Description Table. The structure SDT is a
12 /// generic format for creating various ACPI tables like DSDT/FADT/MADT.
13 pub struct SDT {
14     data: Vec<u8>,
15 }
16 
17 pub const HEADER_LEN: u32 = 36;
18 const LENGTH_OFFSET: usize = 4;
19 const CHECKSUM_OFFSET: usize = 9;
20 
21 #[allow(clippy::len_without_is_empty)]
22 impl SDT {
23     /// Set up the ACPI table header at the front of the SDT.
24     /// The arguments correspond to the elements in the ACPI
25     /// table headers.
new( signature: [u8; 4], length: u32, revision: u8, oem_id: [u8; 6], oem_table: [u8; 8], oem_revision: u32, ) -> Self26     pub fn new(
27         signature: [u8; 4],
28         length: u32,
29         revision: u8,
30         oem_id: [u8; 6],
31         oem_table: [u8; 8],
32         oem_revision: u32,
33     ) -> Self {
34         // The length represents for the length of the entire table
35         // which includes this header. And the header is 36 bytes, so
36         // lenght should be >= 36. For the case who gives a number less
37         // than the header len, use the header len directly.
38         let len: u32 = if length < HEADER_LEN {
39             HEADER_LEN
40         } else {
41             length
42         };
43         let mut data = Vec::with_capacity(length as usize);
44         data.extend_from_slice(&signature);
45         data.extend_from_slice(&len.to_le_bytes());
46         data.push(revision);
47         data.push(0); // checksum
48         data.extend_from_slice(&oem_id);
49         data.extend_from_slice(&oem_table);
50         data.extend_from_slice(&oem_revision.to_le_bytes());
51         data.extend_from_slice(b"CROS");
52         data.extend_from_slice(&0u32.to_le_bytes());
53 
54         data.resize(length as usize, 0);
55         let mut sdt = SDT { data };
56 
57         sdt.update_checksum();
58         sdt
59     }
60 
61     /// Set up the ACPI table from file content. Verify file checksum.
from_file(path: &PathBuf) -> Result<Self>62     pub fn from_file(path: &PathBuf) -> Result<Self> {
63         let mut file = File::open(path)?;
64         let mut data = Vec::new();
65         file.read_to_end(&mut data)?;
66         let checksum = super::generate_checksum(data.as_slice());
67         if checksum == 0 {
68             Ok(SDT { data })
69         } else {
70             Err(ErrorKind::InvalidData.into())
71         }
72     }
73 
is_signature(&self, signature: &[u8; 4]) -> bool74     pub fn is_signature(&self, signature: &[u8; 4]) -> bool {
75         self.data[0..4] == *signature
76     }
77 
update_checksum(&mut self)78     fn update_checksum(&mut self) {
79         self.data[CHECKSUM_OFFSET] = 0;
80         let checksum = super::generate_checksum(self.data.as_slice());
81         self.data[CHECKSUM_OFFSET] = checksum;
82     }
83 
as_slice(&self) -> &[u8]84     pub fn as_slice(&self) -> &[u8] {
85         &self.data.as_slice()
86     }
87 
append<T: DataInit>(&mut self, value: T)88     pub fn append<T: DataInit>(&mut self, value: T) {
89         self.data.extend_from_slice(value.as_slice());
90         self.write(LENGTH_OFFSET, self.data.len() as u32);
91     }
92 
append_slice(&mut self, value: &[u8])93     pub fn append_slice(&mut self, value: &[u8]) {
94         self.data.extend_from_slice(value);
95         self.write(LENGTH_OFFSET, self.data.len() as u32);
96     }
97 
98     /// Write a value at the given offset
write<T: DataInit>(&mut self, offset: usize, value: T)99     pub fn write<T: DataInit>(&mut self, offset: usize, value: T) {
100         let value_len = std::mem::size_of::<T>();
101         if (offset + value_len) > self.data.len() {
102             return;
103         }
104 
105         self.data[offset..offset + value_len].copy_from_slice(&value.as_slice());
106         self.update_checksum();
107     }
108 
len(&self) -> usize109     pub fn len(&self) -> usize {
110         self.data.len()
111     }
112 }
113 
114 #[cfg(test)]
115 mod tests {
116     use super::SDT;
117     use std::io::Write;
118     use tempfile::NamedTempFile;
119 
120     #[test]
test_sdt()121     fn test_sdt() {
122         let mut sdt = SDT::new(*b"TEST", 40, 1, *b"CROSVM", *b"TESTTEST", 1);
123         let sum: u8 = sdt
124             .as_slice()
125             .iter()
126             .fold(0u8, |acc, x| acc.wrapping_add(*x));
127         assert_eq!(sum, 0);
128         sdt.write(36, 0x12345678 as u32);
129         let sum: u8 = sdt
130             .as_slice()
131             .iter()
132             .fold(0u8, |acc, x| acc.wrapping_add(*x));
133         assert_eq!(sum, 0);
134     }
135 
136     #[test]
test_sdt_read_write() -> Result<(), std::io::Error>137     fn test_sdt_read_write() -> Result<(), std::io::Error> {
138         let temp_file = NamedTempFile::new()?;
139         let expected_sdt = SDT::new(*b"TEST", 40, 1, *b"CROSVM", *b"TESTTEST", 1);
140 
141         // Write SDT to file.
142         {
143             let mut writer = temp_file.as_file();
144             writer.write_all(&expected_sdt.as_slice())?;
145         }
146 
147         // Read it back and verify.
148         let actual_sdt = SDT::from_file(&temp_file.path().to_path_buf())?;
149         assert!(actual_sdt.is_signature(b"TEST"));
150         assert_eq!(actual_sdt.as_slice(), expected_sdt.as_slice());
151         Ok(())
152     }
153 }
154