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