wxtla 0.3.0

Wired eXploring Target Layer Accessor
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

//! Validation of parsed APM layouts.

use super::{
  descriptor::ApmDriverDescriptor,
  entry::{ApmPartitionInfo, ApmPartitionMapEntry},
  type_identifiers,
};
use crate::{Error, Result};

pub(super) fn validate_layout(
  source_size: u64, descriptor: &ApmDriverDescriptor, partitions: &[ApmPartitionInfo],
) -> Result<()> {
  validate_descriptor(source_size, descriptor)?;
  validate_partitions(source_size, descriptor, partitions)?;
  Ok(())
}

fn validate_descriptor(source_size: u64, descriptor: &ApmDriverDescriptor) -> Result<()> {
  if descriptor.block_size == 0 {
    return Err(Error::InvalidFormat(
      "apm block size must be non-zero".to_string(),
    ));
  }
  if descriptor.block_count == 0 {
    return Err(Error::InvalidFormat(
      "apm block count must be non-zero".to_string(),
    ));
  }

  let total_size = u64::from(descriptor.block_size)
    .checked_mul(u64::from(descriptor.block_count))
    .ok_or_else(|| Error::InvalidRange("apm device size overflow".to_string()))?;
  if total_size > source_size {
    return Err(Error::InvalidFormat(
      "apm device size exceeds the source size".to_string(),
    ));
  }

  Ok(())
}

fn validate_partitions(
  source_size: u64, descriptor: &ApmDriverDescriptor, partitions: &[ApmPartitionInfo],
) -> Result<()> {
  let Some(first_partition) = partitions.first() else {
    return Err(Error::InvalidFormat(
      "apm partition map is empty".to_string(),
    ));
  };
  if first_partition.entry.type_identifier != type_identifiers::PARTITION_MAP {
    return Err(Error::InvalidFormat(
      "apm first partition entry must describe the partition map".to_string(),
    ));
  }

  let expected_entry_count = first_partition.entry.total_entry_count;
  if expected_entry_count == 0 {
    return Err(Error::InvalidFormat(
      "apm partition map entry count must be non-zero".to_string(),
    ));
  }
  if usize::try_from(expected_entry_count).ok() != Some(partitions.len()) {
    return Err(Error::InvalidFormat(
      "apm partition map entry count does not match the parsed entries".to_string(),
    ));
  }

  for partition in partitions {
    validate_partition(source_size, descriptor, &partition.entry)?;
    if partition.entry.total_entry_count != expected_entry_count {
      return Err(Error::InvalidFormat(format!(
        "apm partition {} has an inconsistent entry count",
        partition.record.index
      )));
    }
  }

  let mut spans = partitions
    .iter()
    .map(|partition| {
      Ok((
        partition.record.index,
        partition.record.span.byte_offset,
        partition
          .record
          .span
          .end_offset()
          .ok_or_else(|| Error::InvalidRange("apm partition end offset overflow".to_string()))?,
      ))
    })
    .collect::<Result<Vec<_>>>()?;
  spans.sort_unstable_by_key(|(_, start, _)| *start);
  for pair in spans.windows(2) {
    if pair[1].1 < pair[0].2 {
      return Err(Error::InvalidFormat(format!(
        "apm partitions {} and {} overlap",
        pair[0].0, pair[1].0
      )));
    }
  }

  Ok(())
}

fn validate_partition(
  source_size: u64, descriptor: &ApmDriverDescriptor, entry: &ApmPartitionMapEntry,
) -> Result<()> {
  if entry.block_count == 0 {
    return Err(Error::InvalidFormat(
      "apm partition block count must be non-zero".to_string(),
    ));
  }

  let start_block = u64::from(entry.start_block);
  let block_count = u64::from(entry.block_count);
  let end_block = start_block
    .checked_add(block_count)
    .ok_or_else(|| Error::InvalidRange("apm partition end block overflow".to_string()))?;
  if end_block > u64::from(descriptor.block_count) {
    return Err(Error::InvalidFormat(
      "apm partition exceeds the declared device block count".to_string(),
    ));
  }

  let byte_offset = start_block
    .checked_mul(u64::from(descriptor.block_size))
    .ok_or_else(|| Error::InvalidRange("apm partition byte offset overflow".to_string()))?;
  let byte_size = block_count
    .checked_mul(u64::from(descriptor.block_size))
    .ok_or_else(|| Error::InvalidRange("apm partition byte size overflow".to_string()))?;
  let byte_end = byte_offset
    .checked_add(byte_size)
    .ok_or_else(|| Error::InvalidRange("apm partition byte end overflow".to_string()))?;
  if byte_end > source_size {
    return Err(Error::InvalidFormat(
      "apm partition exceeds the source size".to_string(),
    ));
  }

  Ok(())
}