@@ -149,16 +149,16 @@ impl BootloaderConfig {
149
149
/// ELF file.
150
150
///
151
151
/// TODO: return error enum
152
- pub fn deserialize ( serialized : & [ u8 ] ) -> Result < Self , ( ) > {
152
+ pub fn deserialize ( serialized : & [ u8 ] ) -> Result < Self , & ' static str > {
153
153
if serialized. len ( ) != Self :: SERIALIZED_LEN {
154
- return Err ( ( ) ) ;
154
+ return Err ( "invalid len" ) ;
155
155
}
156
156
157
157
let s = serialized;
158
158
159
159
let ( uuid, s) = split_array_ref ( s) ;
160
160
if uuid != & Self :: UUID {
161
- return Err ( ( ) ) ;
161
+ return Err ( "invalid UUID" ) ;
162
162
}
163
163
164
164
let ( version, s) = {
@@ -169,7 +169,7 @@ impl BootloaderConfig {
169
169
let pre = match pre {
170
170
[ 0 ] => false ,
171
171
[ 1 ] => true ,
172
- _ => return Err ( ( ) ) ,
172
+ _ => return Err ( "invalid pre version" ) ,
173
173
} ;
174
174
175
175
let version = ApiVersion {
@@ -206,27 +206,27 @@ impl BootloaderConfig {
206
206
physical_memory : match physical_memory_some {
207
207
[ 0 ] if physical_memory == [ 0 ; 9 ] => Option :: None ,
208
208
[ 1 ] => Option :: Some ( Mapping :: deserialize ( & physical_memory) ?) ,
209
- _ => return Err ( ( ) ) ,
209
+ _ => return Err ( "invalid phys memory value" ) ,
210
210
} ,
211
211
page_table_recursive : match page_table_recursive_some {
212
212
[ 0 ] if page_table_recursive == [ 0 ; 9 ] => Option :: None ,
213
213
[ 1 ] => Option :: Some ( Mapping :: deserialize ( & page_table_recursive) ?) ,
214
- _ => return Err ( ( ) ) ,
214
+ _ => return Err ( "invalid page table recursive value" ) ,
215
215
} ,
216
216
aslr : match alsr {
217
217
1 => true ,
218
218
0 => false ,
219
- _ => return Err ( ( ) ) ,
219
+ _ => return Err ( "invalid aslr value" ) ,
220
220
} ,
221
221
dynamic_range_start : match dynamic_range_start_some {
222
222
[ 0 ] if dynamic_range_start == [ 0 ; 8 ] => Option :: None ,
223
223
[ 1 ] => Option :: Some ( u64:: from_le_bytes ( dynamic_range_start) ) ,
224
- _ => return Err ( ( ) ) ,
224
+ _ => return Err ( "invalid dynamic range start value" ) ,
225
225
} ,
226
226
dynamic_range_end : match dynamic_range_end_some {
227
227
[ 0 ] if dynamic_range_end == [ 0 ; 8 ] => Option :: None ,
228
228
[ 1 ] => Option :: Some ( u64:: from_le_bytes ( dynamic_range_end) ) ,
229
- _ => return Err ( ( ) ) ,
229
+ _ => return Err ( "invalid dynamic range end value" ) ,
230
230
} ,
231
231
} ;
232
232
( mappings, s)
@@ -242,19 +242,19 @@ impl BootloaderConfig {
242
242
minimum_framebuffer_height : match min_framebuffer_height_some {
243
243
[ 0 ] if min_framebuffer_height == [ 0 ; 8 ] => Option :: None ,
244
244
[ 1 ] => Option :: Some ( u64:: from_le_bytes ( min_framebuffer_height) ) ,
245
- _ => return Err ( ( ) ) ,
245
+ _ => return Err ( "minimum_framebuffer_height invalid" ) ,
246
246
} ,
247
247
minimum_framebuffer_width : match min_framebuffer_width_some {
248
248
[ 0 ] if min_framebuffer_width == [ 0 ; 8 ] => Option :: None ,
249
249
[ 1 ] => Option :: Some ( u64:: from_le_bytes ( min_framebuffer_width) ) ,
250
- _ => return Err ( ( ) ) ,
250
+ _ => return Err ( "minimum_framebuffer_width invalid" ) ,
251
251
} ,
252
252
} ;
253
253
( frame_buffer, s)
254
254
} ;
255
255
256
256
if !s. is_empty ( ) {
257
- return Err ( ( ) ) ;
257
+ return Err ( "unexpected rest" ) ;
258
258
}
259
259
260
260
Ok ( Self {
@@ -509,17 +509,17 @@ impl Mapping {
509
509
}
510
510
}
511
511
512
- fn deserialize ( serialized : & [ u8 ; 9 ] ) -> Result < Self , ( ) > {
512
+ fn deserialize ( serialized : & [ u8 ; 9 ] ) -> Result < Self , & ' static str > {
513
513
let ( & variant, s) = split_array_ref ( serialized) ;
514
514
let ( & addr, s) = split_array_ref ( s) ;
515
515
if !s. is_empty ( ) {
516
- return Err ( ( ) ) ;
516
+ return Err ( "invalid mapping format" ) ;
517
517
}
518
518
519
519
match variant {
520
520
[ 0 ] if addr == [ 0 ; 8 ] => Ok ( Mapping :: Dynamic ) ,
521
521
[ 1 ] => Ok ( Mapping :: FixedAddress ( u64:: from_le_bytes ( addr) ) ) ,
522
- _ => Err ( ( ) ) ,
522
+ _ => Err ( "invalid mapping value" ) ,
523
523
}
524
524
}
525
525
}
0 commit comments