Add support for panicking in the emulated application when unsupported syscalls are encountered

Author: landaire

src/bin/miri.rs

@@ -233,6 +233,9 @@ fn main() {
                 "-Zmiri-ignore-leaks" => {
                     miri_config.ignore_leaks = true;
                 }
+                "-Zmiri-panic-on-unsupported-syscalls" => {
+                    miri_config.panic_on_unsupported_syscalls = true;
+                }
                 "-Zmiri-track-raw-pointers" => {
                     miri_config.track_raw = true;
                 }

src/eval.rs

@@ -54,6 +54,8 @@ pub struct MiriConfig {
     /// Rate of spurious failures for compare_exchange_weak atomic operations,
     /// between 0.0 and 1.0, defaulting to 0.8 (80% chance of failure).
     pub cmpxchg_weak_failure_rate: f64,
+    /// Panic when unsupported syscalls are encountered
+    pub panic_on_unsupported_syscalls: bool,
 }
 
 impl Default for MiriConfig {
@@ -73,6 +75,7 @@ impl Default for MiriConfig {
             track_raw: false,
             data_race_detector: true,
             cmpxchg_weak_failure_rate: 0.8,
+            panic_on_unsupported_syscalls: false,
         }
     }
 }
@@ -92,8 +95,8 @@ pub fn create_ecx<'mir, 'tcx: 'mir>(
         tcx,
         rustc_span::source_map::DUMMY_SP,
         param_env,
-        Evaluator::new(config.communicate, config.validate, layout_cx),
-        MemoryExtra::new(&config),
+        Evaluator::new(config.communicate, config.validate, config.panic_on_unsupported_syscalls, layout_cx),
+        MemoryExtra::new(&config)
     );
     // Complete initialization.
     EnvVars::init(&mut ecx, config.excluded_env_vars)?;

src/machine.rs

@@ -274,12 +274,18 @@ pub struct Evaluator<'mir, 'tcx> {
 
     /// Allocations that are considered roots of static memory (that may leak).
     pub(crate) static_roots: Vec<AllocId>,
+
+    /// Whether to raise a panic in the context of the evaluated process when unsupported
+    /// syscalls are encountered. If `false`, an error is propagated in the Miri application context 
+    /// instead (default behavior)
+    pub(crate) panic_on_unsupported_syscalls: bool,
 }
 
 impl<'mir, 'tcx> Evaluator<'mir, 'tcx> {
     pub(crate) fn new(
         communicate: bool,
         validate: bool,
+        panic_on_unsupported_syscalls: bool,
         layout_cx: LayoutCx<'tcx, TyCtxt<'tcx>>,
     ) -> Self {
         let layouts =
@@ -300,6 +306,7 @@ impl<'mir, 'tcx> Evaluator<'mir, 'tcx> {
             layouts,
             threads: ThreadManager::default(),
             static_roots: Vec::new(),
+            panic_on_unsupported_syscalls,
         }
     }
 }

src/shims/posix/linux/foreign_items.rs

@@ -182,7 +182,15 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                     id if id == sys_futex => {
                         futex(this, args, dest)?;
                     }
-                    id => throw_unsup_format!("Miri does not support syscall ID {}", id),
+                    id => {
+                        if this.eval_context_ref().machine.panic_on_unsupported_syscalls {
+                            // message is slightly different here to make automated analysis easier
+                            this.start_panic(format!("unsupported Miri functionality: syscall ID {} is not emulated", id).as_ref(), None)?;
+                            return Ok(false);
+                        } else {
+                            throw_unsup_format!("Miri does not support syscall ID {}", id);
+                        }
+                    }
                 }
             }
 
@@ -214,7 +222,15 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 this.write_null(dest)?;
             }
 
-            _ => throw_unsup_format!("can't call foreign function: {}", link_name),
+            _ => {
+                if this.eval_context_ref().machine.panic_on_unsupported_syscalls {
+                    // message is slightly different here to make automated analysis easier
+                    this.start_panic(format!("unsupported Miri functionality: can't call foreign function {:?}", link_name).as_ref(), None)?;
+                    return Ok(false);
+                } else {
+                    throw_unsup_format!("can't call foreign function: {}", link_name);
+                }
+            }
         };
 
         Ok(true)

src/shims/posix/macos/foreign_items.rs

@@ -156,7 +156,15 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 this.write_scalar(addr, dest)?;
             }
 
-            _ => throw_unsup_format!("can't call foreign function: {}", link_name),
+            _ => {
+                if this.eval_context_ref().machine.panic_on_unsupported_syscalls {
+                    // message is slightly different here to make automated analysis easier
+                    this.start_panic(format!("unsupported Miri functionality: can't call foreign function {:?}", link_name).as_ref(), None)?;
+                    return Ok(false);
+                } else {
+                    throw_unsup_format!("can't call foreign function: {}", link_name);
+                }
+            }
         };
 
         Ok(true)

src/shims/windows/foreign_items.rs

@@ -342,7 +342,12 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
             // Better error for attempts to create a thread
             "CreateThread" => {
                 check_abi(abi, Abi::System { unwind: false })?;
-                throw_unsup_format!("Miri does not support concurrency on Windows");
+                if this.eval_context_ref().machine.panic_on_unsupported_syscalls {
+                    this.start_panic("unsupported Miri functionality: concurrency is not supported on Windows", None)?;
+                    return Ok(false);
+                } else {
+                    throw_unsup_format!("Miri does not support concurrency on Windows");
+                }
             }
 
             // Incomplete shims that we "stub out" just to get pre-main initialization code to work.
@@ -415,7 +420,15 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                 this.write_scalar(Scalar::from_i32(1), dest)?;
             }
 
-            _ => throw_unsup_format!("can't call foreign function: {}", link_name),
+            _ => {
+                if this.eval_context_ref().machine.panic_on_unsupported_syscalls {
+                    // message is slightly different here to make automated analysis easier
+                    this.start_panic(format!("unsupported Miri functionality: can't call foreign function {:?}", link_name).as_ref(), None)?;
+                    return Ok(false);
+                } else {
+                    throw_unsup_format!("can't call foreign function: {}", link_name);
+                }
+            }
         }
 
         Ok(true)