]>
Commit | Line | Data |
---|---|---|
e3d4d252 | 1 | /* |
42074a9d | 2 | * QEMU Guest Agent POSIX-specific command implementations |
e3d4d252 MR |
3 | * |
4 | * Copyright IBM Corp. 2011 | |
5 | * | |
6 | * Authors: | |
7 | * Michael Roth <mdroth@linux.vnet.ibm.com> | |
3424fc9f | 8 | * Michal Privoznik <mprivozn@redhat.com> |
e3d4d252 MR |
9 | * |
10 | * This work is licensed under the terms of the GNU GPL, version 2 or later. | |
11 | * See the COPYING file in the top-level directory. | |
12 | */ | |
13 | ||
14 | #include <glib.h> | |
e72c3f2e MR |
15 | #include <sys/types.h> |
16 | #include <sys/ioctl.h> | |
2c02cbf6 | 17 | #include <sys/wait.h> |
d2baff62 LE |
18 | #include <unistd.h> |
19 | #include <errno.h> | |
20 | #include <fcntl.h> | |
c689b4f1 LE |
21 | #include <stdio.h> |
22 | #include <string.h> | |
23 | #include <sys/stat.h> | |
d2baff62 | 24 | #include <inttypes.h> |
e72c3f2e MR |
25 | #include "qga/guest-agent-core.h" |
26 | #include "qga-qmp-commands.h" | |
7b1b5d19 | 27 | #include "qapi/qmp/qerror.h" |
1de7afc9 PB |
28 | #include "qemu/queue.h" |
29 | #include "qemu/host-utils.h" | |
4eb36d40 | 30 | |
2c02cbf6 | 31 | #ifndef CONFIG_HAS_ENVIRON |
eecae147 AF |
32 | #ifdef __APPLE__ |
33 | #include <crt_externs.h> | |
34 | #define environ (*_NSGetEnviron()) | |
35 | #else | |
2c02cbf6 LC |
36 | extern char **environ; |
37 | #endif | |
eecae147 | 38 | #endif |
2c02cbf6 | 39 | |
4eb36d40 | 40 | #if defined(__linux__) |
e3d4d252 | 41 | #include <mntent.h> |
7006b9cf | 42 | #include <linux/fs.h> |
3424fc9f MP |
43 | #include <ifaddrs.h> |
44 | #include <arpa/inet.h> | |
45 | #include <sys/socket.h> | |
46 | #include <net/if.h> | |
e3d4d252 | 47 | |
eab5fd59 | 48 | #ifdef FIFREEZE |
e72c3f2e MR |
49 | #define CONFIG_FSFREEZE |
50 | #endif | |
eab5fd59 PB |
51 | #ifdef FITRIM |
52 | #define CONFIG_FSTRIM | |
53 | #endif | |
e72c3f2e MR |
54 | #endif |
55 | ||
77dbc81b | 56 | static void ga_wait_child(pid_t pid, int *status, Error **errp) |
d220a6df LC |
57 | { |
58 | pid_t rpid; | |
59 | ||
60 | *status = 0; | |
61 | ||
62 | do { | |
63 | rpid = waitpid(pid, status, 0); | |
64 | } while (rpid == -1 && errno == EINTR); | |
65 | ||
66 | if (rpid == -1) { | |
77dbc81b MA |
67 | error_setg_errno(errp, errno, "failed to wait for child (pid: %d)", |
68 | pid); | |
d220a6df LC |
69 | return; |
70 | } | |
71 | ||
72 | g_assert(rpid == pid); | |
73 | } | |
74 | ||
77dbc81b | 75 | void qmp_guest_shutdown(bool has_mode, const char *mode, Error **errp) |
e3d4d252 | 76 | { |
e3d4d252 | 77 | const char *shutdown_flag; |
d220a6df LC |
78 | Error *local_err = NULL; |
79 | pid_t pid; | |
3674838c | 80 | int status; |
e3d4d252 MR |
81 | |
82 | slog("guest-shutdown called, mode: %s", mode); | |
83 | if (!has_mode || strcmp(mode, "powerdown") == 0) { | |
84 | shutdown_flag = "-P"; | |
85 | } else if (strcmp(mode, "halt") == 0) { | |
86 | shutdown_flag = "-H"; | |
87 | } else if (strcmp(mode, "reboot") == 0) { | |
88 | shutdown_flag = "-r"; | |
89 | } else { | |
77dbc81b | 90 | error_setg(errp, |
d220a6df | 91 | "mode is invalid (valid values are: halt|powerdown|reboot"); |
e3d4d252 MR |
92 | return; |
93 | } | |
94 | ||
d5dd3498 LC |
95 | pid = fork(); |
96 | if (pid == 0) { | |
e3d4d252 MR |
97 | /* child, start the shutdown */ |
98 | setsid(); | |
3674838c LC |
99 | reopen_fd_to_null(0); |
100 | reopen_fd_to_null(1); | |
101 | reopen_fd_to_null(2); | |
e3d4d252 | 102 | |
485e741c | 103 | execle("/sbin/shutdown", "shutdown", "-h", shutdown_flag, "+0", |
3674838c LC |
104 | "hypervisor initiated shutdown", (char*)NULL, environ); |
105 | _exit(EXIT_FAILURE); | |
d5dd3498 | 106 | } else if (pid < 0) { |
77dbc81b | 107 | error_setg_errno(errp, errno, "failed to create child process"); |
d220a6df | 108 | return; |
e3d4d252 | 109 | } |
d5dd3498 | 110 | |
d220a6df | 111 | ga_wait_child(pid, &status, &local_err); |
84d18f06 | 112 | if (local_err) { |
77dbc81b | 113 | error_propagate(errp, local_err); |
d220a6df LC |
114 | return; |
115 | } | |
116 | ||
117 | if (!WIFEXITED(status)) { | |
77dbc81b | 118 | error_setg(errp, "child process has terminated abnormally"); |
d220a6df LC |
119 | return; |
120 | } | |
121 | ||
122 | if (WEXITSTATUS(status)) { | |
77dbc81b | 123 | error_setg(errp, "child process has failed to shutdown"); |
d5dd3498 LC |
124 | return; |
125 | } | |
126 | ||
085d8134 | 127 | /* succeeded */ |
e3d4d252 MR |
128 | } |
129 | ||
6912e6a9 LL |
130 | int64_t qmp_guest_get_time(Error **errp) |
131 | { | |
132 | int ret; | |
133 | qemu_timeval tq; | |
134 | int64_t time_ns; | |
135 | ||
136 | ret = qemu_gettimeofday(&tq); | |
137 | if (ret < 0) { | |
138 | error_setg_errno(errp, errno, "Failed to get time"); | |
139 | return -1; | |
140 | } | |
141 | ||
142 | time_ns = tq.tv_sec * 1000000000LL + tq.tv_usec * 1000; | |
143 | return time_ns; | |
144 | } | |
145 | ||
2c958923 | 146 | void qmp_guest_set_time(bool has_time, int64_t time_ns, Error **errp) |
a1bca57f LL |
147 | { |
148 | int ret; | |
149 | int status; | |
150 | pid_t pid; | |
151 | Error *local_err = NULL; | |
152 | struct timeval tv; | |
153 | ||
2c958923 MP |
154 | /* If user has passed a time, validate and set it. */ |
155 | if (has_time) { | |
156 | /* year-2038 will overflow in case time_t is 32bit */ | |
157 | if (time_ns / 1000000000 != (time_t)(time_ns / 1000000000)) { | |
158 | error_setg(errp, "Time %" PRId64 " is too large", time_ns); | |
159 | return; | |
160 | } | |
161 | ||
162 | tv.tv_sec = time_ns / 1000000000; | |
163 | tv.tv_usec = (time_ns % 1000000000) / 1000; | |
164 | ||
165 | ret = settimeofday(&tv, NULL); | |
166 | if (ret < 0) { | |
167 | error_setg_errno(errp, errno, "Failed to set time to guest"); | |
168 | return; | |
169 | } | |
a1bca57f LL |
170 | } |
171 | ||
2c958923 MP |
172 | /* Now, if user has passed a time to set and the system time is set, we |
173 | * just need to synchronize the hardware clock. However, if no time was | |
174 | * passed, user is requesting the opposite: set the system time from the | |
1634df56 | 175 | * hardware clock (RTC). */ |
a1bca57f LL |
176 | pid = fork(); |
177 | if (pid == 0) { | |
178 | setsid(); | |
179 | reopen_fd_to_null(0); | |
180 | reopen_fd_to_null(1); | |
181 | reopen_fd_to_null(2); | |
182 | ||
2c958923 MP |
183 | /* Use '/sbin/hwclock -w' to set RTC from the system time, |
184 | * or '/sbin/hwclock -s' to set the system time from RTC. */ | |
185 | execle("/sbin/hwclock", "hwclock", has_time ? "-w" : "-s", | |
186 | NULL, environ); | |
a1bca57f LL |
187 | _exit(EXIT_FAILURE); |
188 | } else if (pid < 0) { | |
189 | error_setg_errno(errp, errno, "failed to create child process"); | |
190 | return; | |
191 | } | |
192 | ||
193 | ga_wait_child(pid, &status, &local_err); | |
84d18f06 | 194 | if (local_err) { |
a1bca57f LL |
195 | error_propagate(errp, local_err); |
196 | return; | |
197 | } | |
198 | ||
199 | if (!WIFEXITED(status)) { | |
200 | error_setg(errp, "child process has terminated abnormally"); | |
201 | return; | |
202 | } | |
203 | ||
204 | if (WEXITSTATUS(status)) { | |
205 | error_setg(errp, "hwclock failed to set hardware clock to system time"); | |
206 | return; | |
207 | } | |
208 | } | |
209 | ||
e3d4d252 MR |
210 | typedef struct GuestFileHandle { |
211 | uint64_t id; | |
212 | FILE *fh; | |
213 | QTAILQ_ENTRY(GuestFileHandle) next; | |
214 | } GuestFileHandle; | |
215 | ||
216 | static struct { | |
217 | QTAILQ_HEAD(, GuestFileHandle) filehandles; | |
218 | } guest_file_state; | |
219 | ||
39097daf | 220 | static int64_t guest_file_handle_add(FILE *fh, Error **errp) |
e3d4d252 MR |
221 | { |
222 | GuestFileHandle *gfh; | |
39097daf MR |
223 | int64_t handle; |
224 | ||
225 | handle = ga_get_fd_handle(ga_state, errp); | |
226 | if (error_is_set(errp)) { | |
227 | return 0; | |
228 | } | |
e3d4d252 | 229 | |
7267c094 | 230 | gfh = g_malloc0(sizeof(GuestFileHandle)); |
39097daf | 231 | gfh->id = handle; |
e3d4d252 MR |
232 | gfh->fh = fh; |
233 | QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next); | |
39097daf MR |
234 | |
235 | return handle; | |
e3d4d252 MR |
236 | } |
237 | ||
77dbc81b | 238 | static GuestFileHandle *guest_file_handle_find(int64_t id, Error **errp) |
e3d4d252 MR |
239 | { |
240 | GuestFileHandle *gfh; | |
241 | ||
242 | QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next) | |
243 | { | |
244 | if (gfh->id == id) { | |
245 | return gfh; | |
246 | } | |
247 | } | |
248 | ||
77dbc81b | 249 | error_setg(errp, "handle '%" PRId64 "' has not been found", id); |
e3d4d252 MR |
250 | return NULL; |
251 | } | |
252 | ||
c689b4f1 LE |
253 | typedef const char * const ccpc; |
254 | ||
8fe6bbca LE |
255 | #ifndef O_BINARY |
256 | #define O_BINARY 0 | |
257 | #endif | |
258 | ||
c689b4f1 LE |
259 | /* http://pubs.opengroup.org/onlinepubs/9699919799/functions/fopen.html */ |
260 | static const struct { | |
261 | ccpc *forms; | |
262 | int oflag_base; | |
263 | } guest_file_open_modes[] = { | |
8fe6bbca LE |
264 | { (ccpc[]){ "r", NULL }, O_RDONLY }, |
265 | { (ccpc[]){ "rb", NULL }, O_RDONLY | O_BINARY }, | |
266 | { (ccpc[]){ "w", NULL }, O_WRONLY | O_CREAT | O_TRUNC }, | |
267 | { (ccpc[]){ "wb", NULL }, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY }, | |
268 | { (ccpc[]){ "a", NULL }, O_WRONLY | O_CREAT | O_APPEND }, | |
269 | { (ccpc[]){ "ab", NULL }, O_WRONLY | O_CREAT | O_APPEND | O_BINARY }, | |
270 | { (ccpc[]){ "r+", NULL }, O_RDWR }, | |
271 | { (ccpc[]){ "rb+", "r+b", NULL }, O_RDWR | O_BINARY }, | |
272 | { (ccpc[]){ "w+", NULL }, O_RDWR | O_CREAT | O_TRUNC }, | |
273 | { (ccpc[]){ "wb+", "w+b", NULL }, O_RDWR | O_CREAT | O_TRUNC | O_BINARY }, | |
274 | { (ccpc[]){ "a+", NULL }, O_RDWR | O_CREAT | O_APPEND }, | |
275 | { (ccpc[]){ "ab+", "a+b", NULL }, O_RDWR | O_CREAT | O_APPEND | O_BINARY } | |
c689b4f1 LE |
276 | }; |
277 | ||
278 | static int | |
77dbc81b | 279 | find_open_flag(const char *mode_str, Error **errp) |
c689b4f1 LE |
280 | { |
281 | unsigned mode; | |
282 | ||
283 | for (mode = 0; mode < ARRAY_SIZE(guest_file_open_modes); ++mode) { | |
284 | ccpc *form; | |
285 | ||
286 | form = guest_file_open_modes[mode].forms; | |
287 | while (*form != NULL && strcmp(*form, mode_str) != 0) { | |
288 | ++form; | |
289 | } | |
290 | if (*form != NULL) { | |
291 | break; | |
292 | } | |
293 | } | |
294 | ||
295 | if (mode == ARRAY_SIZE(guest_file_open_modes)) { | |
77dbc81b | 296 | error_setg(errp, "invalid file open mode '%s'", mode_str); |
c689b4f1 LE |
297 | return -1; |
298 | } | |
299 | return guest_file_open_modes[mode].oflag_base | O_NOCTTY | O_NONBLOCK; | |
300 | } | |
301 | ||
302 | #define DEFAULT_NEW_FILE_MODE (S_IRUSR | S_IWUSR | \ | |
303 | S_IRGRP | S_IWGRP | \ | |
304 | S_IROTH | S_IWOTH) | |
305 | ||
306 | static FILE * | |
77dbc81b | 307 | safe_open_or_create(const char *path, const char *mode, Error **errp) |
c689b4f1 LE |
308 | { |
309 | Error *local_err = NULL; | |
310 | int oflag; | |
311 | ||
312 | oflag = find_open_flag(mode, &local_err); | |
313 | if (local_err == NULL) { | |
314 | int fd; | |
315 | ||
316 | /* If the caller wants / allows creation of a new file, we implement it | |
317 | * with a two step process: open() + (open() / fchmod()). | |
318 | * | |
319 | * First we insist on creating the file exclusively as a new file. If | |
320 | * that succeeds, we're free to set any file-mode bits on it. (The | |
321 | * motivation is that we want to set those file-mode bits independently | |
322 | * of the current umask.) | |
323 | * | |
324 | * If the exclusive creation fails because the file already exists | |
325 | * (EEXIST is not possible for any other reason), we just attempt to | |
326 | * open the file, but in this case we won't be allowed to change the | |
327 | * file-mode bits on the preexistent file. | |
328 | * | |
329 | * The pathname should never disappear between the two open()s in | |
330 | * practice. If it happens, then someone very likely tried to race us. | |
331 | * In this case just go ahead and report the ENOENT from the second | |
332 | * open() to the caller. | |
333 | * | |
334 | * If the caller wants to open a preexistent file, then the first | |
335 | * open() is decisive and its third argument is ignored, and the second | |
336 | * open() and the fchmod() are never called. | |
337 | */ | |
338 | fd = open(path, oflag | ((oflag & O_CREAT) ? O_EXCL : 0), 0); | |
339 | if (fd == -1 && errno == EEXIST) { | |
340 | oflag &= ~(unsigned)O_CREAT; | |
341 | fd = open(path, oflag); | |
342 | } | |
343 | ||
344 | if (fd == -1) { | |
345 | error_setg_errno(&local_err, errno, "failed to open file '%s' " | |
346 | "(mode: '%s')", path, mode); | |
347 | } else { | |
348 | qemu_set_cloexec(fd); | |
349 | ||
350 | if ((oflag & O_CREAT) && fchmod(fd, DEFAULT_NEW_FILE_MODE) == -1) { | |
351 | error_setg_errno(&local_err, errno, "failed to set permission " | |
352 | "0%03o on new file '%s' (mode: '%s')", | |
353 | (unsigned)DEFAULT_NEW_FILE_MODE, path, mode); | |
354 | } else { | |
355 | FILE *f; | |
356 | ||
357 | f = fdopen(fd, mode); | |
358 | if (f == NULL) { | |
359 | error_setg_errno(&local_err, errno, "failed to associate " | |
360 | "stdio stream with file descriptor %d, " | |
361 | "file '%s' (mode: '%s')", fd, path, mode); | |
362 | } else { | |
363 | return f; | |
364 | } | |
365 | } | |
366 | ||
367 | close(fd); | |
2b720018 LE |
368 | if (oflag & O_CREAT) { |
369 | unlink(path); | |
370 | } | |
c689b4f1 LE |
371 | } |
372 | } | |
373 | ||
77dbc81b | 374 | error_propagate(errp, local_err); |
c689b4f1 LE |
375 | return NULL; |
376 | } | |
377 | ||
77dbc81b MA |
378 | int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, |
379 | Error **errp) | |
e3d4d252 MR |
380 | { |
381 | FILE *fh; | |
c689b4f1 | 382 | Error *local_err = NULL; |
e3d4d252 | 383 | int fd; |
39097daf | 384 | int64_t ret = -1, handle; |
e3d4d252 MR |
385 | |
386 | if (!has_mode) { | |
387 | mode = "r"; | |
388 | } | |
389 | slog("guest-file-open called, filepath: %s, mode: %s", path, mode); | |
c689b4f1 LE |
390 | fh = safe_open_or_create(path, mode, &local_err); |
391 | if (local_err != NULL) { | |
77dbc81b | 392 | error_propagate(errp, local_err); |
e3d4d252 MR |
393 | return -1; |
394 | } | |
395 | ||
396 | /* set fd non-blocking to avoid common use cases (like reading from a | |
397 | * named pipe) from hanging the agent | |
398 | */ | |
399 | fd = fileno(fh); | |
400 | ret = fcntl(fd, F_GETFL); | |
401 | ret = fcntl(fd, F_SETFL, ret | O_NONBLOCK); | |
402 | if (ret == -1) { | |
77dbc81b | 403 | error_setg_errno(errp, errno, "failed to make file '%s' non-blocking", |
db3edb66 | 404 | path); |
e3d4d252 MR |
405 | fclose(fh); |
406 | return -1; | |
407 | } | |
408 | ||
77dbc81b MA |
409 | handle = guest_file_handle_add(fh, errp); |
410 | if (error_is_set(errp)) { | |
39097daf MR |
411 | fclose(fh); |
412 | return -1; | |
413 | } | |
414 | ||
d607a523 | 415 | slog("guest-file-open, handle: %" PRId64, handle); |
39097daf | 416 | return handle; |
e3d4d252 MR |
417 | } |
418 | ||
77dbc81b | 419 | void qmp_guest_file_close(int64_t handle, Error **errp) |
e3d4d252 | 420 | { |
77dbc81b | 421 | GuestFileHandle *gfh = guest_file_handle_find(handle, errp); |
e3d4d252 MR |
422 | int ret; |
423 | ||
d607a523 | 424 | slog("guest-file-close called, handle: %" PRId64, handle); |
e3d4d252 | 425 | if (!gfh) { |
e3d4d252 MR |
426 | return; |
427 | } | |
428 | ||
429 | ret = fclose(gfh->fh); | |
3ac4b7c5 | 430 | if (ret == EOF) { |
77dbc81b | 431 | error_setg_errno(errp, errno, "failed to close handle"); |
e3d4d252 MR |
432 | return; |
433 | } | |
434 | ||
435 | QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next); | |
7267c094 | 436 | g_free(gfh); |
e3d4d252 MR |
437 | } |
438 | ||
439 | struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count, | |
77dbc81b | 440 | int64_t count, Error **errp) |
e3d4d252 | 441 | { |
77dbc81b | 442 | GuestFileHandle *gfh = guest_file_handle_find(handle, errp); |
e3d4d252 MR |
443 | GuestFileRead *read_data = NULL; |
444 | guchar *buf; | |
445 | FILE *fh; | |
446 | size_t read_count; | |
447 | ||
448 | if (!gfh) { | |
e3d4d252 MR |
449 | return NULL; |
450 | } | |
451 | ||
452 | if (!has_count) { | |
453 | count = QGA_READ_COUNT_DEFAULT; | |
454 | } else if (count < 0) { | |
77dbc81b | 455 | error_setg(errp, "value '%" PRId64 "' is invalid for argument count", |
db3edb66 | 456 | count); |
e3d4d252 MR |
457 | return NULL; |
458 | } | |
459 | ||
460 | fh = gfh->fh; | |
7267c094 | 461 | buf = g_malloc0(count+1); |
e3d4d252 MR |
462 | read_count = fread(buf, 1, count, fh); |
463 | if (ferror(fh)) { | |
77dbc81b | 464 | error_setg_errno(errp, errno, "failed to read file"); |
d607a523 | 465 | slog("guest-file-read failed, handle: %" PRId64, handle); |
e3d4d252 MR |
466 | } else { |
467 | buf[read_count] = 0; | |
7267c094 | 468 | read_data = g_malloc0(sizeof(GuestFileRead)); |
e3d4d252 MR |
469 | read_data->count = read_count; |
470 | read_data->eof = feof(fh); | |
471 | if (read_count) { | |
472 | read_data->buf_b64 = g_base64_encode(buf, read_count); | |
473 | } | |
474 | } | |
7267c094 | 475 | g_free(buf); |
e3d4d252 MR |
476 | clearerr(fh); |
477 | ||
478 | return read_data; | |
479 | } | |
480 | ||
481 | GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64, | |
77dbc81b MA |
482 | bool has_count, int64_t count, |
483 | Error **errp) | |
e3d4d252 MR |
484 | { |
485 | GuestFileWrite *write_data = NULL; | |
486 | guchar *buf; | |
487 | gsize buf_len; | |
488 | int write_count; | |
77dbc81b | 489 | GuestFileHandle *gfh = guest_file_handle_find(handle, errp); |
e3d4d252 MR |
490 | FILE *fh; |
491 | ||
492 | if (!gfh) { | |
e3d4d252 MR |
493 | return NULL; |
494 | } | |
495 | ||
496 | fh = gfh->fh; | |
497 | buf = g_base64_decode(buf_b64, &buf_len); | |
498 | ||
499 | if (!has_count) { | |
500 | count = buf_len; | |
501 | } else if (count < 0 || count > buf_len) { | |
77dbc81b | 502 | error_setg(errp, "value '%" PRId64 "' is invalid for argument count", |
db3edb66 | 503 | count); |
7267c094 | 504 | g_free(buf); |
e3d4d252 MR |
505 | return NULL; |
506 | } | |
507 | ||
508 | write_count = fwrite(buf, 1, count, fh); | |
509 | if (ferror(fh)) { | |
77dbc81b | 510 | error_setg_errno(errp, errno, "failed to write to file"); |
d607a523 | 511 | slog("guest-file-write failed, handle: %" PRId64, handle); |
e3d4d252 | 512 | } else { |
7267c094 | 513 | write_data = g_malloc0(sizeof(GuestFileWrite)); |
e3d4d252 MR |
514 | write_data->count = write_count; |
515 | write_data->eof = feof(fh); | |
516 | } | |
7267c094 | 517 | g_free(buf); |
e3d4d252 MR |
518 | clearerr(fh); |
519 | ||
520 | return write_data; | |
521 | } | |
522 | ||
523 | struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset, | |
77dbc81b | 524 | int64_t whence, Error **errp) |
e3d4d252 | 525 | { |
77dbc81b | 526 | GuestFileHandle *gfh = guest_file_handle_find(handle, errp); |
e3d4d252 MR |
527 | GuestFileSeek *seek_data = NULL; |
528 | FILE *fh; | |
529 | int ret; | |
530 | ||
531 | if (!gfh) { | |
e3d4d252 MR |
532 | return NULL; |
533 | } | |
534 | ||
535 | fh = gfh->fh; | |
536 | ret = fseek(fh, offset, whence); | |
537 | if (ret == -1) { | |
77dbc81b | 538 | error_setg_errno(errp, errno, "failed to seek file"); |
e3d4d252 | 539 | } else { |
10b7c5dd | 540 | seek_data = g_new0(GuestFileSeek, 1); |
e3d4d252 MR |
541 | seek_data->position = ftell(fh); |
542 | seek_data->eof = feof(fh); | |
543 | } | |
544 | clearerr(fh); | |
545 | ||
546 | return seek_data; | |
547 | } | |
548 | ||
77dbc81b | 549 | void qmp_guest_file_flush(int64_t handle, Error **errp) |
e3d4d252 | 550 | { |
77dbc81b | 551 | GuestFileHandle *gfh = guest_file_handle_find(handle, errp); |
e3d4d252 MR |
552 | FILE *fh; |
553 | int ret; | |
554 | ||
555 | if (!gfh) { | |
e3d4d252 MR |
556 | return; |
557 | } | |
558 | ||
559 | fh = gfh->fh; | |
560 | ret = fflush(fh); | |
561 | if (ret == EOF) { | |
77dbc81b | 562 | error_setg_errno(errp, errno, "failed to flush file"); |
e3d4d252 MR |
563 | } |
564 | } | |
565 | ||
566 | static void guest_file_init(void) | |
567 | { | |
568 | QTAILQ_INIT(&guest_file_state.filehandles); | |
569 | } | |
570 | ||
e72c3f2e MR |
571 | /* linux-specific implementations. avoid this if at all possible. */ |
572 | #if defined(__linux__) | |
573 | ||
eab5fd59 | 574 | #if defined(CONFIG_FSFREEZE) || defined(CONFIG_FSTRIM) |
af02203f | 575 | typedef struct FsMount { |
e3d4d252 MR |
576 | char *dirname; |
577 | char *devtype; | |
af02203f PB |
578 | QTAILQ_ENTRY(FsMount) next; |
579 | } FsMount; | |
e3d4d252 | 580 | |
e5d9adbd | 581 | typedef QTAILQ_HEAD(FsMountList, FsMount) FsMountList; |
9e8aded4 | 582 | |
af02203f | 583 | static void free_fs_mount_list(FsMountList *mounts) |
9e8aded4 | 584 | { |
af02203f | 585 | FsMount *mount, *temp; |
9e8aded4 MR |
586 | |
587 | if (!mounts) { | |
588 | return; | |
589 | } | |
590 | ||
591 | QTAILQ_FOREACH_SAFE(mount, mounts, next, temp) { | |
592 | QTAILQ_REMOVE(mounts, mount, next); | |
593 | g_free(mount->dirname); | |
594 | g_free(mount->devtype); | |
595 | g_free(mount); | |
596 | } | |
597 | } | |
598 | ||
e3d4d252 MR |
599 | /* |
600 | * Walk the mount table and build a list of local file systems | |
601 | */ | |
77dbc81b | 602 | static void build_fs_mount_list(FsMountList *mounts, Error **errp) |
e3d4d252 MR |
603 | { |
604 | struct mntent *ment; | |
af02203f | 605 | FsMount *mount; |
9e2fa418 | 606 | char const *mtab = "/proc/self/mounts"; |
e3d4d252 MR |
607 | FILE *fp; |
608 | ||
e3d4d252 MR |
609 | fp = setmntent(mtab, "r"); |
610 | if (!fp) { | |
77dbc81b | 611 | error_setg(errp, "failed to open mtab file: '%s'", mtab); |
261551d1 | 612 | return; |
e3d4d252 MR |
613 | } |
614 | ||
615 | while ((ment = getmntent(fp))) { | |
616 | /* | |
617 | * An entry which device name doesn't start with a '/' is | |
618 | * either a dummy file system or a network file system. | |
619 | * Add special handling for smbfs and cifs as is done by | |
620 | * coreutils as well. | |
621 | */ | |
622 | if ((ment->mnt_fsname[0] != '/') || | |
623 | (strcmp(ment->mnt_type, "smbfs") == 0) || | |
624 | (strcmp(ment->mnt_type, "cifs") == 0)) { | |
625 | continue; | |
626 | } | |
627 | ||
af02203f | 628 | mount = g_malloc0(sizeof(FsMount)); |
7267c094 AL |
629 | mount->dirname = g_strdup(ment->mnt_dir); |
630 | mount->devtype = g_strdup(ment->mnt_type); | |
e3d4d252 | 631 | |
9e8aded4 | 632 | QTAILQ_INSERT_TAIL(mounts, mount, next); |
e3d4d252 MR |
633 | } |
634 | ||
635 | endmntent(fp); | |
e3d4d252 | 636 | } |
eab5fd59 PB |
637 | #endif |
638 | ||
639 | #if defined(CONFIG_FSFREEZE) | |
e3d4d252 | 640 | |
ec0f694c TS |
641 | typedef enum { |
642 | FSFREEZE_HOOK_THAW = 0, | |
643 | FSFREEZE_HOOK_FREEZE, | |
644 | } FsfreezeHookArg; | |
645 | ||
646 | const char *fsfreeze_hook_arg_string[] = { | |
647 | "thaw", | |
648 | "freeze", | |
649 | }; | |
650 | ||
77dbc81b | 651 | static void execute_fsfreeze_hook(FsfreezeHookArg arg, Error **errp) |
ec0f694c TS |
652 | { |
653 | int status; | |
654 | pid_t pid; | |
655 | const char *hook; | |
656 | const char *arg_str = fsfreeze_hook_arg_string[arg]; | |
657 | Error *local_err = NULL; | |
658 | ||
659 | hook = ga_fsfreeze_hook(ga_state); | |
660 | if (!hook) { | |
661 | return; | |
662 | } | |
663 | if (access(hook, X_OK) != 0) { | |
77dbc81b | 664 | error_setg_errno(errp, errno, "can't access fsfreeze hook '%s'", hook); |
ec0f694c TS |
665 | return; |
666 | } | |
667 | ||
668 | slog("executing fsfreeze hook with arg '%s'", arg_str); | |
669 | pid = fork(); | |
670 | if (pid == 0) { | |
671 | setsid(); | |
672 | reopen_fd_to_null(0); | |
673 | reopen_fd_to_null(1); | |
674 | reopen_fd_to_null(2); | |
675 | ||
676 | execle(hook, hook, arg_str, NULL, environ); | |
677 | _exit(EXIT_FAILURE); | |
678 | } else if (pid < 0) { | |
77dbc81b | 679 | error_setg_errno(errp, errno, "failed to create child process"); |
ec0f694c TS |
680 | return; |
681 | } | |
682 | ||
683 | ga_wait_child(pid, &status, &local_err); | |
84d18f06 | 684 | if (local_err) { |
77dbc81b | 685 | error_propagate(errp, local_err); |
ec0f694c TS |
686 | return; |
687 | } | |
688 | ||
689 | if (!WIFEXITED(status)) { | |
77dbc81b | 690 | error_setg(errp, "fsfreeze hook has terminated abnormally"); |
ec0f694c TS |
691 | return; |
692 | } | |
693 | ||
694 | status = WEXITSTATUS(status); | |
695 | if (status) { | |
77dbc81b | 696 | error_setg(errp, "fsfreeze hook has failed with status %d", status); |
ec0f694c TS |
697 | return; |
698 | } | |
699 | } | |
700 | ||
e3d4d252 MR |
701 | /* |
702 | * Return status of freeze/thaw | |
703 | */ | |
77dbc81b | 704 | GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp) |
e3d4d252 | 705 | { |
f22d85e9 MR |
706 | if (ga_is_frozen(ga_state)) { |
707 | return GUEST_FSFREEZE_STATUS_FROZEN; | |
708 | } | |
709 | ||
710 | return GUEST_FSFREEZE_STATUS_THAWED; | |
e3d4d252 MR |
711 | } |
712 | ||
713 | /* | |
714 | * Walk list of mounted file systems in the guest, and freeze the ones which | |
715 | * are real local file systems. | |
716 | */ | |
77dbc81b | 717 | int64_t qmp_guest_fsfreeze_freeze(Error **errp) |
e3d4d252 MR |
718 | { |
719 | int ret = 0, i = 0; | |
af02203f PB |
720 | FsMountList mounts; |
721 | struct FsMount *mount; | |
261551d1 | 722 | Error *local_err = NULL; |
e3d4d252 | 723 | int fd; |
e3d4d252 MR |
724 | |
725 | slog("guest-fsfreeze called"); | |
726 | ||
ec0f694c | 727 | execute_fsfreeze_hook(FSFREEZE_HOOK_FREEZE, &local_err); |
84d18f06 | 728 | if (local_err) { |
77dbc81b | 729 | error_propagate(errp, local_err); |
ec0f694c TS |
730 | return -1; |
731 | } | |
732 | ||
9e8aded4 | 733 | QTAILQ_INIT(&mounts); |
261551d1 | 734 | build_fs_mount_list(&mounts, &local_err); |
84d18f06 | 735 | if (local_err) { |
77dbc81b | 736 | error_propagate(errp, local_err); |
261551d1 | 737 | return -1; |
e3d4d252 MR |
738 | } |
739 | ||
740 | /* cannot risk guest agent blocking itself on a write in this state */ | |
f22d85e9 | 741 | ga_set_frozen(ga_state); |
e3d4d252 | 742 | |
e5d9adbd | 743 | QTAILQ_FOREACH_REVERSE(mount, &mounts, FsMountList, next) { |
e3d4d252 MR |
744 | fd = qemu_open(mount->dirname, O_RDONLY); |
745 | if (fd == -1) { | |
77dbc81b | 746 | error_setg_errno(errp, errno, "failed to open %s", mount->dirname); |
e3d4d252 MR |
747 | goto error; |
748 | } | |
749 | ||
750 | /* we try to cull filesytems we know won't work in advance, but other | |
751 | * filesytems may not implement fsfreeze for less obvious reasons. | |
9e8aded4 MR |
752 | * these will report EOPNOTSUPP. we simply ignore these when tallying |
753 | * the number of frozen filesystems. | |
754 | * | |
755 | * any other error means a failure to freeze a filesystem we | |
756 | * expect to be freezable, so return an error in those cases | |
757 | * and return system to thawed state. | |
e3d4d252 MR |
758 | */ |
759 | ret = ioctl(fd, FIFREEZE); | |
9e8aded4 MR |
760 | if (ret == -1) { |
761 | if (errno != EOPNOTSUPP) { | |
77dbc81b | 762 | error_setg_errno(errp, errno, "failed to freeze %s", |
617fbbc1 | 763 | mount->dirname); |
9e8aded4 MR |
764 | close(fd); |
765 | goto error; | |
766 | } | |
767 | } else { | |
768 | i++; | |
e3d4d252 MR |
769 | } |
770 | close(fd); | |
e3d4d252 MR |
771 | } |
772 | ||
af02203f | 773 | free_fs_mount_list(&mounts); |
e3d4d252 MR |
774 | return i; |
775 | ||
776 | error: | |
af02203f | 777 | free_fs_mount_list(&mounts); |
9e8aded4 | 778 | qmp_guest_fsfreeze_thaw(NULL); |
e3d4d252 MR |
779 | return 0; |
780 | } | |
781 | ||
782 | /* | |
783 | * Walk list of frozen file systems in the guest, and thaw them. | |
784 | */ | |
77dbc81b | 785 | int64_t qmp_guest_fsfreeze_thaw(Error **errp) |
e3d4d252 MR |
786 | { |
787 | int ret; | |
af02203f PB |
788 | FsMountList mounts; |
789 | FsMount *mount; | |
9e8aded4 | 790 | int fd, i = 0, logged; |
261551d1 | 791 | Error *local_err = NULL; |
9e8aded4 MR |
792 | |
793 | QTAILQ_INIT(&mounts); | |
261551d1 | 794 | build_fs_mount_list(&mounts, &local_err); |
84d18f06 | 795 | if (local_err) { |
77dbc81b | 796 | error_propagate(errp, local_err); |
9e8aded4 MR |
797 | return 0; |
798 | } | |
e3d4d252 | 799 | |
9e8aded4 MR |
800 | QTAILQ_FOREACH(mount, &mounts, next) { |
801 | logged = false; | |
e3d4d252 MR |
802 | fd = qemu_open(mount->dirname, O_RDONLY); |
803 | if (fd == -1) { | |
e3d4d252 MR |
804 | continue; |
805 | } | |
9e8aded4 MR |
806 | /* we have no way of knowing whether a filesystem was actually unfrozen |
807 | * as a result of a successful call to FITHAW, only that if an error | |
808 | * was returned the filesystem was *not* unfrozen by that particular | |
809 | * call. | |
810 | * | |
a31f0531 | 811 | * since multiple preceding FIFREEZEs require multiple calls to FITHAW |
9e8aded4 MR |
812 | * to unfreeze, continuing issuing FITHAW until an error is returned, |
813 | * in which case either the filesystem is in an unfreezable state, or, | |
814 | * more likely, it was thawed previously (and remains so afterward). | |
815 | * | |
816 | * also, since the most recent successful call is the one that did | |
817 | * the actual unfreeze, we can use this to provide an accurate count | |
818 | * of the number of filesystems unfrozen by guest-fsfreeze-thaw, which | |
819 | * may * be useful for determining whether a filesystem was unfrozen | |
820 | * during the freeze/thaw phase by a process other than qemu-ga. | |
821 | */ | |
822 | do { | |
823 | ret = ioctl(fd, FITHAW); | |
824 | if (ret == 0 && !logged) { | |
825 | i++; | |
826 | logged = true; | |
827 | } | |
828 | } while (ret == 0); | |
e3d4d252 | 829 | close(fd); |
e3d4d252 MR |
830 | } |
831 | ||
f22d85e9 | 832 | ga_unset_frozen(ga_state); |
af02203f | 833 | free_fs_mount_list(&mounts); |
ec0f694c | 834 | |
77dbc81b | 835 | execute_fsfreeze_hook(FSFREEZE_HOOK_THAW, errp); |
ec0f694c | 836 | |
e3d4d252 MR |
837 | return i; |
838 | } | |
839 | ||
e3d4d252 MR |
840 | static void guest_fsfreeze_cleanup(void) |
841 | { | |
e3d4d252 MR |
842 | Error *err = NULL; |
843 | ||
f22d85e9 | 844 | if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) { |
6f686749 MA |
845 | qmp_guest_fsfreeze_thaw(&err); |
846 | if (err) { | |
847 | slog("failed to clean up frozen filesystems: %s", | |
848 | error_get_pretty(err)); | |
849 | error_free(err); | |
e3d4d252 MR |
850 | } |
851 | } | |
852 | } | |
e72c3f2e | 853 | #endif /* CONFIG_FSFREEZE */ |
e3d4d252 | 854 | |
eab5fd59 PB |
855 | #if defined(CONFIG_FSTRIM) |
856 | /* | |
857 | * Walk list of mounted file systems in the guest, and trim them. | |
858 | */ | |
77dbc81b | 859 | void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp) |
eab5fd59 PB |
860 | { |
861 | int ret = 0; | |
862 | FsMountList mounts; | |
863 | struct FsMount *mount; | |
864 | int fd; | |
261551d1 | 865 | Error *local_err = NULL; |
eab5fd59 PB |
866 | struct fstrim_range r = { |
867 | .start = 0, | |
868 | .len = -1, | |
869 | .minlen = has_minimum ? minimum : 0, | |
870 | }; | |
871 | ||
872 | slog("guest-fstrim called"); | |
873 | ||
874 | QTAILQ_INIT(&mounts); | |
261551d1 | 875 | build_fs_mount_list(&mounts, &local_err); |
84d18f06 | 876 | if (local_err) { |
77dbc81b | 877 | error_propagate(errp, local_err); |
eab5fd59 PB |
878 | return; |
879 | } | |
880 | ||
881 | QTAILQ_FOREACH(mount, &mounts, next) { | |
882 | fd = qemu_open(mount->dirname, O_RDONLY); | |
883 | if (fd == -1) { | |
77dbc81b | 884 | error_setg_errno(errp, errno, "failed to open %s", mount->dirname); |
eab5fd59 PB |
885 | goto error; |
886 | } | |
887 | ||
888 | /* We try to cull filesytems we know won't work in advance, but other | |
889 | * filesytems may not implement fstrim for less obvious reasons. These | |
890 | * will report EOPNOTSUPP; we simply ignore these errors. Any other | |
891 | * error means an unexpected error, so return it in those cases. In | |
892 | * some other cases ENOTTY will be reported (e.g. CD-ROMs). | |
893 | */ | |
894 | ret = ioctl(fd, FITRIM, &r); | |
895 | if (ret == -1) { | |
896 | if (errno != ENOTTY && errno != EOPNOTSUPP) { | |
77dbc81b | 897 | error_setg_errno(errp, errno, "failed to trim %s", |
071673b0 | 898 | mount->dirname); |
eab5fd59 PB |
899 | close(fd); |
900 | goto error; | |
901 | } | |
902 | } | |
903 | close(fd); | |
904 | } | |
905 | ||
906 | error: | |
907 | free_fs_mount_list(&mounts); | |
908 | } | |
909 | #endif /* CONFIG_FSTRIM */ | |
910 | ||
911 | ||
11d0f125 LC |
912 | #define LINUX_SYS_STATE_FILE "/sys/power/state" |
913 | #define SUSPEND_SUPPORTED 0 | |
914 | #define SUSPEND_NOT_SUPPORTED 1 | |
915 | ||
11d0f125 | 916 | static void bios_supports_mode(const char *pmutils_bin, const char *pmutils_arg, |
77dbc81b | 917 | const char *sysfile_str, Error **errp) |
11d0f125 | 918 | { |
6b26e837 | 919 | Error *local_err = NULL; |
11d0f125 | 920 | char *pmutils_path; |
6b26e837 | 921 | pid_t pid; |
dc8764f0 | 922 | int status; |
11d0f125 LC |
923 | |
924 | pmutils_path = g_find_program_in_path(pmutils_bin); | |
925 | ||
926 | pid = fork(); | |
927 | if (!pid) { | |
dc8764f0 LC |
928 | char buf[32]; /* hopefully big enough */ |
929 | ssize_t ret; | |
930 | int fd; | |
11d0f125 LC |
931 | |
932 | setsid(); | |
11d0f125 LC |
933 | reopen_fd_to_null(0); |
934 | reopen_fd_to_null(1); | |
935 | reopen_fd_to_null(2); | |
936 | ||
dc8764f0 LC |
937 | if (pmutils_path) { |
938 | execle(pmutils_path, pmutils_bin, pmutils_arg, NULL, environ); | |
939 | } | |
11d0f125 | 940 | |
dc8764f0 LC |
941 | /* |
942 | * If we get here either pm-utils is not installed or execle() has | |
943 | * failed. Let's try the manual method if the caller wants it. | |
944 | */ | |
11d0f125 | 945 | |
dc8764f0 LC |
946 | if (!sysfile_str) { |
947 | _exit(SUSPEND_NOT_SUPPORTED); | |
948 | } | |
11d0f125 | 949 | |
dc8764f0 LC |
950 | fd = open(LINUX_SYS_STATE_FILE, O_RDONLY); |
951 | if (fd < 0) { | |
11d0f125 LC |
952 | _exit(SUSPEND_NOT_SUPPORTED); |
953 | } | |
954 | ||
dc8764f0 LC |
955 | ret = read(fd, buf, sizeof(buf)-1); |
956 | if (ret <= 0) { | |
957 | _exit(SUSPEND_NOT_SUPPORTED); | |
11d0f125 | 958 | } |
dc8764f0 | 959 | buf[ret] = '\0'; |
11d0f125 | 960 | |
dc8764f0 LC |
961 | if (strstr(buf, sysfile_str)) { |
962 | _exit(SUSPEND_SUPPORTED); | |
11d0f125 LC |
963 | } |
964 | ||
dc8764f0 | 965 | _exit(SUSPEND_NOT_SUPPORTED); |
6b26e837 | 966 | } else if (pid < 0) { |
77dbc81b | 967 | error_setg_errno(errp, errno, "failed to create child process"); |
6b26e837 | 968 | goto out; |
11d0f125 LC |
969 | } |
970 | ||
6b26e837 | 971 | ga_wait_child(pid, &status, &local_err); |
84d18f06 | 972 | if (local_err) { |
77dbc81b | 973 | error_propagate(errp, local_err); |
6b26e837 LC |
974 | goto out; |
975 | } | |
11d0f125 | 976 | |
6b26e837 | 977 | if (!WIFEXITED(status)) { |
77dbc81b | 978 | error_setg(errp, "child process has terminated abnormally"); |
6b26e837 | 979 | goto out; |
dc8764f0 LC |
980 | } |
981 | ||
6b26e837 LC |
982 | switch (WEXITSTATUS(status)) { |
983 | case SUSPEND_SUPPORTED: | |
984 | goto out; | |
985 | case SUSPEND_NOT_SUPPORTED: | |
77dbc81b | 986 | error_setg(errp, |
6b26e837 LC |
987 | "the requested suspend mode is not supported by the guest"); |
988 | goto out; | |
989 | default: | |
77dbc81b | 990 | error_setg(errp, |
6b26e837 LC |
991 | "the helper program '%s' returned an unexpected exit status" |
992 | " code (%d)", pmutils_path, WEXITSTATUS(status)); | |
993 | goto out; | |
11d0f125 LC |
994 | } |
995 | ||
6b26e837 LC |
996 | out: |
997 | g_free(pmutils_path); | |
11d0f125 LC |
998 | } |
999 | ||
1000 | static void guest_suspend(const char *pmutils_bin, const char *sysfile_str, | |
77dbc81b | 1001 | Error **errp) |
11d0f125 | 1002 | { |
7b376087 | 1003 | Error *local_err = NULL; |
11d0f125 | 1004 | char *pmutils_path; |
7b376087 | 1005 | pid_t pid; |
dc8764f0 | 1006 | int status; |
11d0f125 LC |
1007 | |
1008 | pmutils_path = g_find_program_in_path(pmutils_bin); | |
1009 | ||
1010 | pid = fork(); | |
1011 | if (pid == 0) { | |
1012 | /* child */ | |
1013 | int fd; | |
1014 | ||
1015 | setsid(); | |
1016 | reopen_fd_to_null(0); | |
1017 | reopen_fd_to_null(1); | |
1018 | reopen_fd_to_null(2); | |
1019 | ||
1020 | if (pmutils_path) { | |
1021 | execle(pmutils_path, pmutils_bin, NULL, environ); | |
1022 | } | |
1023 | ||
1024 | /* | |
1025 | * If we get here either pm-utils is not installed or execle() has | |
1026 | * failed. Let's try the manual method if the caller wants it. | |
1027 | */ | |
1028 | ||
1029 | if (!sysfile_str) { | |
1030 | _exit(EXIT_FAILURE); | |
1031 | } | |
1032 | ||
1033 | fd = open(LINUX_SYS_STATE_FILE, O_WRONLY); | |
1034 | if (fd < 0) { | |
1035 | _exit(EXIT_FAILURE); | |
1036 | } | |
1037 | ||
1038 | if (write(fd, sysfile_str, strlen(sysfile_str)) < 0) { | |
1039 | _exit(EXIT_FAILURE); | |
1040 | } | |
1041 | ||
1042 | _exit(EXIT_SUCCESS); | |
7b376087 | 1043 | } else if (pid < 0) { |
77dbc81b | 1044 | error_setg_errno(errp, errno, "failed to create child process"); |
7b376087 | 1045 | goto out; |
11d0f125 LC |
1046 | } |
1047 | ||
7b376087 | 1048 | ga_wait_child(pid, &status, &local_err); |
84d18f06 | 1049 | if (local_err) { |
77dbc81b | 1050 | error_propagate(errp, local_err); |
7b376087 LC |
1051 | goto out; |
1052 | } | |
11d0f125 | 1053 | |
7b376087 | 1054 | if (!WIFEXITED(status)) { |
77dbc81b | 1055 | error_setg(errp, "child process has terminated abnormally"); |
7b376087 | 1056 | goto out; |
dc8764f0 LC |
1057 | } |
1058 | ||
7b376087 | 1059 | if (WEXITSTATUS(status)) { |
77dbc81b | 1060 | error_setg(errp, "child process has failed to suspend"); |
7b376087 | 1061 | goto out; |
11d0f125 | 1062 | } |
dc8764f0 | 1063 | |
7b376087 LC |
1064 | out: |
1065 | g_free(pmutils_path); | |
11d0f125 LC |
1066 | } |
1067 | ||
77dbc81b | 1068 | void qmp_guest_suspend_disk(Error **errp) |
11d0f125 | 1069 | { |
77dbc81b MA |
1070 | bios_supports_mode("pm-is-supported", "--hibernate", "disk", errp); |
1071 | if (error_is_set(errp)) { | |
11d0f125 LC |
1072 | return; |
1073 | } | |
1074 | ||
77dbc81b | 1075 | guest_suspend("pm-hibernate", "disk", errp); |
11d0f125 LC |
1076 | } |
1077 | ||
77dbc81b | 1078 | void qmp_guest_suspend_ram(Error **errp) |
fbf42210 | 1079 | { |
77dbc81b MA |
1080 | bios_supports_mode("pm-is-supported", "--suspend", "mem", errp); |
1081 | if (error_is_set(errp)) { | |
fbf42210 LC |
1082 | return; |
1083 | } | |
1084 | ||
77dbc81b | 1085 | guest_suspend("pm-suspend", "mem", errp); |
fbf42210 LC |
1086 | } |
1087 | ||
77dbc81b | 1088 | void qmp_guest_suspend_hybrid(Error **errp) |
95f4f404 | 1089 | { |
77dbc81b MA |
1090 | bios_supports_mode("pm-is-supported", "--suspend-hybrid", NULL, errp); |
1091 | if (error_is_set(errp)) { | |
95f4f404 LC |
1092 | return; |
1093 | } | |
1094 | ||
77dbc81b | 1095 | guest_suspend("pm-suspend-hybrid", NULL, errp); |
95f4f404 LC |
1096 | } |
1097 | ||
3424fc9f MP |
1098 | static GuestNetworkInterfaceList * |
1099 | guest_find_interface(GuestNetworkInterfaceList *head, | |
1100 | const char *name) | |
1101 | { | |
1102 | for (; head; head = head->next) { | |
1103 | if (strcmp(head->value->name, name) == 0) { | |
1104 | break; | |
1105 | } | |
1106 | } | |
1107 | ||
1108 | return head; | |
1109 | } | |
1110 | ||
1111 | /* | |
1112 | * Build information about guest interfaces | |
1113 | */ | |
1114 | GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp) | |
1115 | { | |
1116 | GuestNetworkInterfaceList *head = NULL, *cur_item = NULL; | |
1117 | struct ifaddrs *ifap, *ifa; | |
3424fc9f MP |
1118 | |
1119 | if (getifaddrs(&ifap) < 0) { | |
878a0ae0 | 1120 | error_setg_errno(errp, errno, "getifaddrs failed"); |
3424fc9f MP |
1121 | goto error; |
1122 | } | |
1123 | ||
1124 | for (ifa = ifap; ifa; ifa = ifa->ifa_next) { | |
1125 | GuestNetworkInterfaceList *info; | |
1126 | GuestIpAddressList **address_list = NULL, *address_item = NULL; | |
1127 | char addr4[INET_ADDRSTRLEN]; | |
1128 | char addr6[INET6_ADDRSTRLEN]; | |
1129 | int sock; | |
1130 | struct ifreq ifr; | |
1131 | unsigned char *mac_addr; | |
1132 | void *p; | |
1133 | ||
1134 | g_debug("Processing %s interface", ifa->ifa_name); | |
1135 | ||
1136 | info = guest_find_interface(head, ifa->ifa_name); | |
1137 | ||
1138 | if (!info) { | |
1139 | info = g_malloc0(sizeof(*info)); | |
1140 | info->value = g_malloc0(sizeof(*info->value)); | |
1141 | info->value->name = g_strdup(ifa->ifa_name); | |
1142 | ||
1143 | if (!cur_item) { | |
1144 | head = cur_item = info; | |
1145 | } else { | |
1146 | cur_item->next = info; | |
1147 | cur_item = info; | |
1148 | } | |
1149 | } | |
1150 | ||
1151 | if (!info->value->has_hardware_address && | |
1152 | ifa->ifa_flags & SIOCGIFHWADDR) { | |
1153 | /* we haven't obtained HW address yet */ | |
1154 | sock = socket(PF_INET, SOCK_STREAM, 0); | |
1155 | if (sock == -1) { | |
878a0ae0 | 1156 | error_setg_errno(errp, errno, "failed to create socket"); |
3424fc9f MP |
1157 | goto error; |
1158 | } | |
1159 | ||
1160 | memset(&ifr, 0, sizeof(ifr)); | |
1ab516ed | 1161 | pstrcpy(ifr.ifr_name, IF_NAMESIZE, info->value->name); |
3424fc9f | 1162 | if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) { |
878a0ae0 LC |
1163 | error_setg_errno(errp, errno, |
1164 | "failed to get MAC address of %s", | |
1165 | ifa->ifa_name); | |
10a2158f | 1166 | close(sock); |
3424fc9f MP |
1167 | goto error; |
1168 | } | |
1169 | ||
10a2158f | 1170 | close(sock); |
3424fc9f MP |
1171 | mac_addr = (unsigned char *) &ifr.ifr_hwaddr.sa_data; |
1172 | ||
e4ada482 SW |
1173 | info->value->hardware_address = |
1174 | g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x", | |
1175 | (int) mac_addr[0], (int) mac_addr[1], | |
1176 | (int) mac_addr[2], (int) mac_addr[3], | |
1177 | (int) mac_addr[4], (int) mac_addr[5]); | |
3424fc9f MP |
1178 | |
1179 | info->value->has_hardware_address = true; | |
3424fc9f MP |
1180 | } |
1181 | ||
1182 | if (ifa->ifa_addr && | |
1183 | ifa->ifa_addr->sa_family == AF_INET) { | |
1184 | /* interface with IPv4 address */ | |
3424fc9f MP |
1185 | p = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr; |
1186 | if (!inet_ntop(AF_INET, p, addr4, sizeof(addr4))) { | |
878a0ae0 | 1187 | error_setg_errno(errp, errno, "inet_ntop failed"); |
3424fc9f MP |
1188 | goto error; |
1189 | } | |
1190 | ||
10a2158f MA |
1191 | address_item = g_malloc0(sizeof(*address_item)); |
1192 | address_item->value = g_malloc0(sizeof(*address_item->value)); | |
3424fc9f MP |
1193 | address_item->value->ip_address = g_strdup(addr4); |
1194 | address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4; | |
1195 | ||
1196 | if (ifa->ifa_netmask) { | |
1197 | /* Count the number of set bits in netmask. | |
1198 | * This is safe as '1' and '0' cannot be shuffled in netmask. */ | |
1199 | p = &((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr; | |
1200 | address_item->value->prefix = ctpop32(((uint32_t *) p)[0]); | |
1201 | } | |
1202 | } else if (ifa->ifa_addr && | |
1203 | ifa->ifa_addr->sa_family == AF_INET6) { | |
1204 | /* interface with IPv6 address */ | |
3424fc9f MP |
1205 | p = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr; |
1206 | if (!inet_ntop(AF_INET6, p, addr6, sizeof(addr6))) { | |
878a0ae0 | 1207 | error_setg_errno(errp, errno, "inet_ntop failed"); |
3424fc9f MP |
1208 | goto error; |
1209 | } | |
1210 | ||
10a2158f MA |
1211 | address_item = g_malloc0(sizeof(*address_item)); |
1212 | address_item->value = g_malloc0(sizeof(*address_item->value)); | |
3424fc9f MP |
1213 | address_item->value->ip_address = g_strdup(addr6); |
1214 | address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6; | |
1215 | ||
1216 | if (ifa->ifa_netmask) { | |
1217 | /* Count the number of set bits in netmask. | |
1218 | * This is safe as '1' and '0' cannot be shuffled in netmask. */ | |
1219 | p = &((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr; | |
1220 | address_item->value->prefix = | |
1221 | ctpop32(((uint32_t *) p)[0]) + | |
1222 | ctpop32(((uint32_t *) p)[1]) + | |
1223 | ctpop32(((uint32_t *) p)[2]) + | |
1224 | ctpop32(((uint32_t *) p)[3]); | |
1225 | } | |
1226 | } | |
1227 | ||
1228 | if (!address_item) { | |
1229 | continue; | |
1230 | } | |
1231 | ||
1232 | address_list = &info->value->ip_addresses; | |
1233 | ||
1234 | while (*address_list && (*address_list)->next) { | |
1235 | address_list = &(*address_list)->next; | |
1236 | } | |
1237 | ||
1238 | if (!*address_list) { | |
1239 | *address_list = address_item; | |
1240 | } else { | |
1241 | (*address_list)->next = address_item; | |
1242 | } | |
1243 | ||
1244 | info->value->has_ip_addresses = true; | |
1245 | ||
1246 | ||
1247 | } | |
1248 | ||
1249 | freeifaddrs(ifap); | |
1250 | return head; | |
1251 | ||
1252 | error: | |
1253 | freeifaddrs(ifap); | |
1254 | qapi_free_GuestNetworkInterfaceList(head); | |
1255 | return NULL; | |
1256 | } | |
1257 | ||
77dbc81b | 1258 | #define SYSCONF_EXACT(name, errp) sysconf_exact((name), #name, (errp)) |
d2baff62 | 1259 | |
77dbc81b | 1260 | static long sysconf_exact(int name, const char *name_str, Error **errp) |
d2baff62 LE |
1261 | { |
1262 | long ret; | |
1263 | ||
1264 | errno = 0; | |
1265 | ret = sysconf(name); | |
1266 | if (ret == -1) { | |
1267 | if (errno == 0) { | |
77dbc81b | 1268 | error_setg(errp, "sysconf(%s): value indefinite", name_str); |
d2baff62 | 1269 | } else { |
77dbc81b | 1270 | error_setg_errno(errp, errno, "sysconf(%s)", name_str); |
d2baff62 LE |
1271 | } |
1272 | } | |
1273 | return ret; | |
1274 | } | |
1275 | ||
1276 | /* Transfer online/offline status between @vcpu and the guest system. | |
1277 | * | |
1278 | * On input either @errp or *@errp must be NULL. | |
1279 | * | |
1280 | * In system-to-@vcpu direction, the following @vcpu fields are accessed: | |
1281 | * - R: vcpu->logical_id | |
1282 | * - W: vcpu->online | |
1283 | * - W: vcpu->can_offline | |
1284 | * | |
1285 | * In @vcpu-to-system direction, the following @vcpu fields are accessed: | |
1286 | * - R: vcpu->logical_id | |
1287 | * - R: vcpu->online | |
1288 | * | |
1289 | * Written members remain unmodified on error. | |
1290 | */ | |
1291 | static void transfer_vcpu(GuestLogicalProcessor *vcpu, bool sys2vcpu, | |
1292 | Error **errp) | |
1293 | { | |
1294 | char *dirpath; | |
1295 | int dirfd; | |
1296 | ||
1297 | dirpath = g_strdup_printf("/sys/devices/system/cpu/cpu%" PRId64 "/", | |
1298 | vcpu->logical_id); | |
1299 | dirfd = open(dirpath, O_RDONLY | O_DIRECTORY); | |
1300 | if (dirfd == -1) { | |
1301 | error_setg_errno(errp, errno, "open(\"%s\")", dirpath); | |
1302 | } else { | |
1303 | static const char fn[] = "online"; | |
1304 | int fd; | |
1305 | int res; | |
1306 | ||
1307 | fd = openat(dirfd, fn, sys2vcpu ? O_RDONLY : O_RDWR); | |
1308 | if (fd == -1) { | |
1309 | if (errno != ENOENT) { | |
1310 | error_setg_errno(errp, errno, "open(\"%s/%s\")", dirpath, fn); | |
1311 | } else if (sys2vcpu) { | |
1312 | vcpu->online = true; | |
1313 | vcpu->can_offline = false; | |
1314 | } else if (!vcpu->online) { | |
1315 | error_setg(errp, "logical processor #%" PRId64 " can't be " | |
1316 | "offlined", vcpu->logical_id); | |
1317 | } /* otherwise pretend successful re-onlining */ | |
1318 | } else { | |
1319 | unsigned char status; | |
1320 | ||
1321 | res = pread(fd, &status, 1, 0); | |
1322 | if (res == -1) { | |
1323 | error_setg_errno(errp, errno, "pread(\"%s/%s\")", dirpath, fn); | |
1324 | } else if (res == 0) { | |
1325 | error_setg(errp, "pread(\"%s/%s\"): unexpected EOF", dirpath, | |
1326 | fn); | |
1327 | } else if (sys2vcpu) { | |
1328 | vcpu->online = (status != '0'); | |
1329 | vcpu->can_offline = true; | |
1330 | } else if (vcpu->online != (status != '0')) { | |
1331 | status = '0' + vcpu->online; | |
1332 | if (pwrite(fd, &status, 1, 0) == -1) { | |
1333 | error_setg_errno(errp, errno, "pwrite(\"%s/%s\")", dirpath, | |
1334 | fn); | |
1335 | } | |
1336 | } /* otherwise pretend successful re-(on|off)-lining */ | |
1337 | ||
1338 | res = close(fd); | |
1339 | g_assert(res == 0); | |
1340 | } | |
1341 | ||
1342 | res = close(dirfd); | |
1343 | g_assert(res == 0); | |
1344 | } | |
1345 | ||
1346 | g_free(dirpath); | |
1347 | } | |
1348 | ||
1349 | GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp) | |
1350 | { | |
1351 | int64_t current; | |
1352 | GuestLogicalProcessorList *head, **link; | |
1353 | long sc_max; | |
1354 | Error *local_err = NULL; | |
1355 | ||
1356 | current = 0; | |
1357 | head = NULL; | |
1358 | link = &head; | |
1359 | sc_max = SYSCONF_EXACT(_SC_NPROCESSORS_CONF, &local_err); | |
1360 | ||
1361 | while (local_err == NULL && current < sc_max) { | |
1362 | GuestLogicalProcessor *vcpu; | |
1363 | GuestLogicalProcessorList *entry; | |
1364 | ||
1365 | vcpu = g_malloc0(sizeof *vcpu); | |
1366 | vcpu->logical_id = current++; | |
1367 | vcpu->has_can_offline = true; /* lolspeak ftw */ | |
1368 | transfer_vcpu(vcpu, true, &local_err); | |
1369 | ||
1370 | entry = g_malloc0(sizeof *entry); | |
1371 | entry->value = vcpu; | |
1372 | ||
1373 | *link = entry; | |
1374 | link = &entry->next; | |
1375 | } | |
1376 | ||
1377 | if (local_err == NULL) { | |
1378 | /* there's no guest with zero VCPUs */ | |
1379 | g_assert(head != NULL); | |
1380 | return head; | |
1381 | } | |
1382 | ||
1383 | qapi_free_GuestLogicalProcessorList(head); | |
1384 | error_propagate(errp, local_err); | |
1385 | return NULL; | |
1386 | } | |
1387 | ||
cbb65fc2 LE |
1388 | int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp) |
1389 | { | |
1390 | int64_t processed; | |
1391 | Error *local_err = NULL; | |
1392 | ||
1393 | processed = 0; | |
1394 | while (vcpus != NULL) { | |
1395 | transfer_vcpu(vcpus->value, false, &local_err); | |
1396 | if (local_err != NULL) { | |
1397 | break; | |
1398 | } | |
1399 | ++processed; | |
1400 | vcpus = vcpus->next; | |
1401 | } | |
1402 | ||
1403 | if (local_err != NULL) { | |
1404 | if (processed == 0) { | |
1405 | error_propagate(errp, local_err); | |
1406 | } else { | |
1407 | error_free(local_err); | |
1408 | } | |
1409 | } | |
1410 | ||
1411 | return processed; | |
1412 | } | |
1413 | ||
e72c3f2e MR |
1414 | #else /* defined(__linux__) */ |
1415 | ||
77dbc81b | 1416 | void qmp_guest_suspend_disk(Error **errp) |
e72c3f2e | 1417 | { |
77dbc81b | 1418 | error_set(errp, QERR_UNSUPPORTED); |
e72c3f2e MR |
1419 | } |
1420 | ||
77dbc81b | 1421 | void qmp_guest_suspend_ram(Error **errp) |
e72c3f2e | 1422 | { |
77dbc81b | 1423 | error_set(errp, QERR_UNSUPPORTED); |
e72c3f2e MR |
1424 | } |
1425 | ||
77dbc81b | 1426 | void qmp_guest_suspend_hybrid(Error **errp) |
e72c3f2e | 1427 | { |
77dbc81b | 1428 | error_set(errp, QERR_UNSUPPORTED); |
e72c3f2e MR |
1429 | } |
1430 | ||
d35d4cb5 | 1431 | GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp) |
e72c3f2e | 1432 | { |
d35d4cb5 MR |
1433 | error_set(errp, QERR_UNSUPPORTED); |
1434 | return NULL; | |
e72c3f2e MR |
1435 | } |
1436 | ||
d2baff62 LE |
1437 | GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp) |
1438 | { | |
1439 | error_set(errp, QERR_UNSUPPORTED); | |
1440 | return NULL; | |
1441 | } | |
1442 | ||
cbb65fc2 LE |
1443 | int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp) |
1444 | { | |
1445 | error_set(errp, QERR_UNSUPPORTED); | |
1446 | return -1; | |
1447 | } | |
1448 | ||
d35d4cb5 MR |
1449 | #endif |
1450 | ||
1451 | #if !defined(CONFIG_FSFREEZE) | |
1452 | ||
77dbc81b | 1453 | GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp) |
e72c3f2e | 1454 | { |
77dbc81b | 1455 | error_set(errp, QERR_UNSUPPORTED); |
d35d4cb5 MR |
1456 | |
1457 | return 0; | |
e72c3f2e MR |
1458 | } |
1459 | ||
77dbc81b | 1460 | int64_t qmp_guest_fsfreeze_freeze(Error **errp) |
e72c3f2e | 1461 | { |
77dbc81b | 1462 | error_set(errp, QERR_UNSUPPORTED); |
d35d4cb5 MR |
1463 | |
1464 | return 0; | |
e72c3f2e MR |
1465 | } |
1466 | ||
77dbc81b | 1467 | int64_t qmp_guest_fsfreeze_thaw(Error **errp) |
e72c3f2e | 1468 | { |
77dbc81b | 1469 | error_set(errp, QERR_UNSUPPORTED); |
d35d4cb5 MR |
1470 | |
1471 | return 0; | |
e72c3f2e | 1472 | } |
eab5fd59 PB |
1473 | #endif /* CONFIG_FSFREEZE */ |
1474 | ||
1475 | #if !defined(CONFIG_FSTRIM) | |
77dbc81b | 1476 | void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp) |
eab5fd59 | 1477 | { |
77dbc81b | 1478 | error_set(errp, QERR_UNSUPPORTED); |
eab5fd59 | 1479 | } |
e72c3f2e MR |
1480 | #endif |
1481 | ||
e3d4d252 MR |
1482 | /* register init/cleanup routines for stateful command groups */ |
1483 | void ga_command_state_init(GAState *s, GACommandState *cs) | |
1484 | { | |
7006b9cf | 1485 | #if defined(CONFIG_FSFREEZE) |
f22d85e9 | 1486 | ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup); |
7006b9cf | 1487 | #endif |
e3d4d252 MR |
1488 | ga_command_state_add(cs, guest_file_init, NULL); |
1489 | } |