![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to commands-win32.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / qga|
Return to commands-win32.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / qga |
1.1 root 1: /*
2: * QEMU Guest Agent win32-specific command implementations
3: *
4: * Copyright IBM Corp. 2012
5: *
6: * Authors:
7: * Michael Roth <[email protected]>
8: * Gal Hammer <[email protected]>
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-qmp-commands.h"
19: #include "qerror.h"
20:
21: #ifndef SHTDN_REASON_FLAG_PLANNED
22: #define SHTDN_REASON_FLAG_PLANNED 0x80000000
23: #endif
24:
25: static void acquire_privilege(const char *name, Error **err)
26: {
27: HANDLE token;
28: TOKEN_PRIVILEGES priv;
29: Error *local_err = NULL;
30:
31: if (error_is_set(err)) {
32: return;
33: }
34:
35: if (OpenProcessToken(GetCurrentProcess(),
36: TOKEN_ADJUST_PRIVILEGES|TOKEN_QUERY, &token))
37: {
38: if (!LookupPrivilegeValue(NULL, name, &priv.Privileges[0].Luid)) {
39: error_set(&local_err, QERR_QGA_COMMAND_FAILED,
40: "no luid for requested privilege");
41: goto out;
42: }
43:
44: priv.PrivilegeCount = 1;
45: priv.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
46:
47: if (!AdjustTokenPrivileges(token, FALSE, &priv, 0, NULL, 0)) {
48: error_set(&local_err, QERR_QGA_COMMAND_FAILED,
49: "unable to acquire requested privilege");
50: goto out;
51: }
52:
53: CloseHandle(token);
54: } else {
55: error_set(&local_err, QERR_QGA_COMMAND_FAILED,
56: "failed to open privilege token");
57: }
58:
59: out:
60: if (local_err) {
61: error_propagate(err, local_err);
62: }
63: }
64:
65: static void execute_async(DWORD WINAPI (*func)(LPVOID), LPVOID opaque, Error **err)
66: {
67: Error *local_err = NULL;
68:
69: if (error_is_set(err)) {
70: return;
71: }
72: HANDLE thread = CreateThread(NULL, 0, func, opaque, 0, NULL);
73: if (!thread) {
74: error_set(&local_err, QERR_QGA_COMMAND_FAILED,
75: "failed to dispatch asynchronous command");
76: error_propagate(err, local_err);
77: }
78: }
79:
80: void qmp_guest_shutdown(bool has_mode, const char *mode, Error **err)
81: {
82: UINT shutdown_flag = EWX_FORCE;
83:
84: slog("guest-shutdown called, mode: %s", mode);
85:
86: if (!has_mode || strcmp(mode, "powerdown") == 0) {
87: shutdown_flag |= EWX_POWEROFF;
88: } else if (strcmp(mode, "halt") == 0) {
89: shutdown_flag |= EWX_SHUTDOWN;
90: } else if (strcmp(mode, "reboot") == 0) {
91: shutdown_flag |= EWX_REBOOT;
92: } else {
93: error_set(err, QERR_INVALID_PARAMETER_VALUE, "mode",
94: "halt|powerdown|reboot");
95: return;
96: }
97:
98: /* Request a shutdown privilege, but try to shut down the system
99: anyway. */
100: acquire_privilege(SE_SHUTDOWN_NAME, err);
101: if (error_is_set(err)) {
102: return;
103: }
104:
105: if (!ExitWindowsEx(shutdown_flag, SHTDN_REASON_FLAG_PLANNED)) {
106: slog("guest-shutdown failed: %d", GetLastError());
107: error_set(err, QERR_UNDEFINED_ERROR);
108: }
109: }
110:
111: int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, Error **err)
112: {
113: error_set(err, QERR_UNSUPPORTED);
114: return 0;
115: }
116:
117: void qmp_guest_file_close(int64_t handle, Error **err)
118: {
119: error_set(err, QERR_UNSUPPORTED);
120: }
121:
122: GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
123: int64_t count, Error **err)
124: {
125: error_set(err, QERR_UNSUPPORTED);
126: return 0;
127: }
128:
129: GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
130: bool has_count, int64_t count, Error **err)
131: {
132: error_set(err, QERR_UNSUPPORTED);
133: return 0;
134: }
135:
136: GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
137: int64_t whence, Error **err)
138: {
139: error_set(err, QERR_UNSUPPORTED);
140: return 0;
141: }
142:
143: void qmp_guest_file_flush(int64_t handle, Error **err)
144: {
145: error_set(err, QERR_UNSUPPORTED);
146: }
147:
148: /*
149: * Return status of freeze/thaw
150: */
151: GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err)
152: {
153: error_set(err, QERR_UNSUPPORTED);
154: return 0;
155: }
156:
157: /*
158: * Walk list of mounted file systems in the guest, and freeze the ones which
159: * are real local file systems.
160: */
161: int64_t qmp_guest_fsfreeze_freeze(Error **err)
162: {
163: error_set(err, QERR_UNSUPPORTED);
164: return 0;
165: }
166:
167: /*
168: * Walk list of frozen file systems in the guest, and thaw them.
169: */
170: int64_t qmp_guest_fsfreeze_thaw(Error **err)
171: {
172: error_set(err, QERR_UNSUPPORTED);
173: return 0;
174: }
175:
176: typedef enum {
177: GUEST_SUSPEND_MODE_DISK,
178: GUEST_SUSPEND_MODE_RAM
179: } GuestSuspendMode;
180:
181: static void check_suspend_mode(GuestSuspendMode mode, Error **err)
182: {
183: SYSTEM_POWER_CAPABILITIES sys_pwr_caps;
184: Error *local_err = NULL;
185:
186: if (error_is_set(err)) {
187: return;
188: }
189: ZeroMemory(&sys_pwr_caps, sizeof(sys_pwr_caps));
190: if (!GetPwrCapabilities(&sys_pwr_caps)) {
191: error_set(&local_err, QERR_QGA_COMMAND_FAILED,
192: "failed to determine guest suspend capabilities");
193: goto out;
194: }
195:
196: switch (mode) {
197: case GUEST_SUSPEND_MODE_DISK:
198: if (!sys_pwr_caps.SystemS4) {
199: error_set(&local_err, QERR_QGA_COMMAND_FAILED,
200: "suspend-to-disk not supported by OS");
201: }
202: break;
203: case GUEST_SUSPEND_MODE_RAM:
204: if (!sys_pwr_caps.SystemS3) {
205: error_set(&local_err, QERR_QGA_COMMAND_FAILED,
206: "suspend-to-ram not supported by OS");
207: }
208: break;
209: default:
210: error_set(&local_err, QERR_INVALID_PARAMETER_VALUE, "mode",
211: "GuestSuspendMode");
212: }
213:
214: out:
215: if (local_err) {
216: error_propagate(err, local_err);
217: }
218: }
219:
220: static DWORD WINAPI do_suspend(LPVOID opaque)
221: {
222: GuestSuspendMode *mode = opaque;
223: DWORD ret = 0;
224:
225: if (!SetSuspendState(*mode == GUEST_SUSPEND_MODE_DISK, TRUE, TRUE)) {
226: slog("failed to suspend guest, %s", GetLastError());
227: ret = -1;
228: }
229: g_free(mode);
230: return ret;
231: }
232:
233: void qmp_guest_suspend_disk(Error **err)
234: {
235: GuestSuspendMode *mode = g_malloc(sizeof(GuestSuspendMode));
236:
237: *mode = GUEST_SUSPEND_MODE_DISK;
238: check_suspend_mode(*mode, err);
239: acquire_privilege(SE_SHUTDOWN_NAME, err);
240: execute_async(do_suspend, mode, err);
241:
242: if (error_is_set(err)) {
243: g_free(mode);
244: }
245: }
246:
247: void qmp_guest_suspend_ram(Error **err)
248: {
249: GuestSuspendMode *mode = g_malloc(sizeof(GuestSuspendMode));
250:
251: *mode = GUEST_SUSPEND_MODE_RAM;
252: check_suspend_mode(*mode, err);
253: acquire_privilege(SE_SHUTDOWN_NAME, err);
254: execute_async(do_suspend, mode, err);
255:
256: if (error_is_set(err)) {
257: g_free(mode);
258: }
259: }
260:
261: void qmp_guest_suspend_hybrid(Error **err)
262: {
263: error_set(err, QERR_UNSUPPORTED);
264: }
265:
266: GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **err)
267: {
268: error_set(err, QERR_UNSUPPORTED);
269: return NULL;
270: }
271:
272: /* register init/cleanup routines for stateful command groups */
273: void ga_command_state_init(GAState *s, GACommandState *cs)
274: {
275: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.