chore: remove aya_obj -> obj alias

When `aya::obj` was migrated to be its own crate `aya-obj`, the `obj`
alias was created to preserve existing imports that relied on
`crate::obj`.

This resulted in 3 ways to import `aya-obj` objects:
- `use aya_obj::*`
- `use obj::*`
- `use crate::obj::*`

The `obj` alias is now removed to avoid confusion, and all `obj` imports
should now refer to `aya_obj`.

aya/src/bpf.rs

@@ -11,24 +11,20 @@ use std::{
 };
 
 use aya_obj::{
-    btf::{BtfFeatures, BtfRelocationError},
+    btf::{Btf, BtfError, BtfFeatures, BtfRelocationError},
-    generated::{BPF_F_SLEEPABLE, BPF_F_XDP_HAS_FRAGS},
+    generated::{
+        bpf_map_type::{self, *},
+        AYA_PERF_EVENT_IOC_DISABLE, AYA_PERF_EVENT_IOC_ENABLE, AYA_PERF_EVENT_IOC_SET_BPF,
+        BPF_F_SLEEPABLE, BPF_F_XDP_HAS_FRAGS,
+    },
     relocation::EbpfRelocationError,
-    EbpfSectionKind, Features,
+    EbpfSectionKind, Features, Object, ParseError, ProgramSection,
 };
 use log::{debug, warn};
 use thiserror::Error;
 
 use crate::{
-    generated::{
-        bpf_map_type::{self, *},
-        AYA_PERF_EVENT_IOC_DISABLE, AYA_PERF_EVENT_IOC_ENABLE, AYA_PERF_EVENT_IOC_SET_BPF,
-    },
     maps::{Map, MapData, MapError},
-    obj::{
-        btf::{Btf, BtfError},
-        Object, ParseError, ProgramSection,
-    },
     programs::{
         BtfTracePoint, CgroupDevice, CgroupSkb, CgroupSkbAttachType, CgroupSock, CgroupSockAddr,
         CgroupSockopt, CgroupSysctl, Extension, FEntry, FExit, KProbe, LircMode2, Lsm, PerfEvent,
@@ -790,7 +786,7 @@ fn adjust_to_page_size(byte_size: u32, page_size: u32) -> u32 {
 
 #[cfg(test)]
 mod tests {
-    use crate::generated::bpf_map_type::*;
+    use aya_obj::generated::bpf_map_type::*;
 
     const PAGE_SIZE: u32 = 4096;
     const NUM_CPUS: u32 = 4;

aya/src/lib.rs

@@ -86,10 +86,8 @@ pub mod util;
 
 use std::os::fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, OwnedFd, RawFd};
 
-use aya_obj as obj;
+pub use aya_obj::btf::{Btf, BtfError};
-use aya_obj::generated;
 pub use bpf::*;
-pub use obj::btf::{Btf, BtfError};
 pub use object::Endianness;
 #[doc(hidden)]
 pub use sys::netlink_set_link_up;

aya/src/maps/bloom_filter.rs

@@ -81,23 +81,22 @@ mod tests {
     use std::io;
 
     use assert_matches::assert_matches;
+    use aya_obj::generated::{
+        bpf_cmd,
+        bpf_map_type::{BPF_MAP_TYPE_ARRAY, BPF_MAP_TYPE_BLOOM_FILTER},
+    };
     use libc::{EFAULT, ENOENT};
 
     use super::*;
     use crate::{
-        generated::{
-            bpf_cmd,
-            bpf_map_type::{BPF_MAP_TYPE_ARRAY, BPF_MAP_TYPE_BLOOM_FILTER},
-        },
         maps::{
             test_utils::{self, new_map},
             Map,
         },
-        obj,
         sys::{override_syscall, SysResult, Syscall},
     };
 
-    fn new_obj_map() -> obj::Map {
+    fn new_obj_map() -> aya_obj::Map {
         test_utils::new_obj_map::<u32>(BPF_MAP_TYPE_BLOOM_FILTER)
     }
 

aya/src/maps/hash_map/hash_map.rs

@@ -106,23 +106,22 @@ mod tests {
     use std::io;
 
     use assert_matches::assert_matches;
+    use aya_obj::generated::{
+        bpf_attr, bpf_cmd,
+        bpf_map_type::{BPF_MAP_TYPE_HASH, BPF_MAP_TYPE_LRU_HASH},
+    };
     use libc::{EFAULT, ENOENT};
 
     use super::*;
     use crate::{
-        generated::{
-            bpf_attr, bpf_cmd,
-            bpf_map_type::{BPF_MAP_TYPE_HASH, BPF_MAP_TYPE_LRU_HASH},
-        },
         maps::{
             test_utils::{self, new_map},
             Map,
         },
-        obj,
         sys::{override_syscall, SysResult, Syscall},
     };
 
-    fn new_obj_map() -> obj::Map {
+    fn new_obj_map() -> aya_obj::Map {
         test_utils::new_obj_map::<u32>(BPF_MAP_TYPE_HASH)
     }
 

aya/src/maps/hash_map/per_cpu_hash_map.rs

@@ -151,12 +151,13 @@ impl<T: Borrow<MapData>, K: Pod, V: Pod> IterableMap<K, PerCpuValues<V>>
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use aya_obj::generated::bpf_map_type::{
-    use crate::{
+        BPF_MAP_TYPE_LRU_PERCPU_HASH, BPF_MAP_TYPE_PERCPU_HASH,
-        generated::bpf_map_type::{BPF_MAP_TYPE_LRU_PERCPU_HASH, BPF_MAP_TYPE_PERCPU_HASH},
-        maps::{test_utils, Map},
     };
 
+    use super::*;
+    use crate::maps::{test_utils, Map};
+
     #[test]
     fn test_try_from_ok() {
         let map = Map::PerCpuHashMap(test_utils::new_map(test_utils::new_obj_map::<u32>(

aya/src/maps/lpm_trie.rs

@@ -198,23 +198,22 @@ mod tests {
     use std::{io, net::Ipv4Addr};
 
     use assert_matches::assert_matches;
+    use aya_obj::generated::{
+        bpf_cmd,
+        bpf_map_type::{BPF_MAP_TYPE_ARRAY, BPF_MAP_TYPE_LPM_TRIE},
+    };
     use libc::{EFAULT, ENOENT};
 
     use super::*;
     use crate::{
-        generated::{
-            bpf_cmd,
-            bpf_map_type::{BPF_MAP_TYPE_ARRAY, BPF_MAP_TYPE_LPM_TRIE},
-        },
         maps::{
             test_utils::{self, new_map},
             Map,
         },
-        obj,
         sys::{override_syscall, SysResult, Syscall},
     };
 
-    fn new_obj_map() -> obj::Map {
+    fn new_obj_map() -> aya_obj::Map {
         test_utils::new_obj_map::<Key<u32>>(BPF_MAP_TYPE_LPM_TRIE)
     }
 

aya/src/maps/mod.rs

@@ -59,13 +59,12 @@ use std::{
     ptr,
 };
 
-use aya_obj::{generated::bpf_map_type, InvalidTypeBinding};
+use aya_obj::{generated::bpf_map_type, parse_map_info, EbpfSectionKind, InvalidTypeBinding};
 use libc::{getrlimit, rlim_t, rlimit, RLIMIT_MEMLOCK, RLIM_INFINITY};
 use log::warn;
 use thiserror::Error;
 
 use crate::{
-    obj::{self, parse_map_info, EbpfSectionKind},
     pin::PinError,
     sys::{
         bpf_create_map, bpf_get_object, bpf_map_freeze, bpf_map_get_fd_by_id, bpf_map_get_next_key,
@@ -544,14 +543,14 @@ pub(crate) fn check_v_size<V>(map: &MapData) -> Result<(), MapError> {
 /// You should never need to use this unless you're implementing a new map type.
 #[derive(Debug)]
 pub struct MapData {
-    obj: obj::Map,
+    obj: aya_obj::Map,
     fd: MapFd,
 }
 
 impl MapData {
     /// Creates a new map with the provided `name`
     pub fn create(
-        mut obj: obj::Map,
+        mut obj: aya_obj::Map,
         name: &str,
         btf_fd: Option<BorrowedFd<'_>>,
     ) -> Result<Self, MapError> {
@@ -599,7 +598,7 @@ impl MapData {
 
     pub(crate) fn create_pinned_by_name<P: AsRef<Path>>(
         path: P,
-        obj: obj::Map,
+        obj: aya_obj::Map,
         name: &str,
         btf_fd: Option<BorrowedFd<'_>>,
     ) -> Result<Self, MapError> {
@@ -750,7 +749,7 @@ impl MapData {
         fd
     }
 
-    pub(crate) fn obj(&self) -> &obj::Map {
+    pub(crate) fn obj(&self) -> &aya_obj::Map {
         let Self { obj, fd: _ } = self;
         obj
     }
@@ -951,15 +950,19 @@ impl<T: Pod> Deref for PerCpuValues<T> {
 
 #[cfg(test)]
 mod test_utils {
+    use aya_obj::{
+        generated::{bpf_cmd, bpf_map_type},
+        maps::LegacyMap,
+        EbpfSectionKind,
+    };
+
     use crate::{
         bpf_map_def,
-        generated::{bpf_cmd, bpf_map_type},
         maps::MapData,
-        obj::{self, maps::LegacyMap, EbpfSectionKind},
         sys::{override_syscall, Syscall},
     };
 
-    pub(super) fn new_map(obj: obj::Map) -> MapData {
+    pub(super) fn new_map(obj: aya_obj::Map) -> MapData {
         override_syscall(|call| match call {
             Syscall::Ebpf {
                 cmd: bpf_cmd::BPF_MAP_CREATE,
@@ -970,8 +973,8 @@ mod test_utils {
         MapData::create(obj, "foo", None).unwrap()
     }
 
-    pub(super) fn new_obj_map<K>(map_type: bpf_map_type) -> obj::Map {
+    pub(super) fn new_obj_map<K>(map_type: bpf_map_type) -> aya_obj::Map {
-        obj::Map::Legacy(LegacyMap {
+        aya_obj::Map::Legacy(LegacyMap {
             def: bpf_map_def {
                 map_type: map_type as u32,
                 key_size: std::mem::size_of::<K>() as u32,
@@ -989,8 +992,8 @@ mod test_utils {
     pub(super) fn new_obj_map_with_max_entries<K>(
         map_type: bpf_map_type,
         max_entries: u32,
-    ) -> obj::Map {
+    ) -> aya_obj::Map {
-        obj::Map::Legacy(LegacyMap {
+        aya_obj::Map::Legacy(LegacyMap {
             def: bpf_map_def {
                 map_type: map_type as u32,
                 key_size: std::mem::size_of::<K>() as u32,
@@ -1011,17 +1014,15 @@ mod tests {
     use std::os::fd::AsRawFd as _;
 
     use assert_matches::assert_matches;
+    use aya_obj::generated::{bpf_cmd, bpf_map_info, bpf_map_type};
     use libc::{c_char, EFAULT};
 
-    fn new_obj_map() -> obj::Map {
-        test_utils::new_obj_map::<u32>(crate::generated::bpf_map_type::BPF_MAP_TYPE_HASH)
-    }
-
     use super::*;
-    use crate::{
+    use crate::sys::{override_syscall, Syscall};
-        generated::bpf_cmd,
+
-        sys::{override_syscall, Syscall},
+    fn new_obj_map() -> aya_obj::Map {
-    };
+        test_utils::new_obj_map::<u32>(bpf_map_type::BPF_MAP_TYPE_HASH)
+    }
 
     #[test]
     fn test_from_map_id() {
@@ -1093,7 +1094,7 @@ mod tests {
         // Create with max_entries > nr_cpus is clamped to nr_cpus
         assert_matches!(
             MapData::create(test_utils::new_obj_map_with_max_entries::<u32>(
-                crate::generated::bpf_map_type::BPF_MAP_TYPE_PERF_EVENT_ARRAY,
+                bpf_map_type::BPF_MAP_TYPE_PERF_EVENT_ARRAY,
                 65535,
             ), "foo", None),
             Ok(MapData {
@@ -1108,7 +1109,7 @@ mod tests {
         // Create with max_entries = 0 is set to nr_cpus
         assert_matches!(
             MapData::create(test_utils::new_obj_map_with_max_entries::<u32>(
-                crate::generated::bpf_map_type::BPF_MAP_TYPE_PERF_EVENT_ARRAY,
+                bpf_map_type::BPF_MAP_TYPE_PERF_EVENT_ARRAY,
                 0,
             ), "foo", None),
             Ok(MapData {
@@ -1123,7 +1124,7 @@ mod tests {
         // Create with max_entries < nr_cpus is unchanged
         assert_matches!(
             MapData::create(test_utils::new_obj_map_with_max_entries::<u32>(
-                crate::generated::bpf_map_type::BPF_MAP_TYPE_PERF_EVENT_ARRAY,
+                bpf_map_type::BPF_MAP_TYPE_PERF_EVENT_ARRAY,
                 1,
             ), "foo", None),
             Ok(MapData {
@@ -1142,8 +1143,6 @@ mod tests {
         ignore = "`let map_info = unsafe { &mut *(attr.info.info as *mut bpf_map_info) }` is trying to retag from <wildcard> for Unique permission, but no exposed tags have suitable permission in the borrow stack for this location"
     )]
     fn test_name() {
-        use crate::generated::bpf_map_info;
-
         const TEST_NAME: &str = "foo";
 
         override_syscall(|call| match call {
@@ -1178,8 +1177,6 @@ mod tests {
         ignore = "`let map_info = unsafe { &mut *(attr.info.info as *mut bpf_map_info) }` is trying to retag from <wildcard> for Unique permission, but no exposed tags have suitable permission in the borrow stack for this location"
     )]
     fn test_loaded_maps() {
-        use crate::generated::bpf_map_info;
-
         override_syscall(|call| match call {
             Syscall::Ebpf {
                 cmd: bpf_cmd::BPF_MAP_GET_NEXT_ID,

aya/src/maps/perf/perf_buffer.rs

@@ -6,15 +6,15 @@ use std::{
     sync::atomic::{self, AtomicPtr, Ordering},
 };
 
+use aya_obj::generated::{
+    perf_event_header, perf_event_mmap_page,
+    perf_event_type::{PERF_RECORD_LOST, PERF_RECORD_SAMPLE},
+};
 use bytes::BytesMut;
 use libc::{munmap, MAP_FAILED, MAP_SHARED, PROT_READ, PROT_WRITE};
 use thiserror::Error;
 
 use crate::{
-    generated::{
-        perf_event_header, perf_event_mmap_page,
-        perf_event_type::{PERF_RECORD_LOST, PERF_RECORD_SAMPLE},
-    },
     sys::{mmap, perf_event_ioctl, perf_event_open_bpf, SysResult},
     PERF_EVENT_IOC_DISABLE, PERF_EVENT_IOC_ENABLE,
 };

aya/src/maps/ring_buf.rs

@@ -17,10 +17,10 @@ use std::{
     sync::atomic::{AtomicU32, AtomicUsize, Ordering},
 };
 
+use aya_obj::generated::{BPF_RINGBUF_BUSY_BIT, BPF_RINGBUF_DISCARD_BIT, BPF_RINGBUF_HDR_SZ};
 use libc::{munmap, off_t, MAP_FAILED, MAP_SHARED, PROT_READ, PROT_WRITE};
 
 use crate::{
-    generated::{BPF_RINGBUF_BUSY_BIT, BPF_RINGBUF_DISCARD_BIT, BPF_RINGBUF_HDR_SZ},
     maps::{MapData, MapError},
     sys::{mmap, SyscallError},
     util::page_size,

aya/src/programs/cgroup_device.rs

@@ -2,8 +2,11 @@
 
 use std::os::fd::AsFd;
 
+use aya_obj::generated::{
+    bpf_attach_type::BPF_CGROUP_DEVICE, bpf_prog_type::BPF_PROG_TYPE_CGROUP_DEVICE,
+};
+
 use crate::{
-    generated::{bpf_attach_type::BPF_CGROUP_DEVICE, bpf_prog_type::BPF_PROG_TYPE_CGROUP_DEVICE},
     programs::{
         bpf_prog_get_fd_by_id, define_link_wrapper, load_program, query, CgroupAttachMode, FdLink,
         Link, ProgAttachLink, ProgramData, ProgramError, ProgramFd,

aya/src/programs/cgroup_skb.rs

@@ -2,11 +2,12 @@
 
 use std::{hash::Hash, os::fd::AsFd, path::Path};
 
+use aya_obj::generated::{
+    bpf_attach_type::{BPF_CGROUP_INET_EGRESS, BPF_CGROUP_INET_INGRESS},
+    bpf_prog_type::BPF_PROG_TYPE_CGROUP_SKB,
+};
+
 use crate::{
-    generated::{
-        bpf_attach_type::{BPF_CGROUP_INET_EGRESS, BPF_CGROUP_INET_INGRESS},
-        bpf_prog_type::BPF_PROG_TYPE_CGROUP_SKB,
-    },
     programs::{
         define_link_wrapper, load_program, CgroupAttachMode, FdLink, Link, ProgAttachLink,
         ProgramData, ProgramError,

aya/src/programs/cgroup_sock.rs

@@ -2,10 +2,10 @@
 
 use std::{hash::Hash, os::fd::AsFd, path::Path};
 
+use aya_obj::generated::bpf_prog_type::BPF_PROG_TYPE_CGROUP_SOCK;
 pub use aya_obj::programs::CgroupSockAttachType;
 
 use crate::{
-    generated::bpf_prog_type::BPF_PROG_TYPE_CGROUP_SOCK,
     programs::{
         define_link_wrapper, load_program, CgroupAttachMode, FdLink, Link, ProgAttachLink,
         ProgramData, ProgramError,

aya/src/programs/cgroup_sock_addr.rs

@@ -2,10 +2,10 @@
 
 use std::{hash::Hash, os::fd::AsFd, path::Path};
 
+use aya_obj::generated::bpf_prog_type::BPF_PROG_TYPE_CGROUP_SOCK_ADDR;
 pub use aya_obj::programs::CgroupSockAddrAttachType;
 
 use crate::{
-    generated::bpf_prog_type::BPF_PROG_TYPE_CGROUP_SOCK_ADDR,
     programs::{
         define_link_wrapper, load_program, CgroupAttachMode, FdLink, Link, ProgAttachLink,
         ProgramData, ProgramError,

aya/src/programs/cgroup_sockopt.rs

@@ -2,10 +2,10 @@
 
 use std::{hash::Hash, os::fd::AsFd, path::Path};
 
+use aya_obj::generated::bpf_prog_type::BPF_PROG_TYPE_CGROUP_SOCKOPT;
 pub use aya_obj::programs::CgroupSockoptAttachType;
 
 use crate::{
-    generated::bpf_prog_type::BPF_PROG_TYPE_CGROUP_SOCKOPT,
     programs::{
         define_link_wrapper, load_program, CgroupAttachMode, FdLink, Link, ProgAttachLink,
         ProgramData, ProgramError,

aya/src/programs/cgroup_sysctl.rs

@@ -2,8 +2,11 @@
 
 use std::{hash::Hash, os::fd::AsFd};
 
+use aya_obj::generated::{
+    bpf_attach_type::BPF_CGROUP_SYSCTL, bpf_prog_type::BPF_PROG_TYPE_CGROUP_SYSCTL,
+};
+
 use crate::{
-    generated::{bpf_attach_type::BPF_CGROUP_SYSCTL, bpf_prog_type::BPF_PROG_TYPE_CGROUP_SYSCTL},
     programs::{
         define_link_wrapper, load_program, CgroupAttachMode, FdLink, Link, ProgAttachLink,
         ProgramData, ProgramError,

aya/src/programs/extension.rs

@@ -2,12 +2,14 @@
 
 use std::os::fd::{AsFd as _, BorrowedFd};
 
+use aya_obj::{
+    btf::BtfKind,
+    generated::{bpf_attach_type::BPF_CGROUP_INET_INGRESS, bpf_prog_type::BPF_PROG_TYPE_EXT},
+};
 use object::Endianness;
 use thiserror::Error;
 
 use crate::{
-    generated::{bpf_attach_type::BPF_CGROUP_INET_INGRESS, bpf_prog_type::BPF_PROG_TYPE_EXT},
-    obj::btf::BtfKind,
     programs::{
         define_link_wrapper, load_program, FdLink, FdLinkId, ProgramData, ProgramError, ProgramFd,
     },

aya/src/programs/fentry.rs

@@ -1,12 +1,13 @@
 //! Fentry programs.
 
-use crate::{
+use aya_obj::{
+    btf::{Btf, BtfKind},
     generated::{bpf_attach_type::BPF_TRACE_FENTRY, bpf_prog_type::BPF_PROG_TYPE_TRACING},
-    obj::btf::{Btf, BtfKind},
+};
-    programs::{
+
-        define_link_wrapper, load_program, utils::attach_raw_tracepoint, FdLink, FdLinkId,
+use crate::programs::{
-        ProgramData, ProgramError,
+    define_link_wrapper, load_program, utils::attach_raw_tracepoint, FdLink, FdLinkId, ProgramData,
-    },
+    ProgramError,
 };
 
 /// A program that can be attached to the entry point of (almost) any kernel

aya/src/programs/fexit.rs

@@ -1,12 +1,13 @@
 //! Fexit programs.
 
-use crate::{
+use aya_obj::{
+    btf::{Btf, BtfKind},
     generated::{bpf_attach_type::BPF_TRACE_FEXIT, bpf_prog_type::BPF_PROG_TYPE_TRACING},
-    obj::btf::{Btf, BtfKind},
+};
-    programs::{
+
-        define_link_wrapper, load_program, utils::attach_raw_tracepoint, FdLink, FdLinkId,
+use crate::programs::{
-        ProgramData, ProgramError,
+    define_link_wrapper, load_program, utils::attach_raw_tracepoint, FdLink, FdLinkId, ProgramData,
-    },
+    ProgramError,
 };
 
 /// A program that can be attached to the exit point of (almost) anny kernel

aya/src/programs/kprobe.rs

@@ -6,10 +6,10 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use aya_obj::generated::{bpf_link_type, bpf_prog_type::BPF_PROG_TYPE_KPROBE};
 use thiserror::Error;
 
 use crate::{
-    generated::{bpf_link_type, bpf_prog_type::BPF_PROG_TYPE_KPROBE},
     programs::{
         define_link_wrapper, load_program,
         perf_attach::{PerfLinkIdInner, PerfLinkInner},

aya/src/programs/links.rs

@@ -7,13 +7,13 @@ use std::{
     path::{Path, PathBuf},
 };
 
+use aya_obj::generated::{
+    bpf_attach_type, BPF_F_AFTER, BPF_F_ALLOW_MULTI, BPF_F_ALLOW_OVERRIDE, BPF_F_BEFORE, BPF_F_ID,
+    BPF_F_LINK, BPF_F_REPLACE,
+};
 use thiserror::Error;
 
 use crate::{
-    generated::{
-        bpf_attach_type, BPF_F_AFTER, BPF_F_ALLOW_MULTI, BPF_F_ALLOW_OVERRIDE, BPF_F_BEFORE,
-        BPF_F_ID, BPF_F_LINK, BPF_F_REPLACE,
-    },
     pin::PinError,
     programs::{MultiProgLink, MultiProgram, ProgramError, ProgramFd, ProgramId},
     sys::{bpf_get_object, bpf_pin_object, bpf_prog_attach, bpf_prog_detach, SyscallError},
@@ -521,11 +521,11 @@ mod tests {
     use std::{cell::RefCell, fs::File, rc::Rc};
 
     use assert_matches::assert_matches;
+    use aya_obj::generated::{BPF_F_ALLOW_MULTI, BPF_F_ALLOW_OVERRIDE};
     use tempfile::tempdir;
 
     use super::{FdLink, Link, LinkMap};
     use crate::{
-        generated::{BPF_F_ALLOW_MULTI, BPF_F_ALLOW_OVERRIDE},
         programs::{CgroupAttachMode, ProgramError},
         sys::override_syscall,
     };

aya/src/programs/lirc_mode2.rs

@@ -1,8 +1,11 @@
 //! Lirc programs.
 use std::os::fd::{AsFd, AsRawFd as _, RawFd};
 
+use aya_obj::generated::{
+    bpf_attach_type::BPF_LIRC_MODE2, bpf_prog_type::BPF_PROG_TYPE_LIRC_MODE2,
+};
+
 use crate::{
-    generated::{bpf_attach_type::BPF_LIRC_MODE2, bpf_prog_type::BPF_PROG_TYPE_LIRC_MODE2},
     programs::{
         load_program, query, CgroupAttachMode, Link, ProgramData, ProgramError, ProgramFd,
         ProgramInfo,

aya/src/programs/lsm.rs

@@ -1,12 +1,13 @@
 //! LSM probes.
 
-use crate::{
+use aya_obj::{
+    btf::{Btf, BtfKind},
     generated::{bpf_attach_type::BPF_LSM_MAC, bpf_prog_type::BPF_PROG_TYPE_LSM},
-    obj::btf::{Btf, BtfKind},
+};
-    programs::{
+
-        define_link_wrapper, load_program, utils::attach_raw_tracepoint, FdLink, FdLinkId,
+use crate::programs::{
-        ProgramData, ProgramError,
+    define_link_wrapper, load_program, utils::attach_raw_tracepoint, FdLink, FdLinkId, ProgramData,
-    },
+    ProgramError,
 };
 
 /// A program that attaches to Linux LSM hooks. Used to implement security policy and

aya/src/programs/mod.rs

@@ -77,6 +77,11 @@ use std::{
     sync::Arc,
 };
 
+use aya_obj::{
+    btf::BtfError,
+    generated::{bpf_attach_type, bpf_link_info, bpf_prog_info, bpf_prog_type},
+    VerifierLog,
+};
 use info::impl_info;
 pub use info::{loaded_programs, ProgramInfo, ProgramType};
 use libc::ENOSPC;
@@ -113,9 +118,7 @@ pub use crate::programs::{
     xdp::{Xdp, XdpError, XdpFlags},
 };
 use crate::{
-    generated::{bpf_attach_type, bpf_link_info, bpf_prog_info, bpf_prog_type},
     maps::MapError,
-    obj::{self, btf::BtfError, VerifierLog},
     pin::PinError,
     programs::{links::*, perf_attach::*},
     sys::{
@@ -462,7 +465,7 @@ impl Program {
 #[derive(Debug)]
 pub(crate) struct ProgramData<T: Link> {
     pub(crate) name: Option<String>,
-    pub(crate) obj: Option<(obj::Program, obj::Function)>,
+    pub(crate) obj: Option<(aya_obj::Program, aya_obj::Function)>,
     pub(crate) fd: Option<ProgramFd>,
     pub(crate) links: LinkMap<T>,
     pub(crate) expected_attach_type: Option<bpf_attach_type>,
@@ -478,7 +481,7 @@ pub(crate) struct ProgramData<T: Link> {
 impl<T: Link> ProgramData<T> {
     pub(crate) fn new(
         name: Option<String>,
-        obj: (obj::Program, obj::Function),
+        obj: (aya_obj::Program, aya_obj::Function),
         btf_fd: Option<Arc<crate::MockableFd>>,
         verifier_log_level: VerifierLogLevel,
     ) -> Self {
@@ -617,12 +620,12 @@ fn load_program<T: Link>(
     }
     let obj = obj.as_ref().unwrap();
     let (
-        obj::Program {
+        aya_obj::Program {
             license,
             kernel_version,
             ..
         },
-        obj::Function {
+        aya_obj::Function {
             instructions,
             func_info,
             line_info,

aya/src/programs/perf_attach.rs

@@ -1,8 +1,9 @@
 //! Perf attach links.
 use std::os::fd::{AsFd as _, AsRawFd as _, BorrowedFd, RawFd};
 
+use aya_obj::generated::bpf_attach_type::BPF_PERF_EVENT;
+
 use crate::{
-    generated::bpf_attach_type::BPF_PERF_EVENT,
     programs::{
         probe::{detach_debug_fs, ProbeEvent},
         FdLink, Link, ProgramError,

aya/src/programs/perf_event.rs

@@ -2,18 +2,19 @@
 
 use std::os::fd::AsFd as _;
 
-pub use crate::generated::{
+use aya_obj::generated::{
+    bpf_link_type,
+    bpf_prog_type::BPF_PROG_TYPE_PERF_EVENT,
+    perf_type_id::{
+        PERF_TYPE_BREAKPOINT, PERF_TYPE_HARDWARE, PERF_TYPE_HW_CACHE, PERF_TYPE_RAW,
+        PERF_TYPE_SOFTWARE, PERF_TYPE_TRACEPOINT,
+    },
+};
+pub use aya_obj::generated::{
     perf_hw_cache_id, perf_hw_cache_op_id, perf_hw_cache_op_result_id, perf_hw_id, perf_sw_ids,
 };
+
 use crate::{
-    generated::{
-        bpf_link_type,
-        bpf_prog_type::BPF_PROG_TYPE_PERF_EVENT,
-        perf_type_id::{
-            PERF_TYPE_BREAKPOINT, PERF_TYPE_HARDWARE, PERF_TYPE_HW_CACHE, PERF_TYPE_RAW,
-            PERF_TYPE_SOFTWARE, PERF_TYPE_TRACEPOINT,
-        },
-    },
     programs::{
         links::define_link_wrapper,
         load_program, perf_attach,

aya/src/programs/raw_trace_point.rs

@@ -1,12 +1,11 @@
 //! Raw tracepoints.
 use std::ffi::CString;
 
-use crate::{
+use aya_obj::generated::bpf_prog_type::BPF_PROG_TYPE_RAW_TRACEPOINT;
-    generated::bpf_prog_type::BPF_PROG_TYPE_RAW_TRACEPOINT,
+
-    programs::{
+use crate::programs::{
-        define_link_wrapper, load_program, utils::attach_raw_tracepoint, FdLink, FdLinkId,
+    define_link_wrapper, load_program, utils::attach_raw_tracepoint, FdLink, FdLinkId, ProgramData,
-        ProgramData, ProgramError,
+    ProgramError,
-    },
 };
 
 /// A program that can be attached at a pre-defined kernel trace point.

aya/src/programs/sk_lookup.rs

@@ -1,9 +1,10 @@
 //! Programmable socket lookup.
 use std::os::fd::AsFd;
 
+use aya_obj::generated::{bpf_attach_type::BPF_SK_LOOKUP, bpf_prog_type::BPF_PROG_TYPE_SK_LOOKUP};
+
 use super::links::FdLink;
 use crate::{
-    generated::{bpf_attach_type::BPF_SK_LOOKUP, bpf_prog_type::BPF_PROG_TYPE_SK_LOOKUP},
     programs::{define_link_wrapper, load_program, FdLinkId, ProgramData, ProgramError},
     sys::{bpf_link_create, LinkTarget, SyscallError},
 };

aya/src/programs/sk_msg.rs

@@ -2,8 +2,11 @@
 
 use std::os::fd::AsFd as _;
 
+use aya_obj::generated::{
+    bpf_attach_type::BPF_SK_MSG_VERDICT, bpf_prog_type::BPF_PROG_TYPE_SK_MSG,
+};
+
 use crate::{
-    generated::{bpf_attach_type::BPF_SK_MSG_VERDICT, bpf_prog_type::BPF_PROG_TYPE_SK_MSG},
     maps::sock::SockMapFd,
     programs::{
         define_link_wrapper, load_program, CgroupAttachMode, ProgAttachLink, ProgAttachLinkId,

aya/src/programs/sk_skb.rs

@@ -2,11 +2,12 @@
 
 use std::{os::fd::AsFd as _, path::Path};
 
+use aya_obj::generated::{
+    bpf_attach_type::{BPF_SK_SKB_STREAM_PARSER, BPF_SK_SKB_STREAM_VERDICT},
+    bpf_prog_type::BPF_PROG_TYPE_SK_SKB,
+};
+
 use crate::{
-    generated::{
-        bpf_attach_type::{BPF_SK_SKB_STREAM_PARSER, BPF_SK_SKB_STREAM_VERDICT},
-        bpf_prog_type::BPF_PROG_TYPE_SK_SKB,
-    },
     maps::sock::SockMapFd,
     programs::{
         define_link_wrapper, load_program, CgroupAttachMode, ProgAttachLink, ProgAttachLinkId,

aya/src/programs/sock_ops.rs

@@ -1,8 +1,11 @@
 //! Socket option programs.
 use std::os::fd::AsFd;
 
+use aya_obj::generated::{
+    bpf_attach_type::BPF_CGROUP_SOCK_OPS, bpf_prog_type::BPF_PROG_TYPE_SOCK_OPS,
+};
+
 use crate::{
-    generated::{bpf_attach_type::BPF_CGROUP_SOCK_OPS, bpf_prog_type::BPF_PROG_TYPE_SOCK_OPS},
     programs::{
         define_link_wrapper, load_program, CgroupAttachMode, FdLink, Link, ProgAttachLink,
         ProgramData, ProgramError,

aya/src/programs/socket_filter.rs

@@ -4,13 +4,13 @@ use std::{
     os::fd::{AsFd, AsRawFd, RawFd},
 };
 
+use aya_obj::generated::{
+    bpf_prog_type::BPF_PROG_TYPE_SOCKET_FILTER, SO_ATTACH_BPF, SO_DETACH_BPF,
+};
 use libc::{setsockopt, SOL_SOCKET};
 use thiserror::Error;
 
-use crate::{
+use crate::programs::{load_program, Link, ProgramData, ProgramError};
-    generated::{bpf_prog_type::BPF_PROG_TYPE_SOCKET_FILTER, SO_ATTACH_BPF, SO_DETACH_BPF},
-    programs::{load_program, Link, ProgramData, ProgramError},
-};
 
 /// The type returned when attaching a [`SocketFilter`] fails.
 #[derive(Debug, Error)]

aya/src/programs/tc.rs

@@ -6,16 +6,16 @@ use std::{
     path::Path,
 };
 
+use aya_obj::generated::{
+    bpf_attach_type::{self, BPF_TCX_EGRESS, BPF_TCX_INGRESS},
+    bpf_link_type,
+    bpf_prog_type::BPF_PROG_TYPE_SCHED_CLS,
+    TC_H_CLSACT, TC_H_MIN_EGRESS, TC_H_MIN_INGRESS,
+};
 use thiserror::Error;
 
 use super::{FdLink, ProgramInfo};
 use crate::{
-    generated::{
-        bpf_attach_type::{self, BPF_TCX_EGRESS, BPF_TCX_INGRESS},
-        bpf_link_type,
-        bpf_prog_type::BPF_PROG_TYPE_SCHED_CLS,
-        TC_H_CLSACT, TC_H_MIN_EGRESS, TC_H_MIN_INGRESS,
-    },
     programs::{
         define_link_wrapper, load_program, query, Link, LinkError, LinkOrder, ProgramData,
         ProgramError,

aya/src/programs/tp_btf.rs

@@ -1,12 +1,13 @@
 //! BTF-enabled raw tracepoints.
 
-use crate::{
+use aya_obj::{
+    btf::{Btf, BtfKind},
     generated::{bpf_attach_type::BPF_TRACE_RAW_TP, bpf_prog_type::BPF_PROG_TYPE_TRACING},
-    obj::btf::{Btf, BtfKind},
+};
-    programs::{
+
-        define_link_wrapper, load_program, utils::attach_raw_tracepoint, FdLink, FdLinkId,
+use crate::programs::{
-        ProgramData, ProgramError,
+    define_link_wrapper, load_program, utils::attach_raw_tracepoint, FdLink, FdLinkId, ProgramData,
-    },
+    ProgramError,
 };
 
 /// Marks a function as a [BTF-enabled raw tracepoint][1] eBPF program that can be attached at

aya/src/programs/trace_point.rs

@@ -1,10 +1,10 @@
 //! Tracepoint programs.
 use std::{fs, io, os::fd::AsFd as _, path::Path};
 
+use aya_obj::generated::{bpf_link_type, bpf_prog_type::BPF_PROG_TYPE_TRACEPOINT};
 use thiserror::Error;
 
 use crate::{
-    generated::{bpf_link_type, bpf_prog_type::BPF_PROG_TYPE_TRACEPOINT},
     programs::{
         define_link_wrapper, load_program,
         perf_attach::{perf_attach, PerfLinkIdInner, PerfLinkInner},

aya/src/programs/uprobe.rs

@@ -11,12 +11,12 @@ use std::{
     sync::LazyLock,
 };
 
+use aya_obj::generated::{bpf_link_type, bpf_prog_type::BPF_PROG_TYPE_KPROBE};
 use libc::pid_t;
 use object::{Object, ObjectSection, ObjectSymbol, Symbol};
 use thiserror::Error;
 
 use crate::{
-    generated::{bpf_link_type, bpf_prog_type::BPF_PROG_TYPE_KPROBE},
     programs::{
         define_link_wrapper, load_program,
         perf_attach::{PerfLinkIdInner, PerfLinkInner},

aya/src/programs/xdp.rs

@@ -8,15 +8,17 @@ use std::{
     path::Path,
 };
 
-use libc::if_nametoindex;
+use aya_obj::{
-use thiserror::Error;
-
-use crate::{
     generated::{
         bpf_link_type, bpf_prog_type, XDP_FLAGS_DRV_MODE, XDP_FLAGS_HW_MODE, XDP_FLAGS_REPLACE,
         XDP_FLAGS_SKB_MODE, XDP_FLAGS_UPDATE_IF_NOEXIST,
     },
-    obj::programs::XdpAttachType,
+    programs::XdpAttachType,
+};
+use libc::if_nametoindex;
+use thiserror::Error;
+
+use crate::{
     programs::{
         define_link_wrapper, load_program, FdLink, Link, LinkError, ProgramData, ProgramError,
     },

aya/src/sys/bpf.rs

@@ -8,28 +8,24 @@ use std::{
 };
 
 use assert_matches::assert_matches;
-use libc::{ENOENT, ENOSPC};
+use aya_obj::{
-use obj::{
+    btf::{
-    btf::{BtfEnum64, Enum64},
+        BtfEnum64, BtfParam, BtfType, DataSec, DataSecEntry, DeclTag, Enum64, Float, Func,
-    generated::bpf_stats_type,
+        FuncLinkage, FuncProto, FuncSecInfo, Int, IntEncoding, LineSecInfo, Ptr, TypeTag, Var,
+        VarLinkage,
+    },
+    copy_instructions,
+    generated::{
+        bpf_attach_type, bpf_attr, bpf_btf_info, bpf_cmd, bpf_insn, bpf_link_info, bpf_map_info,
+        bpf_map_type, bpf_prog_info, bpf_prog_type, bpf_stats_type, BPF_F_REPLACE,
+    },
     maps::{bpf_map_def, LegacyMap},
     EbpfSectionKind, VerifierLog,
 };
+use libc::{ENOENT, ENOSPC};
 
 use crate::{
-    generated::{
-        bpf_attach_type, bpf_attr, bpf_btf_info, bpf_cmd, bpf_insn, bpf_link_info, bpf_map_info,
-        bpf_map_type, bpf_prog_info, bpf_prog_type, BPF_F_REPLACE,
-    },
     maps::{MapData, PerCpuValues},
-    obj::{
-        self,
-        btf::{
-            BtfParam, BtfType, DataSec, DataSecEntry, DeclTag, Float, Func, FuncLinkage, FuncProto,
-            FuncSecInfo, Int, IntEncoding, LineSecInfo, Ptr, TypeTag, Var, VarLinkage,
-        },
-        copy_instructions,
-    },
     programs::links::LinkRef,
     sys::{syscall, SysResult, Syscall, SyscallError},
     util::KernelVersion,
@@ -38,7 +34,7 @@ use crate::{
 
 pub(crate) fn bpf_create_map(
     name: &CStr,
-    def: &obj::Map,
+    def: &aya_obj::Map,
     btf_fd: Option<BorrowedFd<'_>>,
     kernel_version: KernelVersion,
 ) -> SysResult<crate::MockableFd> {
@@ -51,7 +47,7 @@ pub(crate) fn bpf_create_map(
     u.max_entries = def.max_entries();
     u.map_flags = def.map_flags();
 
-    if let obj::Map::Btf(m) = def {
+    if let aya_obj::Map::Btf(m) = def {
         use bpf_map_type::*;
 
         // Mimic https://github.com/libbpf/libbpf/issues/355
@@ -901,7 +897,7 @@ pub(crate) fn is_bpf_global_data_supported() -> bool {
     let mut insns = copy_instructions(prog).unwrap();
 
     let map = MapData::create(
-        obj::Map::Legacy(LegacyMap {
+        aya_obj::Map::Legacy(LegacyMap {
             def: bpf_map_def {
                 map_type: bpf_map_type::BPF_MAP_TYPE_ARRAY as u32,
                 key_size: 4,

aya/src/sys/mod.rs

@@ -13,6 +13,7 @@ use std::{
     os::fd::{AsRawFd as _, BorrowedFd, OwnedFd},
 };
 
+use aya_obj::generated::{bpf_attr, bpf_cmd, perf_event_attr};
 pub(crate) use bpf::*;
 #[cfg(test)]
 pub(crate) use fake::*;
@@ -23,8 +24,6 @@ pub(crate) use netlink::*;
 pub(crate) use perf_event::*;
 use thiserror::Error;
 
-use crate::generated::{bpf_attr, bpf_cmd, perf_event_attr};
-
 pub(crate) type SysResult<T> = Result<T, (i64, io::Error)>;
 
 pub(crate) enum Syscall<'a> {
@@ -152,9 +151,9 @@ pub enum Stats {
     RunTime,
 }
 
-impl From<Stats> for crate::generated::bpf_stats_type {
+impl From<Stats> for aya_obj::generated::bpf_stats_type {
     fn from(value: Stats) -> Self {
-        use crate::generated::bpf_stats_type::*;
+        use aya_obj::generated::bpf_stats_type::*;
 
         match value {
             Stats::RunTime => BPF_STATS_RUN_TIME,

aya/src/sys/netlink.rs

@@ -6,6 +6,11 @@ use std::{
     ptr, slice,
 };
 
+use aya_obj::generated::{
+    ifinfomsg, tcmsg, IFLA_XDP_EXPECTED_FD, IFLA_XDP_FD, IFLA_XDP_FLAGS, NLMSG_ALIGNTO, TCA_BPF_FD,
+    TCA_BPF_FLAGS, TCA_BPF_FLAG_ACT_DIRECT, TCA_BPF_NAME, TCA_KIND, TCA_OPTIONS, TC_H_CLSACT,
+    TC_H_INGRESS, TC_H_MAJ_MASK, TC_H_UNSPEC, XDP_FLAGS_REPLACE,
+};
 use libc::{
     getsockname, nlattr, nlmsgerr, nlmsghdr, recv, send, setsockopt, sockaddr_nl, socket,
     AF_NETLINK, AF_UNSPEC, ETH_P_ALL, IFF_UP, IFLA_XDP, NETLINK_EXT_ACK, NETLINK_ROUTE,
@@ -15,15 +20,7 @@ use libc::{
 };
 use thiserror::Error;
 
-use crate::{
+use crate::{programs::TcAttachType, util::tc_handler_make};
-    generated::{
-        ifinfomsg, tcmsg, IFLA_XDP_EXPECTED_FD, IFLA_XDP_FD, IFLA_XDP_FLAGS, NLMSG_ALIGNTO,
-        TCA_BPF_FD, TCA_BPF_FLAGS, TCA_BPF_FLAG_ACT_DIRECT, TCA_BPF_NAME, TCA_KIND, TCA_OPTIONS,
-        TC_H_CLSACT, TC_H_INGRESS, TC_H_MAJ_MASK, TC_H_UNSPEC, XDP_FLAGS_REPLACE,
-    },
-    programs::TcAttachType,
-    util::tc_handler_make,
-};
 
 const NLA_HDR_LEN: usize = align_to(mem::size_of::<nlattr>(), NLA_ALIGNTO as usize);
 

aya/src/sys/perf_event.rs

@@ -4,16 +4,16 @@ use std::{
     os::fd::{BorrowedFd, FromRawFd as _},
 };
 
-use libc::pid_t;
+use aya_obj::generated::{
-
-use super::{syscall, SysResult, Syscall};
-use crate::generated::{
     perf_event_attr,
     perf_event_sample_format::PERF_SAMPLE_RAW,
     perf_sw_ids::PERF_COUNT_SW_BPF_OUTPUT,
     perf_type_id::{PERF_TYPE_SOFTWARE, PERF_TYPE_TRACEPOINT},
     PERF_FLAG_FD_CLOEXEC,
 };
+use libc::pid_t;
+
+use super::{syscall, SysResult, Syscall};
 
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn perf_event_open(

aya/src/util.rs

@@ -12,12 +12,10 @@ use std::{
     str::{FromStr, Utf8Error},
 };
 
+use aya_obj::generated::{TC_H_MAJ_MASK, TC_H_MIN_MASK};
 use libc::{if_nametoindex, sysconf, uname, utsname, _SC_PAGESIZE};
 
-use crate::{
+use crate::Pod;
-    generated::{TC_H_MAJ_MASK, TC_H_MIN_MASK},
-    Pod,
-};
 
 /// Represents a kernel version, in major.minor.release version.
 // Adapted from https://docs.rs/procfs/latest/procfs/sys/kernel/struct.Version.html.