vendor/libc/src/unix/notbsd/android/b64/mod.rs

   1 // The following definitions are correct for aarch64 and x86_64,
   2 // but may be wrong for mips64
   3
   4 pub type c_long = i64;
   5 pub type c_ulong = u64;
   6 pub type mode_t = u32;
   7 pub type off64_t = i64;
   8 pub type socklen_t = u32;
   9
  10 s! {
  11     pub struct sigset_t {
  12         __val: [::c_ulong; 1],
  13     }
  14
  15     pub struct sigaction {
  16         pub sa_flags: ::c_uint,
  17         pub sa_sigaction: ::sighandler_t,
  18         pub sa_mask: ::sigset_t,
  19         pub sa_restorer: ::Option<extern fn()>,
  20     }
  21
  22     pub struct rlimit64 {
  23         pub rlim_cur: ::c_ulonglong,
  24         pub rlim_max: ::c_ulonglong,
  25     }
  26
  27     pub struct pthread_attr_t {
  28         pub flags: ::uint32_t,
  29         pub stack_base: *mut ::c_void,
  30         pub stack_size: ::size_t,
  31         pub guard_size: ::size_t,
  32         pub sched_policy: ::int32_t,
  33         pub sched_priority: ::int32_t,
  34         __reserved: [::c_char; 16],
  35     }
  36
  37     pub struct passwd {
  38         pub pw_name: *mut ::c_char,
  39         pub pw_passwd: *mut ::c_char,
  40         pub pw_uid: ::uid_t,
  41         pub pw_gid: ::gid_t,
  42         pub pw_gecos: *mut ::c_char,
  43         pub pw_dir: *mut ::c_char,
  44         pub pw_shell: *mut ::c_char,
  45     }
  46
  47     pub struct statfs {
  48         pub f_type: ::uint64_t,
  49         pub f_bsize: ::uint64_t,
  50         pub f_blocks: ::uint64_t,
  51         pub f_bfree: ::uint64_t,
  52         pub f_bavail: ::uint64_t,
  53         pub f_files: ::uint64_t,
  54         pub f_ffree: ::uint64_t,
  55         pub f_fsid: ::__fsid_t,
  56         pub f_namelen: ::uint64_t,
  57         pub f_frsize: ::uint64_t,
  58         pub f_flags: ::uint64_t,
  59         pub f_spare: [::uint64_t; 4],
  60     }
  61
  62     pub struct sysinfo {
  63         pub uptime: ::c_long,
  64         pub loads: [::c_ulong; 3],
  65         pub totalram: ::c_ulong,
  66         pub freeram: ::c_ulong,
  67         pub sharedram: ::c_ulong,
  68         pub bufferram: ::c_ulong,
  69         pub totalswap: ::c_ulong,
  70         pub freeswap: ::c_ulong,
  71         pub procs: ::c_ushort,
  72         pub pad: ::c_ushort,
  73         pub totalhigh: ::c_ulong,
  74         pub freehigh: ::c_ulong,
  75         pub mem_unit: ::c_uint,
  76         pub _f: [::c_char; 0],
  77     }
  78
  79     pub struct statfs64 {
  80         pub f_type: u64,
  81         pub f_bsize: u64,
  82         pub f_blocks: u64,
  83         pub f_bfree: u64,
  84         pub f_bavail: u64,
  85         pub f_files: u64,
  86         pub f_ffree: u64,
  87         f_fsid: [u32; 2],
  88         pub f_namelen: u64,
  89         pub f_frsize: u64,
  90         pub f_flags: u64,
  91         pub f_spare: [u64; 4],
  92     }
  93
  94     pub struct statvfs64 {
  95         pub f_bsize: ::c_ulong,
  96         pub f_frsize: ::c_ulong,
  97         pub f_blocks: u64,
  98         pub f_bfree: u64,
  99         pub f_bavail: u64,
 100         pub f_files: u64,
 101         pub f_ffree: u64,
 102         pub f_favail: u64,
 103         pub f_fsid: ::c_ulong,
 104         pub f_flag: ::c_ulong,
 105         pub f_namemax: ::c_ulong,
 106         __f_spare: [::c_int; 6],
 107     }
 108 }
 109
 110 s_no_extra_traits!{
 111     pub struct pthread_mutex_t {
 112         value: ::c_int,
 113         __reserved: [::c_char; 36],
 114     }
 115
 116     pub struct pthread_cond_t {
 117         value: ::c_int,
 118         __reserved: [::c_char; 44],
 119     }
 120
 121     pub struct pthread_rwlock_t {
 122         numLocks: ::c_int,
 123         writerThreadId: ::c_int,
 124         pendingReaders: ::c_int,
 125         pendingWriters: ::c_int,
 126         attr: i32,
 127         __reserved: [::c_char; 36],
 128     }
 129 }
 130
 131 cfg_if! {
 132     if #[cfg(feature = "extra_traits")] {
 133         impl PartialEq for pthread_mutex_t {
 134             fn eq(&self, other: &pthread_mutex_t) -> bool {
 135                 self.value == other.value
 136                     && self
 137                     .__reserved
 138                     .iter()
 139                     .zip(other.__reserved.iter())
 140                     .all(|(a,b)| a == b)
 141             }
 142         }
 143
 144         impl Eq for pthread_mutex_t {}
 145
 146         impl ::fmt::Debug for pthread_mutex_t {
 147             fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
 148                 f.debug_struct("pthread_mutex_t")
 149                     .field("value", &self.value)
 150                     // FIXME: .field("__reserved", &self.__reserved)
 151                     .finish()
 152             }
 153         }
 154
 155         impl ::hash::Hash for pthread_mutex_t {
 156             fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
 157                 self.value.hash(state);
 158                 self.__reserved.hash(state);
 159             }
 160         }
 161
 162         impl PartialEq for pthread_cond_t {
 163             fn eq(&self, other: &pthread_cond_t) -> bool {
 164                 self.value == other.value
 165                     && self
 166                     .__reserved
 167                     .iter()
 168                     .zip(other.__reserved.iter())
 169                     .all(|(a,b)| a == b)
 170             }
 171         }
 172
 173         impl Eq for pthread_cond_t {}
 174
 175         impl ::fmt::Debug for pthread_cond_t {
 176             fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
 177                 f.debug_struct("pthread_cond_t")
 178                     .field("value", &self.value)
 179                     // FIXME: .field("__reserved", &self.__reserved)
 180                     .finish()
 181             }
 182         }
 183
 184         impl ::hash::Hash for pthread_cond_t {
 185             fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
 186                 self.value.hash(state);
 187                 self.__reserved.hash(state);
 188             }
 189         }
 190
 191         impl PartialEq for pthread_rwlock_t {
 192             fn eq(&self, other: &pthread_rwlock_t) -> bool {
 193                 self.numLocks == other.numLocks
 194                     && self.writerThreadId == other.writerThreadId
 195                     && self.pendingReaders == other.pendingReaders
 196                     && self.pendingWriters == other.pendingWriters
 197                     && self.attr == other.attr
 198                     && self
 199                     .__reserved
 200                     .iter()
 201                     .zip(other.__reserved.iter())
 202                     .all(|(a,b)| a == b)
 203             }
 204         }
 205
 206         impl Eq for pthread_rwlock_t {}
 207
 208         impl ::fmt::Debug for pthread_rwlock_t {
 209             fn fmt(&self, f: &mut ::fmt::Formatter) -> ::fmt::Result {
 210                 f.debug_struct("pthread_rwlock_t")
 211                     .field("numLocks", &self.numLocks)
 212                     .field("writerThreadId", &self.writerThreadId)
 213                     .field("pendingReaders", &self.pendingReaders)
 214                     .field("pendingWriters", &self.pendingWriters)
 215                     .field("attr", &self.attr)
 216                     // FIXME: .field("__reserved", &self.__reserved)
 217                     .finish()
 218             }
 219         }
 220
 221         impl ::hash::Hash for pthread_rwlock_t {
 222             fn hash<H: ::hash::Hasher>(&self, state: &mut H) {
 223                 self.numLocks.hash(state);
 224                 self.writerThreadId.hash(state);
 225                 self.pendingReaders.hash(state);
 226                 self.pendingWriters.hash(state);
 227                 self.attr.hash(state);
 228                 self.__reserved.hash(state);
 229             }
 230         }
 231     }
 232 }
 233
 234 pub const RTLD_GLOBAL: ::c_int = 0x00100;
 235 pub const RTLD_NOW: ::c_int = 2;
 236 pub const RTLD_DEFAULT: *mut ::c_void = 0i64 as *mut ::c_void;
 237
 238 pub const PTHREAD_MUTEX_INITIALIZER: pthread_mutex_t = pthread_mutex_t {
 239     value: 0,
 240     __reserved: [0; 36],
 241 };
 242 pub const PTHREAD_COND_INITIALIZER: pthread_cond_t = pthread_cond_t {
 243     value: 0,
 244     __reserved: [0; 44],
 245 };
 246 pub const PTHREAD_RWLOCK_INITIALIZER: pthread_rwlock_t = pthread_rwlock_t {
 247     numLocks: 0,
 248     writerThreadId: 0,
 249     pendingReaders: 0,
 250     pendingWriters: 0,
 251     attr: 0,
 252     __reserved: [0; 36],
 253 };
 254 pub const PTHREAD_STACK_MIN: ::size_t = 4096 * 4;
 255 pub const CPU_SETSIZE: ::size_t = 1024;
 256 pub const __CPU_BITS: ::size_t = 64;
 257
 258 pub const UT_LINESIZE: usize = 32;
 259 pub const UT_NAMESIZE: usize = 32;
 260 pub const UT_HOSTSIZE: usize = 256;
 261
 262 cfg_if! {
 263     if #[cfg(target_arch = "x86_64")] {
 264         mod x86_64;
 265         pub use self::x86_64::*;
 266     } else if #[cfg(target_arch = "aarch64")] {
 267         mod aarch64;
 268         pub use self::aarch64::*;
 269     } else {
 270         // Unknown target_arch
 271     }
 272 }