2 * QEMU Guest Agent win32-specific command implementations
4 * Copyright IBM Corp. 2012
7 * Michael Roth <mdroth@linux.vnet.ibm.com>
8 * Gal Hammer <ghammer@redhat.com>
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.
14 #include "qemu/osdep.h"
21 #ifdef CONFIG_QGA_NTDDSCSI
29 #include "qga/guest-agent-core.h"
30 #include "qga/vss-win32.h"
31 #include "qga-qmp-commands.h"
32 #include "qapi/qmp/qerror.h"
33 #include "qemu/queue.h"
34 #include "qemu/host-utils.h"
35 #include "qemu/base64.h"
37 #ifndef SHTDN_REASON_FLAG_PLANNED
38 #define SHTDN_REASON_FLAG_PLANNED 0x80000000
41 /* multiple of 100 nanoseconds elapsed between windows baseline
42 * (1/1/1601) and Unix Epoch (1/1/1970), accounting for leap years */
43 #define W32_FT_OFFSET (10000000ULL * 60 * 60 * 24 * \
44 (365 * (1970 - 1601) + \
45 (1970 - 1601) / 4 - 3))
47 #define INVALID_SET_FILE_POINTER ((DWORD)-1)
49 typedef struct GuestFileHandle
{
52 QTAILQ_ENTRY(GuestFileHandle
) next
;
56 QTAILQ_HEAD(, GuestFileHandle
) filehandles
;
57 } guest_file_state
= {
58 .filehandles
= QTAILQ_HEAD_INITIALIZER(guest_file_state
.filehandles
),
61 #define FILE_GENERIC_APPEND (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA)
63 typedef struct OpenFlags
{
66 DWORD creation_disposition
;
68 static OpenFlags guest_file_open_modes
[] = {
69 {"r", GENERIC_READ
, OPEN_EXISTING
},
70 {"rb", GENERIC_READ
, OPEN_EXISTING
},
71 {"w", GENERIC_WRITE
, CREATE_ALWAYS
},
72 {"wb", GENERIC_WRITE
, CREATE_ALWAYS
},
73 {"a", FILE_GENERIC_APPEND
, OPEN_ALWAYS
},
74 {"r+", GENERIC_WRITE
|GENERIC_READ
, OPEN_EXISTING
},
75 {"rb+", GENERIC_WRITE
|GENERIC_READ
, OPEN_EXISTING
},
76 {"r+b", GENERIC_WRITE
|GENERIC_READ
, OPEN_EXISTING
},
77 {"w+", GENERIC_WRITE
|GENERIC_READ
, CREATE_ALWAYS
},
78 {"wb+", GENERIC_WRITE
|GENERIC_READ
, CREATE_ALWAYS
},
79 {"w+b", GENERIC_WRITE
|GENERIC_READ
, CREATE_ALWAYS
},
80 {"a+", FILE_GENERIC_APPEND
|GENERIC_READ
, OPEN_ALWAYS
},
81 {"ab+", FILE_GENERIC_APPEND
|GENERIC_READ
, OPEN_ALWAYS
},
82 {"a+b", FILE_GENERIC_APPEND
|GENERIC_READ
, OPEN_ALWAYS
}
85 static OpenFlags
*find_open_flag(const char *mode_str
)
90 for (mode
= 0; mode
< ARRAY_SIZE(guest_file_open_modes
); ++mode
) {
91 OpenFlags
*flags
= guest_file_open_modes
+ mode
;
93 if (strcmp(flags
->forms
, mode_str
) == 0) {
98 error_setg(errp
, "invalid file open mode '%s'", mode_str
);
102 static int64_t guest_file_handle_add(HANDLE fh
, Error
**errp
)
104 GuestFileHandle
*gfh
;
107 handle
= ga_get_fd_handle(ga_state
, errp
);
111 gfh
= g_new0(GuestFileHandle
, 1);
114 QTAILQ_INSERT_TAIL(&guest_file_state
.filehandles
, gfh
, next
);
119 static GuestFileHandle
*guest_file_handle_find(int64_t id
, Error
**errp
)
121 GuestFileHandle
*gfh
;
122 QTAILQ_FOREACH(gfh
, &guest_file_state
.filehandles
, next
) {
127 error_setg(errp
, "handle '%" PRId64
"' has not been found", id
);
131 static void handle_set_nonblocking(HANDLE fh
)
133 DWORD file_type
, pipe_state
;
134 file_type
= GetFileType(fh
);
135 if (file_type
!= FILE_TYPE_PIPE
) {
138 /* If file_type == FILE_TYPE_PIPE, according to MSDN
139 * the specified file is socket or named pipe */
140 if (!GetNamedPipeHandleState(fh
, &pipe_state
, NULL
,
141 NULL
, NULL
, NULL
, 0)) {
144 /* The fd is named pipe fd */
145 if (pipe_state
& PIPE_NOWAIT
) {
149 pipe_state
|= PIPE_NOWAIT
;
150 SetNamedPipeHandleState(fh
, &pipe_state
, NULL
, NULL
);
153 int64_t qmp_guest_file_open(const char *path
, bool has_mode
,
154 const char *mode
, Error
**errp
)
158 HANDLE templ_file
= NULL
;
159 DWORD share_mode
= FILE_SHARE_READ
;
160 DWORD flags_and_attr
= FILE_ATTRIBUTE_NORMAL
;
161 LPSECURITY_ATTRIBUTES sa_attr
= NULL
;
162 OpenFlags
*guest_flags
;
167 slog("guest-file-open called, filepath: %s, mode: %s", path
, mode
);
168 guest_flags
= find_open_flag(mode
);
169 if (guest_flags
== NULL
) {
170 error_setg(errp
, "invalid file open mode");
174 fh
= CreateFile(path
, guest_flags
->desired_access
, share_mode
, sa_attr
,
175 guest_flags
->creation_disposition
, flags_and_attr
,
177 if (fh
== INVALID_HANDLE_VALUE
) {
178 error_setg_win32(errp
, GetLastError(), "failed to open file '%s'",
183 /* set fd non-blocking to avoid common use cases (like reading from a
184 * named pipe) from hanging the agent
186 handle_set_nonblocking(fh
);
188 fd
= guest_file_handle_add(fh
, errp
);
191 error_setg(errp
, "failed to add handle to qmp handle table");
195 slog("guest-file-open, handle: % " PRId64
, fd
);
199 void qmp_guest_file_close(int64_t handle
, Error
**errp
)
202 GuestFileHandle
*gfh
= guest_file_handle_find(handle
, errp
);
203 slog("guest-file-close called, handle: %" PRId64
, handle
);
207 ret
= CloseHandle(gfh
->fh
);
209 error_setg_win32(errp
, GetLastError(), "failed close handle");
213 QTAILQ_REMOVE(&guest_file_state
.filehandles
, gfh
, next
);
217 static void acquire_privilege(const char *name
, Error
**errp
)
220 TOKEN_PRIVILEGES priv
;
221 Error
*local_err
= NULL
;
223 if (OpenProcessToken(GetCurrentProcess(),
224 TOKEN_ADJUST_PRIVILEGES
|TOKEN_QUERY
, &token
))
226 if (!LookupPrivilegeValue(NULL
, name
, &priv
.Privileges
[0].Luid
)) {
227 error_setg(&local_err
, QERR_QGA_COMMAND_FAILED
,
228 "no luid for requested privilege");
232 priv
.PrivilegeCount
= 1;
233 priv
.Privileges
[0].Attributes
= SE_PRIVILEGE_ENABLED
;
235 if (!AdjustTokenPrivileges(token
, FALSE
, &priv
, 0, NULL
, 0)) {
236 error_setg(&local_err
, QERR_QGA_COMMAND_FAILED
,
237 "unable to acquire requested privilege");
242 error_setg(&local_err
, QERR_QGA_COMMAND_FAILED
,
243 "failed to open privilege token");
251 error_propagate(errp
, local_err
);
255 static void execute_async(DWORD
WINAPI (*func
)(LPVOID
), LPVOID opaque
,
258 Error
*local_err
= NULL
;
260 HANDLE thread
= CreateThread(NULL
, 0, func
, opaque
, 0, NULL
);
262 error_setg(&local_err
, QERR_QGA_COMMAND_FAILED
,
263 "failed to dispatch asynchronous command");
264 error_propagate(errp
, local_err
);
268 void qmp_guest_shutdown(bool has_mode
, const char *mode
, Error
**errp
)
270 Error
*local_err
= NULL
;
271 UINT shutdown_flag
= EWX_FORCE
;
273 slog("guest-shutdown called, mode: %s", mode
);
275 if (!has_mode
|| strcmp(mode
, "powerdown") == 0) {
276 shutdown_flag
|= EWX_POWEROFF
;
277 } else if (strcmp(mode
, "halt") == 0) {
278 shutdown_flag
|= EWX_SHUTDOWN
;
279 } else if (strcmp(mode
, "reboot") == 0) {
280 shutdown_flag
|= EWX_REBOOT
;
282 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "mode",
283 "halt|powerdown|reboot");
287 /* Request a shutdown privilege, but try to shut down the system
289 acquire_privilege(SE_SHUTDOWN_NAME
, &local_err
);
291 error_propagate(errp
, local_err
);
295 if (!ExitWindowsEx(shutdown_flag
, SHTDN_REASON_FLAG_PLANNED
)) {
296 slog("guest-shutdown failed: %lu", GetLastError());
297 error_setg(errp
, QERR_UNDEFINED_ERROR
);
301 GuestFileRead
*qmp_guest_file_read(int64_t handle
, bool has_count
,
302 int64_t count
, Error
**errp
)
304 GuestFileRead
*read_data
= NULL
;
309 GuestFileHandle
*gfh
= guest_file_handle_find(handle
, errp
);
315 count
= QGA_READ_COUNT_DEFAULT
;
316 } else if (count
< 0) {
317 error_setg(errp
, "value '%" PRId64
318 "' is invalid for argument count", count
);
323 buf
= g_malloc0(count
+1);
324 is_ok
= ReadFile(fh
, buf
, count
, &read_count
, NULL
);
326 error_setg_win32(errp
, GetLastError(), "failed to read file");
327 slog("guest-file-read failed, handle %" PRId64
, handle
);
330 read_data
= g_new0(GuestFileRead
, 1);
331 read_data
->count
= (size_t)read_count
;
332 read_data
->eof
= read_count
== 0;
334 if (read_count
!= 0) {
335 read_data
->buf_b64
= g_base64_encode(buf
, read_count
);
343 GuestFileWrite
*qmp_guest_file_write(int64_t handle
, const char *buf_b64
,
344 bool has_count
, int64_t count
,
347 GuestFileWrite
*write_data
= NULL
;
352 GuestFileHandle
*gfh
= guest_file_handle_find(handle
, errp
);
359 buf
= qbase64_decode(buf_b64
, -1, &buf_len
, errp
);
366 } else if (count
< 0 || count
> buf_len
) {
367 error_setg(errp
, "value '%" PRId64
368 "' is invalid for argument count", count
);
372 is_ok
= WriteFile(fh
, buf
, count
, &write_count
, NULL
);
374 error_setg_win32(errp
, GetLastError(), "failed to write to file");
375 slog("guest-file-write-failed, handle: %" PRId64
, handle
);
377 write_data
= g_new0(GuestFileWrite
, 1);
378 write_data
->count
= (size_t) write_count
;
386 GuestFileSeek
*qmp_guest_file_seek(int64_t handle
, int64_t offset
,
387 GuestFileWhence
*whence_code
,
390 GuestFileHandle
*gfh
;
391 GuestFileSeek
*seek_data
;
393 LARGE_INTEGER new_pos
, off_pos
;
394 off_pos
.QuadPart
= offset
;
399 gfh
= guest_file_handle_find(handle
, errp
);
404 /* We stupidly exposed 'whence':'int' in our qapi */
405 whence
= ga_parse_whence(whence_code
, &err
);
407 error_propagate(errp
, err
);
412 res
= SetFilePointerEx(fh
, off_pos
, &new_pos
, whence
);
414 error_setg_win32(errp
, GetLastError(), "failed to seek file");
417 seek_data
= g_new0(GuestFileSeek
, 1);
418 seek_data
->position
= new_pos
.QuadPart
;
422 void qmp_guest_file_flush(int64_t handle
, Error
**errp
)
425 GuestFileHandle
*gfh
= guest_file_handle_find(handle
, errp
);
431 if (!FlushFileBuffers(fh
)) {
432 error_setg_win32(errp
, GetLastError(), "failed to flush file");
436 #ifdef CONFIG_QGA_NTDDSCSI
438 static STORAGE_BUS_TYPE win2qemu
[] = {
439 [BusTypeUnknown
] = GUEST_DISK_BUS_TYPE_UNKNOWN
,
440 [BusTypeScsi
] = GUEST_DISK_BUS_TYPE_SCSI
,
441 [BusTypeAtapi
] = GUEST_DISK_BUS_TYPE_IDE
,
442 [BusTypeAta
] = GUEST_DISK_BUS_TYPE_IDE
,
443 [BusType1394
] = GUEST_DISK_BUS_TYPE_IEEE1394
,
444 [BusTypeSsa
] = GUEST_DISK_BUS_TYPE_SSA
,
445 [BusTypeFibre
] = GUEST_DISK_BUS_TYPE_SSA
,
446 [BusTypeUsb
] = GUEST_DISK_BUS_TYPE_USB
,
447 [BusTypeRAID
] = GUEST_DISK_BUS_TYPE_RAID
,
448 #if (_WIN32_WINNT >= 0x0600)
449 [BusTypeiScsi
] = GUEST_DISK_BUS_TYPE_ISCSI
,
450 [BusTypeSas
] = GUEST_DISK_BUS_TYPE_SAS
,
451 [BusTypeSata
] = GUEST_DISK_BUS_TYPE_SATA
,
452 [BusTypeSd
] = GUEST_DISK_BUS_TYPE_SD
,
453 [BusTypeMmc
] = GUEST_DISK_BUS_TYPE_MMC
,
455 #if (_WIN32_WINNT >= 0x0601)
456 [BusTypeVirtual
] = GUEST_DISK_BUS_TYPE_VIRTUAL
,
457 [BusTypeFileBackedVirtual
] = GUEST_DISK_BUS_TYPE_FILE_BACKED_VIRTUAL
,
461 static GuestDiskBusType
find_bus_type(STORAGE_BUS_TYPE bus
)
463 if (bus
> ARRAY_SIZE(win2qemu
) || (int)bus
< 0) {
464 return GUEST_DISK_BUS_TYPE_UNKNOWN
;
466 return win2qemu
[(int)bus
];
469 DEFINE_GUID(GUID_DEVINTERFACE_VOLUME
,
470 0x53f5630dL
, 0xb6bf, 0x11d0, 0x94, 0xf2,
471 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
473 static GuestPCIAddress
*get_pci_info(char *guid
, Error
**errp
)
476 SP_DEVINFO_DATA dev_info_data
;
479 char dev_name
[MAX_PATH
];
481 GuestPCIAddress
*pci
= NULL
;
482 char *name
= g_strdup(&guid
[4]);
484 if (!QueryDosDevice(name
, dev_name
, ARRAY_SIZE(dev_name
))) {
485 error_setg_win32(errp
, GetLastError(), "failed to get dos device name");
489 dev_info
= SetupDiGetClassDevs(&GUID_DEVINTERFACE_VOLUME
, 0, 0,
490 DIGCF_PRESENT
| DIGCF_DEVICEINTERFACE
);
491 if (dev_info
== INVALID_HANDLE_VALUE
) {
492 error_setg_win32(errp
, GetLastError(), "failed to get devices tree");
496 dev_info_data
.cbSize
= sizeof(SP_DEVINFO_DATA
);
497 for (i
= 0; SetupDiEnumDeviceInfo(dev_info
, i
, &dev_info_data
); i
++) {
498 DWORD addr
, bus
, slot
, func
, dev
, data
, size2
;
499 while (!SetupDiGetDeviceRegistryProperty(dev_info
, &dev_info_data
,
500 SPDRP_PHYSICAL_DEVICE_OBJECT_NAME
,
501 &data
, (PBYTE
)buffer
, size
,
503 size
= MAX(size
, size2
);
504 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER
) {
506 /* Double the size to avoid problems on
507 * W2k MBCS systems per KB 888609.
508 * https://support.microsoft.com/en-us/kb/259695 */
509 buffer
= g_malloc(size
* 2);
511 error_setg_win32(errp
, GetLastError(),
512 "failed to get device name");
517 if (g_strcmp0(buffer
, dev_name
)) {
521 /* There is no need to allocate buffer in the next functions. The size
522 * is known and ULONG according to
523 * https://support.microsoft.com/en-us/kb/253232
524 * https://msdn.microsoft.com/en-us/library/windows/hardware/ff543095(v=vs.85).aspx
526 if (!SetupDiGetDeviceRegistryProperty(dev_info
, &dev_info_data
,
527 SPDRP_BUSNUMBER
, &data
, (PBYTE
)&bus
, size
, NULL
)) {
531 /* The function retrieves the device's address. This value will be
532 * transformed into device function and number */
533 if (!SetupDiGetDeviceRegistryProperty(dev_info
, &dev_info_data
,
534 SPDRP_ADDRESS
, &data
, (PBYTE
)&addr
, size
, NULL
)) {
538 /* This call returns UINumber of DEVICE_CAPABILITIES structure.
539 * This number is typically a user-perceived slot number. */
540 if (!SetupDiGetDeviceRegistryProperty(dev_info
, &dev_info_data
,
541 SPDRP_UI_NUMBER
, &data
, (PBYTE
)&slot
, size
, NULL
)) {
545 /* SetupApi gives us the same information as driver with
546 * IoGetDeviceProperty. According to Microsoft
547 * https://support.microsoft.com/en-us/kb/253232
548 * FunctionNumber = (USHORT)((propertyAddress) & 0x0000FFFF);
549 * DeviceNumber = (USHORT)(((propertyAddress) >> 16) & 0x0000FFFF);
550 * SPDRP_ADDRESS is propertyAddress, so we do the same.*/
552 func
= addr
& 0x0000FFFF;
553 dev
= (addr
>> 16) & 0x0000FFFF;
554 pci
= g_malloc0(sizeof(*pci
));
557 pci
->function
= func
;
567 static int get_disk_bus_type(HANDLE vol_h
, Error
**errp
)
569 STORAGE_PROPERTY_QUERY query
;
570 STORAGE_DEVICE_DESCRIPTOR
*dev_desc
, buf
;
574 dev_desc
->Size
= sizeof(buf
);
575 query
.PropertyId
= StorageDeviceProperty
;
576 query
.QueryType
= PropertyStandardQuery
;
578 if (!DeviceIoControl(vol_h
, IOCTL_STORAGE_QUERY_PROPERTY
, &query
,
579 sizeof(STORAGE_PROPERTY_QUERY
), dev_desc
,
580 dev_desc
->Size
, &received
, NULL
)) {
581 error_setg_win32(errp
, GetLastError(), "failed to get bus type");
585 return dev_desc
->BusType
;
588 /* VSS provider works with volumes, thus there is no difference if
589 * the volume consist of spanned disks. Info about the first disk in the
590 * volume is returned for the spanned disk group (LVM) */
591 static GuestDiskAddressList
*build_guest_disk_info(char *guid
, Error
**errp
)
593 GuestDiskAddressList
*list
= NULL
;
594 GuestDiskAddress
*disk
;
595 SCSI_ADDRESS addr
, *scsi_ad
;
601 char *name
= g_strndup(guid
, strlen(guid
)-1);
603 vol_h
= CreateFile(name
, 0, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
,
605 if (vol_h
== INVALID_HANDLE_VALUE
) {
606 error_setg_win32(errp
, GetLastError(), "failed to open volume");
610 bus
= get_disk_bus_type(vol_h
, errp
);
615 disk
= g_malloc0(sizeof(*disk
));
616 disk
->bus_type
= find_bus_type(bus
);
617 if (bus
== BusTypeScsi
|| bus
== BusTypeAta
|| bus
== BusTypeRAID
618 #if (_WIN32_WINNT >= 0x0600)
619 /* This bus type is not supported before Windows Server 2003 SP1 */
623 /* We are able to use the same ioctls for different bus types
624 * according to Microsoft docs
625 * https://technet.microsoft.com/en-us/library/ee851589(v=ws.10).aspx */
626 if (DeviceIoControl(vol_h
, IOCTL_SCSI_GET_ADDRESS
, NULL
, 0, scsi_ad
,
627 sizeof(SCSI_ADDRESS
), &len
, NULL
)) {
628 disk
->unit
= addr
.Lun
;
629 disk
->target
= addr
.TargetId
;
630 disk
->bus
= addr
.PathId
;
631 disk
->pci_controller
= get_pci_info(name
, errp
);
633 /* We do not set error in this case, because we still have enough
634 * information about volume. */
636 disk
->pci_controller
= NULL
;
639 list
= g_malloc0(sizeof(*list
));
651 static GuestDiskAddressList
*build_guest_disk_info(char *guid
, Error
**errp
)
656 #endif /* CONFIG_QGA_NTDDSCSI */
658 static GuestFilesystemInfo
*build_guest_fsinfo(char *guid
, Error
**errp
)
661 char mnt
, *mnt_point
;
663 char vol_info
[MAX_PATH
+1];
665 GuestFilesystemInfo
*fs
= NULL
;
667 GetVolumePathNamesForVolumeName(guid
, (LPCH
)&mnt
, 0, &info_size
);
668 if (GetLastError() != ERROR_MORE_DATA
) {
669 error_setg_win32(errp
, GetLastError(), "failed to get volume name");
673 mnt_point
= g_malloc(info_size
+ 1);
674 if (!GetVolumePathNamesForVolumeName(guid
, mnt_point
, info_size
,
676 error_setg_win32(errp
, GetLastError(), "failed to get volume name");
680 len
= strlen(mnt_point
);
681 mnt_point
[len
] = '\\';
682 mnt_point
[len
+1] = 0;
683 if (!GetVolumeInformation(mnt_point
, vol_info
, sizeof(vol_info
), NULL
, NULL
,
684 NULL
, (LPSTR
)&fs_name
, sizeof(fs_name
))) {
685 if (GetLastError() != ERROR_NOT_READY
) {
686 error_setg_win32(errp
, GetLastError(), "failed to get volume info");
691 fs_name
[sizeof(fs_name
) - 1] = 0;
692 fs
= g_malloc(sizeof(*fs
));
693 fs
->name
= g_strdup(guid
);
695 fs
->mountpoint
= g_strdup("System Reserved");
697 fs
->mountpoint
= g_strndup(mnt_point
, len
);
699 fs
->type
= g_strdup(fs_name
);
700 fs
->disk
= build_guest_disk_info(guid
, errp
);
706 GuestFilesystemInfoList
*qmp_guest_get_fsinfo(Error
**errp
)
709 GuestFilesystemInfoList
*new, *ret
= NULL
;
712 vol_h
= FindFirstVolume(guid
, sizeof(guid
));
713 if (vol_h
== INVALID_HANDLE_VALUE
) {
714 error_setg_win32(errp
, GetLastError(), "failed to find any volume");
719 GuestFilesystemInfo
*info
= build_guest_fsinfo(guid
, errp
);
723 new = g_malloc(sizeof(*ret
));
727 } while (FindNextVolume(vol_h
, guid
, sizeof(guid
)));
729 if (GetLastError() != ERROR_NO_MORE_FILES
) {
730 error_setg_win32(errp
, GetLastError(), "failed to find next volume");
733 FindVolumeClose(vol_h
);
738 * Return status of freeze/thaw
740 GuestFsfreezeStatus
qmp_guest_fsfreeze_status(Error
**errp
)
742 if (!vss_initialized()) {
743 error_setg(errp
, QERR_UNSUPPORTED
);
747 if (ga_is_frozen(ga_state
)) {
748 return GUEST_FSFREEZE_STATUS_FROZEN
;
751 return GUEST_FSFREEZE_STATUS_THAWED
;
755 * Freeze local file systems using Volume Shadow-copy Service.
756 * The frozen state is limited for up to 10 seconds by VSS.
758 int64_t qmp_guest_fsfreeze_freeze(Error
**errp
)
761 Error
*local_err
= NULL
;
763 if (!vss_initialized()) {
764 error_setg(errp
, QERR_UNSUPPORTED
);
768 slog("guest-fsfreeze called");
770 /* cannot risk guest agent blocking itself on a write in this state */
771 ga_set_frozen(ga_state
);
773 qga_vss_fsfreeze(&i
, &local_err
, true);
775 error_propagate(errp
, local_err
);
783 qmp_guest_fsfreeze_thaw(&local_err
);
785 g_debug("cleanup thaw: %s", error_get_pretty(local_err
));
786 error_free(local_err
);
791 int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints
,
792 strList
*mountpoints
,
795 error_setg(errp
, QERR_UNSUPPORTED
);
801 * Thaw local file systems using Volume Shadow-copy Service.
803 int64_t qmp_guest_fsfreeze_thaw(Error
**errp
)
807 if (!vss_initialized()) {
808 error_setg(errp
, QERR_UNSUPPORTED
);
812 qga_vss_fsfreeze(&i
, errp
, false);
814 ga_unset_frozen(ga_state
);
818 static void guest_fsfreeze_cleanup(void)
822 if (!vss_initialized()) {
826 if (ga_is_frozen(ga_state
) == GUEST_FSFREEZE_STATUS_FROZEN
) {
827 qmp_guest_fsfreeze_thaw(&err
);
829 slog("failed to clean up frozen filesystems: %s",
830 error_get_pretty(err
));
839 * Walk list of mounted file systems in the guest, and discard unused
842 GuestFilesystemTrimResponse
*
843 qmp_guest_fstrim(bool has_minimum
, int64_t minimum
, Error
**errp
)
845 error_setg(errp
, QERR_UNSUPPORTED
);
850 GUEST_SUSPEND_MODE_DISK
,
851 GUEST_SUSPEND_MODE_RAM
854 static void check_suspend_mode(GuestSuspendMode mode
, Error
**errp
)
856 SYSTEM_POWER_CAPABILITIES sys_pwr_caps
;
857 Error
*local_err
= NULL
;
859 ZeroMemory(&sys_pwr_caps
, sizeof(sys_pwr_caps
));
860 if (!GetPwrCapabilities(&sys_pwr_caps
)) {
861 error_setg(&local_err
, QERR_QGA_COMMAND_FAILED
,
862 "failed to determine guest suspend capabilities");
867 case GUEST_SUSPEND_MODE_DISK
:
868 if (!sys_pwr_caps
.SystemS4
) {
869 error_setg(&local_err
, QERR_QGA_COMMAND_FAILED
,
870 "suspend-to-disk not supported by OS");
873 case GUEST_SUSPEND_MODE_RAM
:
874 if (!sys_pwr_caps
.SystemS3
) {
875 error_setg(&local_err
, QERR_QGA_COMMAND_FAILED
,
876 "suspend-to-ram not supported by OS");
880 error_setg(&local_err
, QERR_INVALID_PARAMETER_VALUE
, "mode",
886 error_propagate(errp
, local_err
);
890 static DWORD WINAPI
do_suspend(LPVOID opaque
)
892 GuestSuspendMode
*mode
= opaque
;
895 if (!SetSuspendState(*mode
== GUEST_SUSPEND_MODE_DISK
, TRUE
, TRUE
)) {
896 slog("failed to suspend guest, %lu", GetLastError());
903 void qmp_guest_suspend_disk(Error
**errp
)
905 Error
*local_err
= NULL
;
906 GuestSuspendMode
*mode
= g_new(GuestSuspendMode
, 1);
908 *mode
= GUEST_SUSPEND_MODE_DISK
;
909 check_suspend_mode(*mode
, &local_err
);
910 acquire_privilege(SE_SHUTDOWN_NAME
, &local_err
);
911 execute_async(do_suspend
, mode
, &local_err
);
914 error_propagate(errp
, local_err
);
919 void qmp_guest_suspend_ram(Error
**errp
)
921 Error
*local_err
= NULL
;
922 GuestSuspendMode
*mode
= g_new(GuestSuspendMode
, 1);
924 *mode
= GUEST_SUSPEND_MODE_RAM
;
925 check_suspend_mode(*mode
, &local_err
);
926 acquire_privilege(SE_SHUTDOWN_NAME
, &local_err
);
927 execute_async(do_suspend
, mode
, &local_err
);
930 error_propagate(errp
, local_err
);
935 void qmp_guest_suspend_hybrid(Error
**errp
)
937 error_setg(errp
, QERR_UNSUPPORTED
);
940 static IP_ADAPTER_ADDRESSES
*guest_get_adapters_addresses(Error
**errp
)
942 IP_ADAPTER_ADDRESSES
*adptr_addrs
= NULL
;
943 ULONG adptr_addrs_len
= 0;
946 /* Call the first time to get the adptr_addrs_len. */
947 GetAdaptersAddresses(AF_UNSPEC
, GAA_FLAG_INCLUDE_PREFIX
,
948 NULL
, adptr_addrs
, &adptr_addrs_len
);
950 adptr_addrs
= g_malloc(adptr_addrs_len
);
951 ret
= GetAdaptersAddresses(AF_UNSPEC
, GAA_FLAG_INCLUDE_PREFIX
,
952 NULL
, adptr_addrs
, &adptr_addrs_len
);
953 if (ret
!= ERROR_SUCCESS
) {
954 error_setg_win32(errp
, ret
, "failed to get adapters addresses");
961 static char *guest_wctomb_dup(WCHAR
*wstr
)
966 i
= wcslen(wstr
) + 1;
968 WideCharToMultiByte(CP_ACP
, WC_COMPOSITECHECK
,
969 wstr
, -1, str
, i
, NULL
, NULL
);
973 static char *guest_addr_to_str(IP_ADAPTER_UNICAST_ADDRESS
*ip_addr
,
976 char addr_str
[INET6_ADDRSTRLEN
+ INET_ADDRSTRLEN
];
980 if (ip_addr
->Address
.lpSockaddr
->sa_family
== AF_INET
||
981 ip_addr
->Address
.lpSockaddr
->sa_family
== AF_INET6
) {
982 len
= sizeof(addr_str
);
983 ret
= WSAAddressToString(ip_addr
->Address
.lpSockaddr
,
984 ip_addr
->Address
.iSockaddrLength
,
989 error_setg_win32(errp
, WSAGetLastError(),
990 "failed address presentation form conversion");
993 return g_strdup(addr_str
);
998 #if (_WIN32_WINNT >= 0x0600)
999 static int64_t guest_ip_prefix(IP_ADAPTER_UNICAST_ADDRESS
*ip_addr
)
1001 /* For Windows Vista/2008 and newer, use the OnLinkPrefixLength
1002 * field to obtain the prefix.
1004 return ip_addr
->OnLinkPrefixLength
;
1007 /* When using the Windows XP and 2003 build environment, do the best we can to
1008 * figure out the prefix.
1010 static IP_ADAPTER_INFO
*guest_get_adapters_info(void)
1012 IP_ADAPTER_INFO
*adptr_info
= NULL
;
1013 ULONG adptr_info_len
= 0;
1016 /* Call the first time to get the adptr_info_len. */
1017 GetAdaptersInfo(adptr_info
, &adptr_info_len
);
1019 adptr_info
= g_malloc(adptr_info_len
);
1020 ret
= GetAdaptersInfo(adptr_info
, &adptr_info_len
);
1021 if (ret
!= ERROR_SUCCESS
) {
1028 static int64_t guest_ip_prefix(IP_ADAPTER_UNICAST_ADDRESS
*ip_addr
)
1030 int64_t prefix
= -1; /* Use for AF_INET6 and unknown/undetermined values. */
1031 IP_ADAPTER_INFO
*adptr_info
, *info
;
1035 if (ip_addr
->Address
.lpSockaddr
->sa_family
!= AF_INET
) {
1038 adptr_info
= guest_get_adapters_info();
1039 if (adptr_info
== NULL
) {
1043 /* Match up the passed in ip_addr with one found in adaptr_info.
1044 * The matching one in adptr_info will have the netmask.
1046 p
= &((struct sockaddr_in
*)ip_addr
->Address
.lpSockaddr
)->sin_addr
;
1047 for (info
= adptr_info
; info
; info
= info
->Next
) {
1048 for (ip
= &info
->IpAddressList
; ip
; ip
= ip
->Next
) {
1049 if (p
->S_un
.S_addr
== inet_addr(ip
->IpAddress
.String
)) {
1050 prefix
= ctpop32(inet_addr(ip
->IpMask
.String
));
1061 GuestNetworkInterfaceList
*qmp_guest_network_get_interfaces(Error
**errp
)
1063 IP_ADAPTER_ADDRESSES
*adptr_addrs
, *addr
;
1064 IP_ADAPTER_UNICAST_ADDRESS
*ip_addr
= NULL
;
1065 GuestNetworkInterfaceList
*head
= NULL
, *cur_item
= NULL
;
1066 GuestIpAddressList
*head_addr
, *cur_addr
;
1067 GuestNetworkInterfaceList
*info
;
1068 GuestIpAddressList
*address_item
= NULL
;
1069 unsigned char *mac_addr
;
1075 adptr_addrs
= guest_get_adapters_addresses(errp
);
1076 if (adptr_addrs
== NULL
) {
1080 /* Make WSA APIs available. */
1081 wsa_version
= MAKEWORD(2, 2);
1082 ret
= WSAStartup(wsa_version
, &wsa_data
);
1084 error_setg_win32(errp
, ret
, "failed socket startup");
1088 for (addr
= adptr_addrs
; addr
; addr
= addr
->Next
) {
1089 info
= g_malloc0(sizeof(*info
));
1091 if (cur_item
== NULL
) {
1092 head
= cur_item
= info
;
1094 cur_item
->next
= info
;
1098 info
->value
= g_malloc0(sizeof(*info
->value
));
1099 info
->value
->name
= guest_wctomb_dup(addr
->FriendlyName
);
1101 if (addr
->PhysicalAddressLength
!= 0) {
1102 mac_addr
= addr
->PhysicalAddress
;
1104 info
->value
->hardware_address
=
1105 g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x",
1106 (int) mac_addr
[0], (int) mac_addr
[1],
1107 (int) mac_addr
[2], (int) mac_addr
[3],
1108 (int) mac_addr
[4], (int) mac_addr
[5]);
1110 info
->value
->has_hardware_address
= true;
1115 for (ip_addr
= addr
->FirstUnicastAddress
;
1117 ip_addr
= ip_addr
->Next
) {
1118 addr_str
= guest_addr_to_str(ip_addr
, errp
);
1119 if (addr_str
== NULL
) {
1123 address_item
= g_malloc0(sizeof(*address_item
));
1126 head_addr
= cur_addr
= address_item
;
1128 cur_addr
->next
= address_item
;
1129 cur_addr
= address_item
;
1132 address_item
->value
= g_malloc0(sizeof(*address_item
->value
));
1133 address_item
->value
->ip_address
= addr_str
;
1134 address_item
->value
->prefix
= guest_ip_prefix(ip_addr
);
1135 if (ip_addr
->Address
.lpSockaddr
->sa_family
== AF_INET
) {
1136 address_item
->value
->ip_address_type
=
1137 GUEST_IP_ADDRESS_TYPE_IPV4
;
1138 } else if (ip_addr
->Address
.lpSockaddr
->sa_family
== AF_INET6
) {
1139 address_item
->value
->ip_address_type
=
1140 GUEST_IP_ADDRESS_TYPE_IPV6
;
1144 info
->value
->has_ip_addresses
= true;
1145 info
->value
->ip_addresses
= head_addr
;
1150 g_free(adptr_addrs
);
1154 int64_t qmp_guest_get_time(Error
**errp
)
1156 SYSTEMTIME ts
= {0};
1161 if (ts
.wYear
< 1601 || ts
.wYear
> 30827) {
1162 error_setg(errp
, "Failed to get time");
1166 if (!SystemTimeToFileTime(&ts
, &tf
)) {
1167 error_setg(errp
, "Failed to convert system time: %d", (int)GetLastError());
1171 time_ns
= ((((int64_t)tf
.dwHighDateTime
<< 32) | tf
.dwLowDateTime
)
1172 - W32_FT_OFFSET
) * 100;
1177 void qmp_guest_set_time(bool has_time
, int64_t time_ns
, Error
**errp
)
1179 Error
*local_err
= NULL
;
1185 /* Unfortunately, Windows libraries don't provide an easy way to access
1188 * https://msdn.microsoft.com/en-us/library/aa908981.aspx
1190 error_setg(errp
, "Time argument is required on this platform");
1194 /* Validate time passed by user. */
1195 if (time_ns
< 0 || time_ns
/ 100 > INT64_MAX
- W32_FT_OFFSET
) {
1196 error_setg(errp
, "Time %" PRId64
"is invalid", time_ns
);
1200 time
= time_ns
/ 100 + W32_FT_OFFSET
;
1202 tf
.dwLowDateTime
= (DWORD
) time
;
1203 tf
.dwHighDateTime
= (DWORD
) (time
>> 32);
1205 if (!FileTimeToSystemTime(&tf
, &ts
)) {
1206 error_setg(errp
, "Failed to convert system time %d",
1207 (int)GetLastError());
1211 acquire_privilege(SE_SYSTEMTIME_NAME
, &local_err
);
1213 error_propagate(errp
, local_err
);
1217 if (!SetSystemTime(&ts
)) {
1218 error_setg(errp
, "Failed to set time to guest: %d", (int)GetLastError());
1223 GuestLogicalProcessorList
*qmp_guest_get_vcpus(Error
**errp
)
1225 PSYSTEM_LOGICAL_PROCESSOR_INFORMATION pslpi
, ptr
;
1227 GuestLogicalProcessorList
*head
, **link
;
1228 Error
*local_err
= NULL
;
1237 if ((GetLogicalProcessorInformation(pslpi
, &length
) == FALSE
) &&
1238 (GetLastError() == ERROR_INSUFFICIENT_BUFFER
) &&
1239 (length
> sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION
))) {
1240 ptr
= pslpi
= g_malloc0(length
);
1241 if (GetLogicalProcessorInformation(pslpi
, &length
) == FALSE
) {
1242 error_setg(&local_err
, "Failed to get processor information: %d",
1243 (int)GetLastError());
1246 error_setg(&local_err
,
1247 "Failed to get processor information buffer length: %d",
1248 (int)GetLastError());
1251 while ((local_err
== NULL
) && (length
> 0)) {
1252 if (pslpi
->Relationship
== RelationProcessorCore
) {
1253 ULONG_PTR cpu_bits
= pslpi
->ProcessorMask
;
1255 while (cpu_bits
> 0) {
1256 if (!!(cpu_bits
& 1)) {
1257 GuestLogicalProcessor
*vcpu
;
1258 GuestLogicalProcessorList
*entry
;
1260 vcpu
= g_malloc0(sizeof *vcpu
);
1261 vcpu
->logical_id
= current
++;
1262 vcpu
->online
= true;
1263 vcpu
->has_can_offline
= false;
1265 entry
= g_malloc0(sizeof *entry
);
1266 entry
->value
= vcpu
;
1269 link
= &entry
->next
;
1274 length
-= sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION
);
1275 pslpi
++; /* next entry */
1280 if (local_err
== NULL
) {
1284 /* there's no guest with zero VCPUs */
1285 error_setg(&local_err
, "Guest reported zero VCPUs");
1288 qapi_free_GuestLogicalProcessorList(head
);
1289 error_propagate(errp
, local_err
);
1293 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList
*vcpus
, Error
**errp
)
1295 error_setg(errp
, QERR_UNSUPPORTED
);
1300 get_net_error_message(gint error
)
1302 HMODULE module
= NULL
;
1303 gchar
*retval
= NULL
;
1304 wchar_t *msg
= NULL
;
1308 flags
= FORMAT_MESSAGE_ALLOCATE_BUFFER
|
1309 FORMAT_MESSAGE_IGNORE_INSERTS
|
1310 FORMAT_MESSAGE_FROM_SYSTEM
;
1312 if (error
>= NERR_BASE
&& error
<= MAX_NERR
) {
1313 module
= LoadLibraryExW(L
"netmsg.dll", NULL
, LOAD_LIBRARY_AS_DATAFILE
);
1315 if (module
!= NULL
) {
1316 flags
|= FORMAT_MESSAGE_FROM_HMODULE
;
1320 FormatMessageW(flags
, module
, error
, 0, (LPWSTR
)&msg
, 0, NULL
);
1323 nchars
= wcslen(msg
);
1326 msg
[nchars
- 1] == L
'\n' &&
1327 msg
[nchars
- 2] == L
'\r') {
1328 msg
[nchars
- 2] = L
'\0';
1331 retval
= g_utf16_to_utf8(msg
, -1, NULL
, NULL
, NULL
);
1336 if (module
!= NULL
) {
1337 FreeLibrary(module
);
1343 void qmp_guest_set_user_password(const char *username
,
1344 const char *password
,
1349 char *rawpasswddata
= NULL
;
1350 size_t rawpasswdlen
;
1351 wchar_t *user
= NULL
, *wpass
= NULL
;
1352 USER_INFO_1003 pi1003
= { 0, };
1353 GError
*gerr
= NULL
;
1356 error_setg(errp
, QERR_UNSUPPORTED
);
1360 rawpasswddata
= (char *)qbase64_decode(password
, -1, &rawpasswdlen
, errp
);
1361 if (!rawpasswddata
) {
1364 rawpasswddata
= g_renew(char, rawpasswddata
, rawpasswdlen
+ 1);
1365 rawpasswddata
[rawpasswdlen
] = '\0';
1367 user
= g_utf8_to_utf16(username
, -1, NULL
, NULL
, &gerr
);
1372 wpass
= g_utf8_to_utf16(rawpasswddata
, -1, NULL
, NULL
, &gerr
);
1377 pi1003
.usri1003_password
= wpass
;
1378 nas
= NetUserSetInfo(NULL
, user
,
1379 1003, (LPBYTE
)&pi1003
,
1382 if (nas
!= NERR_Success
) {
1383 gchar
*msg
= get_net_error_message(nas
);
1384 error_setg(errp
, "failed to set password: %s", msg
);
1390 error_setg(errp
, QERR_QGA_COMMAND_FAILED
, gerr
->message
);
1395 g_free(rawpasswddata
);
1398 GuestMemoryBlockList
*qmp_guest_get_memory_blocks(Error
**errp
)
1400 error_setg(errp
, QERR_UNSUPPORTED
);
1404 GuestMemoryBlockResponseList
*
1405 qmp_guest_set_memory_blocks(GuestMemoryBlockList
*mem_blks
, Error
**errp
)
1407 error_setg(errp
, QERR_UNSUPPORTED
);
1411 GuestMemoryBlockInfo
*qmp_guest_get_memory_block_info(Error
**errp
)
1413 error_setg(errp
, QERR_UNSUPPORTED
);
1417 /* add unsupported commands to the blacklist */
1418 GList
*ga_command_blacklist_init(GList
*blacklist
)
1420 const char *list_unsupported
[] = {
1421 "guest-suspend-hybrid",
1423 "guest-get-memory-blocks", "guest-set-memory-blocks",
1424 "guest-get-memory-block-size",
1425 "guest-fsfreeze-freeze-list",
1426 "guest-fstrim", NULL
};
1427 char **p
= (char **)list_unsupported
;
1430 blacklist
= g_list_append(blacklist
, g_strdup(*p
++));
1433 if (!vss_init(true)) {
1434 g_debug("vss_init failed, vss commands are going to be disabled");
1435 const char *list
[] = {
1436 "guest-get-fsinfo", "guest-fsfreeze-status",
1437 "guest-fsfreeze-freeze", "guest-fsfreeze-thaw", NULL
};
1441 blacklist
= g_list_append(blacklist
, g_strdup(*p
++));
1448 /* register init/cleanup routines for stateful command groups */
1449 void ga_command_state_init(GAState
*s
, GACommandState
*cs
)
1451 if (!vss_initialized()) {
1452 ga_command_state_add(cs
, NULL
, guest_fsfreeze_cleanup
);