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