rustix/backend/libc/fs/
types.rs

1use crate::backend::c;
2use crate::ffi;
3use bitflags::bitflags;
4
5#[cfg(not(any(target_os = "espidf", target_os = "horizon", target_os = "vita")))]
6bitflags! {
7    /// `*_OK` constants for use with [`accessat`].
8    ///
9    /// [`accessat`]: fn.accessat.html
10    #[repr(transparent)]
11    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
12    pub struct Access: ffi::c_int {
13        /// `R_OK`
14        const READ_OK = c::R_OK;
15
16        /// `W_OK`
17        const WRITE_OK = c::W_OK;
18
19        /// `X_OK`
20        const EXEC_OK = c::X_OK;
21
22        /// `F_OK`
23        const EXISTS = c::F_OK;
24
25        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
26        const _ = !0;
27    }
28}
29
30#[cfg(not(any(target_os = "espidf", target_os = "horizon", target_os = "redox")))]
31bitflags! {
32    /// `AT_*` constants for use with [`openat`], [`statat`], and other `*at`
33    /// functions.
34    ///
35    /// [`openat`]: crate::fs::openat
36    /// [`statat`]: crate::fs::statat
37    #[repr(transparent)]
38    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
39    pub struct AtFlags: u32 {
40        /// `AT_SYMLINK_NOFOLLOW`
41        const SYMLINK_NOFOLLOW = bitcast!(c::AT_SYMLINK_NOFOLLOW);
42
43        /// `AT_EACCESS`
44        #[cfg(not(target_os = "android"))]
45        const EACCESS = bitcast!(c::AT_EACCESS);
46
47        /// `AT_REMOVEDIR`
48        const REMOVEDIR = bitcast!(c::AT_REMOVEDIR);
49
50        /// `AT_SYMLINK_FOLLOW`
51        const SYMLINK_FOLLOW = bitcast!(c::AT_SYMLINK_FOLLOW);
52
53        /// `AT_NO_AUTOMOUNT`
54        #[cfg(any(linux_like, target_os = "fuchsia"))]
55        const NO_AUTOMOUNT = bitcast!(c::AT_NO_AUTOMOUNT);
56
57        /// `AT_EMPTY_PATH`
58        #[cfg(any(
59            linux_kernel,
60            target_os = "freebsd",
61            target_os = "fuchsia",
62        ))]
63        const EMPTY_PATH = bitcast!(c::AT_EMPTY_PATH);
64
65        /// `AT_RESOLVE_BENEATH`
66        #[cfg(target_os = "freebsd")]
67        const RESOLVE_BENEATH = bitcast!(c::AT_RESOLVE_BENEATH);
68
69        /// `AT_STATX_SYNC_AS_STAT`
70        #[cfg(all(target_os = "linux", target_env = "gnu"))]
71        const STATX_SYNC_AS_STAT = bitcast!(c::AT_STATX_SYNC_AS_STAT);
72
73        /// `AT_STATX_FORCE_SYNC`
74        #[cfg(all(target_os = "linux", target_env = "gnu"))]
75        const STATX_FORCE_SYNC = bitcast!(c::AT_STATX_FORCE_SYNC);
76
77        /// `AT_STATX_DONT_SYNC`
78        #[cfg(all(target_os = "linux", target_env = "gnu"))]
79        const STATX_DONT_SYNC = bitcast!(c::AT_STATX_DONT_SYNC);
80
81        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
82        const _ = !0;
83    }
84}
85
86#[cfg(target_os = "horizon")]
87bitflags! {
88    /// `AT_*` constants for use with [`openat`], [`statat`], and other `*at`
89    /// functions.
90    ///
91    /// [`openat`]: crate::fs::openat
92    /// [`statat`]: crate::fs::statat
93    #[repr(transparent)]
94    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
95    pub struct AtFlags: u32 {
96        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
97        const _ = !0;
98    }
99}
100
101#[cfg(not(target_os = "horizon"))]
102bitflags! {
103    /// `S_I*` constants for use with [`openat`], [`chmodat`], and [`fchmod`].
104    ///
105    /// [`openat`]: crate::fs::openat
106    /// [`chmodat`]: crate::fs::chmodat
107    /// [`fchmod`]: crate::fs::fchmod
108    #[repr(transparent)]
109    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
110    pub struct Mode: RawMode {
111        /// `S_IRWXU`
112        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
113        const RWXU = c::S_IRWXU as RawMode;
114
115        /// `S_IRUSR`
116        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
117        const RUSR = c::S_IRUSR as RawMode;
118
119        /// `S_IWUSR`
120        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
121        const WUSR = c::S_IWUSR as RawMode;
122
123        /// `S_IXUSR`
124        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
125        const XUSR = c::S_IXUSR as RawMode;
126
127        /// `S_IRWXG`
128        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
129        const RWXG = c::S_IRWXG as RawMode;
130
131        /// `S_IRGRP`
132        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
133        const RGRP = c::S_IRGRP as RawMode;
134
135        /// `S_IWGRP`
136        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
137        const WGRP = c::S_IWGRP as RawMode;
138
139        /// `S_IXGRP`
140        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
141        const XGRP = c::S_IXGRP as RawMode;
142
143        /// `S_IRWXO`
144        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
145        const RWXO = c::S_IRWXO as RawMode;
146
147        /// `S_IROTH`
148        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
149        const ROTH = c::S_IROTH as RawMode;
150
151        /// `S_IWOTH`
152        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
153        const WOTH = c::S_IWOTH as RawMode;
154
155        /// `S_IXOTH`
156        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
157        const XOTH = c::S_IXOTH as RawMode;
158
159        /// `S_ISUID`
160        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
161        const SUID = c::S_ISUID as RawMode;
162
163        /// `S_ISGID`
164        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
165        const SGID = c::S_ISGID as RawMode;
166
167        /// `S_ISVTX`
168        #[cfg(not(any(target_os = "espidf", target_os = "vita")))]
169        const SVTX = c::S_ISVTX as RawMode;
170
171        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
172        const _ = !0;
173    }
174}
175
176#[cfg(target_os = "horizon")]
177bitflags! {
178    /// `S_I*` constants for use with [`openat`], [`chmodat`], and [`fchmod`].
179    ///
180    /// [`openat`]: crate::fs::openat
181    /// [`chmodat`]: crate::fs::chmodat
182    /// [`fchmod`]: crate::fs::fchmod
183    #[repr(transparent)]
184    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
185    pub struct Mode: RawMode {
186        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
187        const _ = !0;
188    }
189}
190
191#[cfg(not(target_os = "espidf"))]
192impl Mode {
193    /// Construct a `Mode` from the mode bits of the `st_mode` field of a
194    /// `Mode`.
195    #[inline]
196    pub const fn from_raw_mode(st_mode: RawMode) -> Self {
197        Self::from_bits_truncate(st_mode & !c::S_IFMT as RawMode)
198    }
199
200    /// Construct an `st_mode` value from a `Mode`.
201    #[inline]
202    pub const fn as_raw_mode(self) -> RawMode {
203        self.bits()
204    }
205}
206
207#[cfg(not(target_os = "espidf"))]
208impl From<RawMode> for Mode {
209    /// Support conversions from raw mode values to `Mode`.
210    ///
211    /// ```
212    /// use rustix::fs::{Mode, RawMode};
213    /// assert_eq!(Mode::from(0o700), Mode::RWXU);
214    /// ```
215    #[inline]
216    fn from(st_mode: RawMode) -> Self {
217        Self::from_raw_mode(st_mode)
218    }
219}
220
221#[cfg(not(target_os = "espidf"))]
222impl From<Mode> for RawMode {
223    /// Support conversions from `Mode` to raw mode values.
224    ///
225    /// ```
226    /// use rustix::fs::{Mode, RawMode};
227    /// assert_eq!(RawMode::from(Mode::RWXU), 0o700);
228    /// ```
229    #[inline]
230    fn from(mode: Mode) -> Self {
231        mode.as_raw_mode()
232    }
233}
234
235bitflags! {
236    /// `O_*` constants for use with [`openat`].
237    ///
238    /// [`openat`]: crate::fs::openat
239    #[repr(transparent)]
240    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
241    pub struct OFlags: u32 {
242        /// `O_ACCMODE`
243        const ACCMODE = bitcast!(c::O_ACCMODE);
244
245        /// Similar to `ACCMODE`, but just includes the read/write flags, and
246        /// no other flags.
247        ///
248        /// On some platforms, `PATH` may be included in `ACCMODE`, when
249        /// sometimes we really just want the read/write bits. Caution is
250        /// indicated, as the presence of `PATH` may mean that the read/write
251        /// bits don't have their usual meaning.
252        const RWMODE = bitcast!(c::O_RDONLY | c::O_WRONLY | c::O_RDWR);
253
254        /// `O_APPEND`
255        const APPEND = bitcast!(c::O_APPEND);
256
257        /// `O_CREAT`
258        #[doc(alias = "CREAT")]
259        const CREATE = bitcast!(c::O_CREAT);
260
261        /// `O_DIRECTORY`
262        #[cfg(not(any(target_os = "espidf", target_os = "horizon")))]
263        const DIRECTORY = bitcast!(c::O_DIRECTORY);
264
265        /// `O_DSYNC`
266        #[cfg(not(any(target_os = "dragonfly", target_os = "espidf", target_os = "horizon", target_os = "l4re", target_os = "redox", target_os = "vita")))]
267        const DSYNC = bitcast!(c::O_DSYNC);
268
269        /// `O_EXCL`
270        const EXCL = bitcast!(c::O_EXCL);
271
272        /// `O_FSYNC`
273        #[cfg(any(
274            bsd,
275            all(target_os = "linux", not(target_env = "musl")),
276        ))]
277        const FSYNC = bitcast!(c::O_FSYNC);
278
279        /// `O_NOFOLLOW`
280        #[cfg(not(any(target_os = "espidf", target_os = "horizon")))]
281        const NOFOLLOW = bitcast!(c::O_NOFOLLOW);
282
283        /// `O_NONBLOCK`
284        const NONBLOCK = bitcast!(c::O_NONBLOCK);
285
286        /// `O_RDONLY`
287        const RDONLY = bitcast!(c::O_RDONLY);
288
289        /// `O_WRONLY`
290        const WRONLY = bitcast!(c::O_WRONLY);
291
292        /// `O_RDWR`
293        ///
294        /// This is not equal to `RDONLY | WRONLY`. It's a distinct flag.
295        const RDWR = bitcast!(c::O_RDWR);
296
297        /// `O_NOCTTY`
298        #[cfg(not(any(target_os = "espidf", target_os = "horizon", target_os = "l4re", target_os = "redox", target_os = "vita")))]
299        const NOCTTY = bitcast!(c::O_NOCTTY);
300
301        /// `O_RSYNC`
302        #[cfg(any(
303            linux_kernel,
304            netbsdlike,
305            solarish,
306            target_os = "emscripten",
307            target_os = "wasi",
308        ))]
309        const RSYNC = bitcast!(c::O_RSYNC);
310
311        /// `O_SYNC`
312        #[cfg(not(any(target_os = "l4re", target_os = "redox")))]
313        const SYNC = bitcast!(c::O_SYNC);
314
315        /// `O_TRUNC`
316        const TRUNC = bitcast!(c::O_TRUNC);
317
318        /// `O_PATH`
319        #[cfg(any(
320            linux_kernel,
321            target_os = "emscripten",
322            target_os = "freebsd",
323            target_os = "fuchsia",
324            target_os = "redox",
325        ))]
326        const PATH = bitcast!(c::O_PATH);
327
328        /// `O_CLOEXEC`
329        const CLOEXEC = bitcast!(c::O_CLOEXEC);
330
331        /// `O_TMPFILE`
332        #[cfg(any(
333            linux_kernel,
334            target_os = "emscripten",
335            target_os = "fuchsia",
336        ))]
337        const TMPFILE = bitcast!(c::O_TMPFILE);
338
339        /// `O_NOATIME`
340        #[cfg(any(
341            linux_kernel,
342            target_os = "fuchsia",
343        ))]
344        const NOATIME = bitcast!(c::O_NOATIME);
345
346        /// `O_DIRECT`
347        #[cfg(any(
348            linux_kernel,
349            target_os = "emscripten",
350            target_os = "freebsd",
351            target_os = "fuchsia",
352            target_os = "netbsd",
353        ))]
354        const DIRECT = bitcast!(c::O_DIRECT);
355
356        /// `O_RESOLVE_BENEATH`
357        #[cfg(target_os = "freebsd")]
358        const RESOLVE_BENEATH = bitcast!(c::O_RESOLVE_BENEATH);
359
360        /// `O_EMPTY_PATH`
361        #[cfg(target_os = "freebsd")]
362        const EMPTY_PATH = bitcast!(c::O_EMPTY_PATH);
363
364        /// `O_LARGEFILE`
365        ///
366        /// Rustix and/or libc will automatically set this flag when
367        /// appropriate in the [`rustix::fs::open`] family of functions, so
368        /// typical users do not need to care about it. It may be reported in
369        /// the return of `fcntl_getfl`, though.
370        #[cfg(any(linux_kernel, solarish))]
371        const LARGEFILE = bitcast!(c::O_LARGEFILE);
372
373        /// `O_ASYNC`, `FASYNC`
374        ///
375        /// This flag can't be used with the [`rustix::fs::open`] family of
376        /// functions, use [`rustix::fs::fcntl_setfl`] instead.
377        #[cfg(not(any(
378            target_os = "aix",
379            target_os = "cygwin",
380            target_os = "espidf",
381            target_os = "haiku",
382            target_os = "horizon",
383            target_os = "wasi",
384            target_os = "vita",
385            solarish
386        )))]
387        const ASYNC = bitcast!(c::O_ASYNC);
388
389        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
390        const _ = !0;
391    }
392}
393
394#[cfg(apple)]
395bitflags! {
396    /// `CLONE_*` constants for use with [`fclonefileat`].
397    ///
398    /// [`fclonefileat`]: crate::fs::fclonefileat
399    #[repr(transparent)]
400    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
401    pub struct CloneFlags: u32 {
402        /// `CLONE_NOFOLLOW`
403        const NOFOLLOW = 1;
404
405        /// `CLONE_NOOWNERCOPY`
406        const NOOWNERCOPY = 2;
407
408        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
409        const _ = !0;
410    }
411}
412
413#[cfg(apple)]
414mod copyfile {
415    pub(super) const ACL: u32 = 1 << 0;
416    pub(super) const STAT: u32 = 1 << 1;
417    pub(super) const XATTR: u32 = 1 << 2;
418    pub(super) const DATA: u32 = 1 << 3;
419    pub(super) const SECURITY: u32 = STAT | ACL;
420    pub(super) const METADATA: u32 = SECURITY | XATTR;
421    pub(super) const ALL: u32 = METADATA | DATA;
422}
423
424#[cfg(apple)]
425bitflags! {
426    /// `COPYFILE_*` constants for use with [`fcopyfile`].
427    ///
428    /// [`fcopyfile`]: crate::fs::fcopyfile
429    #[repr(transparent)]
430    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
431    pub struct CopyfileFlags: ffi::c_uint {
432        /// `COPYFILE_ACL`
433        const ACL = copyfile::ACL;
434
435        /// `COPYFILE_STAT`
436        const STAT = copyfile::STAT;
437
438        /// `COPYFILE_XATTR`
439        const XATTR = copyfile::XATTR;
440
441        /// `COPYFILE_DATA`
442        const DATA = copyfile::DATA;
443
444        /// `COPYFILE_SECURITY`
445        const SECURITY = copyfile::SECURITY;
446
447        /// `COPYFILE_METADATA`
448        const METADATA = copyfile::METADATA;
449
450        /// `COPYFILE_ALL`
451        const ALL = copyfile::ALL;
452
453        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
454        const _ = !0;
455    }
456}
457
458#[cfg(linux_kernel)]
459bitflags! {
460    /// `RESOLVE_*` constants for use with [`openat2`].
461    ///
462    /// [`openat2`]: crate::fs::openat2
463    #[repr(transparent)]
464    #[derive(Default, Copy, Clone, Eq, PartialEq, Hash, Debug)]
465    pub struct ResolveFlags: u64 {
466        /// `RESOLVE_NO_XDEV`
467        const NO_XDEV = 0x01;
468
469        /// `RESOLVE_NO_MAGICLINKS`
470        const NO_MAGICLINKS = 0x02;
471
472        /// `RESOLVE_NO_SYMLINKS`
473        const NO_SYMLINKS = 0x04;
474
475        /// `RESOLVE_BENEATH`
476        const BENEATH = 0x08;
477
478        /// `RESOLVE_IN_ROOT`
479        const IN_ROOT = 0x10;
480
481        /// `RESOLVE_CACHED` (since Linux 5.12)
482        const CACHED = 0x20;
483
484        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
485        const _ = !0;
486    }
487}
488
489#[cfg(linux_kernel)]
490bitflags! {
491    /// `RENAME_*` constants for use with [`renameat_with`].
492    ///
493    /// [`renameat_with`]: crate::fs::renameat_with
494    #[repr(transparent)]
495    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
496    pub struct RenameFlags: ffi::c_uint {
497        /// `RENAME_EXCHANGE`
498        const EXCHANGE = bitcast!(c::RENAME_EXCHANGE);
499
500        /// `RENAME_NOREPLACE`
501        const NOREPLACE = bitcast!(c::RENAME_NOREPLACE);
502
503        /// `RENAME_WHITEOUT`
504        const WHITEOUT = bitcast!(c::RENAME_WHITEOUT);
505
506        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
507        const _ = !0;
508    }
509}
510
511#[cfg(apple)]
512bitflags! {
513    /// `RENAME_*` constants for use with [`renameat_with`].
514    ///
515    /// [`renameat_with`]: crate::fs::renameat_with
516    #[repr(transparent)]
517    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
518    pub struct RenameFlags: ffi::c_uint {
519        /// `RENAME_SWAP`
520        const EXCHANGE = bitcast!(c::RENAME_SWAP);
521
522        /// `RENAME_EXCL`
523        const NOREPLACE = bitcast!(c::RENAME_EXCL);
524
525        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
526        const _ = !0;
527    }
528}
529
530/// `S_IF*` constants for use with [`mknodat`] and [`Stat`]'s `st_mode` field.
531///
532/// [`mknodat`]: crate::fs::mknodat
533/// [`Stat`]: crate::fs::Stat
534#[derive(Clone, Copy, Debug, PartialEq, Eq)]
535pub enum FileType {
536    /// `S_IFREG`
537    RegularFile = c::S_IFREG as isize,
538
539    /// `S_IFDIR`
540    Directory = c::S_IFDIR as isize,
541
542    /// `S_IFLNK`
543    Symlink = c::S_IFLNK as isize,
544
545    /// `S_IFIFO`
546    #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFIFO`.
547    #[doc(alias = "IFO")]
548    Fifo = c::S_IFIFO as isize,
549
550    /// `S_IFSOCK`
551    #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFSOCK`.
552    Socket = c::S_IFSOCK as isize,
553
554    /// `S_IFCHR`
555    CharacterDevice = c::S_IFCHR as isize,
556
557    /// `S_IFBLK`
558    BlockDevice = c::S_IFBLK as isize,
559
560    /// An unknown filesystem object.
561    Unknown,
562}
563
564impl FileType {
565    /// Construct a `FileType` from the `S_IFMT` bits of the `st_mode` field of
566    /// a `Stat`.
567    #[inline]
568    pub const fn from_raw_mode(st_mode: RawMode) -> Self {
569        match (st_mode as c::mode_t) & c::S_IFMT {
570            c::S_IFREG => Self::RegularFile,
571            c::S_IFDIR => Self::Directory,
572            c::S_IFLNK => Self::Symlink,
573            #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFIFO`.
574            c::S_IFIFO => Self::Fifo,
575            #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFSOCK`.
576            c::S_IFSOCK => Self::Socket,
577            c::S_IFCHR => Self::CharacterDevice,
578            c::S_IFBLK => Self::BlockDevice,
579            _ => Self::Unknown,
580        }
581    }
582
583    /// Construct an `st_mode` value from a `FileType`.
584    #[inline]
585    pub const fn as_raw_mode(self) -> RawMode {
586        match self {
587            Self::RegularFile => c::S_IFREG as RawMode,
588            Self::Directory => c::S_IFDIR as RawMode,
589            Self::Symlink => c::S_IFLNK as RawMode,
590            #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFIFO`.
591            Self::Fifo => c::S_IFIFO as RawMode,
592            #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `S_IFSOCK`.
593            Self::Socket => c::S_IFSOCK as RawMode,
594            Self::CharacterDevice => c::S_IFCHR as RawMode,
595            Self::BlockDevice => c::S_IFBLK as RawMode,
596            Self::Unknown => c::S_IFMT as RawMode,
597        }
598    }
599
600    /// Construct a `FileType` from the `d_type` field of a `c::dirent`.
601    #[cfg(not(any(
602        solarish,
603        target_os = "aix",
604        target_os = "espidf",
605        target_os = "haiku",
606        target_os = "nto",
607        target_os = "redox",
608        target_os = "vita"
609    )))]
610    #[inline]
611    pub(crate) const fn from_dirent_d_type(d_type: u8) -> Self {
612        match d_type {
613            c::DT_REG => Self::RegularFile,
614            c::DT_DIR => Self::Directory,
615            c::DT_LNK => Self::Symlink,
616            #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `DT_SOCK`.
617            c::DT_SOCK => Self::Socket,
618            #[cfg(not(target_os = "wasi"))] // TODO: Use WASI's `DT_FIFO`.
619            c::DT_FIFO => Self::Fifo,
620            c::DT_CHR => Self::CharacterDevice,
621            c::DT_BLK => Self::BlockDevice,
622            // c::DT_UNKNOWN |
623            _ => Self::Unknown,
624        }
625    }
626}
627
628/// `POSIX_FADV_*` constants for use with [`fadvise`].
629///
630/// [`fadvise`]: crate::fs::fadvise
631#[cfg(not(any(
632    apple,
633    netbsdlike,
634    target_os = "dragonfly",
635    target_os = "espidf",
636    target_os = "horizon",
637    target_os = "haiku",
638    target_os = "redox",
639    target_os = "solaris",
640    target_os = "vita",
641)))]
642#[derive(Debug, Copy, Clone, Eq, PartialEq)]
643#[repr(u32)]
644pub enum Advice {
645    /// `POSIX_FADV_NORMAL`
646    Normal = c::POSIX_FADV_NORMAL as c::c_uint,
647
648    /// `POSIX_FADV_SEQUENTIAL`
649    Sequential = c::POSIX_FADV_SEQUENTIAL as c::c_uint,
650
651    /// `POSIX_FADV_RANDOM`
652    Random = c::POSIX_FADV_RANDOM as c::c_uint,
653
654    /// `POSIX_FADV_NOREUSE`
655    NoReuse = c::POSIX_FADV_NOREUSE as c::c_uint,
656
657    /// `POSIX_FADV_WILLNEED`
658    WillNeed = c::POSIX_FADV_WILLNEED as c::c_uint,
659
660    /// `POSIX_FADV_DONTNEED`
661    DontNeed = c::POSIX_FADV_DONTNEED as c::c_uint,
662}
663
664#[cfg(any(linux_kernel, target_os = "freebsd"))]
665bitflags! {
666    /// `MFD_*` constants for use with [`memfd_create`].
667    ///
668    /// [`memfd_create`]: crate::fs::memfd_create
669    #[repr(transparent)]
670    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
671    pub struct MemfdFlags: ffi::c_uint {
672        /// `MFD_CLOEXEC`
673        const CLOEXEC = c::MFD_CLOEXEC;
674
675        /// `MFD_ALLOW_SEALING`
676        const ALLOW_SEALING = c::MFD_ALLOW_SEALING;
677
678        /// `MFD_HUGETLB` (since Linux 4.14)
679        const HUGETLB = c::MFD_HUGETLB;
680
681        /// `MFD_NOEXEC_SEAL` (since Linux 6.3)
682        #[cfg(linux_kernel)]
683        const NOEXEC_SEAL = c::MFD_NOEXEC_SEAL;
684        /// `MFD_EXEC` (since Linux 6.3)
685        #[cfg(linux_kernel)]
686        const EXEC = c::MFD_EXEC;
687
688        /// `MFD_HUGE_64KB`
689        const HUGE_64KB = c::MFD_HUGE_64KB;
690        /// `MFD_HUGE_512JB`
691        const HUGE_512KB = c::MFD_HUGE_512KB;
692        /// `MFD_HUGE_1MB`
693        const HUGE_1MB = c::MFD_HUGE_1MB;
694        /// `MFD_HUGE_2MB`
695        const HUGE_2MB = c::MFD_HUGE_2MB;
696        /// `MFD_HUGE_8MB`
697        const HUGE_8MB = c::MFD_HUGE_8MB;
698        /// `MFD_HUGE_16MB`
699        const HUGE_16MB = c::MFD_HUGE_16MB;
700        /// `MFD_HUGE_32MB`
701        const HUGE_32MB = c::MFD_HUGE_32MB;
702        /// `MFD_HUGE_256MB`
703        const HUGE_256MB = c::MFD_HUGE_256MB;
704        /// `MFD_HUGE_512MB`
705        const HUGE_512MB = c::MFD_HUGE_512MB;
706        /// `MFD_HUGE_1GB`
707        const HUGE_1GB = c::MFD_HUGE_1GB;
708        /// `MFD_HUGE_2GB`
709        const HUGE_2GB = c::MFD_HUGE_2GB;
710        /// `MFD_HUGE_16GB`
711        const HUGE_16GB = c::MFD_HUGE_16GB;
712
713        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
714        const _ = !0;
715    }
716}
717
718#[cfg(any(linux_kernel, target_os = "freebsd", target_os = "fuchsia"))]
719bitflags! {
720    /// `F_SEAL_*` constants for use with [`fcntl_add_seals`] and
721    /// [`fcntl_get_seals`].
722    ///
723    /// [`fcntl_add_seals`]: crate::fs::fcntl_add_seals
724    /// [`fcntl_get_seals`]: crate::fs::fcntl_get_seals
725    #[repr(transparent)]
726    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
727    pub struct SealFlags: u32 {
728        /// `F_SEAL_SEAL`
729        const SEAL = bitcast!(c::F_SEAL_SEAL);
730        /// `F_SEAL_SHRINK`
731        const SHRINK = bitcast!(c::F_SEAL_SHRINK);
732        /// `F_SEAL_GROW`
733        const GROW = bitcast!(c::F_SEAL_GROW);
734        /// `F_SEAL_WRITE`
735        const WRITE = bitcast!(c::F_SEAL_WRITE);
736        /// `F_SEAL_FUTURE_WRITE` (since Linux 5.1)
737        #[cfg(linux_kernel)]
738        const FUTURE_WRITE = bitcast!(c::F_SEAL_FUTURE_WRITE);
739        /// `F_SEAL_EXEC` (since Linux 6.3)
740        #[cfg(linux_kernel)]
741        const EXEC = bitcast!(c::F_SEAL_EXEC);
742
743        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
744        const _ = !0;
745    }
746}
747
748#[cfg(not(any(
749    netbsdlike,
750    target_os = "espidf",
751    target_os = "horizon",
752    target_os = "nto",
753    target_os = "redox",
754    target_os = "vita"
755)))]
756bitflags! {
757    /// `FALLOC_FL_*` constants for use with [`fallocate`].
758    ///
759    /// [`fallocate`]: crate::fs::fallocate
760    #[repr(transparent)]
761    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
762    pub struct FallocateFlags: u32 {
763        /// `FALLOC_FL_KEEP_SIZE`
764        #[cfg(not(any(
765            bsd,
766            solarish,
767            target_os = "aix",
768            target_os = "haiku",
769            target_os = "hurd",
770            target_os = "wasi",
771        )))]
772        const KEEP_SIZE = bitcast!(c::FALLOC_FL_KEEP_SIZE);
773        /// `FALLOC_FL_PUNCH_HOLE`
774        #[cfg(not(any(
775            bsd,
776            solarish,
777            target_os = "aix",
778            target_os = "haiku",
779            target_os = "hurd",
780            target_os = "wasi",
781        )))]
782        const PUNCH_HOLE = bitcast!(c::FALLOC_FL_PUNCH_HOLE);
783        /// `FALLOC_FL_NO_HIDE_STALE`
784        #[cfg(not(any(
785            bsd,
786            solarish,
787            target_os = "aix",
788            target_os = "cygwin",
789            target_os = "emscripten",
790            target_os = "fuchsia",
791            target_os = "haiku",
792            target_os = "hurd",
793            target_os = "l4re",
794            target_os = "linux",
795            target_os = "wasi",
796        )))]
797        const NO_HIDE_STALE = bitcast!(c::FALLOC_FL_NO_HIDE_STALE);
798        /// `FALLOC_FL_COLLAPSE_RANGE`
799        #[cfg(not(any(
800            bsd,
801            solarish,
802            target_os = "aix",
803            target_os = "haiku",
804            target_os = "hurd",
805            target_os = "emscripten",
806            target_os = "wasi",
807        )))]
808        const COLLAPSE_RANGE = bitcast!(c::FALLOC_FL_COLLAPSE_RANGE);
809        /// `FALLOC_FL_ZERO_RANGE`
810        #[cfg(not(any(
811            bsd,
812            solarish,
813            target_os = "aix",
814            target_os = "haiku",
815            target_os = "hurd",
816            target_os = "emscripten",
817            target_os = "wasi",
818        )))]
819        const ZERO_RANGE = bitcast!(c::FALLOC_FL_ZERO_RANGE);
820        /// `FALLOC_FL_INSERT_RANGE`
821        #[cfg(not(any(
822            bsd,
823            solarish,
824            target_os = "aix",
825            target_os = "haiku",
826            target_os = "hurd",
827            target_os = "emscripten",
828            target_os = "wasi",
829        )))]
830        const INSERT_RANGE = bitcast!(c::FALLOC_FL_INSERT_RANGE);
831        /// `FALLOC_FL_UNSHARE_RANGE`
832        #[cfg(not(any(
833            bsd,
834            solarish,
835            target_os = "aix",
836            target_os = "haiku",
837            target_os = "hurd",
838            target_os = "emscripten",
839            target_os = "wasi",
840        )))]
841        const UNSHARE_RANGE = bitcast!(c::FALLOC_FL_UNSHARE_RANGE);
842
843        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
844        const _ = !0;
845    }
846}
847
848#[cfg(not(target_os = "wasi"))]
849bitflags! {
850    /// `ST_*` constants for use with [`StatVfs`].
851    #[repr(transparent)]
852    #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
853    pub struct StatVfsMountFlags: u64 {
854        /// `ST_MANDLOCK`
855        #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
856        const MANDLOCK = c::ST_MANDLOCK as u64;
857
858        /// `ST_NOATIME`
859        #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
860        const NOATIME = c::ST_NOATIME as u64;
861
862        /// `ST_NODEV`
863        #[cfg(any(
864            linux_kernel,
865            target_os = "aix",
866            target_os = "emscripten",
867            target_os = "fuchsia"
868        ))]
869        const NODEV = c::ST_NODEV as u64;
870
871        /// `ST_NODIRATIME`
872        #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
873        const NODIRATIME = c::ST_NODIRATIME as u64;
874
875        /// `ST_NOEXEC`
876        #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
877        const NOEXEC = c::ST_NOEXEC as u64;
878
879        /// `ST_NOSUID`
880        #[cfg(not(any(target_os = "espidf", target_os = "haiku", target_os = "horizon", target_os = "redox", target_os = "vita")))]
881        const NOSUID = c::ST_NOSUID as u64;
882
883        /// `ST_RDONLY`
884        #[cfg(not(any(target_os = "espidf", target_os = "haiku", target_os = "horizon", target_os = "redox", target_os = "vita")))]
885        const RDONLY = c::ST_RDONLY as u64;
886
887        /// `ST_RELATIME`
888        #[cfg(any(target_os = "android", all(target_os = "linux", target_env = "gnu")))]
889        const RELATIME = c::ST_RELATIME as u64;
890
891        /// `ST_SYNCHRONOUS`
892        #[cfg(any(linux_kernel, target_os = "emscripten", target_os = "fuchsia"))]
893        const SYNCHRONOUS = c::ST_SYNCHRONOUS as u64;
894
895        /// <https://docs.rs/bitflags/*/bitflags/#externally-defined-flags>
896        const _ = !0;
897    }
898}
899
900/// `LOCK_*` constants for use with [`flock`] and [`fcntl_lock`].
901///
902/// [`flock`]: crate::fs::flock
903/// [`fcntl_lock`]: crate::fs::fcntl_lock
904// Solaris doesn't support `flock` and doesn't define `LOCK_SH` etc., but we
905// reuse this `FlockOperation` enum for `fcntl_lock`, so on Solaris we use
906// our own made-up integer values.
907#[cfg(not(any(
908    target_os = "espidf",
909    target_os = "horizon",
910    target_os = "vita",
911    target_os = "wasi"
912)))]
913#[derive(Clone, Copy, Debug, PartialEq, Eq)]
914#[repr(u32)]
915pub enum FlockOperation {
916    /// `LOCK_SH`
917    #[cfg(not(target_os = "solaris"))]
918    LockShared = bitcast!(c::LOCK_SH),
919    /// `LOCK_SH`
920    #[cfg(target_os = "solaris")]
921    LockShared = bitcast!(1),
922    /// `LOCK_EX`
923    #[cfg(not(target_os = "solaris"))]
924    LockExclusive = bitcast!(c::LOCK_EX),
925    /// `LOCK_EX`
926    #[cfg(target_os = "solaris")]
927    LockExclusive = bitcast!(2),
928    /// `LOCK_UN`
929    #[cfg(not(target_os = "solaris"))]
930    Unlock = bitcast!(c::LOCK_UN),
931    /// `LOCK_UN`
932    #[cfg(target_os = "solaris")]
933    Unlock = bitcast!(8),
934    /// `LOCK_SH | LOCK_NB`
935    #[cfg(not(target_os = "solaris"))]
936    NonBlockingLockShared = bitcast!(c::LOCK_SH | c::LOCK_NB),
937    /// `LOCK_SH | LOCK_NB`
938    #[cfg(target_os = "solaris")]
939    NonBlockingLockShared = bitcast!(1 | 4),
940    /// `LOCK_EX | LOCK_NB`
941    #[cfg(not(target_os = "solaris"))]
942    NonBlockingLockExclusive = bitcast!(c::LOCK_EX | c::LOCK_NB),
943    /// `LOCK_EX | LOCK_NB`
944    #[cfg(target_os = "solaris")]
945    NonBlockingLockExclusive = bitcast!(2 | 4),
946    /// `LOCK_UN | LOCK_NB`
947    #[cfg(not(target_os = "solaris"))]
948    NonBlockingUnlock = bitcast!(c::LOCK_UN | c::LOCK_NB),
949    /// `LOCK_UN | LOCK_NB`
950    #[cfg(target_os = "solaris")]
951    NonBlockingUnlock = bitcast!(8 | 4),
952}
953
954/// `struct stat` for use with [`statat`] and [`fstat`].
955///
956/// [`statat`]: crate::fs::statat
957/// [`fstat`]: crate::fs::fstat
958#[cfg(not(any(linux_like, target_os = "hurd", target_os = "netbsd")))]
959pub type Stat = c::stat;
960
961/// `struct stat` for use with [`statat`] and [`fstat`].
962///
963/// [`statat`]: crate::fs::statat
964/// [`fstat`]: crate::fs::fstat
965#[cfg(any(
966    all(linux_kernel, target_pointer_width = "64"),
967    target_os = "hurd",
968    target_os = "emscripten",
969    target_os = "l4re",
970))]
971pub type Stat = c::stat64;
972
973/// `struct stat` for use with [`statat`] and [`fstat`].
974///
975/// [`statat`]: crate::fs::statat
976/// [`fstat`]: crate::fs::fstat
977// On 32-bit, Linux's `struct stat64` has a 32-bit `st_mtime` and friends, so
978// we use our own struct, populated from `statx` where possible, to avoid the
979// y2038 bug.
980#[cfg(all(linux_kernel, target_pointer_width = "32"))]
981#[derive(Debug, Copy, Clone)]
982#[allow(missing_docs)]
983pub struct Stat {
984    pub st_dev: u64,
985    pub st_mode: u32,
986    pub st_nlink: u64,
987    pub st_uid: u32,
988    pub st_gid: u32,
989    pub st_rdev: u64,
990    pub st_size: i64,
991    pub st_blksize: u32,
992    pub st_blocks: u64,
993    pub st_atime: i64,
994    pub st_atime_nsec: u32,
995    pub st_mtime: i64,
996    pub st_mtime_nsec: u32,
997    pub st_ctime: i64,
998    pub st_ctime_nsec: u32,
999    pub st_ino: u64,
1000}
1001
1002/// `struct stat` for use with [`statat`] and [`fstat`].
1003///
1004/// [`statat`]: crate::fs::statat
1005/// [`fstat`]: crate::fs::fstat
1006// NetBSD's `st_mtime_nsec` is named `st_mtimensec` so we declare our own
1007// `Stat` so that we can be consistent with other platforms.
1008#[cfg(target_os = "netbsd")]
1009#[derive(Debug, Copy, Clone)]
1010#[allow(missing_docs)]
1011#[repr(C)]
1012pub struct Stat {
1013    pub st_dev: c::dev_t,
1014    pub st_mode: c::mode_t,
1015    pub st_ino: c::ino_t,
1016    pub st_nlink: c::nlink_t,
1017    pub st_uid: c::uid_t,
1018    pub st_gid: c::gid_t,
1019    pub st_rdev: c::dev_t,
1020    pub st_atime: c::time_t,
1021    pub st_atime_nsec: c::c_long,
1022    pub st_mtime: c::time_t,
1023    pub st_mtime_nsec: c::c_long,
1024    pub st_ctime: c::time_t,
1025    pub st_ctime_nsec: c::c_long,
1026    pub st_birthtime: c::time_t,
1027    pub st_birthtime_nsec: c::c_long,
1028    pub st_size: c::off_t,
1029    pub st_blocks: c::blkcnt_t,
1030    pub st_blksize: c::blksize_t,
1031    pub st_flags: u32,
1032    pub st_gen: u32,
1033    pub st_spare: [u32; 2],
1034}
1035
1036/// `struct statfs` for use with [`statfs`] and [`fstatfs`].
1037///
1038/// [`statfs`]: crate::fs::statfs
1039/// [`fstatfs`]: crate::fs::fstatfs
1040#[cfg(not(any(
1041    linux_like,
1042    solarish,
1043    target_os = "espidf",
1044    target_os = "haiku",
1045    target_os = "horizon",
1046    target_os = "netbsd",
1047    target_os = "nto",
1048    target_os = "redox",
1049    target_os = "vita",
1050    target_os = "wasi",
1051)))]
1052#[allow(clippy::module_name_repetitions)]
1053pub type StatFs = c::statfs;
1054
1055/// `struct statfs` for use with [`statfs`] and [`fstatfs`].
1056///
1057/// [`statfs`]: crate::fs::statfs
1058/// [`fstatfs`]: crate::fs::fstatfs
1059#[cfg(linux_like)]
1060pub type StatFs = c::statfs64;
1061
1062/// `fsid_t` for use with [`StatFs`].
1063#[cfg(not(any(
1064    solarish,
1065    target_os = "cygwin",
1066    target_os = "espidf",
1067    target_os = "haiku",
1068    target_os = "horizon",
1069    target_os = "nto",
1070    target_os = "redox",
1071    target_os = "vita",
1072    target_os = "wasi",
1073)))]
1074pub type Fsid = c::fsid_t;
1075
1076/// `struct statvfs` for use with [`statvfs`] and [`fstatvfs`].
1077///
1078/// [`statvfs`]: crate::fs::statvfs
1079/// [`fstatvfs`]: crate::fs::fstatvfs
1080#[cfg(not(target_os = "wasi"))]
1081#[allow(missing_docs)]
1082pub struct StatVfs {
1083    pub f_bsize: u64,
1084    pub f_frsize: u64,
1085    pub f_blocks: u64,
1086    pub f_bfree: u64,
1087    pub f_bavail: u64,
1088    pub f_files: u64,
1089    pub f_ffree: u64,
1090    pub f_favail: u64,
1091    pub f_fsid: u64,
1092    pub f_flag: StatVfsMountFlags,
1093    pub f_namemax: u64,
1094}
1095
1096/// `mode_t`
1097#[cfg(not(all(target_os = "android", target_pointer_width = "32")))]
1098pub type RawMode = c::mode_t;
1099
1100/// `mode_t`
1101#[cfg(all(target_os = "android", target_pointer_width = "32"))]
1102pub type RawMode = ffi::c_uint;
1103
1104/// `dev_t`
1105#[cfg(not(all(target_os = "android", target_pointer_width = "32")))]
1106pub type Dev = c::dev_t;
1107
1108/// `dev_t`
1109#[cfg(all(target_os = "android", target_pointer_width = "32"))]
1110pub type Dev = ffi::c_ulonglong;
1111
1112/// `__fsword_t`
1113#[cfg(all(
1114    target_os = "linux",
1115    not(target_env = "musl"),
1116    not(target_arch = "s390x"),
1117))]
1118pub type FsWord = c::__fsword_t;
1119
1120/// `__fsword_t`
1121#[cfg(all(
1122    any(target_os = "android", all(target_os = "linux", target_env = "musl")),
1123    target_pointer_width = "32",
1124))]
1125pub type FsWord = u32;
1126
1127/// `__fsword_t`
1128#[cfg(all(
1129    any(target_os = "android", all(target_os = "linux", target_env = "musl")),
1130    not(target_arch = "s390x"),
1131    target_pointer_width = "64",
1132))]
1133pub type FsWord = u64;
1134
1135/// `__fsword_t`
1136// s390x uses `u32` for `statfs` entries on glibc, even though `__fsword_t` is
1137// `u64`.
1138#[cfg(all(target_os = "linux", target_arch = "s390x", target_env = "gnu"))]
1139pub type FsWord = u32;
1140
1141/// `__fsword_t`
1142// s390x uses `u64` for `statfs` entries on musl.
1143#[cfg(all(target_os = "linux", target_arch = "s390x", target_env = "musl"))]
1144pub type FsWord = u64;
1145
1146/// `copyfile_state_t`—State for use with [`fcopyfile`].
1147///
1148/// [`fcopyfile`]: crate::fs::fcopyfile
1149#[cfg(apple)]
1150#[allow(non_camel_case_types)]
1151#[repr(transparent)]
1152#[derive(Copy, Clone)]
1153pub struct copyfile_state_t(pub(crate) *mut c::c_void);
rustix/backend/libc/fs/types.rs

rustix/backend/libc/fs/
types.rs
