blob: 7eed7f45923ba52c51e826017943d07aaa6e320f [file] [log] [blame]
Michael Rothe3d4d252011-07-19 15:41:55 -05001/*
Michael Roth42074a92012-01-19 22:19:27 -06002 * QEMU Guest Agent POSIX-specific command implementations
Michael Rothe3d4d252011-07-19 15:41:55 -05003 *
4 * Copyright IBM Corp. 2011
5 *
6 * Authors:
7 * Michael Roth <mdroth@linux.vnet.ibm.com>
Michal Privoznik3424fc92012-02-29 17:02:23 +01008 * Michal Privoznik <mprivozn@redhat.com>
Michael Rothe3d4d252011-07-19 15:41:55 -05009 *
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>
Michael Rothe3d4d252011-07-19 15:41:55 -050015#include <sys/types.h>
16#include <sys/ioctl.h>
Luiz Capitulino2c02cbf2012-05-23 15:48:05 -030017#include <sys/wait.h>
Laszlo Ersekd2baff62013-03-06 22:59:30 +010018#include <unistd.h>
19#include <errno.h>
20#include <fcntl.h>
Tomoki Sekiyama46d4c572014-06-30 17:51:34 -040021#include <dirent.h>
Laszlo Ersekc689b4f2013-04-24 13:13:18 +020022#include <stdio.h>
23#include <string.h>
24#include <sys/stat.h>
Laszlo Ersekd2baff62013-03-06 22:59:30 +010025#include <inttypes.h>
Michael Rothe3d4d252011-07-19 15:41:55 -050026#include "qga/guest-agent-core.h"
27#include "qga-qmp-commands.h"
Paolo Bonzini7b1b5d12012-12-17 18:19:43 +010028#include "qapi/qmp/qerror.h"
Paolo Bonzini1de7afc2012-12-17 18:20:00 +010029#include "qemu/queue.h"
30#include "qemu/host-utils.h"
Michael Rothe3d4d252011-07-19 15:41:55 -050031
Luiz Capitulino2c02cbf2012-05-23 15:48:05 -030032#ifndef CONFIG_HAS_ENVIRON
Andreas Färbereecae142012-05-27 17:02:20 +020033#ifdef __APPLE__
34#include <crt_externs.h>
35#define environ (*_NSGetEnviron())
36#else
Luiz Capitulino2c02cbf2012-05-23 15:48:05 -030037extern char **environ;
38#endif
Andreas Färbereecae142012-05-27 17:02:20 +020039#endif
Luiz Capitulino2c02cbf2012-05-23 15:48:05 -030040
Michael Rothe72c3f22012-03-25 13:59:41 -050041#if defined(__linux__)
42#include <mntent.h>
43#include <linux/fs.h>
44#include <ifaddrs.h>
45#include <arpa/inet.h>
46#include <sys/socket.h>
47#include <net/if.h>
Michael Rothe72c3f22012-03-25 13:59:41 -050048
Paolo Bonzinieab5fd52012-06-13 07:41:28 +020049#ifdef FIFREEZE
Michael Rothe72c3f22012-03-25 13:59:41 -050050#define CONFIG_FSFREEZE
51#endif
Paolo Bonzinieab5fd52012-06-13 07:41:28 +020052#ifdef FITRIM
53#define CONFIG_FSTRIM
54#endif
Michael Rothe72c3f22012-03-25 13:59:41 -050055#endif
56
Markus Armbruster77dbc812014-05-02 13:26:30 +020057static void ga_wait_child(pid_t pid, int *status, Error **errp)
Luiz Capitulinod220a6d2012-11-27 11:01:58 -020058{
59 pid_t rpid;
60
61 *status = 0;
62
63 do {
64 rpid = waitpid(pid, status, 0);
65 } while (rpid == -1 && errno == EINTR);
66
67 if (rpid == -1) {
Markus Armbruster77dbc812014-05-02 13:26:30 +020068 error_setg_errno(errp, errno, "failed to wait for child (pid: %d)",
69 pid);
Luiz Capitulinod220a6d2012-11-27 11:01:58 -020070 return;
71 }
72
73 g_assert(rpid == pid);
74}
75
Markus Armbruster77dbc812014-05-02 13:26:30 +020076void qmp_guest_shutdown(bool has_mode, const char *mode, Error **errp)
Michael Rothe3d4d252011-07-19 15:41:55 -050077{
Michael Rothe3d4d252011-07-19 15:41:55 -050078 const char *shutdown_flag;
Luiz Capitulinod220a6d2012-11-27 11:01:58 -020079 Error *local_err = NULL;
80 pid_t pid;
Luiz Capitulino36748382012-05-14 15:25:20 -030081 int status;
Michael Rothe3d4d252011-07-19 15:41:55 -050082
83 slog("guest-shutdown called, mode: %s", mode);
84 if (!has_mode || strcmp(mode, "powerdown") == 0) {
85 shutdown_flag = "-P";
86 } else if (strcmp(mode, "halt") == 0) {
87 shutdown_flag = "-H";
88 } else if (strcmp(mode, "reboot") == 0) {
89 shutdown_flag = "-r";
90 } else {
Markus Armbruster77dbc812014-05-02 13:26:30 +020091 error_setg(errp,
Luiz Capitulinod220a6d2012-11-27 11:01:58 -020092 "mode is invalid (valid values are: halt|powerdown|reboot");
Michael Rothe3d4d252011-07-19 15:41:55 -050093 return;
94 }
95
Luiz Capitulinod5dd3492012-05-11 16:19:47 -030096 pid = fork();
97 if (pid == 0) {
Michael Rothe3d4d252011-07-19 15:41:55 -050098 /* child, start the shutdown */
99 setsid();
Luiz Capitulino36748382012-05-14 15:25:20 -0300100 reopen_fd_to_null(0);
101 reopen_fd_to_null(1);
102 reopen_fd_to_null(2);
Michael Rothe3d4d252011-07-19 15:41:55 -0500103
whitearchey485e7412013-11-06 10:54:04 +0900104 execle("/sbin/shutdown", "shutdown", "-h", shutdown_flag, "+0",
Luiz Capitulino36748382012-05-14 15:25:20 -0300105 "hypervisor initiated shutdown", (char*)NULL, environ);
106 _exit(EXIT_FAILURE);
Luiz Capitulinod5dd3492012-05-11 16:19:47 -0300107 } else if (pid < 0) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200108 error_setg_errno(errp, errno, "failed to create child process");
Luiz Capitulinod5dd3492012-05-11 16:19:47 -0300109 return;
110 }
111
Luiz Capitulinod220a6d2012-11-27 11:01:58 -0200112 ga_wait_child(pid, &status, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100113 if (local_err) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200114 error_propagate(errp, local_err);
Luiz Capitulinod220a6d2012-11-27 11:01:58 -0200115 return;
116 }
117
118 if (!WIFEXITED(status)) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200119 error_setg(errp, "child process has terminated abnormally");
Luiz Capitulinod220a6d2012-11-27 11:01:58 -0200120 return;
121 }
122
123 if (WEXITSTATUS(status)) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200124 error_setg(errp, "child process has failed to shutdown");
Luiz Capitulinod220a6d2012-11-27 11:01:58 -0200125 return;
126 }
127
Peter Maydell085d8132013-03-18 17:20:07 +0000128 /* succeeded */
Michael Rothe3d4d252011-07-19 15:41:55 -0500129}
130
Lei Li6912e6a2013-03-05 17:39:11 +0800131int64_t qmp_guest_get_time(Error **errp)
132{
133 int ret;
134 qemu_timeval tq;
135 int64_t time_ns;
136
137 ret = qemu_gettimeofday(&tq);
138 if (ret < 0) {
139 error_setg_errno(errp, errno, "Failed to get time");
140 return -1;
141 }
142
143 time_ns = tq.tv_sec * 1000000000LL + tq.tv_usec * 1000;
144 return time_ns;
145}
146
Michal Privoznik2c958922014-01-31 11:29:51 +0100147void qmp_guest_set_time(bool has_time, int64_t time_ns, Error **errp)
Lei Lia1bca572013-03-05 17:39:12 +0800148{
149 int ret;
150 int status;
151 pid_t pid;
152 Error *local_err = NULL;
153 struct timeval tv;
154
Michal Privoznik2c958922014-01-31 11:29:51 +0100155 /* If user has passed a time, validate and set it. */
156 if (has_time) {
157 /* year-2038 will overflow in case time_t is 32bit */
158 if (time_ns / 1000000000 != (time_t)(time_ns / 1000000000)) {
159 error_setg(errp, "Time %" PRId64 " is too large", time_ns);
160 return;
161 }
162
163 tv.tv_sec = time_ns / 1000000000;
164 tv.tv_usec = (time_ns % 1000000000) / 1000;
165
166 ret = settimeofday(&tv, NULL);
167 if (ret < 0) {
168 error_setg_errno(errp, errno, "Failed to set time to guest");
169 return;
170 }
Lei Lia1bca572013-03-05 17:39:12 +0800171 }
172
Michal Privoznik2c958922014-01-31 11:29:51 +0100173 /* Now, if user has passed a time to set and the system time is set, we
174 * just need to synchronize the hardware clock. However, if no time was
175 * passed, user is requesting the opposite: set the system time from the
Amos Kong1634df52014-04-04 23:25:02 +0800176 * hardware clock (RTC). */
Lei Lia1bca572013-03-05 17:39:12 +0800177 pid = fork();
178 if (pid == 0) {
179 setsid();
180 reopen_fd_to_null(0);
181 reopen_fd_to_null(1);
182 reopen_fd_to_null(2);
183
Michal Privoznik2c958922014-01-31 11:29:51 +0100184 /* Use '/sbin/hwclock -w' to set RTC from the system time,
185 * or '/sbin/hwclock -s' to set the system time from RTC. */
186 execle("/sbin/hwclock", "hwclock", has_time ? "-w" : "-s",
187 NULL, environ);
Lei Lia1bca572013-03-05 17:39:12 +0800188 _exit(EXIT_FAILURE);
189 } else if (pid < 0) {
190 error_setg_errno(errp, errno, "failed to create child process");
191 return;
192 }
193
194 ga_wait_child(pid, &status, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +0100195 if (local_err) {
Lei Lia1bca572013-03-05 17:39:12 +0800196 error_propagate(errp, local_err);
197 return;
198 }
199
200 if (!WIFEXITED(status)) {
201 error_setg(errp, "child process has terminated abnormally");
202 return;
203 }
204
205 if (WEXITSTATUS(status)) {
206 error_setg(errp, "hwclock failed to set hardware clock to system time");
207 return;
208 }
209}
210
Michael Rothe3d4d252011-07-19 15:41:55 -0500211typedef struct GuestFileHandle {
212 uint64_t id;
213 FILE *fh;
214 QTAILQ_ENTRY(GuestFileHandle) next;
215} GuestFileHandle;
216
217static struct {
218 QTAILQ_HEAD(, GuestFileHandle) filehandles;
219} guest_file_state;
220
Michael Roth39097da2013-03-01 11:40:27 -0600221static int64_t guest_file_handle_add(FILE *fh, Error **errp)
Michael Rothe3d4d252011-07-19 15:41:55 -0500222{
223 GuestFileHandle *gfh;
Michael Roth39097da2013-03-01 11:40:27 -0600224 int64_t handle;
225
226 handle = ga_get_fd_handle(ga_state, errp);
Markus Armbrustera903f402014-05-02 13:26:33 +0200227 if (handle < 0) {
228 return -1;
Michael Roth39097da2013-03-01 11:40:27 -0600229 }
Michael Rothe3d4d252011-07-19 15:41:55 -0500230
Anthony Liguori7267c092011-08-20 22:09:37 -0500231 gfh = g_malloc0(sizeof(GuestFileHandle));
Michael Roth39097da2013-03-01 11:40:27 -0600232 gfh->id = handle;
Michael Rothe3d4d252011-07-19 15:41:55 -0500233 gfh->fh = fh;
234 QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
Michael Roth39097da2013-03-01 11:40:27 -0600235
236 return handle;
Michael Rothe3d4d252011-07-19 15:41:55 -0500237}
238
Markus Armbruster77dbc812014-05-02 13:26:30 +0200239static GuestFileHandle *guest_file_handle_find(int64_t id, Error **errp)
Michael Rothe3d4d252011-07-19 15:41:55 -0500240{
241 GuestFileHandle *gfh;
242
243 QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next)
244 {
245 if (gfh->id == id) {
246 return gfh;
247 }
248 }
249
Markus Armbruster77dbc812014-05-02 13:26:30 +0200250 error_setg(errp, "handle '%" PRId64 "' has not been found", id);
Michael Rothe3d4d252011-07-19 15:41:55 -0500251 return NULL;
252}
253
Laszlo Ersekc689b4f2013-04-24 13:13:18 +0200254typedef const char * const ccpc;
255
Laszlo Ersek8fe6bbc2013-05-08 17:31:35 +0200256#ifndef O_BINARY
257#define O_BINARY 0
258#endif
259
Laszlo Ersekc689b4f2013-04-24 13:13:18 +0200260/* http://pubs.opengroup.org/onlinepubs/9699919799/functions/fopen.html */
261static const struct {
262 ccpc *forms;
263 int oflag_base;
264} guest_file_open_modes[] = {
Laszlo Ersek8fe6bbc2013-05-08 17:31:35 +0200265 { (ccpc[]){ "r", NULL }, O_RDONLY },
266 { (ccpc[]){ "rb", NULL }, O_RDONLY | O_BINARY },
267 { (ccpc[]){ "w", NULL }, O_WRONLY | O_CREAT | O_TRUNC },
268 { (ccpc[]){ "wb", NULL }, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY },
269 { (ccpc[]){ "a", NULL }, O_WRONLY | O_CREAT | O_APPEND },
270 { (ccpc[]){ "ab", NULL }, O_WRONLY | O_CREAT | O_APPEND | O_BINARY },
271 { (ccpc[]){ "r+", NULL }, O_RDWR },
272 { (ccpc[]){ "rb+", "r+b", NULL }, O_RDWR | O_BINARY },
273 { (ccpc[]){ "w+", NULL }, O_RDWR | O_CREAT | O_TRUNC },
274 { (ccpc[]){ "wb+", "w+b", NULL }, O_RDWR | O_CREAT | O_TRUNC | O_BINARY },
275 { (ccpc[]){ "a+", NULL }, O_RDWR | O_CREAT | O_APPEND },
276 { (ccpc[]){ "ab+", "a+b", NULL }, O_RDWR | O_CREAT | O_APPEND | O_BINARY }
Laszlo Ersekc689b4f2013-04-24 13:13:18 +0200277};
278
279static int
Markus Armbruster77dbc812014-05-02 13:26:30 +0200280find_open_flag(const char *mode_str, Error **errp)
Laszlo Ersekc689b4f2013-04-24 13:13:18 +0200281{
282 unsigned mode;
283
284 for (mode = 0; mode < ARRAY_SIZE(guest_file_open_modes); ++mode) {
285 ccpc *form;
286
287 form = guest_file_open_modes[mode].forms;
288 while (*form != NULL && strcmp(*form, mode_str) != 0) {
289 ++form;
290 }
291 if (*form != NULL) {
292 break;
293 }
294 }
295
296 if (mode == ARRAY_SIZE(guest_file_open_modes)) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200297 error_setg(errp, "invalid file open mode '%s'", mode_str);
Laszlo Ersekc689b4f2013-04-24 13:13:18 +0200298 return -1;
299 }
300 return guest_file_open_modes[mode].oflag_base | O_NOCTTY | O_NONBLOCK;
301}
302
303#define DEFAULT_NEW_FILE_MODE (S_IRUSR | S_IWUSR | \
304 S_IRGRP | S_IWGRP | \
305 S_IROTH | S_IWOTH)
306
307static FILE *
Markus Armbruster77dbc812014-05-02 13:26:30 +0200308safe_open_or_create(const char *path, const char *mode, Error **errp)
Laszlo Ersekc689b4f2013-04-24 13:13:18 +0200309{
310 Error *local_err = NULL;
311 int oflag;
312
313 oflag = find_open_flag(mode, &local_err);
314 if (local_err == NULL) {
315 int fd;
316
317 /* If the caller wants / allows creation of a new file, we implement it
318 * with a two step process: open() + (open() / fchmod()).
319 *
320 * First we insist on creating the file exclusively as a new file. If
321 * that succeeds, we're free to set any file-mode bits on it. (The
322 * motivation is that we want to set those file-mode bits independently
323 * of the current umask.)
324 *
325 * If the exclusive creation fails because the file already exists
326 * (EEXIST is not possible for any other reason), we just attempt to
327 * open the file, but in this case we won't be allowed to change the
328 * file-mode bits on the preexistent file.
329 *
330 * The pathname should never disappear between the two open()s in
331 * practice. If it happens, then someone very likely tried to race us.
332 * In this case just go ahead and report the ENOENT from the second
333 * open() to the caller.
334 *
335 * If the caller wants to open a preexistent file, then the first
336 * open() is decisive and its third argument is ignored, and the second
337 * open() and the fchmod() are never called.
338 */
339 fd = open(path, oflag | ((oflag & O_CREAT) ? O_EXCL : 0), 0);
340 if (fd == -1 && errno == EEXIST) {
341 oflag &= ~(unsigned)O_CREAT;
342 fd = open(path, oflag);
343 }
344
345 if (fd == -1) {
346 error_setg_errno(&local_err, errno, "failed to open file '%s' "
347 "(mode: '%s')", path, mode);
348 } else {
349 qemu_set_cloexec(fd);
350
351 if ((oflag & O_CREAT) && fchmod(fd, DEFAULT_NEW_FILE_MODE) == -1) {
352 error_setg_errno(&local_err, errno, "failed to set permission "
353 "0%03o on new file '%s' (mode: '%s')",
354 (unsigned)DEFAULT_NEW_FILE_MODE, path, mode);
355 } else {
356 FILE *f;
357
358 f = fdopen(fd, mode);
359 if (f == NULL) {
360 error_setg_errno(&local_err, errno, "failed to associate "
361 "stdio stream with file descriptor %d, "
362 "file '%s' (mode: '%s')", fd, path, mode);
363 } else {
364 return f;
365 }
366 }
367
368 close(fd);
Laszlo Ersek2b720012013-05-08 17:31:36 +0200369 if (oflag & O_CREAT) {
370 unlink(path);
371 }
Laszlo Ersekc689b4f2013-04-24 13:13:18 +0200372 }
373 }
374
Markus Armbruster77dbc812014-05-02 13:26:30 +0200375 error_propagate(errp, local_err);
Laszlo Ersekc689b4f2013-04-24 13:13:18 +0200376 return NULL;
377}
378
Markus Armbruster77dbc812014-05-02 13:26:30 +0200379int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode,
380 Error **errp)
Michael Rothe3d4d252011-07-19 15:41:55 -0500381{
382 FILE *fh;
Laszlo Ersekc689b4f2013-04-24 13:13:18 +0200383 Error *local_err = NULL;
Michael Rothe3d4d252011-07-19 15:41:55 -0500384 int fd;
Michael Roth39097da2013-03-01 11:40:27 -0600385 int64_t ret = -1, handle;
Michael Rothe3d4d252011-07-19 15:41:55 -0500386
387 if (!has_mode) {
388 mode = "r";
389 }
390 slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
Laszlo Ersekc689b4f2013-04-24 13:13:18 +0200391 fh = safe_open_or_create(path, mode, &local_err);
392 if (local_err != NULL) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200393 error_propagate(errp, local_err);
Michael Rothe3d4d252011-07-19 15:41:55 -0500394 return -1;
395 }
396
397 /* set fd non-blocking to avoid common use cases (like reading from a
398 * named pipe) from hanging the agent
399 */
400 fd = fileno(fh);
401 ret = fcntl(fd, F_GETFL);
402 ret = fcntl(fd, F_SETFL, ret | O_NONBLOCK);
403 if (ret == -1) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200404 error_setg_errno(errp, errno, "failed to make file '%s' non-blocking",
Luiz Capitulinodb3edb62012-11-27 11:01:57 -0200405 path);
Michael Rothe3d4d252011-07-19 15:41:55 -0500406 fclose(fh);
407 return -1;
408 }
409
Markus Armbruster77dbc812014-05-02 13:26:30 +0200410 handle = guest_file_handle_add(fh, errp);
Markus Armbrustera903f402014-05-02 13:26:33 +0200411 if (handle < 0) {
Michael Roth39097da2013-03-01 11:40:27 -0600412 fclose(fh);
413 return -1;
414 }
415
Stefan Weild607a522013-11-17 19:19:52 +0100416 slog("guest-file-open, handle: %" PRId64, handle);
Michael Roth39097da2013-03-01 11:40:27 -0600417 return handle;
Michael Rothe3d4d252011-07-19 15:41:55 -0500418}
419
Markus Armbruster77dbc812014-05-02 13:26:30 +0200420void qmp_guest_file_close(int64_t handle, Error **errp)
Michael Rothe3d4d252011-07-19 15:41:55 -0500421{
Markus Armbruster77dbc812014-05-02 13:26:30 +0200422 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
Michael Rothe3d4d252011-07-19 15:41:55 -0500423 int ret;
424
Stefan Weild607a522013-11-17 19:19:52 +0100425 slog("guest-file-close called, handle: %" PRId64, handle);
Michael Rothe3d4d252011-07-19 15:41:55 -0500426 if (!gfh) {
Michael Rothe3d4d252011-07-19 15:41:55 -0500427 return;
428 }
429
430 ret = fclose(gfh->fh);
Luiz Capitulino3ac4b7c2012-11-27 11:01:56 -0200431 if (ret == EOF) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200432 error_setg_errno(errp, errno, "failed to close handle");
Michael Rothe3d4d252011-07-19 15:41:55 -0500433 return;
434 }
435
436 QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
Anthony Liguori7267c092011-08-20 22:09:37 -0500437 g_free(gfh);
Michael Rothe3d4d252011-07-19 15:41:55 -0500438}
439
440struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
Markus Armbruster77dbc812014-05-02 13:26:30 +0200441 int64_t count, Error **errp)
Michael Rothe3d4d252011-07-19 15:41:55 -0500442{
Markus Armbruster77dbc812014-05-02 13:26:30 +0200443 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
Michael Rothe3d4d252011-07-19 15:41:55 -0500444 GuestFileRead *read_data = NULL;
445 guchar *buf;
446 FILE *fh;
447 size_t read_count;
448
449 if (!gfh) {
Michael Rothe3d4d252011-07-19 15:41:55 -0500450 return NULL;
451 }
452
453 if (!has_count) {
454 count = QGA_READ_COUNT_DEFAULT;
455 } else if (count < 0) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200456 error_setg(errp, "value '%" PRId64 "' is invalid for argument count",
Luiz Capitulinodb3edb62012-11-27 11:01:57 -0200457 count);
Michael Rothe3d4d252011-07-19 15:41:55 -0500458 return NULL;
459 }
460
461 fh = gfh->fh;
Anthony Liguori7267c092011-08-20 22:09:37 -0500462 buf = g_malloc0(count+1);
Michael Rothe3d4d252011-07-19 15:41:55 -0500463 read_count = fread(buf, 1, count, fh);
464 if (ferror(fh)) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200465 error_setg_errno(errp, errno, "failed to read file");
Stefan Weild607a522013-11-17 19:19:52 +0100466 slog("guest-file-read failed, handle: %" PRId64, handle);
Michael Rothe3d4d252011-07-19 15:41:55 -0500467 } else {
468 buf[read_count] = 0;
Anthony Liguori7267c092011-08-20 22:09:37 -0500469 read_data = g_malloc0(sizeof(GuestFileRead));
Michael Rothe3d4d252011-07-19 15:41:55 -0500470 read_data->count = read_count;
471 read_data->eof = feof(fh);
472 if (read_count) {
473 read_data->buf_b64 = g_base64_encode(buf, read_count);
474 }
475 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500476 g_free(buf);
Michael Rothe3d4d252011-07-19 15:41:55 -0500477 clearerr(fh);
478
479 return read_data;
480}
481
482GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
Markus Armbruster77dbc812014-05-02 13:26:30 +0200483 bool has_count, int64_t count,
484 Error **errp)
Michael Rothe3d4d252011-07-19 15:41:55 -0500485{
486 GuestFileWrite *write_data = NULL;
487 guchar *buf;
488 gsize buf_len;
489 int write_count;
Markus Armbruster77dbc812014-05-02 13:26:30 +0200490 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
Michael Rothe3d4d252011-07-19 15:41:55 -0500491 FILE *fh;
492
493 if (!gfh) {
Michael Rothe3d4d252011-07-19 15:41:55 -0500494 return NULL;
495 }
496
497 fh = gfh->fh;
498 buf = g_base64_decode(buf_b64, &buf_len);
499
500 if (!has_count) {
501 count = buf_len;
502 } else if (count < 0 || count > buf_len) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200503 error_setg(errp, "value '%" PRId64 "' is invalid for argument count",
Luiz Capitulinodb3edb62012-11-27 11:01:57 -0200504 count);
Anthony Liguori7267c092011-08-20 22:09:37 -0500505 g_free(buf);
Michael Rothe3d4d252011-07-19 15:41:55 -0500506 return NULL;
507 }
508
509 write_count = fwrite(buf, 1, count, fh);
510 if (ferror(fh)) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200511 error_setg_errno(errp, errno, "failed to write to file");
Stefan Weild607a522013-11-17 19:19:52 +0100512 slog("guest-file-write failed, handle: %" PRId64, handle);
Michael Rothe3d4d252011-07-19 15:41:55 -0500513 } else {
Anthony Liguori7267c092011-08-20 22:09:37 -0500514 write_data = g_malloc0(sizeof(GuestFileWrite));
Michael Rothe3d4d252011-07-19 15:41:55 -0500515 write_data->count = write_count;
516 write_data->eof = feof(fh);
517 }
Anthony Liguori7267c092011-08-20 22:09:37 -0500518 g_free(buf);
Michael Rothe3d4d252011-07-19 15:41:55 -0500519 clearerr(fh);
520
521 return write_data;
522}
523
524struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
Markus Armbruster77dbc812014-05-02 13:26:30 +0200525 int64_t whence, Error **errp)
Michael Rothe3d4d252011-07-19 15:41:55 -0500526{
Markus Armbruster77dbc812014-05-02 13:26:30 +0200527 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
Michael Rothe3d4d252011-07-19 15:41:55 -0500528 GuestFileSeek *seek_data = NULL;
529 FILE *fh;
530 int ret;
531
532 if (!gfh) {
Michael Rothe3d4d252011-07-19 15:41:55 -0500533 return NULL;
534 }
535
536 fh = gfh->fh;
537 ret = fseek(fh, offset, whence);
538 if (ret == -1) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200539 error_setg_errno(errp, errno, "failed to seek file");
Michael Rothe3d4d252011-07-19 15:41:55 -0500540 } else {
Markus Armbruster10b7c5d2014-02-21 13:36:49 +0100541 seek_data = g_new0(GuestFileSeek, 1);
Michael Rothe3d4d252011-07-19 15:41:55 -0500542 seek_data->position = ftell(fh);
543 seek_data->eof = feof(fh);
544 }
545 clearerr(fh);
546
547 return seek_data;
548}
549
Markus Armbruster77dbc812014-05-02 13:26:30 +0200550void qmp_guest_file_flush(int64_t handle, Error **errp)
Michael Rothe3d4d252011-07-19 15:41:55 -0500551{
Markus Armbruster77dbc812014-05-02 13:26:30 +0200552 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
Michael Rothe3d4d252011-07-19 15:41:55 -0500553 FILE *fh;
554 int ret;
555
556 if (!gfh) {
Michael Rothe3d4d252011-07-19 15:41:55 -0500557 return;
558 }
559
560 fh = gfh->fh;
561 ret = fflush(fh);
562 if (ret == EOF) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200563 error_setg_errno(errp, errno, "failed to flush file");
Michael Rothe3d4d252011-07-19 15:41:55 -0500564 }
565}
566
567static void guest_file_init(void)
568{
569 QTAILQ_INIT(&guest_file_state.filehandles);
570}
571
Michael Rothe72c3f22012-03-25 13:59:41 -0500572/* linux-specific implementations. avoid this if at all possible. */
573#if defined(__linux__)
574
Paolo Bonzinieab5fd52012-06-13 07:41:28 +0200575#if defined(CONFIG_FSFREEZE) || defined(CONFIG_FSTRIM)
Paolo Bonziniaf022032012-06-13 07:41:27 +0200576typedef struct FsMount {
Michael Rothe3d4d252011-07-19 15:41:55 -0500577 char *dirname;
578 char *devtype;
Tomoki Sekiyama46d4c572014-06-30 17:51:34 -0400579 unsigned int devmajor, devminor;
Paolo Bonziniaf022032012-06-13 07:41:27 +0200580 QTAILQ_ENTRY(FsMount) next;
581} FsMount;
Michael Rothe3d4d252011-07-19 15:41:55 -0500582
Tomoki Sekiyamae5d9adb2013-10-01 17:09:53 -0400583typedef QTAILQ_HEAD(FsMountList, FsMount) FsMountList;
Michael Roth9e8aded432012-04-16 19:52:17 -0500584
Paolo Bonziniaf022032012-06-13 07:41:27 +0200585static void free_fs_mount_list(FsMountList *mounts)
Michael Roth9e8aded432012-04-16 19:52:17 -0500586{
Paolo Bonziniaf022032012-06-13 07:41:27 +0200587 FsMount *mount, *temp;
Michael Roth9e8aded432012-04-16 19:52:17 -0500588
589 if (!mounts) {
590 return;
591 }
592
593 QTAILQ_FOREACH_SAFE(mount, mounts, next, temp) {
594 QTAILQ_REMOVE(mounts, mount, next);
595 g_free(mount->dirname);
596 g_free(mount->devtype);
597 g_free(mount);
598 }
599}
600
Tomoki Sekiyama46d4c572014-06-30 17:51:34 -0400601static int dev_major_minor(const char *devpath,
602 unsigned int *devmajor, unsigned int *devminor)
603{
604 struct stat st;
605
606 *devmajor = 0;
607 *devminor = 0;
608
609 if (stat(devpath, &st) < 0) {
610 slog("failed to stat device file '%s': %s", devpath, strerror(errno));
611 return -1;
612 }
613 if (S_ISDIR(st.st_mode)) {
614 /* It is bind mount */
615 return -2;
616 }
617 if (S_ISBLK(st.st_mode)) {
618 *devmajor = major(st.st_rdev);
619 *devminor = minor(st.st_rdev);
620 return 0;
621 }
622 return -1;
623}
624
Michael Rothe3d4d252011-07-19 15:41:55 -0500625/*
626 * Walk the mount table and build a list of local file systems
627 */
Tomoki Sekiyama46d4c572014-06-30 17:51:34 -0400628static void build_fs_mount_list_from_mtab(FsMountList *mounts, Error **errp)
Michael Rothe3d4d252011-07-19 15:41:55 -0500629{
630 struct mntent *ment;
Paolo Bonziniaf022032012-06-13 07:41:27 +0200631 FsMount *mount;
Michael Roth9e2fa412012-05-29 10:08:50 -0500632 char const *mtab = "/proc/self/mounts";
Michael Rothe3d4d252011-07-19 15:41:55 -0500633 FILE *fp;
Tomoki Sekiyama46d4c572014-06-30 17:51:34 -0400634 unsigned int devmajor, devminor;
Michael Rothe3d4d252011-07-19 15:41:55 -0500635
Michael Rothe3d4d252011-07-19 15:41:55 -0500636 fp = setmntent(mtab, "r");
637 if (!fp) {
Markus Armbruster77dbc812014-05-02 13:26:30 +0200638 error_setg(errp, "failed to open mtab file: '%s'", mtab);
Luiz Capitulino261551d2012-11-29 15:29:11 -0200639 return;
Michael Rothe3d4d252011-07-19 15:41:55 -0500640 }
641
642 while ((ment = getmntent(fp))) {
643 /*
644 * An entry which device name doesn't start with a '/' is
645 * either a dummy file system or a network file system.
646 * Add special handling for smbfs and cifs as is done by
647 * coreutils as well.
648 */
649 if ((ment->mnt_fsname[0] != '/') ||
650 (strcmp(ment->mnt_type, "smbfs") == 0) ||
651 (strcmp(ment->mnt_type, "cifs") == 0)) {
652 continue;
653 }
Tomoki Sekiyama46d4c572014-06-30 17:51:34 -0400654 if (dev_major_minor(ment->mnt_fsname, &devmajor, &devminor) == -2) {
655 /* Skip bind mounts */
656 continue;
657 }
Michael Rothe3d4d252011-07-19 15:41:55 -0500658
Paolo Bonziniaf022032012-06-13 07:41:27 +0200659 mount = g_malloc0(sizeof(FsMount));
Anthony Liguori7267c092011-08-20 22:09:37 -0500660 mount->dirname = g_strdup(ment->mnt_dir);
661 mount->devtype = g_strdup(ment->mnt_type);
Tomoki Sekiyama46d4c572014-06-30 17:51:34 -0400662 mount->devmajor = devmajor;
663 mount->devminor = devminor;
Michael Rothe3d4d252011-07-19 15:41:55 -0500664
Michael Roth9e8aded432012-04-16 19:52:17 -0500665 QTAILQ_INSERT_TAIL(mounts, mount, next);
Michael Rothe3d4d252011-07-19 15:41:55 -0500666 }
667
668 endmntent(fp);
Michael Rothe3d4d252011-07-19 15:41:55 -0500669}
Tomoki Sekiyama46d4c572014-06-30 17:51:34 -0400670
671static void decode_mntname(char *name, int len)
672{
673 int i, j = 0;
674 for (i = 0; i <= len; i++) {
675 if (name[i] != '\\') {
676 name[j++] = name[i];
677 } else if (name[i + 1] == '\\') {
678 name[j++] = '\\';
679 i++;
680 } else if (name[i + 1] >= '0' && name[i + 1] <= '3' &&
681 name[i + 2] >= '0' && name[i + 2] <= '7' &&
682 name[i + 3] >= '0' && name[i + 3] <= '7') {
683 name[j++] = (name[i + 1] - '0') * 64 +
684 (name[i + 2] - '0') * 8 +
685 (name[i + 3] - '0');
686 i += 3;
687 } else {
688 name[j++] = name[i];
689 }
690 }
691}
692
693static void build_fs_mount_list(FsMountList *mounts, Error **errp)
694{
695 FsMount *mount;
696 char const *mountinfo = "/proc/self/mountinfo";
697 FILE *fp;
698 char *line = NULL, *dash;
699 size_t n;
700 char check;
701 unsigned int devmajor, devminor;
702 int ret, dir_s, dir_e, type_s, type_e, dev_s, dev_e;
703
704 fp = fopen(mountinfo, "r");
705 if (!fp) {
706 build_fs_mount_list_from_mtab(mounts, errp);
707 return;
708 }
709
710 while (getline(&line, &n, fp) != -1) {
711 ret = sscanf(line, "%*u %*u %u:%u %*s %n%*s%n%c",
712 &devmajor, &devminor, &dir_s, &dir_e, &check);
713 if (ret < 3) {
714 continue;
715 }
716 dash = strstr(line + dir_e, " - ");
717 if (!dash) {
718 continue;
719 }
720 ret = sscanf(dash, " - %n%*s%n %n%*s%n%c",
721 &type_s, &type_e, &dev_s, &dev_e, &check);
722 if (ret < 1) {
723 continue;
724 }
725 line[dir_e] = 0;
726 dash[type_e] = 0;
727 dash[dev_e] = 0;
728 decode_mntname(line + dir_s, dir_e - dir_s);
729 decode_mntname(dash + dev_s, dev_e - dev_s);
730 if (devmajor == 0) {
731 /* btrfs reports major number = 0 */
732 if (strcmp("btrfs", dash + type_s) != 0 ||
733 dev_major_minor(dash + dev_s, &devmajor, &devminor) < 0) {
734 continue;
735 }
736 }
737
738 mount = g_malloc0(sizeof(FsMount));
739 mount->dirname = g_strdup(line + dir_s);
740 mount->devtype = g_strdup(dash + type_s);
741 mount->devmajor = devmajor;
742 mount->devminor = devminor;
743
744 QTAILQ_INSERT_TAIL(mounts, mount, next);
745 }
746 free(line);
747
748 fclose(fp);
749}
Paolo Bonzinieab5fd52012-06-13 07:41:28 +0200750#endif
751
752#if defined(CONFIG_FSFREEZE)
Michael Rothe3d4d252011-07-19 15:41:55 -0500753
Tomoki Sekiyama46d4c572014-06-30 17:51:34 -0400754static char *get_pci_driver(char const *syspath, int pathlen, Error **errp)
755{
756 char *path;
757 char *dpath;
758 char *driver = NULL;
759 char buf[PATH_MAX];
760 ssize_t len;
761
762 path = g_strndup(syspath, pathlen);
763 dpath = g_strdup_printf("%s/driver", path);
764 len = readlink(dpath, buf, sizeof(buf) - 1);
765 if (len != -1) {
766 buf[len] = 0;
767 driver = g_strdup(basename(buf));
768 }
769 g_free(dpath);
770 g_free(path);
771 return driver;
772}
773
774static int compare_uint(const void *_a, const void *_b)
775{
776 unsigned int a = *(unsigned int *)_a;
777 unsigned int b = *(unsigned int *)_b;
778
779 return a < b ? -1 : a > b ? 1 : 0;
780}
781
782/* Walk the specified sysfs and build a sorted list of host or ata numbers */
783static int build_hosts(char const *syspath, char const *host, bool ata,
784 unsigned int *hosts, int hosts_max, Error **errp)
785{
786 char *path;
787 DIR *dir;
788 struct dirent *entry;
789 int i = 0;
790
791 path = g_strndup(syspath, host - syspath);
792 dir = opendir(path);
793 if (!dir) {
794 error_setg_errno(errp, errno, "opendir(\"%s\")", path);
795 g_free(path);
796 return -1;
797 }
798
799 while (i < hosts_max) {
800 entry = readdir(dir);
801 if (!entry) {
802 break;
803 }
804 if (ata && sscanf(entry->d_name, "ata%d", hosts + i) == 1) {
805 ++i;
806 } else if (!ata && sscanf(entry->d_name, "host%d", hosts + i) == 1) {
807 ++i;
808 }
809 }
810
811 qsort(hosts, i, sizeof(hosts[0]), compare_uint);
812
813 g_free(path);
814 closedir(dir);
815 return i;
816}
817
818/* Store disk device info specified by @sysfs into @fs */
819static void build_guest_fsinfo_for_real_device(char const *syspath,
820 GuestFilesystemInfo *fs,
821 Error **errp)
822{
823 unsigned int pci[4], host, hosts[8], tgt[3];
824 int i, nhosts = 0, pcilen;
825 GuestDiskAddress *disk;
826 GuestPCIAddress *pciaddr;
827 GuestDiskAddressList *list = NULL;
828 bool has_ata = false, has_host = false, has_tgt = false;
829 char *p, *q, *driver = NULL;
830
831 p = strstr(syspath, "/devices/pci");
832 if (!p || sscanf(p + 12, "%*x:%*x/%x:%x:%x.%x%n",
833 pci, pci + 1, pci + 2, pci + 3, &pcilen) < 4) {
834 g_debug("only pci device is supported: sysfs path \"%s\"", syspath);
835 return;
836 }
837
838 driver = get_pci_driver(syspath, (p + 12 + pcilen) - syspath, errp);
839 if (!driver) {
840 goto cleanup;
841 }
842
843 p = strstr(syspath, "/target");
844 if (p && sscanf(p + 7, "%*u:%*u:%*u/%*u:%u:%u:%u",
845 tgt, tgt + 1, tgt + 2) == 3) {
846 has_tgt = true;
847 }
848
849 p = strstr(syspath, "/ata");
850 if (p) {
851 q = p + 4;
852 has_ata = true;
853 } else {
854 p = strstr(syspath, "/host");
855 q = p + 5;
856 }
857 if (p && sscanf(q, "%u", &host) == 1) {
858 has_host = true;
859 nhosts = build_hosts(syspath, p, has_ata, hosts,
860 sizeof(hosts) / sizeof(hosts[0]), errp);
861 if (nhosts < 0) {
862 goto cleanup;
863 }
864 }
865
866 pciaddr = g_malloc0(sizeof(*pciaddr));
867 pciaddr->domain = pci[0];
868 pciaddr->bus = pci[1];
869 pciaddr->slot = pci[2];
870 pciaddr->function = pci[3];
871
872 disk = g_malloc0(sizeof(*disk));
873 disk->pci_controller = pciaddr;
874
875 list = g_malloc0(sizeof(*list));
876 list->value = disk;
877
878 if (strcmp(driver, "ata_piix") == 0) {
879 /* a host per ide bus, target*:0:<unit>:0 */
880 if (!has_host || !has_tgt) {
881 g_debug("invalid sysfs path '%s' (driver '%s')", syspath, driver);
882 goto cleanup;
883 }
884 for (i = 0; i < nhosts; i++) {
885 if (host == hosts[i]) {
886 disk->bus_type = GUEST_DISK_BUS_TYPE_IDE;
887 disk->bus = i;
888 disk->unit = tgt[1];
889 break;
890 }
891 }
892 if (i >= nhosts) {
893 g_debug("no host for '%s' (driver '%s')", syspath, driver);
894 goto cleanup;
895 }
896 } else if (strcmp(driver, "sym53c8xx") == 0) {
897 /* scsi(LSI Logic): target*:0:<unit>:0 */
898 if (!has_tgt) {
899 g_debug("invalid sysfs path '%s' (driver '%s')", syspath, driver);
900 goto cleanup;
901 }
902 disk->bus_type = GUEST_DISK_BUS_TYPE_SCSI;
903 disk->unit = tgt[1];
904 } else if (strcmp(driver, "virtio-pci") == 0) {
905 if (has_tgt) {
906 /* virtio-scsi: target*:0:0:<unit> */
907 disk->bus_type = GUEST_DISK_BUS_TYPE_SCSI;
908 disk->unit = tgt[2];
909 } else {
910 /* virtio-blk: 1 disk per 1 device */
911 disk->bus_type = GUEST_DISK_BUS_TYPE_VIRTIO;
912 }
913 } else if (strcmp(driver, "ahci") == 0) {
914 /* ahci: 1 host per 1 unit */
915 if (!has_host || !has_tgt) {
916 g_debug("invalid sysfs path '%s' (driver '%s')", syspath, driver);
917 goto cleanup;
918 }
919 for (i = 0; i < nhosts; i++) {
920 if (host == hosts[i]) {
921 disk->unit = i;
922 disk->bus_type = GUEST_DISK_BUS_TYPE_SATA;
923 break;
924 }
925 }
926 if (i >= nhosts) {
927 g_debug("no host for '%s' (driver '%s')", syspath, driver);
928 goto cleanup;
929 }
930 } else {
931 g_debug("unknown driver '%s' (sysfs path '%s')", driver, syspath);
932 goto cleanup;
933 }
934
935 list->next = fs->disk;
936 fs->disk = list;
937 g_free(driver);
938 return;
939
940cleanup:
941 if (list) {
942 qapi_free_GuestDiskAddressList(list);
943 }
944 g_free(driver);
945}
946
947static void build_guest_fsinfo_for_device(char const *devpath,
948 GuestFilesystemInfo *fs,
949 Error **errp);
950
951/* Store a list of slave devices of virtual volume specified by @syspath into
952 * @fs */
953static void build_guest_fsinfo_for_virtual_device(char const *syspath,
954 GuestFilesystemInfo *fs,
955 Error **errp)
956{
957 DIR *dir;
958 char *dirpath;
959 struct dirent entry, *result;
960
961 dirpath = g_strdup_printf("%s/slaves", syspath);
962 dir = opendir(dirpath);
963 if (!dir) {
964 error_setg_errno(errp, errno, "opendir(\"%s\")", dirpath);
965 g_free(dirpath);
966 return;
967 }
968 g_free(dirpath);
969
970 for (;;) {
971 if (readdir_r(dir, &entry, &result) != 0) {
972 error_setg_errno(errp, errno, "readdir_r(\"%s\")", dirpath);
973 break;
974 }
975 if (!result) {
976 break;
977 }
978
979 if (entry.d_type == DT_LNK) {
980 g_debug(" slave device '%s'", entry.d_name);
981 dirpath = g_strdup_printf("%s/slaves/%s", syspath, entry.d_name);
982 build_guest_fsinfo_for_device(dirpath, fs, errp);
983 g_free(dirpath);
984
985 if (*errp) {
986 break;
987 }
988 }
989 }
990
991 closedir(dir);
992}
993
994/* Dispatch to functions for virtual/real device */
995static void build_guest_fsinfo_for_device(char const *devpath,
996 GuestFilesystemInfo *fs,
997 Error **errp)
998{
999 char *syspath = realpath(devpath, NULL);
1000
1001 if (!syspath) {
1002 error_setg_errno(errp, errno, "realpath(\"%s\")", devpath);
1003 return;
1004 }
1005
1006 if (!fs->name) {
1007 fs->name = g_strdup(basename(syspath));
1008 }
1009
1010 g_debug(" parse sysfs path '%s'", syspath);
1011
1012 if (strstr(syspath, "/devices/virtual/block/")) {
1013 build_guest_fsinfo_for_virtual_device(syspath, fs, errp);
1014 } else {
1015 build_guest_fsinfo_for_real_device(syspath, fs, errp);
1016 }
1017
1018 free(syspath);
1019}
1020
1021/* Return a list of the disk device(s)' info which @mount lies on */
1022static GuestFilesystemInfo *build_guest_fsinfo(struct FsMount *mount,
1023 Error **errp)
1024{
1025 GuestFilesystemInfo *fs = g_malloc0(sizeof(*fs));
1026 char *devpath = g_strdup_printf("/sys/dev/block/%u:%u",
1027 mount->devmajor, mount->devminor);
1028
1029 fs->mountpoint = g_strdup(mount->dirname);
1030 fs->type = g_strdup(mount->devtype);
1031 build_guest_fsinfo_for_device(devpath, fs, errp);
1032
1033 g_free(devpath);
1034 return fs;
1035}
1036
1037GuestFilesystemInfoList *qmp_guest_get_fsinfo(Error **errp)
1038{
1039 FsMountList mounts;
1040 struct FsMount *mount;
1041 GuestFilesystemInfoList *new, *ret = NULL;
1042 Error *local_err = NULL;
1043
1044 QTAILQ_INIT(&mounts);
1045 build_fs_mount_list(&mounts, &local_err);
1046 if (local_err) {
1047 error_propagate(errp, local_err);
1048 return NULL;
1049 }
1050
1051 QTAILQ_FOREACH(mount, &mounts, next) {
1052 g_debug("Building guest fsinfo for '%s'", mount->dirname);
1053
1054 new = g_malloc0(sizeof(*ret));
1055 new->value = build_guest_fsinfo(mount, &local_err);
1056 new->next = ret;
1057 ret = new;
1058 if (local_err) {
1059 error_propagate(errp, local_err);
1060 qapi_free_GuestFilesystemInfoList(ret);
1061 ret = NULL;
1062 break;
1063 }
1064 }
1065
1066 free_fs_mount_list(&mounts);
1067 return ret;
1068}
1069
1070
Tomoki Sekiyamaec0f6942012-12-12 12:55:55 +09001071typedef enum {
1072 FSFREEZE_HOOK_THAW = 0,
1073 FSFREEZE_HOOK_FREEZE,
1074} FsfreezeHookArg;
1075
Stefan Weil13a439e2014-07-07 21:07:29 +02001076static const char *fsfreeze_hook_arg_string[] = {
Tomoki Sekiyamaec0f6942012-12-12 12:55:55 +09001077 "thaw",
1078 "freeze",
1079};
1080
Markus Armbruster77dbc812014-05-02 13:26:30 +02001081static void execute_fsfreeze_hook(FsfreezeHookArg arg, Error **errp)
Tomoki Sekiyamaec0f6942012-12-12 12:55:55 +09001082{
1083 int status;
1084 pid_t pid;
1085 const char *hook;
1086 const char *arg_str = fsfreeze_hook_arg_string[arg];
1087 Error *local_err = NULL;
1088
1089 hook = ga_fsfreeze_hook(ga_state);
1090 if (!hook) {
1091 return;
1092 }
1093 if (access(hook, X_OK) != 0) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001094 error_setg_errno(errp, errno, "can't access fsfreeze hook '%s'", hook);
Tomoki Sekiyamaec0f6942012-12-12 12:55:55 +09001095 return;
1096 }
1097
1098 slog("executing fsfreeze hook with arg '%s'", arg_str);
1099 pid = fork();
1100 if (pid == 0) {
1101 setsid();
1102 reopen_fd_to_null(0);
1103 reopen_fd_to_null(1);
1104 reopen_fd_to_null(2);
1105
1106 execle(hook, hook, arg_str, NULL, environ);
1107 _exit(EXIT_FAILURE);
1108 } else if (pid < 0) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001109 error_setg_errno(errp, errno, "failed to create child process");
Tomoki Sekiyamaec0f6942012-12-12 12:55:55 +09001110 return;
1111 }
1112
1113 ga_wait_child(pid, &status, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001114 if (local_err) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001115 error_propagate(errp, local_err);
Tomoki Sekiyamaec0f6942012-12-12 12:55:55 +09001116 return;
1117 }
1118
1119 if (!WIFEXITED(status)) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001120 error_setg(errp, "fsfreeze hook has terminated abnormally");
Tomoki Sekiyamaec0f6942012-12-12 12:55:55 +09001121 return;
1122 }
1123
1124 status = WEXITSTATUS(status);
1125 if (status) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001126 error_setg(errp, "fsfreeze hook has failed with status %d", status);
Tomoki Sekiyamaec0f6942012-12-12 12:55:55 +09001127 return;
1128 }
1129}
1130
Michael Rothe3d4d252011-07-19 15:41:55 -05001131/*
1132 * Return status of freeze/thaw
1133 */
Markus Armbruster77dbc812014-05-02 13:26:30 +02001134GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp)
Michael Rothe3d4d252011-07-19 15:41:55 -05001135{
Michael Rothf22d85e2012-04-17 19:01:45 -05001136 if (ga_is_frozen(ga_state)) {
1137 return GUEST_FSFREEZE_STATUS_FROZEN;
1138 }
1139
1140 return GUEST_FSFREEZE_STATUS_THAWED;
Michael Rothe3d4d252011-07-19 15:41:55 -05001141}
1142
Tomoki Sekiyamae99bce22014-06-30 17:51:27 -04001143int64_t qmp_guest_fsfreeze_freeze(Error **errp)
1144{
1145 return qmp_guest_fsfreeze_freeze_list(false, NULL, errp);
1146}
1147
Michael Rothe3d4d252011-07-19 15:41:55 -05001148/*
1149 * Walk list of mounted file systems in the guest, and freeze the ones which
1150 * are real local file systems.
1151 */
Tomoki Sekiyamae99bce22014-06-30 17:51:27 -04001152int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,
1153 strList *mountpoints,
1154 Error **errp)
Michael Rothe3d4d252011-07-19 15:41:55 -05001155{
1156 int ret = 0, i = 0;
Tomoki Sekiyamae99bce22014-06-30 17:51:27 -04001157 strList *list;
Paolo Bonziniaf022032012-06-13 07:41:27 +02001158 FsMountList mounts;
1159 struct FsMount *mount;
Luiz Capitulino261551d2012-11-29 15:29:11 -02001160 Error *local_err = NULL;
Michael Rothe3d4d252011-07-19 15:41:55 -05001161 int fd;
Michael Rothe3d4d252011-07-19 15:41:55 -05001162
1163 slog("guest-fsfreeze called");
1164
Tomoki Sekiyamaec0f6942012-12-12 12:55:55 +09001165 execute_fsfreeze_hook(FSFREEZE_HOOK_FREEZE, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001166 if (local_err) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001167 error_propagate(errp, local_err);
Tomoki Sekiyamaec0f6942012-12-12 12:55:55 +09001168 return -1;
1169 }
1170
Michael Roth9e8aded432012-04-16 19:52:17 -05001171 QTAILQ_INIT(&mounts);
Luiz Capitulino261551d2012-11-29 15:29:11 -02001172 build_fs_mount_list(&mounts, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001173 if (local_err) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001174 error_propagate(errp, local_err);
Luiz Capitulino261551d2012-11-29 15:29:11 -02001175 return -1;
Michael Rothe3d4d252011-07-19 15:41:55 -05001176 }
1177
1178 /* cannot risk guest agent blocking itself on a write in this state */
Michael Rothf22d85e2012-04-17 19:01:45 -05001179 ga_set_frozen(ga_state);
Michael Rothe3d4d252011-07-19 15:41:55 -05001180
Tomoki Sekiyamae5d9adb2013-10-01 17:09:53 -04001181 QTAILQ_FOREACH_REVERSE(mount, &mounts, FsMountList, next) {
Tomoki Sekiyamae99bce22014-06-30 17:51:27 -04001182 /* To issue fsfreeze in the reverse order of mounts, check if the
1183 * mount is listed in the list here */
1184 if (has_mountpoints) {
1185 for (list = mountpoints; list; list = list->next) {
1186 if (strcmp(list->value, mount->dirname) == 0) {
1187 break;
1188 }
1189 }
1190 if (!list) {
1191 continue;
1192 }
1193 }
1194
Michael Rothe3d4d252011-07-19 15:41:55 -05001195 fd = qemu_open(mount->dirname, O_RDONLY);
1196 if (fd == -1) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001197 error_setg_errno(errp, errno, "failed to open %s", mount->dirname);
Michael Rothe3d4d252011-07-19 15:41:55 -05001198 goto error;
1199 }
1200
1201 /* we try to cull filesytems we know won't work in advance, but other
1202 * filesytems may not implement fsfreeze for less obvious reasons.
Michael Roth9e8aded432012-04-16 19:52:17 -05001203 * these will report EOPNOTSUPP. we simply ignore these when tallying
1204 * the number of frozen filesystems.
1205 *
1206 * any other error means a failure to freeze a filesystem we
1207 * expect to be freezable, so return an error in those cases
1208 * and return system to thawed state.
Michael Rothe3d4d252011-07-19 15:41:55 -05001209 */
1210 ret = ioctl(fd, FIFREEZE);
Michael Roth9e8aded432012-04-16 19:52:17 -05001211 if (ret == -1) {
1212 if (errno != EOPNOTSUPP) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001213 error_setg_errno(errp, errno, "failed to freeze %s",
Luiz Capitulino617fbbc2012-11-27 11:02:00 -02001214 mount->dirname);
Michael Roth9e8aded432012-04-16 19:52:17 -05001215 close(fd);
1216 goto error;
1217 }
1218 } else {
1219 i++;
Michael Rothe3d4d252011-07-19 15:41:55 -05001220 }
1221 close(fd);
Michael Rothe3d4d252011-07-19 15:41:55 -05001222 }
1223
Paolo Bonziniaf022032012-06-13 07:41:27 +02001224 free_fs_mount_list(&mounts);
Michael Rothe3d4d252011-07-19 15:41:55 -05001225 return i;
1226
1227error:
Paolo Bonziniaf022032012-06-13 07:41:27 +02001228 free_fs_mount_list(&mounts);
Michael Roth9e8aded432012-04-16 19:52:17 -05001229 qmp_guest_fsfreeze_thaw(NULL);
Michael Rothe3d4d252011-07-19 15:41:55 -05001230 return 0;
1231}
1232
1233/*
1234 * Walk list of frozen file systems in the guest, and thaw them.
1235 */
Markus Armbruster77dbc812014-05-02 13:26:30 +02001236int64_t qmp_guest_fsfreeze_thaw(Error **errp)
Michael Rothe3d4d252011-07-19 15:41:55 -05001237{
1238 int ret;
Paolo Bonziniaf022032012-06-13 07:41:27 +02001239 FsMountList mounts;
1240 FsMount *mount;
Michael Roth9e8aded432012-04-16 19:52:17 -05001241 int fd, i = 0, logged;
Luiz Capitulino261551d2012-11-29 15:29:11 -02001242 Error *local_err = NULL;
Michael Rothe3d4d252011-07-19 15:41:55 -05001243
Michael Roth9e8aded432012-04-16 19:52:17 -05001244 QTAILQ_INIT(&mounts);
Luiz Capitulino261551d2012-11-29 15:29:11 -02001245 build_fs_mount_list(&mounts, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001246 if (local_err) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001247 error_propagate(errp, local_err);
Michael Roth9e8aded432012-04-16 19:52:17 -05001248 return 0;
1249 }
1250
1251 QTAILQ_FOREACH(mount, &mounts, next) {
1252 logged = false;
Michael Rothe3d4d252011-07-19 15:41:55 -05001253 fd = qemu_open(mount->dirname, O_RDONLY);
1254 if (fd == -1) {
Michael Rothe3d4d252011-07-19 15:41:55 -05001255 continue;
1256 }
Michael Roth9e8aded432012-04-16 19:52:17 -05001257 /* we have no way of knowing whether a filesystem was actually unfrozen
1258 * as a result of a successful call to FITHAW, only that if an error
1259 * was returned the filesystem was *not* unfrozen by that particular
1260 * call.
1261 *
Jim Meyeringa31f0532012-05-09 05:12:04 +00001262 * since multiple preceding FIFREEZEs require multiple calls to FITHAW
Michael Roth9e8aded432012-04-16 19:52:17 -05001263 * to unfreeze, continuing issuing FITHAW until an error is returned,
1264 * in which case either the filesystem is in an unfreezable state, or,
1265 * more likely, it was thawed previously (and remains so afterward).
1266 *
1267 * also, since the most recent successful call is the one that did
1268 * the actual unfreeze, we can use this to provide an accurate count
1269 * of the number of filesystems unfrozen by guest-fsfreeze-thaw, which
1270 * may * be useful for determining whether a filesystem was unfrozen
1271 * during the freeze/thaw phase by a process other than qemu-ga.
1272 */
1273 do {
1274 ret = ioctl(fd, FITHAW);
1275 if (ret == 0 && !logged) {
1276 i++;
1277 logged = true;
1278 }
1279 } while (ret == 0);
Michael Rothe3d4d252011-07-19 15:41:55 -05001280 close(fd);
Michael Rothe3d4d252011-07-19 15:41:55 -05001281 }
1282
Michael Rothf22d85e2012-04-17 19:01:45 -05001283 ga_unset_frozen(ga_state);
Paolo Bonziniaf022032012-06-13 07:41:27 +02001284 free_fs_mount_list(&mounts);
Tomoki Sekiyamaec0f6942012-12-12 12:55:55 +09001285
Markus Armbruster77dbc812014-05-02 13:26:30 +02001286 execute_fsfreeze_hook(FSFREEZE_HOOK_THAW, errp);
Tomoki Sekiyamaec0f6942012-12-12 12:55:55 +09001287
Michael Rothe3d4d252011-07-19 15:41:55 -05001288 return i;
1289}
1290
Michael Rothe3d4d252011-07-19 15:41:55 -05001291static void guest_fsfreeze_cleanup(void)
1292{
Michael Rothe3d4d252011-07-19 15:41:55 -05001293 Error *err = NULL;
1294
Michael Rothf22d85e2012-04-17 19:01:45 -05001295 if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) {
Markus Armbruster6f686742013-01-16 18:15:08 +01001296 qmp_guest_fsfreeze_thaw(&err);
1297 if (err) {
1298 slog("failed to clean up frozen filesystems: %s",
1299 error_get_pretty(err));
1300 error_free(err);
Michael Rothe3d4d252011-07-19 15:41:55 -05001301 }
1302 }
1303}
Michael Rothe72c3f22012-03-25 13:59:41 -05001304#endif /* CONFIG_FSFREEZE */
Michael Rothe3d4d252011-07-19 15:41:55 -05001305
Paolo Bonzinieab5fd52012-06-13 07:41:28 +02001306#if defined(CONFIG_FSTRIM)
1307/*
1308 * Walk list of mounted file systems in the guest, and trim them.
1309 */
Markus Armbruster77dbc812014-05-02 13:26:30 +02001310void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
Paolo Bonzinieab5fd52012-06-13 07:41:28 +02001311{
1312 int ret = 0;
1313 FsMountList mounts;
1314 struct FsMount *mount;
1315 int fd;
Luiz Capitulino261551d2012-11-29 15:29:11 -02001316 Error *local_err = NULL;
Paolo Bonzinieab5fd52012-06-13 07:41:28 +02001317 struct fstrim_range r = {
1318 .start = 0,
1319 .len = -1,
1320 .minlen = has_minimum ? minimum : 0,
1321 };
1322
1323 slog("guest-fstrim called");
1324
1325 QTAILQ_INIT(&mounts);
Luiz Capitulino261551d2012-11-29 15:29:11 -02001326 build_fs_mount_list(&mounts, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001327 if (local_err) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001328 error_propagate(errp, local_err);
Paolo Bonzinieab5fd52012-06-13 07:41:28 +02001329 return;
1330 }
1331
1332 QTAILQ_FOREACH(mount, &mounts, next) {
1333 fd = qemu_open(mount->dirname, O_RDONLY);
1334 if (fd == -1) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001335 error_setg_errno(errp, errno, "failed to open %s", mount->dirname);
Paolo Bonzinieab5fd52012-06-13 07:41:28 +02001336 goto error;
1337 }
1338
1339 /* We try to cull filesytems we know won't work in advance, but other
1340 * filesytems may not implement fstrim for less obvious reasons. These
1341 * will report EOPNOTSUPP; we simply ignore these errors. Any other
1342 * error means an unexpected error, so return it in those cases. In
1343 * some other cases ENOTTY will be reported (e.g. CD-ROMs).
1344 */
1345 ret = ioctl(fd, FITRIM, &r);
1346 if (ret == -1) {
1347 if (errno != ENOTTY && errno != EOPNOTSUPP) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001348 error_setg_errno(errp, errno, "failed to trim %s",
Luiz Capitulino071673b2012-11-27 11:02:01 -02001349 mount->dirname);
Paolo Bonzinieab5fd52012-06-13 07:41:28 +02001350 close(fd);
1351 goto error;
1352 }
1353 }
1354 close(fd);
1355 }
1356
1357error:
1358 free_fs_mount_list(&mounts);
1359}
1360#endif /* CONFIG_FSTRIM */
1361
1362
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001363#define LINUX_SYS_STATE_FILE "/sys/power/state"
1364#define SUSPEND_SUPPORTED 0
1365#define SUSPEND_NOT_SUPPORTED 1
1366
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001367static void bios_supports_mode(const char *pmutils_bin, const char *pmutils_arg,
Markus Armbruster77dbc812014-05-02 13:26:30 +02001368 const char *sysfile_str, Error **errp)
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001369{
Luiz Capitulino6b26e832012-11-27 11:02:03 -02001370 Error *local_err = NULL;
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001371 char *pmutils_path;
Luiz Capitulino6b26e832012-11-27 11:02:03 -02001372 pid_t pid;
Luiz Capitulinodc8764f02012-05-11 16:19:46 -03001373 int status;
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001374
1375 pmutils_path = g_find_program_in_path(pmutils_bin);
1376
1377 pid = fork();
1378 if (!pid) {
Luiz Capitulinodc8764f02012-05-11 16:19:46 -03001379 char buf[32]; /* hopefully big enough */
1380 ssize_t ret;
1381 int fd;
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001382
1383 setsid();
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001384 reopen_fd_to_null(0);
1385 reopen_fd_to_null(1);
1386 reopen_fd_to_null(2);
1387
Luiz Capitulinodc8764f02012-05-11 16:19:46 -03001388 if (pmutils_path) {
1389 execle(pmutils_path, pmutils_bin, pmutils_arg, NULL, environ);
1390 }
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001391
Luiz Capitulinodc8764f02012-05-11 16:19:46 -03001392 /*
1393 * If we get here either pm-utils is not installed or execle() has
1394 * failed. Let's try the manual method if the caller wants it.
1395 */
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001396
Luiz Capitulinodc8764f02012-05-11 16:19:46 -03001397 if (!sysfile_str) {
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001398 _exit(SUSPEND_NOT_SUPPORTED);
1399 }
1400
Luiz Capitulinodc8764f02012-05-11 16:19:46 -03001401 fd = open(LINUX_SYS_STATE_FILE, O_RDONLY);
1402 if (fd < 0) {
1403 _exit(SUSPEND_NOT_SUPPORTED);
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001404 }
1405
Luiz Capitulinodc8764f02012-05-11 16:19:46 -03001406 ret = read(fd, buf, sizeof(buf)-1);
1407 if (ret <= 0) {
1408 _exit(SUSPEND_NOT_SUPPORTED);
1409 }
1410 buf[ret] = '\0';
1411
1412 if (strstr(buf, sysfile_str)) {
1413 _exit(SUSPEND_SUPPORTED);
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001414 }
1415
Luiz Capitulinodc8764f02012-05-11 16:19:46 -03001416 _exit(SUSPEND_NOT_SUPPORTED);
Luiz Capitulino6b26e832012-11-27 11:02:03 -02001417 } else if (pid < 0) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001418 error_setg_errno(errp, errno, "failed to create child process");
Luiz Capitulino6b26e832012-11-27 11:02:03 -02001419 goto out;
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001420 }
1421
Luiz Capitulino6b26e832012-11-27 11:02:03 -02001422 ga_wait_child(pid, &status, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001423 if (local_err) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001424 error_propagate(errp, local_err);
Luiz Capitulino6b26e832012-11-27 11:02:03 -02001425 goto out;
1426 }
1427
1428 if (!WIFEXITED(status)) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001429 error_setg(errp, "child process has terminated abnormally");
Luiz Capitulino6b26e832012-11-27 11:02:03 -02001430 goto out;
1431 }
1432
1433 switch (WEXITSTATUS(status)) {
1434 case SUSPEND_SUPPORTED:
1435 goto out;
1436 case SUSPEND_NOT_SUPPORTED:
Markus Armbruster77dbc812014-05-02 13:26:30 +02001437 error_setg(errp,
Luiz Capitulino6b26e832012-11-27 11:02:03 -02001438 "the requested suspend mode is not supported by the guest");
1439 goto out;
1440 default:
Markus Armbruster77dbc812014-05-02 13:26:30 +02001441 error_setg(errp,
Luiz Capitulino6b26e832012-11-27 11:02:03 -02001442 "the helper program '%s' returned an unexpected exit status"
1443 " code (%d)", pmutils_path, WEXITSTATUS(status));
1444 goto out;
1445 }
1446
1447out:
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001448 g_free(pmutils_path);
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001449}
1450
1451static void guest_suspend(const char *pmutils_bin, const char *sysfile_str,
Markus Armbruster77dbc812014-05-02 13:26:30 +02001452 Error **errp)
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001453{
Luiz Capitulino7b376082012-11-27 11:02:04 -02001454 Error *local_err = NULL;
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001455 char *pmutils_path;
Luiz Capitulino7b376082012-11-27 11:02:04 -02001456 pid_t pid;
Luiz Capitulinodc8764f02012-05-11 16:19:46 -03001457 int status;
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001458
1459 pmutils_path = g_find_program_in_path(pmutils_bin);
1460
1461 pid = fork();
1462 if (pid == 0) {
1463 /* child */
1464 int fd;
1465
1466 setsid();
1467 reopen_fd_to_null(0);
1468 reopen_fd_to_null(1);
1469 reopen_fd_to_null(2);
1470
1471 if (pmutils_path) {
1472 execle(pmutils_path, pmutils_bin, NULL, environ);
1473 }
1474
1475 /*
1476 * If we get here either pm-utils is not installed or execle() has
1477 * failed. Let's try the manual method if the caller wants it.
1478 */
1479
1480 if (!sysfile_str) {
1481 _exit(EXIT_FAILURE);
1482 }
1483
1484 fd = open(LINUX_SYS_STATE_FILE, O_WRONLY);
1485 if (fd < 0) {
1486 _exit(EXIT_FAILURE);
1487 }
1488
1489 if (write(fd, sysfile_str, strlen(sysfile_str)) < 0) {
1490 _exit(EXIT_FAILURE);
1491 }
1492
1493 _exit(EXIT_SUCCESS);
Luiz Capitulino7b376082012-11-27 11:02:04 -02001494 } else if (pid < 0) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001495 error_setg_errno(errp, errno, "failed to create child process");
Luiz Capitulino7b376082012-11-27 11:02:04 -02001496 goto out;
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001497 }
1498
Luiz Capitulino7b376082012-11-27 11:02:04 -02001499 ga_wait_child(pid, &status, &local_err);
Markus Armbruster84d18f02014-01-30 15:07:28 +01001500 if (local_err) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001501 error_propagate(errp, local_err);
Luiz Capitulino7b376082012-11-27 11:02:04 -02001502 goto out;
1503 }
1504
1505 if (!WIFEXITED(status)) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001506 error_setg(errp, "child process has terminated abnormally");
Luiz Capitulino7b376082012-11-27 11:02:04 -02001507 goto out;
1508 }
1509
1510 if (WEXITSTATUS(status)) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001511 error_setg(errp, "child process has failed to suspend");
Luiz Capitulino7b376082012-11-27 11:02:04 -02001512 goto out;
1513 }
1514
1515out:
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001516 g_free(pmutils_path);
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001517}
1518
Markus Armbruster77dbc812014-05-02 13:26:30 +02001519void qmp_guest_suspend_disk(Error **errp)
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001520{
Markus Armbruster0f230bf2014-05-02 13:26:38 +02001521 Error *local_err = NULL;
1522
1523 bios_supports_mode("pm-is-supported", "--hibernate", "disk", &local_err);
1524 if (local_err) {
1525 error_propagate(errp, local_err);
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001526 return;
1527 }
1528
Markus Armbruster77dbc812014-05-02 13:26:30 +02001529 guest_suspend("pm-hibernate", "disk", errp);
Luiz Capitulino11d0f122012-02-28 11:03:03 -03001530}
1531
Markus Armbruster77dbc812014-05-02 13:26:30 +02001532void qmp_guest_suspend_ram(Error **errp)
Luiz Capitulinofbf42212012-02-28 11:03:04 -03001533{
Markus Armbruster0f230bf2014-05-02 13:26:38 +02001534 Error *local_err = NULL;
1535
1536 bios_supports_mode("pm-is-supported", "--suspend", "mem", &local_err);
1537 if (local_err) {
1538 error_propagate(errp, local_err);
Luiz Capitulinofbf42212012-02-28 11:03:04 -03001539 return;
1540 }
1541
Markus Armbruster77dbc812014-05-02 13:26:30 +02001542 guest_suspend("pm-suspend", "mem", errp);
Luiz Capitulinofbf42212012-02-28 11:03:04 -03001543}
1544
Markus Armbruster77dbc812014-05-02 13:26:30 +02001545void qmp_guest_suspend_hybrid(Error **errp)
Luiz Capitulino95f4f402012-02-28 11:03:05 -03001546{
Markus Armbruster0f230bf2014-05-02 13:26:38 +02001547 Error *local_err = NULL;
1548
1549 bios_supports_mode("pm-is-supported", "--suspend-hybrid", NULL,
1550 &local_err);
1551 if (local_err) {
1552 error_propagate(errp, local_err);
Luiz Capitulino95f4f402012-02-28 11:03:05 -03001553 return;
1554 }
1555
Markus Armbruster77dbc812014-05-02 13:26:30 +02001556 guest_suspend("pm-suspend-hybrid", NULL, errp);
Luiz Capitulino95f4f402012-02-28 11:03:05 -03001557}
1558
Michal Privoznik3424fc92012-02-29 17:02:23 +01001559static GuestNetworkInterfaceList *
1560guest_find_interface(GuestNetworkInterfaceList *head,
1561 const char *name)
1562{
1563 for (; head; head = head->next) {
1564 if (strcmp(head->value->name, name) == 0) {
1565 break;
1566 }
1567 }
1568
1569 return head;
1570}
1571
1572/*
1573 * Build information about guest interfaces
1574 */
1575GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
1576{
1577 GuestNetworkInterfaceList *head = NULL, *cur_item = NULL;
1578 struct ifaddrs *ifap, *ifa;
Michal Privoznik3424fc92012-02-29 17:02:23 +01001579
1580 if (getifaddrs(&ifap) < 0) {
Luiz Capitulino878a0ae2012-11-27 11:02:02 -02001581 error_setg_errno(errp, errno, "getifaddrs failed");
Michal Privoznik3424fc92012-02-29 17:02:23 +01001582 goto error;
1583 }
1584
1585 for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
1586 GuestNetworkInterfaceList *info;
1587 GuestIpAddressList **address_list = NULL, *address_item = NULL;
1588 char addr4[INET_ADDRSTRLEN];
1589 char addr6[INET6_ADDRSTRLEN];
1590 int sock;
1591 struct ifreq ifr;
1592 unsigned char *mac_addr;
1593 void *p;
1594
1595 g_debug("Processing %s interface", ifa->ifa_name);
1596
1597 info = guest_find_interface(head, ifa->ifa_name);
1598
1599 if (!info) {
1600 info = g_malloc0(sizeof(*info));
1601 info->value = g_malloc0(sizeof(*info->value));
1602 info->value->name = g_strdup(ifa->ifa_name);
1603
1604 if (!cur_item) {
1605 head = cur_item = info;
1606 } else {
1607 cur_item->next = info;
1608 cur_item = info;
1609 }
1610 }
1611
1612 if (!info->value->has_hardware_address &&
1613 ifa->ifa_flags & SIOCGIFHWADDR) {
1614 /* we haven't obtained HW address yet */
1615 sock = socket(PF_INET, SOCK_STREAM, 0);
1616 if (sock == -1) {
Luiz Capitulino878a0ae2012-11-27 11:02:02 -02001617 error_setg_errno(errp, errno, "failed to create socket");
Michal Privoznik3424fc92012-02-29 17:02:23 +01001618 goto error;
1619 }
1620
1621 memset(&ifr, 0, sizeof(ifr));
Jim Meyering1ab516e2012-10-04 13:09:58 +02001622 pstrcpy(ifr.ifr_name, IF_NAMESIZE, info->value->name);
Michal Privoznik3424fc92012-02-29 17:02:23 +01001623 if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) {
Luiz Capitulino878a0ae2012-11-27 11:02:02 -02001624 error_setg_errno(errp, errno,
1625 "failed to get MAC address of %s",
1626 ifa->ifa_name);
Markus Armbruster10a21582013-01-16 18:15:09 +01001627 close(sock);
Michal Privoznik3424fc92012-02-29 17:02:23 +01001628 goto error;
1629 }
1630
Markus Armbruster10a21582013-01-16 18:15:09 +01001631 close(sock);
Michal Privoznik3424fc92012-02-29 17:02:23 +01001632 mac_addr = (unsigned char *) &ifr.ifr_hwaddr.sa_data;
1633
Stefan Weile4ada482013-01-16 18:37:23 +01001634 info->value->hardware_address =
1635 g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x",
1636 (int) mac_addr[0], (int) mac_addr[1],
1637 (int) mac_addr[2], (int) mac_addr[3],
1638 (int) mac_addr[4], (int) mac_addr[5]);
Michal Privoznik3424fc92012-02-29 17:02:23 +01001639
1640 info->value->has_hardware_address = true;
Michal Privoznik3424fc92012-02-29 17:02:23 +01001641 }
1642
1643 if (ifa->ifa_addr &&
1644 ifa->ifa_addr->sa_family == AF_INET) {
1645 /* interface with IPv4 address */
Michal Privoznik3424fc92012-02-29 17:02:23 +01001646 p = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
1647 if (!inet_ntop(AF_INET, p, addr4, sizeof(addr4))) {
Luiz Capitulino878a0ae2012-11-27 11:02:02 -02001648 error_setg_errno(errp, errno, "inet_ntop failed");
Michal Privoznik3424fc92012-02-29 17:02:23 +01001649 goto error;
1650 }
1651
Markus Armbruster10a21582013-01-16 18:15:09 +01001652 address_item = g_malloc0(sizeof(*address_item));
1653 address_item->value = g_malloc0(sizeof(*address_item->value));
Michal Privoznik3424fc92012-02-29 17:02:23 +01001654 address_item->value->ip_address = g_strdup(addr4);
1655 address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4;
1656
1657 if (ifa->ifa_netmask) {
1658 /* Count the number of set bits in netmask.
1659 * This is safe as '1' and '0' cannot be shuffled in netmask. */
1660 p = &((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr;
1661 address_item->value->prefix = ctpop32(((uint32_t *) p)[0]);
1662 }
1663 } else if (ifa->ifa_addr &&
1664 ifa->ifa_addr->sa_family == AF_INET6) {
1665 /* interface with IPv6 address */
Michal Privoznik3424fc92012-02-29 17:02:23 +01001666 p = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr;
1667 if (!inet_ntop(AF_INET6, p, addr6, sizeof(addr6))) {
Luiz Capitulino878a0ae2012-11-27 11:02:02 -02001668 error_setg_errno(errp, errno, "inet_ntop failed");
Michal Privoznik3424fc92012-02-29 17:02:23 +01001669 goto error;
1670 }
1671
Markus Armbruster10a21582013-01-16 18:15:09 +01001672 address_item = g_malloc0(sizeof(*address_item));
1673 address_item->value = g_malloc0(sizeof(*address_item->value));
Michal Privoznik3424fc92012-02-29 17:02:23 +01001674 address_item->value->ip_address = g_strdup(addr6);
1675 address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6;
1676
1677 if (ifa->ifa_netmask) {
1678 /* Count the number of set bits in netmask.
1679 * This is safe as '1' and '0' cannot be shuffled in netmask. */
1680 p = &((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr;
1681 address_item->value->prefix =
1682 ctpop32(((uint32_t *) p)[0]) +
1683 ctpop32(((uint32_t *) p)[1]) +
1684 ctpop32(((uint32_t *) p)[2]) +
1685 ctpop32(((uint32_t *) p)[3]);
1686 }
1687 }
1688
1689 if (!address_item) {
1690 continue;
1691 }
1692
1693 address_list = &info->value->ip_addresses;
1694
1695 while (*address_list && (*address_list)->next) {
1696 address_list = &(*address_list)->next;
1697 }
1698
1699 if (!*address_list) {
1700 *address_list = address_item;
1701 } else {
1702 (*address_list)->next = address_item;
1703 }
1704
1705 info->value->has_ip_addresses = true;
1706
1707
1708 }
1709
1710 freeifaddrs(ifap);
1711 return head;
1712
1713error:
1714 freeifaddrs(ifap);
1715 qapi_free_GuestNetworkInterfaceList(head);
1716 return NULL;
1717}
1718
Markus Armbruster77dbc812014-05-02 13:26:30 +02001719#define SYSCONF_EXACT(name, errp) sysconf_exact((name), #name, (errp))
Laszlo Ersekd2baff62013-03-06 22:59:30 +01001720
Markus Armbruster77dbc812014-05-02 13:26:30 +02001721static long sysconf_exact(int name, const char *name_str, Error **errp)
Laszlo Ersekd2baff62013-03-06 22:59:30 +01001722{
1723 long ret;
1724
1725 errno = 0;
1726 ret = sysconf(name);
1727 if (ret == -1) {
1728 if (errno == 0) {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001729 error_setg(errp, "sysconf(%s): value indefinite", name_str);
Laszlo Ersekd2baff62013-03-06 22:59:30 +01001730 } else {
Markus Armbruster77dbc812014-05-02 13:26:30 +02001731 error_setg_errno(errp, errno, "sysconf(%s)", name_str);
Laszlo Ersekd2baff62013-03-06 22:59:30 +01001732 }
1733 }
1734 return ret;
1735}
1736
1737/* Transfer online/offline status between @vcpu and the guest system.
1738 *
1739 * On input either @errp or *@errp must be NULL.
1740 *
1741 * In system-to-@vcpu direction, the following @vcpu fields are accessed:
1742 * - R: vcpu->logical_id
1743 * - W: vcpu->online
1744 * - W: vcpu->can_offline
1745 *
1746 * In @vcpu-to-system direction, the following @vcpu fields are accessed:
1747 * - R: vcpu->logical_id
1748 * - R: vcpu->online
1749 *
1750 * Written members remain unmodified on error.
1751 */
1752static void transfer_vcpu(GuestLogicalProcessor *vcpu, bool sys2vcpu,
1753 Error **errp)
1754{
1755 char *dirpath;
1756 int dirfd;
1757
1758 dirpath = g_strdup_printf("/sys/devices/system/cpu/cpu%" PRId64 "/",
1759 vcpu->logical_id);
1760 dirfd = open(dirpath, O_RDONLY | O_DIRECTORY);
1761 if (dirfd == -1) {
1762 error_setg_errno(errp, errno, "open(\"%s\")", dirpath);
1763 } else {
1764 static const char fn[] = "online";
1765 int fd;
1766 int res;
1767
1768 fd = openat(dirfd, fn, sys2vcpu ? O_RDONLY : O_RDWR);
1769 if (fd == -1) {
1770 if (errno != ENOENT) {
1771 error_setg_errno(errp, errno, "open(\"%s/%s\")", dirpath, fn);
1772 } else if (sys2vcpu) {
1773 vcpu->online = true;
1774 vcpu->can_offline = false;
1775 } else if (!vcpu->online) {
1776 error_setg(errp, "logical processor #%" PRId64 " can't be "
1777 "offlined", vcpu->logical_id);
1778 } /* otherwise pretend successful re-onlining */
1779 } else {
1780 unsigned char status;
1781
1782 res = pread(fd, &status, 1, 0);
1783 if (res == -1) {
1784 error_setg_errno(errp, errno, "pread(\"%s/%s\")", dirpath, fn);
1785 } else if (res == 0) {
1786 error_setg(errp, "pread(\"%s/%s\"): unexpected EOF", dirpath,
1787 fn);
1788 } else if (sys2vcpu) {
1789 vcpu->online = (status != '0');
1790 vcpu->can_offline = true;
1791 } else if (vcpu->online != (status != '0')) {
1792 status = '0' + vcpu->online;
1793 if (pwrite(fd, &status, 1, 0) == -1) {
1794 error_setg_errno(errp, errno, "pwrite(\"%s/%s\")", dirpath,
1795 fn);
1796 }
1797 } /* otherwise pretend successful re-(on|off)-lining */
1798
1799 res = close(fd);
1800 g_assert(res == 0);
1801 }
1802
1803 res = close(dirfd);
1804 g_assert(res == 0);
1805 }
1806
1807 g_free(dirpath);
1808}
1809
1810GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp)
1811{
1812 int64_t current;
1813 GuestLogicalProcessorList *head, **link;
1814 long sc_max;
1815 Error *local_err = NULL;
1816
1817 current = 0;
1818 head = NULL;
1819 link = &head;
1820 sc_max = SYSCONF_EXACT(_SC_NPROCESSORS_CONF, &local_err);
1821
1822 while (local_err == NULL && current < sc_max) {
1823 GuestLogicalProcessor *vcpu;
1824 GuestLogicalProcessorList *entry;
1825
1826 vcpu = g_malloc0(sizeof *vcpu);
1827 vcpu->logical_id = current++;
1828 vcpu->has_can_offline = true; /* lolspeak ftw */
1829 transfer_vcpu(vcpu, true, &local_err);
1830
1831 entry = g_malloc0(sizeof *entry);
1832 entry->value = vcpu;
1833
1834 *link = entry;
1835 link = &entry->next;
1836 }
1837
1838 if (local_err == NULL) {
1839 /* there's no guest with zero VCPUs */
1840 g_assert(head != NULL);
1841 return head;
1842 }
1843
1844 qapi_free_GuestLogicalProcessorList(head);
1845 error_propagate(errp, local_err);
1846 return NULL;
1847}
1848
Laszlo Ersekcbb65fc2013-03-06 22:59:31 +01001849int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp)
1850{
1851 int64_t processed;
1852 Error *local_err = NULL;
1853
1854 processed = 0;
1855 while (vcpus != NULL) {
1856 transfer_vcpu(vcpus->value, false, &local_err);
1857 if (local_err != NULL) {
1858 break;
1859 }
1860 ++processed;
1861 vcpus = vcpus->next;
1862 }
1863
1864 if (local_err != NULL) {
1865 if (processed == 0) {
1866 error_propagate(errp, local_err);
1867 } else {
1868 error_free(local_err);
1869 }
1870 }
1871
1872 return processed;
1873}
1874
Michael Rothe72c3f22012-03-25 13:59:41 -05001875#else /* defined(__linux__) */
1876
Markus Armbruster77dbc812014-05-02 13:26:30 +02001877void qmp_guest_suspend_disk(Error **errp)
Michael Rothe72c3f22012-03-25 13:59:41 -05001878{
Markus Armbruster77dbc812014-05-02 13:26:30 +02001879 error_set(errp, QERR_UNSUPPORTED);
Michael Rothe72c3f22012-03-25 13:59:41 -05001880}
1881
Markus Armbruster77dbc812014-05-02 13:26:30 +02001882void qmp_guest_suspend_ram(Error **errp)
Michael Rothe72c3f22012-03-25 13:59:41 -05001883{
Markus Armbruster77dbc812014-05-02 13:26:30 +02001884 error_set(errp, QERR_UNSUPPORTED);
Michael Rothe72c3f22012-03-25 13:59:41 -05001885}
1886
Markus Armbruster77dbc812014-05-02 13:26:30 +02001887void qmp_guest_suspend_hybrid(Error **errp)
Michael Rothe72c3f22012-03-25 13:59:41 -05001888{
Markus Armbruster77dbc812014-05-02 13:26:30 +02001889 error_set(errp, QERR_UNSUPPORTED);
Michael Rothe72c3f22012-03-25 13:59:41 -05001890}
1891
1892GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
1893{
1894 error_set(errp, QERR_UNSUPPORTED);
1895 return NULL;
1896}
1897
Laszlo Ersekd2baff62013-03-06 22:59:30 +01001898GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp)
1899{
1900 error_set(errp, QERR_UNSUPPORTED);
1901 return NULL;
1902}
1903
Laszlo Ersekcbb65fc2013-03-06 22:59:31 +01001904int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp)
1905{
1906 error_set(errp, QERR_UNSUPPORTED);
1907 return -1;
1908}
1909
Michael Rothe72c3f22012-03-25 13:59:41 -05001910#endif
1911
Michael Rothd35d4cb2012-04-13 21:07:36 -05001912#if !defined(CONFIG_FSFREEZE)
1913
Tomoki Sekiyama46d4c572014-06-30 17:51:34 -04001914GuestFilesystemInfoList *qmp_guest_get_fsinfo(Error **errp)
1915{
1916 error_set(errp, QERR_UNSUPPORTED);
1917 return NULL;
1918}
1919
Markus Armbruster77dbc812014-05-02 13:26:30 +02001920GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp)
Michael Rothd35d4cb2012-04-13 21:07:36 -05001921{
Markus Armbruster77dbc812014-05-02 13:26:30 +02001922 error_set(errp, QERR_UNSUPPORTED);
Michael Rothd35d4cb2012-04-13 21:07:36 -05001923
1924 return 0;
1925}
1926
Markus Armbruster77dbc812014-05-02 13:26:30 +02001927int64_t qmp_guest_fsfreeze_freeze(Error **errp)
Michael Rothd35d4cb2012-04-13 21:07:36 -05001928{
Markus Armbruster77dbc812014-05-02 13:26:30 +02001929 error_set(errp, QERR_UNSUPPORTED);
Michael Rothd35d4cb2012-04-13 21:07:36 -05001930
1931 return 0;
1932}
1933
Tomoki Sekiyamae99bce22014-06-30 17:51:27 -04001934int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,
1935 strList *mountpoints,
1936 Error **errp)
1937{
1938 error_set(errp, QERR_UNSUPPORTED);
1939
1940 return 0;
1941}
1942
Markus Armbruster77dbc812014-05-02 13:26:30 +02001943int64_t qmp_guest_fsfreeze_thaw(Error **errp)
Michael Rothd35d4cb2012-04-13 21:07:36 -05001944{
Markus Armbruster77dbc812014-05-02 13:26:30 +02001945 error_set(errp, QERR_UNSUPPORTED);
Michael Rothd35d4cb2012-04-13 21:07:36 -05001946
1947 return 0;
1948}
Paolo Bonzinieab5fd52012-06-13 07:41:28 +02001949#endif /* CONFIG_FSFREEZE */
Michael Rothd35d4cb2012-04-13 21:07:36 -05001950
Paolo Bonzinieab5fd52012-06-13 07:41:28 +02001951#if !defined(CONFIG_FSTRIM)
Markus Armbruster77dbc812014-05-02 13:26:30 +02001952void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
Paolo Bonzinieab5fd52012-06-13 07:41:28 +02001953{
Markus Armbruster77dbc812014-05-02 13:26:30 +02001954 error_set(errp, QERR_UNSUPPORTED);
Paolo Bonzinieab5fd52012-06-13 07:41:28 +02001955}
Michael Rothd35d4cb2012-04-13 21:07:36 -05001956#endif
1957
Tomoki Sekiyama1281c082014-06-30 17:51:40 -04001958/* add unsupported commands to the blacklist */
1959GList *ga_command_blacklist_init(GList *blacklist)
1960{
1961#if !defined(__linux__)
1962 {
1963 const char *list[] = {
1964 "guest-suspend-disk", "guest-suspend-ram",
1965 "guest-suspend-hybrid", "guest-network-get-interfaces",
1966 "guest-get-vcpus", "guest-set-vcpus", NULL};
1967 char **p = (char **)list;
1968
1969 while (*p) {
1970 blacklist = g_list_append(blacklist, *p++);
1971 }
1972 }
1973#endif
1974
1975#if !defined(CONFIG_FSFREEZE)
1976 {
1977 const char *list[] = {
1978 "guest-get-fsinfo", "guest-fsfreeze-status",
1979 "guest-fsfreeze-freeze", "guest-fsfreeze-freeze-list",
1980 "guest-fsfreeze-thaw", "guest-get-fsinfo", NULL};
1981 char **p = (char **)list;
1982
1983 while (*p) {
1984 blacklist = g_list_append(blacklist, *p++);
1985 }
1986 }
1987#endif
1988
1989#if !defined(CONFIG_FSTRIM)
1990 blacklist = g_list_append(blacklist, (char *)"guest-fstrim");
1991#endif
1992
1993 return blacklist;
1994}
1995
Michael Rothe3d4d252011-07-19 15:41:55 -05001996/* register init/cleanup routines for stateful command groups */
1997void ga_command_state_init(GAState *s, GACommandState *cs)
1998{
Anthony Liguori7006b9c2011-07-22 14:14:17 -05001999#if defined(CONFIG_FSFREEZE)
Michael Rothf22d85e2012-04-17 19:01:45 -05002000 ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup);
Anthony Liguori7006b9c2011-07-22 14:14:17 -05002001#endif
Michael Rothe3d4d252011-07-19 15:41:55 -05002002 ga_command_state_add(cs, guest_file_init, NULL);
2003}