diff --git a/src/unix/bsd/netbsdlike/openbsdlike/mod.rs b/src/unix/bsd/netbsdlike/openbsdlike/mod.rs
index 1c2e47dc3f98f..d45e5e16ac8f2 100644
--- a/src/unix/bsd/netbsdlike/openbsdlike/mod.rs
+++ b/src/unix/bsd/netbsdlike/openbsdlike/mod.rs
@@ -17,16 +17,6 @@ pub type pthread_rwlockattr_t = *mut ::c_void;
 pub type caddr_t = *mut ::c_char;
 
 s! {
-    pub struct dirent {
-        pub d_fileno: ::ino_t,
-        pub d_off: ::off_t,
-        pub d_reclen: u16,
-        pub d_type: u8,
-        pub d_namlen: u8,
-        __d_padding: [u8; 4],
-        pub d_name: [::c_char; 256],
-    }
-
     pub struct glob_t {
         pub gl_pathc:   ::c_int,
         pub gl_matchc:  ::c_int,
@@ -99,25 +89,6 @@ s! {
         pub ai_next: *mut ::addrinfo,
     }
 
-    pub struct sockaddr_storage {
-        pub ss_len: u8,
-        pub ss_family: ::sa_family_t,
-        __ss_pad1: [u8; 6],
-        __ss_pad2: i64,
-        __ss_pad3: [u8; 240],
-    }
-
-    pub struct siginfo_t {
-        pub si_signo: ::c_int,
-        pub si_code: ::c_int,
-        pub si_errno: ::c_int,
-        pub si_addr: *mut ::c_char,
-        #[cfg(target_pointer_width = "32")]
-        __pad: [u8; 112],
-        #[cfg(target_pointer_width = "64")]
-        __pad: [u8; 108],
-    }
-
     pub struct Dl_info {
         pub dli_fname: *const ::c_char,
         pub dli_fbase: *mut ::c_void,
@@ -125,19 +96,6 @@ s! {
         pub dli_saddr: *mut ::c_void,
     }
 
-    pub struct lastlog {
-        ll_time: ::time_t,
-        ll_line: [::c_char; UT_LINESIZE],
-        ll_host: [::c_char; UT_HOSTSIZE],
-    }
-
-    pub struct utmp {
-        pub ut_line: [::c_char; UT_LINESIZE],
-        pub ut_name: [::c_char; UT_NAMESIZE],
-        pub ut_host: [::c_char; UT_HOSTSIZE],
-        pub ut_time: ::time_t,
-    }
-
     pub struct if_data {
         pub ifi_type: ::c_uchar,
         pub ifi_addrlen: ::c_uchar,
@@ -204,6 +162,232 @@ s! {
     }
 }
 
+s_no_extra_traits! {
+    pub struct dirent {
+        pub d_fileno: ::ino_t,
+        pub d_off: ::off_t,
+        pub d_reclen: u16,
+        pub d_type: u8,
+        pub d_namlen: u8,
+        __d_padding: [u8; 4],
+        pub d_name: [::c_char; 256],
+    }
+
+    pub struct sockaddr_storage {
+        pub ss_len: u8,
+        pub ss_family: ::sa_family_t,
+        __ss_pad1: [u8; 6],
+        __ss_pad2: i64,
+        __ss_pad3: [u8; 240],
+    }
+
+    pub struct siginfo_t {
+        pub si_signo: ::c_int,
+        pub si_code: ::c_int,
+        pub si_errno: ::c_int,
+        pub si_addr: *mut ::c_char,
+        #[cfg(target_pointer_width = "32")]
+        __pad: [u8; 112],
+        #[cfg(target_pointer_width = "64")]
+        __pad: [u8; 108],
+    }
+
+    pub struct lastlog {
+        ll_time: ::time_t,
+        ll_line: [::c_char; UT_LINESIZE],
+        ll_host: [::c_char; UT_HOSTSIZE],
+    }
+
+    pub struct utmp {
+        pub ut_line: [::c_char; UT_LINESIZE],
+        pub ut_name: [::c_char; UT_NAMESIZE],
+        pub ut_host: [::c_char; UT_HOSTSIZE],
+        pub ut_time: ::time_t,
+    }
+}
+
+#[cfg(feature = "extra_traits")]
+impl PartialEq for dirent {
+    fn eq(&self, other: &dirent) -> bool {
+        self.d_fileno == other.d_fileno
+            && self.d_off == other.d_off
+            && self.d_reclen == other.d_reclen
+            && self.d_type == other.d_type
+            && self.d_namlen == other.d_namlen
+            && self
+                .d_name
+                .iter()
+                .zip(other.d_name.iter())
+                .all(|(a,b)| a == b)
+    }
+}
+#[cfg(feature = "extra_traits")]
+impl Eq for dirent {}
+#[cfg(feature = "extra_traits")]
+impl std::fmt::Debug for dirent {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("dirent")
+         .field("d_fileno", &self.d_fileno)
+         .field("d_off", &self.d_off)
+         .field("d_reclen", &self.d_reclen)
+         .field("d_type", &self.d_type)
+         .field("d_namlen", &self.d_namlen)
+         // FIXME: .field("d_name", &self.d_name)
+         .finish()
+    }
+}
+#[cfg(feature = "extra_traits")]
+impl std::hash::Hash for dirent {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.d_fileno.hash(state);
+        self.d_off.hash(state);
+        self.d_reclen.hash(state);
+        self.d_type.hash(state);
+        self.d_namlen.hash(state);
+        self.d_name.hash(state);
+    }
+}
+
+#[cfg(feature = "extra_traits")]
+impl PartialEq for sockaddr_storage {
+    fn eq(&self, other: &sockaddr_storage) -> bool {
+        self.ss_len == other.ss_len
+            && self.ss_family == other.ss_family
+    }
+}
+#[cfg(feature = "extra_traits")]
+impl Eq for sockaddr_storage {}
+#[cfg(feature = "extra_traits")]
+impl std::fmt::Debug for sockaddr_storage {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("sockaddr_storage")
+         .field("ss_len", &self.ss_len)
+         .field("ss_family", &self.ss_family)
+         .finish()
+    }
+}
+#[cfg(feature = "extra_traits")]
+impl std::hash::Hash for sockaddr_storage {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.ss_len.hash(state);
+        self.ss_family.hash(state);
+    }
+}
+
+#[cfg(feature = "extra_traits")]
+impl PartialEq for siginfo_t {
+    fn eq(&self, other: &siginfo_t) -> bool {
+        self.si_signo == other.si_signo
+            && self.si_code == other.si_code
+            && self.si_errno == other.si_errno
+            && self.si_addr == other.si_addr
+    }
+}
+#[cfg(feature = "extra_traits")]
+impl Eq for siginfo_t {}
+#[cfg(feature = "extra_traits")]
+impl std::fmt::Debug for siginfo_t {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("siginfo_t")
+         .field("si_signo", &self.si_signo)
+         .field("si_code", &self.si_code)
+         .field("si_errno", &self.si_errno)
+         .field("si_addr", &self.si_addr)
+         .finish()
+    }
+}
+#[cfg(feature = "extra_traits")]
+impl std::hash::Hash for siginfo_t {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.si_signo.hash(state);
+        self.si_code.hash(state);
+        self.si_errno.hash(state);
+        self.si_addr.hash(state);
+    }
+}
+
+#[cfg(feature = "extra_traits")]
+impl PartialEq for lastlog {
+    fn eq(&self, other: &lastlog) -> bool {
+        self.ll_time == other.ll_time
+            && self
+                .ll_line
+                .iter()
+                .zip(other.ll_line.iter())
+                .all(|(a,b)| a == b)
+            && self
+                .ll_host
+                .iter()
+                .zip(other.ll_host.iter())
+                .all(|(a,b)| a == b)
+    }
+}
+#[cfg(feature = "extra_traits")]
+impl Eq for lastlog {}
+#[cfg(feature = "extra_traits")]
+impl std::fmt::Debug for lastlog {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("lastlog")
+         .field("ll_time", &self.ll_time)
+         // FIXME: .field("ll_line", &self.ll_line)
+         // FIXME: .field("ll_host", &self.ll_host)
+         .finish()
+    }
+}
+#[cfg(feature = "extra_traits")]
+impl std::hash::Hash for lastlog {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.ll_time.hash(state);
+        self.ll_line.hash(state);
+        self.ll_host.hash(state);
+    }
+}
+
+#[cfg(feature = "extra_traits")]
+impl PartialEq for utmp {
+    fn eq(&self, other: &utmp) -> bool {
+        self.ut_time == other.ut_time
+            && self
+                .ut_line
+                .iter()
+                .zip(other.ut_line.iter())
+                .all(|(a,b)| a == b)
+            && self
+                .ut_name
+                .iter()
+                .zip(other.ut_name.iter())
+                .all(|(a,b)| a == b)
+            && self
+                .ut_host
+                .iter()
+                .zip(other.ut_host.iter())
+                .all(|(a,b)| a == b)
+    }
+}
+#[cfg(feature = "extra_traits")]
+impl Eq for utmp {}
+#[cfg(feature = "extra_traits")]
+impl std::fmt::Debug for utmp {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("utmp")
+         // FIXME: .field("ut_line", &self.ut_line)
+         // FIXME: .field("ut_name", &self.ut_name)
+         // FIXME: .field("ut_host", &self.ut_host)
+         .field("ut_time", &self.ut_time)
+         .finish()
+    }
+}
+#[cfg(feature = "extra_traits")]
+impl std::hash::Hash for utmp {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.ut_line.hash(state);
+        self.ut_name.hash(state);
+        self.ut_host.hash(state);
+        self.ut_time.hash(state);
+    }
+}
+
+
 pub const UT_NAMESIZE: usize = 32;
 pub const UT_LINESIZE: usize = 8;
 pub const UT_HOSTSIZE: usize = 256;
diff --git a/src/unix/bsd/netbsdlike/openbsdlike/openbsd/mod.rs b/src/unix/bsd/netbsdlike/openbsdlike/openbsd/mod.rs
index a2a7a30a102a9..0a531c3278b43 100644
--- a/src/unix/bsd/netbsdlike/openbsdlike/openbsd/mod.rs
+++ b/src/unix/bsd/netbsdlike/openbsdlike/openbsd/mod.rs
@@ -26,42 +26,6 @@ s! {
         pub int_n_sign_posn: ::c_char,
     }
 
-    pub struct statfs {
-        pub f_flags: ::uint32_t,
-        pub f_bsize: ::uint32_t,
-        pub f_iosize: ::uint32_t,
-        pub f_blocks: ::uint64_t,
-        pub f_bfree: ::uint64_t,
-        pub f_bavail: ::int64_t,
-        pub f_files: ::uint64_t,
-        pub f_ffree: ::uint64_t,
-        pub f_favail: ::int64_t,
-        pub f_syncwrites: ::uint64_t,
-        pub f_syncreads: ::uint64_t,
-        pub f_asyncwrites: ::uint64_t,
-        pub f_asyncreads: ::uint64_t,
-        pub f_fsid: ::fsid_t,
-        pub f_namemax: ::uint32_t,
-        pub f_owner: ::uid_t,
-        pub f_ctime: ::uint64_t,
-        pub f_fstypename: [::c_char; 16],
-        pub f_mntonname: [::c_char; 90],
-        pub f_mntfromname: [::c_char; 90],
-        pub f_mntfromspec: [::c_char; 90],
-        pub mount_info: mount_info,
-    }
-
-    pub union mount_info {
-        pub ufs_args: ufs_args,
-        pub mfs_args: mfs_args,
-        pub nfs_args: nfs_args,
-        pub iso_args: iso_args,
-        pub msdosfs_args: msdosfs_args,
-        pub ntfs_args: ntfs_args,
-        pub tmpfs_args: tmpfs_args,
-        align: [::c_char; 160],
-    }
-
     pub struct ufs_args {
         pub fspec: *mut ::c_char,
         pub export_info: export_args,
@@ -165,6 +129,171 @@ s! {
     }
 }
 
+s_no_extra_traits! {
+    pub union mount_info {
+        pub ufs_args: ufs_args,
+        pub mfs_args: mfs_args,
+        pub nfs_args: nfs_args,
+        pub iso_args: iso_args,
+        pub msdosfs_args: msdosfs_args,
+        pub ntfs_args: ntfs_args,
+        pub tmpfs_args: tmpfs_args,
+        align: [::c_char; 160],
+    }
+
+    pub struct statfs {
+        pub f_flags: ::uint32_t,
+        pub f_bsize: ::uint32_t,
+        pub f_iosize: ::uint32_t,
+        pub f_blocks: ::uint64_t,
+        pub f_bfree: ::uint64_t,
+        pub f_bavail: ::int64_t,
+        pub f_files: ::uint64_t,
+        pub f_ffree: ::uint64_t,
+        pub f_favail: ::int64_t,
+        pub f_syncwrites: ::uint64_t,
+        pub f_syncreads: ::uint64_t,
+        pub f_asyncwrites: ::uint64_t,
+        pub f_asyncreads: ::uint64_t,
+        pub f_fsid: ::fsid_t,
+        pub f_namemax: ::uint32_t,
+        pub f_owner: ::uid_t,
+        pub f_ctime: ::uint64_t,
+        pub f_fstypename: [::c_char; 16],
+        pub f_mntonname: [::c_char; 90],
+        pub f_mntfromname: [::c_char; 90],
+        pub f_mntfromspec: [::c_char; 90],
+        pub mount_info: mount_info,
+    }
+}
+
+#[cfg(feature = "extra_traits")]
+impl PartialEq for mount_info {
+    fn eq(&self, other: &mount_info) -> bool {
+        unsafe {
+            self.align
+                .iter()
+                .zip(other.align.iter())
+                .all(|(a,b)| a == b)
+        }
+    }
+}
+#[cfg(feature = "extra_traits")]
+impl Eq for mount_info { }
+#[cfg(feature = "extra_traits")]
+impl std::fmt::Debug for mount_info {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("mount_info")
+         // FIXME: .field("align", &self.align)
+         .finish()
+    }
+}
+#[cfg(feature = "extra_traits")]
+impl std::hash::Hash for mount_info {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        unsafe { self.align.hash(state) };
+    }
+}
+
+#[cfg(feature = "extra_traits")]
+impl PartialEq for statfs {
+    fn eq(&self, other: &statfs) -> bool {
+        self.f_flags == other.f_flags
+            && self.f_bsize == other.f_bsize
+            && self.f_iosize == other.f_iosize
+            && self.f_blocks == other.f_blocks
+            && self.f_bfree == other.f_bfree
+            && self.f_bavail == other.f_bavail
+            && self.f_files == other.f_files
+            && self.f_ffree == other.f_ffree
+            && self.f_favail == other.f_favail
+            && self.f_syncwrites == other.f_syncwrites
+            && self.f_syncreads == other.f_syncreads
+            && self.f_asyncwrites == other.f_asyncwrites
+            && self.f_asyncreads == other.f_asyncreads
+            && self.f_fsid == other.f_fsid
+            && self.f_namemax == other.f_namemax
+            && self.f_owner == other.f_owner
+            && self.f_ctime == other.f_ctime
+            && self.f_fstypename
+                   .iter()
+                   .zip(other.f_fstypename.iter())
+                   .all(|(a,b)| a == b)
+            && self.f_mntonname
+                   .iter()
+                   .zip(other.f_mntonname.iter())
+                   .all(|(a,b)| a == b)
+            && self.f_mntfromname
+                   .iter()
+                   .zip(other.f_mntfromname.iter())
+                   .all(|(a,b)| a == b)
+            && self.f_mntfromspec
+                   .iter()
+                   .zip(other.f_mntfromspec.iter())
+                   .all(|(a,b)| a == b)
+            && self.mount_info == other.mount_info
+    }
+}
+#[cfg(feature = "extra_traits")]
+impl Eq for statfs { }
+#[cfg(feature = "extra_traits")]
+impl std::fmt::Debug for statfs {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        f.debug_struct("statfs")
+         .field("f_flags", &self.f_flags)
+         .field("f_bsize", &self.f_bsize)
+         .field("f_iosize", &self.f_iosize)
+         .field("f_blocks", &self.f_blocks)
+         .field("f_bfree", &self.f_bfree)
+         .field("f_bavail", &self.f_bavail)
+         .field("f_files", &self.f_files)
+         .field("f_ffree", &self.f_ffree)
+         .field("f_favail", &self.f_favail)
+         .field("f_syncwrites", &self.f_syncwrites)
+         .field("f_syncreads", &self.f_syncreads)
+         .field("f_asyncwrites", &self.f_asyncwrites)
+         .field("f_asyncreads", &self.f_asyncreads)
+         .field("f_fsid", &self.f_fsid)
+         .field("f_namemax", &self.f_namemax)
+         .field("f_owner", &self.f_owner)
+         .field("f_ctime", &self.f_ctime)
+         // FIXME: .field("f_fstypename", &self.f_fstypename)
+         // FIXME: .field("f_mntonname", &self.f_mntonname)
+         // FIXME: .field("f_mntfromname", &self.f_mntfromname)
+         // FIXME: .field("f_mntfromspec", &self.f_mntfromspec)
+         .field("mount_info", &self.mount_info)
+         .finish()
+    }
+}
+
+#[cfg(feature = "extra_traits")]
+impl std::hash::Hash for statfs {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.f_flags.hash(state);
+        self.f_bsize.hash(state);
+        self.f_iosize.hash(state);
+        self.f_blocks.hash(state);
+        self.f_bfree.hash(state);
+        self.f_bavail.hash(state);
+        self.f_files.hash(state);
+        self.f_ffree.hash(state);
+        self.f_favail.hash(state);
+        self.f_syncwrites.hash(state);
+        self.f_syncreads.hash(state);
+        self.f_asyncwrites.hash(state);
+        self.f_asyncreads.hash(state);
+        self.f_fsid.hash(state);
+        self.f_namemax.hash(state);
+        self.f_owner.hash(state);
+        self.f_ctime.hash(state);
+        self.f_fstypename.hash(state);
+        self.f_mntonname.hash(state);
+        self.f_mntfromname.hash(state);
+        self.f_mntfromspec.hash(state);
+        self.mount_info.hash(state);
+    }
+}
+
 //https://github.com/openbsd/src/blob/master/sys/sys/mount.h
 pub const ISOFSMNT_NORRIP: ::c_int = 0x1; // disable Rock Ridge Ext
 pub const ISOFSMNT_GENS: ::c_int = 0x2; // enable generation numbers