Debian Codegraph @

third_party/rust/libc/src/unix/bsd/freebsdlike/freebsd/freebsd13/mod.rs

raw
1 use crate::off_t;
2 use crate::prelude::*;
3
4 // APIs in FreeBSD 13 that have changed since 11.
5
6 pub type nlink_t = u64;
7 pub type dev_t = u64;
8 pub type ino_t = u64;
9 pub type shmatt_t = c_uint;
10 pub type kpaddr_t = u64;
11 pub type kssize_t = i64;
12 pub type domainset_t = __c_anonymous_domainset;
13
14 s! {
15 pub struct shmid_ds {
16 pub shm_perm: crate::ipc_perm,
17 pub shm_segsz: size_t,
18 pub shm_lpid: crate::pid_t,
19 pub shm_cpid: crate::pid_t,
20 pub shm_nattch: crate::shmatt_t,
21 pub shm_atime: crate::time_t,
22 pub shm_dtime: crate::time_t,
23 pub shm_ctime: crate::time_t,
24 }
25
26 pub struct kevent {
27 pub ident: crate::uintptr_t,
28 pub filter: c_short,
29 pub flags: c_ushort,
30 pub fflags: c_uint,
31 pub data: i64,
32 pub udata: *mut c_void,
33 pub ext: [u64; 4],
34 }
35
36 pub struct kvm_page {
37 pub kp_version: crate::u_int,
38 pub kp_paddr: crate::kpaddr_t,
39 pub kp_kmap_vaddr: crate::kvaddr_t,
40 pub kp_dmap_vaddr: crate::kvaddr_t,
41 pub kp_prot: crate::vm_prot_t,
42 pub kp_offset: off_t,
43 pub kp_len: size_t,
44 }
45
46 pub struct __c_anonymous_domainset {
47 #[cfg(target_pointer_width = "64")]
48 _priv: [c_ulong; 4],
49 #[cfg(target_pointer_width = "32")]
50 _priv: [c_ulong; 8],
51 }
52
53 pub struct kinfo_proc {
54 /// Size of this structure.
55 pub ki_structsize: c_int,
56 /// Reserved: layout identifier.
57 pub ki_layout: c_int,
58 /// Address of command arguments.
59 pub ki_args: *mut crate::pargs,
60 // This is normally "struct proc".
61 /// Address of proc.
62 pub ki_paddr: *mut c_void,
63 // This is normally "struct user".
64 /// Kernel virtual address of u-area.
65 pub ki_addr: *mut c_void,
66 // This is normally "struct vnode".
67 /// Pointer to trace file.
68 pub ki_tracep: *mut c_void,
69 // This is normally "struct vnode".
70 /// Pointer to executable file.
71 pub ki_textvp: *mut c_void,
72 // This is normally "struct filedesc".
73 /// Pointer to open file info.
74 pub ki_fd: *mut c_void,
75 // This is normally "struct vmspace".
76 /// Pointer to kernel vmspace struct.
77 pub ki_vmspace: *mut c_void,
78 /// Sleep address.
79 pub ki_wchan: *const c_void,
80 /// Process identifier.
81 pub ki_pid: crate::pid_t,
82 /// Parent process ID.
83 pub ki_ppid: crate::pid_t,
84 /// Process group ID.
85 pub ki_pgid: crate::pid_t,
86 /// tty process group ID.
87 pub ki_tpgid: crate::pid_t,
88 /// Process session ID.
89 pub ki_sid: crate::pid_t,
90 /// Terminal session ID.
91 pub ki_tsid: crate::pid_t,
92 /// Job control counter.
93 pub ki_jobc: c_short,
94 /// Unused (just here for alignment).
95 pub ki_spare_short1: c_short,
96 /// Controlling tty dev.
97 pub ki_tdev_freebsd11: u32,
98 /// Signals arrived but not delivered.
99 pub ki_siglist: crate::sigset_t,
100 /// Current signal mask.
101 pub ki_sigmask: crate::sigset_t,
102 /// Signals being ignored.
103 pub ki_sigignore: crate::sigset_t,
104 /// Signals being caught by user.
105 pub ki_sigcatch: crate::sigset_t,
106 /// Effective user ID.
107 pub ki_uid: crate::uid_t,
108 /// Real user ID.
109 pub ki_ruid: crate::uid_t,
110 /// Saved effective user ID.
111 pub ki_svuid: crate::uid_t,
112 /// Real group ID.
113 pub ki_rgid: crate::gid_t,
114 /// Saved effective group ID.
115 pub ki_svgid: crate::gid_t,
116 /// Number of groups.
117 pub ki_ngroups: c_short,
118 /// Unused (just here for alignment).
119 pub ki_spare_short2: c_short,
120 /// Groups.
121 pub ki_groups: [crate::gid_t; crate::KI_NGROUPS],
122 /// Virtual size.
123 pub ki_size: crate::vm_size_t,
124 /// Current resident set size in pages.
125 pub ki_rssize: crate::segsz_t,
126 /// Resident set size before last swap.
127 pub ki_swrss: crate::segsz_t,
128 /// Text size (pages) XXX.
129 pub ki_tsize: crate::segsz_t,
130 /// Data size (pages) XXX.
131 pub ki_dsize: crate::segsz_t,
132 /// Stack size (pages).
133 pub ki_ssize: crate::segsz_t,
134 /// Exit status for wait & stop signal.
135 pub ki_xstat: crate::u_short,
136 /// Accounting flags.
137 pub ki_acflag: crate::u_short,
138 /// %cpu for process during `ki_swtime`.
139 pub ki_pctcpu: crate::fixpt_t,
140 /// Time averaged value of `ki_cpticks`.
141 pub ki_estcpu: crate::u_int,
142 /// Time since last blocked.
143 pub ki_slptime: crate::u_int,
144 /// Time swapped in or out.
145 pub ki_swtime: crate::u_int,
146 /// Number of copy-on-write faults.
147 pub ki_cow: crate::u_int,
148 /// Real time in microsec.
149 pub ki_runtime: u64,
150 /// Starting time.
151 pub ki_start: crate::timeval,
152 /// Time used by process children.
153 pub ki_childtime: crate::timeval,
154 /// P_* flags.
155 pub ki_flag: c_long,
156 /// KI_* flags (below).
157 pub ki_kiflag: c_long,
158 /// Kernel trace points.
159 pub ki_traceflag: c_int,
160 /// S* process status.
161 pub ki_stat: c_char,
162 /// Process "nice" value.
163 pub ki_nice: i8, // signed char
164 /// Process lock (prevent swap) count.
165 pub ki_lock: c_char,
166 /// Run queue index.
167 pub ki_rqindex: c_char,
168 /// Which cpu we are on.
169 pub ki_oncpu_old: c_uchar,
170 /// Last cpu we were on.
171 pub ki_lastcpu_old: c_uchar,
172 /// Thread name.
173 pub ki_tdname: [c_char; crate::TDNAMLEN + 1],
174 /// Wchan message.
175 pub ki_wmesg: [c_char; crate::WMESGLEN + 1],
176 /// Setlogin name.
177 pub ki_login: [c_char; crate::LOGNAMELEN + 1],
178 /// Lock name.
179 pub ki_lockname: [c_char; crate::LOCKNAMELEN + 1],
180 /// Command name.
181 pub ki_comm: [c_char; crate::COMMLEN + 1],
182 /// Emulation name.
183 pub ki_emul: [c_char; crate::KI_EMULNAMELEN + 1],
184 /// Login class.
185 pub ki_loginclass: [c_char; crate::LOGINCLASSLEN + 1],
186 /// More thread name.
187 pub ki_moretdname: [c_char; crate::MAXCOMLEN - crate::TDNAMLEN + 1],
188 /// Spare string space.
189 pub ki_sparestrings: [[c_char; 23]; 2], // little hack to allow PartialEq
190 /// Spare room for growth.
191 pub ki_spareints: [c_int; crate::KI_NSPARE_INT],
192 /// Controlling tty dev.
193 pub ki_tdev: u64,
194 /// Which cpu we are on.
195 pub ki_oncpu: c_int,
196 /// Last cpu we were on.
197 pub ki_lastcpu: c_int,
198 /// PID of tracing process.
199 pub ki_tracer: c_int,
200 /// P2_* flags.
201 pub ki_flag2: c_int,
202 /// Default FIB number.
203 pub ki_fibnum: c_int,
204 /// Credential flags.
205 pub ki_cr_flags: crate::u_int,
206 /// Process jail ID.
207 pub ki_jid: c_int,
208 /// Number of threads in total.
209 pub ki_numthreads: c_int,
210 /// Thread ID.
211 pub ki_tid: crate::lwpid_t,
212 /// Process priority.
213 pub ki_pri: crate::priority,
214 /// Process rusage statistics.
215 pub ki_rusage: crate::rusage,
216 /// rusage of children processes.
217 pub ki_rusage_ch: crate::rusage,
218 // This is normally "struct pcb".
219 /// Kernel virtual addr of pcb.
220 pub ki_pcb: *mut c_void,
221 /// Kernel virtual addr of stack.
222 pub ki_kstack: *mut c_void,
223 /// User convenience pointer.
224 pub ki_udata: *mut c_void,
225 // This is normally "struct thread".
226 pub ki_tdaddr: *mut c_void,
227 // This is normally "struct pwddesc".
228 /// Pointer to process paths info.
229 pub ki_pd: *mut c_void,
230 pub ki_spareptrs: [*mut c_void; crate::KI_NSPARE_PTR],
231 pub ki_sparelongs: [c_long; crate::KI_NSPARE_LONG],
232 /// PS_* flags.
233 pub ki_sflag: c_long,
234 /// kthread flag.
235 pub ki_tdflags: c_long,
236 }
237
238 pub struct stat {
239 pub st_dev: crate::dev_t,
240 pub st_ino: crate::ino_t,
241 pub st_nlink: crate::nlink_t,
242 pub st_mode: crate::mode_t,
243 st_padding0: i16,
244 pub st_uid: crate::uid_t,
245 pub st_gid: crate::gid_t,
246 st_padding1: i32,
247 pub st_rdev: crate::dev_t,
248 #[cfg(target_arch = "x86")]
249 st_atim_ext: i32,
250 pub st_atime: crate::time_t,
251 pub st_atime_nsec: c_long,
252 #[cfg(target_arch = "x86")]
253 st_mtim_ext: i32,
254 pub st_mtime: crate::time_t,
255 pub st_mtime_nsec: c_long,
256 #[cfg(target_arch = "x86")]
257 st_ctim_ext: i32,
258 pub st_ctime: crate::time_t,
259 pub st_ctime_nsec: c_long,
260 #[cfg(target_arch = "x86")]
261 st_btim_ext: i32,
262 pub st_birthtime: crate::time_t,
263 pub st_birthtime_nsec: c_long,
264 pub st_size: off_t,
265 pub st_blocks: crate::blkcnt_t,
266 pub st_blksize: crate::blksize_t,
267 pub st_flags: crate::fflags_t,
268 pub st_gen: u64,
269 pub st_spare: [u64; 10],
270 }
271 }
272
273 s_no_extra_traits! {
274 pub struct dirent {
275 pub d_fileno: crate::ino_t,
276 pub d_off: off_t,
277 pub d_reclen: u16,
278 pub d_type: u8,
279 d_pad0: u8,
280 pub d_namlen: u16,
281 d_pad1: u16,
282 pub d_name: [c_char; 256],
283 }
284
285 pub struct statfs {
286 pub f_version: u32,
287 pub f_type: u32,
288 pub f_flags: u64,
289 pub f_bsize: u64,
290 pub f_iosize: u64,
291 pub f_blocks: u64,
292 pub f_bfree: u64,
293 pub f_bavail: i64,
294 pub f_files: u64,
295 pub f_ffree: i64,
296 pub f_syncwrites: u64,
297 pub f_asyncwrites: u64,
298 pub f_syncreads: u64,
299 pub f_asyncreads: u64,
300 f_spare: [u64; 10],
301 pub f_namemax: u32,
302 pub f_owner: crate::uid_t,
303 pub f_fsid: crate::fsid_t,
304 f_charspare: [c_char; 80],
305 pub f_fstypename: [c_char; 16],
306 pub f_mntfromname: [c_char; 1024],
307 pub f_mntonname: [c_char; 1024],
308 }
309
310 pub struct vnstat {
311 pub vn_fileid: u64,
312 pub vn_size: u64,
313 pub vn_dev: u64,
314 pub vn_fsid: u64,
315 pub vn_mntdir: *mut c_char,
316 pub vn_type: c_int,
317 pub vn_mode: u16,
318 pub vn_devname: [c_char; crate::SPECNAMELEN as usize + 1],
319 }
320 }
321
322 cfg_if! {
323 if #[cfg(feature = "extra_traits")] {
324 impl PartialEq for statfs {
325 fn eq(&self, other: &statfs) -> bool {
326 self.f_version == other.f_version
327 && self.f_type == other.f_type
328 && self.f_flags == other.f_flags
329 && self.f_bsize == other.f_bsize
330 && self.f_iosize == other.f_iosize
331 && self.f_blocks == other.f_blocks
332 && self.f_bfree == other.f_bfree
333 && self.f_bavail == other.f_bavail
334 && self.f_files == other.f_files
335 && self.f_ffree == other.f_ffree
336 && self.f_syncwrites == other.f_syncwrites
337 && self.f_asyncwrites == other.f_asyncwrites
338 && self.f_syncreads == other.f_syncreads
339 && self.f_asyncreads == other.f_asyncreads
340 && self.f_namemax == other.f_namemax
341 && self.f_owner == other.f_owner
342 && self.f_fsid == other.f_fsid
343 && self.f_fstypename == other.f_fstypename
344 && self
345 .f_mntfromname
346 .iter()
347 .zip(other.f_mntfromname.iter())
348 .all(|(a, b)| a == b)
349 && self
350 .f_mntonname
351 .iter()
352 .zip(other.f_mntonname.iter())
353 .all(|(a, b)| a == b)
354 }
355 }
356 impl Eq for statfs {}
357 impl fmt::Debug for statfs {
358 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
359 f.debug_struct("statfs")
360 .field("f_bsize", &self.f_bsize)
361 .field("f_iosize", &self.f_iosize)
362 .field("f_blocks", &self.f_blocks)
363 .field("f_bfree", &self.f_bfree)
364 .field("f_bavail", &self.f_bavail)
365 .field("f_files", &self.f_files)
366 .field("f_ffree", &self.f_ffree)
367 .field("f_syncwrites", &self.f_syncwrites)
368 .field("f_asyncwrites", &self.f_asyncwrites)
369 .field("f_syncreads", &self.f_syncreads)
370 .field("f_asyncreads", &self.f_asyncreads)
371 .field("f_namemax", &self.f_namemax)
372 .field("f_owner", &self.f_owner)
373 .field("f_fsid", &self.f_fsid)
374 .field("f_fstypename", &self.f_fstypename)
375 .field("f_mntfromname", &&self.f_mntfromname[..])
376 .field("f_mntonname", &&self.f_mntonname[..])
377 .finish()
378 }
379 }
380 impl hash::Hash for statfs {
381 fn hash<H: hash::Hasher>(&self, state: &mut H) {
382 self.f_version.hash(state);
383 self.f_type.hash(state);
384 self.f_flags.hash(state);
385 self.f_bsize.hash(state);
386 self.f_iosize.hash(state);
387 self.f_blocks.hash(state);
388 self.f_bfree.hash(state);
389 self.f_bavail.hash(state);
390 self.f_files.hash(state);
391 self.f_ffree.hash(state);
392 self.f_syncwrites.hash(state);
393 self.f_asyncwrites.hash(state);
394 self.f_syncreads.hash(state);
395 self.f_asyncreads.hash(state);
396 self.f_namemax.hash(state);
397 self.f_owner.hash(state);
398 self.f_fsid.hash(state);
399 self.f_charspare.hash(state);
400 self.f_fstypename.hash(state);
401 self.f_mntfromname.hash(state);
402 self.f_mntonname.hash(state);
403 }
404 }
405
406 impl PartialEq for dirent {
407 fn eq(&self, other: &dirent) -> bool {
408 self.d_fileno == other.d_fileno
409 && self.d_off == other.d_off
410 && self.d_reclen == other.d_reclen
411 && self.d_type == other.d_type
412 && self.d_namlen == other.d_namlen
413 && self.d_name[..self.d_namlen as _]
414 .iter()
415 .zip(other.d_name.iter())
416 .all(|(a, b)| a == b)
417 }
418 }
419 impl Eq for dirent {}
420 impl fmt::Debug for dirent {
421 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
422 f.debug_struct("dirent")
423 .field("d_fileno", &self.d_fileno)
424 .field("d_off", &self.d_off)
425 .field("d_reclen", &self.d_reclen)
426 .field("d_type", &self.d_type)
427 .field("d_namlen", &self.d_namlen)
428 .field("d_name", &&self.d_name[..self.d_namlen as _])
429 .finish()
430 }
431 }
432 impl hash::Hash for dirent {
433 fn hash<H: hash::Hasher>(&self, state: &mut H) {
434 self.d_fileno.hash(state);
435 self.d_off.hash(state);
436 self.d_reclen.hash(state);
437 self.d_type.hash(state);
438 self.d_namlen.hash(state);
439 self.d_name[..self.d_namlen as _].hash(state);
440 }
441 }
442
443 impl PartialEq for vnstat {
444 fn eq(&self, other: &vnstat) -> bool {
445 let self_vn_devname: &[c_char] = &self.vn_devname;
446 let other_vn_devname: &[c_char] = &other.vn_devname;
447
448 self.vn_fileid == other.vn_fileid
449 && self.vn_size == other.vn_size
450 && self.vn_dev == other.vn_dev
451 && self.vn_fsid == other.vn_fsid
452 && self.vn_mntdir == other.vn_mntdir
453 && self.vn_type == other.vn_type
454 && self.vn_mode == other.vn_mode
455 && self_vn_devname == other_vn_devname
456 }
457 }
458 impl Eq for vnstat {}
459 impl fmt::Debug for vnstat {
460 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
461 let self_vn_devname: &[c_char] = &self.vn_devname;
462
463 f.debug_struct("vnstat")
464 .field("vn_fileid", &self.vn_fileid)
465 .field("vn_size", &self.vn_size)
466 .field("vn_dev", &self.vn_dev)
467 .field("vn_fsid", &self.vn_fsid)
468 .field("vn_mntdir", &self.vn_mntdir)
469 .field("vn_type", &self.vn_type)
470 .field("vn_mode", &self.vn_mode)
471 .field("vn_devname", &self_vn_devname)
472 .finish()
473 }
474 }
475 impl hash::Hash for vnstat {
476 fn hash<H: hash::Hasher>(&self, state: &mut H) {
477 let self_vn_devname: &[c_char] = &self.vn_devname;
478
479 self.vn_fileid.hash(state);
480 self.vn_size.hash(state);
481 self.vn_dev.hash(state);
482 self.vn_fsid.hash(state);
483 self.vn_mntdir.hash(state);
484 self.vn_type.hash(state);
485 self.vn_mode.hash(state);
486 self_vn_devname.hash(state);
487 }
488 }
489 }
490 }
491
492 pub const RAND_MAX: c_int = 0x7fff_ffff;
493 pub const ELAST: c_int = 97;
494
495 pub const KF_TYPE_EVENTFD: c_int = 13;
496
497 /// max length of devicename
498 pub const SPECNAMELEN: c_int = 255;
499 pub const KI_NSPARE_PTR: usize = 5;
500
501 /// domainset policies
502 pub const DOMAINSET_POLICY_INVALID: c_int = 0;
503 pub const DOMAINSET_POLICY_ROUNDROBIN: c_int = 1;
504 pub const DOMAINSET_POLICY_FIRSTTOUCH: c_int = 2;
505 pub const DOMAINSET_POLICY_PREFER: c_int = 3;
506 pub const DOMAINSET_POLICY_INTERLEAVE: c_int = 4;
507
508 pub const MINCORE_SUPER: c_int = 0x20;
509
510 safe_f! {
511 pub {const} fn makedev(major: c_uint, minor: c_uint) -> crate::dev_t {
512 let major = major as crate::dev_t;
513 let minor = minor as crate::dev_t;
514 let mut dev = 0;
515 dev |= ((major & 0xffffff00) as dev_t) << 32;
516 dev |= ((major & 0x000000ff) as dev_t) << 8;
517 dev |= ((minor & 0x0000ff00) as dev_t) << 24;
518 dev |= ((minor & 0xffff00ff) as dev_t) << 0;
519 dev
520 }
521
522 pub {const} fn major(dev: crate::dev_t) -> c_int {
523 (((dev >> 32) & 0xffffff00) | ((dev >> 8) & 0xff)) as c_int
524 }
525
526 pub {const} fn minor(dev: crate::dev_t) -> c_int {
527 (((dev >> 24) & 0xff00) | (dev & 0xffff00ff)) as c_int
528 }
529 }
530
531 extern "C" {
532 pub fn setgrent();
533 pub fn mprotect(addr: *mut c_void, len: size_t, prot: c_int) -> c_int;
534 pub fn freelocale(loc: crate::locale_t);
535 pub fn msgrcv(
536 msqid: c_int,
537 msgp: *mut c_void,
538 msgsz: size_t,
539 msgtyp: c_long,
540 msgflg: c_int,
541 ) -> ssize_t;
542
543 pub fn cpuset_getdomain(
544 level: crate::cpulevel_t,
545 which: crate::cpuwhich_t,
546 id: crate::id_t,
547 setsize: size_t,
548 mask: *mut crate::domainset_t,
549 policy: *mut c_int,
550 ) -> c_int;
551 pub fn cpuset_setdomain(
552 level: crate::cpulevel_t,
553 which: crate::cpuwhich_t,
554 id: crate::id_t,
555 setsize: size_t,
556 mask: *const crate::domainset_t,
557 policy: c_int,
558 ) -> c_int;
559
560 pub fn dirname(path: *mut c_char) -> *mut c_char;
561 pub fn basename(path: *mut c_char) -> *mut c_char;
562 }
563
564 #[link(name = "kvm")]
565 extern "C" {
566 pub fn kvm_kerndisp(kd: *mut crate::kvm_t) -> crate::kssize_t;
567 }
568
569 cfg_if! {
570 if #[cfg(target_arch = "x86_64")] {
571 mod x86_64;
572 pub use self::x86_64::*;
573 }
574 }