systemd_tmpfiles 0.2.9

A parser for systemd-tmpfiles configuration files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

//! Systemd architecture mapping (based on systemd.unit(5))

use strum::IntoStaticStr;

/// Architectures as systemd understands them
#[derive(Debug, Clone, PartialEq, Eq, Hash, IntoStaticStr)]
pub(crate) enum Architecture {
    #[strum(serialize = "x86")]
    X86,
    #[strum(serialize = "x86-64")]
    X86_64,
    #[strum(serialize = "ppc")]
    Ppc,
    #[strum(serialize = "ppc-le")]
    PpcLE,
    #[strum(serialize = "ppc64")]
    Ppc64,
    #[strum(serialize = "ppc64-le")]
    Ppc64LE,
    #[strum(serialize = "ia64")]
    Ia64,
    #[strum(serialize = "parisc")]
    Parisc,
    #[strum(serialize = "parisc64")]
    Parisc64,
    #[strum(serialize = "s390")]
    S390,
    #[strum(serialize = "s390x")]
    S390x,
    #[strum(serialize = "sparc")]
    Sparc,
    #[strum(serialize = "sparc64")]
    Sparc64,
    #[strum(serialize = "mips")]
    Mips,
    #[strum(serialize = "mips64")]
    Mips64,
    #[strum(serialize = "alpha")]
    Alpha,
    #[strum(serialize = "arm")]
    Arm,
    #[strum(serialize = "arm-be")]
    ArmBe,
    #[strum(serialize = "arm64")]
    Arm64,
    #[strum(serialize = "arm64-be")]
    Arm64Be,
    #[strum(serialize = "sh")]
    Sh,
    #[strum(serialize = "sh64")]
    Sh64,
    #[strum(serialize = "mk68k")]
    M68k,
    #[strum(serialize = "tilegx")]
    Tilegx,
    #[strum(serialize = "cris")]
    Cris,
    #[strum(serialize = "arc")]
    Arc,
    #[strum(serialize = "arc-be")]
    ArcBe,
    #[strum(serialize = "riscv32")]
    Riscv32,
    #[strum(serialize = "riscv64")]
    Riscv64,
}

impl Architecture {
    pub(crate) fn from_uname(uname_arch: &str) -> Option<Self> {
        match uname_arch {
            // x86
            "i386" => Some(Self::X86),
            "i486" => Some(Self::X86),
            "i586" => Some(Self::X86),
            "i686" => Some(Self::X86),
            "x86_64" => Some(Self::X86_64),
            // ARM
            "aarch64" => Some(Self::Arm64),
            "aarch64_be" => Some(Self::Arm64Be),
            // PPC
            "ppc" => Some(Self::Ppc),
            "ppcle" => Some(Self::PpcLE),
            "ppc64" => Some(Self::Ppc64),
            "ppc64le" => Some(Self::Ppc64LE),
            // RISCV (not documented, but actually supported)
            "riscv32" => Some(Self::Riscv32),
            "riscv64" => Some(Self::Riscv64),
            // MIPS
            "mips" => Some(Self::Mips),
            "mips64" => Some(Self::Mips64),
            // SH
            "sh5" => Some(Self::Sh64),
            // s390
            "s390" => Some(Self::S390),
            "s390x" => Some(Self::S390x),
            // SPARC
            "sparc" => Some(Self::Sparc),
            "sparc64" => Some(Self::Sparc64),
            // Alpha
            "alpha" => Some(Self::Alpha),
            // IA64
            "ia64" => Some(Self::Ia64),
            // Parisc
            "parisc" => Some(Self::Parisc),
            "parisc64" => Some(Self::Parisc64),
            // M68k
            "m68k" => Some(Self::M68k),
            // TileGX
            "tilegx" => Some(Self::Tilegx),
            // CRIS
            "crisv32" => Some(Self::Cris),
            // ARC
            "arc" => Some(Self::Arc),
            "arceb" => Some(Self::ArcBe),
            _ => {
                if uname_arch.starts_with("arm") {
                    // Map 32-bit ARMs, too many variants to list explicitly
                    if uname_arch.ends_with('b') {
                        Some(Self::ArmBe)
                    } else {
                        Some(Self::Arm)
                    }
                } else if uname_arch.starts_with("sh") {
                    // Too many SH too
                    Some(Self::Sh)
                } else {
                    None
                }
            }
        }
    }
}