fn load()

in src/bpf/pid_iter.skel.rs [3327:3363]
34 lines of code
2 McCabe index (conditional complexity)

        fn load(self) -> libbpf_rs::Result<PidIterSkel<'obj>> {
            let skel_ptr = self.skel_config.as_libbpf_object().as_ptr();

            let ret = unsafe { libbpf_sys::bpf_object__load_skeleton(skel_ptr) };
            if ret != 0 {
                return Err(libbpf_rs::Error::from_raw_os_error(-ret));
            }

            let obj_ref = self.obj.take();
            let open_obj = std::mem::replace(obj_ref, std::mem::MaybeUninit::uninit());
            // SAFETY: `open_obj` is guaranteed to be properly
            //         initialized as it came from an `OwnedRef`.
            let obj_ptr = unsafe { open_obj.assume_init().take_ptr() };
            // SAFETY: `obj_ptr` points to a loaded object after
            //         skeleton load.
            let obj = unsafe { libbpf_rs::Object::from_ptr(obj_ptr) };
            // SAFETY: `OpenObject` and `Object` are guaranteed to
            //         have the same memory layout.
            let obj_ref = unsafe {
                std::mem::transmute::<
                    &'obj mut std::mem::MaybeUninit<libbpf_rs::OpenObject>,
                    &'obj mut std::mem::MaybeUninit<libbpf_rs::Object>,
                >(obj_ref)
            };
            let _obj = obj_ref.write(obj);
            // SAFETY: We just wrote initialized data to `obj_ref`.
            let mut obj_ref = unsafe { OwnedRef::new(obj_ref) };

            Ok(PidIterSkel {
                maps: unsafe { PidIterMaps::new(&self.skel_config, obj_ref.as_mut())? },
                progs: PidIterProgs::new(self.progs),
                obj: obj_ref,
                struct_ops: self.struct_ops,
                skel_config: self.skel_config,
                links: PidIterLinks::default(),
            })
        }