X-Git-Url: https://git.proxmox.com/?a=blobdiff_plain;f=os-win32.c;h=50b7f6f8859a70ef159c62a483f3dc59eec43c37;hb=0478f37ce258438d74164dd182b0ae125f174ec6;hp=a936f7ad22516bea7e7aa858ad275fa928ece789;hpb=fe98ac146109e307d7e19486dcfebbc89259d34d;p=qemu.git diff --git a/os-win32.c b/os-win32.c index a936f7ad2..50b7f6f88 100644 --- a/os-win32.c +++ b/os-win32.c @@ -23,6 +23,7 @@ * THE SOFTWARE. */ #include +#include #include #include #include @@ -30,154 +31,122 @@ #include #include #include "config-host.h" -#include "sysemu.h" +#include "sysemu/sysemu.h" +#include "qemu-options.h" /***********************************************************/ -/* Polling handling */ +/* Functions missing in mingw */ -typedef struct PollingEntry { - PollingFunc *func; - void *opaque; - struct PollingEntry *next; -} PollingEntry; - -static PollingEntry *first_polling_entry; - -int qemu_add_polling_cb(PollingFunc *func, void *opaque) +int setenv(const char *name, const char *value, int overwrite) { - PollingEntry **ppe, *pe; - pe = qemu_mallocz(sizeof(PollingEntry)); - pe->func = func; - pe->opaque = opaque; - for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next); - *ppe = pe; - return 0; + int result = 0; + if (overwrite || !getenv(name)) { + size_t length = strlen(name) + strlen(value) + 2; + char *string = g_malloc(length); + snprintf(string, length, "%s=%s", name, value); + result = putenv(string); + + /* Windows takes a copy and does not continue to use our string. + * Therefore it can be safely freed on this platform. POSIX code + * typically has to leak the string because according to the spec it + * becomes part of the environment. + */ + g_free(string); + } + return result; } -void qemu_del_polling_cb(PollingFunc *func, void *opaque) +static BOOL WINAPI qemu_ctrl_handler(DWORD type) { - PollingEntry **ppe, *pe; - for(ppe = &first_polling_entry; *ppe != NULL; ppe = &(*ppe)->next) { - pe = *ppe; - if (pe->func == func && pe->opaque == opaque) { - *ppe = pe->next; - qemu_free(pe); - break; - } - } -} + qemu_system_shutdown_request(); + /* Windows 7 kills application when the function returns. + Sleep here to give QEMU a try for closing. + Sleep period is 10000ms because Windows kills the program + after 10 seconds anyway. */ + Sleep(10000); -/***********************************************************/ -/* Wait objects support */ -typedef struct WaitObjects { - int num; - HANDLE events[MAXIMUM_WAIT_OBJECTS + 1]; - WaitObjectFunc *func[MAXIMUM_WAIT_OBJECTS + 1]; - void *opaque[MAXIMUM_WAIT_OBJECTS + 1]; -} WaitObjects; + return TRUE; +} -static WaitObjects wait_objects = {0}; +static TIMECAPS mm_tc; -int qemu_add_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque) +static void os_undo_timer_resolution(void) { - WaitObjects *w = &wait_objects; - - if (w->num >= MAXIMUM_WAIT_OBJECTS) - return -1; - w->events[w->num] = handle; - w->func[w->num] = func; - w->opaque[w->num] = opaque; - w->num++; - return 0; + timeEndPeriod(mm_tc.wPeriodMin); } -void qemu_del_wait_object(HANDLE handle, WaitObjectFunc *func, void *opaque) +void os_setup_early_signal_handling(void) { - int i, found; - WaitObjects *w = &wait_objects; - - found = 0; - for (i = 0; i < w->num; i++) { - if (w->events[i] == handle) - found = 1; - if (found) { - w->events[i] = w->events[i + 1]; - w->func[i] = w->func[i + 1]; - w->opaque[i] = w->opaque[i + 1]; - } - } - if (found) - w->num--; + SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE); + timeGetDevCaps(&mm_tc, sizeof(mm_tc)); + timeBeginPeriod(mm_tc.wPeriodMin); + atexit(os_undo_timer_resolution); } -void os_host_main_loop_wait(int *timeout) +/* Look for support files in the same directory as the executable. */ +char *os_find_datadir(const char *argv0) { - int ret, ret2, i; - PollingEntry *pe; + char *p; + char buf[MAX_PATH]; + DWORD len; - /* XXX: need to suppress polling by better using win32 events */ - ret = 0; - for(pe = first_polling_entry; pe != NULL; pe = pe->next) { - ret |= pe->func(pe->opaque); + len = GetModuleFileName(NULL, buf, sizeof(buf) - 1); + if (len == 0) { + return NULL; } - if (ret == 0) { - int err; - WaitObjects *w = &wait_objects; - - ret = WaitForMultipleObjects(w->num, w->events, FALSE, *timeout); - if (WAIT_OBJECT_0 + 0 <= ret && ret <= WAIT_OBJECT_0 + w->num - 1) { - if (w->func[ret - WAIT_OBJECT_0]) - w->func[ret - WAIT_OBJECT_0](w->opaque[ret - WAIT_OBJECT_0]); - - /* Check for additional signaled events */ - for(i = (ret - WAIT_OBJECT_0 + 1); i < w->num; i++) { - - /* Check if event is signaled */ - ret2 = WaitForSingleObject(w->events[i], 0); - if(ret2 == WAIT_OBJECT_0) { - if (w->func[i]) - w->func[i](w->opaque[i]); - } else if (ret2 == WAIT_TIMEOUT) { - } else { - err = GetLastError(); - fprintf(stderr, "WaitForSingleObject error %d %d\n", i, err); - } - } - } else if (ret == WAIT_TIMEOUT) { - } else { - err = GetLastError(); - fprintf(stderr, "WaitForMultipleObjects error %d %d\n", ret, err); - } + + buf[len] = 0; + p = buf + len - 1; + while (p != buf && *p != '\\') + p--; + *p = 0; + if (access(buf, R_OK) == 0) { + return g_strdup(buf); } + return NULL; +} - *timeout = 0; +void os_set_line_buffering(void) +{ + setbuf(stdout, NULL); + setbuf(stderr, NULL); } -static BOOL WINAPI qemu_ctrl_handler(DWORD type) +/* + * Parse OS specific command line options. + * return 0 if option handled, -1 otherwise + */ +void os_parse_cmd_args(int index, const char *optarg) { - exit(STATUS_CONTROL_C_EXIT); - return TRUE; + return; } -void os_setup_early_signal_handling(void) +void os_pidfile_error(void) { - /* Note: cpu_interrupt() is currently not SMP safe, so we force - QEMU to run on a single CPU */ - HANDLE h; - DWORD mask, smask; - int i; + fprintf(stderr, "Could not acquire pid file: %s\n", strerror(errno)); +} - SetConsoleCtrlHandler(qemu_ctrl_handler, TRUE); +int qemu_create_pidfile(const char *filename) +{ + char buffer[128]; + int len; + HANDLE file; + OVERLAPPED overlap; + BOOL ret; + memset(&overlap, 0, sizeof(overlap)); - h = GetCurrentProcess(); - if (GetProcessAffinityMask(h, &mask, &smask)) { - for(i = 0; i < 32; i++) { - if (mask & (1 << i)) - break; - } - if (i != 32) { - mask = 1 << i; - SetProcessAffinityMask(h, mask); - } + file = CreateFile(filename, GENERIC_WRITE, FILE_SHARE_READ, NULL, + OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); + + if (file == INVALID_HANDLE_VALUE) { + return -1; } + len = snprintf(buffer, sizeof(buffer), "%d\n", getpid()); + ret = WriteFile(file, (LPCVOID)buffer, (DWORD)len, + NULL, &overlap); + CloseHandle(file); + if (ret == 0) { + return -1; + } + return 0; }