should be BccError so it works nicely in external

Author: brayniac

examples/softirqs.rs

@@ -1,6 +1,7 @@
+use std::error::Error;
+use bcc::BccError;
 use bcc::core::BPF;
 use clap::{App, Arg};
-use failure::Error;
 
 use core::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
@@ -73,7 +74,7 @@ impl fmt::Display for SoftIRQ {
     }
 }
 
-fn do_main(runnable: Arc<AtomicBool>) -> Result<(), Error> {
+fn do_main(runnable: Arc<AtomicBool>) -> Result<(), BccError> {
     let matches = App::new("softirqs")
         .about("Reports time spent in IRQ Handlers")
         .arg(

src/core/kprobe/v0_4_0.rs

@@ -4,7 +4,7 @@ use bcc_sys::bccapi::*;
 
 use crate::core::make_alphanumeric;
 use crate::types::MutPointer;
-use crate::Error;
+use crate::BccError;
 
 use regex::Regex;
 
@@ -23,7 +23,7 @@ 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, BccError> {
         let cname = CString::new(name)?;
         let cfunction = CString::new(function)?;
         let (pid, cpu, group_fd) = (-1, 0, -1);
@@ -42,10 +42,10 @@ impl Kprobe {
         };
         if ptr.is_null() {
             match attach_type {
-                BPF_PROBE_ENTRY => Err(Error::AttachKprobe {
+                BPF_PROBE_ENTRY => Err(BccError::AttachKprobe {
                     name: name.to_string(),
                 }),
-                BPF_PROBE_RETURN => Err(Error::AttachKretprobe {
+                BPF_PROBE_RETURN => Err(BccError::AttachKretprobe {
                     name: name.to_string(),
                 }),
                 _ => unreachable!(),
@@ -59,17 +59,17 @@ impl Kprobe {
         }
     }
 
-    pub fn attach_kprobe(function: &str, code: File) -> Result<Self, Error> {
+    pub fn attach_kprobe(function: &str, code: File) -> Result<Self, BccError> {
         let name = format!("p_{}", &make_alphanumeric(function));
         Kprobe::new(&name, BPF_PROBE_ENTRY, function, code)
     }
 
-    pub fn attach_kretprobe(function: &str, code: File) -> Result<Self, Error> {
+    pub fn attach_kretprobe(function: &str, code: File) -> Result<Self, BccError> {
         let name = format!("r_{}", &make_alphanumeric(function));
         Kprobe::new(&name, BPF_PROBE_RETURN, function, code)
     }
 
-    pub fn get_kprobe_functions(event_re: &str) -> Result<Vec<String>, Error> {
+    pub fn get_kprobe_functions(event_re: &str) -> Result<Vec<String>, BccError> {
         let mut fns: Vec<String> = vec![];
 
         enum Section {

src/core/kprobe/v0_6_0.rs

@@ -3,7 +3,7 @@ use bcc_sys::bccapi::bpf_probe_attach_type_BPF_PROBE_RETURN as BPF_PROBE_RETURN;
 use bcc_sys::bccapi::*;
 
 use crate::core::make_alphanumeric;
-use crate::Error;
+use crate::BccError;
 
 use regex::Regex;
 
@@ -21,7 +21,7 @@ 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, BccError> {
         let cname = CString::new(name)?;
         let cfunction = CString::new(function)?;
         let ptr = unsafe {
@@ -35,10 +35,10 @@ impl Kprobe {
         };
         if ptr < 0 {
             match attach_type {
-                BPF_PROBE_ENTRY => Err(Error::AttachKprobe {
+                BPF_PROBE_ENTRY => Err(BccError::AttachKprobe {
                     name: name.to_string(),
                 }),
-                BPF_PROBE_RETURN => Err(Error::AttachKretprobe {
+                BPF_PROBE_RETURN => Err(BccError::AttachKretprobe {
                     name: name.to_string(),
                 }),
                 _ => unreachable!(),
@@ -52,17 +52,17 @@ impl Kprobe {
         }
     }
 
-    pub fn attach_kprobe(function: &str, code: File) -> Result<Self, Error> {
+    pub fn attach_kprobe(function: &str, code: File) -> Result<Self, BccError> {
         let name = format!("p_{}", &make_alphanumeric(function));
         Kprobe::new(&name, BPF_PROBE_ENTRY, function, code)
     }
 
-    pub fn attach_kretprobe(function: &str, code: File) -> Result<Self, Error> {
+    pub fn attach_kretprobe(function: &str, code: File) -> Result<Self, BccError> {
         let name = format!("r_{}", &make_alphanumeric(function));
         Kprobe::new(&name, BPF_PROBE_RETURN, function, code)
     }
 
-    pub fn get_kprobe_functions(event_re: &str) -> Result<Vec<String>, Error> {
+    pub fn get_kprobe_functions(event_re: &str) -> Result<Vec<String>, BccError> {
         let mut fns: Vec<String> = vec![];
 
         enum Section {

src/core/kprobe/v0_9_0.rs

@@ -3,7 +3,7 @@ use bcc_sys::bccapi::bpf_probe_attach_type_BPF_PROBE_RETURN as BPF_PROBE_RETURN;
 use bcc_sys::bccapi::*;
 
 use crate::core::make_alphanumeric;
-use crate::Error;
+use crate::BccError;
 
 use regex::Regex;
 
@@ -21,7 +21,7 @@ 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, BccError> {
         let cname = CString::new(name)?;
         let cfunction = CString::new(function)?;
         let ptr = unsafe {
@@ -36,10 +36,10 @@ impl Kprobe {
         };
         if ptr < 0 {
             match attach_type {
-                BPF_PROBE_ENTRY => Err(Error::AttachKprobe {
+                BPF_PROBE_ENTRY => Err(BccError::AttachKprobe {
                     name: name.to_string(),
                 }),
-                BPF_PROBE_RETURN => Err(Error::AttachKretprobe {
+                BPF_PROBE_RETURN => Err(BccError::AttachKretprobe {
                     name: name.to_string(),
                 }),
                 _ => unreachable!(),
@@ -53,17 +53,17 @@ impl Kprobe {
         }
     }
 
-    pub fn attach_kprobe(function: &str, code: File) -> Result<Self, Error> {
+    pub fn attach_kprobe(function: &str, code: File) -> Result<Self, BccError> {
         let name = format!("p_{}", &make_alphanumeric(function));
         Kprobe::new(&name, BPF_PROBE_ENTRY, function, code)
     }
 
-    pub fn attach_kretprobe(function: &str, code: File) -> Result<Self, Error> {
+    pub fn attach_kretprobe(function: &str, code: File) -> Result<Self, BccError> {
         let name = format!("r_{}", &make_alphanumeric(function));
         Kprobe::new(&name, BPF_PROBE_RETURN, function, code)
     }
 
-    pub fn get_kprobe_functions(event_re: &str) -> Result<Vec<String>, Error> {
+    pub fn get_kprobe_functions(event_re: &str) -> Result<Vec<String>, BccError> {
         let mut fns: Vec<String> = vec![];
 
         enum Section {

src/core/mod.rs

@@ -12,7 +12,7 @@ use self::uprobe::Uprobe;
 use crate::perf::{self, PerfReader};
 use crate::symbol::SymbolCache;
 use crate::table::Table;
-use crate::Error;
+use crate::BccError;
 
 use core::ffi::c_void;
 use core::sync::atomic::{AtomicPtr, Ordering};
@@ -59,11 +59,11 @@ 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, BccError> {
         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() {
-            return Err(Error::Compilation);
+            return Err(BccError::Compilation);
         }
 
         Ok(BPF {
@@ -79,12 +79,12 @@ 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, BccError> {
         let cs = CString::new(code)?;
         let ptr =
             unsafe { bpf_module_create_c_from_string(cs.as_ptr(), 2, ptr::null_mut(), 0, true) };
         if ptr.is_null() {
-            return Err(Error::Compilation);
+            return Err(BccError::Compilation);
         }
 
         Ok(BPF {
@@ -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, BccError> {
         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(Error::Compilation);
+            return Err(BccError::Compilation);
         }
 
         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, BccError> {
         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, BccError> {
         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, BccError> {
         // 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, BccError> {
         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, BccError> {
         self.load(name, bpf_prog_type_BPF_PROG_TYPE_RAW_TRACEPOINT, 0, 0)
     }
 
@@ -192,7 +192,7 @@ impl BPF {
             let license = bpf_module_license(self.ptr());
             let version = bpf_module_kern_version(self.ptr());
             if start.is_null() {
-                return Err(Error::Loading {
+                return Err(BccError::Loading {
                     name: name.to_string(),
                 });
             }
@@ -210,7 +210,7 @@ impl BPF {
                 log_buf.capacity() as u32,
             );
             if fd < 0 {
-                return Err(Error::Loading {
+                return Err(BccError::Loading {
                     name: name.to_string(),
                 });
             }
@@ -240,7 +240,7 @@ impl BPF {
             let license = bpf_module_license(self.ptr());
             let version = bpf_module_kern_version(self.ptr());
             if start.is_null() {
-                return Err(Error::Loading {
+                return Err(BccError::Loading {
                     name: name.to_string(),
                 });
             }
@@ -260,7 +260,7 @@ impl BPF {
                 log_buf.capacity() as u32,
             );
             if fd < 0 {
-                return Err(Error::Loading {
+                return Err(BccError::Loading {
                     name: name.to_string(),
                 });
             }
@@ -282,7 +282,7 @@ impl BPF {
         prog_type: u32,
         log_level: i32,
         log_size: u32,
-    ) -> Result<File, Error> {
+    ) -> Result<File, BccError> {
         let cname = CString::new(name).unwrap();
         unsafe {
             let start: *mut bpf_insn =
@@ -291,7 +291,7 @@ impl BPF {
             let license = bpf_module_license(self.ptr());
             let version = bpf_module_kern_version(self.ptr());
             if start.is_null() {
-                return Err(Error::Loading {
+                return Err(BccError::Loading {
                     name: name.to_string(),
                 });
             }
@@ -311,7 +311,7 @@ impl BPF {
                 log_buf.capacity() as u32,
             );
             if fd < 0 {
-                return Err(Error::Loading {
+                return Err(BccError::Loading {
                     name: name.to_string(),
                 });
             }
@@ -325,25 +325,25 @@ impl BPF {
         symbol: &str,
         file: File,
         pid: pid_t,
-    ) -> Result<(), Error> {
+    ) -> Result<(), BccError> {
         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<(), BccError> {
         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<(), BccError> {
         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>, BccError> {
         Kprobe::get_kprobe_functions(event_re)
     }
 
@@ -353,13 +353,13 @@ impl BPF {
         symbol: &str,
         file: File,
         pid: pid_t,
-    ) -> Result<(), Error> {
+    ) -> Result<(), BccError> {
         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<(), BccError> {
         let tracepoint = Tracepoint::attach_tracepoint(subsys, name, file)?;
         self.tracepoints.insert(tracepoint);
         Ok(())
@@ -377,13 +377,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<(), BccError> {
         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, BccError> {
         self.sym_caches
             .entry(-1)
             .or_insert_with(|| SymbolCache::new(-1));
@@ -408,7 +408,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<(), BccError>
     where
         F: Fn() -> Box<dyn FnMut(&[u8]) + Send>,
     {