Replaced results with anyhow errors

Author: rdelfin

src/core/kprobe/v0_4_0.rs

@@ -1,7 +1,7 @@
+use anyhow::{self, bail, Result};
 use bcc_sys::bccapi::bpf_probe_attach_type_BPF_PROBE_ENTRY as BPF_PROBE_ENTRY;
 use bcc_sys::bccapi::bpf_probe_attach_type_BPF_PROBE_RETURN as BPF_PROBE_RETURN;
 use bcc_sys::bccapi::*;
-use failure::*;
 
 use crate::core::make_alphanumeric;
 use crate::types::MutPointer;
@@ -23,9 +23,9 @@ pub struct Kprobe {
 }
 
 impl Kprobe {
-    fn new(name: &str, attach_type: u32, function: &str, code: File) -> Result<Self, Error> {
+    fn new(name: &str, attach_type: u32, function: &str, code: File) -> Result<Self> {
         let cname =
-            CString::new(name).map_err(|_| format_err!("Nul byte in Kprobe name: {}", name))?;
+            CString::new(name).map_err(|_| anyhow::anyhow!("Nul byte in Kprobe name: {}", name))?;
         let cfunction = CString::new(function)
             .map_err(|_| format_err!("Nul byte in Kprobe function: {}", function))?;
         let (pid, cpu, group_fd) = (-1, 0, -1);
@@ -43,7 +43,7 @@ impl Kprobe {
             )
         };
         if ptr.is_null() {
-            Err(format_err!("Failed to attach Kprobe: {}", name))
+            bail!(anyhow::anyhow!("Failed to attach Kprobe: {}", name))
         } else {
             Ok(Self {
                 p: ptr,
@@ -53,19 +53,19 @@ impl Kprobe {
         }
     }
 
-    pub fn attach_kprobe(function: &str, code: File) -> Result<Self, Error> {
+    pub fn attach_kprobe(function: &str, code: File) -> Result<Self> {
         let name = format!("p_{}", &make_alphanumeric(function));
         Kprobe::new(&name, BPF_PROBE_ENTRY, function, code)
-            .map_err(|_| format_err!("Failed to attach Kprobe: {}", name))
+            .map_err(|_| anyhow::anyhow!("Failed to attach Kprobe: {}", name))
     }
 
-    pub fn attach_kretprobe(function: &str, code: File) -> Result<Self, Error> {
+    pub fn attach_kretprobe(function: &str, code: File) -> Result<Self> {
         let name = format!("r_{}", &make_alphanumeric(function));
         Kprobe::new(&name, BPF_PROBE_RETURN, function, code)
-            .map_err(|_| format_err!("Failed to attach Kretprobe: {}", name))
+            .map_err(|_| anyhow::anyhow!("Failed to attach Kretprobe: {}", name))
     }
 
-    pub fn get_kprobe_functions(event_re: &str) -> Result<Vec<String>, Error> {
+    pub fn get_kprobe_functions(event_re: &str) -> Result<Vec<String>> {
         let mut fns: Vec<String> = vec![];
 
         enum Section {

src/core/kprobe/v0_6_0.rs

@@ -1,7 +1,7 @@
+use anyhow::{self, bail, Result};
 use bcc_sys::bccapi::bpf_probe_attach_type_BPF_PROBE_ENTRY as BPF_PROBE_ENTRY;
 use bcc_sys::bccapi::bpf_probe_attach_type_BPF_PROBE_RETURN as BPF_PROBE_RETURN;
 use bcc_sys::bccapi::*;
-use failure::*;
 
 use crate::core::make_alphanumeric;
 
@@ -21,11 +21,11 @@ pub struct Kprobe {
 }
 
 impl Kprobe {
-    fn new(name: &str, attach_type: u32, function: &str, code: File) -> Result<Self, Error> {
+    fn new(name: &str, attach_type: u32, function: &str, code: File) -> Result<Self> {
         let cname =
             CString::new(name).map_err(|_| format_err!("Nul byte in Kprobe name: {}", name))?;
         let cfunction = CString::new(function)
-            .map_err(|_| format_err!("Nul byte in Kprobe function: {}", function))?;
+            .map_err(|_| anyhow::anyhow!("Nul byte in Kprobe function: {}", function))?;
         let ptr = unsafe {
             bpf_attach_kprobe(
                 code.as_raw_fd(),
@@ -36,7 +36,7 @@ impl Kprobe {
             )
         };
         if ptr < 0 {
-            Err(format_err!("Failed to attach Kprobe: {}", name))
+            Err(anyhow::anyhow!("Failed to attach Kprobe: {}", name))
         } else {
             Ok(Self {
                 p: ptr,
@@ -46,19 +46,19 @@ impl Kprobe {
         }
     }
 
-    pub fn attach_kprobe(function: &str, code: File) -> Result<Self, Error> {
+    pub fn attach_kprobe(function: &str, code: File) -> Result<Self> {
         let name = format!("p_{}", &make_alphanumeric(function));
         Kprobe::new(&name, BPF_PROBE_ENTRY, function, code)
-            .map_err(|_| format_err!("Failed to attach Kprobe: {}", name))
+            .map_err(|_| anyhow::anyhow!("Failed to attach Kprobe: {}", name))
     }
 
-    pub fn attach_kretprobe(function: &str, code: File) -> Result<Self, Error> {
+    pub fn attach_kretprobe(function: &str, code: File) -> Result<Self> {
         let name = format!("r_{}", &make_alphanumeric(function));
         Kprobe::new(&name, BPF_PROBE_RETURN, function, code)
-            .map_err(|_| format_err!("Failed to attach Kretprobe: {}", name))
+            .map_err(|_| anyhow::anyhow!("Failed to attach Kretprobe: {}", name))
     }
 
-    pub fn get_kprobe_functions(event_re: &str) -> Result<Vec<String>, Error> {
+    pub fn get_kprobe_functions(event_re: &str) -> Result<Vec<String>> {
         let mut fns: Vec<String> = vec![];
 
         enum Section {

src/core/kprobe/v0_9_0.rs

@@ -1,7 +1,7 @@
+use anyhow::{self, Result};
 use bcc_sys::bccapi::bpf_probe_attach_type_BPF_PROBE_ENTRY as BPF_PROBE_ENTRY;
 use bcc_sys::bccapi::bpf_probe_attach_type_BPF_PROBE_RETURN as BPF_PROBE_RETURN;
 use bcc_sys::bccapi::*;
-use failure::*;
 
 use crate::core::make_alphanumeric;
 
@@ -21,11 +21,11 @@ pub struct Kprobe {
 }
 
 impl Kprobe {
-    fn new(name: &str, attach_type: u32, function: &str, code: File) -> Result<Self, Error> {
+    fn new(name: &str, attach_type: u32, function: &str, code: File) -> Result<Self> {
         let cname =
-            CString::new(name).map_err(|_| format_err!("Nul byte in Kprobe name: {}", name))?;
+            CString::new(name).map_err(|_| anyhow::anyhow!("Nul byte in Kprobe name: {}", name))?;
         let cfunction = CString::new(function)
-            .map_err(|_| format_err!("Nul byte in Kprobe function: {}", function))?;
+            .map_err(|_| anyhow::anyhow!("Nul byte in Kprobe function: {}", function))?;
         let ptr = unsafe {
             bpf_attach_kprobe(
                 code.as_raw_fd(),
@@ -37,7 +37,7 @@ impl Kprobe {
             )
         };
         if ptr < 0 {
-            Err(format_err!("Failed to attach Kprobe: {}", name))
+            Err(anyhow::anyhow!("Failed to attach Kprobe: {}", name))
         } else {
             Ok(Self {
                 p: ptr,
@@ -47,19 +47,19 @@ impl Kprobe {
         }
     }
 
-    pub fn attach_kprobe(function: &str, code: File) -> Result<Self, Error> {
+    pub fn attach_kprobe(function: &str, code: File) -> Result<Self> {
         let name = format!("p_{}", &make_alphanumeric(function));
         Kprobe::new(&name, BPF_PROBE_ENTRY, function, code)
-            .map_err(|_| format_err!("Failed to attach Kprobe: {}", name))
+            .map_err(|_| anyhow::anyhow!("Failed to attach Kprobe: {}", name))
     }
 
-    pub fn attach_kretprobe(function: &str, code: File) -> Result<Self, Error> {
+    pub fn attach_kretprobe(function: &str, code: File) -> Result<Self> {
         let name = format!("r_{}", &make_alphanumeric(function));
         Kprobe::new(&name, BPF_PROBE_RETURN, function, code)
-            .map_err(|_| format_err!("Failed to attach Kretprobe: {}", name))
+            .map_err(|_| anyhow::anyhow!("Failed to attach Kretprobe: {}", name))
     }
 
-    pub fn get_kprobe_functions(event_re: &str) -> Result<Vec<String>, Error> {
+    pub fn get_kprobe_functions(event_re: &str) -> Result<Vec<String>> {
         let mut fns: Vec<String> = vec![];
 
         enum Section {

src/core/mod.rs

@@ -3,8 +3,8 @@ mod raw_tracepoint;
 mod tracepoint;
 mod uprobe;
 
+use anyhow::{self, bail, Result};
 use bcc_sys::bccapi::*;
-use failure::*;
 
 use self::kprobe::Kprobe;
 use self::raw_tracepoint::RawTracepoint;
@@ -59,7 +59,7 @@ impl BPF {
         feature = "v0_7_0",
         feature = "v0_8_0",
     ))]
-    pub fn new(code: &str) -> Result<BPF, Error> {
+    pub fn new(code: &str) -> Result<BPF> {
         let cs = CString::new(code)?;
         let ptr = unsafe { bpf_module_create_c_from_string(cs.as_ptr(), 2, ptr::null_mut(), 0) };
         if ptr.is_null() {
@@ -79,7 +79,7 @@ impl BPF {
 
     // 0.9.0 changes the API for bpf_module_create_c_from_string()
     #[cfg(any(feature = "v0_9_0", feature = "v0_10_0",))]
-    pub fn new(code: &str) -> Result<BPF, Error> {
+    pub fn new(code: &str) -> Result<BPF> {
         let cs = CString::new(code)?;
         let ptr =
             unsafe { bpf_module_create_c_from_string(cs.as_ptr(), 2, ptr::null_mut(), 0, true) };
@@ -105,7 +105,7 @@ impl BPF {
         feature = "v0_13_0",
         not(feature = "specific"),
     ))]
-    pub fn new(code: &str) -> Result<BPF, Error> {
+    pub fn new(code: &str) -> Result<BPF> {
         let cs = CString::new(code)?;
         let ptr = unsafe {
             bpf_module_create_c_from_string(
@@ -118,7 +118,7 @@ impl BPF {
             )
         };
         if ptr.is_null() {
-            return Err(format_err!("couldn't create BPF program"));
+            bail!(anyhow::anyhow!("couldn't create BPF program"));
         }
 
         Ok(BPF {
@@ -143,20 +143,20 @@ impl BPF {
         Table::new(id, self.ptr())
     }
 
-    pub fn load_net(&mut self, name: &str) -> Result<File, Error> {
+    pub fn load_net(&mut self, name: &str) -> Result<File> {
         self.load(name, bpf_prog_type_BPF_PROG_TYPE_SCHED_ACT, 0, 0)
     }
 
-    pub fn load_kprobe(&mut self, name: &str) -> Result<File, Error> {
+    pub fn load_kprobe(&mut self, name: &str) -> Result<File> {
         self.load(name, bpf_prog_type_BPF_PROG_TYPE_KPROBE, 0, 0)
     }
 
-    pub fn load_uprobe(&mut self, name: &str) -> Result<File, Error> {
+    pub fn load_uprobe(&mut self, name: &str) -> Result<File> {
         // it's BPF_PROG_TYPE_KPROBE even though it's a uprobe, it's weird
         self.load(name, bpf_prog_type_BPF_PROG_TYPE_KPROBE, 0, 0)
     }
 
-    pub fn load_tracepoint(&mut self, name: &str) -> Result<File, Error> {
+    pub fn load_tracepoint(&mut self, name: &str) -> Result<File> {
         self.load(name, bpf_prog_type_BPF_PROG_TYPE_TRACEPOINT, 0, 0)
     }
 
@@ -172,7 +172,7 @@ impl BPF {
         feature = "v0_13_0",
         not(feature = "specific"),
     ))]
-    pub fn load_raw_tracepoint(&mut self, name: &str) -> Result<File, Error> {
+    pub fn load_raw_tracepoint(&mut self, name: &str) -> Result<File> {
         self.load(name, bpf_prog_type_BPF_PROG_TYPE_RAW_TRACEPOINT, 0, 0)
     }
 
@@ -183,7 +183,7 @@ impl BPF {
         prog_type: u32,
         _log_level: i32,
         log_size: u32,
-    ) -> Result<File, Error> {
+    ) -> Result<File> {
         let cname = CString::new(name).unwrap();
         unsafe {
             let start: *mut bpf_insn =
@@ -227,7 +227,7 @@ impl BPF {
         prog_type: u32,
         log_level: i32,
         log_size: u32,
-    ) -> Result<File, Error> {
+    ) -> Result<File> {
         let cname = CString::new(name).unwrap();
         unsafe {
             let start: *mut bpf_insn =
@@ -236,7 +236,7 @@ impl BPF {
             let license = bpf_module_license(self.ptr());
             let version = bpf_module_kern_version(self.ptr());
             if start.is_null() {
-                return Err(format_err!("Error in bpf_function_start for {}", name));
+                bail!(anyhow::anyhow!("Error in bpf_function_start for {}", name));
             }
             let mut log_buf: Vec<u8> = Vec::with_capacity(log_size as usize);
             // TODO: we're ignoring any changes bpf_prog_load made to log_buf right now
@@ -274,7 +274,7 @@ impl BPF {
         prog_type: u32,
         log_level: i32,
         log_size: u32,
-    ) -> Result<File, Error> {
+    ) -> Result<File> {
         let cname = CString::new(name).unwrap();
         unsafe {
             let start: *mut bpf_insn =
@@ -283,7 +283,7 @@ impl BPF {
             let license = bpf_module_license(self.ptr());
             let version = bpf_module_kern_version(self.ptr());
             if start.is_null() {
-                return Err(format_err!("Error in bpf_function_start for {}", name));
+                bail!(anyhow::anyhow!("Error in bpf_function_start for {}", name));
             }
             let mut log_buf: Vec<u8> = Vec::with_capacity(log_size as usize);
             // TODO: we're ignoring any changes bpf_prog_load made to log_buf right now
@@ -301,7 +301,7 @@ impl BPF {
                 log_buf.capacity() as u32,
             );
             if fd < 0 {
-                return Err(format_err!("error loading BPF program: {}", name));
+                bail!(anyhow::anyhow!("error loading BPF program: {}", name));
             }
             Ok(File::from_raw_fd(fd))
         }
@@ -313,25 +313,25 @@ impl BPF {
         symbol: &str,
         file: File,
         pid: pid_t,
-    ) -> Result<(), Error> {
+    ) -> Result<()> {
         let uprobe = Uprobe::attach_uretprobe(binary_path, symbol, file, pid)?;
         self.uprobes.insert(uprobe);
         Ok(())
     }
 
-    pub fn attach_kprobe(&mut self, function: &str, file: File) -> Result<(), Error> {
+    pub fn attach_kprobe(&mut self, function: &str, file: File) -> Result<()> {
         let kprobe = Kprobe::attach_kprobe(function, file)?;
         self.kprobes.insert(kprobe);
         Ok(())
     }
 
-    pub fn attach_kretprobe(&mut self, function: &str, file: File) -> Result<(), Error> {
+    pub fn attach_kretprobe(&mut self, function: &str, file: File) -> Result<()> {
         let kretprobe = Kprobe::attach_kretprobe(function, file)?;
         self.kprobes.insert(kretprobe);
         Ok(())
     }
 
-    pub fn get_kprobe_functions(&mut self, event_re: &str) -> Result<Vec<String>, Error> {
+    pub fn get_kprobe_functions(&mut self, event_re: &str) -> Result<Vec<String>> {
         Kprobe::get_kprobe_functions(event_re)
     }
 
@@ -341,13 +341,13 @@ impl BPF {
         symbol: &str,
         file: File,
         pid: pid_t,
-    ) -> Result<(), Error> {
+    ) -> Result<()> {
         let uprobe = Uprobe::attach_uprobe(binary_path, symbol, file, pid)?;
         self.uprobes.insert(uprobe);
         Ok(())
     }
 
-    pub fn attach_tracepoint(&mut self, subsys: &str, name: &str, file: File) -> Result<(), Error> {
+    pub fn attach_tracepoint(&mut self, subsys: &str, name: &str, file: File) -> Result<()> {
         let tracepoint = Tracepoint::attach_tracepoint(subsys, name, file)?;
         self.tracepoints.insert(tracepoint);
         Ok(())
@@ -365,13 +365,13 @@ impl BPF {
         feature = "v0_13_0",
         not(feature = "specific"),
     ))]
-    pub fn attach_raw_tracepoint(&mut self, name: &str, file: File) -> Result<(), Error> {
+    pub fn attach_raw_tracepoint(&mut self, name: &str, file: File) -> Result<()> {
         let raw_tracepoint = RawTracepoint::attach_raw_tracepoint(name, file)?;
         self.raw_tracepoints.insert(raw_tracepoint);
         Ok(())
     }
 
-    pub fn ksymname(&mut self, name: &str) -> Result<u64, Error> {
+    pub fn ksymname(&mut self, name: &str) -> Result<u64> {
         self.sym_caches
             .entry(-1)
             .or_insert_with(|| SymbolCache::new(-1));
@@ -396,7 +396,7 @@ impl BPF {
             || self.ksymname("bpf_get_raw_tracepoint").is_ok()
     }
 
-    pub fn init_perf_map<F>(&mut self, table: Table, cb: F) -> Result<(), Error>
+    pub fn init_perf_map<F>(&mut self, table: Table, cb: F) -> Result<()>
     where
         F: Fn() -> Box<dyn FnMut(&[u8]) + Send>,
     {

src/core/raw_tracepoint/v0_6_0.rs

@@ -1,5 +1,5 @@
+use anyhow::{self, Result};
 use bcc_sys::bccapi::*;
-use failure::*;
 
 use std::ffi::CString;
 use std::fs::File;
@@ -14,12 +14,12 @@ pub struct RawTracepoint {
 }
 
 impl RawTracepoint {
-    pub fn attach_raw_tracepoint(name: &str, file: File) -> Result<Self, Error> {
-        let cname =
-            CString::new(name).map_err(|_| format_err!("Nul byte in Tracepoint name: {}", name))?;
+    pub fn attach_raw_tracepoint(name: &str, file: File) -> Result<Self> {
+        let cname = CString::new(name)
+            .map_err(|_| anyhow::anyhow!("Nul byte in Tracepoint name: {}", name))?;
         let ptr = unsafe { bpf_attach_raw_tracepoint(file.as_raw_fd(), cname.as_ptr() as *mut _) };
         if ptr < 0 {
-            Err(format_err!("Failed to attach raw tracepoint: {}", name))
+            Err(anyhow::anyhow!("Failed to attach raw tracepoint: {}", name))
         } else {
             Ok(Self {
                 name: cname,