Skip to main content

arcbox_oci/config/
resources.rs

1//! Linux cgroup resource configuration types.
2
3use serde::{Deserialize, Serialize};
4use std::collections::HashMap;
5
6/// Linux cgroup resource limits.
7#[derive(Debug, Clone, Default, Serialize, Deserialize)]
8#[serde(rename_all = "camelCase")]
9pub struct Resources {
10    /// Device access rules.
11    #[serde(default, skip_serializing_if = "Vec::is_empty")]
12    pub devices: Vec<DeviceCgroup>,
13
14    /// Memory limits.
15    #[serde(skip_serializing_if = "Option::is_none")]
16    pub memory: Option<MemoryResources>,
17
18    /// CPU limits.
19    #[serde(skip_serializing_if = "Option::is_none")]
20    pub cpu: Option<CpuResources>,
21
22    /// Block I/O limits.
23    #[serde(rename = "blockIO", skip_serializing_if = "Option::is_none")]
24    pub block_io: Option<BlockIoResources>,
25
26    /// PIDs limit.
27    #[serde(skip_serializing_if = "Option::is_none")]
28    pub pids: Option<PidsResources>,
29
30    /// Huge pages limits.
31    #[serde(default, skip_serializing_if = "Vec::is_empty")]
32    pub hugepage_limits: Vec<HugepageLimit>,
33
34    /// Network priorities.
35    #[serde(skip_serializing_if = "Option::is_none")]
36    pub network: Option<NetworkResources>,
37
38    /// RDMA resources.
39    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
40    pub rdma: HashMap<String, RdmaResource>,
41}
42
43/// Device cgroup rule.
44#[derive(Debug, Clone, Serialize, Deserialize)]
45#[serde(rename_all = "camelCase")]
46pub struct DeviceCgroup {
47    /// Allow or deny.
48    pub allow: bool,
49    /// Device type (a, c, b).
50    #[serde(rename = "type", skip_serializing_if = "Option::is_none")]
51    pub device_type: Option<String>,
52    /// Major number.
53    #[serde(skip_serializing_if = "Option::is_none")]
54    pub major: Option<i64>,
55    /// Minor number.
56    #[serde(skip_serializing_if = "Option::is_none")]
57    pub minor: Option<i64>,
58    /// Access rights (r, w, m).
59    #[serde(skip_serializing_if = "Option::is_none")]
60    pub access: Option<String>,
61}
62
63/// Memory resource limits.
64#[derive(Debug, Clone, Default, Serialize, Deserialize)]
65#[serde(rename_all = "camelCase")]
66pub struct MemoryResources {
67    /// Memory limit in bytes.
68    #[serde(skip_serializing_if = "Option::is_none")]
69    pub limit: Option<i64>,
70    /// Memory reservation in bytes.
71    #[serde(skip_serializing_if = "Option::is_none")]
72    pub reservation: Option<i64>,
73    /// Memory + swap limit in bytes.
74    #[serde(skip_serializing_if = "Option::is_none")]
75    pub swap: Option<i64>,
76    /// Kernel memory limit in bytes.
77    #[serde(skip_serializing_if = "Option::is_none")]
78    pub kernel: Option<i64>,
79    /// Kernel TCP memory limit in bytes.
80    #[serde(skip_serializing_if = "Option::is_none")]
81    pub kernel_tcp: Option<i64>,
82    /// Swappiness (0-100).
83    #[serde(skip_serializing_if = "Option::is_none")]
84    pub swappiness: Option<u64>,
85    /// Disable OOM killer.
86    #[serde(skip_serializing_if = "Option::is_none")]
87    pub disable_oom_killer: Option<bool>,
88    /// Use hierarchy.
89    #[serde(skip_serializing_if = "Option::is_none")]
90    pub use_hierarchy: Option<bool>,
91    /// Check before update.
92    #[serde(skip_serializing_if = "Option::is_none")]
93    pub check_before_update: Option<bool>,
94}
95
96/// CPU resource limits.
97#[derive(Debug, Clone, Default, Serialize, Deserialize)]
98#[serde(rename_all = "camelCase")]
99pub struct CpuResources {
100    /// CPU shares.
101    #[serde(skip_serializing_if = "Option::is_none")]
102    pub shares: Option<u64>,
103    /// CPU quota.
104    #[serde(skip_serializing_if = "Option::is_none")]
105    pub quota: Option<i64>,
106    /// CPU burst.
107    #[serde(skip_serializing_if = "Option::is_none")]
108    pub burst: Option<u64>,
109    /// CPU period.
110    #[serde(skip_serializing_if = "Option::is_none")]
111    pub period: Option<u64>,
112    /// Realtime runtime.
113    #[serde(skip_serializing_if = "Option::is_none")]
114    pub realtime_runtime: Option<i64>,
115    /// Realtime period.
116    #[serde(skip_serializing_if = "Option::is_none")]
117    pub realtime_period: Option<u64>,
118    /// CPU set (cores).
119    #[serde(skip_serializing_if = "Option::is_none")]
120    pub cpus: Option<String>,
121    /// Memory node set.
122    #[serde(skip_serializing_if = "Option::is_none")]
123    pub mems: Option<String>,
124    /// Idle setting.
125    #[serde(skip_serializing_if = "Option::is_none")]
126    pub idle: Option<i64>,
127}
128
129/// Block I/O resource limits.
130#[derive(Debug, Clone, Default, Serialize, Deserialize)]
131#[serde(rename_all = "camelCase")]
132pub struct BlockIoResources {
133    /// Block I/O weight.
134    #[serde(skip_serializing_if = "Option::is_none")]
135    pub weight: Option<u16>,
136    /// Leaf weight.
137    #[serde(skip_serializing_if = "Option::is_none")]
138    pub leaf_weight: Option<u16>,
139    /// Per-device weight.
140    #[serde(default, skip_serializing_if = "Vec::is_empty")]
141    pub weight_device: Vec<WeightDevice>,
142    /// Throttle read bps.
143    #[serde(default, skip_serializing_if = "Vec::is_empty")]
144    pub throttle_read_bps_device: Vec<ThrottleDevice>,
145    /// Throttle write bps.
146    #[serde(default, skip_serializing_if = "Vec::is_empty")]
147    pub throttle_write_bps_device: Vec<ThrottleDevice>,
148    /// Throttle read iops.
149    #[serde(default, skip_serializing_if = "Vec::is_empty")]
150    pub throttle_read_iops_device: Vec<ThrottleDevice>,
151    /// Throttle write iops.
152    #[serde(default, skip_serializing_if = "Vec::is_empty")]
153    pub throttle_write_iops_device: Vec<ThrottleDevice>,
154}
155
156/// Block I/O weight per device.
157#[derive(Debug, Clone, Serialize, Deserialize)]
158#[serde(rename_all = "camelCase")]
159pub struct WeightDevice {
160    /// Major device number.
161    pub major: i64,
162    /// Minor device number.
163    pub minor: i64,
164    /// Weight.
165    #[serde(skip_serializing_if = "Option::is_none")]
166    pub weight: Option<u16>,
167    /// Leaf weight.
168    #[serde(skip_serializing_if = "Option::is_none")]
169    pub leaf_weight: Option<u16>,
170}
171
172/// Block I/O throttle per device.
173#[derive(Debug, Clone, Serialize, Deserialize)]
174#[serde(rename_all = "camelCase")]
175pub struct ThrottleDevice {
176    /// Major device number.
177    pub major: i64,
178    /// Minor device number.
179    pub minor: i64,
180    /// Rate limit.
181    pub rate: u64,
182}
183
184/// PIDs resource limits.
185#[derive(Debug, Clone, Default, Serialize, Deserialize)]
186pub struct PidsResources {
187    /// Maximum number of PIDs.
188    pub limit: i64,
189}
190
191/// Hugepage limit.
192#[derive(Debug, Clone, Serialize, Deserialize)]
193#[serde(rename_all = "camelCase")]
194pub struct HugepageLimit {
195    /// Page size (e.g., "2MB", "1GB").
196    pub page_size: String,
197    /// Limit in bytes.
198    pub limit: u64,
199}
200
201/// Network resource limits.
202#[derive(Debug, Clone, Default, Serialize, Deserialize)]
203pub struct NetworkResources {
204    /// Class ID for network traffic.
205    #[serde(rename = "classID", skip_serializing_if = "Option::is_none")]
206    pub class_id: Option<u32>,
207    /// Network priorities.
208    #[serde(default, skip_serializing_if = "Vec::is_empty")]
209    pub priorities: Vec<NetworkPriority>,
210}
211
212/// Network priority.
213#[derive(Debug, Clone, Serialize, Deserialize)]
214pub struct NetworkPriority {
215    /// Interface name.
216    pub name: String,
217    /// Priority.
218    pub priority: u32,
219}
220
221/// RDMA resource limits.
222#[derive(Debug, Clone, Default, Serialize, Deserialize)]
223#[serde(rename_all = "camelCase")]
224pub struct RdmaResource {
225    /// HCA handles.
226    #[serde(skip_serializing_if = "Option::is_none")]
227    pub hca_handles: Option<u32>,
228    /// HCA objects.
229    #[serde(skip_serializing_if = "Option::is_none")]
230    pub hca_objects: Option<u32>,
231}