Implement epoll_data union

kellda · kellda · commit 22623e1b173b · 2025-07-05T10:45:03.000+02:00
diff --git a/libc-test/build.rs b/libc-test/build.rs
@@ -1098,8 +1098,6 @@ fn test_solarish(target: &str) {
 
     cfg.field_name(move |struct_, field| {
         match struct_ {
-            // rust struct uses raw u64, rather than union
-            "epoll_event" if field == "u64" => "data.u64".to_string(),
             // rust struct was committed with typo for Solaris
             "door_arg_t" if field == "dec_num" => "desc_num".to_string(),
             "stat" if field.ends_with("_nsec") => {
@@ -1372,7 +1370,6 @@ fn test_netbsd(target: &str) {
             s if s.ends_with("_nsec") && struct_.starts_with("stat") => {
                 s.replace("e_nsec", ".tv_nsec")
             }
-            "u64" if struct_ == "epoll_event" => "data.u64".to_string(),
             s => s.to_string(),
         }
     });
@@ -1583,7 +1580,6 @@ fn test_dragonflybsd(target: &str) {
             s if s.ends_with("_nsec") && struct_.starts_with("stat") => {
                 s.replace("e_nsec", ".tv_nsec")
             }
-            "u64" if struct_ == "epoll_event" => "data.u64".to_string(),
             // Field is named `type` in C but that is a Rust keyword,
             // so these fields are translated to `type_` in the bindings.
             "type_" if struct_ == "rtprio" => "type".to_string(),
@@ -1965,8 +1961,6 @@ fn test_android(target: &str) {
             // Our stat *_nsec fields normally don't actually exist but are part
             // of a timeval struct
             s if s.ends_with("_nsec") && struct_.starts_with("stat") => s.to_string(),
-            // FIXME(union): appears that `epoll_event.data` is an union
-            "u64" if struct_ == "epoll_event" => "data.u64".to_string(),
             // The following structs have a field called `type` in C,
             // but `type` is a Rust keyword, so these fields are translated
             // to `type_` in Rust.
@@ -3063,8 +3057,6 @@ fn test_emscripten(target: &str) {
             s if s.ends_with("_nsec") && struct_.starts_with("stat") => {
                 s.replace("e_nsec", ".tv_nsec")
             }
-            // Rust struct uses raw u64, rather than union
-            "u64" if struct_ == "epoll_event" => "data.u64".to_string(),
             s => s.to_string(),
         }
     });
@@ -3873,10 +3865,6 @@ fn test_linux(target: &str) {
             s if s.ends_with("_nsec") && struct_.starts_with("stat") => {
                 s.replace("e_nsec", ".tv_nsec")
             }
-            // FIXME(linux): epoll_event.data is actually a union in C, but in Rust
-            // it is only a u64 because we only expose one field
-            // http://man7.org/linux/man-pages/man2/epoll_wait.2.html
-            "u64" if struct_ == "epoll_event" => "data.u64".to_string(),
             // The following structs have a field called `type` in C,
             // but `type` is a Rust keyword, so these fields are translated
             // to `type_` in Rust.
diff --git a/src/fuchsia/mod.rs b/src/fuchsia/mod.rs
@@ -408,7 +408,7 @@ s! {
 
     pub struct epoll_event {
         pub events: u32,
-        pub u64: u64,
+        pub data: epoll_data,
     }
 
     pub struct lconv {
@@ -1044,6 +1044,13 @@ s_no_extra_traits! {
         pub sival_ptr: *mut c_void,
     }
 
+    pub union epoll_data {
+        pub ptr: *mut c_void,
+        pub fd: c_int,
+        pub u32: u32,
+        pub u64: u64,
+    }
+
     pub union __c_anonymous_ifa_ifu {
         ifu_broadaddr: *mut sockaddr,
         ifu_dstaddr: *mut sockaddr,
@@ -1312,25 +1319,37 @@ cfg_if! {
         }
 
         impl PartialEq for sigval {
-            fn eq(&self, other: &sigval) -> bool {
+            fn eq(&self, _other: &sigval) -> bool {
                 unimplemented!("traits")
             }
         }
         impl Eq for sigval {}
         impl hash::Hash for sigval {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
+            fn hash<H: hash::Hasher>(&self, _state: &mut H) {
+                unimplemented!("traits")
+            }
+        }
+
+        impl PartialEq for epoll_data {
+            fn eq(&self, _other: &sigval) -> bool {
+                unimplemented!("traits")
+            }
+        }
+        impl Eq for epoll_data {}
+        impl hash::Hash for epoll_data {
+            fn hash<H: hash::Hasher>(&self, _state: &mut H) {
                 unimplemented!("traits")
             }
         }
 
         impl PartialEq for __c_anonymous_ifa_ifu {
-            fn eq(&self, other: &__c_anonymous_ifa_ifu) -> bool {
+            fn eq(&self, _other: &__c_anonymous_ifa_ifu) -> bool {
                 unimplemented!("traits")
             }
         }
         impl Eq for __c_anonymous_ifa_ifu {}
         impl hash::Hash for __c_anonymous_ifa_ifu {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
+            fn hash<H: hash::Hasher>(&self, _state: &mut H) {
                 unimplemented!("traits")
             }
         }
diff --git a/src/unix/linux_like/mod.rs b/src/unix/linux_like/mod.rs
@@ -293,6 +293,13 @@ s_no_extra_traits! {
     )]
     pub struct epoll_event {
         pub events: u32,
+        pub data: epoll_data,
+    }
+
+    pub union epoll_data {
+        pub ptr: *mut c_void,
+        pub fd: c_int,
+        pub u32: u32,
         pub u64: u64,
     }
 
@@ -341,17 +348,29 @@ s_no_extra_traits! {
 cfg_if! {
     if #[cfg(feature = "extra_traits")] {
         impl PartialEq for epoll_event {
-            fn eq(&self, other: &epoll_event) -> bool {
-                self.events == other.events && self.u64 == other.u64
+            fn eq(&self, _other: &epoll_event) -> bool {
+                unimplemented!("traits")
             }
         }
         impl Eq for epoll_event {}
         impl hash::Hash for epoll_event {
             fn hash<H: hash::Hasher>(&self, state: &mut H) {
                 let events = self.events;
-                let u64 = self.u64;
+                let data = self.data;
                 events.hash(state);
-                u64.hash(state);
+                data.hash(state);
+            }
+        }
+
+        impl PartialEq for epoll_data {
+            fn eq(&self, _other: &epoll_data) -> bool {
+                unimplemented!("traits")
+            }
+        }
+        impl Eq for epoll_data {}
+        impl hash::Hash for epoll_data {
+            fn hash<H: hash::Hasher>(&self, _state: &mut H) {
+                unimplemented!("traits")
             }
         }
 
@@ -441,13 +460,13 @@ cfg_if! {
         }
 
         impl PartialEq for __c_anonymous_ifa_ifu {
-            fn eq(&self, other: &__c_anonymous_ifa_ifu) -> bool {
+            fn eq(&self, _other: &__c_anonymous_ifa_ifu) -> bool {
                 unimplemented!("traits")
             }
         }
         impl Eq for __c_anonymous_ifa_ifu {}
         impl hash::Hash for __c_anonymous_ifa_ifu {
-            fn hash<H: hash::Hasher>(&self, state: &mut H) {
+            fn hash<H: hash::Hasher>(&self, _state: &mut H) {
                 unimplemented!("traits")
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -408,7 +408,7 @@ s! {`
`408`	`408`
`409`	`409`	`pub struct epoll_event {`
`410`	`410`	`pub events: u32,`
`411`		`- pub u64: u64,`
	`411`	`+ pub data: epoll_data,`
`412`	`412`	`}`
`413`	`413`
`414`	`414`	`pub struct lconv {`
`@@ -1044,6 +1044,13 @@ s_no_extra_traits! {`
`1044`	`1044`	`pub sival_ptr: *mut c_void,`
`1045`	`1045`	`}`
`1046`	`1046`
	`1047`	`+ pub union epoll_data {`
	`1048`	`+ pub ptr: *mut c_void,`
	`1049`	`+ pub fd: c_int,`
	`1050`	`+ pub u32: u32,`
	`1051`	`+ pub u64: u64,`
	`1052`	`+ }`
	`1053`	`+`
`1047`	`1054`	`pub union __c_anonymous_ifa_ifu {`
`1048`	`1055`	`ifu_broadaddr: *mut sockaddr,`
`1049`	`1056`	`ifu_dstaddr: *mut sockaddr,`
`@@ -1312,25 +1319,37 @@ cfg_if! {`
`1312`	`1319`	`}`
`1313`	`1320`
`1314`	`1321`	`impl PartialEq for sigval {`
`1315`		`- fn eq(&self, other: &sigval) -> bool {`
	`1322`	`+ fn eq(&self, _other: &sigval) -> bool {`
`1316`	`1323`	`unimplemented!("traits")`
`1317`	`1324`	`}`
`1318`	`1325`	`}`
`1319`	`1326`	`impl Eq for sigval {}`
`1320`	`1327`	`impl hash::Hash for sigval {`
`1321`		`- fn hash<H: hash::Hasher>(&self, state: &mut H) {`
	`1328`	`+ fn hash<H: hash::Hasher>(&self, _state: &mut H) {`
	`1329`	`+ unimplemented!("traits")`
	`1330`	`+ }`
	`1331`	`+ }`
	`1332`	`+`
	`1333`	`+ impl PartialEq for epoll_data {`
	`1334`	`+ fn eq(&self, _other: &sigval) -> bool {`
	`1335`	`+ unimplemented!("traits")`
	`1336`	`+ }`
	`1337`	`+ }`
	`1338`	`+ impl Eq for epoll_data {}`
	`1339`	`+ impl hash::Hash for epoll_data {`
	`1340`	`+ fn hash<H: hash::Hasher>(&self, _state: &mut H) {`
`1322`	`1341`	`unimplemented!("traits")`
`1323`	`1342`	`}`
`1324`	`1343`	`}`
`1325`	`1344`
`1326`	`1345`	`impl PartialEq for __c_anonymous_ifa_ifu {`
`1327`		`- fn eq(&self, other: &__c_anonymous_ifa_ifu) -> bool {`
	`1346`	`+ fn eq(&self, _other: &__c_anonymous_ifa_ifu) -> bool {`
`1328`	`1347`	`unimplemented!("traits")`
`1329`	`1348`	`}`
`1330`	`1349`	`}`
`1331`	`1350`	`impl Eq for __c_anonymous_ifa_ifu {}`
`1332`	`1351`	`impl hash::Hash for __c_anonymous_ifa_ifu {`
`1333`		`- fn hash<H: hash::Hasher>(&self, state: &mut H) {`
	`1352`	`+ fn hash<H: hash::Hasher>(&self, _state: &mut H) {`
`1334`	`1353`	`unimplemented!("traits")`
`1335`	`1354`	`}`
`1336`	`1355`	`}`