Implement epoll_data union

Author: kellda

libc-test/build.rs

@@ -670,8 +670,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") => {
@@ -896,7 +894,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(),
         }
     });
@@ -1098,7 +1095,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(),
@@ -1428,8 +1424,6 @@ fn test_android(target: &str) {
             s if s.ends_with("_nsec") && struct_.starts_with("stat") => {
                 s.to_string()
             }
-            // FIXME: appears that `epoll_event.data` is an union
-            "u64" if struct_ == "epoll_event" => "data.u64".to_string(),
             s => s.to_string(),
         }
     });
@@ -1965,8 +1959,6 @@ fn test_emscripten(target: &str) {
             s if s.ends_with("_nsec") && struct_.starts_with("stat") => {
                 s.replace("e_nsec", ".tv_nsec")
             }
-            // FIXME: appears that `epoll_event.data` is an union
-            "u64" if struct_ == "epoll_event" => "data.u64".to_string(),
             s => s.to_string(),
         }
     });
@@ -2399,10 +2391,6 @@ fn test_linux(target: &str) {
             s if s.ends_with("_nsec") && struct_.starts_with("stat") => {
                 s.replace("e_nsec", ".tv_nsec")
             }
-            // FIXME: epoll_event.data is actuall 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.

src/fuchsia/mod.rs

@@ -409,6 +409,13 @@ s! {
 
     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,
     }
 

src/unix/linux_like/mod.rs

@@ -214,6 +214,13 @@ s_no_extra_traits! {
         repr(packed))]
     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,
     }
 
@@ -264,25 +271,46 @@ cfg_if! {
         impl PartialEq for epoll_event {
             fn eq(&self, other: &epoll_event) -> bool {
                 self.events == other.events
-                    && self.u64 == other.u64
+                    && unsafe { self.data.u64 == other.data.u64 }
             }
         }
         impl Eq for epoll_event {}
         impl ::fmt::Debug for epoll_event {
             fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                 let events = self.events;
-                let u64 = self.u64;
+                let data = self.data;
                 f.debug_struct("epoll_event")
                     .field("events", &events)
-                    .field("u64", &u64)
+                    .field("data", &data)
                     .finish()
             }
         }
         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);
+                data.hash(state);
+            }
+        }
+
+        impl PartialEq for epoll_data {
+            fn eq(&self, other: &epoll_data) -> bool {
+                unsafe { self.u64 == other.u64 }
+            }
+        }
+        impl Eq for epoll_data {}
+        impl ::fmt::Debug for epoll_data {
+            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+                let u64 = unsafe { self.u64 };
+                f.debug_struct("epoll_data")
+                    .field("data", &u64)
+                    .finish()
+            }
+        }
+        impl ::hash::Hash for epoll_data {
+            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+                let u64 = unsafe { self.u64 };
                 u64.hash(state);
             }
         }

src/unix/solarish/mod.rs

@@ -429,6 +429,13 @@ s_no_extra_traits! {
         ), repr(packed))]
     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,
     }
 
@@ -563,25 +570,46 @@ cfg_if! {
         impl PartialEq for epoll_event {
             fn eq(&self, other: &epoll_event) -> bool {
                 self.events == other.events
-                    && self.u64 == other.u64
+                    && unsafe { self.data.u64 == other.data.u64 }
             }
         }
         impl Eq for epoll_event {}
         impl ::fmt::Debug for epoll_event {
             fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
                 let events = self.events;
-                let u64 = self.u64;
+                let data = self.data;
                 f.debug_struct("epoll_event")
                     .field("events", &events)
-                    .field("u64", &u64)
+                    .field("data", &data)
                     .finish()
             }
         }
         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);
+                data.hash(state);
+            }
+        }
+
+        impl PartialEq for epoll_data {
+            fn eq(&self, other: &epoll_data) -> bool {
+                unsafe { self.u64 == other.u64 }
+            }
+        }
+        impl Eq for epoll_data {}
+        impl ::fmt::Debug for epoll_data {
+            fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
+                let u64 = unsafe { self.u64 };
+                f.debug_struct("epoll_data")
+                    .field("data", &u64)
+                    .finish()
+            }
+        }
+        impl ::hash::Hash for epoll_data {
+            fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
+                let u64 = unsafe { self.u64 };
                 u64.hash(state);
             }
         }