ip li add name type dummy_rs working

Signed-off-by: Finn Behrens <[email protected]>

Author: kloenk

Diff for: drivers/net/dummy_rs.rs

@@ -39,6 +39,8 @@ fn setup(dev: &mut NetDevice<DummyRsDev>) {
     pr_info!("called rtnl_setup");
     dev.ether_setup();
 
+    dev.set_ops();
+
     // Fill in device structure with ethernet-generic values.
     dev.add_flag(device::Iff::NOARP);
     dev.remove_flag(device::Iff::MULTICAST);
@@ -62,8 +64,13 @@ fn setup(dev: &mut NetDevice<DummyRsDev>) {
     dev.set_hw_features(feature);
     dev.set_hw_enc_features(feature);
 
+    pr_info!("setting hw addr random");
     dev.hw_addr_random();
+    pr_info!("set hw addr");
     dev.set_mtu(0, 0);
+
+    pr_info!("printing rtnl_link_ops");
+    pr_info!("rtnl_link_ops_after_setup_ptr: {:?}", dev.deref().rtnl_link_ops);
 }
 
 fn validate(tb: &NlAttrVec, data: &NlAttrVec, ext_ack: &NlExtAck) -> KernelResult<()> {
@@ -101,10 +108,12 @@ impl KernelModule for RustNetDummy {
             pr_info!("Rust Network Dummy with {} pseudo devices\n", numdummies.read(&lock));
         }
 
-        unsafe { dummy_rs_rtnl_link_ops.register() }?;
+        unsafe { dummy_rs_link_ops.register() }?;
 
         let mut dev = NetDevice::new(DummyRsDev, kernel::cstr!("dummyrs%d"), kernel::net::device::NetNameAssingType::Enum, 1, 1)?;
-        dev.set_rtnl_ops( unsafe { &dummy_rs_rtnl_link_ops });
+        dev.set_rtnl_ops( unsafe { &dummy_rs_link_ops });
+
+        pr_info!("rtnl_link_ops_set_ptr: {:?}", dev.deref().rtnl_link_ops);
 
         if let Err(e) = dev.register() {
             pr_warn!("could not register: {}", e.to_kernel_errno());
@@ -125,13 +134,13 @@ impl Drop for RustNetDummy {
 
         unsafe {
             //let ptr = &dummy_rs_rtnl_link_ops as *const _ as *mut kernel::bindings::rtnl_link_ops;
-            pr_info!("rtnl: {:#?}", &dummy_rs_rtnl_link_ops.0);
-            let ptr = &dummy_rs_rtnl_link_ops.get_ptr();
+            pr_info!("rtnl: {:#?}", &dummy_rs_link_ops.0);
+            let ptr = &dummy_rs_link_ops.get_ptr();
             pr_info!("rtnl_link_ops_ptr: {:?}", ptr);
         }
         // TODO rtnl_link_unregister
         // TODO: remove unsafe somehow
-        unsafe { dummy_rs_rtnl_link_ops.unregister() };
+        unsafe { dummy_rs_link_ops.unregister() };
     }
 }
 

Diff for: rust/kernel/net/device.rs

@@ -54,9 +54,9 @@ pub enum NetNameAssingType {
 unsafe extern "C" fn setup_netdev_callback<T: NetDeviceAdapter>(dev: *mut bindings::net_device) {
     // TODO: pass on dev
     let mut dev = NetDevice::<T>::from_ptr(dev);
-    dev.needs_free_netdev = true; // TODO: is this reasonable?
+    /*dev.needs_free_netdev = true; // TODO: is this reasonable?
     dev.netdev_ops = NetDeviceOperationsVtable::<T>::build();
-    dev.ethtool_ops = super::ethtool::EthToolOperationsVtable::<T>::build();
+    dev.ethtool_ops = super::ethtool::EthToolOperationsVtable::<T>::build();*/
 
     T::setup(&mut dev);
 }
@@ -336,6 +336,14 @@ impl<T: NetDeviceAdapter> NetDevice<T> {
         }
     }
 
+    pub fn set_ops(&mut self) {
+        self.needs_free_netdev = true; // TODO: is this reasonable?
+        unsafe {
+            self.netdev_ops = NetDeviceOperationsVtable::<T>::build();
+            self.ethtool_ops = super::ethtool::EthToolOperationsVtable::<T>::build();
+        }
+    }
+
     /// Constructs a new [`struct net_device`] wrapper.
     ///
     /// # Safety

Diff for: rust/kernel/net/rtnl.rs

@@ -103,6 +103,12 @@ impl RtnlLinkOps {
     }
 }
 
+impl Drop for RtnlLinkOps {
+    fn drop(&mut self) {
+        crate::pr_info!("dropping rtnl_link_ops");
+    }
+}
+
 #[repr(transparent)]
 pub struct RtnlLinkStats64 {
     ptr: *const bindings::rtnl_link_stats64

Diff for: rust/module.rs

@@ -103,6 +103,14 @@ fn expect_end(it: &mut token_stream::IntoIter) {
     }
 }
 
+fn get_ident(it: &mut token_stream::IntoIter, expected_name: &str) -> String {
+    assert_eq!(expect_ident(it), expected_name);
+    assert_eq!(expect_punct(it), ':');
+    let ident = expect_ident(it);
+    assert_eq!(expect_punct(it), ',');
+    ident
+}
+
 fn get_literal(it: &mut token_stream::IntoIter, expected_name: &str) -> String {
     assert_eq!(expect_ident(it), expected_name);
     assert_eq!(expect_punct(it), ':');
@@ -951,7 +959,8 @@ pub fn rtnl_link_ops(ts: TokenStream) -> TokenStream {
     let ops_struct = format!(r#"
             #[doc(hidden)]
             #[used]
-            pub static mut {kind}_rtnl_link_ops: kernel::net::rtnl::RtnlLinkOps = kernel::net::rtnl::RtnlLinkOps(kernel::bindings::rtnl_link_ops {{
+            #[no_mangle]
+            pub static mut {kind}_link_ops: kernel::net::rtnl::RtnlLinkOps = kernel::net::rtnl::RtnlLinkOps(kernel::bindings::rtnl_link_ops {{
                 priv_size: core::mem::size_of::<<{netdevice} as kernel::net::device::NetDeviceAdapter>::Inner>(),
                 kind: b"{kind}\0".as_ptr() as *const i8,
                 {callback_fields}