vmsvga: fix vmsvga_update_display
[qemu.git] / qga / commands-posix.c
1 /*
2 * QEMU Guest Agent POSIX-specific command implementations
3 *
4 * Copyright IBM Corp. 2011
5 *
6 * Authors:
7 * Michael Roth <mdroth@linux.vnet.ibm.com>
8 * Michal Privoznik <mprivozn@redhat.com>
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 "qemu/osdep.h"
15 #include <sys/ioctl.h>
16 #include <sys/wait.h>
17 #include <dirent.h>
18 #include "qga/guest-agent-core.h"
19 #include "qga-qmp-commands.h"
20 #include "qapi/qmp/qerror.h"
21 #include "qemu/queue.h"
22 #include "qemu/host-utils.h"
23 #include "qemu/sockets.h"
24 #include "qemu/base64.h"
25 #include "qemu/cutils.h"
26
27 #ifndef CONFIG_HAS_ENVIRON
28 #ifdef __APPLE__
29 #include <crt_externs.h>
30 #define environ (*_NSGetEnviron())
31 #else
32 extern char **environ;
33 #endif
34 #endif
35
36 #if defined(__linux__)
37 #include <mntent.h>
38 #include <linux/fs.h>
39 #include <ifaddrs.h>
40 #include <arpa/inet.h>
41 #include <sys/socket.h>
42 #include <net/if.h>
43
44 #ifdef FIFREEZE
45 #define CONFIG_FSFREEZE
46 #endif
47 #ifdef FITRIM
48 #define CONFIG_FSTRIM
49 #endif
50 #endif
51
52 static void ga_wait_child(pid_t pid, int *status, Error **errp)
53 {
54 pid_t rpid;
55
56 *status = 0;
57
58 do {
59 rpid = waitpid(pid, status, 0);
60 } while (rpid == -1 && errno == EINTR);
61
62 if (rpid == -1) {
63 error_setg_errno(errp, errno, "failed to wait for child (pid: %d)",
64 pid);
65 return;
66 }
67
68 g_assert(rpid == pid);
69 }
70
71 void qmp_guest_shutdown(bool has_mode, const char *mode, Error **errp)
72 {
73 const char *shutdown_flag;
74 Error *local_err = NULL;
75 pid_t pid;
76 int status;
77
78 slog("guest-shutdown called, mode: %s", mode);
79 if (!has_mode || strcmp(mode, "powerdown") == 0) {
80 shutdown_flag = "-P";
81 } else if (strcmp(mode, "halt") == 0) {
82 shutdown_flag = "-H";
83 } else if (strcmp(mode, "reboot") == 0) {
84 shutdown_flag = "-r";
85 } else {
86 error_setg(errp,
87 "mode is invalid (valid values are: halt|powerdown|reboot");
88 return;
89 }
90
91 pid = fork();
92 if (pid == 0) {
93 /* child, start the shutdown */
94 setsid();
95 reopen_fd_to_null(0);
96 reopen_fd_to_null(1);
97 reopen_fd_to_null(2);
98
99 execle("/sbin/shutdown", "shutdown", "-h", shutdown_flag, "+0",
100 "hypervisor initiated shutdown", (char*)NULL, environ);
101 _exit(EXIT_FAILURE);
102 } else if (pid < 0) {
103 error_setg_errno(errp, errno, "failed to create child process");
104 return;
105 }
106
107 ga_wait_child(pid, &status, &local_err);
108 if (local_err) {
109 error_propagate(errp, local_err);
110 return;
111 }
112
113 if (!WIFEXITED(status)) {
114 error_setg(errp, "child process has terminated abnormally");
115 return;
116 }
117
118 if (WEXITSTATUS(status)) {
119 error_setg(errp, "child process has failed to shutdown");
120 return;
121 }
122
123 /* succeeded */
124 }
125
126 int64_t qmp_guest_get_time(Error **errp)
127 {
128 int ret;
129 qemu_timeval tq;
130
131 ret = qemu_gettimeofday(&tq);
132 if (ret < 0) {
133 error_setg_errno(errp, errno, "Failed to get time");
134 return -1;
135 }
136
137 return tq.tv_sec * 1000000000LL + tq.tv_usec * 1000;
138 }
139
140 void qmp_guest_set_time(bool has_time, int64_t time_ns, Error **errp)
141 {
142 int ret;
143 int status;
144 pid_t pid;
145 Error *local_err = NULL;
146 struct timeval tv;
147
148 /* If user has passed a time, validate and set it. */
149 if (has_time) {
150 GDate date = { 0, };
151
152 /* year-2038 will overflow in case time_t is 32bit */
153 if (time_ns / 1000000000 != (time_t)(time_ns / 1000000000)) {
154 error_setg(errp, "Time %" PRId64 " is too large", time_ns);
155 return;
156 }
157
158 tv.tv_sec = time_ns / 1000000000;
159 tv.tv_usec = (time_ns % 1000000000) / 1000;
160 g_date_set_time_t(&date, tv.tv_sec);
161 if (date.year < 1970 || date.year >= 2070) {
162 error_setg_errno(errp, errno, "Invalid time");
163 return;
164 }
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 }
171 }
172
173 /* 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
176 * hardware clock (RTC). */
177 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
184 /* 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);
188 _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);
195 if (local_err) {
196 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
211 typedef enum {
212 RW_STATE_NEW,
213 RW_STATE_READING,
214 RW_STATE_WRITING,
215 } RwState;
216
217 typedef struct GuestFileHandle {
218 uint64_t id;
219 FILE *fh;
220 RwState state;
221 QTAILQ_ENTRY(GuestFileHandle) next;
222 } GuestFileHandle;
223
224 static struct {
225 QTAILQ_HEAD(, GuestFileHandle) filehandles;
226 } guest_file_state = {
227 .filehandles = QTAILQ_HEAD_INITIALIZER(guest_file_state.filehandles),
228 };
229
230 static int64_t guest_file_handle_add(FILE *fh, Error **errp)
231 {
232 GuestFileHandle *gfh;
233 int64_t handle;
234
235 handle = ga_get_fd_handle(ga_state, errp);
236 if (handle < 0) {
237 return -1;
238 }
239
240 gfh = g_new0(GuestFileHandle, 1);
241 gfh->id = handle;
242 gfh->fh = fh;
243 QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
244
245 return handle;
246 }
247
248 static GuestFileHandle *guest_file_handle_find(int64_t id, Error **errp)
249 {
250 GuestFileHandle *gfh;
251
252 QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next)
253 {
254 if (gfh->id == id) {
255 return gfh;
256 }
257 }
258
259 error_setg(errp, "handle '%" PRId64 "' has not been found", id);
260 return NULL;
261 }
262
263 typedef const char * const ccpc;
264
265 #ifndef O_BINARY
266 #define O_BINARY 0
267 #endif
268
269 /* http://pubs.opengroup.org/onlinepubs/9699919799/functions/fopen.html */
270 static const struct {
271 ccpc *forms;
272 int oflag_base;
273 } guest_file_open_modes[] = {
274 { (ccpc[]){ "r", NULL }, O_RDONLY },
275 { (ccpc[]){ "rb", NULL }, O_RDONLY | O_BINARY },
276 { (ccpc[]){ "w", NULL }, O_WRONLY | O_CREAT | O_TRUNC },
277 { (ccpc[]){ "wb", NULL }, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY },
278 { (ccpc[]){ "a", NULL }, O_WRONLY | O_CREAT | O_APPEND },
279 { (ccpc[]){ "ab", NULL }, O_WRONLY | O_CREAT | O_APPEND | O_BINARY },
280 { (ccpc[]){ "r+", NULL }, O_RDWR },
281 { (ccpc[]){ "rb+", "r+b", NULL }, O_RDWR | O_BINARY },
282 { (ccpc[]){ "w+", NULL }, O_RDWR | O_CREAT | O_TRUNC },
283 { (ccpc[]){ "wb+", "w+b", NULL }, O_RDWR | O_CREAT | O_TRUNC | O_BINARY },
284 { (ccpc[]){ "a+", NULL }, O_RDWR | O_CREAT | O_APPEND },
285 { (ccpc[]){ "ab+", "a+b", NULL }, O_RDWR | O_CREAT | O_APPEND | O_BINARY }
286 };
287
288 static int
289 find_open_flag(const char *mode_str, Error **errp)
290 {
291 unsigned mode;
292
293 for (mode = 0; mode < ARRAY_SIZE(guest_file_open_modes); ++mode) {
294 ccpc *form;
295
296 form = guest_file_open_modes[mode].forms;
297 while (*form != NULL && strcmp(*form, mode_str) != 0) {
298 ++form;
299 }
300 if (*form != NULL) {
301 break;
302 }
303 }
304
305 if (mode == ARRAY_SIZE(guest_file_open_modes)) {
306 error_setg(errp, "invalid file open mode '%s'", mode_str);
307 return -1;
308 }
309 return guest_file_open_modes[mode].oflag_base | O_NOCTTY | O_NONBLOCK;
310 }
311
312 #define DEFAULT_NEW_FILE_MODE (S_IRUSR | S_IWUSR | \
313 S_IRGRP | S_IWGRP | \
314 S_IROTH | S_IWOTH)
315
316 static FILE *
317 safe_open_or_create(const char *path, const char *mode, Error **errp)
318 {
319 Error *local_err = NULL;
320 int oflag;
321
322 oflag = find_open_flag(mode, &local_err);
323 if (local_err == NULL) {
324 int fd;
325
326 /* If the caller wants / allows creation of a new file, we implement it
327 * with a two step process: open() + (open() / fchmod()).
328 *
329 * First we insist on creating the file exclusively as a new file. If
330 * that succeeds, we're free to set any file-mode bits on it. (The
331 * motivation is that we want to set those file-mode bits independently
332 * of the current umask.)
333 *
334 * If the exclusive creation fails because the file already exists
335 * (EEXIST is not possible for any other reason), we just attempt to
336 * open the file, but in this case we won't be allowed to change the
337 * file-mode bits on the preexistent file.
338 *
339 * The pathname should never disappear between the two open()s in
340 * practice. If it happens, then someone very likely tried to race us.
341 * In this case just go ahead and report the ENOENT from the second
342 * open() to the caller.
343 *
344 * If the caller wants to open a preexistent file, then the first
345 * open() is decisive and its third argument is ignored, and the second
346 * open() and the fchmod() are never called.
347 */
348 fd = open(path, oflag | ((oflag & O_CREAT) ? O_EXCL : 0), 0);
349 if (fd == -1 && errno == EEXIST) {
350 oflag &= ~(unsigned)O_CREAT;
351 fd = open(path, oflag);
352 }
353
354 if (fd == -1) {
355 error_setg_errno(&local_err, errno, "failed to open file '%s' "
356 "(mode: '%s')", path, mode);
357 } else {
358 qemu_set_cloexec(fd);
359
360 if ((oflag & O_CREAT) && fchmod(fd, DEFAULT_NEW_FILE_MODE) == -1) {
361 error_setg_errno(&local_err, errno, "failed to set permission "
362 "0%03o on new file '%s' (mode: '%s')",
363 (unsigned)DEFAULT_NEW_FILE_MODE, path, mode);
364 } else {
365 FILE *f;
366
367 f = fdopen(fd, mode);
368 if (f == NULL) {
369 error_setg_errno(&local_err, errno, "failed to associate "
370 "stdio stream with file descriptor %d, "
371 "file '%s' (mode: '%s')", fd, path, mode);
372 } else {
373 return f;
374 }
375 }
376
377 close(fd);
378 if (oflag & O_CREAT) {
379 unlink(path);
380 }
381 }
382 }
383
384 error_propagate(errp, local_err);
385 return NULL;
386 }
387
388 int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode,
389 Error **errp)
390 {
391 FILE *fh;
392 Error *local_err = NULL;
393 int64_t handle;
394
395 if (!has_mode) {
396 mode = "r";
397 }
398 slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
399 fh = safe_open_or_create(path, mode, &local_err);
400 if (local_err != NULL) {
401 error_propagate(errp, local_err);
402 return -1;
403 }
404
405 /* set fd non-blocking to avoid common use cases (like reading from a
406 * named pipe) from hanging the agent
407 */
408 qemu_set_nonblock(fileno(fh));
409
410 handle = guest_file_handle_add(fh, errp);
411 if (handle < 0) {
412 fclose(fh);
413 return -1;
414 }
415
416 slog("guest-file-open, handle: %" PRId64, handle);
417 return handle;
418 }
419
420 void qmp_guest_file_close(int64_t handle, Error **errp)
421 {
422 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
423 int ret;
424
425 slog("guest-file-close called, handle: %" PRId64, handle);
426 if (!gfh) {
427 return;
428 }
429
430 ret = fclose(gfh->fh);
431 if (ret == EOF) {
432 error_setg_errno(errp, errno, "failed to close handle");
433 return;
434 }
435
436 QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
437 g_free(gfh);
438 }
439
440 struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
441 int64_t count, Error **errp)
442 {
443 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
444 GuestFileRead *read_data = NULL;
445 guchar *buf;
446 FILE *fh;
447 size_t read_count;
448
449 if (!gfh) {
450 return NULL;
451 }
452
453 if (!has_count) {
454 count = QGA_READ_COUNT_DEFAULT;
455 } else if (count < 0) {
456 error_setg(errp, "value '%" PRId64 "' is invalid for argument count",
457 count);
458 return NULL;
459 }
460
461 fh = gfh->fh;
462
463 /* explicitly flush when switching from writing to reading */
464 if (gfh->state == RW_STATE_WRITING) {
465 int ret = fflush(fh);
466 if (ret == EOF) {
467 error_setg_errno(errp, errno, "failed to flush file");
468 return NULL;
469 }
470 gfh->state = RW_STATE_NEW;
471 }
472
473 buf = g_malloc0(count+1);
474 read_count = fread(buf, 1, count, fh);
475 if (ferror(fh)) {
476 error_setg_errno(errp, errno, "failed to read file");
477 slog("guest-file-read failed, handle: %" PRId64, handle);
478 } else {
479 buf[read_count] = 0;
480 read_data = g_new0(GuestFileRead, 1);
481 read_data->count = read_count;
482 read_data->eof = feof(fh);
483 if (read_count) {
484 read_data->buf_b64 = g_base64_encode(buf, read_count);
485 }
486 gfh->state = RW_STATE_READING;
487 }
488 g_free(buf);
489 clearerr(fh);
490
491 return read_data;
492 }
493
494 GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
495 bool has_count, int64_t count,
496 Error **errp)
497 {
498 GuestFileWrite *write_data = NULL;
499 guchar *buf;
500 gsize buf_len;
501 int write_count;
502 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
503 FILE *fh;
504
505 if (!gfh) {
506 return NULL;
507 }
508
509 fh = gfh->fh;
510
511 if (gfh->state == RW_STATE_READING) {
512 int ret = fseek(fh, 0, SEEK_CUR);
513 if (ret == -1) {
514 error_setg_errno(errp, errno, "failed to seek file");
515 return NULL;
516 }
517 gfh->state = RW_STATE_NEW;
518 }
519
520 buf = qbase64_decode(buf_b64, -1, &buf_len, errp);
521 if (!buf) {
522 return NULL;
523 }
524
525 if (!has_count) {
526 count = buf_len;
527 } else if (count < 0 || count > buf_len) {
528 error_setg(errp, "value '%" PRId64 "' is invalid for argument count",
529 count);
530 g_free(buf);
531 return NULL;
532 }
533
534 write_count = fwrite(buf, 1, count, fh);
535 if (ferror(fh)) {
536 error_setg_errno(errp, errno, "failed to write to file");
537 slog("guest-file-write failed, handle: %" PRId64, handle);
538 } else {
539 write_data = g_new0(GuestFileWrite, 1);
540 write_data->count = write_count;
541 write_data->eof = feof(fh);
542 gfh->state = RW_STATE_WRITING;
543 }
544 g_free(buf);
545 clearerr(fh);
546
547 return write_data;
548 }
549
550 struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
551 GuestFileWhence *whence_code,
552 Error **errp)
553 {
554 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
555 GuestFileSeek *seek_data = NULL;
556 FILE *fh;
557 int ret;
558 int whence;
559 Error *err = NULL;
560
561 if (!gfh) {
562 return NULL;
563 }
564
565 /* We stupidly exposed 'whence':'int' in our qapi */
566 whence = ga_parse_whence(whence_code, &err);
567 if (err) {
568 error_propagate(errp, err);
569 return NULL;
570 }
571
572 fh = gfh->fh;
573 ret = fseek(fh, offset, whence);
574 if (ret == -1) {
575 error_setg_errno(errp, errno, "failed to seek file");
576 if (errno == ESPIPE) {
577 /* file is non-seekable, stdio shouldn't be buffering anyways */
578 gfh->state = RW_STATE_NEW;
579 }
580 } else {
581 seek_data = g_new0(GuestFileSeek, 1);
582 seek_data->position = ftell(fh);
583 seek_data->eof = feof(fh);
584 gfh->state = RW_STATE_NEW;
585 }
586 clearerr(fh);
587
588 return seek_data;
589 }
590
591 void qmp_guest_file_flush(int64_t handle, Error **errp)
592 {
593 GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
594 FILE *fh;
595 int ret;
596
597 if (!gfh) {
598 return;
599 }
600
601 fh = gfh->fh;
602 ret = fflush(fh);
603 if (ret == EOF) {
604 error_setg_errno(errp, errno, "failed to flush file");
605 } else {
606 gfh->state = RW_STATE_NEW;
607 }
608 }
609
610 /* linux-specific implementations. avoid this if at all possible. */
611 #if defined(__linux__)
612
613 #if defined(CONFIG_FSFREEZE) || defined(CONFIG_FSTRIM)
614 typedef struct FsMount {
615 char *dirname;
616 char *devtype;
617 unsigned int devmajor, devminor;
618 QTAILQ_ENTRY(FsMount) next;
619 } FsMount;
620
621 typedef QTAILQ_HEAD(FsMountList, FsMount) FsMountList;
622
623 static void free_fs_mount_list(FsMountList *mounts)
624 {
625 FsMount *mount, *temp;
626
627 if (!mounts) {
628 return;
629 }
630
631 QTAILQ_FOREACH_SAFE(mount, mounts, next, temp) {
632 QTAILQ_REMOVE(mounts, mount, next);
633 g_free(mount->dirname);
634 g_free(mount->devtype);
635 g_free(mount);
636 }
637 }
638
639 static int dev_major_minor(const char *devpath,
640 unsigned int *devmajor, unsigned int *devminor)
641 {
642 struct stat st;
643
644 *devmajor = 0;
645 *devminor = 0;
646
647 if (stat(devpath, &st) < 0) {
648 slog("failed to stat device file '%s': %s", devpath, strerror(errno));
649 return -1;
650 }
651 if (S_ISDIR(st.st_mode)) {
652 /* It is bind mount */
653 return -2;
654 }
655 if (S_ISBLK(st.st_mode)) {
656 *devmajor = major(st.st_rdev);
657 *devminor = minor(st.st_rdev);
658 return 0;
659 }
660 return -1;
661 }
662
663 /*
664 * Walk the mount table and build a list of local file systems
665 */
666 static void build_fs_mount_list_from_mtab(FsMountList *mounts, Error **errp)
667 {
668 struct mntent *ment;
669 FsMount *mount;
670 char const *mtab = "/proc/self/mounts";
671 FILE *fp;
672 unsigned int devmajor, devminor;
673
674 fp = setmntent(mtab, "r");
675 if (!fp) {
676 error_setg(errp, "failed to open mtab file: '%s'", mtab);
677 return;
678 }
679
680 while ((ment = getmntent(fp))) {
681 /*
682 * An entry which device name doesn't start with a '/' is
683 * either a dummy file system or a network file system.
684 * Add special handling for smbfs and cifs as is done by
685 * coreutils as well.
686 */
687 if ((ment->mnt_fsname[0] != '/') ||
688 (strcmp(ment->mnt_type, "smbfs") == 0) ||
689 (strcmp(ment->mnt_type, "cifs") == 0)) {
690 continue;
691 }
692 if (dev_major_minor(ment->mnt_fsname, &devmajor, &devminor) == -2) {
693 /* Skip bind mounts */
694 continue;
695 }
696
697 mount = g_new0(FsMount, 1);
698 mount->dirname = g_strdup(ment->mnt_dir);
699 mount->devtype = g_strdup(ment->mnt_type);
700 mount->devmajor = devmajor;
701 mount->devminor = devminor;
702
703 QTAILQ_INSERT_TAIL(mounts, mount, next);
704 }
705
706 endmntent(fp);
707 }
708
709 static void decode_mntname(char *name, int len)
710 {
711 int i, j = 0;
712 for (i = 0; i <= len; i++) {
713 if (name[i] != '\\') {
714 name[j++] = name[i];
715 } else if (name[i + 1] == '\\') {
716 name[j++] = '\\';
717 i++;
718 } else if (name[i + 1] >= '0' && name[i + 1] <= '3' &&
719 name[i + 2] >= '0' && name[i + 2] <= '7' &&
720 name[i + 3] >= '0' && name[i + 3] <= '7') {
721 name[j++] = (name[i + 1] - '0') * 64 +
722 (name[i + 2] - '0') * 8 +
723 (name[i + 3] - '0');
724 i += 3;
725 } else {
726 name[j++] = name[i];
727 }
728 }
729 }
730
731 static void build_fs_mount_list(FsMountList *mounts, Error **errp)
732 {
733 FsMount *mount;
734 char const *mountinfo = "/proc/self/mountinfo";
735 FILE *fp;
736 char *line = NULL, *dash;
737 size_t n;
738 char check;
739 unsigned int devmajor, devminor;
740 int ret, dir_s, dir_e, type_s, type_e, dev_s, dev_e;
741
742 fp = fopen(mountinfo, "r");
743 if (!fp) {
744 build_fs_mount_list_from_mtab(mounts, errp);
745 return;
746 }
747
748 while (getline(&line, &n, fp) != -1) {
749 ret = sscanf(line, "%*u %*u %u:%u %*s %n%*s%n%c",
750 &devmajor, &devminor, &dir_s, &dir_e, &check);
751 if (ret < 3) {
752 continue;
753 }
754 dash = strstr(line + dir_e, " - ");
755 if (!dash) {
756 continue;
757 }
758 ret = sscanf(dash, " - %n%*s%n %n%*s%n%c",
759 &type_s, &type_e, &dev_s, &dev_e, &check);
760 if (ret < 1) {
761 continue;
762 }
763 line[dir_e] = 0;
764 dash[type_e] = 0;
765 dash[dev_e] = 0;
766 decode_mntname(line + dir_s, dir_e - dir_s);
767 decode_mntname(dash + dev_s, dev_e - dev_s);
768 if (devmajor == 0) {
769 /* btrfs reports major number = 0 */
770 if (strcmp("btrfs", dash + type_s) != 0 ||
771 dev_major_minor(dash + dev_s, &devmajor, &devminor) < 0) {
772 continue;
773 }
774 }
775
776 mount = g_new0(FsMount, 1);
777 mount->dirname = g_strdup(line + dir_s);
778 mount->devtype = g_strdup(dash + type_s);
779 mount->devmajor = devmajor;
780 mount->devminor = devminor;
781
782 QTAILQ_INSERT_TAIL(mounts, mount, next);
783 }
784 free(line);
785
786 fclose(fp);
787 }
788 #endif
789
790 #if defined(CONFIG_FSFREEZE)
791
792 static char *get_pci_driver(char const *syspath, int pathlen, Error **errp)
793 {
794 char *path;
795 char *dpath;
796 char *driver = NULL;
797 char buf[PATH_MAX];
798 ssize_t len;
799
800 path = g_strndup(syspath, pathlen);
801 dpath = g_strdup_printf("%s/driver", path);
802 len = readlink(dpath, buf, sizeof(buf) - 1);
803 if (len != -1) {
804 buf[len] = 0;
805 driver = g_strdup(basename(buf));
806 }
807 g_free(dpath);
808 g_free(path);
809 return driver;
810 }
811
812 static int compare_uint(const void *_a, const void *_b)
813 {
814 unsigned int a = *(unsigned int *)_a;
815 unsigned int b = *(unsigned int *)_b;
816
817 return a < b ? -1 : a > b ? 1 : 0;
818 }
819
820 /* Walk the specified sysfs and build a sorted list of host or ata numbers */
821 static int build_hosts(char const *syspath, char const *host, bool ata,
822 unsigned int *hosts, int hosts_max, Error **errp)
823 {
824 char *path;
825 DIR *dir;
826 struct dirent *entry;
827 int i = 0;
828
829 path = g_strndup(syspath, host - syspath);
830 dir = opendir(path);
831 if (!dir) {
832 error_setg_errno(errp, errno, "opendir(\"%s\")", path);
833 g_free(path);
834 return -1;
835 }
836
837 while (i < hosts_max) {
838 entry = readdir(dir);
839 if (!entry) {
840 break;
841 }
842 if (ata && sscanf(entry->d_name, "ata%d", hosts + i) == 1) {
843 ++i;
844 } else if (!ata && sscanf(entry->d_name, "host%d", hosts + i) == 1) {
845 ++i;
846 }
847 }
848
849 qsort(hosts, i, sizeof(hosts[0]), compare_uint);
850
851 g_free(path);
852 closedir(dir);
853 return i;
854 }
855
856 /* Store disk device info specified by @sysfs into @fs */
857 static void build_guest_fsinfo_for_real_device(char const *syspath,
858 GuestFilesystemInfo *fs,
859 Error **errp)
860 {
861 unsigned int pci[4], host, hosts[8], tgt[3];
862 int i, nhosts = 0, pcilen;
863 GuestDiskAddress *disk;
864 GuestPCIAddress *pciaddr;
865 GuestDiskAddressList *list = NULL;
866 bool has_ata = false, has_host = false, has_tgt = false;
867 char *p, *q, *driver = NULL;
868
869 p = strstr(syspath, "/devices/pci");
870 if (!p || sscanf(p + 12, "%*x:%*x/%x:%x:%x.%x%n",
871 pci, pci + 1, pci + 2, pci + 3, &pcilen) < 4) {
872 g_debug("only pci device is supported: sysfs path \"%s\"", syspath);
873 return;
874 }
875
876 driver = get_pci_driver(syspath, (p + 12 + pcilen) - syspath, errp);
877 if (!driver) {
878 goto cleanup;
879 }
880
881 p = strstr(syspath, "/target");
882 if (p && sscanf(p + 7, "%*u:%*u:%*u/%*u:%u:%u:%u",
883 tgt, tgt + 1, tgt + 2) == 3) {
884 has_tgt = true;
885 }
886
887 p = strstr(syspath, "/ata");
888 if (p) {
889 q = p + 4;
890 has_ata = true;
891 } else {
892 p = strstr(syspath, "/host");
893 q = p + 5;
894 }
895 if (p && sscanf(q, "%u", &host) == 1) {
896 has_host = true;
897 nhosts = build_hosts(syspath, p, has_ata, hosts,
898 sizeof(hosts) / sizeof(hosts[0]), errp);
899 if (nhosts < 0) {
900 goto cleanup;
901 }
902 }
903
904 pciaddr = g_malloc0(sizeof(*pciaddr));
905 pciaddr->domain = pci[0];
906 pciaddr->bus = pci[1];
907 pciaddr->slot = pci[2];
908 pciaddr->function = pci[3];
909
910 disk = g_malloc0(sizeof(*disk));
911 disk->pci_controller = pciaddr;
912
913 list = g_malloc0(sizeof(*list));
914 list->value = disk;
915
916 if (strcmp(driver, "ata_piix") == 0) {
917 /* a host per ide bus, target*:0:<unit>:0 */
918 if (!has_host || !has_tgt) {
919 g_debug("invalid sysfs path '%s' (driver '%s')", syspath, driver);
920 goto cleanup;
921 }
922 for (i = 0; i < nhosts; i++) {
923 if (host == hosts[i]) {
924 disk->bus_type = GUEST_DISK_BUS_TYPE_IDE;
925 disk->bus = i;
926 disk->unit = tgt[1];
927 break;
928 }
929 }
930 if (i >= nhosts) {
931 g_debug("no host for '%s' (driver '%s')", syspath, driver);
932 goto cleanup;
933 }
934 } else if (strcmp(driver, "sym53c8xx") == 0) {
935 /* scsi(LSI Logic): target*:0:<unit>:0 */
936 if (!has_tgt) {
937 g_debug("invalid sysfs path '%s' (driver '%s')", syspath, driver);
938 goto cleanup;
939 }
940 disk->bus_type = GUEST_DISK_BUS_TYPE_SCSI;
941 disk->unit = tgt[1];
942 } else if (strcmp(driver, "virtio-pci") == 0) {
943 if (has_tgt) {
944 /* virtio-scsi: target*:0:0:<unit> */
945 disk->bus_type = GUEST_DISK_BUS_TYPE_SCSI;
946 disk->unit = tgt[2];
947 } else {
948 /* virtio-blk: 1 disk per 1 device */
949 disk->bus_type = GUEST_DISK_BUS_TYPE_VIRTIO;
950 }
951 } else if (strcmp(driver, "ahci") == 0) {
952 /* ahci: 1 host per 1 unit */
953 if (!has_host || !has_tgt) {
954 g_debug("invalid sysfs path '%s' (driver '%s')", syspath, driver);
955 goto cleanup;
956 }
957 for (i = 0; i < nhosts; i++) {
958 if (host == hosts[i]) {
959 disk->unit = i;
960 disk->bus_type = GUEST_DISK_BUS_TYPE_SATA;
961 break;
962 }
963 }
964 if (i >= nhosts) {
965 g_debug("no host for '%s' (driver '%s')", syspath, driver);
966 goto cleanup;
967 }
968 } else {
969 g_debug("unknown driver '%s' (sysfs path '%s')", driver, syspath);
970 goto cleanup;
971 }
972
973 list->next = fs->disk;
974 fs->disk = list;
975 g_free(driver);
976 return;
977
978 cleanup:
979 if (list) {
980 qapi_free_GuestDiskAddressList(list);
981 }
982 g_free(driver);
983 }
984
985 static void build_guest_fsinfo_for_device(char const *devpath,
986 GuestFilesystemInfo *fs,
987 Error **errp);
988
989 /* Store a list of slave devices of virtual volume specified by @syspath into
990 * @fs */
991 static void build_guest_fsinfo_for_virtual_device(char const *syspath,
992 GuestFilesystemInfo *fs,
993 Error **errp)
994 {
995 DIR *dir;
996 char *dirpath;
997 struct dirent *entry;
998
999 dirpath = g_strdup_printf("%s/slaves", syspath);
1000 dir = opendir(dirpath);
1001 if (!dir) {
1002 if (errno != ENOENT) {
1003 error_setg_errno(errp, errno, "opendir(\"%s\")", dirpath);
1004 }
1005 g_free(dirpath);
1006 return;
1007 }
1008
1009 for (;;) {
1010 errno = 0;
1011 entry = readdir(dir);
1012 if (entry == NULL) {
1013 if (errno) {
1014 error_setg_errno(errp, errno, "readdir(\"%s\")", dirpath);
1015 }
1016 break;
1017 }
1018
1019 if (entry->d_type == DT_LNK) {
1020 char *path;
1021
1022 g_debug(" slave device '%s'", entry->d_name);
1023 path = g_strdup_printf("%s/slaves/%s", syspath, entry->d_name);
1024 build_guest_fsinfo_for_device(path, fs, errp);
1025 g_free(path);
1026
1027 if (*errp) {
1028 break;
1029 }
1030 }
1031 }
1032
1033 g_free(dirpath);
1034 closedir(dir);
1035 }
1036
1037 /* Dispatch to functions for virtual/real device */
1038 static void build_guest_fsinfo_for_device(char const *devpath,
1039 GuestFilesystemInfo *fs,
1040 Error **errp)
1041 {
1042 char *syspath = realpath(devpath, NULL);
1043
1044 if (!syspath) {
1045 error_setg_errno(errp, errno, "realpath(\"%s\")", devpath);
1046 return;
1047 }
1048
1049 if (!fs->name) {
1050 fs->name = g_strdup(basename(syspath));
1051 }
1052
1053 g_debug(" parse sysfs path '%s'", syspath);
1054
1055 if (strstr(syspath, "/devices/virtual/block/")) {
1056 build_guest_fsinfo_for_virtual_device(syspath, fs, errp);
1057 } else {
1058 build_guest_fsinfo_for_real_device(syspath, fs, errp);
1059 }
1060
1061 free(syspath);
1062 }
1063
1064 /* Return a list of the disk device(s)' info which @mount lies on */
1065 static GuestFilesystemInfo *build_guest_fsinfo(struct FsMount *mount,
1066 Error **errp)
1067 {
1068 GuestFilesystemInfo *fs = g_malloc0(sizeof(*fs));
1069 char *devpath = g_strdup_printf("/sys/dev/block/%u:%u",
1070 mount->devmajor, mount->devminor);
1071
1072 fs->mountpoint = g_strdup(mount->dirname);
1073 fs->type = g_strdup(mount->devtype);
1074 build_guest_fsinfo_for_device(devpath, fs, errp);
1075
1076 g_free(devpath);
1077 return fs;
1078 }
1079
1080 GuestFilesystemInfoList *qmp_guest_get_fsinfo(Error **errp)
1081 {
1082 FsMountList mounts;
1083 struct FsMount *mount;
1084 GuestFilesystemInfoList *new, *ret = NULL;
1085 Error *local_err = NULL;
1086
1087 QTAILQ_INIT(&mounts);
1088 build_fs_mount_list(&mounts, &local_err);
1089 if (local_err) {
1090 error_propagate(errp, local_err);
1091 return NULL;
1092 }
1093
1094 QTAILQ_FOREACH(mount, &mounts, next) {
1095 g_debug("Building guest fsinfo for '%s'", mount->dirname);
1096
1097 new = g_malloc0(sizeof(*ret));
1098 new->value = build_guest_fsinfo(mount, &local_err);
1099 new->next = ret;
1100 ret = new;
1101 if (local_err) {
1102 error_propagate(errp, local_err);
1103 qapi_free_GuestFilesystemInfoList(ret);
1104 ret = NULL;
1105 break;
1106 }
1107 }
1108
1109 free_fs_mount_list(&mounts);
1110 return ret;
1111 }
1112
1113
1114 typedef enum {
1115 FSFREEZE_HOOK_THAW = 0,
1116 FSFREEZE_HOOK_FREEZE,
1117 } FsfreezeHookArg;
1118
1119 static const char *fsfreeze_hook_arg_string[] = {
1120 "thaw",
1121 "freeze",
1122 };
1123
1124 static void execute_fsfreeze_hook(FsfreezeHookArg arg, Error **errp)
1125 {
1126 int status;
1127 pid_t pid;
1128 const char *hook;
1129 const char *arg_str = fsfreeze_hook_arg_string[arg];
1130 Error *local_err = NULL;
1131
1132 hook = ga_fsfreeze_hook(ga_state);
1133 if (!hook) {
1134 return;
1135 }
1136 if (access(hook, X_OK) != 0) {
1137 error_setg_errno(errp, errno, "can't access fsfreeze hook '%s'", hook);
1138 return;
1139 }
1140
1141 slog("executing fsfreeze hook with arg '%s'", arg_str);
1142 pid = fork();
1143 if (pid == 0) {
1144 setsid();
1145 reopen_fd_to_null(0);
1146 reopen_fd_to_null(1);
1147 reopen_fd_to_null(2);
1148
1149 execle(hook, hook, arg_str, NULL, environ);
1150 _exit(EXIT_FAILURE);
1151 } else if (pid < 0) {
1152 error_setg_errno(errp, errno, "failed to create child process");
1153 return;
1154 }
1155
1156 ga_wait_child(pid, &status, &local_err);
1157 if (local_err) {
1158 error_propagate(errp, local_err);
1159 return;
1160 }
1161
1162 if (!WIFEXITED(status)) {
1163 error_setg(errp, "fsfreeze hook has terminated abnormally");
1164 return;
1165 }
1166
1167 status = WEXITSTATUS(status);
1168 if (status) {
1169 error_setg(errp, "fsfreeze hook has failed with status %d", status);
1170 return;
1171 }
1172 }
1173
1174 /*
1175 * Return status of freeze/thaw
1176 */
1177 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp)
1178 {
1179 if (ga_is_frozen(ga_state)) {
1180 return GUEST_FSFREEZE_STATUS_FROZEN;
1181 }
1182
1183 return GUEST_FSFREEZE_STATUS_THAWED;
1184 }
1185
1186 int64_t qmp_guest_fsfreeze_freeze(Error **errp)
1187 {
1188 return qmp_guest_fsfreeze_freeze_list(false, NULL, errp);
1189 }
1190
1191 /*
1192 * Walk list of mounted file systems in the guest, and freeze the ones which
1193 * are real local file systems.
1194 */
1195 int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,
1196 strList *mountpoints,
1197 Error **errp)
1198 {
1199 int ret = 0, i = 0;
1200 strList *list;
1201 FsMountList mounts;
1202 struct FsMount *mount;
1203 Error *local_err = NULL;
1204 int fd;
1205
1206 slog("guest-fsfreeze called");
1207
1208 execute_fsfreeze_hook(FSFREEZE_HOOK_FREEZE, &local_err);
1209 if (local_err) {
1210 error_propagate(errp, local_err);
1211 return -1;
1212 }
1213
1214 QTAILQ_INIT(&mounts);
1215 build_fs_mount_list(&mounts, &local_err);
1216 if (local_err) {
1217 error_propagate(errp, local_err);
1218 return -1;
1219 }
1220
1221 /* cannot risk guest agent blocking itself on a write in this state */
1222 ga_set_frozen(ga_state);
1223
1224 QTAILQ_FOREACH_REVERSE(mount, &mounts, FsMountList, next) {
1225 /* To issue fsfreeze in the reverse order of mounts, check if the
1226 * mount is listed in the list here */
1227 if (has_mountpoints) {
1228 for (list = mountpoints; list; list = list->next) {
1229 if (strcmp(list->value, mount->dirname) == 0) {
1230 break;
1231 }
1232 }
1233 if (!list) {
1234 continue;
1235 }
1236 }
1237
1238 fd = qemu_open(mount->dirname, O_RDONLY);
1239 if (fd == -1) {
1240 error_setg_errno(errp, errno, "failed to open %s", mount->dirname);
1241 goto error;
1242 }
1243
1244 /* we try to cull filesystems we know won't work in advance, but other
1245 * filesystems may not implement fsfreeze for less obvious reasons.
1246 * these will report EOPNOTSUPP. we simply ignore these when tallying
1247 * the number of frozen filesystems.
1248 * if a filesystem is mounted more than once (aka bind mount) a
1249 * consecutive attempt to freeze an already frozen filesystem will
1250 * return EBUSY.
1251 *
1252 * any other error means a failure to freeze a filesystem we
1253 * expect to be freezable, so return an error in those cases
1254 * and return system to thawed state.
1255 */
1256 ret = ioctl(fd, FIFREEZE);
1257 if (ret == -1) {
1258 if (errno != EOPNOTSUPP && errno != EBUSY) {
1259 error_setg_errno(errp, errno, "failed to freeze %s",
1260 mount->dirname);
1261 close(fd);
1262 goto error;
1263 }
1264 } else {
1265 i++;
1266 }
1267 close(fd);
1268 }
1269
1270 free_fs_mount_list(&mounts);
1271 return i;
1272
1273 error:
1274 free_fs_mount_list(&mounts);
1275 qmp_guest_fsfreeze_thaw(NULL);
1276 return 0;
1277 }
1278
1279 /*
1280 * Walk list of frozen file systems in the guest, and thaw them.
1281 */
1282 int64_t qmp_guest_fsfreeze_thaw(Error **errp)
1283 {
1284 int ret;
1285 FsMountList mounts;
1286 FsMount *mount;
1287 int fd, i = 0, logged;
1288 Error *local_err = NULL;
1289
1290 QTAILQ_INIT(&mounts);
1291 build_fs_mount_list(&mounts, &local_err);
1292 if (local_err) {
1293 error_propagate(errp, local_err);
1294 return 0;
1295 }
1296
1297 QTAILQ_FOREACH(mount, &mounts, next) {
1298 logged = false;
1299 fd = qemu_open(mount->dirname, O_RDONLY);
1300 if (fd == -1) {
1301 continue;
1302 }
1303 /* we have no way of knowing whether a filesystem was actually unfrozen
1304 * as a result of a successful call to FITHAW, only that if an error
1305 * was returned the filesystem was *not* unfrozen by that particular
1306 * call.
1307 *
1308 * since multiple preceding FIFREEZEs require multiple calls to FITHAW
1309 * to unfreeze, continuing issuing FITHAW until an error is returned,
1310 * in which case either the filesystem is in an unfreezable state, or,
1311 * more likely, it was thawed previously (and remains so afterward).
1312 *
1313 * also, since the most recent successful call is the one that did
1314 * the actual unfreeze, we can use this to provide an accurate count
1315 * of the number of filesystems unfrozen by guest-fsfreeze-thaw, which
1316 * may * be useful for determining whether a filesystem was unfrozen
1317 * during the freeze/thaw phase by a process other than qemu-ga.
1318 */
1319 do {
1320 ret = ioctl(fd, FITHAW);
1321 if (ret == 0 && !logged) {
1322 i++;
1323 logged = true;
1324 }
1325 } while (ret == 0);
1326 close(fd);
1327 }
1328
1329 ga_unset_frozen(ga_state);
1330 free_fs_mount_list(&mounts);
1331
1332 execute_fsfreeze_hook(FSFREEZE_HOOK_THAW, errp);
1333
1334 return i;
1335 }
1336
1337 static void guest_fsfreeze_cleanup(void)
1338 {
1339 Error *err = NULL;
1340
1341 if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) {
1342 qmp_guest_fsfreeze_thaw(&err);
1343 if (err) {
1344 slog("failed to clean up frozen filesystems: %s",
1345 error_get_pretty(err));
1346 error_free(err);
1347 }
1348 }
1349 }
1350 #endif /* CONFIG_FSFREEZE */
1351
1352 #if defined(CONFIG_FSTRIM)
1353 /*
1354 * Walk list of mounted file systems in the guest, and trim them.
1355 */
1356 GuestFilesystemTrimResponse *
1357 qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
1358 {
1359 GuestFilesystemTrimResponse *response;
1360 GuestFilesystemTrimResultList *list;
1361 GuestFilesystemTrimResult *result;
1362 int ret = 0;
1363 FsMountList mounts;
1364 struct FsMount *mount;
1365 int fd;
1366 Error *local_err = NULL;
1367 struct fstrim_range r;
1368
1369 slog("guest-fstrim called");
1370
1371 QTAILQ_INIT(&mounts);
1372 build_fs_mount_list(&mounts, &local_err);
1373 if (local_err) {
1374 error_propagate(errp, local_err);
1375 return NULL;
1376 }
1377
1378 response = g_malloc0(sizeof(*response));
1379
1380 QTAILQ_FOREACH(mount, &mounts, next) {
1381 result = g_malloc0(sizeof(*result));
1382 result->path = g_strdup(mount->dirname);
1383
1384 list = g_malloc0(sizeof(*list));
1385 list->value = result;
1386 list->next = response->paths;
1387 response->paths = list;
1388
1389 fd = qemu_open(mount->dirname, O_RDONLY);
1390 if (fd == -1) {
1391 result->error = g_strdup_printf("failed to open: %s",
1392 strerror(errno));
1393 result->has_error = true;
1394 continue;
1395 }
1396
1397 /* We try to cull filesystems we know won't work in advance, but other
1398 * filesystems may not implement fstrim for less obvious reasons.
1399 * These will report EOPNOTSUPP; while in some other cases ENOTTY
1400 * will be reported (e.g. CD-ROMs).
1401 * Any other error means an unexpected error.
1402 */
1403 r.start = 0;
1404 r.len = -1;
1405 r.minlen = has_minimum ? minimum : 0;
1406 ret = ioctl(fd, FITRIM, &r);
1407 if (ret == -1) {
1408 result->has_error = true;
1409 if (errno == ENOTTY || errno == EOPNOTSUPP) {
1410 result->error = g_strdup("trim not supported");
1411 } else {
1412 result->error = g_strdup_printf("failed to trim: %s",
1413 strerror(errno));
1414 }
1415 close(fd);
1416 continue;
1417 }
1418
1419 result->has_minimum = true;
1420 result->minimum = r.minlen;
1421 result->has_trimmed = true;
1422 result->trimmed = r.len;
1423 close(fd);
1424 }
1425
1426 free_fs_mount_list(&mounts);
1427 return response;
1428 }
1429 #endif /* CONFIG_FSTRIM */
1430
1431
1432 #define LINUX_SYS_STATE_FILE "/sys/power/state"
1433 #define SUSPEND_SUPPORTED 0
1434 #define SUSPEND_NOT_SUPPORTED 1
1435
1436 static void bios_supports_mode(const char *pmutils_bin, const char *pmutils_arg,
1437 const char *sysfile_str, Error **errp)
1438 {
1439 Error *local_err = NULL;
1440 char *pmutils_path;
1441 pid_t pid;
1442 int status;
1443
1444 pmutils_path = g_find_program_in_path(pmutils_bin);
1445
1446 pid = fork();
1447 if (!pid) {
1448 char buf[32]; /* hopefully big enough */
1449 ssize_t ret;
1450 int fd;
1451
1452 setsid();
1453 reopen_fd_to_null(0);
1454 reopen_fd_to_null(1);
1455 reopen_fd_to_null(2);
1456
1457 if (pmutils_path) {
1458 execle(pmutils_path, pmutils_bin, pmutils_arg, NULL, environ);
1459 }
1460
1461 /*
1462 * If we get here either pm-utils is not installed or execle() has
1463 * failed. Let's try the manual method if the caller wants it.
1464 */
1465
1466 if (!sysfile_str) {
1467 _exit(SUSPEND_NOT_SUPPORTED);
1468 }
1469
1470 fd = open(LINUX_SYS_STATE_FILE, O_RDONLY);
1471 if (fd < 0) {
1472 _exit(SUSPEND_NOT_SUPPORTED);
1473 }
1474
1475 ret = read(fd, buf, sizeof(buf)-1);
1476 if (ret <= 0) {
1477 _exit(SUSPEND_NOT_SUPPORTED);
1478 }
1479 buf[ret] = '\0';
1480
1481 if (strstr(buf, sysfile_str)) {
1482 _exit(SUSPEND_SUPPORTED);
1483 }
1484
1485 _exit(SUSPEND_NOT_SUPPORTED);
1486 } else if (pid < 0) {
1487 error_setg_errno(errp, errno, "failed to create child process");
1488 goto out;
1489 }
1490
1491 ga_wait_child(pid, &status, &local_err);
1492 if (local_err) {
1493 error_propagate(errp, local_err);
1494 goto out;
1495 }
1496
1497 if (!WIFEXITED(status)) {
1498 error_setg(errp, "child process has terminated abnormally");
1499 goto out;
1500 }
1501
1502 switch (WEXITSTATUS(status)) {
1503 case SUSPEND_SUPPORTED:
1504 goto out;
1505 case SUSPEND_NOT_SUPPORTED:
1506 error_setg(errp,
1507 "the requested suspend mode is not supported by the guest");
1508 goto out;
1509 default:
1510 error_setg(errp,
1511 "the helper program '%s' returned an unexpected exit status"
1512 " code (%d)", pmutils_path, WEXITSTATUS(status));
1513 goto out;
1514 }
1515
1516 out:
1517 g_free(pmutils_path);
1518 }
1519
1520 static void guest_suspend(const char *pmutils_bin, const char *sysfile_str,
1521 Error **errp)
1522 {
1523 Error *local_err = NULL;
1524 char *pmutils_path;
1525 pid_t pid;
1526 int status;
1527
1528 pmutils_path = g_find_program_in_path(pmutils_bin);
1529
1530 pid = fork();
1531 if (pid == 0) {
1532 /* child */
1533 int fd;
1534
1535 setsid();
1536 reopen_fd_to_null(0);
1537 reopen_fd_to_null(1);
1538 reopen_fd_to_null(2);
1539
1540 if (pmutils_path) {
1541 execle(pmutils_path, pmutils_bin, NULL, environ);
1542 }
1543
1544 /*
1545 * If we get here either pm-utils is not installed or execle() has
1546 * failed. Let's try the manual method if the caller wants it.
1547 */
1548
1549 if (!sysfile_str) {
1550 _exit(EXIT_FAILURE);
1551 }
1552
1553 fd = open(LINUX_SYS_STATE_FILE, O_WRONLY);
1554 if (fd < 0) {
1555 _exit(EXIT_FAILURE);
1556 }
1557
1558 if (write(fd, sysfile_str, strlen(sysfile_str)) < 0) {
1559 _exit(EXIT_FAILURE);
1560 }
1561
1562 _exit(EXIT_SUCCESS);
1563 } else if (pid < 0) {
1564 error_setg_errno(errp, errno, "failed to create child process");
1565 goto out;
1566 }
1567
1568 ga_wait_child(pid, &status, &local_err);
1569 if (local_err) {
1570 error_propagate(errp, local_err);
1571 goto out;
1572 }
1573
1574 if (!WIFEXITED(status)) {
1575 error_setg(errp, "child process has terminated abnormally");
1576 goto out;
1577 }
1578
1579 if (WEXITSTATUS(status)) {
1580 error_setg(errp, "child process has failed to suspend");
1581 goto out;
1582 }
1583
1584 out:
1585 g_free(pmutils_path);
1586 }
1587
1588 void qmp_guest_suspend_disk(Error **errp)
1589 {
1590 Error *local_err = NULL;
1591
1592 bios_supports_mode("pm-is-supported", "--hibernate", "disk", &local_err);
1593 if (local_err) {
1594 error_propagate(errp, local_err);
1595 return;
1596 }
1597
1598 guest_suspend("pm-hibernate", "disk", errp);
1599 }
1600
1601 void qmp_guest_suspend_ram(Error **errp)
1602 {
1603 Error *local_err = NULL;
1604
1605 bios_supports_mode("pm-is-supported", "--suspend", "mem", &local_err);
1606 if (local_err) {
1607 error_propagate(errp, local_err);
1608 return;
1609 }
1610
1611 guest_suspend("pm-suspend", "mem", errp);
1612 }
1613
1614 void qmp_guest_suspend_hybrid(Error **errp)
1615 {
1616 Error *local_err = NULL;
1617
1618 bios_supports_mode("pm-is-supported", "--suspend-hybrid", NULL,
1619 &local_err);
1620 if (local_err) {
1621 error_propagate(errp, local_err);
1622 return;
1623 }
1624
1625 guest_suspend("pm-suspend-hybrid", NULL, errp);
1626 }
1627
1628 static GuestNetworkInterfaceList *
1629 guest_find_interface(GuestNetworkInterfaceList *head,
1630 const char *name)
1631 {
1632 for (; head; head = head->next) {
1633 if (strcmp(head->value->name, name) == 0) {
1634 break;
1635 }
1636 }
1637
1638 return head;
1639 }
1640
1641 /*
1642 * Build information about guest interfaces
1643 */
1644 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
1645 {
1646 GuestNetworkInterfaceList *head = NULL, *cur_item = NULL;
1647 struct ifaddrs *ifap, *ifa;
1648
1649 if (getifaddrs(&ifap) < 0) {
1650 error_setg_errno(errp, errno, "getifaddrs failed");
1651 goto error;
1652 }
1653
1654 for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
1655 GuestNetworkInterfaceList *info;
1656 GuestIpAddressList **address_list = NULL, *address_item = NULL;
1657 char addr4[INET_ADDRSTRLEN];
1658 char addr6[INET6_ADDRSTRLEN];
1659 int sock;
1660 struct ifreq ifr;
1661 unsigned char *mac_addr;
1662 void *p;
1663
1664 g_debug("Processing %s interface", ifa->ifa_name);
1665
1666 info = guest_find_interface(head, ifa->ifa_name);
1667
1668 if (!info) {
1669 info = g_malloc0(sizeof(*info));
1670 info->value = g_malloc0(sizeof(*info->value));
1671 info->value->name = g_strdup(ifa->ifa_name);
1672
1673 if (!cur_item) {
1674 head = cur_item = info;
1675 } else {
1676 cur_item->next = info;
1677 cur_item = info;
1678 }
1679 }
1680
1681 if (!info->value->has_hardware_address &&
1682 ifa->ifa_flags & SIOCGIFHWADDR) {
1683 /* we haven't obtained HW address yet */
1684 sock = socket(PF_INET, SOCK_STREAM, 0);
1685 if (sock == -1) {
1686 error_setg_errno(errp, errno, "failed to create socket");
1687 goto error;
1688 }
1689
1690 memset(&ifr, 0, sizeof(ifr));
1691 pstrcpy(ifr.ifr_name, IF_NAMESIZE, info->value->name);
1692 if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) {
1693 error_setg_errno(errp, errno,
1694 "failed to get MAC address of %s",
1695 ifa->ifa_name);
1696 close(sock);
1697 goto error;
1698 }
1699
1700 close(sock);
1701 mac_addr = (unsigned char *) &ifr.ifr_hwaddr.sa_data;
1702
1703 info->value->hardware_address =
1704 g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x",
1705 (int) mac_addr[0], (int) mac_addr[1],
1706 (int) mac_addr[2], (int) mac_addr[3],
1707 (int) mac_addr[4], (int) mac_addr[5]);
1708
1709 info->value->has_hardware_address = true;
1710 }
1711
1712 if (ifa->ifa_addr &&
1713 ifa->ifa_addr->sa_family == AF_INET) {
1714 /* interface with IPv4 address */
1715 p = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
1716 if (!inet_ntop(AF_INET, p, addr4, sizeof(addr4))) {
1717 error_setg_errno(errp, errno, "inet_ntop failed");
1718 goto error;
1719 }
1720
1721 address_item = g_malloc0(sizeof(*address_item));
1722 address_item->value = g_malloc0(sizeof(*address_item->value));
1723 address_item->value->ip_address = g_strdup(addr4);
1724 address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4;
1725
1726 if (ifa->ifa_netmask) {
1727 /* Count the number of set bits in netmask.
1728 * This is safe as '1' and '0' cannot be shuffled in netmask. */
1729 p = &((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr;
1730 address_item->value->prefix = ctpop32(((uint32_t *) p)[0]);
1731 }
1732 } else if (ifa->ifa_addr &&
1733 ifa->ifa_addr->sa_family == AF_INET6) {
1734 /* interface with IPv6 address */
1735 p = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr;
1736 if (!inet_ntop(AF_INET6, p, addr6, sizeof(addr6))) {
1737 error_setg_errno(errp, errno, "inet_ntop failed");
1738 goto error;
1739 }
1740
1741 address_item = g_malloc0(sizeof(*address_item));
1742 address_item->value = g_malloc0(sizeof(*address_item->value));
1743 address_item->value->ip_address = g_strdup(addr6);
1744 address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6;
1745
1746 if (ifa->ifa_netmask) {
1747 /* Count the number of set bits in netmask.
1748 * This is safe as '1' and '0' cannot be shuffled in netmask. */
1749 p = &((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr;
1750 address_item->value->prefix =
1751 ctpop32(((uint32_t *) p)[0]) +
1752 ctpop32(((uint32_t *) p)[1]) +
1753 ctpop32(((uint32_t *) p)[2]) +
1754 ctpop32(((uint32_t *) p)[3]);
1755 }
1756 }
1757
1758 if (!address_item) {
1759 continue;
1760 }
1761
1762 address_list = &info->value->ip_addresses;
1763
1764 while (*address_list && (*address_list)->next) {
1765 address_list = &(*address_list)->next;
1766 }
1767
1768 if (!*address_list) {
1769 *address_list = address_item;
1770 } else {
1771 (*address_list)->next = address_item;
1772 }
1773
1774 info->value->has_ip_addresses = true;
1775
1776
1777 }
1778
1779 freeifaddrs(ifap);
1780 return head;
1781
1782 error:
1783 freeifaddrs(ifap);
1784 qapi_free_GuestNetworkInterfaceList(head);
1785 return NULL;
1786 }
1787
1788 #define SYSCONF_EXACT(name, errp) sysconf_exact((name), #name, (errp))
1789
1790 static long sysconf_exact(int name, const char *name_str, Error **errp)
1791 {
1792 long ret;
1793
1794 errno = 0;
1795 ret = sysconf(name);
1796 if (ret == -1) {
1797 if (errno == 0) {
1798 error_setg(errp, "sysconf(%s): value indefinite", name_str);
1799 } else {
1800 error_setg_errno(errp, errno, "sysconf(%s)", name_str);
1801 }
1802 }
1803 return ret;
1804 }
1805
1806 /* Transfer online/offline status between @vcpu and the guest system.
1807 *
1808 * On input either @errp or *@errp must be NULL.
1809 *
1810 * In system-to-@vcpu direction, the following @vcpu fields are accessed:
1811 * - R: vcpu->logical_id
1812 * - W: vcpu->online
1813 * - W: vcpu->can_offline
1814 *
1815 * In @vcpu-to-system direction, the following @vcpu fields are accessed:
1816 * - R: vcpu->logical_id
1817 * - R: vcpu->online
1818 *
1819 * Written members remain unmodified on error.
1820 */
1821 static void transfer_vcpu(GuestLogicalProcessor *vcpu, bool sys2vcpu,
1822 Error **errp)
1823 {
1824 char *dirpath;
1825 int dirfd;
1826
1827 dirpath = g_strdup_printf("/sys/devices/system/cpu/cpu%" PRId64 "/",
1828 vcpu->logical_id);
1829 dirfd = open(dirpath, O_RDONLY | O_DIRECTORY);
1830 if (dirfd == -1) {
1831 error_setg_errno(errp, errno, "open(\"%s\")", dirpath);
1832 } else {
1833 static const char fn[] = "online";
1834 int fd;
1835 int res;
1836
1837 fd = openat(dirfd, fn, sys2vcpu ? O_RDONLY : O_RDWR);
1838 if (fd == -1) {
1839 if (errno != ENOENT) {
1840 error_setg_errno(errp, errno, "open(\"%s/%s\")", dirpath, fn);
1841 } else if (sys2vcpu) {
1842 vcpu->online = true;
1843 vcpu->can_offline = false;
1844 } else if (!vcpu->online) {
1845 error_setg(errp, "logical processor #%" PRId64 " can't be "
1846 "offlined", vcpu->logical_id);
1847 } /* otherwise pretend successful re-onlining */
1848 } else {
1849 unsigned char status;
1850
1851 res = pread(fd, &status, 1, 0);
1852 if (res == -1) {
1853 error_setg_errno(errp, errno, "pread(\"%s/%s\")", dirpath, fn);
1854 } else if (res == 0) {
1855 error_setg(errp, "pread(\"%s/%s\"): unexpected EOF", dirpath,
1856 fn);
1857 } else if (sys2vcpu) {
1858 vcpu->online = (status != '0');
1859 vcpu->can_offline = true;
1860 } else if (vcpu->online != (status != '0')) {
1861 status = '0' + vcpu->online;
1862 if (pwrite(fd, &status, 1, 0) == -1) {
1863 error_setg_errno(errp, errno, "pwrite(\"%s/%s\")", dirpath,
1864 fn);
1865 }
1866 } /* otherwise pretend successful re-(on|off)-lining */
1867
1868 res = close(fd);
1869 g_assert(res == 0);
1870 }
1871
1872 res = close(dirfd);
1873 g_assert(res == 0);
1874 }
1875
1876 g_free(dirpath);
1877 }
1878
1879 GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp)
1880 {
1881 int64_t current;
1882 GuestLogicalProcessorList *head, **link;
1883 long sc_max;
1884 Error *local_err = NULL;
1885
1886 current = 0;
1887 head = NULL;
1888 link = &head;
1889 sc_max = SYSCONF_EXACT(_SC_NPROCESSORS_CONF, &local_err);
1890
1891 while (local_err == NULL && current < sc_max) {
1892 GuestLogicalProcessor *vcpu;
1893 GuestLogicalProcessorList *entry;
1894
1895 vcpu = g_malloc0(sizeof *vcpu);
1896 vcpu->logical_id = current++;
1897 vcpu->has_can_offline = true; /* lolspeak ftw */
1898 transfer_vcpu(vcpu, true, &local_err);
1899
1900 entry = g_malloc0(sizeof *entry);
1901 entry->value = vcpu;
1902
1903 *link = entry;
1904 link = &entry->next;
1905 }
1906
1907 if (local_err == NULL) {
1908 /* there's no guest with zero VCPUs */
1909 g_assert(head != NULL);
1910 return head;
1911 }
1912
1913 qapi_free_GuestLogicalProcessorList(head);
1914 error_propagate(errp, local_err);
1915 return NULL;
1916 }
1917
1918 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp)
1919 {
1920 int64_t processed;
1921 Error *local_err = NULL;
1922
1923 processed = 0;
1924 while (vcpus != NULL) {
1925 transfer_vcpu(vcpus->value, false, &local_err);
1926 if (local_err != NULL) {
1927 break;
1928 }
1929 ++processed;
1930 vcpus = vcpus->next;
1931 }
1932
1933 if (local_err != NULL) {
1934 if (processed == 0) {
1935 error_propagate(errp, local_err);
1936 } else {
1937 error_free(local_err);
1938 }
1939 }
1940
1941 return processed;
1942 }
1943
1944 void qmp_guest_set_user_password(const char *username,
1945 const char *password,
1946 bool crypted,
1947 Error **errp)
1948 {
1949 Error *local_err = NULL;
1950 char *passwd_path = NULL;
1951 pid_t pid;
1952 int status;
1953 int datafd[2] = { -1, -1 };
1954 char *rawpasswddata = NULL;
1955 size_t rawpasswdlen;
1956 char *chpasswddata = NULL;
1957 size_t chpasswdlen;
1958
1959 rawpasswddata = (char *)qbase64_decode(password, -1, &rawpasswdlen, errp);
1960 if (!rawpasswddata) {
1961 return;
1962 }
1963 rawpasswddata = g_renew(char, rawpasswddata, rawpasswdlen + 1);
1964 rawpasswddata[rawpasswdlen] = '\0';
1965
1966 if (strchr(rawpasswddata, '\n')) {
1967 error_setg(errp, "forbidden characters in raw password");
1968 goto out;
1969 }
1970
1971 if (strchr(username, '\n') ||
1972 strchr(username, ':')) {
1973 error_setg(errp, "forbidden characters in username");
1974 goto out;
1975 }
1976
1977 chpasswddata = g_strdup_printf("%s:%s\n", username, rawpasswddata);
1978 chpasswdlen = strlen(chpasswddata);
1979
1980 passwd_path = g_find_program_in_path("chpasswd");
1981
1982 if (!passwd_path) {
1983 error_setg(errp, "cannot find 'passwd' program in PATH");
1984 goto out;
1985 }
1986
1987 if (pipe(datafd) < 0) {
1988 error_setg(errp, "cannot create pipe FDs");
1989 goto out;
1990 }
1991
1992 pid = fork();
1993 if (pid == 0) {
1994 close(datafd[1]);
1995 /* child */
1996 setsid();
1997 dup2(datafd[0], 0);
1998 reopen_fd_to_null(1);
1999 reopen_fd_to_null(2);
2000
2001 if (crypted) {
2002 execle(passwd_path, "chpasswd", "-e", NULL, environ);
2003 } else {
2004 execle(passwd_path, "chpasswd", NULL, environ);
2005 }
2006 _exit(EXIT_FAILURE);
2007 } else if (pid < 0) {
2008 error_setg_errno(errp, errno, "failed to create child process");
2009 goto out;
2010 }
2011 close(datafd[0]);
2012 datafd[0] = -1;
2013
2014 if (qemu_write_full(datafd[1], chpasswddata, chpasswdlen) != chpasswdlen) {
2015 error_setg_errno(errp, errno, "cannot write new account password");
2016 goto out;
2017 }
2018 close(datafd[1]);
2019 datafd[1] = -1;
2020
2021 ga_wait_child(pid, &status, &local_err);
2022 if (local_err) {
2023 error_propagate(errp, local_err);
2024 goto out;
2025 }
2026
2027 if (!WIFEXITED(status)) {
2028 error_setg(errp, "child process has terminated abnormally");
2029 goto out;
2030 }
2031
2032 if (WEXITSTATUS(status)) {
2033 error_setg(errp, "child process has failed to set user password");
2034 goto out;
2035 }
2036
2037 out:
2038 g_free(chpasswddata);
2039 g_free(rawpasswddata);
2040 g_free(passwd_path);
2041 if (datafd[0] != -1) {
2042 close(datafd[0]);
2043 }
2044 if (datafd[1] != -1) {
2045 close(datafd[1]);
2046 }
2047 }
2048
2049 static void ga_read_sysfs_file(int dirfd, const char *pathname, char *buf,
2050 int size, Error **errp)
2051 {
2052 int fd;
2053 int res;
2054
2055 errno = 0;
2056 fd = openat(dirfd, pathname, O_RDONLY);
2057 if (fd == -1) {
2058 error_setg_errno(errp, errno, "open sysfs file \"%s\"", pathname);
2059 return;
2060 }
2061
2062 res = pread(fd, buf, size, 0);
2063 if (res == -1) {
2064 error_setg_errno(errp, errno, "pread sysfs file \"%s\"", pathname);
2065 } else if (res == 0) {
2066 error_setg(errp, "pread sysfs file \"%s\": unexpected EOF", pathname);
2067 }
2068 close(fd);
2069 }
2070
2071 static void ga_write_sysfs_file(int dirfd, const char *pathname,
2072 const char *buf, int size, Error **errp)
2073 {
2074 int fd;
2075
2076 errno = 0;
2077 fd = openat(dirfd, pathname, O_WRONLY);
2078 if (fd == -1) {
2079 error_setg_errno(errp, errno, "open sysfs file \"%s\"", pathname);
2080 return;
2081 }
2082
2083 if (pwrite(fd, buf, size, 0) == -1) {
2084 error_setg_errno(errp, errno, "pwrite sysfs file \"%s\"", pathname);
2085 }
2086
2087 close(fd);
2088 }
2089
2090 /* Transfer online/offline status between @mem_blk and the guest system.
2091 *
2092 * On input either @errp or *@errp must be NULL.
2093 *
2094 * In system-to-@mem_blk direction, the following @mem_blk fields are accessed:
2095 * - R: mem_blk->phys_index
2096 * - W: mem_blk->online
2097 * - W: mem_blk->can_offline
2098 *
2099 * In @mem_blk-to-system direction, the following @mem_blk fields are accessed:
2100 * - R: mem_blk->phys_index
2101 * - R: mem_blk->online
2102 *- R: mem_blk->can_offline
2103 * Written members remain unmodified on error.
2104 */
2105 static void transfer_memory_block(GuestMemoryBlock *mem_blk, bool sys2memblk,
2106 GuestMemoryBlockResponse *result,
2107 Error **errp)
2108 {
2109 char *dirpath;
2110 int dirfd;
2111 char *status;
2112 Error *local_err = NULL;
2113
2114 if (!sys2memblk) {
2115 DIR *dp;
2116
2117 if (!result) {
2118 error_setg(errp, "Internal error, 'result' should not be NULL");
2119 return;
2120 }
2121 errno = 0;
2122 dp = opendir("/sys/devices/system/memory/");
2123 /* if there is no 'memory' directory in sysfs,
2124 * we think this VM does not support online/offline memory block,
2125 * any other solution?
2126 */
2127 if (!dp && errno == ENOENT) {
2128 result->response =
2129 GUEST_MEMORY_BLOCK_RESPONSE_TYPE_OPERATION_NOT_SUPPORTED;
2130 goto out1;
2131 }
2132 closedir(dp);
2133 }
2134
2135 dirpath = g_strdup_printf("/sys/devices/system/memory/memory%" PRId64 "/",
2136 mem_blk->phys_index);
2137 dirfd = open(dirpath, O_RDONLY | O_DIRECTORY);
2138 if (dirfd == -1) {
2139 if (sys2memblk) {
2140 error_setg_errno(errp, errno, "open(\"%s\")", dirpath);
2141 } else {
2142 if (errno == ENOENT) {
2143 result->response = GUEST_MEMORY_BLOCK_RESPONSE_TYPE_NOT_FOUND;
2144 } else {
2145 result->response =
2146 GUEST_MEMORY_BLOCK_RESPONSE_TYPE_OPERATION_FAILED;
2147 }
2148 }
2149 g_free(dirpath);
2150 goto out1;
2151 }
2152 g_free(dirpath);
2153
2154 status = g_malloc0(10);
2155 ga_read_sysfs_file(dirfd, "state", status, 10, &local_err);
2156 if (local_err) {
2157 /* treat with sysfs file that not exist in old kernel */
2158 if (errno == ENOENT) {
2159 error_free(local_err);
2160 if (sys2memblk) {
2161 mem_blk->online = true;
2162 mem_blk->can_offline = false;
2163 } else if (!mem_blk->online) {
2164 result->response =
2165 GUEST_MEMORY_BLOCK_RESPONSE_TYPE_OPERATION_NOT_SUPPORTED;
2166 }
2167 } else {
2168 if (sys2memblk) {
2169 error_propagate(errp, local_err);
2170 } else {
2171 result->response =
2172 GUEST_MEMORY_BLOCK_RESPONSE_TYPE_OPERATION_FAILED;
2173 }
2174 }
2175 goto out2;
2176 }
2177
2178 if (sys2memblk) {
2179 char removable = '0';
2180
2181 mem_blk->online = (strncmp(status, "online", 6) == 0);
2182
2183 ga_read_sysfs_file(dirfd, "removable", &removable, 1, &local_err);
2184 if (local_err) {
2185 /* if no 'removable' file, it doesn't support offline mem blk */
2186 if (errno == ENOENT) {
2187 error_free(local_err);
2188 mem_blk->can_offline = false;
2189 } else {
2190 error_propagate(errp, local_err);
2191 }
2192 } else {
2193 mem_blk->can_offline = (removable != '0');
2194 }
2195 } else {
2196 if (mem_blk->online != (strncmp(status, "online", 6) == 0)) {
2197 char *new_state = mem_blk->online ? g_strdup("online") :
2198 g_strdup("offline");
2199
2200 ga_write_sysfs_file(dirfd, "state", new_state, strlen(new_state),
2201 &local_err);
2202 g_free(new_state);
2203 if (local_err) {
2204 error_free(local_err);
2205 result->response =
2206 GUEST_MEMORY_BLOCK_RESPONSE_TYPE_OPERATION_FAILED;
2207 goto out2;
2208 }
2209
2210 result->response = GUEST_MEMORY_BLOCK_RESPONSE_TYPE_SUCCESS;
2211 result->has_error_code = false;
2212 } /* otherwise pretend successful re-(on|off)-lining */
2213 }
2214 g_free(status);
2215 close(dirfd);
2216 return;
2217
2218 out2:
2219 g_free(status);
2220 close(dirfd);
2221 out1:
2222 if (!sys2memblk) {
2223 result->has_error_code = true;
2224 result->error_code = errno;
2225 }
2226 }
2227
2228 GuestMemoryBlockList *qmp_guest_get_memory_blocks(Error **errp)
2229 {
2230 GuestMemoryBlockList *head, **link;
2231 Error *local_err = NULL;
2232 struct dirent *de;
2233 DIR *dp;
2234
2235 head = NULL;
2236 link = &head;
2237
2238 dp = opendir("/sys/devices/system/memory/");
2239 if (!dp) {
2240 /* it's ok if this happens to be a system that doesn't expose
2241 * memory blocks via sysfs, but otherwise we should report
2242 * an error
2243 */
2244 if (errno != ENOENT) {
2245 error_setg_errno(errp, errno, "Can't open directory"
2246 "\"/sys/devices/system/memory/\"");
2247 }
2248 return NULL;
2249 }
2250
2251 /* Note: the phys_index of memory block may be discontinuous,
2252 * this is because a memblk is the unit of the Sparse Memory design, which
2253 * allows discontinuous memory ranges (ex. NUMA), so here we should
2254 * traverse the memory block directory.
2255 */
2256 while ((de = readdir(dp)) != NULL) {
2257 GuestMemoryBlock *mem_blk;
2258 GuestMemoryBlockList *entry;
2259
2260 if ((strncmp(de->d_name, "memory", 6) != 0) ||
2261 !(de->d_type & DT_DIR)) {
2262 continue;
2263 }
2264
2265 mem_blk = g_malloc0(sizeof *mem_blk);
2266 /* The d_name is "memoryXXX", phys_index is block id, same as XXX */
2267 mem_blk->phys_index = strtoul(&de->d_name[6], NULL, 10);
2268 mem_blk->has_can_offline = true; /* lolspeak ftw */
2269 transfer_memory_block(mem_blk, true, NULL, &local_err);
2270
2271 entry = g_malloc0(sizeof *entry);
2272 entry->value = mem_blk;
2273
2274 *link = entry;
2275 link = &entry->next;
2276 }
2277
2278 closedir(dp);
2279 if (local_err == NULL) {
2280 /* there's no guest with zero memory blocks */
2281 if (head == NULL) {
2282 error_setg(errp, "guest reported zero memory blocks!");
2283 }
2284 return head;
2285 }
2286
2287 qapi_free_GuestMemoryBlockList(head);
2288 error_propagate(errp, local_err);
2289 return NULL;
2290 }
2291
2292 GuestMemoryBlockResponseList *
2293 qmp_guest_set_memory_blocks(GuestMemoryBlockList *mem_blks, Error **errp)
2294 {
2295 GuestMemoryBlockResponseList *head, **link;
2296 Error *local_err = NULL;
2297
2298 head = NULL;
2299 link = &head;
2300
2301 while (mem_blks != NULL) {
2302 GuestMemoryBlockResponse *result;
2303 GuestMemoryBlockResponseList *entry;
2304 GuestMemoryBlock *current_mem_blk = mem_blks->value;
2305
2306 result = g_malloc0(sizeof(*result));
2307 result->phys_index = current_mem_blk->phys_index;
2308 transfer_memory_block(current_mem_blk, false, result, &local_err);
2309 if (local_err) { /* should never happen */
2310 goto err;
2311 }
2312 entry = g_malloc0(sizeof *entry);
2313 entry->value = result;
2314
2315 *link = entry;
2316 link = &entry->next;
2317 mem_blks = mem_blks->next;
2318 }
2319
2320 return head;
2321 err:
2322 qapi_free_GuestMemoryBlockResponseList(head);
2323 error_propagate(errp, local_err);
2324 return NULL;
2325 }
2326
2327 GuestMemoryBlockInfo *qmp_guest_get_memory_block_info(Error **errp)
2328 {
2329 Error *local_err = NULL;
2330 char *dirpath;
2331 int dirfd;
2332 char *buf;
2333 GuestMemoryBlockInfo *info;
2334
2335 dirpath = g_strdup_printf("/sys/devices/system/memory/");
2336 dirfd = open(dirpath, O_RDONLY | O_DIRECTORY);
2337 if (dirfd == -1) {
2338 error_setg_errno(errp, errno, "open(\"%s\")", dirpath);
2339 g_free(dirpath);
2340 return NULL;
2341 }
2342 g_free(dirpath);
2343
2344 buf = g_malloc0(20);
2345 ga_read_sysfs_file(dirfd, "block_size_bytes", buf, 20, &local_err);
2346 close(dirfd);
2347 if (local_err) {
2348 g_free(buf);
2349 error_propagate(errp, local_err);
2350 return NULL;
2351 }
2352
2353 info = g_new0(GuestMemoryBlockInfo, 1);
2354 info->size = strtol(buf, NULL, 16); /* the unit is bytes */
2355
2356 g_free(buf);
2357
2358 return info;
2359 }
2360
2361 #else /* defined(__linux__) */
2362
2363 void qmp_guest_suspend_disk(Error **errp)
2364 {
2365 error_setg(errp, QERR_UNSUPPORTED);
2366 }
2367
2368 void qmp_guest_suspend_ram(Error **errp)
2369 {
2370 error_setg(errp, QERR_UNSUPPORTED);
2371 }
2372
2373 void qmp_guest_suspend_hybrid(Error **errp)
2374 {
2375 error_setg(errp, QERR_UNSUPPORTED);
2376 }
2377
2378 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
2379 {
2380 error_setg(errp, QERR_UNSUPPORTED);
2381 return NULL;
2382 }
2383
2384 GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp)
2385 {
2386 error_setg(errp, QERR_UNSUPPORTED);
2387 return NULL;
2388 }
2389
2390 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp)
2391 {
2392 error_setg(errp, QERR_UNSUPPORTED);
2393 return -1;
2394 }
2395
2396 void qmp_guest_set_user_password(const char *username,
2397 const char *password,
2398 bool crypted,
2399 Error **errp)
2400 {
2401 error_setg(errp, QERR_UNSUPPORTED);
2402 }
2403
2404 GuestMemoryBlockList *qmp_guest_get_memory_blocks(Error **errp)
2405 {
2406 error_setg(errp, QERR_UNSUPPORTED);
2407 return NULL;
2408 }
2409
2410 GuestMemoryBlockResponseList *
2411 qmp_guest_set_memory_blocks(GuestMemoryBlockList *mem_blks, Error **errp)
2412 {
2413 error_setg(errp, QERR_UNSUPPORTED);
2414 return NULL;
2415 }
2416
2417 GuestMemoryBlockInfo *qmp_guest_get_memory_block_info(Error **errp)
2418 {
2419 error_setg(errp, QERR_UNSUPPORTED);
2420 return NULL;
2421 }
2422
2423 #endif
2424
2425 #if !defined(CONFIG_FSFREEZE)
2426
2427 GuestFilesystemInfoList *qmp_guest_get_fsinfo(Error **errp)
2428 {
2429 error_setg(errp, QERR_UNSUPPORTED);
2430 return NULL;
2431 }
2432
2433 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp)
2434 {
2435 error_setg(errp, QERR_UNSUPPORTED);
2436
2437 return 0;
2438 }
2439
2440 int64_t qmp_guest_fsfreeze_freeze(Error **errp)
2441 {
2442 error_setg(errp, QERR_UNSUPPORTED);
2443
2444 return 0;
2445 }
2446
2447 int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,
2448 strList *mountpoints,
2449 Error **errp)
2450 {
2451 error_setg(errp, QERR_UNSUPPORTED);
2452
2453 return 0;
2454 }
2455
2456 int64_t qmp_guest_fsfreeze_thaw(Error **errp)
2457 {
2458 error_setg(errp, QERR_UNSUPPORTED);
2459
2460 return 0;
2461 }
2462 #endif /* CONFIG_FSFREEZE */
2463
2464 #if !defined(CONFIG_FSTRIM)
2465 GuestFilesystemTrimResponse *
2466 qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
2467 {
2468 error_setg(errp, QERR_UNSUPPORTED);
2469 return NULL;
2470 }
2471 #endif
2472
2473 /* add unsupported commands to the blacklist */
2474 GList *ga_command_blacklist_init(GList *blacklist)
2475 {
2476 #if !defined(__linux__)
2477 {
2478 const char *list[] = {
2479 "guest-suspend-disk", "guest-suspend-ram",
2480 "guest-suspend-hybrid", "guest-network-get-interfaces",
2481 "guest-get-vcpus", "guest-set-vcpus",
2482 "guest-get-memory-blocks", "guest-set-memory-blocks",
2483 "guest-get-memory-block-size", NULL};
2484 char **p = (char **)list;
2485
2486 while (*p) {
2487 blacklist = g_list_append(blacklist, g_strdup(*p++));
2488 }
2489 }
2490 #endif
2491
2492 #if !defined(CONFIG_FSFREEZE)
2493 {
2494 const char *list[] = {
2495 "guest-get-fsinfo", "guest-fsfreeze-status",
2496 "guest-fsfreeze-freeze", "guest-fsfreeze-freeze-list",
2497 "guest-fsfreeze-thaw", "guest-get-fsinfo", NULL};
2498 char **p = (char **)list;
2499
2500 while (*p) {
2501 blacklist = g_list_append(blacklist, g_strdup(*p++));
2502 }
2503 }
2504 #endif
2505
2506 #if !defined(CONFIG_FSTRIM)
2507 blacklist = g_list_append(blacklist, g_strdup("guest-fstrim"));
2508 #endif
2509
2510 return blacklist;
2511 }
2512
2513 /* register init/cleanup routines for stateful command groups */
2514 void ga_command_state_init(GAState *s, GACommandState *cs)
2515 {
2516 #if defined(CONFIG_FSFREEZE)
2517 ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup);
2518 #endif
2519 }