Enable clippy::absolute_paths lint

In the past we had many submissions that, for one reason or another,
were using absolute paths to functions/constants in a very inconsistent
manner. It is not particularly great use of anybody's time pointing
these out and it's certainly a job that computers can do better. Clippy
folks seem to concur that this can be a useful lint [0] and we got
blessed with clippy::absolute_paths.
Enable it throughout libbpf-rs and libbpf-cargo and fix all violations.

[0] rust-lang/rust-clippy#10568

Signed-off-by: Daniel Müller <[email protected]>

Author: d-e-s-o

libbpf-cargo/src/build.rs

@@ -1,4 +1,5 @@
 use std::collections::HashSet;
+use std::env::consts::ARCH;
 use std::ffi::OsStr;
 use std::ffi::OsString;
 use std::fs;
@@ -170,10 +171,10 @@ fn compile_one(debug: bool, source: &Path, out: &Path, clang: &Path, options: &s
     }
 
     if !options.contains("-D__TARGET_ARCH_") {
-        let arch = match std::env::consts::ARCH {
+        let arch = match ARCH {
             "x86_64" => "x86",
             "aarch64" => "arm64",
-            _ => std::env::consts::ARCH,
+            _ => ARCH,
         };
         cmd.arg(format!("-D__TARGET_ARCH_{arch}"));
     }

libbpf-cargo/src/gen/mod.rs

@@ -10,6 +10,7 @@ use std::fs::File;
 use std::io::stdout;
 use std::io::ErrorKind;
 use std::io::Write;
+use std::mem::size_of;
 use std::os::raw::c_ulong;
 use std::path::Path;
 use std::path::PathBuf;
@@ -606,7 +607,7 @@ fn gen_skel_link_getter(skel: &mut String, object: &mut BpfObj, obj_name: &str)
 fn open_bpf_object(name: &str, data: &[u8]) -> Result<BpfObj> {
     let cname = CString::new(name)?;
     let obj_opts = libbpf_sys::bpf_object_open_opts {
-        sz: std::mem::size_of::<libbpf_sys::bpf_object_open_opts>() as libbpf_sys::size_t,
+        sz: size_of::<libbpf_sys::bpf_object_open_opts>() as libbpf_sys::size_t,
         object_name: cname.as_ptr(),
         ..Default::default()
     };

libbpf-cargo/src/lib.rs

@@ -59,6 +59,7 @@
 #![warn(
     elided_lifetimes_in_paths,
     single_use_lifetimes,
+    clippy::absolute_paths,
     clippy::wildcard_imports
 )]
 #![deny(unsafe_op_in_unsafe_fn)]

libbpf-cargo/src/main.rs

@@ -1,4 +1,4 @@
-#![allow(clippy::let_unit_value)]
+#![allow(clippy::absolute_paths, clippy::let_unit_value)]
 
 use std::path::PathBuf;
 

libbpf-rs/src/btf/mod.rs

@@ -24,12 +24,14 @@ use std::marker::PhantomData;
 use std::mem::size_of;
 use std::num::NonZeroUsize;
 use std::ops::Deref;
+use std::os::raw::c_ulong;
 use std::os::raw::c_void;
 use std::os::unix::prelude::AsRawFd;
 use std::os::unix::prelude::FromRawFd;
 use std::os::unix::prelude::OsStrExt;
 use std::os::unix::prelude::OwnedFd;
 use std::path::Path;
+use std::ptr;
 use std::ptr::NonNull;
 
 use num_enum::IntoPrimitive;
@@ -141,7 +143,7 @@ impl Btf<'static> {
                 Error::with_invalid_data(format!("invalid path {path:?}, has null bytes"))
             })?;
             let ptr = create_bpf_entity_checked(|| unsafe {
-                libbpf_sys::btf__parse(path.as_ptr(), std::ptr::null_mut())
+                libbpf_sys::btf__parse(path.as_ptr(), ptr::null_mut())
             })?;
             Ok(Btf {
                 ptr,
@@ -219,15 +221,15 @@ impl<'btf> Btf<'btf> {
             .unwrap();
 
         let obj_opts = libbpf_sys::bpf_object_open_opts {
-            sz: std::mem::size_of::<libbpf_sys::bpf_object_open_opts>() as libbpf_sys::size_t,
+            sz: size_of::<libbpf_sys::bpf_object_open_opts>() as libbpf_sys::size_t,
             object_name: cname.as_ptr(),
             ..Default::default()
         };
 
         let mut bpf_obj = create_bpf_entity_checked(|| unsafe {
             libbpf_sys::bpf_object__open_mem(
                 object_file.as_ptr() as *const c_void,
-                object_file.len() as std::os::raw::c_ulong,
+                object_file.len() as c_ulong,
                 &obj_opts,
             )
         })?;

libbpf-rs/src/btf/types.rs

@@ -339,7 +339,7 @@ pub enum IntEncoding {
 impl<'btf> TryFrom<BtfType<'btf>> for Int<'btf> {
     type Error = BtfType<'btf>;
 
-    fn try_from(t: BtfType<'btf>) -> std::result::Result<Self, Self::Error> {
+    fn try_from(t: BtfType<'btf>) -> Result<Self, Self::Error> {
         if t.kind() == BtfKind::Int {
             let int = {
                 let base_ptr = t.ty as *const libbpf_sys::btf_type;

libbpf-rs/src/lib.rs

@@ -72,6 +72,7 @@
     missing_debug_implementations,
     missing_docs,
     single_use_lifetimes,
+    clippy::absolute_paths,
     clippy::wildcard_imports,
     rustdoc::broken_intra_doc_links
 )]

libbpf-rs/src/map.rs

@@ -16,7 +16,6 @@ use std::os::unix::io::OwnedFd;
 use std::os::unix::io::RawFd;
 use std::path::Path;
 use std::ptr;
-use std::ptr::null;
 use std::ptr::NonNull;
 use std::slice::from_raw_parts;
 
@@ -83,7 +82,7 @@ impl OpenMap {
         let ret = unsafe {
             libbpf_sys::bpf_map__set_initial_value(
                 self.ptr.as_ptr(),
-                data.as_ptr() as *const std::ffi::c_void,
+                data.as_ptr() as *const c_void,
                 data.len() as libbpf_sys::size_t,
             )
         };
@@ -393,7 +392,7 @@ impl MapHandle {
 
         let map_name_ptr = {
             if map_name_str.as_bytes().is_empty() {
-                null()
+                ptr::null()
             } else {
                 map_name_str.as_ptr()
             }
@@ -934,7 +933,7 @@ impl MapType {
     /// Make sure the process has required set of CAP_* permissions (or runs as
     /// root) when performing feature checking.
     pub fn is_supported(&self) -> Result<bool> {
-        let ret = unsafe { libbpf_sys::libbpf_probe_bpf_map_type(*self as u32, std::ptr::null()) };
+        let ret = unsafe { libbpf_sys::libbpf_probe_bpf_map_type(*self as u32, ptr::null()) };
         match ret {
             0 => Ok(false),
             1 => Ok(true),

libbpf-rs/src/object.rs

@@ -171,7 +171,7 @@ impl OpenObject {
         };
 
         // Populate obj.maps
-        let mut map: *mut libbpf_sys::bpf_map = std::ptr::null_mut();
+        let mut map: *mut libbpf_sys::bpf_map = ptr::null_mut();
         loop {
             // Get the pointer to the next BPF map
             let map_ptr = {
@@ -190,7 +190,7 @@ impl OpenObject {
         }
 
         // Populate obj.progs
-        let mut prog: *mut libbpf_sys::bpf_program = std::ptr::null_mut();
+        let mut prog: *mut libbpf_sys::bpf_program = ptr::null_mut();
         loop {
             // Get the pointer to the next BPF program
             let prog_ptr = {
@@ -233,12 +233,12 @@ impl OpenObject {
             // using destructuring we make sure we'll get a compiler error if anything in
             // Self changes, which will alert us to change this function as well
             let Self { ptr, maps, progs } = &mut self;
-            std::mem::take(maps);
-            std::mem::take(progs);
+            mem::take(maps);
+            mem::take(progs);
             *ptr
         };
         // avoid double free of self.ptr
-        std::mem::forget(self);
+        mem::forget(self);
         ptr
     }
 
@@ -354,7 +354,7 @@ impl Object {
         };
 
         // Populate obj.maps
-        let mut map: *mut libbpf_sys::bpf_map = std::ptr::null_mut();
+        let mut map: *mut libbpf_sys::bpf_map = ptr::null_mut();
         loop {
             // Get the pointer to the next BPF map
             let map_ptr = {
@@ -373,7 +373,7 @@ impl Object {
         }
 
         // Populate obj.progs
-        let mut prog: *mut libbpf_sys::bpf_program = std::ptr::null_mut();
+        let mut prog: *mut libbpf_sys::bpf_program = ptr::null_mut();
         loop {
             // Get the pointer to the next BPF program
             let prog_ptr = {

libbpf-rs/src/perf_buffer.rs

@@ -5,6 +5,7 @@ use std::fmt::Formatter;
 use std::fmt::Result as FmtResult;
 use std::os::unix::io::AsFd;
 use std::os::unix::prelude::AsRawFd;
+use std::ptr;
 use std::ptr::NonNull;
 use std::slice;
 use std::time::Duration;
@@ -133,7 +134,7 @@ impl<'a, 'b> PerfBufferBuilder<'a, 'b> {
                 c_sample_cb,
                 c_lost_cb,
                 callback_struct_ptr as *mut _,
-                std::ptr::null(),
+                ptr::null(),
             )
         })
         .map(|ptr| PerfBuffer {