s390x/sclpconsole-lm: Fix hanging SCLP line mode console
[qemu.git] / qga / commands-win32.c
1 /*
2 * QEMU Guest Agent win32-specific command implementations
3 *
4 * Copyright IBM Corp. 2012
5 *
6 * Authors:
7 * Michael Roth <mdroth@linux.vnet.ibm.com>
8 * Gal Hammer <ghammer@redhat.com>
9 *
10 * This work is licensed under the terms of the GNU GPL, version 2 or later.
11 * See the COPYING file in the top-level directory.
12 */
13
14 #include <glib.h>
15 #include <wtypes.h>
16 #include <powrprof.h>
17 #include "qga/guest-agent-core.h"
18 #include "qga/vss-win32.h"
19 #include "qga-qmp-commands.h"
20 #include "qapi/qmp/qerror.h"
21
22 #ifndef SHTDN_REASON_FLAG_PLANNED
23 #define SHTDN_REASON_FLAG_PLANNED 0x80000000
24 #endif
25
26 /* multiple of 100 nanoseconds elapsed between windows baseline
27 * (1/1/1601) and Unix Epoch (1/1/1970), accounting for leap years */
28 #define W32_FT_OFFSET (10000000ULL * 60 * 60 * 24 * \
29 (365 * (1970 - 1601) + \
30 (1970 - 1601) / 4 - 3))
31
32 static void acquire_privilege(const char *name, Error **errp)
33 {
34 HANDLE token = NULL;
35 TOKEN_PRIVILEGES priv;
36 Error *local_err = NULL;
37
38 if (OpenProcessToken(GetCurrentProcess(),
39 TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY, &token))
40 {
41 if (!LookupPrivilegeValue(NULL, name, &priv.Privileges[0].Luid)) {
42 error_set(&local_err, QERR_QGA_COMMAND_FAILED,
43 "no luid for requested privilege");
44 goto out;
45 }
46
47 priv.PrivilegeCount = 1;
48 priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
49
50 if (!AdjustTokenPrivileges(token, FALSE, &priv, 0, NULL, 0)) {
51 error_set(&local_err, QERR_QGA_COMMAND_FAILED,
52 "unable to acquire requested privilege");
53 goto out;
54 }
55
56 } else {
57 error_set(&local_err, QERR_QGA_COMMAND_FAILED,
58 "failed to open privilege token");
59 }
60
61 out:
62 if (token) {
63 CloseHandle(token);
64 }
65 if (local_err) {
66 error_propagate(errp, local_err);
67 }
68 }
69
70 static void execute_async(DWORD WINAPI (*func)(LPVOID), LPVOID opaque,
71 Error **errp)
72 {
73 Error *local_err = NULL;
74
75 HANDLE thread = CreateThread(NULL, 0, func, opaque, 0, NULL);
76 if (!thread) {
77 error_set(&local_err, QERR_QGA_COMMAND_FAILED,
78 "failed to dispatch asynchronous command");
79 error_propagate(errp, local_err);
80 }
81 }
82
83 void qmp_guest_shutdown(bool has_mode, const char *mode, Error **errp)
84 {
85 Error *local_err = NULL;
86 UINT shutdown_flag = EWX_FORCE;
87
88 slog("guest-shutdown called, mode: %s", mode);
89
90 if (!has_mode || strcmp(mode, "powerdown") == 0) {
91 shutdown_flag |= EWX_POWEROFF;
92 } else if (strcmp(mode, "halt") == 0) {
93 shutdown_flag |= EWX_SHUTDOWN;
94 } else if (strcmp(mode, "reboot") == 0) {
95 shutdown_flag |= EWX_REBOOT;
96 } else {
97 error_set(errp, QERR_INVALID_PARAMETER_VALUE, "mode",
98 "halt|powerdown|reboot");
99 return;
100 }
101
102 /* Request a shutdown privilege, but try to shut down the system
103 anyway. */
104 acquire_privilege(SE_SHUTDOWN_NAME, &local_err);
105 if (local_err) {
106 error_propagate(errp, local_err);
107 return;
108 }
109
110 if (!ExitWindowsEx(shutdown_flag, SHTDN_REASON_FLAG_PLANNED)) {
111 slog("guest-shutdown failed: %lu", GetLastError());
112 error_set(errp, QERR_UNDEFINED_ERROR);
113 }
114 }
115
116 int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode,
117 Error **errp)
118 {
119 error_set(errp, QERR_UNSUPPORTED);
120 return 0;
121 }
122
123 void qmp_guest_file_close(int64_t handle, Error **errp)
124 {
125 error_set(errp, QERR_UNSUPPORTED);
126 }
127
128 GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
129 int64_t count, Error **errp)
130 {
131 error_set(errp, QERR_UNSUPPORTED);
132 return 0;
133 }
134
135 GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
136 bool has_count, int64_t count,
137 Error **errp)
138 {
139 error_set(errp, QERR_UNSUPPORTED);
140 return 0;
141 }
142
143 GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
144 int64_t whence, Error **errp)
145 {
146 error_set(errp, QERR_UNSUPPORTED);
147 return 0;
148 }
149
150 void qmp_guest_file_flush(int64_t handle, Error **errp)
151 {
152 error_set(errp, QERR_UNSUPPORTED);
153 }
154
155 GuestFilesystemInfoList *qmp_guest_get_fsinfo(Error **errp)
156 {
157 error_set(errp, QERR_UNSUPPORTED);
158 return NULL;
159 }
160
161 /*
162 * Return status of freeze/thaw
163 */
164 GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **errp)
165 {
166 if (!vss_initialized()) {
167 error_set(errp, QERR_UNSUPPORTED);
168 return 0;
169 }
170
171 if (ga_is_frozen(ga_state)) {
172 return GUEST_FSFREEZE_STATUS_FROZEN;
173 }
174
175 return GUEST_FSFREEZE_STATUS_THAWED;
176 }
177
178 /*
179 * Freeze local file systems using Volume Shadow-copy Service.
180 * The frozen state is limited for up to 10 seconds by VSS.
181 */
182 int64_t qmp_guest_fsfreeze_freeze(Error **errp)
183 {
184 int i;
185 Error *local_err = NULL;
186
187 if (!vss_initialized()) {
188 error_set(errp, QERR_UNSUPPORTED);
189 return 0;
190 }
191
192 slog("guest-fsfreeze called");
193
194 /* cannot risk guest agent blocking itself on a write in this state */
195 ga_set_frozen(ga_state);
196
197 qga_vss_fsfreeze(&i, &local_err, true);
198 if (local_err) {
199 error_propagate(errp, local_err);
200 goto error;
201 }
202
203 return i;
204
205 error:
206 local_err = NULL;
207 qmp_guest_fsfreeze_thaw(&local_err);
208 if (local_err) {
209 g_debug("cleanup thaw: %s", error_get_pretty(local_err));
210 error_free(local_err);
211 }
212 return 0;
213 }
214
215 int64_t qmp_guest_fsfreeze_freeze_list(bool has_mountpoints,
216 strList *mountpoints,
217 Error **errp)
218 {
219 error_set(errp, QERR_UNSUPPORTED);
220
221 return 0;
222 }
223
224 /*
225 * Thaw local file systems using Volume Shadow-copy Service.
226 */
227 int64_t qmp_guest_fsfreeze_thaw(Error **errp)
228 {
229 int i;
230
231 if (!vss_initialized()) {
232 error_set(errp, QERR_UNSUPPORTED);
233 return 0;
234 }
235
236 qga_vss_fsfreeze(&i, errp, false);
237
238 ga_unset_frozen(ga_state);
239 return i;
240 }
241
242 static void guest_fsfreeze_cleanup(void)
243 {
244 Error *err = NULL;
245
246 if (!vss_initialized()) {
247 return;
248 }
249
250 if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) {
251 qmp_guest_fsfreeze_thaw(&err);
252 if (err) {
253 slog("failed to clean up frozen filesystems: %s",
254 error_get_pretty(err));
255 error_free(err);
256 }
257 }
258
259 vss_deinit(true);
260 }
261
262 /*
263 * Walk list of mounted file systems in the guest, and discard unused
264 * areas.
265 */
266 void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **errp)
267 {
268 error_set(errp, QERR_UNSUPPORTED);
269 }
270
271 typedef enum {
272 GUEST_SUSPEND_MODE_DISK,
273 GUEST_SUSPEND_MODE_RAM
274 } GuestSuspendMode;
275
276 static void check_suspend_mode(GuestSuspendMode mode, Error **errp)
277 {
278 SYSTEM_POWER_CAPABILITIES sys_pwr_caps;
279 Error *local_err = NULL;
280
281 ZeroMemory(&sys_pwr_caps, sizeof(sys_pwr_caps));
282 if (!GetPwrCapabilities(&sys_pwr_caps)) {
283 error_set(&local_err, QERR_QGA_COMMAND_FAILED,
284 "failed to determine guest suspend capabilities");
285 goto out;
286 }
287
288 switch (mode) {
289 case GUEST_SUSPEND_MODE_DISK:
290 if (!sys_pwr_caps.SystemS4) {
291 error_set(&local_err, QERR_QGA_COMMAND_FAILED,
292 "suspend-to-disk not supported by OS");
293 }
294 break;
295 case GUEST_SUSPEND_MODE_RAM:
296 if (!sys_pwr_caps.SystemS3) {
297 error_set(&local_err, QERR_QGA_COMMAND_FAILED,
298 "suspend-to-ram not supported by OS");
299 }
300 break;
301 default:
302 error_set(&local_err, QERR_INVALID_PARAMETER_VALUE, "mode",
303 "GuestSuspendMode");
304 }
305
306 out:
307 if (local_err) {
308 error_propagate(errp, local_err);
309 }
310 }
311
312 static DWORD WINAPI do_suspend(LPVOID opaque)
313 {
314 GuestSuspendMode *mode = opaque;
315 DWORD ret = 0;
316
317 if (!SetSuspendState(*mode == GUEST_SUSPEND_MODE_DISK, TRUE, TRUE)) {
318 slog("failed to suspend guest, %lu", GetLastError());
319 ret = -1;
320 }
321 g_free(mode);
322 return ret;
323 }
324
325 void qmp_guest_suspend_disk(Error **errp)
326 {
327 Error *local_err = NULL;
328 GuestSuspendMode *mode = g_malloc(sizeof(GuestSuspendMode));
329
330 *mode = GUEST_SUSPEND_MODE_DISK;
331 check_suspend_mode(*mode, &local_err);
332 acquire_privilege(SE_SHUTDOWN_NAME, &local_err);
333 execute_async(do_suspend, mode, &local_err);
334
335 if (local_err) {
336 error_propagate(errp, local_err);
337 g_free(mode);
338 }
339 }
340
341 void qmp_guest_suspend_ram(Error **errp)
342 {
343 Error *local_err = NULL;
344 GuestSuspendMode *mode = g_malloc(sizeof(GuestSuspendMode));
345
346 *mode = GUEST_SUSPEND_MODE_RAM;
347 check_suspend_mode(*mode, &local_err);
348 acquire_privilege(SE_SHUTDOWN_NAME, &local_err);
349 execute_async(do_suspend, mode, &local_err);
350
351 if (local_err) {
352 error_propagate(errp, local_err);
353 g_free(mode);
354 }
355 }
356
357 void qmp_guest_suspend_hybrid(Error **errp)
358 {
359 error_set(errp, QERR_UNSUPPORTED);
360 }
361
362 GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
363 {
364 error_set(errp, QERR_UNSUPPORTED);
365 return NULL;
366 }
367
368 int64_t qmp_guest_get_time(Error **errp)
369 {
370 SYSTEMTIME ts = {0};
371 int64_t time_ns;
372 FILETIME tf;
373
374 GetSystemTime(&ts);
375 if (ts.wYear < 1601 || ts.wYear > 30827) {
376 error_setg(errp, "Failed to get time");
377 return -1;
378 }
379
380 if (!SystemTimeToFileTime(&ts, &tf)) {
381 error_setg(errp, "Failed to convert system time: %d", (int)GetLastError());
382 return -1;
383 }
384
385 time_ns = ((((int64_t)tf.dwHighDateTime << 32) | tf.dwLowDateTime)
386 - W32_FT_OFFSET) * 100;
387
388 return time_ns;
389 }
390
391 void qmp_guest_set_time(bool has_time, int64_t time_ns, Error **errp)
392 {
393 Error *local_err = NULL;
394 SYSTEMTIME ts;
395 FILETIME tf;
396 LONGLONG time;
397
398 if (has_time) {
399 /* Okay, user passed a time to set. Validate it. */
400 if (time_ns < 0 || time_ns / 100 > INT64_MAX - W32_FT_OFFSET) {
401 error_setg(errp, "Time %" PRId64 "is invalid", time_ns);
402 return;
403 }
404
405 time = time_ns / 100 + W32_FT_OFFSET;
406
407 tf.dwLowDateTime = (DWORD) time;
408 tf.dwHighDateTime = (DWORD) (time >> 32);
409
410 if (!FileTimeToSystemTime(&tf, &ts)) {
411 error_setg(errp, "Failed to convert system time %d",
412 (int)GetLastError());
413 return;
414 }
415 } else {
416 /* Otherwise read the time from RTC which contains the correct value.
417 * Hopefully. */
418 GetSystemTime(&ts);
419 if (ts.wYear < 1601 || ts.wYear > 30827) {
420 error_setg(errp, "Failed to get time");
421 return;
422 }
423 }
424
425 acquire_privilege(SE_SYSTEMTIME_NAME, &local_err);
426 if (local_err) {
427 error_propagate(errp, local_err);
428 return;
429 }
430
431 if (!SetSystemTime(&ts)) {
432 error_setg(errp, "Failed to set time to guest: %d", (int)GetLastError());
433 return;
434 }
435 }
436
437 GuestLogicalProcessorList *qmp_guest_get_vcpus(Error **errp)
438 {
439 error_set(errp, QERR_UNSUPPORTED);
440 return NULL;
441 }
442
443 int64_t qmp_guest_set_vcpus(GuestLogicalProcessorList *vcpus, Error **errp)
444 {
445 error_set(errp, QERR_UNSUPPORTED);
446 return -1;
447 }
448
449 /* add unsupported commands to the blacklist */
450 GList *ga_command_blacklist_init(GList *blacklist)
451 {
452 const char *list_unsupported[] = {
453 "guest-file-open", "guest-file-close", "guest-file-read",
454 "guest-file-write", "guest-file-seek", "guest-file-flush",
455 "guest-suspend-hybrid", "guest-network-get-interfaces",
456 "guest-get-vcpus", "guest-set-vcpus",
457 "guest-fsfreeze-freeze-list", "guest-get-fsinfo",
458 "guest-fstrim", NULL};
459 char **p = (char **)list_unsupported;
460
461 while (*p) {
462 blacklist = g_list_append(blacklist, *p++);
463 }
464
465 if (!vss_init(true)) {
466 const char *list[] = {
467 "guest-get-fsinfo", "guest-fsfreeze-status",
468 "guest-fsfreeze-freeze", "guest-fsfreeze-thaw", NULL};
469 p = (char **)list;
470
471 while (*p) {
472 blacklist = g_list_append(blacklist, *p++);
473 }
474 }
475
476 return blacklist;
477 }
478
479 /* register init/cleanup routines for stateful command groups */
480 void ga_command_state_init(GAState *s, GACommandState *cs)
481 {
482 if (!vss_initialized()) {
483 ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup);
484 }
485 }