1d8ca685aSMichael Roth /*
2d8ca685aSMichael Roth * QEMU Guest Agent win32-specific command implementations
3d8ca685aSMichael Roth *
4d8ca685aSMichael Roth * Copyright IBM Corp. 2012
5d8ca685aSMichael Roth *
6d8ca685aSMichael Roth * Authors:
7d8ca685aSMichael Roth * Michael Roth <mdroth@linux.vnet.ibm.com>
8aa59637eSGal Hammer * Gal Hammer <ghammer@redhat.com>
9d8ca685aSMichael Roth *
10d8ca685aSMichael Roth * This work is licensed under the terms of the GNU GPL, version 2 or later.
11d8ca685aSMichael Roth * See the COPYING file in the top-level directory.
12d8ca685aSMichael Roth */
134459bf38SPeter Maydell #include "qemu/osdep.h"
1456cdca1dSMarc-André Lureau
15aa59637eSGal Hammer #include <wtypes.h>
16aa59637eSGal Hammer #include <powrprof.h>
17d6c5528bSKirk Allan #include <winsock2.h>
18d6c5528bSKirk Allan #include <ws2tcpip.h>
19d6c5528bSKirk Allan #include <iptypes.h>
20d6c5528bSKirk Allan #include <iphlpapi.h>
21a3ef3b22SOlga Krishtal #include <winioctl.h>
22a3ef3b22SOlga Krishtal #include <ntddscsi.h>
23c54e1eb4SMichael Roth #include <setupapi.h>
24996b9cdcSMatt Hines #include <cfgmgr32.h>
25c54e1eb4SMichael Roth #include <initguid.h>
262e4211ceSTomáš Golembiovský #include <devpropdef.h>
27259434b8SMarc-André Lureau #include <lm.h>
28161a56a9SVinzenz Feenstra #include <wtsapi32.h>
29105fad6bSBishara AbuHattoum #include <wininet.h>
30259434b8SMarc-André Lureau
31dc03272dSMichael S. Tsirkin #include "guest-agent-core.h"
32dc03272dSMichael S. Tsirkin #include "vss-win32.h"
33eb815e24SMarkus Armbruster #include "qga-qapi-commands.h"
34e688df6bSMarkus Armbruster #include "qapi/error.h"
357b1b5d19SPaolo Bonzini #include "qapi/qmp/qerror.h"
36fa193594SOlga Krishtal #include "qemu/queue.h"
37d6c5528bSKirk Allan #include "qemu/host-utils.h"
38920639caSDaniel P. Berrange #include "qemu/base64.h"
395d3586b8SPhilippe Mathieu-Daudé #include "commands-common.h"
40d8ca685aSMichael Roth
412e4211ceSTomáš Golembiovský /*
422e4211ceSTomáš Golembiovský * The following should be in devpkey.h, but it isn't. The key names were
432e4211ceSTomáš Golembiovský * prefixed to avoid (future) name clashes. Once the definitions get into
442e4211ceSTomáš Golembiovský * mingw the following lines can be removed.
452e4211ceSTomáš Golembiovský */
462e4211ceSTomáš Golembiovský DEFINE_DEVPROPKEY(qga_DEVPKEY_NAME, 0xb725f130, 0x47ef, 0x101a, 0xa5,
472e4211ceSTomáš Golembiovský 0xf1, 0x02, 0x60, 0x8c, 0x9e, 0xeb, 0xac, 10);
482e4211ceSTomáš Golembiovský /* DEVPROP_TYPE_STRING */
492e4211ceSTomáš Golembiovský DEFINE_DEVPROPKEY(qga_DEVPKEY_Device_HardwareIds, 0xa45c254e, 0xdf1c,
502e4211ceSTomáš Golembiovský 0x4efd, 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0, 3);
512e4211ceSTomáš Golembiovský /* DEVPROP_TYPE_STRING_LIST */
522e4211ceSTomáš Golembiovský DEFINE_DEVPROPKEY(qga_DEVPKEY_Device_DriverDate, 0xa8b865dd, 0x2e3d,
532e4211ceSTomáš Golembiovský 0x4094, 0xad, 0x97, 0xe5, 0x93, 0xa7, 0xc, 0x75, 0xd6, 2);
542e4211ceSTomáš Golembiovský /* DEVPROP_TYPE_FILETIME */
552e4211ceSTomáš Golembiovský DEFINE_DEVPROPKEY(qga_DEVPKEY_Device_DriverVersion, 0xa8b865dd, 0x2e3d,
562e4211ceSTomáš Golembiovský 0x4094, 0xad, 0x97, 0xe5, 0x93, 0xa7, 0xc, 0x75, 0xd6, 3);
572e4211ceSTomáš Golembiovský /* DEVPROP_TYPE_STRING */
5837d98abdSThomas Huth /* The CM_Get_DevNode_PropertyW prototype is only sometimes in cfgmgr32.h */
592e4211ceSTomáš Golembiovský #ifndef CM_Get_DevNode_Property
6037d98abdSThomas Huth #pragma GCC diagnostic push
6137d98abdSThomas Huth #pragma GCC diagnostic ignored "-Wredundant-decls"
622e4211ceSTomáš Golembiovský CMAPI CONFIGRET WINAPI CM_Get_DevNode_PropertyW(
632e4211ceSTomáš Golembiovský DEVINST dnDevInst,
642e4211ceSTomáš Golembiovský CONST DEVPROPKEY * PropertyKey,
652e4211ceSTomáš Golembiovský DEVPROPTYPE * PropertyType,
662e4211ceSTomáš Golembiovský PBYTE PropertyBuffer,
672e4211ceSTomáš Golembiovský PULONG PropertyBufferSize,
682e4211ceSTomáš Golembiovský ULONG ulFlags
692e4211ceSTomáš Golembiovský );
702e4211ceSTomáš Golembiovský #define CM_Get_DevNode_Property CM_Get_DevNode_PropertyW
7137d98abdSThomas Huth #pragma GCC diagnostic pop
722e4211ceSTomáš Golembiovský #endif
732e4211ceSTomáš Golembiovský
74546b60d0SMichael Roth #ifndef SHTDN_REASON_FLAG_PLANNED
75546b60d0SMichael Roth #define SHTDN_REASON_FLAG_PLANNED 0x80000000
76546b60d0SMichael Roth #endif
77546b60d0SMichael Roth
783f2a6087SLei Li /* multiple of 100 nanoseconds elapsed between windows baseline
793f2a6087SLei Li * (1/1/1601) and Unix Epoch (1/1/1970), accounting for leap years */
803f2a6087SLei Li #define W32_FT_OFFSET (10000000ULL * 60 * 60 * 24 * \
813f2a6087SLei Li (365 * (1970 - 1601) + \
823f2a6087SLei Li (1970 - 1601) / 4 - 3))
833f2a6087SLei Li
84fa193594SOlga Krishtal #define INVALID_SET_FILE_POINTER ((DWORD)-1)
85fa193594SOlga Krishtal
865d3586b8SPhilippe Mathieu-Daudé struct GuestFileHandle {
87fa193594SOlga Krishtal int64_t id;
88fa193594SOlga Krishtal HANDLE fh;
89fa193594SOlga Krishtal QTAILQ_ENTRY(GuestFileHandle) next;
905d3586b8SPhilippe Mathieu-Daudé };
91fa193594SOlga Krishtal
92fa193594SOlga Krishtal static struct {
93fa193594SOlga Krishtal QTAILQ_HEAD(, GuestFileHandle) filehandles;
94b4fe97c8SDenis V. Lunev } guest_file_state = {
95b4fe97c8SDenis V. Lunev .filehandles = QTAILQ_HEAD_INITIALIZER(guest_file_state.filehandles),
96b4fe97c8SDenis V. Lunev };
97fa193594SOlga Krishtal
9852074d0fSKirk Allan #define FILE_GENERIC_APPEND (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA)
99fa193594SOlga Krishtal
100fa193594SOlga Krishtal typedef struct OpenFlags {
101fa193594SOlga Krishtal const char *forms;
102fa193594SOlga Krishtal DWORD desired_access;
103fa193594SOlga Krishtal DWORD creation_disposition;
104fa193594SOlga Krishtal } OpenFlags;
105fa193594SOlga Krishtal static OpenFlags guest_file_open_modes[] = {
106fa193594SOlga Krishtal {"r", GENERIC_READ, OPEN_EXISTING},
107fa193594SOlga Krishtal {"rb", GENERIC_READ, OPEN_EXISTING},
108fa193594SOlga Krishtal {"w", GENERIC_WRITE, CREATE_ALWAYS},
109fa193594SOlga Krishtal {"wb", GENERIC_WRITE, CREATE_ALWAYS},
11052074d0fSKirk Allan {"a", FILE_GENERIC_APPEND, OPEN_ALWAYS },
111fa193594SOlga Krishtal {"r+", GENERIC_WRITE | GENERIC_READ, OPEN_EXISTING},
112fa193594SOlga Krishtal {"rb+", GENERIC_WRITE | GENERIC_READ, OPEN_EXISTING},
113fa193594SOlga Krishtal {"r+b", GENERIC_WRITE | GENERIC_READ, OPEN_EXISTING},
114fa193594SOlga Krishtal {"w+", GENERIC_WRITE | GENERIC_READ, CREATE_ALWAYS},
115fa193594SOlga Krishtal {"wb+", GENERIC_WRITE | GENERIC_READ, CREATE_ALWAYS},
116fa193594SOlga Krishtal {"w+b", GENERIC_WRITE | GENERIC_READ, CREATE_ALWAYS},
11752074d0fSKirk Allan {"a+", FILE_GENERIC_APPEND | GENERIC_READ, OPEN_ALWAYS },
11852074d0fSKirk Allan {"ab+", FILE_GENERIC_APPEND | GENERIC_READ, OPEN_ALWAYS },
11952074d0fSKirk Allan {"a+b", FILE_GENERIC_APPEND | GENERIC_READ, OPEN_ALWAYS }
120fa193594SOlga Krishtal };
121fa193594SOlga Krishtal
122222682abSTomáš Golembiovský #define debug_error(msg) do { \
123222682abSTomáš Golembiovský char *suffix = g_win32_error_message(GetLastError()); \
124222682abSTomáš Golembiovský g_debug("%s: %s", (msg), suffix); \
125222682abSTomáš Golembiovský g_free(suffix); \
126222682abSTomáš Golembiovský } while (0)
127222682abSTomáš Golembiovský
find_open_flag(const char * mode_str)128fa193594SOlga Krishtal static OpenFlags *find_open_flag(const char *mode_str)
129fa193594SOlga Krishtal {
130fa193594SOlga Krishtal int mode;
131fa193594SOlga Krishtal Error **errp = NULL;
132fa193594SOlga Krishtal
133fa193594SOlga Krishtal for (mode = 0; mode < ARRAY_SIZE(guest_file_open_modes); ++mode) {
134fa193594SOlga Krishtal OpenFlags *flags = guest_file_open_modes + mode;
135fa193594SOlga Krishtal
136fa193594SOlga Krishtal if (strcmp(flags->forms, mode_str) == 0) {
137fa193594SOlga Krishtal return flags;
138fa193594SOlga Krishtal }
139fa193594SOlga Krishtal }
140fa193594SOlga Krishtal
141fa193594SOlga Krishtal error_setg(errp, "invalid file open mode '%s'", mode_str);
142fa193594SOlga Krishtal return NULL;
143fa193594SOlga Krishtal }
144fa193594SOlga Krishtal
guest_file_handle_add(HANDLE fh,Error ** errp)145fa193594SOlga Krishtal static int64_t guest_file_handle_add(HANDLE fh, Error **errp)
146fa193594SOlga Krishtal {
147fa193594SOlga Krishtal GuestFileHandle *gfh;
148fa193594SOlga Krishtal int64_t handle;
149fa193594SOlga Krishtal
150fa193594SOlga Krishtal handle = ga_get_fd_handle(ga_state, errp);
151fa193594SOlga Krishtal if (handle < 0) {
152fa193594SOlga Krishtal return -1;
153fa193594SOlga Krishtal }
154f3a06403SMarkus Armbruster gfh = g_new0(GuestFileHandle, 1);
155fa193594SOlga Krishtal gfh->id = handle;
156fa193594SOlga Krishtal gfh->fh = fh;
157fa193594SOlga Krishtal QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
158fa193594SOlga Krishtal
159fa193594SOlga Krishtal return handle;
160fa193594SOlga Krishtal }
161fa193594SOlga Krishtal
guest_file_handle_find(int64_t id,Error ** errp)1625d3586b8SPhilippe Mathieu-Daudé GuestFileHandle *guest_file_handle_find(int64_t id, Error **errp)
163fa193594SOlga Krishtal {
164fa193594SOlga Krishtal GuestFileHandle *gfh;
165fa193594SOlga Krishtal QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next) {
166fa193594SOlga Krishtal if (gfh->id == id) {
167fa193594SOlga Krishtal return gfh;
168fa193594SOlga Krishtal }
169fa193594SOlga Krishtal }
170fa193594SOlga Krishtal error_setg(errp, "handle '%" PRId64 "' has not been found", id);
171fa193594SOlga Krishtal return NULL;
172fa193594SOlga Krishtal }
173fa193594SOlga Krishtal
handle_set_nonblocking(HANDLE fh)174fb687773SOlga Krishtal static void handle_set_nonblocking(HANDLE fh)
175fb687773SOlga Krishtal {
176fb687773SOlga Krishtal DWORD file_type, pipe_state;
177fb687773SOlga Krishtal file_type = GetFileType(fh);
178fb687773SOlga Krishtal if (file_type != FILE_TYPE_PIPE) {
179fb687773SOlga Krishtal return;
180fb687773SOlga Krishtal }
181fb687773SOlga Krishtal /* If file_type == FILE_TYPE_PIPE, according to MSDN
182fb687773SOlga Krishtal * the specified file is socket or named pipe */
183fb687773SOlga Krishtal if (!GetNamedPipeHandleState(fh, &pipe_state, NULL,
184fb687773SOlga Krishtal NULL, NULL, NULL, 0)) {
185fb687773SOlga Krishtal return;
186fb687773SOlga Krishtal }
187fb687773SOlga Krishtal /* The fd is named pipe fd */
188fb687773SOlga Krishtal if (pipe_state & PIPE_NOWAIT) {
189fb687773SOlga Krishtal return;
190fb687773SOlga Krishtal }
191fb687773SOlga Krishtal
192fb687773SOlga Krishtal pipe_state |= PIPE_NOWAIT;
193fb687773SOlga Krishtal SetNamedPipeHandleState(fh, &pipe_state, NULL, NULL);
194fb687773SOlga Krishtal }
195fb687773SOlga Krishtal
qmp_guest_file_open(const char * path,const char * mode,Error ** errp)19691eab32aSMarkus Armbruster int64_t qmp_guest_file_open(const char *path, const char *mode, Error **errp)
197fa193594SOlga Krishtal {
198bad0227dSJonathon Reinhart int64_t fd = -1;
199fa193594SOlga Krishtal HANDLE fh;
200fa193594SOlga Krishtal HANDLE templ_file = NULL;
201fa193594SOlga Krishtal DWORD share_mode = FILE_SHARE_READ;
202fa193594SOlga Krishtal DWORD flags_and_attr = FILE_ATTRIBUTE_NORMAL;
203fa193594SOlga Krishtal LPSECURITY_ATTRIBUTES sa_attr = NULL;
204fa193594SOlga Krishtal OpenFlags *guest_flags;
205bad0227dSJonathon Reinhart GError *gerr = NULL;
206bad0227dSJonathon Reinhart wchar_t *w_path = NULL;
207fa193594SOlga Krishtal
20891eab32aSMarkus Armbruster if (!mode) {
209fa193594SOlga Krishtal mode = "r";
210fa193594SOlga Krishtal }
211fa193594SOlga Krishtal slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
212fa193594SOlga Krishtal guest_flags = find_open_flag(mode);
213fa193594SOlga Krishtal if (guest_flags == NULL) {
214fa193594SOlga Krishtal error_setg(errp, "invalid file open mode");
215bad0227dSJonathon Reinhart goto done;
216fa193594SOlga Krishtal }
217fa193594SOlga Krishtal
218bad0227dSJonathon Reinhart w_path = g_utf8_to_utf16(path, -1, NULL, NULL, &gerr);
219bad0227dSJonathon Reinhart if (!w_path) {
220bad0227dSJonathon Reinhart goto done;
221bad0227dSJonathon Reinhart }
222bad0227dSJonathon Reinhart
223bad0227dSJonathon Reinhart fh = CreateFileW(w_path, guest_flags->desired_access, share_mode, sa_attr,
224fa193594SOlga Krishtal guest_flags->creation_disposition, flags_and_attr,
225fa193594SOlga Krishtal templ_file);
226fa193594SOlga Krishtal if (fh == INVALID_HANDLE_VALUE) {
227fa193594SOlga Krishtal error_setg_win32(errp, GetLastError(), "failed to open file '%s'",
228fa193594SOlga Krishtal path);
229bad0227dSJonathon Reinhart goto done;
230fa193594SOlga Krishtal }
231fa193594SOlga Krishtal
232fb687773SOlga Krishtal /* set fd non-blocking to avoid common use cases (like reading from a
233fb687773SOlga Krishtal * named pipe) from hanging the agent
234fb687773SOlga Krishtal */
235fb687773SOlga Krishtal handle_set_nonblocking(fh);
236fb687773SOlga Krishtal
237fa193594SOlga Krishtal fd = guest_file_handle_add(fh, errp);
238fa193594SOlga Krishtal if (fd < 0) {
239c87d0964SOlga Krishtal CloseHandle(fh);
240fa193594SOlga Krishtal error_setg(errp, "failed to add handle to qmp handle table");
241bad0227dSJonathon Reinhart goto done;
242fa193594SOlga Krishtal }
243fa193594SOlga Krishtal
244fa193594SOlga Krishtal slog("guest-file-open, handle: % " PRId64, fd);
245bad0227dSJonathon Reinhart
246bad0227dSJonathon Reinhart done:
247bad0227dSJonathon Reinhart if (gerr) {
248bad0227dSJonathon Reinhart error_setg(errp, QERR_QGA_COMMAND_FAILED, gerr->message);
249bad0227dSJonathon Reinhart g_error_free(gerr);
250bad0227dSJonathon Reinhart }
251bad0227dSJonathon Reinhart g_free(w_path);
252fa193594SOlga Krishtal return fd;
253fa193594SOlga Krishtal }
254fa193594SOlga Krishtal
qmp_guest_file_close(int64_t handle,Error ** errp)255fa193594SOlga Krishtal void qmp_guest_file_close(int64_t handle, Error **errp)
256fa193594SOlga Krishtal {
257fa193594SOlga Krishtal bool ret;
258fa193594SOlga Krishtal GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
259fa193594SOlga Krishtal slog("guest-file-close called, handle: %" PRId64, handle);
260fa193594SOlga Krishtal if (gfh == NULL) {
261fa193594SOlga Krishtal return;
262fa193594SOlga Krishtal }
263fa193594SOlga Krishtal ret = CloseHandle(gfh->fh);
264fa193594SOlga Krishtal if (!ret) {
265fa193594SOlga Krishtal error_setg_win32(errp, GetLastError(), "failed close handle");
266fa193594SOlga Krishtal return;
267fa193594SOlga Krishtal }
268fa193594SOlga Krishtal
269fa193594SOlga Krishtal QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
270fa193594SOlga Krishtal g_free(gfh);
271fa193594SOlga Krishtal }
272fa193594SOlga Krishtal
acquire_privilege(const char * name,Error ** errp)27377dbc81bSMarkus Armbruster static void acquire_privilege(const char *name, Error **errp)
274d8ca685aSMichael Roth {
275374044f0SGonglei HANDLE token = NULL;
276546b60d0SMichael Roth TOKEN_PRIVILEGES priv;
277aa59637eSGal Hammer
278aa59637eSGal Hammer if (OpenProcessToken(GetCurrentProcess(),
279aa59637eSGal Hammer TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &token))
280aa59637eSGal Hammer {
281aa59637eSGal Hammer if (!LookupPrivilegeValue(NULL, name, &priv.Privileges[0].Luid)) {
2826c37ebf3SMarkus Armbruster error_setg(errp, QERR_QGA_COMMAND_FAILED,
283aa59637eSGal Hammer "no luid for requested privilege");
284aa59637eSGal Hammer goto out;
285aa59637eSGal Hammer }
286aa59637eSGal Hammer
287aa59637eSGal Hammer priv.PrivilegeCount = 1;
288aa59637eSGal Hammer priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
289aa59637eSGal Hammer
290aa59637eSGal Hammer if (!AdjustTokenPrivileges(token, FALSE, &priv, 0, NULL, 0)) {
2916c37ebf3SMarkus Armbruster error_setg(errp, QERR_QGA_COMMAND_FAILED,
292aa59637eSGal Hammer "unable to acquire requested privilege");
293aa59637eSGal Hammer goto out;
294aa59637eSGal Hammer }
295aa59637eSGal Hammer
296aa59637eSGal Hammer } else {
2976c37ebf3SMarkus Armbruster error_setg(errp, QERR_QGA_COMMAND_FAILED,
298aa59637eSGal Hammer "failed to open privilege token");
299aa59637eSGal Hammer }
300aa59637eSGal Hammer
301aa59637eSGal Hammer out:
302374044f0SGonglei if (token) {
303374044f0SGonglei CloseHandle(token);
304374044f0SGonglei }
305aa59637eSGal Hammer }
306aa59637eSGal Hammer
execute_async(DWORD WINAPI (* func)(LPVOID),LPVOID opaque,Error ** errp)30777dbc81bSMarkus Armbruster static void execute_async(DWORD WINAPI (*func)(LPVOID), LPVOID opaque,
30877dbc81bSMarkus Armbruster Error **errp)
309aa59637eSGal Hammer {
310aa59637eSGal Hammer HANDLE thread = CreateThread(NULL, 0, func, opaque, 0, NULL);
311aa59637eSGal Hammer if (!thread) {
312dcfe4805SMarkus Armbruster error_setg(errp, QERR_QGA_COMMAND_FAILED,
313aa59637eSGal Hammer "failed to dispatch asynchronous command");
314aa59637eSGal Hammer }
315aa59637eSGal Hammer }
316aa59637eSGal Hammer
qmp_guest_shutdown(const char * mode,Error ** errp)31791eab32aSMarkus Armbruster void qmp_guest_shutdown(const char *mode, Error **errp)
318aa59637eSGal Hammer {
3190f230bf7SMarkus Armbruster Error *local_err = NULL;
320546b60d0SMichael Roth UINT shutdown_flag = EWX_FORCE;
321546b60d0SMichael Roth
322546b60d0SMichael Roth slog("guest-shutdown called, mode: %s", mode);
323546b60d0SMichael Roth
32491eab32aSMarkus Armbruster if (!mode || strcmp(mode, "powerdown") == 0) {
325546b60d0SMichael Roth shutdown_flag |= EWX_POWEROFF;
326546b60d0SMichael Roth } else if (strcmp(mode, "halt") == 0) {
327546b60d0SMichael Roth shutdown_flag |= EWX_SHUTDOWN;
328546b60d0SMichael Roth } else if (strcmp(mode, "reboot") == 0) {
329546b60d0SMichael Roth shutdown_flag |= EWX_REBOOT;
330546b60d0SMichael Roth } else {
331c6bd8c70SMarkus Armbruster error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "mode",
3329fc0ab5cSMarkus Armbruster "'halt', 'powerdown', or 'reboot'");
333546b60d0SMichael Roth return;
334546b60d0SMichael Roth }
335546b60d0SMichael Roth
336546b60d0SMichael Roth /* Request a shutdown privilege, but try to shut down the system
337546b60d0SMichael Roth anyway. */
3380f230bf7SMarkus Armbruster acquire_privilege(SE_SHUTDOWN_NAME, &local_err);
3390f230bf7SMarkus Armbruster if (local_err) {
3400f230bf7SMarkus Armbruster error_propagate(errp, local_err);
341aa59637eSGal Hammer return;
342546b60d0SMichael Roth }
343546b60d0SMichael Roth
344546b60d0SMichael Roth if (!ExitWindowsEx(shutdown_flag, SHTDN_REASON_FLAG_PLANNED)) {
345672db778SPhilippe Mathieu-Daudé g_autofree gchar *emsg = g_win32_error_message(GetLastError());
346672db778SPhilippe Mathieu-Daudé slog("guest-shutdown failed: %s", emsg);
347672db778SPhilippe Mathieu-Daudé error_setg_win32(errp, GetLastError(), "guest-shutdown failed");
348546b60d0SMichael Roth }
349d8ca685aSMichael Roth }
350d8ca685aSMichael Roth
guest_file_read_unsafe(GuestFileHandle * gfh,int64_t count,Error ** errp)351ead83a13SPhilippe Mathieu-Daudé GuestFileRead *guest_file_read_unsafe(GuestFileHandle *gfh,
35277dbc81bSMarkus Armbruster int64_t count, Error **errp)
353d8ca685aSMichael Roth {
354fa193594SOlga Krishtal GuestFileRead *read_data = NULL;
355fa193594SOlga Krishtal guchar *buf;
356ead83a13SPhilippe Mathieu-Daudé HANDLE fh = gfh->fh;
357fa193594SOlga Krishtal bool is_ok;
358fa193594SOlga Krishtal DWORD read_count;
359fa193594SOlga Krishtal
360f62ebb63SPhilippe Mathieu-Daudé buf = g_malloc0(count + 1);
361fa193594SOlga Krishtal is_ok = ReadFile(fh, buf, count, &read_count, NULL);
362fa193594SOlga Krishtal if (!is_ok) {
363fa193594SOlga Krishtal error_setg_win32(errp, GetLastError(), "failed to read file");
364fa193594SOlga Krishtal } else {
365fa193594SOlga Krishtal buf[read_count] = 0;
366f3a06403SMarkus Armbruster read_data = g_new0(GuestFileRead, 1);
367fa193594SOlga Krishtal read_data->count = (size_t)read_count;
368fa193594SOlga Krishtal read_data->eof = read_count == 0;
369fa193594SOlga Krishtal
370fa193594SOlga Krishtal if (read_count != 0) {
371fa193594SOlga Krishtal read_data->buf_b64 = g_base64_encode(buf, read_count);
372fa193594SOlga Krishtal }
373fa193594SOlga Krishtal }
374fa193594SOlga Krishtal g_free(buf);
375fa193594SOlga Krishtal
376fa193594SOlga Krishtal return read_data;
377d8ca685aSMichael Roth }
378d8ca685aSMichael Roth
qmp_guest_file_write(int64_t handle,const char * buf_b64,bool has_count,int64_t count,Error ** errp)379d8ca685aSMichael Roth GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
38077dbc81bSMarkus Armbruster bool has_count, int64_t count,
38177dbc81bSMarkus Armbruster Error **errp)
382d8ca685aSMichael Roth {
383fa193594SOlga Krishtal GuestFileWrite *write_data = NULL;
384fa193594SOlga Krishtal guchar *buf;
385fa193594SOlga Krishtal gsize buf_len;
386fa193594SOlga Krishtal bool is_ok;
387fa193594SOlga Krishtal DWORD write_count;
388fa193594SOlga Krishtal GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
389fa193594SOlga Krishtal HANDLE fh;
390fa193594SOlga Krishtal
391fa193594SOlga Krishtal if (!gfh) {
392fa193594SOlga Krishtal return NULL;
393fa193594SOlga Krishtal }
394fa193594SOlga Krishtal fh = gfh->fh;
395920639caSDaniel P. Berrange buf = qbase64_decode(buf_b64, -1, &buf_len, errp);
396920639caSDaniel P. Berrange if (!buf) {
397920639caSDaniel P. Berrange return NULL;
398920639caSDaniel P. Berrange }
399fa193594SOlga Krishtal
400fa193594SOlga Krishtal if (!has_count) {
401fa193594SOlga Krishtal count = buf_len;
402fa193594SOlga Krishtal } else if (count < 0 || count > buf_len) {
403fa193594SOlga Krishtal error_setg(errp, "value '%" PRId64
404fa193594SOlga Krishtal "' is invalid for argument count", count);
405fa193594SOlga Krishtal goto done;
406fa193594SOlga Krishtal }
407fa193594SOlga Krishtal
408fa193594SOlga Krishtal is_ok = WriteFile(fh, buf, count, &write_count, NULL);
409fa193594SOlga Krishtal if (!is_ok) {
410fa193594SOlga Krishtal error_setg_win32(errp, GetLastError(), "failed to write to file");
411fa193594SOlga Krishtal slog("guest-file-write-failed, handle: %" PRId64, handle);
412fa193594SOlga Krishtal } else {
413f3a06403SMarkus Armbruster write_data = g_new0(GuestFileWrite, 1);
414fa193594SOlga Krishtal write_data->count = (size_t) write_count;
415fa193594SOlga Krishtal }
416fa193594SOlga Krishtal
417fa193594SOlga Krishtal done:
418fa193594SOlga Krishtal g_free(buf);
419fa193594SOlga Krishtal return write_data;
420d8ca685aSMichael Roth }
421d8ca685aSMichael Roth
qmp_guest_file_seek(int64_t handle,int64_t offset,GuestFileWhence * whence_code,Error ** errp)422d8ca685aSMichael Roth GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
4230b4b4938SEric Blake GuestFileWhence *whence_code,
4240b4b4938SEric Blake Error **errp)
425d8ca685aSMichael Roth {
426fa193594SOlga Krishtal GuestFileHandle *gfh;
427fa193594SOlga Krishtal GuestFileSeek *seek_data;
428fa193594SOlga Krishtal HANDLE fh;
429fa193594SOlga Krishtal LARGE_INTEGER new_pos, off_pos;
430fa193594SOlga Krishtal off_pos.QuadPart = offset;
431fa193594SOlga Krishtal BOOL res;
4320a982b1bSEric Blake int whence;
4330b4b4938SEric Blake Error *err = NULL;
4340a982b1bSEric Blake
435fa193594SOlga Krishtal gfh = guest_file_handle_find(handle, errp);
436fa193594SOlga Krishtal if (!gfh) {
437fa193594SOlga Krishtal return NULL;
438fa193594SOlga Krishtal }
439fa193594SOlga Krishtal
4400a982b1bSEric Blake /* We stupidly exposed 'whence':'int' in our qapi */
4410b4b4938SEric Blake whence = ga_parse_whence(whence_code, &err);
4420b4b4938SEric Blake if (err) {
4430b4b4938SEric Blake error_propagate(errp, err);
4440a982b1bSEric Blake return NULL;
4450a982b1bSEric Blake }
4460a982b1bSEric Blake
447fa193594SOlga Krishtal fh = gfh->fh;
448fa193594SOlga Krishtal res = SetFilePointerEx(fh, off_pos, &new_pos, whence);
449fa193594SOlga Krishtal if (!res) {
450fa193594SOlga Krishtal error_setg_win32(errp, GetLastError(), "failed to seek file");
451fa193594SOlga Krishtal return NULL;
452fa193594SOlga Krishtal }
453fa193594SOlga Krishtal seek_data = g_new0(GuestFileSeek, 1);
454fa193594SOlga Krishtal seek_data->position = new_pos.QuadPart;
455fa193594SOlga Krishtal return seek_data;
456d8ca685aSMichael Roth }
457d8ca685aSMichael Roth
qmp_guest_file_flush(int64_t handle,Error ** errp)45877dbc81bSMarkus Armbruster void qmp_guest_file_flush(int64_t handle, Error **errp)
459d8ca685aSMichael Roth {
460fa193594SOlga Krishtal HANDLE fh;
461fa193594SOlga Krishtal GuestFileHandle *gfh = guest_file_handle_find(handle, errp);
462fa193594SOlga Krishtal if (!gfh) {
463fa193594SOlga Krishtal return;
464fa193594SOlga Krishtal }
465fa193594SOlga Krishtal
466fa193594SOlga Krishtal fh = gfh->fh;
467fa193594SOlga Krishtal if (!FlushFileBuffers(fh)) {
468fa193594SOlga Krishtal error_setg_win32(errp, GetLastError(), "failed to flush file");
469fa193594SOlga Krishtal }
470fa193594SOlga Krishtal }
471fa193594SOlga Krishtal
4728ac65578SCao Jiaxi static GuestDiskBusType win2qemu[] = {
473a3ef3b22SOlga Krishtal [BusTypeUnknown] = GUEST_DISK_BUS_TYPE_UNKNOWN,
474a3ef3b22SOlga Krishtal [BusTypeScsi] = GUEST_DISK_BUS_TYPE_SCSI,
475a3ef3b22SOlga Krishtal [BusTypeAtapi] = GUEST_DISK_BUS_TYPE_IDE,
476a3ef3b22SOlga Krishtal [BusTypeAta] = GUEST_DISK_BUS_TYPE_IDE,
477a3ef3b22SOlga Krishtal [BusType1394] = GUEST_DISK_BUS_TYPE_IEEE1394,
478a3ef3b22SOlga Krishtal [BusTypeSsa] = GUEST_DISK_BUS_TYPE_SSA,
479a3ef3b22SOlga Krishtal [BusTypeFibre] = GUEST_DISK_BUS_TYPE_SSA,
480a3ef3b22SOlga Krishtal [BusTypeUsb] = GUEST_DISK_BUS_TYPE_USB,
481a3ef3b22SOlga Krishtal [BusTypeRAID] = GUEST_DISK_BUS_TYPE_RAID,
482a3ef3b22SOlga Krishtal [BusTypeiScsi] = GUEST_DISK_BUS_TYPE_ISCSI,
483a3ef3b22SOlga Krishtal [BusTypeSas] = GUEST_DISK_BUS_TYPE_SAS,
484a3ef3b22SOlga Krishtal [BusTypeSata] = GUEST_DISK_BUS_TYPE_SATA,
485a3ef3b22SOlga Krishtal [BusTypeSd] = GUEST_DISK_BUS_TYPE_SD,
486a3ef3b22SOlga Krishtal [BusTypeMmc] = GUEST_DISK_BUS_TYPE_MMC,
487a3ef3b22SOlga Krishtal [BusTypeVirtual] = GUEST_DISK_BUS_TYPE_VIRTUAL,
488a3ef3b22SOlga Krishtal [BusTypeFileBackedVirtual] = GUEST_DISK_BUS_TYPE_FILE_BACKED_VIRTUAL,
489b9a00260SKonstantin Kostiuk /*
490*01dc0651SMichael Tokarev * BusTypeSpaces currently is not supported
491b9a00260SKonstantin Kostiuk */
492b9a00260SKonstantin Kostiuk [BusTypeSpaces] = GUEST_DISK_BUS_TYPE_UNKNOWN,
493b9a00260SKonstantin Kostiuk [BusTypeNvme] = GUEST_DISK_BUS_TYPE_NVME,
494a3ef3b22SOlga Krishtal };
495a3ef3b22SOlga Krishtal
find_bus_type(STORAGE_BUS_TYPE bus)496a3ef3b22SOlga Krishtal static GuestDiskBusType find_bus_type(STORAGE_BUS_TYPE bus)
497a3ef3b22SOlga Krishtal {
498d9c85b6cSLi Qiang if (bus >= ARRAY_SIZE(win2qemu) || (int)bus < 0) {
499a3ef3b22SOlga Krishtal return GUEST_DISK_BUS_TYPE_UNKNOWN;
500a3ef3b22SOlga Krishtal }
501a3ef3b22SOlga Krishtal return win2qemu[(int)bus];
502a3ef3b22SOlga Krishtal }
503a3ef3b22SOlga Krishtal
get_pci_address_for_device(GuestPCIAddress * pci,HDEVINFO dev_info)5047cc35461SKostiantyn Kostiuk static void get_pci_address_for_device(GuestPCIAddress *pci,
5057cc35461SKostiantyn Kostiuk HDEVINFO dev_info)
5067cc35461SKostiantyn Kostiuk {
5077cc35461SKostiantyn Kostiuk SP_DEVINFO_DATA dev_info_data;
5087cc35461SKostiantyn Kostiuk DWORD j;
5097cc35461SKostiantyn Kostiuk DWORD size;
5107cc35461SKostiantyn Kostiuk bool partial_pci = false;
5117cc35461SKostiantyn Kostiuk
5127cc35461SKostiantyn Kostiuk dev_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
5137cc35461SKostiantyn Kostiuk
5147cc35461SKostiantyn Kostiuk for (j = 0;
5157cc35461SKostiantyn Kostiuk SetupDiEnumDeviceInfo(dev_info, j, &dev_info_data);
5167cc35461SKostiantyn Kostiuk j++) {
5177cc35461SKostiantyn Kostiuk DWORD addr, bus, ui_slot, type;
5187cc35461SKostiantyn Kostiuk int func, slot;
5197cc35461SKostiantyn Kostiuk size = sizeof(DWORD);
5207cc35461SKostiantyn Kostiuk
5217cc35461SKostiantyn Kostiuk /*
5227cc35461SKostiantyn Kostiuk * There is no need to allocate buffer in the next functions. The
5237cc35461SKostiantyn Kostiuk * size is known and ULONG according to
5247cc35461SKostiantyn Kostiuk * https://msdn.microsoft.com/en-us/library/windows/hardware/ff543095(v=vs.85).aspx
5257cc35461SKostiantyn Kostiuk */
5267cc35461SKostiantyn Kostiuk if (!SetupDiGetDeviceRegistryProperty(
5277cc35461SKostiantyn Kostiuk dev_info, &dev_info_data, SPDRP_BUSNUMBER,
5287cc35461SKostiantyn Kostiuk &type, (PBYTE)&bus, size, NULL)) {
5297cc35461SKostiantyn Kostiuk debug_error("failed to get PCI bus");
5307cc35461SKostiantyn Kostiuk bus = -1;
5317cc35461SKostiantyn Kostiuk partial_pci = true;
5327cc35461SKostiantyn Kostiuk }
5337cc35461SKostiantyn Kostiuk
5347cc35461SKostiantyn Kostiuk /*
5357cc35461SKostiantyn Kostiuk * The function retrieves the device's address. This value will be
5367cc35461SKostiantyn Kostiuk * transformed into device function and number
5377cc35461SKostiantyn Kostiuk */
5387cc35461SKostiantyn Kostiuk if (!SetupDiGetDeviceRegistryProperty(
5397cc35461SKostiantyn Kostiuk dev_info, &dev_info_data, SPDRP_ADDRESS,
5407cc35461SKostiantyn Kostiuk &type, (PBYTE)&addr, size, NULL)) {
5417cc35461SKostiantyn Kostiuk debug_error("failed to get PCI address");
5427cc35461SKostiantyn Kostiuk addr = -1;
5437cc35461SKostiantyn Kostiuk partial_pci = true;
5447cc35461SKostiantyn Kostiuk }
5457cc35461SKostiantyn Kostiuk
5467cc35461SKostiantyn Kostiuk /*
5477cc35461SKostiantyn Kostiuk * This call returns UINumber of DEVICE_CAPABILITIES structure.
5487cc35461SKostiantyn Kostiuk * This number is typically a user-perceived slot number.
5497cc35461SKostiantyn Kostiuk */
5507cc35461SKostiantyn Kostiuk if (!SetupDiGetDeviceRegistryProperty(
5517cc35461SKostiantyn Kostiuk dev_info, &dev_info_data, SPDRP_UI_NUMBER,
5527cc35461SKostiantyn Kostiuk &type, (PBYTE)&ui_slot, size, NULL)) {
5537cc35461SKostiantyn Kostiuk debug_error("failed to get PCI slot");
5547cc35461SKostiantyn Kostiuk ui_slot = -1;
5557cc35461SKostiantyn Kostiuk partial_pci = true;
5567cc35461SKostiantyn Kostiuk }
5577cc35461SKostiantyn Kostiuk
5587cc35461SKostiantyn Kostiuk /*
5597cc35461SKostiantyn Kostiuk * SetupApi gives us the same information as driver with
5607cc35461SKostiantyn Kostiuk * IoGetDeviceProperty. According to Microsoft:
5617cc35461SKostiantyn Kostiuk *
5627cc35461SKostiantyn Kostiuk * FunctionNumber = (USHORT)((propertyAddress) & 0x0000FFFF)
5637cc35461SKostiantyn Kostiuk * DeviceNumber = (USHORT)(((propertyAddress) >> 16) & 0x0000FFFF)
5647cc35461SKostiantyn Kostiuk * SPDRP_ADDRESS is propertyAddress, so we do the same.
5657cc35461SKostiantyn Kostiuk *
5667cc35461SKostiantyn Kostiuk * https://docs.microsoft.com/en-us/windows/desktop/api/setupapi/nf-setupapi-setupdigetdeviceregistrypropertya
5677cc35461SKostiantyn Kostiuk */
5687cc35461SKostiantyn Kostiuk if (partial_pci) {
5697cc35461SKostiantyn Kostiuk pci->domain = -1;
5707cc35461SKostiantyn Kostiuk pci->slot = -1;
5717cc35461SKostiantyn Kostiuk pci->function = -1;
5727cc35461SKostiantyn Kostiuk pci->bus = -1;
5737cc35461SKostiantyn Kostiuk continue;
5747cc35461SKostiantyn Kostiuk } else {
5757cc35461SKostiantyn Kostiuk func = ((int)addr == -1) ? -1 : addr & 0x0000FFFF;
5767cc35461SKostiantyn Kostiuk slot = ((int)addr == -1) ? -1 : (addr >> 16) & 0x0000FFFF;
5777cc35461SKostiantyn Kostiuk if ((int)ui_slot != slot) {
5787cc35461SKostiantyn Kostiuk g_debug("mismatch with reported slot values: %d vs %d",
5797cc35461SKostiantyn Kostiuk (int)ui_slot, slot);
5807cc35461SKostiantyn Kostiuk }
5817cc35461SKostiantyn Kostiuk pci->domain = 0;
5827cc35461SKostiantyn Kostiuk pci->slot = (int)ui_slot;
5837cc35461SKostiantyn Kostiuk pci->function = func;
5847cc35461SKostiantyn Kostiuk pci->bus = (int)bus;
5857cc35461SKostiantyn Kostiuk return;
5867cc35461SKostiantyn Kostiuk }
5877cc35461SKostiantyn Kostiuk }
5887cc35461SKostiantyn Kostiuk }
5897cc35461SKostiantyn Kostiuk
get_empty_pci_address(void)5908e12ec8eSKfir Manor static GuestPCIAddress *get_empty_pci_address(void)
5918e12ec8eSKfir Manor {
5928e12ec8eSKfir Manor GuestPCIAddress *pci = NULL;
5938e12ec8eSKfir Manor
5948e12ec8eSKfir Manor pci = g_malloc0(sizeof(*pci));
5958e12ec8eSKfir Manor pci->domain = -1;
5968e12ec8eSKfir Manor pci->slot = -1;
5978e12ec8eSKfir Manor pci->function = -1;
5988e12ec8eSKfir Manor pci->bus = -1;
5998e12ec8eSKfir Manor return pci;
6008e12ec8eSKfir Manor }
6018e12ec8eSKfir Manor
get_pci_info(int number,Error ** errp)602996b9cdcSMatt Hines static GuestPCIAddress *get_pci_info(int number, Error **errp)
603a3ef3b22SOlga Krishtal {
604d0b896a7SKostiantyn Kostiuk HDEVINFO dev_info = INVALID_HANDLE_VALUE;
605c49ca88bSKostiantyn Kostiuk HDEVINFO parent_dev_info = INVALID_HANDLE_VALUE;
606c49ca88bSKostiantyn Kostiuk
607c54e1eb4SMichael Roth SP_DEVINFO_DATA dev_info_data;
608996b9cdcSMatt Hines SP_DEVICE_INTERFACE_DATA dev_iface_data;
609996b9cdcSMatt Hines HANDLE dev_file;
610c54e1eb4SMichael Roth int i;
6118e12ec8eSKfir Manor GuestPCIAddress *pci = get_empty_pci_address();
612c54e1eb4SMichael Roth
613b1ba8890STomáš Golembiovský dev_info = SetupDiGetClassDevs(&GUID_DEVINTERFACE_DISK, 0, 0,
614c54e1eb4SMichael Roth DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
615c54e1eb4SMichael Roth if (dev_info == INVALID_HANDLE_VALUE) {
616c54e1eb4SMichael Roth error_setg_win32(errp, GetLastError(), "failed to get devices tree");
617e78ca586SKostiantyn Kostiuk goto end;
618c54e1eb4SMichael Roth }
619c54e1eb4SMichael Roth
620222682abSTomáš Golembiovský g_debug("enumerating devices");
621c54e1eb4SMichael Roth dev_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
622996b9cdcSMatt Hines dev_iface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
623c54e1eb4SMichael Roth for (i = 0; SetupDiEnumDeviceInfo(dev_info, i, &dev_info_data); i++) {
6245f22473eSKostiantyn Kostiuk g_autofree PSP_DEVICE_INTERFACE_DETAIL_DATA pdev_iface_detail_data = NULL;
625996b9cdcSMatt Hines STORAGE_DEVICE_NUMBER sdn;
6265f22473eSKostiantyn Kostiuk g_autofree char *parent_dev_id = NULL;
627996b9cdcSMatt Hines SP_DEVINFO_DATA parent_dev_info_data;
628996b9cdcSMatt Hines DWORD size = 0;
629996b9cdcSMatt Hines
630996b9cdcSMatt Hines g_debug("getting device path");
631996b9cdcSMatt Hines if (SetupDiEnumDeviceInterfaces(dev_info, &dev_info_data,
632996b9cdcSMatt Hines &GUID_DEVINTERFACE_DISK, 0,
633996b9cdcSMatt Hines &dev_iface_data)) {
634d919cea0SKostiantyn Kostiuk if (!SetupDiGetDeviceInterfaceDetail(dev_info, &dev_iface_data,
635996b9cdcSMatt Hines pdev_iface_detail_data,
636996b9cdcSMatt Hines size, &size,
637996b9cdcSMatt Hines &dev_info_data)) {
638c54e1eb4SMichael Roth if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
639996b9cdcSMatt Hines pdev_iface_detail_data = g_malloc(size);
640996b9cdcSMatt Hines pdev_iface_detail_data->cbSize =
641996b9cdcSMatt Hines sizeof(*pdev_iface_detail_data);
642c54e1eb4SMichael Roth } else {
643c54e1eb4SMichael Roth error_setg_win32(errp, GetLastError(),
644996b9cdcSMatt Hines "failed to get device interfaces");
645e78ca586SKostiantyn Kostiuk goto end;
646c54e1eb4SMichael Roth }
647c54e1eb4SMichael Roth }
648c54e1eb4SMichael Roth
649d919cea0SKostiantyn Kostiuk if (!SetupDiGetDeviceInterfaceDetail(dev_info, &dev_iface_data,
650d919cea0SKostiantyn Kostiuk pdev_iface_detail_data,
651d919cea0SKostiantyn Kostiuk size, &size,
652d919cea0SKostiantyn Kostiuk &dev_info_data)) {
653d919cea0SKostiantyn Kostiuk // pdev_iface_detail_data already is allocated
654d919cea0SKostiantyn Kostiuk error_setg_win32(errp, GetLastError(),
655d919cea0SKostiantyn Kostiuk "failed to get device interfaces");
656d919cea0SKostiantyn Kostiuk goto end;
657d919cea0SKostiantyn Kostiuk }
658d919cea0SKostiantyn Kostiuk
659996b9cdcSMatt Hines dev_file = CreateFile(pdev_iface_detail_data->DevicePath, 0,
660996b9cdcSMatt Hines FILE_SHARE_READ, NULL, OPEN_EXISTING, 0,
661996b9cdcSMatt Hines NULL);
662996b9cdcSMatt Hines
663996b9cdcSMatt Hines if (!DeviceIoControl(dev_file, IOCTL_STORAGE_GET_DEVICE_NUMBER,
664996b9cdcSMatt Hines NULL, 0, &sdn, sizeof(sdn), &size, NULL)) {
665996b9cdcSMatt Hines CloseHandle(dev_file);
666996b9cdcSMatt Hines error_setg_win32(errp, GetLastError(),
667996b9cdcSMatt Hines "failed to get device slot number");
668e78ca586SKostiantyn Kostiuk goto end;
669996b9cdcSMatt Hines }
670996b9cdcSMatt Hines
671996b9cdcSMatt Hines CloseHandle(dev_file);
672996b9cdcSMatt Hines if (sdn.DeviceNumber != number) {
673c54e1eb4SMichael Roth continue;
674c54e1eb4SMichael Roth }
675996b9cdcSMatt Hines } else {
676996b9cdcSMatt Hines error_setg_win32(errp, GetLastError(),
677996b9cdcSMatt Hines "failed to get device interfaces");
678e78ca586SKostiantyn Kostiuk goto end;
679996b9cdcSMatt Hines }
680c54e1eb4SMichael Roth
681996b9cdcSMatt Hines g_debug("found device slot %d. Getting storage controller", number);
682996b9cdcSMatt Hines {
683996b9cdcSMatt Hines CONFIGRET cr;
684996b9cdcSMatt Hines DEVINST dev_inst, parent_dev_inst;
685996b9cdcSMatt Hines ULONG dev_id_size = 0;
686996b9cdcSMatt Hines
687996b9cdcSMatt Hines size = 0;
688d919cea0SKostiantyn Kostiuk if (!SetupDiGetDeviceInstanceId(dev_info, &dev_info_data,
689996b9cdcSMatt Hines parent_dev_id, size, &size)) {
690996b9cdcSMatt Hines if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
691996b9cdcSMatt Hines parent_dev_id = g_malloc(size);
692996b9cdcSMatt Hines } else {
693996b9cdcSMatt Hines error_setg_win32(errp, GetLastError(),
694996b9cdcSMatt Hines "failed to get device instance ID");
695e78ca586SKostiantyn Kostiuk goto end;
696996b9cdcSMatt Hines }
697996b9cdcSMatt Hines }
698996b9cdcSMatt Hines
699d919cea0SKostiantyn Kostiuk if (!SetupDiGetDeviceInstanceId(dev_info, &dev_info_data,
700d919cea0SKostiantyn Kostiuk parent_dev_id, size, &size)) {
701d919cea0SKostiantyn Kostiuk // parent_dev_id already is allocated
702d919cea0SKostiantyn Kostiuk error_setg_win32(errp, GetLastError(),
703d919cea0SKostiantyn Kostiuk "failed to get device instance ID");
704d919cea0SKostiantyn Kostiuk goto end;
705d919cea0SKostiantyn Kostiuk }
706d919cea0SKostiantyn Kostiuk
707996b9cdcSMatt Hines /*
708996b9cdcSMatt Hines * CM API used here as opposed to
709996b9cdcSMatt Hines * SetupDiGetDeviceProperty(..., DEVPKEY_Device_Parent, ...)
710996b9cdcSMatt Hines * which exports are only available in mingw-w64 6+
711996b9cdcSMatt Hines */
712996b9cdcSMatt Hines cr = CM_Locate_DevInst(&dev_inst, parent_dev_id, 0);
713996b9cdcSMatt Hines if (cr != CR_SUCCESS) {
714996b9cdcSMatt Hines g_error("CM_Locate_DevInst failed with code %lx", cr);
715996b9cdcSMatt Hines error_setg_win32(errp, GetLastError(),
716996b9cdcSMatt Hines "failed to get device instance");
717e78ca586SKostiantyn Kostiuk goto end;
718996b9cdcSMatt Hines }
719996b9cdcSMatt Hines cr = CM_Get_Parent(&parent_dev_inst, dev_inst, 0);
720996b9cdcSMatt Hines if (cr != CR_SUCCESS) {
721996b9cdcSMatt Hines g_error("CM_Get_Parent failed with code %lx", cr);
722996b9cdcSMatt Hines error_setg_win32(errp, GetLastError(),
723996b9cdcSMatt Hines "failed to get parent device instance");
724e78ca586SKostiantyn Kostiuk goto end;
725996b9cdcSMatt Hines }
726996b9cdcSMatt Hines
727996b9cdcSMatt Hines cr = CM_Get_Device_ID_Size(&dev_id_size, parent_dev_inst, 0);
728996b9cdcSMatt Hines if (cr != CR_SUCCESS) {
729996b9cdcSMatt Hines g_error("CM_Get_Device_ID_Size failed with code %lx", cr);
730996b9cdcSMatt Hines error_setg_win32(errp, GetLastError(),
731996b9cdcSMatt Hines "failed to get parent device ID length");
732e78ca586SKostiantyn Kostiuk goto end;
733996b9cdcSMatt Hines }
734996b9cdcSMatt Hines
735996b9cdcSMatt Hines ++dev_id_size;
736996b9cdcSMatt Hines if (dev_id_size > size) {
737996b9cdcSMatt Hines g_free(parent_dev_id);
738996b9cdcSMatt Hines parent_dev_id = g_malloc(dev_id_size);
739996b9cdcSMatt Hines }
740996b9cdcSMatt Hines
741996b9cdcSMatt Hines cr = CM_Get_Device_ID(parent_dev_inst, parent_dev_id, dev_id_size,
742996b9cdcSMatt Hines 0);
743996b9cdcSMatt Hines if (cr != CR_SUCCESS) {
744996b9cdcSMatt Hines g_error("CM_Get_Device_ID failed with code %lx", cr);
745996b9cdcSMatt Hines error_setg_win32(errp, GetLastError(),
746996b9cdcSMatt Hines "failed to get parent device ID");
747e78ca586SKostiantyn Kostiuk goto end;
748996b9cdcSMatt Hines }
749996b9cdcSMatt Hines }
750996b9cdcSMatt Hines
751996b9cdcSMatt Hines g_debug("querying storage controller %s for PCI information",
752996b9cdcSMatt Hines parent_dev_id);
753996b9cdcSMatt Hines parent_dev_info =
754996b9cdcSMatt Hines SetupDiGetClassDevs(&GUID_DEVINTERFACE_STORAGEPORT, parent_dev_id,
755996b9cdcSMatt Hines NULL, DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
756996b9cdcSMatt Hines
757996b9cdcSMatt Hines if (parent_dev_info == INVALID_HANDLE_VALUE) {
758996b9cdcSMatt Hines error_setg_win32(errp, GetLastError(),
759996b9cdcSMatt Hines "failed to get parent device");
760e78ca586SKostiantyn Kostiuk goto end;
761996b9cdcSMatt Hines }
762996b9cdcSMatt Hines
763996b9cdcSMatt Hines parent_dev_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
764996b9cdcSMatt Hines if (!SetupDiEnumDeviceInfo(parent_dev_info, 0, &parent_dev_info_data)) {
765996b9cdcSMatt Hines error_setg_win32(errp, GetLastError(),
766996b9cdcSMatt Hines "failed to get parent device data");
767e78ca586SKostiantyn Kostiuk goto end;
768996b9cdcSMatt Hines }
769996b9cdcSMatt Hines
7707cc35461SKostiantyn Kostiuk get_pci_address_for_device(pci, parent_dev_info);
771996b9cdcSMatt Hines
772c54e1eb4SMichael Roth break;
773c54e1eb4SMichael Roth }
7749bd8e933SLi Ping
775e78ca586SKostiantyn Kostiuk end:
776c49ca88bSKostiantyn Kostiuk if (parent_dev_info != INVALID_HANDLE_VALUE) {
777c49ca88bSKostiantyn Kostiuk SetupDiDestroyDeviceInfoList(parent_dev_info);
778c49ca88bSKostiantyn Kostiuk }
779d0b896a7SKostiantyn Kostiuk if (dev_info != INVALID_HANDLE_VALUE) {
7809bd8e933SLi Ping SetupDiDestroyDeviceInfoList(dev_info);
781d0b896a7SKostiantyn Kostiuk }
782c54e1eb4SMichael Roth return pci;
783a3ef3b22SOlga Krishtal }
784a3ef3b22SOlga Krishtal
get_disk_properties(HANDLE vol_h,GuestDiskAddress * disk,Error ** errp)785c76d70f4STomáš Golembiovský static void get_disk_properties(HANDLE vol_h, GuestDiskAddress *disk,
786c76d70f4STomáš Golembiovský Error **errp)
787a3ef3b22SOlga Krishtal {
788a3ef3b22SOlga Krishtal STORAGE_PROPERTY_QUERY query;
789a3ef3b22SOlga Krishtal STORAGE_DEVICE_DESCRIPTOR *dev_desc, buf;
790a3ef3b22SOlga Krishtal DWORD received;
791c76d70f4STomáš Golembiovský ULONG size = sizeof(buf);
792a3ef3b22SOlga Krishtal
793a3ef3b22SOlga Krishtal dev_desc = &buf;
794a3ef3b22SOlga Krishtal query.PropertyId = StorageDeviceProperty;
795a3ef3b22SOlga Krishtal query.QueryType = PropertyStandardQuery;
796a3ef3b22SOlga Krishtal
797a3ef3b22SOlga Krishtal if (!DeviceIoControl(vol_h, IOCTL_STORAGE_QUERY_PROPERTY, &query,
798a3ef3b22SOlga Krishtal sizeof(STORAGE_PROPERTY_QUERY), dev_desc,
799c76d70f4STomáš Golembiovský size, &received, NULL)) {
800a3ef3b22SOlga Krishtal error_setg_win32(errp, GetLastError(), "failed to get bus type");
801c76d70f4STomáš Golembiovský return;
802a3ef3b22SOlga Krishtal }
803c76d70f4STomáš Golembiovský disk->bus_type = find_bus_type(dev_desc->BusType);
804c76d70f4STomáš Golembiovský g_debug("bus type %d", disk->bus_type);
805a3ef3b22SOlga Krishtal
806fb08aa70STomáš Golembiovský /* Query once more. Now with long enough buffer. */
807fb08aa70STomáš Golembiovský size = dev_desc->Size;
808fb08aa70STomáš Golembiovský dev_desc = g_malloc0(size);
809fb08aa70STomáš Golembiovský if (!DeviceIoControl(vol_h, IOCTL_STORAGE_QUERY_PROPERTY, &query,
810fb08aa70STomáš Golembiovský sizeof(STORAGE_PROPERTY_QUERY), dev_desc,
811fb08aa70STomáš Golembiovský size, &received, NULL)) {
812fb08aa70STomáš Golembiovský error_setg_win32(errp, GetLastError(), "failed to get serial number");
813fb08aa70STomáš Golembiovský g_debug("failed to get serial number");
814fb08aa70STomáš Golembiovský goto out_free;
815fb08aa70STomáš Golembiovský }
816fb08aa70STomáš Golembiovský if (dev_desc->SerialNumberOffset > 0) {
817fb08aa70STomáš Golembiovský const char *serial;
818fb08aa70STomáš Golembiovský size_t len;
819fb08aa70STomáš Golembiovský
820fb08aa70STomáš Golembiovský if (dev_desc->SerialNumberOffset >= received) {
821fb08aa70STomáš Golembiovský error_setg(errp, "failed to get serial number: offset outside the buffer");
822fb08aa70STomáš Golembiovský g_debug("serial number offset outside the buffer");
823fb08aa70STomáš Golembiovský goto out_free;
824fb08aa70STomáš Golembiovský }
825fb08aa70STomáš Golembiovský serial = (char *)dev_desc + dev_desc->SerialNumberOffset;
826fb08aa70STomáš Golembiovský len = received - dev_desc->SerialNumberOffset;
827fb08aa70STomáš Golembiovský g_debug("serial number \"%s\"", serial);
828fb08aa70STomáš Golembiovský if (*serial != 0) {
829fb08aa70STomáš Golembiovský disk->serial = g_strndup(serial, len);
830fb08aa70STomáš Golembiovský }
831fb08aa70STomáš Golembiovský }
832fb08aa70STomáš Golembiovský out_free:
833fb08aa70STomáš Golembiovský g_free(dev_desc);
834fb08aa70STomáš Golembiovský
835c76d70f4STomáš Golembiovský return;
836a3ef3b22SOlga Krishtal }
837a3ef3b22SOlga Krishtal
get_single_disk_info(int disk_number,GuestDiskAddress * disk,Error ** errp)838996b9cdcSMatt Hines static void get_single_disk_info(int disk_number,
839996b9cdcSMatt Hines GuestDiskAddress *disk, Error **errp)
840a3ef3b22SOlga Krishtal {
841a3ef3b22SOlga Krishtal SCSI_ADDRESS addr, *scsi_ad;
842a3ef3b22SOlga Krishtal DWORD len;
843b1ba8890STomáš Golembiovský HANDLE disk_h;
8446880b94fSSameeh Jubran Error *local_err = NULL;
845a3ef3b22SOlga Krishtal
846a3ef3b22SOlga Krishtal scsi_ad = &addr;
847a3ef3b22SOlga Krishtal
8484550dee8STomáš Golembiovský g_debug("getting disk info for: %s", disk->dev);
8494550dee8STomáš Golembiovský disk_h = CreateFile(disk->dev, 0, FILE_SHARE_READ, NULL, OPEN_EXISTING,
850a3ef3b22SOlga Krishtal 0, NULL);
851b1ba8890STomáš Golembiovský if (disk_h == INVALID_HANDLE_VALUE) {
852b1ba8890STomáš Golembiovský error_setg_win32(errp, GetLastError(), "failed to open disk");
853b1ba8890STomáš Golembiovský return;
854a3ef3b22SOlga Krishtal }
855a3ef3b22SOlga Krishtal
856b1ba8890STomáš Golembiovský get_disk_properties(disk_h, disk, &local_err);
857c76d70f4STomáš Golembiovský if (local_err) {
858c76d70f4STomáš Golembiovský error_propagate(errp, local_err);
859c76d70f4STomáš Golembiovský goto err_close;
860c76d70f4STomáš Golembiovský }
861c76d70f4STomáš Golembiovský
862222682abSTomáš Golembiovský g_debug("bus type %d", disk->bus_type);
8636880b94fSSameeh Jubran /* always set pci_controller as required by schema. get_pci_info() should
8646880b94fSSameeh Jubran * report -1 values for non-PCI buses rather than fail. fail the command
8656880b94fSSameeh Jubran * if that doesn't hold since that suggests some other unexpected
8666880b94fSSameeh Jubran * breakage
8676880b94fSSameeh Jubran */
868cce910f2SKfir Manor if (disk->bus_type == GUEST_DISK_BUS_TYPE_USB) {
869cce910f2SKfir Manor disk->pci_controller = get_empty_pci_address();
870cce910f2SKfir Manor } else {
871996b9cdcSMatt Hines disk->pci_controller = get_pci_info(disk_number, &local_err);
8726880b94fSSameeh Jubran if (local_err) {
8736880b94fSSameeh Jubran error_propagate(errp, local_err);
874c76d70f4STomáš Golembiovský goto err_close;
8756880b94fSSameeh Jubran }
876cce910f2SKfir Manor }
877c76d70f4STomáš Golembiovský if (disk->bus_type == GUEST_DISK_BUS_TYPE_SCSI
878c76d70f4STomáš Golembiovský || disk->bus_type == GUEST_DISK_BUS_TYPE_IDE
879c76d70f4STomáš Golembiovský || disk->bus_type == GUEST_DISK_BUS_TYPE_RAID
880a3ef3b22SOlga Krishtal /* This bus type is not supported before Windows Server 2003 SP1 */
881c76d70f4STomáš Golembiovský || disk->bus_type == GUEST_DISK_BUS_TYPE_SAS
882a3ef3b22SOlga Krishtal ) {
883a3ef3b22SOlga Krishtal /* We are able to use the same ioctls for different bus types
884a3ef3b22SOlga Krishtal * according to Microsoft docs
885a3ef3b22SOlga Krishtal * https://technet.microsoft.com/en-us/library/ee851589(v=ws.10).aspx */
886996b9cdcSMatt Hines g_debug("getting SCSI info");
887b1ba8890STomáš Golembiovský if (DeviceIoControl(disk_h, IOCTL_SCSI_GET_ADDRESS, NULL, 0, scsi_ad,
888a3ef3b22SOlga Krishtal sizeof(SCSI_ADDRESS), &len, NULL)) {
889a3ef3b22SOlga Krishtal disk->unit = addr.Lun;
890a3ef3b22SOlga Krishtal disk->target = addr.TargetId;
891a3ef3b22SOlga Krishtal disk->bus = addr.PathId;
892a3ef3b22SOlga Krishtal }
893a3ef3b22SOlga Krishtal /* We do not set error in this case, because we still have enough
894a3ef3b22SOlga Krishtal * information about volume. */
895a3ef3b22SOlga Krishtal }
896a3ef3b22SOlga Krishtal
897c76d70f4STomáš Golembiovský err_close:
898b1ba8890STomáš Golembiovský CloseHandle(disk_h);
8999e65fd65STomáš Golembiovský return;
9009e65fd65STomáš Golembiovský }
9019e65fd65STomáš Golembiovský
9029e65fd65STomáš Golembiovský /* VSS provider works with volumes, thus there is no difference if
9039e65fd65STomáš Golembiovský * the volume consist of spanned disks. Info about the first disk in the
9049e65fd65STomáš Golembiovský * volume is returned for the spanned disk group (LVM) */
build_guest_disk_info(char * guid,Error ** errp)9059e65fd65STomáš Golembiovský static GuestDiskAddressList *build_guest_disk_info(char *guid, Error **errp)
9069e65fd65STomáš Golembiovský {
9079e65fd65STomáš Golembiovský Error *local_err = NULL;
90854aa3de7SEric Blake GuestDiskAddressList *list = NULL;
9099e65fd65STomáš Golembiovský GuestDiskAddress *disk = NULL;
910b1ba8890STomáš Golembiovský int i;
911b1ba8890STomáš Golembiovský HANDLE vol_h;
912b1ba8890STomáš Golembiovský DWORD size;
913b1ba8890STomáš Golembiovský PVOLUME_DISK_EXTENTS extents = NULL;
9149e65fd65STomáš Golembiovský
9159e65fd65STomáš Golembiovský /* strip final backslash */
9169e65fd65STomáš Golembiovský char *name = g_strdup(guid);
9179e65fd65STomáš Golembiovský if (g_str_has_suffix(name, "\\")) {
9189e65fd65STomáš Golembiovský name[strlen(name) - 1] = 0;
9199e65fd65STomáš Golembiovský }
9209e65fd65STomáš Golembiovský
921b1ba8890STomáš Golembiovský g_debug("opening %s", name);
922b1ba8890STomáš Golembiovský vol_h = CreateFile(name, 0, FILE_SHARE_READ, NULL, OPEN_EXISTING,
923b1ba8890STomáš Golembiovský 0, NULL);
924b1ba8890STomáš Golembiovský if (vol_h == INVALID_HANDLE_VALUE) {
925b1ba8890STomáš Golembiovský error_setg_win32(errp, GetLastError(), "failed to open volume");
926b1ba8890STomáš Golembiovský goto out;
927b1ba8890STomáš Golembiovský }
928b1ba8890STomáš Golembiovský
929b1ba8890STomáš Golembiovský /* Get list of extents */
930b1ba8890STomáš Golembiovský g_debug("getting disk extents");
931b1ba8890STomáš Golembiovský size = sizeof(VOLUME_DISK_EXTENTS);
932b1ba8890STomáš Golembiovský extents = g_malloc0(size);
933b1ba8890STomáš Golembiovský if (!DeviceIoControl(vol_h, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL,
934996b9cdcSMatt Hines 0, extents, size, &size, NULL)) {
935b1ba8890STomáš Golembiovský DWORD last_err = GetLastError();
936b1ba8890STomáš Golembiovský if (last_err == ERROR_MORE_DATA) {
937b1ba8890STomáš Golembiovský /* Try once more with big enough buffer */
938b1ba8890STomáš Golembiovský g_free(extents);
939b1ba8890STomáš Golembiovský extents = g_malloc0(size);
940b1ba8890STomáš Golembiovský if (!DeviceIoControl(
941b1ba8890STomáš Golembiovský vol_h, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL,
942b1ba8890STomáš Golembiovský 0, extents, size, NULL, NULL)) {
943b1ba8890STomáš Golembiovský error_setg_win32(errp, GetLastError(),
944b1ba8890STomáš Golembiovský "failed to get disk extents");
945f898ee0fSMarc-André Lureau goto out;
946b1ba8890STomáš Golembiovský }
947b1ba8890STomáš Golembiovský } else if (last_err == ERROR_INVALID_FUNCTION) {
948b1ba8890STomáš Golembiovský /* Possibly CD-ROM or a shared drive. Try to pass the volume */
949b1ba8890STomáš Golembiovský g_debug("volume not on disk");
950b21e2380SMarkus Armbruster disk = g_new0(GuestDiskAddress, 1);
9514550dee8STomáš Golembiovský disk->dev = g_strdup(name);
952996b9cdcSMatt Hines get_single_disk_info(0xffffffff, disk, &local_err);
9539e65fd65STomáš Golembiovský if (local_err) {
954b1ba8890STomáš Golembiovský g_debug("failed to get disk info, ignoring error: %s",
955b1ba8890STomáš Golembiovský error_get_pretty(local_err));
956b1ba8890STomáš Golembiovský error_free(local_err);
957b1ba8890STomáš Golembiovský goto out;
958b1ba8890STomáš Golembiovský }
95954aa3de7SEric Blake QAPI_LIST_PREPEND(list, disk);
960b1ba8890STomáš Golembiovský disk = NULL;
961b1ba8890STomáš Golembiovský goto out;
962b1ba8890STomáš Golembiovský } else {
963b1ba8890STomáš Golembiovský error_setg_win32(errp, GetLastError(),
964b1ba8890STomáš Golembiovský "failed to get disk extents");
965b1ba8890STomáš Golembiovský goto out;
966b1ba8890STomáš Golembiovský }
967b1ba8890STomáš Golembiovský }
968b1ba8890STomáš Golembiovský g_debug("Number of extents: %lu", extents->NumberOfDiskExtents);
969b1ba8890STomáš Golembiovský
970b1ba8890STomáš Golembiovský /* Go through each extent */
971b1ba8890STomáš Golembiovský for (i = 0; i < extents->NumberOfDiskExtents; i++) {
972b21e2380SMarkus Armbruster disk = g_new0(GuestDiskAddress, 1);
973b1ba8890STomáš Golembiovský
974b1ba8890STomáš Golembiovský /* Disk numbers directly correspond to numbers used in UNCs
975b1ba8890STomáš Golembiovský *
976b1ba8890STomáš Golembiovský * See documentation for DISK_EXTENT:
977b1ba8890STomáš Golembiovský * https://docs.microsoft.com/en-us/windows/desktop/api/winioctl/ns-winioctl-_disk_extent
978b1ba8890STomáš Golembiovský *
979b1ba8890STomáš Golembiovský * See also Naming Files, Paths and Namespaces:
980b1ba8890STomáš Golembiovský * https://docs.microsoft.com/en-us/windows/desktop/FileIO/naming-a-file#win32-device-namespaces
981b1ba8890STomáš Golembiovský */
9824550dee8STomáš Golembiovský disk->dev = g_strdup_printf("\\\\.\\PhysicalDrive%lu",
983b1ba8890STomáš Golembiovský extents->Extents[i].DiskNumber);
9844550dee8STomáš Golembiovský
985996b9cdcSMatt Hines get_single_disk_info(extents->Extents[i].DiskNumber, disk, &local_err);
986b1ba8890STomáš Golembiovský if (local_err) {
9879e65fd65STomáš Golembiovský error_propagate(errp, local_err);
9889e65fd65STomáš Golembiovský goto out;
9899e65fd65STomáš Golembiovský }
99054aa3de7SEric Blake QAPI_LIST_PREPEND(list, disk);
9919e65fd65STomáš Golembiovský disk = NULL;
992b1ba8890STomáš Golembiovský }
993b1ba8890STomáš Golembiovský
9949e65fd65STomáš Golembiovský
9959e65fd65STomáš Golembiovský out:
996f898ee0fSMarc-André Lureau if (vol_h != INVALID_HANDLE_VALUE) {
997f898ee0fSMarc-André Lureau CloseHandle(vol_h);
998f898ee0fSMarc-André Lureau }
9999e65fd65STomáš Golembiovský qapi_free_GuestDiskAddress(disk);
1000b1ba8890STomáš Golembiovský g_free(extents);
1001c76d70f4STomáš Golembiovský g_free(name);
1002c76d70f4STomáš Golembiovský
10039e65fd65STomáš Golembiovský return list;
1004a3ef3b22SOlga Krishtal }
1005a3ef3b22SOlga Krishtal
qmp_guest_get_disks(Error ** errp)1006c67d2efdSTomáš Golembiovský GuestDiskInfoList *qmp_guest_get_disks(Error **errp)
1007c67d2efdSTomáš Golembiovský {
100854aa3de7SEric Blake GuestDiskInfoList *ret = NULL;
1009c67d2efdSTomáš Golembiovský HDEVINFO dev_info;
1010c67d2efdSTomáš Golembiovský SP_DEVICE_INTERFACE_DATA dev_iface_data;
1011c67d2efdSTomáš Golembiovský int i;
1012c67d2efdSTomáš Golembiovský
1013c67d2efdSTomáš Golembiovský dev_info = SetupDiGetClassDevs(&GUID_DEVINTERFACE_DISK, 0, 0,
1014c67d2efdSTomáš Golembiovský DIGCF_PRESENT | DIGCF_DEVICEINTERFACE);
1015c67d2efdSTomáš Golembiovský if (dev_info == INVALID_HANDLE_VALUE) {
1016c67d2efdSTomáš Golembiovský error_setg_win32(errp, GetLastError(), "failed to get device tree");
1017c67d2efdSTomáš Golembiovský return NULL;
1018c67d2efdSTomáš Golembiovský }
1019c67d2efdSTomáš Golembiovský
1020c67d2efdSTomáš Golembiovský g_debug("enumerating devices");
1021c67d2efdSTomáš Golembiovský dev_iface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA);
1022c67d2efdSTomáš Golembiovský for (i = 0;
1023c67d2efdSTomáš Golembiovský SetupDiEnumDeviceInterfaces(dev_info, NULL, &GUID_DEVINTERFACE_DISK,
1024c67d2efdSTomáš Golembiovský i, &dev_iface_data);
1025c67d2efdSTomáš Golembiovský i++) {
1026c67d2efdSTomáš Golembiovský GuestDiskAddress *address = NULL;
1027c67d2efdSTomáš Golembiovský GuestDiskInfo *disk = NULL;
1028c67d2efdSTomáš Golembiovský Error *local_err = NULL;
1029c67d2efdSTomáš Golembiovský g_autofree PSP_DEVICE_INTERFACE_DETAIL_DATA
1030c67d2efdSTomáš Golembiovský pdev_iface_detail_data = NULL;
1031c67d2efdSTomáš Golembiovský STORAGE_DEVICE_NUMBER sdn;
1032c67d2efdSTomáš Golembiovský HANDLE dev_file;
1033c67d2efdSTomáš Golembiovský DWORD size = 0;
1034c67d2efdSTomáš Golembiovský BOOL result;
1035c67d2efdSTomáš Golembiovský int attempt;
1036c67d2efdSTomáš Golembiovský
1037c67d2efdSTomáš Golembiovský g_debug(" getting device path");
1038c67d2efdSTomáš Golembiovský for (attempt = 0, result = FALSE; attempt < 2 && !result; attempt++) {
1039c67d2efdSTomáš Golembiovský result = SetupDiGetDeviceInterfaceDetail(dev_info,
1040c67d2efdSTomáš Golembiovský &dev_iface_data, pdev_iface_detail_data, size, &size, NULL);
1041c67d2efdSTomáš Golembiovský if (result) {
1042c67d2efdSTomáš Golembiovský break;
1043c67d2efdSTomáš Golembiovský }
1044c67d2efdSTomáš Golembiovský if (GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
1045c67d2efdSTomáš Golembiovský pdev_iface_detail_data = g_realloc(pdev_iface_detail_data,
1046c67d2efdSTomáš Golembiovský size);
1047c67d2efdSTomáš Golembiovský pdev_iface_detail_data->cbSize =
1048c67d2efdSTomáš Golembiovský sizeof(*pdev_iface_detail_data);
1049c67d2efdSTomáš Golembiovský } else {
1050c67d2efdSTomáš Golembiovský g_debug("failed to get device interface details");
1051c67d2efdSTomáš Golembiovský break;
1052c67d2efdSTomáš Golembiovský }
1053c67d2efdSTomáš Golembiovský }
1054c67d2efdSTomáš Golembiovský if (!result) {
1055c67d2efdSTomáš Golembiovský g_debug("skipping device");
1056c67d2efdSTomáš Golembiovský continue;
1057c67d2efdSTomáš Golembiovský }
1058c67d2efdSTomáš Golembiovský
1059c67d2efdSTomáš Golembiovský g_debug(" device: %s", pdev_iface_detail_data->DevicePath);
1060c67d2efdSTomáš Golembiovský dev_file = CreateFile(pdev_iface_detail_data->DevicePath, 0,
1061c67d2efdSTomáš Golembiovský FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
1062c67d2efdSTomáš Golembiovský if (!DeviceIoControl(dev_file, IOCTL_STORAGE_GET_DEVICE_NUMBER,
1063c67d2efdSTomáš Golembiovský NULL, 0, &sdn, sizeof(sdn), &size, NULL)) {
1064c67d2efdSTomáš Golembiovský CloseHandle(dev_file);
1065c67d2efdSTomáš Golembiovský debug_error("failed to get storage device number");
1066c67d2efdSTomáš Golembiovský continue;
1067c67d2efdSTomáš Golembiovský }
1068c67d2efdSTomáš Golembiovský CloseHandle(dev_file);
1069c67d2efdSTomáš Golembiovský
1070c67d2efdSTomáš Golembiovský disk = g_new0(GuestDiskInfo, 1);
1071c67d2efdSTomáš Golembiovský disk->name = g_strdup_printf("\\\\.\\PhysicalDrive%lu",
1072c67d2efdSTomáš Golembiovský sdn.DeviceNumber);
1073c67d2efdSTomáš Golembiovský
1074c67d2efdSTomáš Golembiovský g_debug(" number: %lu", sdn.DeviceNumber);
1075b21e2380SMarkus Armbruster address = g_new0(GuestDiskAddress, 1);
1076c67d2efdSTomáš Golembiovský address->dev = g_strdup(disk->name);
1077c67d2efdSTomáš Golembiovský get_single_disk_info(sdn.DeviceNumber, address, &local_err);
1078c67d2efdSTomáš Golembiovský if (local_err) {
1079c67d2efdSTomáš Golembiovský g_debug("failed to get disk info: %s",
1080c67d2efdSTomáš Golembiovský error_get_pretty(local_err));
1081c67d2efdSTomáš Golembiovský error_free(local_err);
1082c67d2efdSTomáš Golembiovský qapi_free_GuestDiskAddress(address);
1083c67d2efdSTomáš Golembiovský address = NULL;
1084c67d2efdSTomáš Golembiovský } else {
1085c67d2efdSTomáš Golembiovský disk->address = address;
1086c67d2efdSTomáš Golembiovský }
1087c67d2efdSTomáš Golembiovský
108854aa3de7SEric Blake QAPI_LIST_PREPEND(ret, disk);
1089c67d2efdSTomáš Golembiovský }
1090c67d2efdSTomáš Golembiovský
1091c67d2efdSTomáš Golembiovský SetupDiDestroyDeviceInfoList(dev_info);
1092c67d2efdSTomáš Golembiovský return ret;
1093c67d2efdSTomáš Golembiovský }
1094c67d2efdSTomáš Golembiovský
build_guest_fsinfo(char * guid,Error ** errp)1095d2b3f390SOlga Krishtal static GuestFilesystemInfo *build_guest_fsinfo(char *guid, Error **errp)
1096d2b3f390SOlga Krishtal {
1097d2b3f390SOlga Krishtal DWORD info_size;
1098d2b3f390SOlga Krishtal char mnt, *mnt_point;
10993aaebc0cSBasil Salman wchar_t wfs_name[32];
1100d2b3f390SOlga Krishtal char fs_name[32];
11013aaebc0cSBasil Salman wchar_t vol_info[MAX_PATH + 1];
1102d2b3f390SOlga Krishtal size_t len;
1103c07e5e6eSChen Hanxiao uint64_t i64FreeBytesToCaller, i64TotalBytes, i64FreeBytes;
1104d2b3f390SOlga Krishtal GuestFilesystemInfo *fs = NULL;
110502ac3f4bSBasil Salman HANDLE hLocalDiskHandle = INVALID_HANDLE_VALUE;
1106d2b3f390SOlga Krishtal
1107d2b3f390SOlga Krishtal GetVolumePathNamesForVolumeName(guid, (LPCH)&mnt, 0, &info_size);
1108d2b3f390SOlga Krishtal if (GetLastError() != ERROR_MORE_DATA) {
1109d2b3f390SOlga Krishtal error_setg_win32(errp, GetLastError(), "failed to get volume name");
1110d2b3f390SOlga Krishtal return NULL;
1111d2b3f390SOlga Krishtal }
1112d2b3f390SOlga Krishtal
1113d2b3f390SOlga Krishtal mnt_point = g_malloc(info_size + 1);
1114d2b3f390SOlga Krishtal if (!GetVolumePathNamesForVolumeName(guid, mnt_point, info_size,
1115d2b3f390SOlga Krishtal &info_size)) {
1116d2b3f390SOlga Krishtal error_setg_win32(errp, GetLastError(), "failed to get volume name");
1117d2b3f390SOlga Krishtal goto free;
1118d2b3f390SOlga Krishtal }
1119d2b3f390SOlga Krishtal
11203aaebc0cSBasil Salman hLocalDiskHandle = CreateFile(guid, 0 , 0, NULL, OPEN_EXISTING,
11213aaebc0cSBasil Salman FILE_ATTRIBUTE_NORMAL |
11223aaebc0cSBasil Salman FILE_FLAG_BACKUP_SEMANTICS, NULL);
11233aaebc0cSBasil Salman if (INVALID_HANDLE_VALUE == hLocalDiskHandle) {
11243aaebc0cSBasil Salman error_setg_win32(errp, GetLastError(), "failed to get handle for volume");
11253aaebc0cSBasil Salman goto free;
11263aaebc0cSBasil Salman }
11273aaebc0cSBasil Salman
1128d2b3f390SOlga Krishtal len = strlen(mnt_point);
1129d2b3f390SOlga Krishtal mnt_point[len] = '\\';
1130d2b3f390SOlga Krishtal mnt_point[len + 1] = 0;
11313aaebc0cSBasil Salman
11323aaebc0cSBasil Salman if (!GetVolumeInformationByHandleW(hLocalDiskHandle, vol_info,
11333aaebc0cSBasil Salman sizeof(vol_info), NULL, NULL, NULL,
11343aaebc0cSBasil Salman (LPWSTR) & wfs_name, sizeof(wfs_name))) {
1135d2b3f390SOlga Krishtal if (GetLastError() != ERROR_NOT_READY) {
1136d2b3f390SOlga Krishtal error_setg_win32(errp, GetLastError(), "failed to get volume info");
1137d2b3f390SOlga Krishtal }
1138d2b3f390SOlga Krishtal goto free;
1139d2b3f390SOlga Krishtal }
1140d2b3f390SOlga Krishtal
1141d2b3f390SOlga Krishtal fs = g_malloc(sizeof(*fs));
1142d2b3f390SOlga Krishtal fs->name = g_strdup(guid);
1143c07e5e6eSChen Hanxiao fs->has_total_bytes = false;
1144c07e5e6eSChen Hanxiao fs->has_used_bytes = false;
1145d2b3f390SOlga Krishtal if (len == 0) {
1146d2b3f390SOlga Krishtal fs->mountpoint = g_strdup("System Reserved");
1147d2b3f390SOlga Krishtal } else {
1148d2b3f390SOlga Krishtal fs->mountpoint = g_strndup(mnt_point, len);
1149c07e5e6eSChen Hanxiao if (GetDiskFreeSpaceEx(fs->mountpoint,
1150c07e5e6eSChen Hanxiao (PULARGE_INTEGER) & i64FreeBytesToCaller,
1151c07e5e6eSChen Hanxiao (PULARGE_INTEGER) & i64TotalBytes,
1152c07e5e6eSChen Hanxiao (PULARGE_INTEGER) & i64FreeBytes)) {
1153c07e5e6eSChen Hanxiao fs->used_bytes = i64TotalBytes - i64FreeBytes;
1154c07e5e6eSChen Hanxiao fs->total_bytes = i64TotalBytes;
1155c07e5e6eSChen Hanxiao fs->has_total_bytes = true;
1156c07e5e6eSChen Hanxiao fs->has_used_bytes = true;
1157c07e5e6eSChen Hanxiao }
1158d2b3f390SOlga Krishtal }
11593aaebc0cSBasil Salman wcstombs(fs_name, wfs_name, sizeof(wfs_name));
1160d2b3f390SOlga Krishtal fs->type = g_strdup(fs_name);
1161a8f15a27SDaniel P. Berrange fs->disk = build_guest_disk_info(guid, errp);
1162d2b3f390SOlga Krishtal free:
116302ac3f4bSBasil Salman if (hLocalDiskHandle != INVALID_HANDLE_VALUE) {
11643aaebc0cSBasil Salman CloseHandle(hLocalDiskHandle);
116502ac3f4bSBasil Salman }
1166d2b3f390SOlga Krishtal g_free(mnt_point);
1167d2b3f390SOlga Krishtal return fs;
1168d2b3f390SOlga Krishtal }
1169d2b3f390SOlga Krishtal
qmp_guest_get_fsinfo(Error ** errp)117046d4c572STomoki Sekiyama GuestFilesystemInfoList *qmp_guest_get_fsinfo(Error **errp)
117146d4c572STomoki Sekiyama {
1172ef0a03f2SOlga Krishtal HANDLE vol_h;
117354aa3de7SEric Blake GuestFilesystemInfoList *ret = NULL;
1174ef0a03f2SOlga Krishtal char guid[256];
1175ef0a03f2SOlga Krishtal
1176ef0a03f2SOlga Krishtal vol_h = FindFirstVolume(guid, sizeof(guid));
1177ef0a03f2SOlga Krishtal if (vol_h == INVALID_HANDLE_VALUE) {
1178ef0a03f2SOlga Krishtal error_setg_win32(errp, GetLastError(), "failed to find any volume");
117946d4c572STomoki Sekiyama return NULL;
118046d4c572STomoki Sekiyama }
118146d4c572STomoki Sekiyama
1182ef0a03f2SOlga Krishtal do {
11833aaebc0cSBasil Salman Error *local_err = NULL;
11843aaebc0cSBasil Salman GuestFilesystemInfo *info = build_guest_fsinfo(guid, &local_err);
11853aaebc0cSBasil Salman if (local_err) {
11863aaebc0cSBasil Salman g_debug("failed to get filesystem info, ignoring error: %s",
11873aaebc0cSBasil Salman error_get_pretty(local_err));
11883aaebc0cSBasil Salman error_free(local_err);
1189d2b3f390SOlga Krishtal continue;
1190d2b3f390SOlga Krishtal }
119154aa3de7SEric Blake QAPI_LIST_PREPEND(ret, info);
1192ef0a03f2SOlga Krishtal } while (FindNextVolume(vol_h, guid, sizeof(guid)));
1193ef0a03f2SOlga Krishtal
1194ef0a03f2SOlga Krishtal if (GetLastError() != ERROR_NO_MORE_FILES) {
1195ef0a03f2SOlga Krishtal error_setg_win32(errp, GetLastError(), "failed to find next volume");
1196ef0a03f2SOlga Krishtal }
1197ef0a03f2SOlga Krishtal
1198ef0a03f2SOlga Krishtal FindVolumeClose(vol_h);
1199ef0a03f2SOlga Krishtal return ret;
1200ef0a03f2SOlga Krishtal }
1201ef0a03f2SOlga Krishtal
1202d8ca685aSMichael Roth /*
1203d8ca685aSMichael Roth * Return status of freeze/thaw
1204d8ca685aSMichael Roth */
qmp_guest_fsfreeze_status(Error ** errp)120577dbc81bSMarkus Armbruster GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp)
1206d8ca685aSMichael Roth {
120764c00317STomoki Sekiyama if (!vss_initialized()) {
1208c6bd8c70SMarkus Armbruster error_setg(errp, QERR_UNSUPPORTED);
1209d8ca685aSMichael Roth return 0;
1210d8ca685aSMichael Roth }
1211d8ca685aSMichael Roth
121264c00317STomoki Sekiyama if (ga_is_frozen(ga_state)) {
121364c00317STomoki Sekiyama return GUEST_FSFREEZE_STATUS_FROZEN;
121464c00317STomoki Sekiyama }
121564c00317STomoki Sekiyama
121664c00317STomoki Sekiyama return GUEST_FSFREEZE_STATUS_THAWED;
121764c00317STomoki Sekiyama }
121864c00317STomoki Sekiyama
1219d8ca685aSMichael Roth /*
122064c00317STomoki Sekiyama * Freeze local file systems using Volume Shadow-copy Service.
122164c00317STomoki Sekiyama * The frozen state is limited for up to 10 seconds by VSS.
1222d8ca685aSMichael Roth */
qmp_guest_fsfreeze_freeze(Error ** errp)122377dbc81bSMarkus Armbruster int64_t qmp_guest_fsfreeze_freeze(Error **errp)
1224d8ca685aSMichael Roth {
12250692b03eSChen Hanxiao return qmp_guest_fsfreeze_freeze_list(false, NULL, errp);
12260692b03eSChen Hanxiao }
12270692b03eSChen Hanxiao
qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,strList * mountpoints,Error ** errp)12280692b03eSChen Hanxiao int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,
12290692b03eSChen Hanxiao strList *mountpoints,
12300692b03eSChen Hanxiao Error **errp)
12310692b03eSChen Hanxiao {
123264c00317STomoki Sekiyama int i;
123364c00317STomoki Sekiyama Error *local_err = NULL;
123464c00317STomoki Sekiyama
123564c00317STomoki Sekiyama if (!vss_initialized()) {
1236c6bd8c70SMarkus Armbruster error_setg(errp, QERR_UNSUPPORTED);
1237d8ca685aSMichael Roth return 0;
1238d8ca685aSMichael Roth }
1239d8ca685aSMichael Roth
124064c00317STomoki Sekiyama slog("guest-fsfreeze called");
124164c00317STomoki Sekiyama
124264c00317STomoki Sekiyama /* cannot risk guest agent blocking itself on a write in this state */
124364c00317STomoki Sekiyama ga_set_frozen(ga_state);
124464c00317STomoki Sekiyama
12450692b03eSChen Hanxiao qga_vss_fsfreeze(&i, true, mountpoints, &local_err);
12460f230bf7SMarkus Armbruster if (local_err) {
12470f230bf7SMarkus Armbruster error_propagate(errp, local_err);
124864c00317STomoki Sekiyama goto error;
124964c00317STomoki Sekiyama }
125064c00317STomoki Sekiyama
125164c00317STomoki Sekiyama return i;
125264c00317STomoki Sekiyama
125364c00317STomoki Sekiyama error:
12540f230bf7SMarkus Armbruster local_err = NULL;
125564c00317STomoki Sekiyama qmp_guest_fsfreeze_thaw(&local_err);
125684d18f06SMarkus Armbruster if (local_err) {
125764c00317STomoki Sekiyama g_debug("cleanup thaw: %s", error_get_pretty(local_err));
125864c00317STomoki Sekiyama error_free(local_err);
125964c00317STomoki Sekiyama }
126064c00317STomoki Sekiyama return 0;
126164c00317STomoki Sekiyama }
126264c00317STomoki Sekiyama
1263d8ca685aSMichael Roth /*
126464c00317STomoki Sekiyama * Thaw local file systems using Volume Shadow-copy Service.
1265d8ca685aSMichael Roth */
qmp_guest_fsfreeze_thaw(Error ** errp)126677dbc81bSMarkus Armbruster int64_t qmp_guest_fsfreeze_thaw(Error **errp)
1267d8ca685aSMichael Roth {
126864c00317STomoki Sekiyama int i;
126964c00317STomoki Sekiyama
127064c00317STomoki Sekiyama if (!vss_initialized()) {
1271c6bd8c70SMarkus Armbruster error_setg(errp, QERR_UNSUPPORTED);
1272d8ca685aSMichael Roth return 0;
1273d8ca685aSMichael Roth }
1274d8ca685aSMichael Roth
12750692b03eSChen Hanxiao qga_vss_fsfreeze(&i, false, NULL, errp);
127664c00317STomoki Sekiyama
127764c00317STomoki Sekiyama ga_unset_frozen(ga_state);
127864c00317STomoki Sekiyama return i;
127964c00317STomoki Sekiyama }
128064c00317STomoki Sekiyama
guest_fsfreeze_cleanup(void)128164c00317STomoki Sekiyama static void guest_fsfreeze_cleanup(void)
128264c00317STomoki Sekiyama {
128364c00317STomoki Sekiyama Error *err = NULL;
128464c00317STomoki Sekiyama
128564c00317STomoki Sekiyama if (!vss_initialized()) {
128664c00317STomoki Sekiyama return;
128764c00317STomoki Sekiyama }
128864c00317STomoki Sekiyama
128964c00317STomoki Sekiyama if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) {
129064c00317STomoki Sekiyama qmp_guest_fsfreeze_thaw(&err);
129164c00317STomoki Sekiyama if (err) {
129264c00317STomoki Sekiyama slog("failed to clean up frozen filesystems: %s",
129364c00317STomoki Sekiyama error_get_pretty(err));
129464c00317STomoki Sekiyama error_free(err);
129564c00317STomoki Sekiyama }
129664c00317STomoki Sekiyama }
129764c00317STomoki Sekiyama
129864c00317STomoki Sekiyama vss_deinit(true);
129964c00317STomoki Sekiyama }
130064c00317STomoki Sekiyama
1301eab5fd59SPaolo Bonzini /*
1302eab5fd59SPaolo Bonzini * Walk list of mounted file systems in the guest, and discard unused
1303eab5fd59SPaolo Bonzini * areas.
1304eab5fd59SPaolo Bonzini */
1305e82855d9SJustin Ossevoort GuestFilesystemTrimResponse *
qmp_guest_fstrim(bool has_minimum,int64_t minimum,Error ** errp)1306e82855d9SJustin Ossevoort qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
1307eab5fd59SPaolo Bonzini {
130891274487SDenis V. Lunev GuestFilesystemTrimResponse *resp;
130991274487SDenis V. Lunev HANDLE handle;
131091274487SDenis V. Lunev WCHAR guid[MAX_PATH] = L"";
1311c5840b90SSameeh Jubran OSVERSIONINFO osvi;
1312c5840b90SSameeh Jubran BOOL win8_or_later;
1313c5840b90SSameeh Jubran
1314c5840b90SSameeh Jubran ZeroMemory(&osvi, sizeof(OSVERSIONINFO));
1315c5840b90SSameeh Jubran osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1316c5840b90SSameeh Jubran GetVersionEx(&osvi);
1317c5840b90SSameeh Jubran win8_or_later = (osvi.dwMajorVersion > 6 ||
1318c5840b90SSameeh Jubran ((osvi.dwMajorVersion == 6) &&
1319c5840b90SSameeh Jubran (osvi.dwMinorVersion >= 2)));
1320c5840b90SSameeh Jubran if (!win8_or_later) {
1321c5840b90SSameeh Jubran error_setg(errp, "fstrim is only supported for Win8+");
1322c5840b90SSameeh Jubran return NULL;
1323c5840b90SSameeh Jubran }
132491274487SDenis V. Lunev
132591274487SDenis V. Lunev handle = FindFirstVolumeW(guid, ARRAYSIZE(guid));
132691274487SDenis V. Lunev if (handle == INVALID_HANDLE_VALUE) {
132791274487SDenis V. Lunev error_setg_win32(errp, GetLastError(), "failed to find any volume");
1328e82855d9SJustin Ossevoort return NULL;
1329eab5fd59SPaolo Bonzini }
1330eab5fd59SPaolo Bonzini
133191274487SDenis V. Lunev resp = g_new0(GuestFilesystemTrimResponse, 1);
133291274487SDenis V. Lunev
133391274487SDenis V. Lunev do {
133491274487SDenis V. Lunev GuestFilesystemTrimResult *res;
133591274487SDenis V. Lunev PWCHAR uc_path;
133691274487SDenis V. Lunev DWORD char_count = 0;
133791274487SDenis V. Lunev char *path, *out;
133891274487SDenis V. Lunev GError *gerr = NULL;
133991274487SDenis V. Lunev gchar *argv[4];
134091274487SDenis V. Lunev
134191274487SDenis V. Lunev GetVolumePathNamesForVolumeNameW(guid, NULL, 0, &char_count);
134291274487SDenis V. Lunev
134391274487SDenis V. Lunev if (GetLastError() != ERROR_MORE_DATA) {
134491274487SDenis V. Lunev continue;
134591274487SDenis V. Lunev }
134691274487SDenis V. Lunev if (GetDriveTypeW(guid) != DRIVE_FIXED) {
134791274487SDenis V. Lunev continue;
134891274487SDenis V. Lunev }
134991274487SDenis V. Lunev
1350b21e2380SMarkus Armbruster uc_path = g_new(WCHAR, char_count);
135191274487SDenis V. Lunev if (!GetVolumePathNamesForVolumeNameW(guid, uc_path, char_count,
135291274487SDenis V. Lunev &char_count) || !*uc_path) {
135391274487SDenis V. Lunev /* strange, but this condition could be faced even with size == 2 */
135491274487SDenis V. Lunev g_free(uc_path);
135591274487SDenis V. Lunev continue;
135691274487SDenis V. Lunev }
135791274487SDenis V. Lunev
135891274487SDenis V. Lunev res = g_new0(GuestFilesystemTrimResult, 1);
135991274487SDenis V. Lunev
136091274487SDenis V. Lunev path = g_utf16_to_utf8(uc_path, char_count, NULL, NULL, &gerr);
136191274487SDenis V. Lunev
136291274487SDenis V. Lunev g_free(uc_path);
136391274487SDenis V. Lunev
136491274487SDenis V. Lunev if (!path) {
136591274487SDenis V. Lunev res->error = g_strdup(gerr->message);
136691274487SDenis V. Lunev g_error_free(gerr);
136791274487SDenis V. Lunev break;
136891274487SDenis V. Lunev }
136991274487SDenis V. Lunev
137091274487SDenis V. Lunev res->path = path;
137191274487SDenis V. Lunev
137254aa3de7SEric Blake QAPI_LIST_PREPEND(resp->paths, res);
137391274487SDenis V. Lunev
137491274487SDenis V. Lunev memset(argv, 0, sizeof(argv));
137591274487SDenis V. Lunev argv[0] = (gchar *)"defrag.exe";
137691274487SDenis V. Lunev argv[1] = (gchar *)"/L";
137791274487SDenis V. Lunev argv[2] = path;
137891274487SDenis V. Lunev
137991274487SDenis V. Lunev if (!g_spawn_sync(NULL, argv, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL,
138091274487SDenis V. Lunev &out /* stdout */, NULL /* stdin */,
138191274487SDenis V. Lunev NULL, &gerr)) {
138291274487SDenis V. Lunev res->error = g_strdup(gerr->message);
138391274487SDenis V. Lunev g_error_free(gerr);
138491274487SDenis V. Lunev } else {
138591274487SDenis V. Lunev /* defrag.exe is UGLY. Exit code is ALWAYS zero.
138691274487SDenis V. Lunev Error is reported in the output with something like
138791274487SDenis V. Lunev (x89000020) etc code in the stdout */
138891274487SDenis V. Lunev
138991274487SDenis V. Lunev int i;
139091274487SDenis V. Lunev gchar **lines = g_strsplit(out, "\r\n", 0);
139191274487SDenis V. Lunev g_free(out);
139291274487SDenis V. Lunev
139391274487SDenis V. Lunev for (i = 0; lines[i] != NULL; i++) {
139491274487SDenis V. Lunev if (g_strstr_len(lines[i], -1, "(0x") == NULL) {
139591274487SDenis V. Lunev continue;
139691274487SDenis V. Lunev }
139791274487SDenis V. Lunev res->error = g_strdup(lines[i]);
139891274487SDenis V. Lunev break;
139991274487SDenis V. Lunev }
140091274487SDenis V. Lunev g_strfreev(lines);
140191274487SDenis V. Lunev }
140291274487SDenis V. Lunev } while (FindNextVolumeW(handle, guid, ARRAYSIZE(guid)));
140391274487SDenis V. Lunev
140491274487SDenis V. Lunev FindVolumeClose(handle);
140591274487SDenis V. Lunev return resp;
140691274487SDenis V. Lunev }
140791274487SDenis V. Lunev
1408aa59637eSGal Hammer typedef enum {
1409f54603b6SMichael Roth GUEST_SUSPEND_MODE_DISK,
1410f54603b6SMichael Roth GUEST_SUSPEND_MODE_RAM
1411aa59637eSGal Hammer } GuestSuspendMode;
1412aa59637eSGal Hammer
check_suspend_mode(GuestSuspendMode mode,Error ** errp)141377dbc81bSMarkus Armbruster static void check_suspend_mode(GuestSuspendMode mode, Error **errp)
1414aa59637eSGal Hammer {
1415aa59637eSGal Hammer SYSTEM_POWER_CAPABILITIES sys_pwr_caps;
1416aa59637eSGal Hammer
1417aa59637eSGal Hammer ZeroMemory(&sys_pwr_caps, sizeof(sys_pwr_caps));
1418aa59637eSGal Hammer if (!GetPwrCapabilities(&sys_pwr_caps)) {
1419dcfe4805SMarkus Armbruster error_setg(errp, QERR_QGA_COMMAND_FAILED,
1420aa59637eSGal Hammer "failed to determine guest suspend capabilities");
1421dcfe4805SMarkus Armbruster return;
1422aa59637eSGal Hammer }
1423aa59637eSGal Hammer
1424f54603b6SMichael Roth switch (mode) {
1425f54603b6SMichael Roth case GUEST_SUSPEND_MODE_DISK:
1426f54603b6SMichael Roth if (!sys_pwr_caps.SystemS4) {
1427dcfe4805SMarkus Armbruster error_setg(errp, QERR_QGA_COMMAND_FAILED,
1428f54603b6SMichael Roth "suspend-to-disk not supported by OS");
1429aa59637eSGal Hammer }
1430f54603b6SMichael Roth break;
1431f54603b6SMichael Roth case GUEST_SUSPEND_MODE_RAM:
1432f54603b6SMichael Roth if (!sys_pwr_caps.SystemS3) {
1433dcfe4805SMarkus Armbruster error_setg(errp, QERR_QGA_COMMAND_FAILED,
1434f54603b6SMichael Roth "suspend-to-ram not supported by OS");
1435f54603b6SMichael Roth }
1436f54603b6SMichael Roth break;
1437f54603b6SMichael Roth default:
1438ac84b0faSMarkus Armbruster abort();
1439aa59637eSGal Hammer }
1440aa59637eSGal Hammer }
1441aa59637eSGal Hammer
do_suspend(LPVOID opaque)1442aa59637eSGal Hammer static DWORD WINAPI do_suspend(LPVOID opaque)
1443aa59637eSGal Hammer {
1444aa59637eSGal Hammer GuestSuspendMode *mode = opaque;
1445aa59637eSGal Hammer DWORD ret = 0;
1446aa59637eSGal Hammer
1447aa59637eSGal Hammer if (!SetSuspendState(*mode == GUEST_SUSPEND_MODE_DISK, TRUE, TRUE)) {
1448672db778SPhilippe Mathieu-Daudé g_autofree gchar *emsg = g_win32_error_message(GetLastError());
1449672db778SPhilippe Mathieu-Daudé slog("failed to suspend guest: %s", emsg);
1450aa59637eSGal Hammer ret = -1;
1451aa59637eSGal Hammer }
1452aa59637eSGal Hammer g_free(mode);
1453aa59637eSGal Hammer return ret;
1454aa59637eSGal Hammer }
1455aa59637eSGal Hammer
qmp_guest_suspend_disk(Error ** errp)145677dbc81bSMarkus Armbruster void qmp_guest_suspend_disk(Error **errp)
145711d0f125SLuiz Capitulino {
14580f230bf7SMarkus Armbruster Error *local_err = NULL;
1459f3a06403SMarkus Armbruster GuestSuspendMode *mode = g_new(GuestSuspendMode, 1);
1460aa59637eSGal Hammer
1461aa59637eSGal Hammer *mode = GUEST_SUSPEND_MODE_DISK;
14620f230bf7SMarkus Armbruster check_suspend_mode(*mode, &local_err);
146351bd4581SMarkus Armbruster if (local_err) {
146451bd4581SMarkus Armbruster goto out;
146551bd4581SMarkus Armbruster }
14660f230bf7SMarkus Armbruster acquire_privilege(SE_SHUTDOWN_NAME, &local_err);
146751bd4581SMarkus Armbruster if (local_err) {
146851bd4581SMarkus Armbruster goto out;
146951bd4581SMarkus Armbruster }
14700f230bf7SMarkus Armbruster execute_async(do_suspend, mode, &local_err);
1471aa59637eSGal Hammer
147251bd4581SMarkus Armbruster out:
14730f230bf7SMarkus Armbruster if (local_err) {
14740f230bf7SMarkus Armbruster error_propagate(errp, local_err);
1475aa59637eSGal Hammer g_free(mode);
1476aa59637eSGal Hammer }
147711d0f125SLuiz Capitulino }
147811d0f125SLuiz Capitulino
qmp_guest_suspend_ram(Error ** errp)147977dbc81bSMarkus Armbruster void qmp_guest_suspend_ram(Error **errp)
1480fbf42210SLuiz Capitulino {
14810f230bf7SMarkus Armbruster Error *local_err = NULL;
1482f3a06403SMarkus Armbruster GuestSuspendMode *mode = g_new(GuestSuspendMode, 1);
1483f54603b6SMichael Roth
1484f54603b6SMichael Roth *mode = GUEST_SUSPEND_MODE_RAM;
14850f230bf7SMarkus Armbruster check_suspend_mode(*mode, &local_err);
148651bd4581SMarkus Armbruster if (local_err) {
148751bd4581SMarkus Armbruster goto out;
148851bd4581SMarkus Armbruster }
14890f230bf7SMarkus Armbruster acquire_privilege(SE_SHUTDOWN_NAME, &local_err);
149051bd4581SMarkus Armbruster if (local_err) {
149151bd4581SMarkus Armbruster goto out;
149251bd4581SMarkus Armbruster }
14930f230bf7SMarkus Armbruster execute_async(do_suspend, mode, &local_err);
1494f54603b6SMichael Roth
149551bd4581SMarkus Armbruster out:
14960f230bf7SMarkus Armbruster if (local_err) {
14970f230bf7SMarkus Armbruster error_propagate(errp, local_err);
1498f54603b6SMichael Roth g_free(mode);
1499f54603b6SMichael Roth }
1500fbf42210SLuiz Capitulino }
1501fbf42210SLuiz Capitulino
qmp_guest_suspend_hybrid(Error ** errp)150277dbc81bSMarkus Armbruster void qmp_guest_suspend_hybrid(Error **errp)
150395f4f404SLuiz Capitulino {
1504c6bd8c70SMarkus Armbruster error_setg(errp, QERR_UNSUPPORTED);
150595f4f404SLuiz Capitulino }
150695f4f404SLuiz Capitulino
guest_get_adapters_addresses(Error ** errp)1507d6c5528bSKirk Allan static IP_ADAPTER_ADDRESSES *guest_get_adapters_addresses(Error **errp)
1508d6c5528bSKirk Allan {
1509d6c5528bSKirk Allan IP_ADAPTER_ADDRESSES *adptr_addrs = NULL;
1510d6c5528bSKirk Allan ULONG adptr_addrs_len = 0;
1511d6c5528bSKirk Allan DWORD ret;
1512d6c5528bSKirk Allan
1513d6c5528bSKirk Allan /* Call the first time to get the adptr_addrs_len. */
1514d6c5528bSKirk Allan GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX,
1515d6c5528bSKirk Allan NULL, adptr_addrs, &adptr_addrs_len);
1516d6c5528bSKirk Allan
1517d6c5528bSKirk Allan adptr_addrs = g_malloc(adptr_addrs_len);
1518d6c5528bSKirk Allan ret = GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_PREFIX,
1519d6c5528bSKirk Allan NULL, adptr_addrs, &adptr_addrs_len);
1520d6c5528bSKirk Allan if (ret != ERROR_SUCCESS) {
1521d6c5528bSKirk Allan error_setg_win32(errp, ret, "failed to get adapters addresses");
1522d6c5528bSKirk Allan g_free(adptr_addrs);
1523d6c5528bSKirk Allan adptr_addrs = NULL;
1524d6c5528bSKirk Allan }
1525d6c5528bSKirk Allan return adptr_addrs;
1526d6c5528bSKirk Allan }
1527d6c5528bSKirk Allan
guest_wctomb_dup(WCHAR * wstr)1528d6c5528bSKirk Allan static char *guest_wctomb_dup(WCHAR *wstr)
1529d6c5528bSKirk Allan {
1530d6c5528bSKirk Allan char *str;
1531a18025f9SBishara AbuHattoum size_t str_size;
1532d6c5528bSKirk Allan
1533a18025f9SBishara AbuHattoum str_size = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);
1534a18025f9SBishara AbuHattoum /* add 1 to str_size for NULL terminator */
1535a18025f9SBishara AbuHattoum str = g_malloc(str_size + 1);
1536a18025f9SBishara AbuHattoum WideCharToMultiByte(CP_UTF8, 0, wstr, -1, str, str_size, NULL, NULL);
1537d6c5528bSKirk Allan return str;
1538d6c5528bSKirk Allan }
1539d6c5528bSKirk Allan
guest_addr_to_str(IP_ADAPTER_UNICAST_ADDRESS * ip_addr,Error ** errp)1540d6c5528bSKirk Allan static char *guest_addr_to_str(IP_ADAPTER_UNICAST_ADDRESS *ip_addr,
1541d6c5528bSKirk Allan Error **errp)
1542d6c5528bSKirk Allan {
1543d6c5528bSKirk Allan char addr_str[INET6_ADDRSTRLEN + INET_ADDRSTRLEN];
1544d6c5528bSKirk Allan DWORD len;
1545d6c5528bSKirk Allan int ret;
1546d6c5528bSKirk Allan
1547d6c5528bSKirk Allan if (ip_addr->Address.lpSockaddr->sa_family == AF_INET ||
1548d6c5528bSKirk Allan ip_addr->Address.lpSockaddr->sa_family == AF_INET6) {
1549d6c5528bSKirk Allan len = sizeof(addr_str);
1550d6c5528bSKirk Allan ret = WSAAddressToString(ip_addr->Address.lpSockaddr,
1551d6c5528bSKirk Allan ip_addr->Address.iSockaddrLength,
1552d6c5528bSKirk Allan NULL,
1553d6c5528bSKirk Allan addr_str,
1554d6c5528bSKirk Allan &len);
1555d6c5528bSKirk Allan if (ret != 0) {
1556d6c5528bSKirk Allan error_setg_win32(errp, WSAGetLastError(),
1557d6c5528bSKirk Allan "failed address presentation form conversion");
1558d6c5528bSKirk Allan return NULL;
1559d6c5528bSKirk Allan }
1560d6c5528bSKirk Allan return g_strdup(addr_str);
1561d6c5528bSKirk Allan }
1562d6c5528bSKirk Allan return NULL;
1563d6c5528bSKirk Allan }
1564d6c5528bSKirk Allan
guest_ip_prefix(IP_ADAPTER_UNICAST_ADDRESS * ip_addr)1565d6c5528bSKirk Allan static int64_t guest_ip_prefix(IP_ADAPTER_UNICAST_ADDRESS *ip_addr)
1566d6c5528bSKirk Allan {
1567d6c5528bSKirk Allan /* For Windows Vista/2008 and newer, use the OnLinkPrefixLength
1568d6c5528bSKirk Allan * field to obtain the prefix.
1569d6c5528bSKirk Allan */
1570d6c5528bSKirk Allan return ip_addr->OnLinkPrefixLength;
1571d6c5528bSKirk Allan }
1572d6c5528bSKirk Allan
157353f9fcb2SZhiPeng Lu #define INTERFACE_PATH_BUF_SZ 512
157453f9fcb2SZhiPeng Lu
get_interface_index(const char * guid)157553f9fcb2SZhiPeng Lu static DWORD get_interface_index(const char *guid)
157653f9fcb2SZhiPeng Lu {
157753f9fcb2SZhiPeng Lu ULONG index;
157853f9fcb2SZhiPeng Lu DWORD status;
157953f9fcb2SZhiPeng Lu wchar_t wbuf[INTERFACE_PATH_BUF_SZ];
158053f9fcb2SZhiPeng Lu snwprintf(wbuf, INTERFACE_PATH_BUF_SZ, L"\\device\\tcpip_%s", guid);
158153f9fcb2SZhiPeng Lu wbuf[INTERFACE_PATH_BUF_SZ - 1] = 0;
158253f9fcb2SZhiPeng Lu status = GetAdapterIndex (wbuf, &index);
158353f9fcb2SZhiPeng Lu if (status != NO_ERROR) {
158453f9fcb2SZhiPeng Lu return (DWORD)~0;
158553f9fcb2SZhiPeng Lu } else {
158653f9fcb2SZhiPeng Lu return index;
158753f9fcb2SZhiPeng Lu }
158853f9fcb2SZhiPeng Lu }
1589df83eabdSZhiPeng Lu
1590df83eabdSZhiPeng Lu typedef NETIOAPI_API (WINAPI *GetIfEntry2Func)(PMIB_IF_ROW2 Row);
1591df83eabdSZhiPeng Lu
guest_get_network_stats(const char * name,GuestNetworkInterfaceStat * stats)159253f9fcb2SZhiPeng Lu static int guest_get_network_stats(const char *name,
159353f9fcb2SZhiPeng Lu GuestNetworkInterfaceStat *stats)
159453f9fcb2SZhiPeng Lu {
1595df83eabdSZhiPeng Lu OSVERSIONINFO os_ver;
1596df83eabdSZhiPeng Lu
1597df83eabdSZhiPeng Lu os_ver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
1598df83eabdSZhiPeng Lu GetVersionEx(&os_ver);
1599df83eabdSZhiPeng Lu if (os_ver.dwMajorVersion >= 6) {
1600df83eabdSZhiPeng Lu MIB_IF_ROW2 a_mid_ifrow;
1601df83eabdSZhiPeng Lu GetIfEntry2Func getifentry2_ex;
160253f9fcb2SZhiPeng Lu DWORD if_index = 0;
1603df83eabdSZhiPeng Lu HMODULE module = GetModuleHandle("iphlpapi");
1604df83eabdSZhiPeng Lu PVOID func = GetProcAddress(module, "GetIfEntry2");
1605df83eabdSZhiPeng Lu
1606df83eabdSZhiPeng Lu if (func == NULL) {
1607df83eabdSZhiPeng Lu return -1;
1608df83eabdSZhiPeng Lu }
1609df83eabdSZhiPeng Lu
1610df83eabdSZhiPeng Lu getifentry2_ex = (GetIfEntry2Func)func;
161153f9fcb2SZhiPeng Lu if_index = get_interface_index(name);
1612df83eabdSZhiPeng Lu if (if_index == (DWORD)~0) {
1613df83eabdSZhiPeng Lu return -1;
1614df83eabdSZhiPeng Lu }
1615df83eabdSZhiPeng Lu
1616df83eabdSZhiPeng Lu memset(&a_mid_ifrow, 0, sizeof(a_mid_ifrow));
1617df83eabdSZhiPeng Lu a_mid_ifrow.InterfaceIndex = if_index;
1618df83eabdSZhiPeng Lu if (NO_ERROR == getifentry2_ex(&a_mid_ifrow)) {
1619df83eabdSZhiPeng Lu stats->rx_bytes = a_mid_ifrow.InOctets;
1620df83eabdSZhiPeng Lu stats->rx_packets = a_mid_ifrow.InUcastPkts;
1621df83eabdSZhiPeng Lu stats->rx_errs = a_mid_ifrow.InErrors;
1622df83eabdSZhiPeng Lu stats->rx_dropped = a_mid_ifrow.InDiscards;
1623df83eabdSZhiPeng Lu stats->tx_bytes = a_mid_ifrow.OutOctets;
1624df83eabdSZhiPeng Lu stats->tx_packets = a_mid_ifrow.OutUcastPkts;
1625df83eabdSZhiPeng Lu stats->tx_errs = a_mid_ifrow.OutErrors;
1626df83eabdSZhiPeng Lu stats->tx_dropped = a_mid_ifrow.OutDiscards;
162753f9fcb2SZhiPeng Lu return 0;
162853f9fcb2SZhiPeng Lu }
1629df83eabdSZhiPeng Lu }
163053f9fcb2SZhiPeng Lu return -1;
163153f9fcb2SZhiPeng Lu }
163253f9fcb2SZhiPeng Lu
qmp_guest_network_get_interfaces(Error ** errp)163377dbc81bSMarkus Armbruster GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
16343424fc9fSMichal Privoznik {
1635d6c5528bSKirk Allan IP_ADAPTER_ADDRESSES *adptr_addrs, *addr;
1636d6c5528bSKirk Allan IP_ADAPTER_UNICAST_ADDRESS *ip_addr = NULL;
163795b3a8c8SEric Blake GuestNetworkInterfaceList *head = NULL, **tail = &head;
163895b3a8c8SEric Blake GuestIpAddressList *head_addr, **tail_addr;
163995b3a8c8SEric Blake GuestNetworkInterface *info;
164053f9fcb2SZhiPeng Lu GuestNetworkInterfaceStat *interface_stat = NULL;
164195b3a8c8SEric Blake GuestIpAddress *address_item = NULL;
1642d6c5528bSKirk Allan unsigned char *mac_addr;
1643d6c5528bSKirk Allan char *addr_str;
1644d6c5528bSKirk Allan WORD wsa_version;
1645d6c5528bSKirk Allan WSADATA wsa_data;
1646d6c5528bSKirk Allan int ret;
1647d6c5528bSKirk Allan
1648d6c5528bSKirk Allan adptr_addrs = guest_get_adapters_addresses(errp);
1649d6c5528bSKirk Allan if (adptr_addrs == NULL) {
16503424fc9fSMichal Privoznik return NULL;
16513424fc9fSMichal Privoznik }
16523424fc9fSMichal Privoznik
1653d6c5528bSKirk Allan /* Make WSA APIs available. */
1654d6c5528bSKirk Allan wsa_version = MAKEWORD(2, 2);
1655d6c5528bSKirk Allan ret = WSAStartup(wsa_version, &wsa_data);
1656d6c5528bSKirk Allan if (ret != 0) {
1657d6c5528bSKirk Allan error_setg_win32(errp, ret, "failed socket startup");
1658d6c5528bSKirk Allan goto out;
1659d6c5528bSKirk Allan }
1660d6c5528bSKirk Allan
1661d6c5528bSKirk Allan for (addr = adptr_addrs; addr; addr = addr->Next) {
1662d6c5528bSKirk Allan info = g_malloc0(sizeof(*info));
1663d6c5528bSKirk Allan
166495b3a8c8SEric Blake QAPI_LIST_APPEND(tail, info);
1665d6c5528bSKirk Allan
166695b3a8c8SEric Blake info->name = guest_wctomb_dup(addr->FriendlyName);
1667d6c5528bSKirk Allan
1668d6c5528bSKirk Allan if (addr->PhysicalAddressLength != 0) {
1669d6c5528bSKirk Allan mac_addr = addr->PhysicalAddress;
1670d6c5528bSKirk Allan
167195b3a8c8SEric Blake info->hardware_address =
1672d6c5528bSKirk Allan g_strdup_printf("%02x:%02x:%02x:%02x:%02x:%02x",
1673d6c5528bSKirk Allan (int) mac_addr[0], (int) mac_addr[1],
1674d6c5528bSKirk Allan (int) mac_addr[2], (int) mac_addr[3],
1675d6c5528bSKirk Allan (int) mac_addr[4], (int) mac_addr[5]);
1676d6c5528bSKirk Allan }
1677d6c5528bSKirk Allan
1678d6c5528bSKirk Allan head_addr = NULL;
167995b3a8c8SEric Blake tail_addr = &head_addr;
1680d6c5528bSKirk Allan for (ip_addr = addr->FirstUnicastAddress;
1681d6c5528bSKirk Allan ip_addr;
1682d6c5528bSKirk Allan ip_addr = ip_addr->Next) {
1683d6c5528bSKirk Allan addr_str = guest_addr_to_str(ip_addr, errp);
1684d6c5528bSKirk Allan if (addr_str == NULL) {
1685d6c5528bSKirk Allan continue;
1686d6c5528bSKirk Allan }
1687d6c5528bSKirk Allan
1688d6c5528bSKirk Allan address_item = g_malloc0(sizeof(*address_item));
1689d6c5528bSKirk Allan
169095b3a8c8SEric Blake QAPI_LIST_APPEND(tail_addr, address_item);
1691d6c5528bSKirk Allan
169295b3a8c8SEric Blake address_item->ip_address = addr_str;
169395b3a8c8SEric Blake address_item->prefix = guest_ip_prefix(ip_addr);
1694d6c5528bSKirk Allan if (ip_addr->Address.lpSockaddr->sa_family == AF_INET) {
169595b3a8c8SEric Blake address_item->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4;
1696d6c5528bSKirk Allan } else if (ip_addr->Address.lpSockaddr->sa_family == AF_INET6) {
169795b3a8c8SEric Blake address_item->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6;
1698d6c5528bSKirk Allan }
1699d6c5528bSKirk Allan }
1700d6c5528bSKirk Allan if (head_addr) {
170195b3a8c8SEric Blake info->has_ip_addresses = true;
170295b3a8c8SEric Blake info->ip_addresses = head_addr;
1703d6c5528bSKirk Allan }
170491eab32aSMarkus Armbruster if (!info->statistics) {
170553f9fcb2SZhiPeng Lu interface_stat = g_malloc0(sizeof(*interface_stat));
170691eab32aSMarkus Armbruster if (guest_get_network_stats(addr->AdapterName, interface_stat)
170791eab32aSMarkus Armbruster == -1) {
170853f9fcb2SZhiPeng Lu g_free(interface_stat);
170953f9fcb2SZhiPeng Lu } else {
171095b3a8c8SEric Blake info->statistics = interface_stat;
171153f9fcb2SZhiPeng Lu }
171253f9fcb2SZhiPeng Lu }
1713d6c5528bSKirk Allan }
1714d6c5528bSKirk Allan WSACleanup();
1715d6c5528bSKirk Allan out:
1716d6c5528bSKirk Allan g_free(adptr_addrs);
1717d6c5528bSKirk Allan return head;
1718d6c5528bSKirk Allan }
1719d6c5528bSKirk Allan
filetime_to_ns(const FILETIME * tf)1720a88bceefSMarkus Armbruster static int64_t filetime_to_ns(const FILETIME *tf)
1721a88bceefSMarkus Armbruster {
1722a88bceefSMarkus Armbruster return ((((int64_t)tf->dwHighDateTime << 32) | tf->dwLowDateTime)
1723a88bceefSMarkus Armbruster - W32_FT_OFFSET) * 100;
1724a88bceefSMarkus Armbruster }
1725a88bceefSMarkus Armbruster
qmp_guest_set_time(bool has_time,int64_t time_ns,Error ** errp)17262c958923SMichal Privoznik void qmp_guest_set_time(bool has_time, int64_t time_ns, Error **errp)
1727a1bca57fSLei Li {
17280f230bf7SMarkus Armbruster Error *local_err = NULL;
1729b8f954feSLei Li SYSTEMTIME ts;
1730b8f954feSLei Li FILETIME tf;
1731b8f954feSLei Li LONGLONG time;
1732b8f954feSLei Li
1733ee17cbdcSMichal Privoznik if (!has_time) {
1734ee17cbdcSMichal Privoznik /* Unfortunately, Windows libraries don't provide an easy way to access
1735ee17cbdcSMichal Privoznik * RTC yet:
1736ee17cbdcSMichal Privoznik *
1737ee17cbdcSMichal Privoznik * https://msdn.microsoft.com/en-us/library/aa908981.aspx
1738105fad6bSBishara AbuHattoum *
1739105fad6bSBishara AbuHattoum * Instead, a workaround is to use the Windows win32tm command to
1740105fad6bSBishara AbuHattoum * resync the time using the Windows Time service.
1741ee17cbdcSMichal Privoznik */
1742105fad6bSBishara AbuHattoum LPVOID msg_buffer;
1743105fad6bSBishara AbuHattoum DWORD ret_flags;
1744105fad6bSBishara AbuHattoum
1745105fad6bSBishara AbuHattoum HRESULT hr = system("w32tm /resync /nowait");
1746105fad6bSBishara AbuHattoum
1747105fad6bSBishara AbuHattoum if (GetLastError() != 0) {
1748105fad6bSBishara AbuHattoum strerror_s((LPTSTR) & msg_buffer, 0, errno);
1749105fad6bSBishara AbuHattoum error_setg(errp, "system(...) failed: %s", (LPCTSTR)msg_buffer);
1750105fad6bSBishara AbuHattoum } else if (hr != 0) {
1751105fad6bSBishara AbuHattoum if (hr == HRESULT_FROM_WIN32(ERROR_SERVICE_NOT_ACTIVE)) {
1752105fad6bSBishara AbuHattoum error_setg(errp, "Windows Time service not running on the "
1753105fad6bSBishara AbuHattoum "guest");
1754105fad6bSBishara AbuHattoum } else {
1755105fad6bSBishara AbuHattoum if (!FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
1756105fad6bSBishara AbuHattoum FORMAT_MESSAGE_FROM_SYSTEM |
1757105fad6bSBishara AbuHattoum FORMAT_MESSAGE_IGNORE_INSERTS, NULL,
1758105fad6bSBishara AbuHattoum (DWORD)hr, MAKELANGID(LANG_NEUTRAL,
1759105fad6bSBishara AbuHattoum SUBLANG_DEFAULT), (LPTSTR) & msg_buffer, 0,
1760105fad6bSBishara AbuHattoum NULL)) {
1761105fad6bSBishara AbuHattoum error_setg(errp, "w32tm failed with error (0x%lx), couldn'"
1762105fad6bSBishara AbuHattoum "t retrieve error message", hr);
1763105fad6bSBishara AbuHattoum } else {
1764105fad6bSBishara AbuHattoum error_setg(errp, "w32tm failed with error (0x%lx): %s", hr,
1765105fad6bSBishara AbuHattoum (LPCTSTR)msg_buffer);
1766105fad6bSBishara AbuHattoum LocalFree(msg_buffer);
1767105fad6bSBishara AbuHattoum }
1768105fad6bSBishara AbuHattoum }
1769105fad6bSBishara AbuHattoum } else if (!InternetGetConnectedState(&ret_flags, 0)) {
1770105fad6bSBishara AbuHattoum error_setg(errp, "No internet connection on guest, sync not "
1771105fad6bSBishara AbuHattoum "accurate");
1772105fad6bSBishara AbuHattoum }
1773ee17cbdcSMichal Privoznik return;
1774ee17cbdcSMichal Privoznik }
1775ee17cbdcSMichal Privoznik
1776ee17cbdcSMichal Privoznik /* Validate time passed by user. */
1777b8f954feSLei Li if (time_ns < 0 || time_ns / 100 > INT64_MAX - W32_FT_OFFSET) {
1778b8f954feSLei Li error_setg(errp, "Time %" PRId64 "is invalid", time_ns);
1779b8f954feSLei Li return;
1780b8f954feSLei Li }
1781b8f954feSLei Li
1782b8f954feSLei Li time = time_ns / 100 + W32_FT_OFFSET;
1783b8f954feSLei Li
1784b8f954feSLei Li tf.dwLowDateTime = (DWORD) time;
1785b8f954feSLei Li tf.dwHighDateTime = (DWORD) (time >> 32);
1786b8f954feSLei Li
1787b8f954feSLei Li if (!FileTimeToSystemTime(&tf, &ts)) {
17882c958923SMichal Privoznik error_setg(errp, "Failed to convert system time %d",
17892c958923SMichal Privoznik (int)GetLastError());
1790b8f954feSLei Li return;
1791b8f954feSLei Li }
1792b8f954feSLei Li
17930f230bf7SMarkus Armbruster acquire_privilege(SE_SYSTEMTIME_NAME, &local_err);
17940f230bf7SMarkus Armbruster if (local_err) {
17950f230bf7SMarkus Armbruster error_propagate(errp, local_err);
1796b8f954feSLei Li return;
1797b8f954feSLei Li }
1798b8f954feSLei Li
1799b8f954feSLei Li if (!SetSystemTime(&ts)) {
1800b8f954feSLei Li error_setg(errp, "Failed to set time to guest: %d", (int)GetLastError());
1801b8f954feSLei Li return;
1802b8f954feSLei Li }
1803a1bca57fSLei Li }
1804a1bca57fSLei Li
qmp_guest_get_vcpus(Error ** errp)180570e133a7SLaszlo Ersek GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp)
180670e133a7SLaszlo Ersek {
1807a7a17362SGal Hammer PSYSTEM_LOGICAL_PROCESSOR_INFORMATION pslpi, ptr;
1808a7a17362SGal Hammer DWORD length;
1809c3033fd3SEric Blake GuestLogicalProcessorList *head, **tail;
1810a7a17362SGal Hammer Error *local_err = NULL;
1811a7a17362SGal Hammer int64_t current;
1812a7a17362SGal Hammer
1813a7a17362SGal Hammer ptr = pslpi = NULL;
1814a7a17362SGal Hammer length = 0;
1815a7a17362SGal Hammer current = 0;
1816a7a17362SGal Hammer head = NULL;
1817c3033fd3SEric Blake tail = &head;
1818a7a17362SGal Hammer
1819a7a17362SGal Hammer if ((GetLogicalProcessorInformation(pslpi, &length) == FALSE) &&
1820a7a17362SGal Hammer (GetLastError() == ERROR_INSUFFICIENT_BUFFER) &&
1821a7a17362SGal Hammer (length > sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION))) {
1822a7a17362SGal Hammer ptr = pslpi = g_malloc0(length);
1823a7a17362SGal Hammer if (GetLogicalProcessorInformation(pslpi, &length) == FALSE) {
1824a7a17362SGal Hammer error_setg(&local_err, "Failed to get processor information: %d",
1825a7a17362SGal Hammer (int)GetLastError());
1826a7a17362SGal Hammer }
1827a7a17362SGal Hammer } else {
1828a7a17362SGal Hammer error_setg(&local_err,
1829a7a17362SGal Hammer "Failed to get processor information buffer length: %d",
1830a7a17362SGal Hammer (int)GetLastError());
1831a7a17362SGal Hammer }
1832a7a17362SGal Hammer
1833a7a17362SGal Hammer while ((local_err == NULL) && (length > 0)) {
1834a7a17362SGal Hammer if (pslpi->Relationship == RelationProcessorCore) {
1835a7a17362SGal Hammer ULONG_PTR cpu_bits = pslpi->ProcessorMask;
1836a7a17362SGal Hammer
1837a7a17362SGal Hammer while (cpu_bits > 0) {
1838a7a17362SGal Hammer if (!!(cpu_bits & 1)) {
1839a7a17362SGal Hammer GuestLogicalProcessor *vcpu;
1840a7a17362SGal Hammer
1841a7a17362SGal Hammer vcpu = g_malloc0(sizeof *vcpu);
1842a7a17362SGal Hammer vcpu->logical_id = current++;
1843a7a17362SGal Hammer vcpu->online = true;
184454858553SSameeh Jubran vcpu->has_can_offline = true;
1845a7a17362SGal Hammer
1846c3033fd3SEric Blake QAPI_LIST_APPEND(tail, vcpu);
1847a7a17362SGal Hammer }
1848a7a17362SGal Hammer cpu_bits >>= 1;
1849a7a17362SGal Hammer }
1850a7a17362SGal Hammer }
1851a7a17362SGal Hammer length -= sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
1852a7a17362SGal Hammer pslpi++; /* next entry */
1853a7a17362SGal Hammer }
1854a7a17362SGal Hammer
1855a7a17362SGal Hammer g_free(ptr);
1856a7a17362SGal Hammer
1857a7a17362SGal Hammer if (local_err == NULL) {
1858a7a17362SGal Hammer if (head != NULL) {
1859a7a17362SGal Hammer return head;
1860a7a17362SGal Hammer }
1861a7a17362SGal Hammer /* there's no guest with zero VCPUs */
1862a7a17362SGal Hammer error_setg(&local_err, "Guest reported zero VCPUs");
1863a7a17362SGal Hammer }
1864a7a17362SGal Hammer
1865a7a17362SGal Hammer qapi_free_GuestLogicalProcessorList(head);
1866a7a17362SGal Hammer error_propagate(errp, local_err);
186770e133a7SLaszlo Ersek return NULL;
186870e133a7SLaszlo Ersek }
186970e133a7SLaszlo Ersek
qmp_guest_set_vcpus(GuestLogicalProcessorList * vcpus,Error ** errp)187070e133a7SLaszlo Ersek int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp)
187170e133a7SLaszlo Ersek {
1872c6bd8c70SMarkus Armbruster error_setg(errp, QERR_UNSUPPORTED);
187370e133a7SLaszlo Ersek return -1;
187470e133a7SLaszlo Ersek }
187570e133a7SLaszlo Ersek
1876259434b8SMarc-André Lureau static gchar *
get_net_error_message(gint error)1877259434b8SMarc-André Lureau get_net_error_message(gint error)
1878259434b8SMarc-André Lureau {
1879259434b8SMarc-André Lureau HMODULE module = NULL;
1880259434b8SMarc-André Lureau gchar *retval = NULL;
1881259434b8SMarc-André Lureau wchar_t *msg = NULL;
18826771197dSMarc-André Lureau int flags;
18836771197dSMarc-André Lureau size_t nchars;
1884259434b8SMarc-André Lureau
188502506e2dSMarc-André Lureau flags = FORMAT_MESSAGE_ALLOCATE_BUFFER |
188602506e2dSMarc-André Lureau FORMAT_MESSAGE_IGNORE_INSERTS |
188702506e2dSMarc-André Lureau FORMAT_MESSAGE_FROM_SYSTEM;
1888259434b8SMarc-André Lureau
1889259434b8SMarc-André Lureau if (error >= NERR_BASE && error <= MAX_NERR) {
1890259434b8SMarc-André Lureau module = LoadLibraryExW(L"netmsg.dll", NULL, LOAD_LIBRARY_AS_DATAFILE);
1891259434b8SMarc-André Lureau
1892259434b8SMarc-André Lureau if (module != NULL) {
1893259434b8SMarc-André Lureau flags |= FORMAT_MESSAGE_FROM_HMODULE;
1894259434b8SMarc-André Lureau }
1895259434b8SMarc-André Lureau }
1896259434b8SMarc-André Lureau
1897259434b8SMarc-André Lureau FormatMessageW(flags, module, error, 0, (LPWSTR)&msg, 0, NULL);
1898259434b8SMarc-André Lureau
1899259434b8SMarc-André Lureau if (msg != NULL) {
1900259434b8SMarc-André Lureau nchars = wcslen(msg);
1901259434b8SMarc-André Lureau
190225d943b9SMarc-André Lureau if (nchars >= 2 &&
19036c6916daSMarc-André Lureau msg[nchars - 1] == L'\n' &&
19046c6916daSMarc-André Lureau msg[nchars - 2] == L'\r') {
19056c6916daSMarc-André Lureau msg[nchars - 2] = L'\0';
1906259434b8SMarc-André Lureau }
1907259434b8SMarc-André Lureau
1908259434b8SMarc-André Lureau retval = g_utf16_to_utf8(msg, -1, NULL, NULL, NULL);
1909259434b8SMarc-André Lureau
1910259434b8SMarc-André Lureau LocalFree(msg);
1911259434b8SMarc-André Lureau }
1912259434b8SMarc-André Lureau
1913259434b8SMarc-André Lureau if (module != NULL) {
1914259434b8SMarc-André Lureau FreeLibrary(module);
1915259434b8SMarc-André Lureau }
1916259434b8SMarc-André Lureau
1917259434b8SMarc-André Lureau return retval;
1918259434b8SMarc-André Lureau }
1919259434b8SMarc-André Lureau
qmp_guest_set_user_password(const char * username,const char * password,bool crypted,Error ** errp)1920215a2771SDaniel P. Berrange void qmp_guest_set_user_password(const char *username,
1921215a2771SDaniel P. Berrange const char *password,
1922215a2771SDaniel P. Berrange bool crypted,
1923215a2771SDaniel P. Berrange Error **errp)
1924215a2771SDaniel P. Berrange {
1925259434b8SMarc-André Lureau NET_API_STATUS nas;
1926259434b8SMarc-André Lureau char *rawpasswddata = NULL;
1927259434b8SMarc-André Lureau size_t rawpasswdlen;
19288021de10SMarc-André Lureau wchar_t *user = NULL, *wpass = NULL;
1929259434b8SMarc-André Lureau USER_INFO_1003 pi1003 = { 0, };
19308021de10SMarc-André Lureau GError *gerr = NULL;
1931259434b8SMarc-André Lureau
1932259434b8SMarc-André Lureau if (crypted) {
1933c6bd8c70SMarkus Armbruster error_setg(errp, QERR_UNSUPPORTED);
1934259434b8SMarc-André Lureau return;
1935259434b8SMarc-André Lureau }
1936259434b8SMarc-André Lureau
1937920639caSDaniel P. Berrange rawpasswddata = (char *)qbase64_decode(password, -1, &rawpasswdlen, errp);
1938920639caSDaniel P. Berrange if (!rawpasswddata) {
1939920639caSDaniel P. Berrange return;
1940920639caSDaniel P. Berrange }
1941259434b8SMarc-André Lureau rawpasswddata = g_renew(char, rawpasswddata, rawpasswdlen + 1);
1942259434b8SMarc-André Lureau rawpasswddata[rawpasswdlen] = '\0';
1943259434b8SMarc-André Lureau
19448021de10SMarc-André Lureau user = g_utf8_to_utf16(username, -1, NULL, NULL, &gerr);
19458021de10SMarc-André Lureau if (!user) {
19468021de10SMarc-André Lureau goto done;
19478021de10SMarc-André Lureau }
19488021de10SMarc-André Lureau
19498021de10SMarc-André Lureau wpass = g_utf8_to_utf16(rawpasswddata, -1, NULL, NULL, &gerr);
19508021de10SMarc-André Lureau if (!wpass) {
19518021de10SMarc-André Lureau goto done;
19528021de10SMarc-André Lureau }
1953259434b8SMarc-André Lureau
1954259434b8SMarc-André Lureau pi1003.usri1003_password = wpass;
1955259434b8SMarc-André Lureau nas = NetUserSetInfo(NULL, user,
1956259434b8SMarc-André Lureau 1003, (LPBYTE)&pi1003,
1957259434b8SMarc-André Lureau NULL);
1958259434b8SMarc-André Lureau
1959259434b8SMarc-André Lureau if (nas != NERR_Success) {
1960259434b8SMarc-André Lureau gchar *msg = get_net_error_message(nas);
1961259434b8SMarc-André Lureau error_setg(errp, "failed to set password: %s", msg);
1962259434b8SMarc-André Lureau g_free(msg);
1963259434b8SMarc-André Lureau }
1964259434b8SMarc-André Lureau
19658021de10SMarc-André Lureau done:
19668021de10SMarc-André Lureau if (gerr) {
19678021de10SMarc-André Lureau error_setg(errp, QERR_QGA_COMMAND_FAILED, gerr->message);
19688021de10SMarc-André Lureau g_error_free(gerr);
19698021de10SMarc-André Lureau }
1970259434b8SMarc-André Lureau g_free(user);
1971259434b8SMarc-André Lureau g_free(wpass);
1972259434b8SMarc-André Lureau g_free(rawpasswddata);
1973215a2771SDaniel P. Berrange }
1974215a2771SDaniel P. Berrange
qmp_guest_get_memory_blocks(Error ** errp)1975a065aaa9Szhanghailiang GuestMemoryBlockList *qmp_guest_get_memory_blocks(Error **errp)
1976a065aaa9Szhanghailiang {
1977c6bd8c70SMarkus Armbruster error_setg(errp, QERR_UNSUPPORTED);
1978a065aaa9Szhanghailiang return NULL;
1979a065aaa9Szhanghailiang }
1980a065aaa9Szhanghailiang
1981a065aaa9Szhanghailiang GuestMemoryBlockResponseList *
qmp_guest_set_memory_blocks(GuestMemoryBlockList * mem_blks,Error ** errp)1982a065aaa9Szhanghailiang qmp_guest_set_memory_blocks(GuestMemoryBlockList *mem_blks, Error **errp)
1983a065aaa9Szhanghailiang {
1984c6bd8c70SMarkus Armbruster error_setg(errp, QERR_UNSUPPORTED);
1985a065aaa9Szhanghailiang return NULL;
1986a065aaa9Szhanghailiang }
1987a065aaa9Szhanghailiang
qmp_guest_get_memory_block_info(Error ** errp)1988a065aaa9Szhanghailiang GuestMemoryBlockInfo *qmp_guest_get_memory_block_info(Error **errp)
1989a065aaa9Szhanghailiang {
1990c6bd8c70SMarkus Armbruster error_setg(errp, QERR_UNSUPPORTED);
1991a065aaa9Szhanghailiang return NULL;
1992a065aaa9Szhanghailiang }
1993a065aaa9Szhanghailiang
19940e4ef702SThomas Huth /* add unsupported commands to the list of blocked RPCs */
ga_command_init_blockedrpcs(GList * blockedrpcs)19950e4ef702SThomas Huth GList *ga_command_init_blockedrpcs(GList *blockedrpcs)
19961281c08aSTomoki Sekiyama {
19971281c08aSTomoki Sekiyama const char *list_unsupported[] = {
1998d6c5528bSKirk Allan "guest-suspend-hybrid",
1999a7a17362SGal Hammer "guest-set-vcpus",
20000dd38a03Szhanghailiang "guest-get-memory-blocks", "guest-set-memory-blocks",
200128d8dd35SBasil Salman "guest-get-memory-block-size", "guest-get-memory-block-info",
200291274487SDenis V. Lunev NULL};
20031281c08aSTomoki Sekiyama char **p = (char **)list_unsupported;
20041281c08aSTomoki Sekiyama
20051281c08aSTomoki Sekiyama while (*p) {
20060e4ef702SThomas Huth blockedrpcs = g_list_append(blockedrpcs, g_strdup(*p++));
20071281c08aSTomoki Sekiyama }
20081281c08aSTomoki Sekiyama
20091281c08aSTomoki Sekiyama if (!vss_init(true)) {
2010c69403fcSYossi Hindin g_debug("vss_init failed, vss commands are going to be disabled");
20111281c08aSTomoki Sekiyama const char *list[] = {
20121281c08aSTomoki Sekiyama "guest-get-fsinfo", "guest-fsfreeze-status",
20131281c08aSTomoki Sekiyama "guest-fsfreeze-freeze", "guest-fsfreeze-thaw", NULL};
20141281c08aSTomoki Sekiyama p = (char **)list;
20151281c08aSTomoki Sekiyama
20161281c08aSTomoki Sekiyama while (*p) {
20170e4ef702SThomas Huth blockedrpcs = g_list_append(blockedrpcs, g_strdup(*p++));
20181281c08aSTomoki Sekiyama }
20191281c08aSTomoki Sekiyama }
20201281c08aSTomoki Sekiyama
20210e4ef702SThomas Huth return blockedrpcs;
20221281c08aSTomoki Sekiyama }
20231281c08aSTomoki Sekiyama
2024d8ca685aSMichael Roth /* register init/cleanup routines for stateful command groups */
ga_command_state_init(GAState * s,GACommandState * cs)2025d8ca685aSMichael Roth void ga_command_state_init(GAState *s, GACommandState *cs)
2026d8ca685aSMichael Roth {
20271281c08aSTomoki Sekiyama if (!vss_initialized()) {
202864c00317STomoki Sekiyama ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup);
202964c00317STomoki Sekiyama }
2030d8ca685aSMichael Roth }
2031161a56a9SVinzenz Feenstra
2032161a56a9SVinzenz Feenstra /* MINGW is missing two fields: IncomingFrames & OutgoingFrames */
2033161a56a9SVinzenz Feenstra typedef struct _GA_WTSINFOA {
2034161a56a9SVinzenz Feenstra WTS_CONNECTSTATE_CLASS State;
2035161a56a9SVinzenz Feenstra DWORD SessionId;
2036161a56a9SVinzenz Feenstra DWORD IncomingBytes;
2037161a56a9SVinzenz Feenstra DWORD OutgoingBytes;
2038161a56a9SVinzenz Feenstra DWORD IncomingFrames;
2039161a56a9SVinzenz Feenstra DWORD OutgoingFrames;
2040161a56a9SVinzenz Feenstra DWORD IncomingCompressedBytes;
2041161a56a9SVinzenz Feenstra DWORD OutgoingCompressedBy;
2042161a56a9SVinzenz Feenstra CHAR WinStationName[WINSTATIONNAME_LENGTH];
2043161a56a9SVinzenz Feenstra CHAR Domain[DOMAIN_LENGTH];
2044161a56a9SVinzenz Feenstra CHAR UserName[USERNAME_LENGTH + 1];
2045161a56a9SVinzenz Feenstra LARGE_INTEGER ConnectTime;
2046161a56a9SVinzenz Feenstra LARGE_INTEGER DisconnectTime;
2047161a56a9SVinzenz Feenstra LARGE_INTEGER LastInputTime;
2048161a56a9SVinzenz Feenstra LARGE_INTEGER LogonTime;
2049161a56a9SVinzenz Feenstra LARGE_INTEGER CurrentTime;
2050161a56a9SVinzenz Feenstra
2051161a56a9SVinzenz Feenstra } GA_WTSINFOA;
2052161a56a9SVinzenz Feenstra
qmp_guest_get_users(Error ** errp)2053b90abbacSVladimir Sementsov-Ogievskiy GuestUserList *qmp_guest_get_users(Error **errp)
2054161a56a9SVinzenz Feenstra {
2055161a56a9SVinzenz Feenstra #define QGA_NANOSECONDS 10000000
2056161a56a9SVinzenz Feenstra
2057161a56a9SVinzenz Feenstra GHashTable *cache = NULL;
205895b3a8c8SEric Blake GuestUserList *head = NULL, **tail = &head;
2059161a56a9SVinzenz Feenstra
2060161a56a9SVinzenz Feenstra DWORD buffer_size = 0, count = 0, i = 0;
2061161a56a9SVinzenz Feenstra GA_WTSINFOA *info = NULL;
2062161a56a9SVinzenz Feenstra WTS_SESSION_INFOA *entries = NULL;
2063161a56a9SVinzenz Feenstra GuestUser *user = NULL;
2064161a56a9SVinzenz Feenstra gpointer value = NULL;
2065161a56a9SVinzenz Feenstra INT64 login = 0;
2066161a56a9SVinzenz Feenstra double login_time = 0;
2067161a56a9SVinzenz Feenstra
2068161a56a9SVinzenz Feenstra cache = g_hash_table_new(g_str_hash, g_str_equal);
2069161a56a9SVinzenz Feenstra
2070161a56a9SVinzenz Feenstra if (WTSEnumerateSessionsA(NULL, 0, 1, &entries, &count)) {
2071161a56a9SVinzenz Feenstra for (i = 0; i < count; ++i) {
2072161a56a9SVinzenz Feenstra buffer_size = 0;
2073161a56a9SVinzenz Feenstra info = NULL;
2074161a56a9SVinzenz Feenstra if (WTSQuerySessionInformationA(
2075161a56a9SVinzenz Feenstra NULL,
2076161a56a9SVinzenz Feenstra entries[i].SessionId,
2077161a56a9SVinzenz Feenstra WTSSessionInfo,
2078161a56a9SVinzenz Feenstra (LPSTR *)&info,
2079161a56a9SVinzenz Feenstra &buffer_size
2080161a56a9SVinzenz Feenstra )) {
2081161a56a9SVinzenz Feenstra
2082161a56a9SVinzenz Feenstra if (strlen(info->UserName) == 0) {
2083161a56a9SVinzenz Feenstra WTSFreeMemory(info);
2084161a56a9SVinzenz Feenstra continue;
2085161a56a9SVinzenz Feenstra }
2086161a56a9SVinzenz Feenstra
2087161a56a9SVinzenz Feenstra login = info->LogonTime.QuadPart;
2088161a56a9SVinzenz Feenstra login -= W32_FT_OFFSET;
2089161a56a9SVinzenz Feenstra login_time = ((double)login) / QGA_NANOSECONDS;
2090161a56a9SVinzenz Feenstra
2091161a56a9SVinzenz Feenstra if (g_hash_table_contains(cache, info->UserName)) {
2092161a56a9SVinzenz Feenstra value = g_hash_table_lookup(cache, info->UserName);
2093161a56a9SVinzenz Feenstra user = (GuestUser *)value;
2094161a56a9SVinzenz Feenstra if (user->login_time > login_time) {
2095161a56a9SVinzenz Feenstra user->login_time = login_time;
2096161a56a9SVinzenz Feenstra }
2097161a56a9SVinzenz Feenstra } else {
209895b3a8c8SEric Blake user = g_new0(GuestUser, 1);
2099161a56a9SVinzenz Feenstra
210095b3a8c8SEric Blake user->user = g_strdup(info->UserName);
210195b3a8c8SEric Blake user->domain = g_strdup(info->Domain);
2102161a56a9SVinzenz Feenstra
210395b3a8c8SEric Blake user->login_time = login_time;
2104161a56a9SVinzenz Feenstra
210595b3a8c8SEric Blake g_hash_table_add(cache, user->user);
2106161a56a9SVinzenz Feenstra
210795b3a8c8SEric Blake QAPI_LIST_APPEND(tail, user);
2108161a56a9SVinzenz Feenstra }
2109161a56a9SVinzenz Feenstra }
2110161a56a9SVinzenz Feenstra WTSFreeMemory(info);
2111161a56a9SVinzenz Feenstra }
2112161a56a9SVinzenz Feenstra WTSFreeMemory(entries);
2113161a56a9SVinzenz Feenstra }
2114161a56a9SVinzenz Feenstra g_hash_table_destroy(cache);
2115161a56a9SVinzenz Feenstra return head;
2116161a56a9SVinzenz Feenstra }
21179848f797STomáš Golembiovský
21189848f797STomáš Golembiovský typedef struct _ga_matrix_lookup_t {
21199848f797STomáš Golembiovský int major;
21209848f797STomáš Golembiovský int minor;
21219848f797STomáš Golembiovský char const *version;
21229848f797STomáš Golembiovský char const *version_id;
21239848f797STomáš Golembiovský } ga_matrix_lookup_t;
21249848f797STomáš Golembiovský
2125206ce969SKostiantyn Kostiuk static ga_matrix_lookup_t const WIN_VERSION_MATRIX[2][7] = {
21269848f797STomáš Golembiovský {
21279848f797STomáš Golembiovský /* Desktop editions */
21289848f797STomáš Golembiovský { 5, 0, "Microsoft Windows 2000", "2000"},
21299848f797STomáš Golembiovský { 5, 1, "Microsoft Windows XP", "xp"},
21309848f797STomáš Golembiovský { 6, 0, "Microsoft Windows Vista", "vista"},
21319848f797STomáš Golembiovský { 6, 1, "Microsoft Windows 7" "7"},
21329848f797STomáš Golembiovský { 6, 2, "Microsoft Windows 8", "8"},
21339848f797STomáš Golembiovský { 6, 3, "Microsoft Windows 8.1", "8.1"},
21349848f797STomáš Golembiovský { 0, 0, 0}
21359848f797STomáš Golembiovský },{
21369848f797STomáš Golembiovský /* Server editions */
21379848f797STomáš Golembiovský { 5, 2, "Microsoft Windows Server 2003", "2003"},
21389848f797STomáš Golembiovský { 6, 0, "Microsoft Windows Server 2008", "2008"},
21399848f797STomáš Golembiovský { 6, 1, "Microsoft Windows Server 2008 R2", "2008r2"},
21409848f797STomáš Golembiovský { 6, 2, "Microsoft Windows Server 2012", "2012"},
21419848f797STomáš Golembiovský { 6, 3, "Microsoft Windows Server 2012 R2", "2012r2"},
2142bd586a91SBishara AbuHattoum { 0, 0, 0},
21439848f797STomáš Golembiovský { 0, 0, 0}
21449848f797STomáš Golembiovský }
21459848f797STomáš Golembiovský };
21469848f797STomáš Golembiovský
2147206ce969SKostiantyn Kostiuk typedef struct _ga_win_10_0_t {
214892857cd7SKostiantyn Kostiuk int first_build;
2149bd586a91SBishara AbuHattoum char const *version;
2150bd586a91SBishara AbuHattoum char const *version_id;
2151206ce969SKostiantyn Kostiuk } ga_win_10_0_t;
2152bd586a91SBishara AbuHattoum
2153206ce969SKostiantyn Kostiuk static ga_win_10_0_t const WIN_10_0_SERVER_VERSION_MATRIX[4] = {
2154bd586a91SBishara AbuHattoum {14393, "Microsoft Windows Server 2016", "2016"},
2155bd586a91SBishara AbuHattoum {17763, "Microsoft Windows Server 2019", "2019"},
2156c141814dSKostiantyn Kostiuk {20344, "Microsoft Windows Server 2022", "2022"},
2157bd586a91SBishara AbuHattoum {0, 0}
2158bd586a91SBishara AbuHattoum };
2159bd586a91SBishara AbuHattoum
2160206ce969SKostiantyn Kostiuk static ga_win_10_0_t const WIN_10_0_CLIENT_VERSION_MATRIX[3] = {
2161206ce969SKostiantyn Kostiuk {10240, "Microsoft Windows 10", "10"},
2162206ce969SKostiantyn Kostiuk {22000, "Microsoft Windows 11", "11"},
2163206ce969SKostiantyn Kostiuk {0, 0}
2164206ce969SKostiantyn Kostiuk };
2165206ce969SKostiantyn Kostiuk
ga_get_win_version(RTL_OSVERSIONINFOEXW * info,Error ** errp)21669848f797STomáš Golembiovský static void ga_get_win_version(RTL_OSVERSIONINFOEXW *info, Error **errp)
21679848f797STomáš Golembiovský {
21689848f797STomáš Golembiovský typedef NTSTATUS(WINAPI *rtl_get_version_t)(
21699848f797STomáš Golembiovský RTL_OSVERSIONINFOEXW *os_version_info_ex);
21709848f797STomáš Golembiovský
21719848f797STomáš Golembiovský info->dwOSVersionInfoSize = sizeof(RTL_OSVERSIONINFOEXW);
21729848f797STomáš Golembiovský
21739848f797STomáš Golembiovský HMODULE module = GetModuleHandle("ntdll");
21749848f797STomáš Golembiovský PVOID fun = GetProcAddress(module, "RtlGetVersion");
21759848f797STomáš Golembiovský if (fun == NULL) {
21769848f797STomáš Golembiovský error_setg(errp, QERR_QGA_COMMAND_FAILED,
21779848f797STomáš Golembiovský "Failed to get address of RtlGetVersion");
21789848f797STomáš Golembiovský return;
21799848f797STomáš Golembiovský }
21809848f797STomáš Golembiovský
21819848f797STomáš Golembiovský rtl_get_version_t rtl_get_version = (rtl_get_version_t)fun;
21829848f797STomáš Golembiovský rtl_get_version(info);
21839848f797STomáš Golembiovský return;
21849848f797STomáš Golembiovský }
21859848f797STomáš Golembiovský
ga_get_win_name(OSVERSIONINFOEXW const * os_version,bool id)21869848f797STomáš Golembiovský static char *ga_get_win_name(OSVERSIONINFOEXW const *os_version, bool id)
21879848f797STomáš Golembiovský {
21889848f797STomáš Golembiovský DWORD major = os_version->dwMajorVersion;
21899848f797STomáš Golembiovský DWORD minor = os_version->dwMinorVersion;
2190bd586a91SBishara AbuHattoum DWORD build = os_version->dwBuildNumber;
21919848f797STomáš Golembiovský int tbl_idx = (os_version->wProductType != VER_NT_WORKSTATION);
21929848f797STomáš Golembiovský ga_matrix_lookup_t const *table = WIN_VERSION_MATRIX[tbl_idx];
2193206ce969SKostiantyn Kostiuk ga_win_10_0_t const *win_10_0_table = tbl_idx ?
2194206ce969SKostiantyn Kostiuk WIN_10_0_SERVER_VERSION_MATRIX : WIN_10_0_CLIENT_VERSION_MATRIX;
2195206ce969SKostiantyn Kostiuk ga_win_10_0_t const *win_10_0_version = NULL;
21969848f797STomáš Golembiovský while (table->version != NULL) {
2197206ce969SKostiantyn Kostiuk if (major == 10 && minor == 0) {
2198bd586a91SBishara AbuHattoum while (win_10_0_table->version != NULL) {
219992857cd7SKostiantyn Kostiuk if (build >= win_10_0_table->first_build) {
220092857cd7SKostiantyn Kostiuk win_10_0_version = win_10_0_table;
2201bd586a91SBishara AbuHattoum }
2202bd586a91SBishara AbuHattoum win_10_0_table++;
2203bd586a91SBishara AbuHattoum }
220492857cd7SKostiantyn Kostiuk if (win_10_0_table) {
220592857cd7SKostiantyn Kostiuk if (id) {
220692857cd7SKostiantyn Kostiuk return g_strdup(win_10_0_version->version_id);
220792857cd7SKostiantyn Kostiuk } else {
220892857cd7SKostiantyn Kostiuk return g_strdup(win_10_0_version->version);
220992857cd7SKostiantyn Kostiuk }
221092857cd7SKostiantyn Kostiuk }
2211bd586a91SBishara AbuHattoum } else if (major == table->major && minor == table->minor) {
22129848f797STomáš Golembiovský if (id) {
22139848f797STomáš Golembiovský return g_strdup(table->version_id);
22149848f797STomáš Golembiovský } else {
22159848f797STomáš Golembiovský return g_strdup(table->version);
22169848f797STomáš Golembiovský }
22179848f797STomáš Golembiovský }
22189848f797STomáš Golembiovský ++table;
22199848f797STomáš Golembiovský }
22209848f797STomáš Golembiovský slog("failed to lookup Windows version: major=%lu, minor=%lu",
22219848f797STomáš Golembiovský major, minor);
22229848f797STomáš Golembiovský return g_strdup("N/A");
22239848f797STomáš Golembiovský }
22249848f797STomáš Golembiovský
ga_get_win_product_name(Error ** errp)22259848f797STomáš Golembiovský static char *ga_get_win_product_name(Error **errp)
22269848f797STomáš Golembiovský {
2227ce72f112SBasil Salman HKEY key = INVALID_HANDLE_VALUE;
22289848f797STomáš Golembiovský DWORD size = 128;
22299848f797STomáš Golembiovský char *result = g_malloc0(size);
22309848f797STomáš Golembiovský LONG err = ERROR_SUCCESS;
22319848f797STomáš Golembiovský
22329848f797STomáš Golembiovský err = RegOpenKeyA(HKEY_LOCAL_MACHINE,
22339848f797STomáš Golembiovský "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion",
22349848f797STomáš Golembiovský &key);
22359848f797STomáš Golembiovský if (err != ERROR_SUCCESS) {
22369848f797STomáš Golembiovský error_setg_win32(errp, err, "failed to open registry key");
2237ce72f112SBasil Salman g_free(result);
2238ce72f112SBasil Salman return NULL;
22399848f797STomáš Golembiovský }
22409848f797STomáš Golembiovský
22419848f797STomáš Golembiovský err = RegQueryValueExA(key, "ProductName", NULL, NULL,
22429848f797STomáš Golembiovský (LPBYTE)result, &size);
22439848f797STomáš Golembiovský if (err == ERROR_MORE_DATA) {
22449848f797STomáš Golembiovský slog("ProductName longer than expected (%lu bytes), retrying",
22459848f797STomáš Golembiovský size);
22469848f797STomáš Golembiovský g_free(result);
22479848f797STomáš Golembiovský result = NULL;
22489848f797STomáš Golembiovský if (size > 0) {
22499848f797STomáš Golembiovský result = g_malloc0(size);
22509848f797STomáš Golembiovský err = RegQueryValueExA(key, "ProductName", NULL, NULL,
22519848f797STomáš Golembiovský (LPBYTE)result, &size);
22529848f797STomáš Golembiovský }
22539848f797STomáš Golembiovský }
22549848f797STomáš Golembiovský if (err != ERROR_SUCCESS) {
2255*01dc0651SMichael Tokarev error_setg_win32(errp, err, "failed to retrieve ProductName");
22569848f797STomáš Golembiovský goto fail;
22579848f797STomáš Golembiovský }
22589848f797STomáš Golembiovský
2259ce72f112SBasil Salman RegCloseKey(key);
22609848f797STomáš Golembiovský return result;
22619848f797STomáš Golembiovský
22629848f797STomáš Golembiovský fail:
2263ce72f112SBasil Salman if (key != INVALID_HANDLE_VALUE) {
2264ce72f112SBasil Salman RegCloseKey(key);
2265ce72f112SBasil Salman }
22669848f797STomáš Golembiovský g_free(result);
22679848f797STomáš Golembiovský return NULL;
22689848f797STomáš Golembiovský }
22699848f797STomáš Golembiovský
ga_get_current_arch(void)22709848f797STomáš Golembiovský static char *ga_get_current_arch(void)
22719848f797STomáš Golembiovský {
22729848f797STomáš Golembiovský SYSTEM_INFO info;
22739848f797STomáš Golembiovský GetNativeSystemInfo(&info);
22749848f797STomáš Golembiovský char *result = NULL;
22759848f797STomáš Golembiovský switch (info.wProcessorArchitecture) {
22769848f797STomáš Golembiovský case PROCESSOR_ARCHITECTURE_AMD64:
22779848f797STomáš Golembiovský result = g_strdup("x86_64");
22789848f797STomáš Golembiovský break;
22799848f797STomáš Golembiovský case PROCESSOR_ARCHITECTURE_ARM:
22809848f797STomáš Golembiovský result = g_strdup("arm");
22819848f797STomáš Golembiovský break;
22829848f797STomáš Golembiovský case PROCESSOR_ARCHITECTURE_IA64:
22839848f797STomáš Golembiovský result = g_strdup("ia64");
22849848f797STomáš Golembiovský break;
22859848f797STomáš Golembiovský case PROCESSOR_ARCHITECTURE_INTEL:
22869848f797STomáš Golembiovský result = g_strdup("x86");
22879848f797STomáš Golembiovský break;
22889848f797STomáš Golembiovský case PROCESSOR_ARCHITECTURE_UNKNOWN:
22899848f797STomáš Golembiovský default:
22909848f797STomáš Golembiovský slog("unknown processor architecture 0x%0x",
22919848f797STomáš Golembiovský info.wProcessorArchitecture);
22929848f797STomáš Golembiovský result = g_strdup("unknown");
22939848f797STomáš Golembiovský break;
22949848f797STomáš Golembiovský }
22959848f797STomáš Golembiovský return result;
22969848f797STomáš Golembiovský }
22979848f797STomáš Golembiovský
qmp_guest_get_osinfo(Error ** errp)22989848f797STomáš Golembiovský GuestOSInfo *qmp_guest_get_osinfo(Error **errp)
22999848f797STomáš Golembiovský {
23009848f797STomáš Golembiovský Error *local_err = NULL;
23019848f797STomáš Golembiovský OSVERSIONINFOEXW os_version = {0};
23029848f797STomáš Golembiovský bool server;
23039848f797STomáš Golembiovský char *product_name;
23049848f797STomáš Golembiovský GuestOSInfo *info;
23059848f797STomáš Golembiovský
23069848f797STomáš Golembiovský ga_get_win_version(&os_version, &local_err);
23079848f797STomáš Golembiovský if (local_err) {
23089848f797STomáš Golembiovský error_propagate(errp, local_err);
23099848f797STomáš Golembiovský return NULL;
23109848f797STomáš Golembiovský }
23119848f797STomáš Golembiovský
23129848f797STomáš Golembiovský server = os_version.wProductType != VER_NT_WORKSTATION;
2313668f62ecSMarkus Armbruster product_name = ga_get_win_product_name(errp);
23149848f797STomáš Golembiovský if (product_name == NULL) {
23159848f797STomáš Golembiovský return NULL;
23169848f797STomáš Golembiovský }
23179848f797STomáš Golembiovský
23189848f797STomáš Golembiovský info = g_new0(GuestOSInfo, 1);
23199848f797STomáš Golembiovský
23209848f797STomáš Golembiovský info->kernel_version = g_strdup_printf("%lu.%lu",
23219848f797STomáš Golembiovský os_version.dwMajorVersion,
23229848f797STomáš Golembiovský os_version.dwMinorVersion);
23239848f797STomáš Golembiovský info->kernel_release = g_strdup_printf("%lu",
23249848f797STomáš Golembiovský os_version.dwBuildNumber);
23259848f797STomáš Golembiovský info->machine = ga_get_current_arch();
23269848f797STomáš Golembiovský
23279848f797STomáš Golembiovský info->id = g_strdup("mswindows");
23289848f797STomáš Golembiovský info->name = g_strdup("Microsoft Windows");
23299848f797STomáš Golembiovský info->pretty_name = product_name;
23309848f797STomáš Golembiovský info->version = ga_get_win_name(&os_version, false);
23319848f797STomáš Golembiovský info->version_id = ga_get_win_name(&os_version, true);
23329848f797STomáš Golembiovský info->variant = g_strdup(server ? "server" : "client");
23339848f797STomáš Golembiovský info->variant_id = g_strdup(server ? "server" : "client");
23349848f797STomáš Golembiovský
23359848f797STomáš Golembiovský return info;
23369848f797STomáš Golembiovský }
23372e4211ceSTomáš Golembiovský
23382e4211ceSTomáš Golembiovský /*
23392e4211ceSTomáš Golembiovský * Safely get device property. Returned strings are using wide characters.
23402e4211ceSTomáš Golembiovský * Caller is responsible for freeing the buffer.
23412e4211ceSTomáš Golembiovský */
cm_get_property(DEVINST devInst,const DEVPROPKEY * propName,PDEVPROPTYPE propType)23422e4211ceSTomáš Golembiovský static LPBYTE cm_get_property(DEVINST devInst, const DEVPROPKEY *propName,
23432e4211ceSTomáš Golembiovský PDEVPROPTYPE propType)
23442e4211ceSTomáš Golembiovský {
23452e4211ceSTomáš Golembiovský CONFIGRET cr;
23462e4211ceSTomáš Golembiovský g_autofree LPBYTE buffer = NULL;
23472e4211ceSTomáš Golembiovský ULONG buffer_len = 0;
23482e4211ceSTomáš Golembiovský
23492e4211ceSTomáš Golembiovský /* First query for needed space */
23502e4211ceSTomáš Golembiovský cr = CM_Get_DevNode_PropertyW(devInst, propName, propType,
23512e4211ceSTomáš Golembiovský buffer, &buffer_len, 0);
23522e4211ceSTomáš Golembiovský if (cr != CR_SUCCESS && cr != CR_BUFFER_SMALL) {
23532e4211ceSTomáš Golembiovský
23542e4211ceSTomáš Golembiovský slog("failed to get property size, error=0x%lx", cr);
23552e4211ceSTomáš Golembiovský return NULL;
23562e4211ceSTomáš Golembiovský }
23572e4211ceSTomáš Golembiovský buffer = g_new0(BYTE, buffer_len + 1);
23582e4211ceSTomáš Golembiovský cr = CM_Get_DevNode_PropertyW(devInst, propName, propType,
23592e4211ceSTomáš Golembiovský buffer, &buffer_len, 0);
23602e4211ceSTomáš Golembiovský if (cr != CR_SUCCESS) {
23612e4211ceSTomáš Golembiovský slog("failed to get device property, error=0x%lx", cr);
23622e4211ceSTomáš Golembiovský return NULL;
23632e4211ceSTomáš Golembiovský }
23642e4211ceSTomáš Golembiovský return g_steal_pointer(&buffer);
23652e4211ceSTomáš Golembiovský }
23662e4211ceSTomáš Golembiovský
ga_get_hardware_ids(DEVINST devInstance)23672e4211ceSTomáš Golembiovský static GStrv ga_get_hardware_ids(DEVINST devInstance)
23682e4211ceSTomáš Golembiovský {
23692e4211ceSTomáš Golembiovský GArray *values = NULL;
23702e4211ceSTomáš Golembiovský DEVPROPTYPE cm_type;
23712e4211ceSTomáš Golembiovský LPWSTR id;
23722e4211ceSTomáš Golembiovský g_autofree LPWSTR property = (LPWSTR)cm_get_property(devInstance,
23732e4211ceSTomáš Golembiovský &qga_DEVPKEY_Device_HardwareIds, &cm_type);
23742e4211ceSTomáš Golembiovský if (property == NULL) {
23752e4211ceSTomáš Golembiovský slog("failed to get hardware IDs");
23762e4211ceSTomáš Golembiovský return NULL;
23772e4211ceSTomáš Golembiovský }
23782e4211ceSTomáš Golembiovský if (*property == '\0') {
23792e4211ceSTomáš Golembiovský /* empty list */
23802e4211ceSTomáš Golembiovský return NULL;
23812e4211ceSTomáš Golembiovský }
23822e4211ceSTomáš Golembiovský values = g_array_new(TRUE, TRUE, sizeof(gchar *));
23832e4211ceSTomáš Golembiovský for (id = property; '\0' != *id; id += lstrlenW(id) + 1) {
23842e4211ceSTomáš Golembiovský gchar *id8 = g_utf16_to_utf8(id, -1, NULL, NULL, NULL);
23852e4211ceSTomáš Golembiovský g_array_append_val(values, id8);
23862e4211ceSTomáš Golembiovský }
23872e4211ceSTomáš Golembiovský return (GStrv)g_array_free(values, FALSE);
23882e4211ceSTomáš Golembiovský }
23892e4211ceSTomáš Golembiovský
23902e4211ceSTomáš Golembiovský /*
23912e4211ceSTomáš Golembiovský * https://docs.microsoft.com/en-us/windows-hardware/drivers/install/identifiers-for-pci-devices
23922e4211ceSTomáš Golembiovský */
23932e4211ceSTomáš Golembiovský #define DEVICE_PCI_RE "PCI\\\\VEN_(1AF4|1B36)&DEV_([0-9A-B]{4})(&|$)"
23942e4211ceSTomáš Golembiovský
qmp_guest_get_devices(Error ** errp)23952e4211ceSTomáš Golembiovský GuestDeviceInfoList *qmp_guest_get_devices(Error **errp)
23962e4211ceSTomáš Golembiovský {
239795b3a8c8SEric Blake GuestDeviceInfoList *head = NULL, **tail = &head;
23982e4211ceSTomáš Golembiovský HDEVINFO dev_info = INVALID_HANDLE_VALUE;
23992e4211ceSTomáš Golembiovský SP_DEVINFO_DATA dev_info_data;
24002e4211ceSTomáš Golembiovský int i, j;
24012e4211ceSTomáš Golembiovský GError *gerr = NULL;
24022e4211ceSTomáš Golembiovský g_autoptr(GRegex) device_pci_re = NULL;
24032e4211ceSTomáš Golembiovský DEVPROPTYPE cm_type;
24042e4211ceSTomáš Golembiovský
24052e4211ceSTomáš Golembiovský device_pci_re = g_regex_new(DEVICE_PCI_RE,
24062e4211ceSTomáš Golembiovský G_REGEX_ANCHORED | G_REGEX_OPTIMIZE, 0,
24072e4211ceSTomáš Golembiovský &gerr);
24082e4211ceSTomáš Golembiovský g_assert(device_pci_re != NULL);
24092e4211ceSTomáš Golembiovský
24102e4211ceSTomáš Golembiovský dev_info_data.cbSize = sizeof(SP_DEVINFO_DATA);
24112e4211ceSTomáš Golembiovský dev_info = SetupDiGetClassDevs(0, 0, 0, DIGCF_PRESENT | DIGCF_ALLCLASSES);
24122e4211ceSTomáš Golembiovský if (dev_info == INVALID_HANDLE_VALUE) {
24132e4211ceSTomáš Golembiovský error_setg(errp, "failed to get device tree");
24142e4211ceSTomáš Golembiovský return NULL;
24152e4211ceSTomáš Golembiovský }
24162e4211ceSTomáš Golembiovský
24172e4211ceSTomáš Golembiovský slog("enumerating devices");
24182e4211ceSTomáš Golembiovský for (i = 0; SetupDiEnumDeviceInfo(dev_info, i, &dev_info_data); i++) {
24192e4211ceSTomáš Golembiovský bool skip = true;
24202e4211ceSTomáš Golembiovský g_autofree LPWSTR name = NULL;
24212e4211ceSTomáš Golembiovský g_autofree LPFILETIME date = NULL;
24222e4211ceSTomáš Golembiovský g_autofree LPWSTR version = NULL;
24232e4211ceSTomáš Golembiovský g_auto(GStrv) hw_ids = NULL;
24242e4211ceSTomáš Golembiovský g_autoptr(GuestDeviceInfo) device = g_new0(GuestDeviceInfo, 1);
24252e4211ceSTomáš Golembiovský g_autofree char *vendor_id = NULL;
24262e4211ceSTomáš Golembiovský g_autofree char *device_id = NULL;
24272e4211ceSTomáš Golembiovský
24282e4211ceSTomáš Golembiovský name = (LPWSTR)cm_get_property(dev_info_data.DevInst,
24292e4211ceSTomáš Golembiovský &qga_DEVPKEY_NAME, &cm_type);
24302e4211ceSTomáš Golembiovský if (name == NULL) {
24312e4211ceSTomáš Golembiovský slog("failed to get device description");
24322e4211ceSTomáš Golembiovský continue;
24332e4211ceSTomáš Golembiovský }
24342e4211ceSTomáš Golembiovský device->driver_name = g_utf16_to_utf8(name, -1, NULL, NULL, NULL);
24352e4211ceSTomáš Golembiovský if (device->driver_name == NULL) {
24362e4211ceSTomáš Golembiovský error_setg(errp, "conversion to utf8 failed (driver name)");
2437939caddcSMarkus Armbruster return NULL;
24382e4211ceSTomáš Golembiovský }
24392e4211ceSTomáš Golembiovský slog("querying device: %s", device->driver_name);
24402e4211ceSTomáš Golembiovský hw_ids = ga_get_hardware_ids(dev_info_data.DevInst);
24412e4211ceSTomáš Golembiovský if (hw_ids == NULL) {
24422e4211ceSTomáš Golembiovský continue;
24432e4211ceSTomáš Golembiovský }
24442e4211ceSTomáš Golembiovský for (j = 0; hw_ids[j] != NULL; j++) {
244524328b7aSKostiantyn Kostiuk g_autoptr(GMatchInfo) match_info;
2446b519e2e9SMarkus Armbruster GuestDeviceIdPCI *id;
24472e4211ceSTomáš Golembiovský if (!g_regex_match(device_pci_re, hw_ids[j], 0, &match_info)) {
24482e4211ceSTomáš Golembiovský continue;
24492e4211ceSTomáš Golembiovský }
24502e4211ceSTomáš Golembiovský skip = false;
24512e4211ceSTomáš Golembiovský
24522e4211ceSTomáš Golembiovský vendor_id = g_match_info_fetch(match_info, 1);
24532e4211ceSTomáš Golembiovský device_id = g_match_info_fetch(match_info, 2);
24542e4211ceSTomáš Golembiovský
2455b519e2e9SMarkus Armbruster device->id = g_new0(GuestDeviceId, 1);
24560083124bSMarkus Armbruster device->id->type = GUEST_DEVICE_TYPE_PCI;
24570083124bSMarkus Armbruster id = &device->id->u.pci;
24580083124bSMarkus Armbruster id->vendor_id = g_ascii_strtoull(vendor_id, NULL, 16);
24590083124bSMarkus Armbruster id->device_id = g_ascii_strtoull(device_id, NULL, 16);
24602e4211ceSTomáš Golembiovský
24612e4211ceSTomáš Golembiovský break;
24622e4211ceSTomáš Golembiovský }
24632e4211ceSTomáš Golembiovský if (skip) {
24642e4211ceSTomáš Golembiovský continue;
24652e4211ceSTomáš Golembiovský }
24662e4211ceSTomáš Golembiovský
24672e4211ceSTomáš Golembiovský version = (LPWSTR)cm_get_property(dev_info_data.DevInst,
24682e4211ceSTomáš Golembiovský &qga_DEVPKEY_Device_DriverVersion, &cm_type);
24692e4211ceSTomáš Golembiovský if (version == NULL) {
24702e4211ceSTomáš Golembiovský slog("failed to get driver version");
24712e4211ceSTomáš Golembiovský continue;
24722e4211ceSTomáš Golembiovský }
24732e4211ceSTomáš Golembiovský device->driver_version = g_utf16_to_utf8(version, -1, NULL,
24742e4211ceSTomáš Golembiovský NULL, NULL);
24752e4211ceSTomáš Golembiovský if (device->driver_version == NULL) {
24762e4211ceSTomáš Golembiovský error_setg(errp, "conversion to utf8 failed (driver version)");
2477939caddcSMarkus Armbruster return NULL;
24782e4211ceSTomáš Golembiovský }
24792e4211ceSTomáš Golembiovský
24802e4211ceSTomáš Golembiovský date = (LPFILETIME)cm_get_property(dev_info_data.DevInst,
24812e4211ceSTomáš Golembiovský &qga_DEVPKEY_Device_DriverDate, &cm_type);
24822e4211ceSTomáš Golembiovský if (date == NULL) {
24832e4211ceSTomáš Golembiovský slog("failed to get driver date");
24842e4211ceSTomáš Golembiovský continue;
24852e4211ceSTomáš Golembiovský }
2486a88bceefSMarkus Armbruster device->driver_date = filetime_to_ns(date);
24872e4211ceSTomáš Golembiovský device->has_driver_date = true;
24882e4211ceSTomáš Golembiovský
2489a88bceefSMarkus Armbruster slog("driver: %s\ndriver version: %" PRId64 ",%s\n",
2490a88bceefSMarkus Armbruster device->driver_name, device->driver_date,
2491a88bceefSMarkus Armbruster device->driver_version);
249295b3a8c8SEric Blake QAPI_LIST_APPEND(tail, g_steal_pointer(&device));
24932e4211ceSTomáš Golembiovský }
24942e4211ceSTomáš Golembiovský
24952e4211ceSTomáš Golembiovský if (dev_info != INVALID_HANDLE_VALUE) {
24962e4211ceSTomáš Golembiovský SetupDiDestroyDeviceInfoList(dev_info);
24972e4211ceSTomáš Golembiovský }
24982e4211ceSTomáš Golembiovský return head;
24992e4211ceSTomáš Golembiovský }
2500548fb0daSMarc-André Lureau
qga_get_host_name(Error ** errp)2501548fb0daSMarc-André Lureau char *qga_get_host_name(Error **errp)
2502548fb0daSMarc-André Lureau {
2503548fb0daSMarc-André Lureau wchar_t tmp[MAX_COMPUTERNAME_LENGTH + 1];
2504548fb0daSMarc-André Lureau DWORD size = G_N_ELEMENTS(tmp);
2505548fb0daSMarc-André Lureau
2506548fb0daSMarc-André Lureau if (GetComputerNameW(tmp, &size) == 0) {
2507548fb0daSMarc-André Lureau error_setg_win32(errp, GetLastError(), "failed close handle");
2508548fb0daSMarc-André Lureau return NULL;
2509548fb0daSMarc-André Lureau }
2510548fb0daSMarc-André Lureau
2511548fb0daSMarc-André Lureau return g_utf16_to_utf8(tmp, size, NULL, NULL, NULL);
2512548fb0daSMarc-André Lureau }
25133569664eSluzhipeng
qmp_guest_get_diskstats(Error ** errp)25143569664eSluzhipeng GuestDiskStatsInfoList *qmp_guest_get_diskstats(Error **errp)
25153569664eSluzhipeng {
25163569664eSluzhipeng error_setg(errp, QERR_UNSUPPORTED);
25173569664eSluzhipeng return NULL;
25183569664eSluzhipeng }
25191db8a0b0Szhenwei pi
qmp_guest_get_cpustats(Error ** errp)25201db8a0b0Szhenwei pi GuestCpuStatsList *qmp_guest_get_cpustats(Error **errp)
25211db8a0b0Szhenwei pi {
25221db8a0b0Szhenwei pi error_setg(errp, QERR_UNSUPPORTED);
25231db8a0b0Szhenwei pi return NULL;
25241db8a0b0Szhenwei pi }
2525