can discover which future was executed before task halted

e2e/examples/deadlock.rs

@@ -0,0 +1,57 @@
+//! Note that this example will not finish by itself and almost guaranteed to deadlock.
+
+use std::sync::Arc;
+
+use tokio::sync::Mutex;
+use tracing::instrument;
+
+#[tokio::main]
+async fn main() {
+    tracing_stacks::init();
+
+    let state = Arc::new(State {
+        first: Mutex::new(0),
+        second: Mutex::new(0),
+    });
+    let handle1 = tokio::spawn({
+        let state = state.clone();
+        async move {
+            loop {
+                state.increment_in_order().await;
+            }
+        }
+    });
+    let handle2 = tokio::spawn({
+        let state = state.clone();
+        async move {
+            loop {
+                state.increment_out_of_order().await;
+            }
+        }
+    });
+    handle1.await.expect("no error");
+    handle2.await.expect("no error");
+}
+
+struct State {
+    first: Mutex<u64>,
+    second: Mutex<u64>,
+}
+
+impl State {
+    #[instrument(skip(self))]
+    async fn increment_in_order(&self) {
+        let mut first = self.first.lock().await;
+        let mut second = self.second.lock().await;
+        *first += 1;
+        *second += 1;
+    }
+
+    #[instrument(skip(self))]
+    async fn increment_out_of_order(&self) {
+        let mut second = self.second.lock().await;
+        let mut first = self.first.lock().await;
+        *first += 1;
+        *second += 1;
+    }
+}

stacks/src/bpf.rs

@@ -59,6 +59,7 @@ pub(crate) enum Program {
     Block(Block),
     Vfs(Vfs),
     Net(Net),
+    Usdt(Usdt),
 }
 
 impl From<Profile> for Program {
@@ -106,6 +107,7 @@ impl Display for Program {
             Program::Block(block) => write!(f, "{}", block),
             Program::Vfs(vfs) => write!(f, "{}", vfs),
             Program::Net(net) => write!(f, "{}", net),
+            Program::Usdt(usdt) => write!(f, "{}", usdt),
         }
     }
 }
@@ -122,6 +124,7 @@ impl TryFrom<&str> for Program {
             Some("block") => Ok(Program::Block(parts.try_into()?)),
             Some("vfs") => Ok(Program::Vfs(parts.try_into()?)),
             Some("net") => Ok(Program::Net(parts.try_into()?)),
+            Some("usdt") => Ok(Program::Usdt(parts.try_into()?)),
             Some(program) => anyhow::bail!("invalid program {}", program),
             None => anyhow::bail!("empty program"),
         }
@@ -261,6 +264,12 @@ impl Programs {
                 }
                 self.net = Some(net);
             }
+            Program::Usdt(usdt) => {
+                if self.usdt.is_some() {
+                    anyhow::bail!("duplicate usdt. {} and {}", self.usdt.as_ref().unwrap(), usdt);
+                }
+                self.usdt = Some(usdt);
+            }
         }
         Ok(())
     }

stacks/src/bpf/stacks.bpf.c

@@ -489,13 +489,13 @@ int BPF_USDT(stacks_tracing_exit, u64 span_id)
     event->pid = pid;
     event->cpu_id = bpf_get_smp_processor_id();
     event->span_id = span_id;
-    if (cfg.switch_ustack)
+    if (cfg.usdt_ustack)
     {
         event->ustack = bpf_get_stackid(ctx, &stackmap, BPF_F_USER_STACK | BPF_F_FAST_STACK_CMP | BPF_F_REUSE_STACKID);
     } else {
         event->ustack = -1;
     }
-    if (cfg.switch_kstack)
+    if (cfg.usdt_kstack)
     {
         event->kstack = bpf_get_stackid(ctx, &stackmap, BPF_F_FAST_STACK_CMP | BPF_F_REUSE_STACKID);
     } else {

stacksexport/sql/traceview/trace_exit_and_close.sql

@@ -5,7 +5,7 @@ select
     duration / 1000 as duration,
     tgid as pid,
     pid as tid,
-    command as name,
+    trace_name as name,
     cpu,
     ustack as end_stack
 from stacks