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.
15 # define _WIN32_WINNT 0x0600
18 #include "qemu/osdep.h"
25 #ifdef CONFIG_QGA_NTDDSCSI
35 #include "guest-agent-core.h"
36 #include "vss-win32.h"
37 #include "qga-qapi-commands.h"
38 #include "qapi/error.h"
39 #include "qapi/qmp/qerror.h"
40 #include "qemu/queue.h"
41 #include "qemu/host-utils.h"
42 #include "qemu/base64.h"
44 #ifndef SHTDN_REASON_FLAG_PLANNED
45 #define SHTDN_REASON_FLAG_PLANNED 0x80000000
48 /* multiple of 100 nanoseconds elapsed between windows baseline
49 * (1/1/1601) and Unix Epoch (1/1/1970), accounting for leap years */
50 #define W32_FT_OFFSET (10000000ULL * 60 * 60 * 24 * \
51 (365 * (1970 - 1601) + \
52 (1970 - 1601) / 4 - 3))
54 #define INVALID_SET_FILE_POINTER ((DWORD)-1)
56 typedef struct GuestFileHandle
{
59 QTAILQ_ENTRY(GuestFileHandle
) next
;
63 QTAILQ_HEAD(, GuestFileHandle
) filehandles
;
64 } guest_file_state
= {
65 .filehandles
= QTAILQ_HEAD_INITIALIZER(guest_file_state
.filehandles
),
68 #define FILE_GENERIC_APPEND (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA)
70 typedef struct OpenFlags
{
73 DWORD creation_disposition
;
75 static OpenFlags guest_file_open_modes
[] = {
76 {"r", GENERIC_READ
, OPEN_EXISTING
},
77 {"rb", GENERIC_READ
, OPEN_EXISTING
},
78 {"w", GENERIC_WRITE
, CREATE_ALWAYS
},
79 {"wb", GENERIC_WRITE
, CREATE_ALWAYS
},
80 {"a", FILE_GENERIC_APPEND
, OPEN_ALWAYS
},
81 {"r+", GENERIC_WRITE
|GENERIC_READ
, OPEN_EXISTING
},
82 {"rb+", GENERIC_WRITE
|GENERIC_READ
, OPEN_EXISTING
},
83 {"r+b", GENERIC_WRITE
|GENERIC_READ
, OPEN_EXISTING
},
84 {"w+", GENERIC_WRITE
|GENERIC_READ
, CREATE_ALWAYS
},
85 {"wb+", GENERIC_WRITE
|GENERIC_READ
, CREATE_ALWAYS
},
86 {"w+b", GENERIC_WRITE
|GENERIC_READ
, CREATE_ALWAYS
},
87 {"a+", FILE_GENERIC_APPEND
|GENERIC_READ
, OPEN_ALWAYS
},
88 {"ab+", FILE_GENERIC_APPEND
|GENERIC_READ
, OPEN_ALWAYS
},
89 {"a+b", FILE_GENERIC_APPEND
|GENERIC_READ
, OPEN_ALWAYS
}
92 #define debug_error(msg) do { \
93 char *suffix = g_win32_error_message(GetLastError()); \
94 g_debug("%s: %s", (msg), suffix); \
98 static OpenFlags
*find_open_flag(const char *mode_str
)
103 for (mode
= 0; mode
< ARRAY_SIZE(guest_file_open_modes
); ++mode
) {
104 OpenFlags
*flags
= guest_file_open_modes
+ mode
;
106 if (strcmp(flags
->forms
, mode_str
) == 0) {
111 error_setg(errp
, "invalid file open mode '%s'", mode_str
);
115 static int64_t guest_file_handle_add(HANDLE fh
, Error
**errp
)
117 GuestFileHandle
*gfh
;
120 handle
= ga_get_fd_handle(ga_state
, errp
);
124 gfh
= g_new0(GuestFileHandle
, 1);
127 QTAILQ_INSERT_TAIL(&guest_file_state
.filehandles
, gfh
, next
);
132 static GuestFileHandle
*guest_file_handle_find(int64_t id
, Error
**errp
)
134 GuestFileHandle
*gfh
;
135 QTAILQ_FOREACH(gfh
, &guest_file_state
.filehandles
, next
) {
140 error_setg(errp
, "handle '%" PRId64
"' has not been found", id
);
144 static void handle_set_nonblocking(HANDLE fh
)
146 DWORD file_type
, pipe_state
;
147 file_type
= GetFileType(fh
);
148 if (file_type
!= FILE_TYPE_PIPE
) {
151 /* If file_type == FILE_TYPE_PIPE, according to MSDN
152 * the specified file is socket or named pipe */
153 if (!GetNamedPipeHandleState(fh
, &pipe_state
, NULL
,
154 NULL
, NULL
, NULL
, 0)) {
157 /* The fd is named pipe fd */
158 if (pipe_state
& PIPE_NOWAIT
) {
162 pipe_state
|= PIPE_NOWAIT
;
163 SetNamedPipeHandleState(fh
, &pipe_state
, NULL
, NULL
);
166 int64_t qmp_guest_file_open(const char *path
, bool has_mode
,
167 const char *mode
, Error
**errp
)
171 HANDLE templ_file
= NULL
;
172 DWORD share_mode
= FILE_SHARE_READ
;
173 DWORD flags_and_attr
= FILE_ATTRIBUTE_NORMAL
;
174 LPSECURITY_ATTRIBUTES sa_attr
= NULL
;
175 OpenFlags
*guest_flags
;
177 wchar_t *w_path
= NULL
;
182 slog("guest-file-open called, filepath: %s, mode: %s", path
, mode
);
183 guest_flags
= find_open_flag(mode
);
184 if (guest_flags
== NULL
) {
185 error_setg(errp
, "invalid file open mode");
189 w_path
= g_utf8_to_utf16(path
, -1, NULL
, NULL
, &gerr
);
194 fh
= CreateFileW(w_path
, guest_flags
->desired_access
, share_mode
, sa_attr
,
195 guest_flags
->creation_disposition
, flags_and_attr
,
197 if (fh
== INVALID_HANDLE_VALUE
) {
198 error_setg_win32(errp
, GetLastError(), "failed to open file '%s'",
203 /* set fd non-blocking to avoid common use cases (like reading from a
204 * named pipe) from hanging the agent
206 handle_set_nonblocking(fh
);
208 fd
= guest_file_handle_add(fh
, errp
);
211 error_setg(errp
, "failed to add handle to qmp handle table");
215 slog("guest-file-open, handle: % " PRId64
, fd
);
219 error_setg(errp
, QERR_QGA_COMMAND_FAILED
, gerr
->message
);
226 void qmp_guest_file_close(int64_t handle
, Error
**errp
)
229 GuestFileHandle
*gfh
= guest_file_handle_find(handle
, errp
);
230 slog("guest-file-close called, handle: %" PRId64
, handle
);
234 ret
= CloseHandle(gfh
->fh
);
236 error_setg_win32(errp
, GetLastError(), "failed close handle");
240 QTAILQ_REMOVE(&guest_file_state
.filehandles
, gfh
, next
);
244 static void acquire_privilege(const char *name
, Error
**errp
)
247 TOKEN_PRIVILEGES priv
;
248 Error
*local_err
= NULL
;
250 if (OpenProcessToken(GetCurrentProcess(),
251 TOKEN_ADJUST_PRIVILEGES
|TOKEN_QUERY
, &token
))
253 if (!LookupPrivilegeValue(NULL
, name
, &priv
.Privileges
[0].Luid
)) {
254 error_setg(&local_err
, QERR_QGA_COMMAND_FAILED
,
255 "no luid for requested privilege");
259 priv
.PrivilegeCount
= 1;
260 priv
.Privileges
[0].Attributes
= SE_PRIVILEGE_ENABLED
;
262 if (!AdjustTokenPrivileges(token
, FALSE
, &priv
, 0, NULL
, 0)) {
263 error_setg(&local_err
, QERR_QGA_COMMAND_FAILED
,
264 "unable to acquire requested privilege");
269 error_setg(&local_err
, QERR_QGA_COMMAND_FAILED
,
270 "failed to open privilege token");
277 error_propagate(errp
, local_err
);
280 static void execute_async(DWORD
WINAPI (*func
)(LPVOID
), LPVOID opaque
,
283 Error
*local_err
= NULL
;
285 HANDLE thread
= CreateThread(NULL
, 0, func
, opaque
, 0, NULL
);
287 error_setg(&local_err
, QERR_QGA_COMMAND_FAILED
,
288 "failed to dispatch asynchronous command");
289 error_propagate(errp
, local_err
);
293 void qmp_guest_shutdown(bool has_mode
, const char *mode
, Error
**errp
)
295 Error
*local_err
= NULL
;
296 UINT shutdown_flag
= EWX_FORCE
;
298 slog("guest-shutdown called, mode: %s", mode
);
300 if (!has_mode
|| strcmp(mode
, "powerdown") == 0) {
301 shutdown_flag
|= EWX_POWEROFF
;
302 } else if (strcmp(mode
, "halt") == 0) {
303 shutdown_flag
|= EWX_SHUTDOWN
;
304 } else if (strcmp(mode
, "reboot") == 0) {
305 shutdown_flag
|= EWX_REBOOT
;
307 error_setg(errp
, QERR_INVALID_PARAMETER_VALUE
, "mode",
308 "halt|powerdown|reboot");
312 /* Request a shutdown privilege, but try to shut down the system
314 acquire_privilege(SE_SHUTDOWN_NAME
, &local_err
);
316 error_propagate(errp
, local_err
);
320 if (!ExitWindowsEx(shutdown_flag
, SHTDN_REASON_FLAG_PLANNED
)) {
321 slog("guest-shutdown failed: %lu", GetLastError());
322 error_setg(errp
, QERR_UNDEFINED_ERROR
);
326 GuestFileRead
*qmp_guest_file_read(int64_t handle
, bool has_count
,
327 int64_t count
, Error
**errp
)
329 GuestFileRead
*read_data
= NULL
;
334 GuestFileHandle
*gfh
= guest_file_handle_find(handle
, errp
);
340 count
= QGA_READ_COUNT_DEFAULT
;
341 } else if (count
< 0 || count
>= UINT32_MAX
) {
342 error_setg(errp
, "value '%" PRId64
343 "' is invalid for argument count", count
);
348 buf
= g_malloc0(count
+1);
349 is_ok
= ReadFile(fh
, buf
, count
, &read_count
, NULL
);
351 error_setg_win32(errp
, GetLastError(), "failed to read file");
352 slog("guest-file-read failed, handle %" PRId64
, handle
);
355 read_data
= g_new0(GuestFileRead
, 1);
356 read_data
->count
= (size_t)read_count
;
357 read_data
->eof
= read_count
== 0;
359 if (read_count
!= 0) {
360 read_data
->buf_b64
= g_base64_encode(buf
, read_count
);
368 GuestFileWrite
*qmp_guest_file_write(int64_t handle
, const char *buf_b64
,
369 bool has_count
, int64_t count
,
372 GuestFileWrite
*write_data
= NULL
;
377 GuestFileHandle
*gfh
= guest_file_handle_find(handle
, errp
);
384 buf
= qbase64_decode(buf_b64
, -1, &buf_len
, errp
);
391 } else if (count
< 0 || count
> buf_len
) {
392 error_setg(errp
, "value '%" PRId64
393 "' is invalid for argument count", count
);
397 is_ok
= WriteFile(fh
, buf
, count
, &write_count
, NULL
);
399 error_setg_win32(errp
, GetLastError(), "failed to write to file");
400 slog("guest-file-write-failed, handle: %" PRId64
, handle
);
402 write_data
= g_new0(GuestFileWrite
, 1);
403 write_data
->count
= (size_t) write_count
;
411 GuestFileSeek
*qmp_guest_file_seek(int64_t handle
, int64_t offset
,
412 GuestFileWhence
*whence_code
,
415 GuestFileHandle
*gfh
;
416 GuestFileSeek
*seek_data
;
418 LARGE_INTEGER new_pos
, off_pos
;
419 off_pos
.QuadPart
= offset
;
424 gfh
= guest_file_handle_find(handle
, errp
);
429 /* We stupidly exposed 'whence':'int' in our qapi */
430 whence
= ga_parse_whence(whence_code
, &err
);
432 error_propagate(errp
, err
);
437 res
= SetFilePointerEx(fh
, off_pos
, &new_pos
, whence
);
439 error_setg_win32(errp
, GetLastError(), "failed to seek file");
442 seek_data
= g_new0(GuestFileSeek
, 1);
443 seek_data
->position
= new_pos
.QuadPart
;
447 void qmp_guest_file_flush(int64_t handle
, Error
**errp
)
450 GuestFileHandle
*gfh
= guest_file_handle_find(handle
, errp
);
456 if (!FlushFileBuffers(fh
)) {
457 error_setg_win32(errp
, GetLastError(), "failed to flush file");
461 #ifdef CONFIG_QGA_NTDDSCSI
463 static STORAGE_BUS_TYPE win2qemu
[] = {
464 [BusTypeUnknown
] = GUEST_DISK_BUS_TYPE_UNKNOWN
,
465 [BusTypeScsi
] = GUEST_DISK_BUS_TYPE_SCSI
,
466 [BusTypeAtapi
] = GUEST_DISK_BUS_TYPE_IDE
,
467 [BusTypeAta
] = GUEST_DISK_BUS_TYPE_IDE
,
468 [BusType1394
] = GUEST_DISK_BUS_TYPE_IEEE1394
,
469 [BusTypeSsa
] = GUEST_DISK_BUS_TYPE_SSA
,
470 [BusTypeFibre
] = GUEST_DISK_BUS_TYPE_SSA
,
471 [BusTypeUsb
] = GUEST_DISK_BUS_TYPE_USB
,
472 [BusTypeRAID
] = GUEST_DISK_BUS_TYPE_RAID
,
473 #if (_WIN32_WINNT >= 0x0600)
474 [BusTypeiScsi
] = GUEST_DISK_BUS_TYPE_ISCSI
,
475 [BusTypeSas
] = GUEST_DISK_BUS_TYPE_SAS
,
476 [BusTypeSata
] = GUEST_DISK_BUS_TYPE_SATA
,
477 [BusTypeSd
] = GUEST_DISK_BUS_TYPE_SD
,
478 [BusTypeMmc
] = GUEST_DISK_BUS_TYPE_MMC
,
480 #if (_WIN32_WINNT >= 0x0601)
481 [BusTypeVirtual
] = GUEST_DISK_BUS_TYPE_VIRTUAL
,
482 [BusTypeFileBackedVirtual
] = GUEST_DISK_BUS_TYPE_FILE_BACKED_VIRTUAL
,
486 static GuestDiskBusType
find_bus_type(STORAGE_BUS_TYPE bus
)
488 if (bus
> ARRAY_SIZE(win2qemu
) || (int)bus
< 0) {
489 return GUEST_DISK_BUS_TYPE_UNKNOWN
;
491 return win2qemu
[(int)bus
];
494 DEFINE_GUID(GUID_DEVINTERFACE_VOLUME
,
495 0x53f5630dL
, 0xb6bf, 0x11d0, 0x94, 0xf2,
496 0x00, 0xa0, 0xc9, 0x1e, 0xfb, 0x8b);
498 static GuestPCIAddress
*get_pci_info(char *guid
, Error
**errp
)
501 SP_DEVINFO_DATA dev_info_data
;
504 char dev_name
[MAX_PATH
];
506 GuestPCIAddress
*pci
= NULL
;
507 char *name
= g_strdup(&guid
[4]);
508 bool partial_pci
= false;
509 pci
= g_malloc0(sizeof(*pci
));
515 if (!QueryDosDevice(name
, dev_name
, ARRAY_SIZE(dev_name
))) {
516 error_setg_win32(errp
, GetLastError(), "failed to get dos device name");
520 dev_info
= SetupDiGetClassDevs(&GUID_DEVINTERFACE_VOLUME
, 0, 0,
521 DIGCF_PRESENT
| DIGCF_DEVICEINTERFACE
);
522 if (dev_info
== INVALID_HANDLE_VALUE
) {
523 error_setg_win32(errp
, GetLastError(), "failed to get devices tree");
527 g_debug("enumerating devices");
528 dev_info_data
.cbSize
= sizeof(SP_DEVINFO_DATA
);
529 for (i
= 0; SetupDiEnumDeviceInfo(dev_info
, i
, &dev_info_data
); i
++) {
530 DWORD addr
, bus
, slot
, data
, size2
;
532 while (!SetupDiGetDeviceRegistryProperty(dev_info
, &dev_info_data
,
533 SPDRP_PHYSICAL_DEVICE_OBJECT_NAME
,
534 &data
, (PBYTE
)buffer
, size
,
536 size
= MAX(size
, size2
);
537 if (GetLastError() == ERROR_INSUFFICIENT_BUFFER
) {
539 /* Double the size to avoid problems on
540 * W2k MBCS systems per KB 888609.
541 * https://support.microsoft.com/en-us/kb/259695 */
542 buffer
= g_malloc(size
* 2);
544 error_setg_win32(errp
, GetLastError(),
545 "failed to get device name");
550 if (g_strcmp0(buffer
, dev_name
)) {
553 g_debug("found device %s", dev_name
);
555 /* There is no need to allocate buffer in the next functions. The size
556 * is known and ULONG according to
557 * https://support.microsoft.com/en-us/kb/253232
558 * https://msdn.microsoft.com/en-us/library/windows/hardware/ff543095(v=vs.85).aspx
560 if (!SetupDiGetDeviceRegistryProperty(dev_info
, &dev_info_data
,
561 SPDRP_BUSNUMBER
, &data
, (PBYTE
)&bus
, size
, NULL
)) {
562 debug_error("failed to get bus");
567 /* The function retrieves the device's address. This value will be
568 * transformed into device function and number */
569 if (!SetupDiGetDeviceRegistryProperty(dev_info
, &dev_info_data
,
570 SPDRP_ADDRESS
, &data
, (PBYTE
)&addr
, size
, NULL
)) {
571 debug_error("failed to get address");
576 /* This call returns UINumber of DEVICE_CAPABILITIES structure.
577 * This number is typically a user-perceived slot number. */
578 if (!SetupDiGetDeviceRegistryProperty(dev_info
, &dev_info_data
,
579 SPDRP_UI_NUMBER
, &data
, (PBYTE
)&slot
, size
, NULL
)) {
580 debug_error("failed to get slot");
585 /* SetupApi gives us the same information as driver with
586 * IoGetDeviceProperty. According to Microsoft
587 * https://support.microsoft.com/en-us/kb/253232
588 * FunctionNumber = (USHORT)((propertyAddress) & 0x0000FFFF);
589 * DeviceNumber = (USHORT)(((propertyAddress) >> 16) & 0x0000FFFF);
590 * SPDRP_ADDRESS is propertyAddress, so we do the same.*/
598 func
= ((int) addr
== -1) ? -1 : addr
& 0x0000FFFF;
599 dev
= ((int) addr
== -1) ? -1 : (addr
>> 16) & 0x0000FFFF;
601 pci
->slot
= (int) slot
;
602 pci
->function
= func
;
603 pci
->bus
= (int) bus
;
609 SetupDiDestroyDeviceInfoList(dev_info
);
616 static void get_disk_properties(HANDLE vol_h
, GuestDiskAddress
*disk
,
619 STORAGE_PROPERTY_QUERY query
;
620 STORAGE_DEVICE_DESCRIPTOR
*dev_desc
, buf
;
622 ULONG size
= sizeof(buf
);
625 query
.PropertyId
= StorageDeviceProperty
;
626 query
.QueryType
= PropertyStandardQuery
;
628 if (!DeviceIoControl(vol_h
, IOCTL_STORAGE_QUERY_PROPERTY
, &query
,
629 sizeof(STORAGE_PROPERTY_QUERY
), dev_desc
,
630 size
, &received
, NULL
)) {
631 error_setg_win32(errp
, GetLastError(), "failed to get bus type");
634 disk
->bus_type
= find_bus_type(dev_desc
->BusType
);
635 g_debug("bus type %d", disk
->bus_type
);
640 /* VSS provider works with volumes, thus there is no difference if
641 * the volume consist of spanned disks. Info about the first disk in the
642 * volume is returned for the spanned disk group (LVM) */
643 static GuestDiskAddressList
*build_guest_disk_info(char *guid
, Error
**errp
)
645 GuestDiskAddressList
*list
= NULL
;
646 GuestDiskAddress
*disk
;
647 SCSI_ADDRESS addr
, *scsi_ad
;
650 Error
*local_err
= NULL
;
653 char *name
= g_strndup(guid
, strlen(guid
)-1);
655 g_debug("getting disk info for: %s", name
);
656 vol_h
= CreateFile(name
, 0, FILE_SHARE_READ
, NULL
, OPEN_EXISTING
,
658 if (vol_h
== INVALID_HANDLE_VALUE
) {
659 error_setg_win32(errp
, GetLastError(), "failed to open volume");
663 disk
= g_malloc0(sizeof(*disk
));
664 get_disk_properties(vol_h
, disk
, &local_err
);
666 error_propagate(errp
, local_err
);
670 g_debug("bus type %d", disk
->bus_type
);
671 /* always set pci_controller as required by schema. get_pci_info() should
672 * report -1 values for non-PCI buses rather than fail. fail the command
673 * if that doesn't hold since that suggests some other unexpected
676 disk
->pci_controller
= get_pci_info(name
, &local_err
);
678 error_propagate(errp
, local_err
);
681 if (disk
->bus_type
== GUEST_DISK_BUS_TYPE_SCSI
682 || disk
->bus_type
== GUEST_DISK_BUS_TYPE_IDE
683 || disk
->bus_type
== GUEST_DISK_BUS_TYPE_RAID
684 #if (_WIN32_WINNT >= 0x0600)
685 /* This bus type is not supported before Windows Server 2003 SP1 */
686 || disk
->bus_type
== GUEST_DISK_BUS_TYPE_SAS
689 /* We are able to use the same ioctls for different bus types
690 * according to Microsoft docs
691 * https://technet.microsoft.com/en-us/library/ee851589(v=ws.10).aspx */
692 g_debug("getting pci-controller info");
693 if (DeviceIoControl(vol_h
, IOCTL_SCSI_GET_ADDRESS
, NULL
, 0, scsi_ad
,
694 sizeof(SCSI_ADDRESS
), &len
, NULL
)) {
695 disk
->unit
= addr
.Lun
;
696 disk
->target
= addr
.TargetId
;
697 disk
->bus
= addr
.PathId
;
699 /* We do not set error in this case, because we still have enough
700 * information about volume. */
703 list
= g_malloc0(sizeof(*list
));
721 static GuestDiskAddressList
*build_guest_disk_info(char *guid
, Error
**errp
)
726 #endif /* CONFIG_QGA_NTDDSCSI */
728 static GuestFilesystemInfo
*build_guest_fsinfo(char *guid
, Error
**errp
)
731 char mnt
, *mnt_point
;
733 char vol_info
[MAX_PATH
+1];
735 uint64_t i64FreeBytesToCaller
, i64TotalBytes
, i64FreeBytes
;
736 GuestFilesystemInfo
*fs
= NULL
;
738 GetVolumePathNamesForVolumeName(guid
, (LPCH
)&mnt
, 0, &info_size
);
739 if (GetLastError() != ERROR_MORE_DATA
) {
740 error_setg_win32(errp
, GetLastError(), "failed to get volume name");
744 mnt_point
= g_malloc(info_size
+ 1);
745 if (!GetVolumePathNamesForVolumeName(guid
, mnt_point
, info_size
,
747 error_setg_win32(errp
, GetLastError(), "failed to get volume name");
751 len
= strlen(mnt_point
);
752 mnt_point
[len
] = '\\';
753 mnt_point
[len
+1] = 0;
754 if (!GetVolumeInformation(mnt_point
, vol_info
, sizeof(vol_info
), NULL
, NULL
,
755 NULL
, (LPSTR
)&fs_name
, sizeof(fs_name
))) {
756 if (GetLastError() != ERROR_NOT_READY
) {
757 error_setg_win32(errp
, GetLastError(), "failed to get volume info");
762 fs_name
[sizeof(fs_name
) - 1] = 0;
763 fs
= g_malloc(sizeof(*fs
));
764 fs
->name
= g_strdup(guid
);
765 fs
->has_total_bytes
= false;
766 fs
->has_used_bytes
= false;
768 fs
->mountpoint
= g_strdup("System Reserved");
770 fs
->mountpoint
= g_strndup(mnt_point
, len
);
771 if (GetDiskFreeSpaceEx(fs
->mountpoint
,
772 (PULARGE_INTEGER
) & i64FreeBytesToCaller
,
773 (PULARGE_INTEGER
) & i64TotalBytes
,
774 (PULARGE_INTEGER
) & i64FreeBytes
)) {
775 fs
->used_bytes
= i64TotalBytes
- i64FreeBytes
;
776 fs
->total_bytes
= i64TotalBytes
;
777 fs
->has_total_bytes
= true;
778 fs
->has_used_bytes
= true;
781 fs
->type
= g_strdup(fs_name
);
782 fs
->disk
= build_guest_disk_info(guid
, errp
);
788 GuestFilesystemInfoList
*qmp_guest_get_fsinfo(Error
**errp
)
791 GuestFilesystemInfoList
*new, *ret
= NULL
;
794 vol_h
= FindFirstVolume(guid
, sizeof(guid
));
795 if (vol_h
== INVALID_HANDLE_VALUE
) {
796 error_setg_win32(errp
, GetLastError(), "failed to find any volume");
801 GuestFilesystemInfo
*info
= build_guest_fsinfo(guid
, errp
);
805 new = g_malloc(sizeof(*ret
));
809 } while (FindNextVolume(vol_h
, guid
, sizeof(guid
)));
811 if (GetLastError() != ERROR_NO_MORE_FILES
) {
812 error_setg_win32(errp
, GetLastError(), "failed to find next volume");
815 FindVolumeClose(vol_h
);
820 * Return status of freeze/thaw
822 GuestFsfreezeStatus
qmp_guest_fsfreeze_status(Error
**errp
)
824 if (!vss_initialized()) {
825 error_setg(errp
, QERR_UNSUPPORTED
);
829 if (ga_is_frozen(ga_state
)) {
830 return GUEST_FSFREEZE_STATUS_FROZEN
;
833 return GUEST_FSFREEZE_STATUS_THAWED
;
837 * Freeze local file systems using Volume Shadow-copy Service.
838 * The frozen state is limited for up to 10 seconds by VSS.
840 int64_t qmp_guest_fsfreeze_freeze(Error
**errp
)
842 return qmp_guest_fsfreeze_freeze_list(false, NULL
, errp
);
845 int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints
,
846 strList
*mountpoints
,
850 Error
*local_err
= NULL
;
852 if (!vss_initialized()) {
853 error_setg(errp
, QERR_UNSUPPORTED
);
857 slog("guest-fsfreeze called");
859 /* cannot risk guest agent blocking itself on a write in this state */
860 ga_set_frozen(ga_state
);
862 qga_vss_fsfreeze(&i
, true, mountpoints
, &local_err
);
864 error_propagate(errp
, local_err
);
872 qmp_guest_fsfreeze_thaw(&local_err
);
874 g_debug("cleanup thaw: %s", error_get_pretty(local_err
));
875 error_free(local_err
);
881 * Thaw local file systems using Volume Shadow-copy Service.
883 int64_t qmp_guest_fsfreeze_thaw(Error
**errp
)
887 if (!vss_initialized()) {
888 error_setg(errp
, QERR_UNSUPPORTED
);
892 qga_vss_fsfreeze(&i
, false, NULL
, errp
);
894 ga_unset_frozen(ga_state
);
898 static void guest_fsfreeze_cleanup(void)
902 if (!vss_initialized()) {
906 if (ga_is_frozen(ga_state
) == GUEST_FSFREEZE_STATUS_FROZEN
) {
907 qmp_guest_fsfreeze_thaw(&err
);
909 slog("failed to clean up frozen filesystems: %s",
910 error_get_pretty(err
));
919 * Walk list of mounted file systems in the guest, and discard unused
922 GuestFilesystemTrimResponse
*
923 qmp_guest_fstrim(bool has_minimum
, int64_t minimum
, Error
**errp
)
925 GuestFilesystemTrimResponse
*resp
;
927 WCHAR guid
[MAX_PATH
] = L
"";
931 ZeroMemory(&osvi
, sizeof(OSVERSIONINFO
));
932 osvi
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
934 win8_or_later
= (osvi
.dwMajorVersion
> 6 ||
935 ((osvi
.dwMajorVersion
== 6) &&
936 (osvi
.dwMinorVersion
>= 2)));
937 if (!win8_or_later
) {
938 error_setg(errp
, "fstrim is only supported for Win8+");
942 handle
= FindFirstVolumeW(guid
, ARRAYSIZE(guid
));
943 if (handle
== INVALID_HANDLE_VALUE
) {
944 error_setg_win32(errp
, GetLastError(), "failed to find any volume");
948 resp
= g_new0(GuestFilesystemTrimResponse
, 1);
951 GuestFilesystemTrimResult
*res
;
952 GuestFilesystemTrimResultList
*list
;
954 DWORD char_count
= 0;
959 GetVolumePathNamesForVolumeNameW(guid
, NULL
, 0, &char_count
);
961 if (GetLastError() != ERROR_MORE_DATA
) {
964 if (GetDriveTypeW(guid
) != DRIVE_FIXED
) {
968 uc_path
= g_malloc(sizeof(WCHAR
) * char_count
);
969 if (!GetVolumePathNamesForVolumeNameW(guid
, uc_path
, char_count
,
970 &char_count
) || !*uc_path
) {
971 /* strange, but this condition could be faced even with size == 2 */
976 res
= g_new0(GuestFilesystemTrimResult
, 1);
978 path
= g_utf16_to_utf8(uc_path
, char_count
, NULL
, NULL
, &gerr
);
983 res
->has_error
= true;
984 res
->error
= g_strdup(gerr
->message
);
991 list
= g_new0(GuestFilesystemTrimResultList
, 1);
993 list
->next
= resp
->paths
;
997 memset(argv
, 0, sizeof(argv
));
998 argv
[0] = (gchar
*)"defrag.exe";
999 argv
[1] = (gchar
*)"/L";
1002 if (!g_spawn_sync(NULL
, argv
, NULL
, G_SPAWN_SEARCH_PATH
, NULL
, NULL
,
1003 &out
/* stdout */, NULL
/* stdin */,
1005 res
->has_error
= true;
1006 res
->error
= g_strdup(gerr
->message
);
1009 /* defrag.exe is UGLY. Exit code is ALWAYS zero.
1010 Error is reported in the output with something like
1011 (x89000020) etc code in the stdout */
1014 gchar
**lines
= g_strsplit(out
, "\r\n", 0);
1017 for (i
= 0; lines
[i
] != NULL
; i
++) {
1018 if (g_strstr_len(lines
[i
], -1, "(0x") == NULL
) {
1021 res
->has_error
= true;
1022 res
->error
= g_strdup(lines
[i
]);
1027 } while (FindNextVolumeW(handle
, guid
, ARRAYSIZE(guid
)));
1029 FindVolumeClose(handle
);
1034 GUEST_SUSPEND_MODE_DISK
,
1035 GUEST_SUSPEND_MODE_RAM
1038 static void check_suspend_mode(GuestSuspendMode mode
, Error
**errp
)
1040 SYSTEM_POWER_CAPABILITIES sys_pwr_caps
;
1041 Error
*local_err
= NULL
;
1043 ZeroMemory(&sys_pwr_caps
, sizeof(sys_pwr_caps
));
1044 if (!GetPwrCapabilities(&sys_pwr_caps
)) {
1045 error_setg(&local_err
, QERR_QGA_COMMAND_FAILED
,
1046 "failed to determine guest suspend capabilities");
1051 case GUEST_SUSPEND_MODE_DISK
:
1052 if (!sys_pwr_caps
.SystemS4
) {
1053 error_setg(&local_err
, QERR_QGA_COMMAND_FAILED
,
1054 "suspend-to-disk not supported by OS");
1057 case GUEST_SUSPEND_MODE_RAM
:
1058 if (!sys_pwr_caps
.SystemS3
) {
1059 error_setg(&local_err
, QERR_QGA_COMMAND_FAILED
,
1060 "suspend-to-ram not supported by OS");
1064 error_setg(&local_err
, QERR_INVALID_PARAMETER_VALUE
, "mode",
1065 "GuestSuspendMode");
1069 error_propagate(errp
, local_err
);
1072 static DWORD WINAPI
do_suspend(LPVOID opaque
)
1074 GuestSuspendMode
*mode
= opaque
;
1077 if (!SetSuspendState(*mode
== GUEST_SUSPEND_MODE_DISK
, TRUE
, TRUE
)) {
1078 slog("failed to suspend guest, %lu", GetLastError());
1085 void qmp_guest_suspend_disk(Error
**errp
)
1087 Error
*local_err
= NULL
;
1088 GuestSuspendMode
*mode
= g_new(GuestSuspendMode
, 1);
1090 *mode
= GUEST_SUSPEND_MODE_DISK
;
1091 check_suspend_mode(*mode
, &local_err
);
1092 acquire_privilege(SE_SHUTDOWN_NAME
, &local_err
);
1093 execute_async(do_suspend
, mode
, &local_err
);
1096 error_propagate(errp
, local_err
);
1101 void qmp_guest_suspend_ram(Error
**errp
)
1103 Error
*local_err
= NULL
;
1104 GuestSuspendMode
*mode
= g_new(GuestSuspendMode
, 1);
1106 *mode
= GUEST_SUSPEND_MODE_RAM
;
1107 check_suspend_mode(*mode
, &local_err
);
1108 acquire_privilege(SE_SHUTDOWN_NAME
, &local_err
);
1109 execute_async(do_suspend
, mode
, &local_err
);
1112 error_propagate(errp
, local_err
);
1117 void qmp_guest_suspend_hybrid(Error
**errp
)
1119 error_setg(errp
, QERR_UNSUPPORTED
);
1122 static IP_ADAPTER_ADDRESSES
*guest_get_adapters_addresses(Error
**errp
)
1124 IP_ADAPTER_ADDRESSES
*adptr_addrs
= NULL
;
1125 ULONG adptr_addrs_len
= 0;
1128 /* Call the first time to get the adptr_addrs_len. */
1129 GetAdaptersAddresses(AF_UNSPEC
, GAA_FLAG_INCLUDE_PREFIX
,
1130 NULL
, adptr_addrs
, &adptr_addrs_len
);
1132 adptr_addrs
= g_malloc(adptr_addrs_len
);
1133 ret
= GetAdaptersAddresses(AF_UNSPEC
, GAA_FLAG_INCLUDE_PREFIX
,
1134 NULL
, adptr_addrs
, &adptr_addrs_len
);
1135 if (ret
!= ERROR_SUCCESS
) {
1136 error_setg_win32(errp
, ret
, "failed to get adapters addresses");
1137 g_free(adptr_addrs
);
1143 static char *guest_wctomb_dup(WCHAR
*wstr
)
1148 i
= wcslen(wstr
) + 1;
1150 WideCharToMultiByte(CP_ACP
, WC_COMPOSITECHECK
,
1151 wstr
, -1, str
, i
, NULL
, NULL
);
1155 static char *guest_addr_to_str(IP_ADAPTER_UNICAST_ADDRESS
*ip_addr
,
1158 char addr_str
[INET6_ADDRSTRLEN
+ INET_ADDRSTRLEN
];
1162 if (ip_addr
->Address
.lpSockaddr
->sa_family
== AF_INET
||
1163 ip_addr
->Address
.lpSockaddr
->sa_family
== AF_INET6
) {
1164 len
= sizeof(addr_str
);
1165 ret
= WSAAddressToString(ip_addr
->Address
.lpSockaddr
,
1166 ip_addr
->Address
.iSockaddrLength
,
1171 error_setg_win32(errp
, WSAGetLastError(),
1172 "failed address presentation form conversion");
1175 return g_strdup(addr_str
);
1180 #if (_WIN32_WINNT >= 0x0600)
1181 static int64_t guest_ip_prefix(IP_ADAPTER_UNICAST_ADDRESS
*ip_addr
)
1183 /* For Windows Vista/2008 and newer, use the OnLinkPrefixLength
1184 * field to obtain the prefix.
1186 return ip_addr
->OnLinkPrefixLength
;
1189 /* When using the Windows XP and 2003 build environment, do the best we can to
1190 * figure out the prefix.
1192 static IP_ADAPTER_INFO
*guest_get_adapters_info(void)
1194 IP_ADAPTER_INFO
*adptr_info
= NULL
;
1195 ULONG adptr_info_len
= 0;
1198 /* Call the first time to get the adptr_info_len. */
1199 GetAdaptersInfo(adptr_info
, &adptr_info_len
);
1201 adptr_info
= g_malloc(adptr_info_len
);
1202 ret
= GetAdaptersInfo(adptr_info
, &adptr_info_len
);
1203 if (ret
!= ERROR_SUCCESS
) {
1210 static int64_t guest_ip_prefix(IP_ADAPTER_UNICAST_ADDRESS
*ip_addr
)
1212 int64_t prefix
= -1; /* Use for AF_INET6 and unknown/undetermined values. */
1213 IP_ADAPTER_INFO
*adptr_info
, *info
;
1217 if (ip_addr
->Address
.lpSockaddr
->sa_family
!= AF_INET
) {
1220 adptr_info
= guest_get_adapters_info();
1221 if (adptr_info
== NULL
) {
1225 /* Match up the passed in ip_addr with one found in adaptr_info.
1226 * The matching one in adptr_info will have the netmask.
1228 p
= &((struct sockaddr_in
*)ip_addr
->Address
.lpSockaddr
)->sin_addr
;
1229 for (info
= adptr_info
; info
; info
= info
->Next
) {
1230 for (ip
= &info
->IpAddressList
; ip
; ip
= ip
->Next
) {
1231 if (p
->S_un
.S_addr
== inet_addr(ip
->IpAddress
.String
)) {
1232 prefix
= ctpop32(inet_addr(ip
->IpMask
.String
));
1243 #define INTERFACE_PATH_BUF_SZ 512
1245 static DWORD
get_interface_index(const char *guid
)
1249 wchar_t wbuf
[INTERFACE_PATH_BUF_SZ
];
1250 snwprintf(wbuf
, INTERFACE_PATH_BUF_SZ
, L
"\\device\\tcpip_%s", guid
);
1251 wbuf
[INTERFACE_PATH_BUF_SZ
- 1] = 0;
1252 status
= GetAdapterIndex (wbuf
, &index
);
1253 if (status
!= NO_ERROR
) {
1260 typedef NETIOAPI_API (WINAPI
*GetIfEntry2Func
)(PMIB_IF_ROW2 Row
);
1262 static int guest_get_network_stats(const char *name
,
1263 GuestNetworkInterfaceStat
*stats
)
1265 OSVERSIONINFO os_ver
;
1267 os_ver
.dwOSVersionInfoSize
= sizeof(OSVERSIONINFO
);
1268 GetVersionEx(&os_ver
);
1269 if (os_ver
.dwMajorVersion
>= 6) {
1270 MIB_IF_ROW2 a_mid_ifrow
;
1271 GetIfEntry2Func getifentry2_ex
;
1273 HMODULE module
= GetModuleHandle("iphlpapi");
1274 PVOID func
= GetProcAddress(module
, "GetIfEntry2");
1280 getifentry2_ex
= (GetIfEntry2Func
)func
;
1281 if_index
= get_interface_index(name
);
1282 if (if_index
== (DWORD
)~0) {
1286 memset(&a_mid_ifrow
, 0, sizeof(a_mid_ifrow
));
1287 a_mid_ifrow
.InterfaceIndex
= if_index
;
1288 if (NO_ERROR
== getifentry2_ex(&a_mid_ifrow
)) {
1289 stats
->rx_bytes
= a_mid_ifrow
.InOctets
;
1290 stats
->rx_packets
= a_mid_ifrow
.InUcastPkts
;
1291 stats
->rx_errs
= a_mid_ifrow
.InErrors
;
1292 stats
->rx_dropped
= a_mid_ifrow
.InDiscards
;
1293 stats
->tx_bytes
= a_mid_ifrow
.OutOctets
;
1294 stats
->tx_packets
= a_mid_ifrow
.OutUcastPkts
;
1295 stats
->tx_errs
= a_mid_ifrow
.OutErrors
;
1296 stats
->tx_dropped
= a_mid_ifrow
.OutDiscards
;
1303 GuestNetworkInterfaceList
*qmp_guest_network_get_interfaces(Error
**errp
)
1305 IP_ADAPTER_ADDRESSES
*adptr_addrs
, *addr
;
1306 IP_ADAPTER_UNICAST_ADDRESS
*ip_addr
= NULL
;
1307 GuestNetworkInterfaceList
*head
= NULL
, *cur_item
= NULL
;
1308 GuestIpAddressList
*head_addr
, *cur_addr
;
1309 GuestNetworkInterfaceList
*info
;
1310 GuestNetworkInterfaceStat
*interface_stat
= NULL
;
1311 GuestIpAddressList
*address_item
= NULL
;
1312 unsigned char *mac_addr
;
1318 adptr_addrs
= guest_get_adapters_addresses(errp
);
1319 if (adptr_addrs
== NULL
) {
1323 /* Make WSA APIs available. */
1324 wsa_version
= MAKEWORD(2, 2);
1325 ret
= WSAStartup(wsa_version
, &wsa_data
);
1327 error_setg_win32(errp
, ret
, "failed socket startup");
1331 for (addr
= adptr_addrs
; addr
; addr
= addr
->Next
) {
1332 info
= g_malloc0(sizeof(*info
));
1334 if (cur_item
== NULL
) {
1335 head
= cur_item
= info
;
1337 cur_item
->next
= info
;
1341 info
->value
= g_malloc0(sizeof(*info
->value
));
1342 info
->value
->name
= guest_wctomb_dup(addr
->FriendlyName
);
1344 if (addr
->PhysicalAddressLength
!= 0) {
1345 mac_addr
= addr
->PhysicalAddress
;
1347 info
->value
->hardware_address
=
1348 g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x",
1349 (int) mac_addr
[0], (int) mac_addr
[1],
1350 (int) mac_addr
[2], (int) mac_addr
[3],
1351 (int) mac_addr
[4], (int) mac_addr
[5]);
1353 info
->value
->has_hardware_address
= true;
1358 for (ip_addr
= addr
->FirstUnicastAddress
;
1360 ip_addr
= ip_addr
->Next
) {
1361 addr_str
= guest_addr_to_str(ip_addr
, errp
);
1362 if (addr_str
== NULL
) {
1366 address_item
= g_malloc0(sizeof(*address_item
));
1369 head_addr
= cur_addr
= address_item
;
1371 cur_addr
->next
= address_item
;
1372 cur_addr
= address_item
;
1375 address_item
->value
= g_malloc0(sizeof(*address_item
->value
));
1376 address_item
->value
->ip_address
= addr_str
;
1377 address_item
->value
->prefix
= guest_ip_prefix(ip_addr
);
1378 if (ip_addr
->Address
.lpSockaddr
->sa_family
== AF_INET
) {
1379 address_item
->value
->ip_address_type
=
1380 GUEST_IP_ADDRESS_TYPE_IPV4
;
1381 } else if (ip_addr
->Address
.lpSockaddr
->sa_family
== AF_INET6
) {
1382 address_item
->value
->ip_address_type
=
1383 GUEST_IP_ADDRESS_TYPE_IPV6
;
1387 info
->value
->has_ip_addresses
= true;
1388 info
->value
->ip_addresses
= head_addr
;
1390 if (!info
->value
->has_statistics
) {
1391 interface_stat
= g_malloc0(sizeof(*interface_stat
));
1392 if (guest_get_network_stats(addr
->AdapterName
,
1393 interface_stat
) == -1) {
1394 info
->value
->has_statistics
= false;
1395 g_free(interface_stat
);
1397 info
->value
->statistics
= interface_stat
;
1398 info
->value
->has_statistics
= true;
1404 g_free(adptr_addrs
);
1408 int64_t qmp_guest_get_time(Error
**errp
)
1410 SYSTEMTIME ts
= {0};
1414 if (ts
.wYear
< 1601 || ts
.wYear
> 30827) {
1415 error_setg(errp
, "Failed to get time");
1419 if (!SystemTimeToFileTime(&ts
, &tf
)) {
1420 error_setg(errp
, "Failed to convert system time: %d", (int)GetLastError());
1424 return ((((int64_t)tf
.dwHighDateTime
<< 32) | tf
.dwLowDateTime
)
1425 - W32_FT_OFFSET
) * 100;
1428 void qmp_guest_set_time(bool has_time
, int64_t time_ns
, Error
**errp
)
1430 Error
*local_err
= NULL
;
1436 /* Unfortunately, Windows libraries don't provide an easy way to access
1439 * https://msdn.microsoft.com/en-us/library/aa908981.aspx
1441 * Instead, a workaround is to use the Windows win32tm command to
1442 * resync the time using the Windows Time service.
1447 HRESULT hr
= system("w32tm /resync /nowait");
1449 if (GetLastError() != 0) {
1450 strerror_s((LPTSTR
) & msg_buffer
, 0, errno
);
1451 error_setg(errp
, "system(...) failed: %s", (LPCTSTR
)msg_buffer
);
1452 } else if (hr
!= 0) {
1453 if (hr
== HRESULT_FROM_WIN32(ERROR_SERVICE_NOT_ACTIVE
)) {
1454 error_setg(errp
, "Windows Time service not running on the "
1457 if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
|
1458 FORMAT_MESSAGE_FROM_SYSTEM
|
1459 FORMAT_MESSAGE_IGNORE_INSERTS
, NULL
,
1460 (DWORD
)hr
, MAKELANGID(LANG_NEUTRAL
,
1461 SUBLANG_DEFAULT
), (LPTSTR
) & msg_buffer
, 0,
1463 error_setg(errp
, "w32tm failed with error (0x%lx), couldn'"
1464 "t retrieve error message", hr
);
1466 error_setg(errp
, "w32tm failed with error (0x%lx): %s", hr
,
1467 (LPCTSTR
)msg_buffer
);
1468 LocalFree(msg_buffer
);
1471 } else if (!InternetGetConnectedState(&ret_flags
, 0)) {
1472 error_setg(errp
, "No internet connection on guest, sync not "
1478 /* Validate time passed by user. */
1479 if (time_ns
< 0 || time_ns
/ 100 > INT64_MAX
- W32_FT_OFFSET
) {
1480 error_setg(errp
, "Time %" PRId64
"is invalid", time_ns
);
1484 time
= time_ns
/ 100 + W32_FT_OFFSET
;
1486 tf
.dwLowDateTime
= (DWORD
) time
;
1487 tf
.dwHighDateTime
= (DWORD
) (time
>> 32);
1489 if (!FileTimeToSystemTime(&tf
, &ts
)) {
1490 error_setg(errp
, "Failed to convert system time %d",
1491 (int)GetLastError());
1495 acquire_privilege(SE_SYSTEMTIME_NAME
, &local_err
);
1497 error_propagate(errp
, local_err
);
1501 if (!SetSystemTime(&ts
)) {
1502 error_setg(errp
, "Failed to set time to guest: %d", (int)GetLastError());
1507 GuestLogicalProcessorList
*qmp_guest_get_vcpus(Error
**errp
)
1509 PSYSTEM_LOGICAL_PROCESSOR_INFORMATION pslpi
, ptr
;
1511 GuestLogicalProcessorList
*head
, **link
;
1512 Error
*local_err
= NULL
;
1521 if ((GetLogicalProcessorInformation(pslpi
, &length
) == FALSE
) &&
1522 (GetLastError() == ERROR_INSUFFICIENT_BUFFER
) &&
1523 (length
> sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION
))) {
1524 ptr
= pslpi
= g_malloc0(length
);
1525 if (GetLogicalProcessorInformation(pslpi
, &length
) == FALSE
) {
1526 error_setg(&local_err
, "Failed to get processor information: %d",
1527 (int)GetLastError());
1530 error_setg(&local_err
,
1531 "Failed to get processor information buffer length: %d",
1532 (int)GetLastError());
1535 while ((local_err
== NULL
) && (length
> 0)) {
1536 if (pslpi
->Relationship
== RelationProcessorCore
) {
1537 ULONG_PTR cpu_bits
= pslpi
->ProcessorMask
;
1539 while (cpu_bits
> 0) {
1540 if (!!(cpu_bits
& 1)) {
1541 GuestLogicalProcessor
*vcpu
;
1542 GuestLogicalProcessorList
*entry
;
1544 vcpu
= g_malloc0(sizeof *vcpu
);
1545 vcpu
->logical_id
= current
++;
1546 vcpu
->online
= true;
1547 vcpu
->has_can_offline
= true;
1549 entry
= g_malloc0(sizeof *entry
);
1550 entry
->value
= vcpu
;
1553 link
= &entry
->next
;
1558 length
-= sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION
);
1559 pslpi
++; /* next entry */
1564 if (local_err
== NULL
) {
1568 /* there's no guest with zero VCPUs */
1569 error_setg(&local_err
, "Guest reported zero VCPUs");
1572 qapi_free_GuestLogicalProcessorList(head
);
1573 error_propagate(errp
, local_err
);
1577 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList
*vcpus
, Error
**errp
)
1579 error_setg(errp
, QERR_UNSUPPORTED
);
1584 get_net_error_message(gint error
)
1586 HMODULE module
= NULL
;
1587 gchar
*retval
= NULL
;
1588 wchar_t *msg
= NULL
;
1592 flags
= FORMAT_MESSAGE_ALLOCATE_BUFFER
|
1593 FORMAT_MESSAGE_IGNORE_INSERTS
|
1594 FORMAT_MESSAGE_FROM_SYSTEM
;
1596 if (error
>= NERR_BASE
&& error
<= MAX_NERR
) {
1597 module
= LoadLibraryExW(L
"netmsg.dll", NULL
, LOAD_LIBRARY_AS_DATAFILE
);
1599 if (module
!= NULL
) {
1600 flags
|= FORMAT_MESSAGE_FROM_HMODULE
;
1604 FormatMessageW(flags
, module
, error
, 0, (LPWSTR
)&msg
, 0, NULL
);
1607 nchars
= wcslen(msg
);
1610 msg
[nchars
- 1] == L
'\n' &&
1611 msg
[nchars
- 2] == L
'\r') {
1612 msg
[nchars
- 2] = L
'\0';
1615 retval
= g_utf16_to_utf8(msg
, -1, NULL
, NULL
, NULL
);
1620 if (module
!= NULL
) {
1621 FreeLibrary(module
);
1627 void qmp_guest_set_user_password(const char *username
,
1628 const char *password
,
1633 char *rawpasswddata
= NULL
;
1634 size_t rawpasswdlen
;
1635 wchar_t *user
= NULL
, *wpass
= NULL
;
1636 USER_INFO_1003 pi1003
= { 0, };
1637 GError
*gerr
= NULL
;
1640 error_setg(errp
, QERR_UNSUPPORTED
);
1644 rawpasswddata
= (char *)qbase64_decode(password
, -1, &rawpasswdlen
, errp
);
1645 if (!rawpasswddata
) {
1648 rawpasswddata
= g_renew(char, rawpasswddata
, rawpasswdlen
+ 1);
1649 rawpasswddata
[rawpasswdlen
] = '\0';
1651 user
= g_utf8_to_utf16(username
, -1, NULL
, NULL
, &gerr
);
1656 wpass
= g_utf8_to_utf16(rawpasswddata
, -1, NULL
, NULL
, &gerr
);
1661 pi1003
.usri1003_password
= wpass
;
1662 nas
= NetUserSetInfo(NULL
, user
,
1663 1003, (LPBYTE
)&pi1003
,
1666 if (nas
!= NERR_Success
) {
1667 gchar
*msg
= get_net_error_message(nas
);
1668 error_setg(errp
, "failed to set password: %s", msg
);
1674 error_setg(errp
, QERR_QGA_COMMAND_FAILED
, gerr
->message
);
1679 g_free(rawpasswddata
);
1682 GuestMemoryBlockList
*qmp_guest_get_memory_blocks(Error
**errp
)
1684 error_setg(errp
, QERR_UNSUPPORTED
);
1688 GuestMemoryBlockResponseList
*
1689 qmp_guest_set_memory_blocks(GuestMemoryBlockList
*mem_blks
, Error
**errp
)
1691 error_setg(errp
, QERR_UNSUPPORTED
);
1695 GuestMemoryBlockInfo
*qmp_guest_get_memory_block_info(Error
**errp
)
1697 error_setg(errp
, QERR_UNSUPPORTED
);
1701 /* add unsupported commands to the blacklist */
1702 GList
*ga_command_blacklist_init(GList
*blacklist
)
1704 const char *list_unsupported
[] = {
1705 "guest-suspend-hybrid",
1707 "guest-get-memory-blocks", "guest-set-memory-blocks",
1708 "guest-get-memory-block-size",
1710 char **p
= (char **)list_unsupported
;
1713 blacklist
= g_list_append(blacklist
, g_strdup(*p
++));
1716 if (!vss_init(true)) {
1717 g_debug("vss_init failed, vss commands are going to be disabled");
1718 const char *list
[] = {
1719 "guest-get-fsinfo", "guest-fsfreeze-status",
1720 "guest-fsfreeze-freeze", "guest-fsfreeze-thaw", NULL
};
1724 blacklist
= g_list_append(blacklist
, g_strdup(*p
++));
1731 /* register init/cleanup routines for stateful command groups */
1732 void ga_command_state_init(GAState
*s
, GACommandState
*cs
)
1734 if (!vss_initialized()) {
1735 ga_command_state_add(cs
, NULL
, guest_fsfreeze_cleanup
);
1739 /* MINGW is missing two fields: IncomingFrames & OutgoingFrames */
1740 typedef struct _GA_WTSINFOA
{
1741 WTS_CONNECTSTATE_CLASS State
;
1743 DWORD IncomingBytes
;
1744 DWORD OutgoingBytes
;
1745 DWORD IncomingFrames
;
1746 DWORD OutgoingFrames
;
1747 DWORD IncomingCompressedBytes
;
1748 DWORD OutgoingCompressedBy
;
1749 CHAR WinStationName
[WINSTATIONNAME_LENGTH
];
1750 CHAR Domain
[DOMAIN_LENGTH
];
1751 CHAR UserName
[USERNAME_LENGTH
+ 1];
1752 LARGE_INTEGER ConnectTime
;
1753 LARGE_INTEGER DisconnectTime
;
1754 LARGE_INTEGER LastInputTime
;
1755 LARGE_INTEGER LogonTime
;
1756 LARGE_INTEGER CurrentTime
;
1760 GuestUserList
*qmp_guest_get_users(Error
**err
)
1762 #if (_WIN32_WINNT >= 0x0600)
1763 #define QGA_NANOSECONDS 10000000
1765 GHashTable
*cache
= NULL
;
1766 GuestUserList
*head
= NULL
, *cur_item
= NULL
;
1768 DWORD buffer_size
= 0, count
= 0, i
= 0;
1769 GA_WTSINFOA
*info
= NULL
;
1770 WTS_SESSION_INFOA
*entries
= NULL
;
1771 GuestUserList
*item
= NULL
;
1772 GuestUser
*user
= NULL
;
1773 gpointer value
= NULL
;
1775 double login_time
= 0;
1777 cache
= g_hash_table_new(g_str_hash
, g_str_equal
);
1779 if (WTSEnumerateSessionsA(NULL
, 0, 1, &entries
, &count
)) {
1780 for (i
= 0; i
< count
; ++i
) {
1783 if (WTSQuerySessionInformationA(
1785 entries
[i
].SessionId
,
1791 if (strlen(info
->UserName
) == 0) {
1792 WTSFreeMemory(info
);
1796 login
= info
->LogonTime
.QuadPart
;
1797 login
-= W32_FT_OFFSET
;
1798 login_time
= ((double)login
) / QGA_NANOSECONDS
;
1800 if (g_hash_table_contains(cache
, info
->UserName
)) {
1801 value
= g_hash_table_lookup(cache
, info
->UserName
);
1802 user
= (GuestUser
*)value
;
1803 if (user
->login_time
> login_time
) {
1804 user
->login_time
= login_time
;
1807 item
= g_new0(GuestUserList
, 1);
1808 item
->value
= g_new0(GuestUser
, 1);
1810 item
->value
->user
= g_strdup(info
->UserName
);
1811 item
->value
->domain
= g_strdup(info
->Domain
);
1812 item
->value
->has_domain
= true;
1814 item
->value
->login_time
= login_time
;
1816 g_hash_table_add(cache
, item
->value
->user
);
1819 head
= cur_item
= item
;
1821 cur_item
->next
= item
;
1826 WTSFreeMemory(info
);
1828 WTSFreeMemory(entries
);
1830 g_hash_table_destroy(cache
);
1833 error_setg(err
, QERR_UNSUPPORTED
);
1838 typedef struct _ga_matrix_lookup_t
{
1841 char const *version
;
1842 char const *version_id
;
1843 } ga_matrix_lookup_t
;
1845 static ga_matrix_lookup_t
const WIN_VERSION_MATRIX
[2][8] = {
1847 /* Desktop editions */
1848 { 5, 0, "Microsoft Windows 2000", "2000"},
1849 { 5, 1, "Microsoft Windows XP", "xp"},
1850 { 6, 0, "Microsoft Windows Vista", "vista"},
1851 { 6, 1, "Microsoft Windows 7" "7"},
1852 { 6, 2, "Microsoft Windows 8", "8"},
1853 { 6, 3, "Microsoft Windows 8.1", "8.1"},
1854 {10, 0, "Microsoft Windows 10", "10"},
1857 /* Server editions */
1858 { 5, 2, "Microsoft Windows Server 2003", "2003"},
1859 { 6, 0, "Microsoft Windows Server 2008", "2008"},
1860 { 6, 1, "Microsoft Windows Server 2008 R2", "2008r2"},
1861 { 6, 2, "Microsoft Windows Server 2012", "2012"},
1862 { 6, 3, "Microsoft Windows Server 2012 R2", "2012r2"},
1863 {10, 0, "Microsoft Windows Server 2016", "2016"},
1869 static void ga_get_win_version(RTL_OSVERSIONINFOEXW
*info
, Error
**errp
)
1871 typedef NTSTATUS(WINAPI
* rtl_get_version_t
)(
1872 RTL_OSVERSIONINFOEXW
*os_version_info_ex
);
1874 info
->dwOSVersionInfoSize
= sizeof(RTL_OSVERSIONINFOEXW
);
1876 HMODULE module
= GetModuleHandle("ntdll");
1877 PVOID fun
= GetProcAddress(module
, "RtlGetVersion");
1879 error_setg(errp
, QERR_QGA_COMMAND_FAILED
,
1880 "Failed to get address of RtlGetVersion");
1884 rtl_get_version_t rtl_get_version
= (rtl_get_version_t
)fun
;
1885 rtl_get_version(info
);
1889 static char *ga_get_win_name(OSVERSIONINFOEXW
const *os_version
, bool id
)
1891 DWORD major
= os_version
->dwMajorVersion
;
1892 DWORD minor
= os_version
->dwMinorVersion
;
1893 int tbl_idx
= (os_version
->wProductType
!= VER_NT_WORKSTATION
);
1894 ga_matrix_lookup_t
const *table
= WIN_VERSION_MATRIX
[tbl_idx
];
1895 while (table
->version
!= NULL
) {
1896 if (major
== table
->major
&& minor
== table
->minor
) {
1898 return g_strdup(table
->version_id
);
1900 return g_strdup(table
->version
);
1905 slog("failed to lookup Windows version: major=%lu, minor=%lu",
1907 return g_strdup("N/A");
1910 static char *ga_get_win_product_name(Error
**errp
)
1914 char *result
= g_malloc0(size
);
1915 LONG err
= ERROR_SUCCESS
;
1917 err
= RegOpenKeyA(HKEY_LOCAL_MACHINE
,
1918 "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
1920 if (err
!= ERROR_SUCCESS
) {
1921 error_setg_win32(errp
, err
, "failed to open registry key");
1925 err
= RegQueryValueExA(key
, "ProductName", NULL
, NULL
,
1926 (LPBYTE
)result
, &size
);
1927 if (err
== ERROR_MORE_DATA
) {
1928 slog("ProductName longer than expected (%lu bytes), retrying",
1933 result
= g_malloc0(size
);
1934 err
= RegQueryValueExA(key
, "ProductName", NULL
, NULL
,
1935 (LPBYTE
)result
, &size
);
1938 if (err
!= ERROR_SUCCESS
) {
1939 error_setg_win32(errp
, err
, "failed to retrive ProductName");
1950 static char *ga_get_current_arch(void)
1953 GetNativeSystemInfo(&info
);
1954 char *result
= NULL
;
1955 switch (info
.wProcessorArchitecture
) {
1956 case PROCESSOR_ARCHITECTURE_AMD64
:
1957 result
= g_strdup("x86_64");
1959 case PROCESSOR_ARCHITECTURE_ARM
:
1960 result
= g_strdup("arm");
1962 case PROCESSOR_ARCHITECTURE_IA64
:
1963 result
= g_strdup("ia64");
1965 case PROCESSOR_ARCHITECTURE_INTEL
:
1966 result
= g_strdup("x86");
1968 case PROCESSOR_ARCHITECTURE_UNKNOWN
:
1970 slog("unknown processor architecture 0x%0x",
1971 info
.wProcessorArchitecture
);
1972 result
= g_strdup("unknown");
1978 GuestOSInfo
*qmp_guest_get_osinfo(Error
**errp
)
1980 Error
*local_err
= NULL
;
1981 OSVERSIONINFOEXW os_version
= {0};
1986 ga_get_win_version(&os_version
, &local_err
);
1988 error_propagate(errp
, local_err
);
1992 server
= os_version
.wProductType
!= VER_NT_WORKSTATION
;
1993 product_name
= ga_get_win_product_name(&local_err
);
1994 if (product_name
== NULL
) {
1995 error_propagate(errp
, local_err
);
1999 info
= g_new0(GuestOSInfo
, 1);
2001 info
->has_kernel_version
= true;
2002 info
->kernel_version
= g_strdup_printf("%lu.%lu",
2003 os_version
.dwMajorVersion
,
2004 os_version
.dwMinorVersion
);
2005 info
->has_kernel_release
= true;
2006 info
->kernel_release
= g_strdup_printf("%lu",
2007 os_version
.dwBuildNumber
);
2008 info
->has_machine
= true;
2009 info
->machine
= ga_get_current_arch();
2011 info
->has_id
= true;
2012 info
->id
= g_strdup("mswindows");
2013 info
->has_name
= true;
2014 info
->name
= g_strdup("Microsoft Windows");
2015 info
->has_pretty_name
= true;
2016 info
->pretty_name
= product_name
;
2017 info
->has_version
= true;
2018 info
->version
= ga_get_win_name(&os_version
, false);
2019 info
->has_version_id
= true;
2020 info
->version_id
= ga_get_win_name(&os_version
, true);
2021 info
->has_variant
= true;
2022 info
->variant
= g_strdup(server
? "server" : "client");
2023 info
->has_variant_id
= true;
2024 info
->variant_id
= g_strdup(server
? "server" : "client");