Debian Codegraph @

src/shared/machine-util.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "alloc-util.h"
4 #include "extract-word.h"
5 #include "machine-util.h"
6 #include "parse-argument.h"
7 #include "parse-util.h"
8 #include "storage-util.h"
9 #include "string-table.h"
10 #include "string-util.h"
11 #include "strv.h"
12
13 static const char *const image_format_table[_IMAGE_FORMAT_MAX] = {
14 [IMAGE_FORMAT_RAW] = "raw",
15 [IMAGE_FORMAT_QCOW2] = "qcow2",
16 };
17
18 DEFINE_STRING_TABLE_LOOKUP(image_format, ImageFormat);
19
20 static const char *const read_only_mode_table[_READ_ONLY_MAX] = {
21 [READ_ONLY_NO] = "no",
22 [READ_ONLY_YES] = "yes",
23 [READ_ONLY_AUTO] = "auto",
24 };
25
26 DEFINE_STRING_TABLE_LOOKUP(read_only_mode, ReadOnlyMode);
27
28 static const char *const disk_type_table[_DISK_TYPE_MAX] = {
29 [DISK_TYPE_VIRTIO_BLK] = "virtio-blk",
30 [DISK_TYPE_VIRTIO_SCSI] = "virtio-scsi",
31 [DISK_TYPE_NVME] = "nvme",
32 [DISK_TYPE_VIRTIO_SCSI_CDROM] = "scsi-cd",
33 };
34
35 DEFINE_STRING_TABLE_LOOKUP(disk_type, DiskType);
36
37 /* Wire value for the io.systemd.VirtualMachineInstance.BlockDriver IDL enum. */
38 static const char *const block_driver_table[_DISK_TYPE_MAX] = {
39 [DISK_TYPE_VIRTIO_BLK] = "virtio_blk",
40 [DISK_TYPE_VIRTIO_SCSI] = "scsi_hd",
41 [DISK_TYPE_NVME] = "nvme",
42 [DISK_TYPE_VIRTIO_SCSI_CDROM] = "scsi_cd",
43 };
44
45 DEFINE_STRING_TABLE_LOOKUP(block_driver, DiskType);
46
47 /* QEMU -device driver name (e.g. "virtio-blk-pci"). */
48 static const char *const qemu_device_driver_table[_DISK_TYPE_MAX] = {
49 [DISK_TYPE_VIRTIO_BLK] = "virtio-blk-pci",
50 [DISK_TYPE_VIRTIO_SCSI] = "scsi-hd",
51 [DISK_TYPE_NVME] = "nvme",
52 [DISK_TYPE_VIRTIO_SCSI_CDROM] = "scsi-cd",
53 };
54
55 DEFINE_STRING_TABLE_LOOKUP(qemu_device_driver, DiskType);
56
57 int parse_disk_spec(
58 const char *arg,
59 ImageFormat *format,
60 DiskType *disk_type,
61 char **ret_path) {
62
63 int r;
64
65 assert(arg);
66 assert(format);
67 assert(disk_type);
68 assert(ret_path);
69
70 ImageFormat parsed_format = *format;
71 DiskType parsed_disk_type = *disk_type;
72 const char *dp = arg;
73
74 /* Format and disk-type vocabularies don't overlap, so prefixes may appear in any order. */
75 for (;;) {
76 _cleanup_free_ char *word = NULL;
77 const char *save = dp;
78
79 r = extract_first_word(&dp, &word, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
80 if (r < 0)
81 return r;
82 if (r == 0 || !dp) {
83 /* No ':' remained after this word — rest is the path. */
84 dp = save;
85 break;
86 }
87
88 ImageFormat f = image_format_from_string(word);
89 if (f >= 0) {
90 parsed_format = f;
91 continue;
92 }
93
94 DiskType dt = disk_type_from_string(word);
95 if (dt >= 0) {
96 parsed_disk_type = dt;
97 continue;
98 }
99
100 /* Unknown prefix — rewind, remainder is the path. */
101 dp = save;
102 break;
103 }
104
105 _cleanup_free_ char *path = NULL;
106 r = parse_path_argument(dp, /* suppress_root= */ false, &path);
107 if (r < 0)
108 return r;
109
110 *format = parsed_format;
111 *disk_type = parsed_disk_type;
112 *ret_path = TAKE_PTR(path);
113 return 0;
114 }
115
116 BindVolume* bind_volume_free(BindVolume *v) {
117 if (!v)
118 return NULL;
119
120 free(v->provider);
121 free(v->volume);
122 free(v->config);
123 free(v->template);
124
125 return mfree(v);
126 }
127
128 static int bind_volume_apply_extra(BindVolume *v, const char *key, const char *value) {
129 int r;
130
131 assert(v);
132 assert(key);
133 assert(value);
134
135 if (streq(key, "template")) {
136 if (v->template)
137 return -EINVAL;
138 if (!storage_template_name_is_valid(value))
139 return -EINVAL;
140 r = free_and_strdup(&v->template, value);
141 if (r < 0)
142 return r;
143 return 0;
144 }
145
146 if (streq(key, "create")) {
147 if (v->create_mode >= 0)
148 return -EINVAL;
149 CreateMode m = create_mode_from_string(value);
150 if (m < 0)
151 return m;
152 v->create_mode = m;
153 return 0;
154 }
155
156 if (STR_IN_SET(key, "read-only", "ro")) {
157 if (v->read_only >= 0)
158 return -EINVAL;
159 ReadOnlyMode m = read_only_mode_from_string(value);
160 if (m < 0) {
161 r = parse_boolean(value);
162 if (r < 0)
163 return r;
164 m = r ? READ_ONLY_YES : READ_ONLY_NO;
165 }
166 v->read_only = m;
167 return 0;
168 }
169
170 if (STR_IN_SET(key, "size", "create-size")) {
171 if (v->create_size_bytes != UINT64_MAX)
172 return -EINVAL;
173 uint64_t sz;
174 r = parse_size(value, 1024, &sz);
175 if (r < 0)
176 return r;
177 if (sz == 0)
178 return -EINVAL;
179 v->create_size_bytes = sz;
180 return 0;
181 }
182
183 if (streq(key, "request-as")) {
184 if (v->request_as >= 0)
185 return -EINVAL;
186 VolumeType t = volume_type_from_string(value);
187 if (t < 0)
188 return t;
189 v->request_as = t;
190 return 0;
191 }
192
193 return -EINVAL;
194 }
195
196 int bind_volume_parse(const char *arg, BindVolume **ret) {
197 _cleanup_(bind_volume_freep) BindVolume *v = NULL;
198 int r;
199
200 assert(arg);
201 assert(ret);
202
203 v = new(BindVolume, 1);
204 if (!v)
205 return -ENOMEM;
206
207 *v = BIND_VOLUME_INIT;
208
209 const char *p = arg;
210 _cleanup_free_ char *provider = NULL, *volume = NULL, *config = NULL;
211
212 r = extract_first_word(&p, &provider, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
213 if (r < 0)
214 return r;
215 if (r == 0 || isempty(provider) || !storage_provider_name_is_valid(provider))
216 return -EINVAL;
217
218 r = extract_first_word(&p, &volume, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
219 if (r < 0)
220 return r;
221 if (r == 0 || isempty(volume) || !storage_volume_name_is_valid(volume))
222 return -EINVAL;
223
224 r = extract_first_word(&p, &config, ":", EXTRACT_DONT_COALESCE_SEPARATORS);
225 if (r < 0)
226 return r;
227
228 v->provider = TAKE_PTR(provider);
229 v->volume = TAKE_PTR(volume);
230 if (!isempty(config)) {
231 if (!string_is_safe(config, /* flags= */ 0))
232 return -EINVAL;
233 v->config = TAKE_PTR(config);
234 }
235
236 for (;;) {
237 _cleanup_free_ char *kv = NULL, *key = NULL, *value = NULL;
238
239 r = extract_first_word(&p, &kv, ",", 0);
240 if (r < 0)
241 return r;
242 if (r == 0)
243 break;
244
245 r = split_pair(kv, "=", &key, &value);
246 if (r < 0)
247 return r;
248 if (isempty(key))
249 return -EINVAL;
250
251 r = bind_volume_apply_extra(v, key, value);
252 if (r < 0)
253 return r;
254 }
255
256 *ret = TAKE_PTR(v);
257 return 0;
258 }
259
260 int machine_storage_name_split(const char *s, char **ret_provider, char **ret_volume) {
261 _cleanup_free_ char *p = NULL, *v = NULL;
262 int r;
263
264 if (isempty(s))
265 return -EINVAL;
266
267 r = split_pair(s, ":", &p, &v);
268 if (r < 0)
269 return r;
270
271 if (!storage_provider_name_is_valid(p) || !storage_volume_name_is_valid(v))
272 return -EINVAL;
273
274 if (ret_provider)
275 *ret_provider = TAKE_PTR(p);
276 if (ret_volume)
277 *ret_volume = TAKE_PTR(v);
278 return 0;
279 }