linux-user: stack_base is now mandatory on all targets
[qemu.git] / qga / guest-agent-commands.c
1 /*
2 * QEMU Guest Agent commands
3 *
4 * Copyright IBM Corp. 2011
5 *
6 * Authors:
7 * Michael Roth <mdroth@linux.vnet.ibm.com>
8 *
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
11 */
12
13 #include <glib.h>
14
15 #if defined(__linux__)
16 #include <mntent.h>
17 #include <linux/fs.h>
18
19 #if defined(__linux__) && defined(FIFREEZE)
20 #define CONFIG_FSFREEZE
21 #endif
22 #endif
23
24 #include <sys/types.h>
25 #include <sys/ioctl.h>
26 #include "qga/guest-agent-core.h"
27 #include "qga-qmp-commands.h"
28 #include "qerror.h"
29 #include "qemu-queue.h"
30
31 static GAState *ga_state;
32
33 /* Note: in some situations, like with the fsfreeze, logging may be
34 * temporarilly disabled. if it is necessary that a command be able
35 * to log for accounting purposes, check ga_logging_enabled() beforehand,
36 * and use the QERR_QGA_LOGGING_DISABLED to generate an error
37 */
38 static void slog(const char *fmt, ...)
39 {
40 va_list ap;
41
42 va_start(ap, fmt);
43 g_logv("syslog", G_LOG_LEVEL_INFO, fmt, ap);
44 va_end(ap);
45 }
46
47 int64_t qmp_guest_sync(int64_t id, Error **errp)
48 {
49 return id;
50 }
51
52 void qmp_guest_ping(Error **err)
53 {
54 slog("guest-ping called");
55 }
56
57 struct GuestAgentInfo *qmp_guest_info(Error **err)
58 {
59 GuestAgentInfo *info = g_malloc0(sizeof(GuestAgentInfo));
60 GuestAgentCommandInfo *cmd_info;
61 GuestAgentCommandInfoList *cmd_info_list;
62 char **cmd_list_head, **cmd_list;
63
64 info->version = g_strdup(QGA_VERSION);
65
66 cmd_list_head = cmd_list = qmp_get_command_list();
67 if (*cmd_list_head == NULL) {
68 goto out;
69 }
70
71 while (*cmd_list) {
72 cmd_info = g_malloc0(sizeof(GuestAgentCommandInfo));
73 cmd_info->name = strdup(*cmd_list);
74 cmd_info->enabled = qmp_command_is_enabled(cmd_info->name);
75
76 cmd_info_list = g_malloc0(sizeof(GuestAgentCommandInfoList));
77 cmd_info_list->value = cmd_info;
78 cmd_info_list->next = info->supported_commands;
79 info->supported_commands = cmd_info_list;
80
81 g_free(*cmd_list);
82 cmd_list++;
83 }
84
85 out:
86 g_free(cmd_list_head);
87 return info;
88 }
89
90 void qmp_guest_shutdown(bool has_mode, const char *mode, Error **err)
91 {
92 int ret;
93 const char *shutdown_flag;
94
95 slog("guest-shutdown called, mode: %s", mode);
96 if (!has_mode || strcmp(mode, "powerdown") == 0) {
97 shutdown_flag = "-P";
98 } else if (strcmp(mode, "halt") == 0) {
99 shutdown_flag = "-H";
100 } else if (strcmp(mode, "reboot") == 0) {
101 shutdown_flag = "-r";
102 } else {
103 error_set(err, QERR_INVALID_PARAMETER_VALUE, "mode",
104 "halt|powerdown|reboot");
105 return;
106 }
107
108 ret = fork();
109 if (ret == 0) {
110 /* child, start the shutdown */
111 setsid();
112 fclose(stdin);
113 fclose(stdout);
114 fclose(stderr);
115
116 ret = execl("/sbin/shutdown", "shutdown", shutdown_flag, "+0",
117 "hypervisor initiated shutdown", (char*)NULL);
118 if (ret) {
119 slog("guest-shutdown failed: %s", strerror(errno));
120 }
121 exit(!!ret);
122 } else if (ret < 0) {
123 error_set(err, QERR_UNDEFINED_ERROR);
124 }
125 }
126
127 typedef struct GuestFileHandle {
128 uint64_t id;
129 FILE *fh;
130 QTAILQ_ENTRY(GuestFileHandle) next;
131 } GuestFileHandle;
132
133 static struct {
134 QTAILQ_HEAD(, GuestFileHandle) filehandles;
135 } guest_file_state;
136
137 static void guest_file_handle_add(FILE *fh)
138 {
139 GuestFileHandle *gfh;
140
141 gfh = g_malloc0(sizeof(GuestFileHandle));
142 gfh->id = fileno(fh);
143 gfh->fh = fh;
144 QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
145 }
146
147 static GuestFileHandle *guest_file_handle_find(int64_t id)
148 {
149 GuestFileHandle *gfh;
150
151 QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next)
152 {
153 if (gfh->id == id) {
154 return gfh;
155 }
156 }
157
158 return NULL;
159 }
160
161 int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, Error **err)
162 {
163 FILE *fh;
164 int fd;
165 int64_t ret = -1;
166
167 if (!has_mode) {
168 mode = "r";
169 }
170 slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
171 fh = fopen(path, mode);
172 if (!fh) {
173 error_set(err, QERR_OPEN_FILE_FAILED, path);
174 return -1;
175 }
176
177 /* set fd non-blocking to avoid common use cases (like reading from a
178 * named pipe) from hanging the agent
179 */
180 fd = fileno(fh);
181 ret = fcntl(fd, F_GETFL);
182 ret = fcntl(fd, F_SETFL, ret | O_NONBLOCK);
183 if (ret == -1) {
184 error_set(err, QERR_QGA_COMMAND_FAILED, "fcntl() failed");
185 fclose(fh);
186 return -1;
187 }
188
189 guest_file_handle_add(fh);
190 slog("guest-file-open, handle: %d", fd);
191 return fd;
192 }
193
194 void qmp_guest_file_close(int64_t handle, Error **err)
195 {
196 GuestFileHandle *gfh = guest_file_handle_find(handle);
197 int ret;
198
199 slog("guest-file-close called, handle: %ld", handle);
200 if (!gfh) {
201 error_set(err, QERR_FD_NOT_FOUND, "handle");
202 return;
203 }
204
205 ret = fclose(gfh->fh);
206 if (ret == -1) {
207 error_set(err, QERR_QGA_COMMAND_FAILED, "fclose() failed");
208 return;
209 }
210
211 QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
212 g_free(gfh);
213 }
214
215 struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
216 int64_t count, Error **err)
217 {
218 GuestFileHandle *gfh = guest_file_handle_find(handle);
219 GuestFileRead *read_data = NULL;
220 guchar *buf;
221 FILE *fh;
222 size_t read_count;
223
224 if (!gfh) {
225 error_set(err, QERR_FD_NOT_FOUND, "handle");
226 return NULL;
227 }
228
229 if (!has_count) {
230 count = QGA_READ_COUNT_DEFAULT;
231 } else if (count < 0) {
232 error_set(err, QERR_INVALID_PARAMETER, "count");
233 return NULL;
234 }
235
236 fh = gfh->fh;
237 buf = g_malloc0(count+1);
238 read_count = fread(buf, 1, count, fh);
239 if (ferror(fh)) {
240 slog("guest-file-read failed, handle: %ld", handle);
241 error_set(err, QERR_QGA_COMMAND_FAILED, "fread() failed");
242 } else {
243 buf[read_count] = 0;
244 read_data = g_malloc0(sizeof(GuestFileRead));
245 read_data->count = read_count;
246 read_data->eof = feof(fh);
247 if (read_count) {
248 read_data->buf_b64 = g_base64_encode(buf, read_count);
249 }
250 }
251 g_free(buf);
252 clearerr(fh);
253
254 return read_data;
255 }
256
257 GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
258 bool has_count, int64_t count, Error **err)
259 {
260 GuestFileWrite *write_data = NULL;
261 guchar *buf;
262 gsize buf_len;
263 int write_count;
264 GuestFileHandle *gfh = guest_file_handle_find(handle);
265 FILE *fh;
266
267 if (!gfh) {
268 error_set(err, QERR_FD_NOT_FOUND, "handle");
269 return NULL;
270 }
271
272 fh = gfh->fh;
273 buf = g_base64_decode(buf_b64, &buf_len);
274
275 if (!has_count) {
276 count = buf_len;
277 } else if (count < 0 || count > buf_len) {
278 g_free(buf);
279 error_set(err, QERR_INVALID_PARAMETER, "count");
280 return NULL;
281 }
282
283 write_count = fwrite(buf, 1, count, fh);
284 if (ferror(fh)) {
285 slog("guest-file-write failed, handle: %ld", handle);
286 error_set(err, QERR_QGA_COMMAND_FAILED, "fwrite() error");
287 } else {
288 write_data = g_malloc0(sizeof(GuestFileWrite));
289 write_data->count = write_count;
290 write_data->eof = feof(fh);
291 }
292 g_free(buf);
293 clearerr(fh);
294
295 return write_data;
296 }
297
298 struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
299 int64_t whence, Error **err)
300 {
301 GuestFileHandle *gfh = guest_file_handle_find(handle);
302 GuestFileSeek *seek_data = NULL;
303 FILE *fh;
304 int ret;
305
306 if (!gfh) {
307 error_set(err, QERR_FD_NOT_FOUND, "handle");
308 return NULL;
309 }
310
311 fh = gfh->fh;
312 ret = fseek(fh, offset, whence);
313 if (ret == -1) {
314 error_set(err, QERR_QGA_COMMAND_FAILED, strerror(errno));
315 } else {
316 seek_data = g_malloc0(sizeof(GuestFileRead));
317 seek_data->position = ftell(fh);
318 seek_data->eof = feof(fh);
319 }
320 clearerr(fh);
321
322 return seek_data;
323 }
324
325 void qmp_guest_file_flush(int64_t handle, Error **err)
326 {
327 GuestFileHandle *gfh = guest_file_handle_find(handle);
328 FILE *fh;
329 int ret;
330
331 if (!gfh) {
332 error_set(err, QERR_FD_NOT_FOUND, "handle");
333 return;
334 }
335
336 fh = gfh->fh;
337 ret = fflush(fh);
338 if (ret == EOF) {
339 error_set(err, QERR_QGA_COMMAND_FAILED, strerror(errno));
340 }
341 }
342
343 static void guest_file_init(void)
344 {
345 QTAILQ_INIT(&guest_file_state.filehandles);
346 }
347
348 #if defined(CONFIG_FSFREEZE)
349 static void disable_logging(void)
350 {
351 ga_disable_logging(ga_state);
352 }
353
354 static void enable_logging(void)
355 {
356 ga_enable_logging(ga_state);
357 }
358
359 typedef struct GuestFsfreezeMount {
360 char *dirname;
361 char *devtype;
362 QTAILQ_ENTRY(GuestFsfreezeMount) next;
363 } GuestFsfreezeMount;
364
365 struct {
366 GuestFsfreezeStatus status;
367 QTAILQ_HEAD(, GuestFsfreezeMount) mount_list;
368 } guest_fsfreeze_state;
369
370 /*
371 * Walk the mount table and build a list of local file systems
372 */
373 static int guest_fsfreeze_build_mount_list(void)
374 {
375 struct mntent *ment;
376 GuestFsfreezeMount *mount, *temp;
377 char const *mtab = MOUNTED;
378 FILE *fp;
379
380 QTAILQ_FOREACH_SAFE(mount, &guest_fsfreeze_state.mount_list, next, temp) {
381 QTAILQ_REMOVE(&guest_fsfreeze_state.mount_list, mount, next);
382 g_free(mount->dirname);
383 g_free(mount->devtype);
384 g_free(mount);
385 }
386
387 fp = setmntent(mtab, "r");
388 if (!fp) {
389 g_warning("fsfreeze: unable to read mtab");
390 return -1;
391 }
392
393 while ((ment = getmntent(fp))) {
394 /*
395 * An entry which device name doesn't start with a '/' is
396 * either a dummy file system or a network file system.
397 * Add special handling for smbfs and cifs as is done by
398 * coreutils as well.
399 */
400 if ((ment->mnt_fsname[0] != '/') ||
401 (strcmp(ment->mnt_type, "smbfs") == 0) ||
402 (strcmp(ment->mnt_type, "cifs") == 0)) {
403 continue;
404 }
405
406 mount = g_malloc0(sizeof(GuestFsfreezeMount));
407 mount->dirname = g_strdup(ment->mnt_dir);
408 mount->devtype = g_strdup(ment->mnt_type);
409
410 QTAILQ_INSERT_TAIL(&guest_fsfreeze_state.mount_list, mount, next);
411 }
412
413 endmntent(fp);
414
415 return 0;
416 }
417
418 /*
419 * Return status of freeze/thaw
420 */
421 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err)
422 {
423 return guest_fsfreeze_state.status;
424 }
425
426 /*
427 * Walk list of mounted file systems in the guest, and freeze the ones which
428 * are real local file systems.
429 */
430 int64_t qmp_guest_fsfreeze_freeze(Error **err)
431 {
432 int ret = 0, i = 0;
433 struct GuestFsfreezeMount *mount, *temp;
434 int fd;
435 char err_msg[512];
436
437 slog("guest-fsfreeze called");
438
439 if (guest_fsfreeze_state.status == GUEST_FSFREEZE_STATUS_FROZEN) {
440 return 0;
441 }
442
443 ret = guest_fsfreeze_build_mount_list();
444 if (ret < 0) {
445 return ret;
446 }
447
448 /* cannot risk guest agent blocking itself on a write in this state */
449 disable_logging();
450
451 QTAILQ_FOREACH_SAFE(mount, &guest_fsfreeze_state.mount_list, next, temp) {
452 fd = qemu_open(mount->dirname, O_RDONLY);
453 if (fd == -1) {
454 sprintf(err_msg, "failed to open %s, %s", mount->dirname, strerror(errno));
455 error_set(err, QERR_QGA_COMMAND_FAILED, err_msg);
456 goto error;
457 }
458
459 /* we try to cull filesytems we know won't work in advance, but other
460 * filesytems may not implement fsfreeze for less obvious reasons.
461 * these will report EOPNOTSUPP, so we simply ignore them. when
462 * thawing, these filesystems will return an EINVAL instead, due to
463 * not being in a frozen state. Other filesystem-specific
464 * errors may result in EINVAL, however, so the user should check the
465 * number * of filesystems returned here against those returned by the
466 * thaw operation to determine whether everything completed
467 * successfully
468 */
469 ret = ioctl(fd, FIFREEZE);
470 if (ret < 0 && errno != EOPNOTSUPP) {
471 sprintf(err_msg, "failed to freeze %s, %s", mount->dirname, strerror(errno));
472 error_set(err, QERR_QGA_COMMAND_FAILED, err_msg);
473 close(fd);
474 goto error;
475 }
476 close(fd);
477
478 i++;
479 }
480
481 guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_FROZEN;
482 return i;
483
484 error:
485 if (i > 0) {
486 qmp_guest_fsfreeze_thaw(NULL);
487 }
488 return 0;
489 }
490
491 /*
492 * Walk list of frozen file systems in the guest, and thaw them.
493 */
494 int64_t qmp_guest_fsfreeze_thaw(Error **err)
495 {
496 int ret;
497 GuestFsfreezeMount *mount, *temp;
498 int fd, i = 0;
499 bool has_error = false;
500
501 QTAILQ_FOREACH_SAFE(mount, &guest_fsfreeze_state.mount_list, next, temp) {
502 fd = qemu_open(mount->dirname, O_RDONLY);
503 if (fd == -1) {
504 has_error = true;
505 continue;
506 }
507 ret = ioctl(fd, FITHAW);
508 if (ret < 0 && errno != EOPNOTSUPP && errno != EINVAL) {
509 has_error = true;
510 close(fd);
511 continue;
512 }
513 close(fd);
514 i++;
515 }
516
517 if (has_error) {
518 guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_ERROR;
519 } else {
520 guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_THAWED;
521 }
522 enable_logging();
523 return i;
524 }
525
526 static void guest_fsfreeze_init(void)
527 {
528 guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_THAWED;
529 QTAILQ_INIT(&guest_fsfreeze_state.mount_list);
530 }
531
532 static void guest_fsfreeze_cleanup(void)
533 {
534 int64_t ret;
535 Error *err = NULL;
536
537 if (guest_fsfreeze_state.status == GUEST_FSFREEZE_STATUS_FROZEN) {
538 ret = qmp_guest_fsfreeze_thaw(&err);
539 if (ret < 0 || err) {
540 slog("failed to clean up frozen filesystems");
541 }
542 }
543 }
544 #else
545 /*
546 * Return status of freeze/thaw
547 */
548 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err)
549 {
550 error_set(err, QERR_UNSUPPORTED);
551
552 return 0;
553 }
554
555 /*
556 * Walk list of mounted file systems in the guest, and freeze the ones which
557 * are real local file systems.
558 */
559 int64_t qmp_guest_fsfreeze_freeze(Error **err)
560 {
561 error_set(err, QERR_UNSUPPORTED);
562
563 return 0;
564 }
565
566 /*
567 * Walk list of frozen file systems in the guest, and thaw them.
568 */
569 int64_t qmp_guest_fsfreeze_thaw(Error **err)
570 {
571 error_set(err, QERR_UNSUPPORTED);
572
573 return 0;
574 }
575 #endif
576
577 /* register init/cleanup routines for stateful command groups */
578 void ga_command_state_init(GAState *s, GACommandState *cs)
579 {
580 ga_state = s;
581 #if defined(CONFIG_FSFREEZE)
582 ga_command_state_add(cs, guest_fsfreeze_init, guest_fsfreeze_cleanup);
583 #endif
584 ga_command_state_add(cs, guest_file_init, NULL);
585 }