f468cbffeeaac5a8fac1a0f4310bdcbfe8a27b21
[fio.git] / os / windows / posix.c
1 /* This file contains functions which implement those POSIX and Linux functions
2  * that MinGW and Microsoft don't provide. The implementations contain just enough
3  * functionality to support fio.
4  */
5
6 #include <arpa/inet.h>
7 #include <netinet/in.h>
8 #include <windows.h>
9 #include <stddef.h>
10 #include <string.h>
11 #include <stdlib.h>
12 #include <unistd.h>
13 #include <dirent.h>
14 #include <pthread.h>
15 #include <time.h>
16 #include <semaphore.h>
17 #include <sys/shm.h>
18 #include <sys/mman.h>
19 #include <sys/uio.h>
20 #include <sys/resource.h>
21 #include <sys/poll.h>
22 #include <sys/wait.h>
23 #include <setjmp.h>
24
25 #include "../os-windows.h"
26 #include "../../lib/hweight.h"
27
28 extern unsigned long mtime_since_now(struct timeval *);
29 extern void fio_gettime(struct timeval *, void *);
30
31 /* These aren't defined in the MinGW headers */
32 HRESULT WINAPI StringCchCopyA(
33   char *pszDest,
34   size_t cchDest,
35   const char *pszSrc);
36
37 HRESULT WINAPI StringCchPrintfA(
38   char *pszDest,
39   size_t cchDest,
40   const char *pszFormat,
41   ...);
42
43 int vsprintf_s(
44   char *buffer,
45   size_t numberOfElements,
46   const char *format,
47   va_list argptr);
48
49 int win_to_posix_error(DWORD winerr)
50 {
51         switch (winerr)
52         {
53         case ERROR_FILE_NOT_FOUND:              return ENOENT;
54         case ERROR_PATH_NOT_FOUND:              return ENOENT;
55         case ERROR_ACCESS_DENIED:               return EACCES;
56         case ERROR_INVALID_HANDLE:              return EBADF;
57         case ERROR_NOT_ENOUGH_MEMORY:   return ENOMEM;
58         case ERROR_INVALID_DATA:                return EINVAL;
59         case ERROR_OUTOFMEMORY:                 return ENOMEM;
60         case ERROR_INVALID_DRIVE:               return ENODEV;
61         case ERROR_NOT_SAME_DEVICE:             return EXDEV;
62         case ERROR_WRITE_PROTECT:               return EROFS;
63         case ERROR_BAD_UNIT:                    return ENODEV;
64         case ERROR_SHARING_VIOLATION:   return EACCES;
65         case ERROR_LOCK_VIOLATION:              return EACCES;
66         case ERROR_SHARING_BUFFER_EXCEEDED:     return ENOLCK;
67         case ERROR_HANDLE_DISK_FULL:    return ENOSPC;
68         case ERROR_NOT_SUPPORTED:               return ENOSYS;
69         case ERROR_FILE_EXISTS:                 return EEXIST;
70         case ERROR_CANNOT_MAKE:                 return EPERM;
71         case ERROR_INVALID_PARAMETER:   return EINVAL;
72         case ERROR_NO_PROC_SLOTS:               return EAGAIN;
73         case ERROR_BROKEN_PIPE:                 return EPIPE;
74         case ERROR_OPEN_FAILED:                 return EIO;
75         case ERROR_NO_MORE_SEARCH_HANDLES:      return ENFILE;
76         case ERROR_CALL_NOT_IMPLEMENTED:        return ENOSYS;
77         case ERROR_INVALID_NAME:                return ENOENT;
78         case ERROR_WAIT_NO_CHILDREN:    return ECHILD;
79         case ERROR_CHILD_NOT_COMPLETE:  return EBUSY;
80         case ERROR_DIR_NOT_EMPTY:               return ENOTEMPTY;
81         case ERROR_SIGNAL_REFUSED:              return EIO;
82         case ERROR_BAD_PATHNAME:                return ENOENT;
83         case ERROR_SIGNAL_PENDING:              return EBUSY;
84         case ERROR_MAX_THRDS_REACHED:   return EAGAIN;
85         case ERROR_BUSY:                                return EBUSY;
86         case ERROR_ALREADY_EXISTS:              return EEXIST;
87         case ERROR_NO_SIGNAL_SENT:              return EIO;
88         case ERROR_FILENAME_EXCED_RANGE:        return EINVAL;
89         case ERROR_META_EXPANSION_TOO_LONG:     return EINVAL;
90         case ERROR_INVALID_SIGNAL_NUMBER:       return EINVAL;
91         case ERROR_THREAD_1_INACTIVE:   return EINVAL;
92         case ERROR_BAD_PIPE:                    return EINVAL;
93         case ERROR_PIPE_BUSY:                   return EBUSY;
94         case ERROR_NO_DATA:                             return EPIPE;
95         case ERROR_MORE_DATA:                   return EAGAIN;
96         case ERROR_DIRECTORY:                   return ENOTDIR;
97         case ERROR_PIPE_CONNECTED:              return EBUSY;
98         case ERROR_NO_TOKEN:                    return EINVAL;
99         case ERROR_PROCESS_ABORTED:             return EFAULT;
100         case ERROR_BAD_DEVICE:                  return ENODEV;
101         case ERROR_BAD_USERNAME:                return EINVAL;
102         case ERROR_OPEN_FILES:                  return EAGAIN;
103         case ERROR_ACTIVE_CONNECTIONS:  return EAGAIN;
104         case ERROR_DEVICE_IN_USE:               return EAGAIN;
105         case ERROR_INVALID_AT_INTERRUPT_TIME:   return EINTR;
106         case ERROR_IO_DEVICE:                   return EIO;
107         case ERROR_NOT_OWNER:                   return EPERM;
108         case ERROR_END_OF_MEDIA:                return ENOSPC;
109         case ERROR_EOM_OVERFLOW:                return ENOSPC;
110         case ERROR_BEGINNING_OF_MEDIA:  return ESPIPE;
111         case ERROR_SETMARK_DETECTED:    return ESPIPE;
112         case ERROR_NO_DATA_DETECTED:    return ENOSPC;
113         case ERROR_POSSIBLE_DEADLOCK:   return EDEADLOCK;
114         case ERROR_CRC:                                 return EIO;
115         case ERROR_NEGATIVE_SEEK:               return EINVAL;
116         case ERROR_DISK_FULL:                   return ENOSPC;
117         case ERROR_NOACCESS:                    return EFAULT;
118         case ERROR_FILE_INVALID:                return ENXIO;
119         }
120
121         return winerr;
122 }
123
124 int GetNumLogicalProcessors(void)
125 {
126         SYSTEM_LOGICAL_PROCESSOR_INFORMATION *processor_info = NULL;
127         DWORD len = 0;
128         DWORD num_processors = 0;
129         DWORD error = 0;
130         DWORD i;
131
132         while (!GetLogicalProcessorInformation(processor_info, &len)) {
133                 error = GetLastError();
134                 if (error == ERROR_INSUFFICIENT_BUFFER)
135                         processor_info = malloc(len);
136                 else {
137                         log_err("Error: GetLogicalProcessorInformation failed: %d\n", error);
138                         return -1;
139                 }
140
141                 if (processor_info == NULL) {
142                         log_err("Error: failed to allocate memory for GetLogicalProcessorInformation");
143                         return -1;
144                 }
145         }
146
147         for (i = 0; i < len / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION); i++)
148         {
149                 if (processor_info[i].Relationship == RelationProcessorCore)
150                         num_processors += hweight64(processor_info[i].ProcessorMask);
151         }
152
153         free(processor_info);
154         return num_processors;
155 }
156
157 long sysconf(int name)
158 {
159         long val = -1;
160         long val2 = -1;
161         SYSTEM_INFO sysInfo;
162         MEMORYSTATUSEX status;
163
164         switch (name)
165         {
166         case _SC_NPROCESSORS_ONLN:
167                 val = GetNumLogicalProcessors();
168                 if (val == -1)
169                         log_err("sysconf(_SC_NPROCESSORS_ONLN) failed\n");
170
171                 break;
172
173         case _SC_PAGESIZE:
174                 GetSystemInfo(&sysInfo);
175                 val = sysInfo.dwPageSize;
176                 break;
177
178         case _SC_PHYS_PAGES:
179                 status.dwLength = sizeof(status);
180                 val2 = sysconf(_SC_PAGESIZE);
181                 if (GlobalMemoryStatusEx(&status) && val2 != -1)
182                         val = status.ullTotalPhys / val2;
183                 else
184                         log_err("sysconf(_SC_PHYS_PAGES) failed\n");
185                 break;
186         default:
187                 log_err("sysconf(%d) is not implemented\n", name);
188                 break;
189         }
190
191         return val;
192 }
193
194 char *dl_error = NULL;
195
196 int dlclose(void *handle)
197 {
198         return !FreeLibrary((HMODULE)handle);
199 }
200
201 void *dlopen(const char *file, int mode)
202 {
203         HMODULE hMod;
204
205         hMod = LoadLibrary(file);
206         if (hMod == INVALID_HANDLE_VALUE)
207                 dl_error = (char*)"LoadLibrary failed";
208         else
209                 dl_error = NULL;
210
211         return hMod;
212 }
213
214 void *dlsym(void *handle, const char *name)
215 {
216         FARPROC fnPtr;
217
218         fnPtr = GetProcAddress((HMODULE)handle, name);
219         if (fnPtr == NULL)
220                 dl_error = (char*)"GetProcAddress failed";
221         else
222                 dl_error = NULL;
223
224         return fnPtr;
225 }
226
227 char *dlerror(void)
228 {
229         return dl_error;
230 }
231
232 /* Copied from http://blogs.msdn.com/b/joshpoley/archive/2007/12/19/date-time-formats-and-conversions.aspx */
233 void Time_tToSystemTime(time_t dosTime, SYSTEMTIME *systemTime)
234 {
235     FILETIME utcFT;
236     LONGLONG jan1970;
237
238     jan1970 = Int32x32To64(dosTime, 10000000) + 116444736000000000;
239     utcFT.dwLowDateTime = (DWORD)jan1970;
240     utcFT.dwHighDateTime = jan1970 >> 32;
241
242     FileTimeToSystemTime((FILETIME*)&utcFT, systemTime);
243 }
244
245 char* ctime_r(const time_t *t, char *buf)
246 {
247     SYSTEMTIME systime;
248     const char * const dayOfWeek[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
249     const char * const monthOfYear[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
250
251     Time_tToSystemTime(*t, &systime);
252     /* We don't know how long `buf` is, but assume it's rounded up from the minimum of 25 to 32 */
253     StringCchPrintfA(buf, 31, "%s %s %d %02d:%02d:%02d %04d\n", dayOfWeek[systime.wDayOfWeek % 7], monthOfYear[(systime.wMonth - 1) % 12],
254                                                                                  systime.wDay, systime.wHour, systime.wMinute, systime.wSecond, systime.wYear);
255     return buf;
256 }
257
258 int gettimeofday(struct timeval *restrict tp, void *restrict tzp)
259 {
260         FILETIME fileTime;
261         uint64_t unix_time, windows_time;
262         const uint64_t MILLISECONDS_BETWEEN_1601_AND_1970 = 11644473600000;
263
264         /* Ignore the timezone parameter */
265         (void)tzp;
266
267         /*
268          * Windows time is stored as the number 100 ns intervals since January 1 1601.
269          * Conversion details from http://www.informit.com/articles/article.aspx?p=102236&seqNum=3
270          * Its precision is 100 ns but accuracy is only one clock tick, or normally around 15 ms.
271          */
272         GetSystemTimeAsFileTime(&fileTime);
273         windows_time = ((uint64_t)fileTime.dwHighDateTime << 32) + fileTime.dwLowDateTime;
274         /* Divide by 10,000 to convert to ms and subtract the time between 1601 and 1970 */
275         unix_time = (((windows_time)/10000) - MILLISECONDS_BETWEEN_1601_AND_1970);
276         /* unix_time is now the number of milliseconds since 1970 (the Unix epoch) */
277         tp->tv_sec = unix_time / 1000;
278         tp->tv_usec = (unix_time % 1000) * 1000;
279         return 0;
280 }
281
282 int sigaction(int sig, const struct sigaction *act,
283                 struct sigaction *oact)
284 {
285         int rc = 0;
286         void (*prev_handler)(int);
287
288         prev_handler = signal(sig, act->sa_handler);
289         if (oact != NULL)
290                 oact->sa_handler = prev_handler;
291
292         if (prev_handler == SIG_ERR)
293                 rc = -1;
294
295         return rc;
296 }
297
298 int lstat(const char * path, struct stat * buf)
299 {
300         return stat(path, buf);
301 }
302
303 void *mmap(void *addr, size_t len, int prot, int flags,
304                 int fildes, off_t off)
305 {
306         DWORD vaProt = 0;
307         DWORD mapAccess = 0;
308         DWORD lenlow;
309         DWORD lenhigh;
310         HANDLE hMap;
311         void* allocAddr = NULL;
312
313         if (prot & PROT_NONE)
314                 vaProt |= PAGE_NOACCESS;
315
316         if ((prot & PROT_READ) && !(prot & PROT_WRITE)) {
317                 vaProt |= PAGE_READONLY;
318                 mapAccess = FILE_MAP_READ;
319         }
320
321         if (prot & PROT_WRITE) {
322                 vaProt |= PAGE_READWRITE;
323                 mapAccess |= FILE_MAP_WRITE;
324         }
325
326         lenlow = len & 0xFFFF;
327         lenhigh = len >> 16;
328         /* If the low DWORD is zero and the high DWORD is non-zero, `CreateFileMapping`
329            will return ERROR_INVALID_PARAMETER. To avoid this, set both to zero. */
330         if (lenlow == 0) {
331                 lenhigh = 0;
332         }
333
334         if (flags & MAP_ANON || flags & MAP_ANONYMOUS)
335         {
336                 allocAddr = VirtualAlloc(addr, len, MEM_COMMIT, vaProt);
337                 if (allocAddr == NULL)
338                         errno = win_to_posix_error(GetLastError());
339         }
340         else
341         {
342                 hMap = CreateFileMapping((HANDLE)_get_osfhandle(fildes), NULL, vaProt, lenhigh, lenlow, NULL);
343
344                 if (hMap != NULL)
345                 {
346                         allocAddr = MapViewOfFile(hMap, mapAccess, off >> 16, off & 0xFFFF, len);
347                 }
348
349                 if (hMap == NULL || allocAddr == NULL)
350                         errno = win_to_posix_error(GetLastError());
351
352         }
353
354         return allocAddr;
355 }
356
357 int munmap(void *addr, size_t len)
358 {
359         BOOL success;
360
361         /* We may have allocated the memory with either MapViewOfFile or
362                  VirtualAlloc. Therefore, try calling UnmapViewOfFile first, and if that
363                  fails, call VirtualFree. */
364         success = UnmapViewOfFile(addr);
365
366         if (!success)
367         {
368                 success = VirtualFree(addr, 0, MEM_RELEASE);
369         }
370
371         return !success;
372 }
373
374 int msync(void *addr, size_t len, int flags)
375 {
376         return !FlushViewOfFile(addr, len);
377 }
378
379 int fork(void)
380 {
381         log_err("%s is not implemented\n", __func__);
382         errno = ENOSYS;
383         return -1;
384 }
385
386 pid_t setsid(void)
387 {
388         log_err("%s is not implemented\n", __func__);
389         errno = ENOSYS;
390         return -1;
391 }
392
393 static HANDLE log_file = INVALID_HANDLE_VALUE;
394
395 void openlog(const char *ident, int logopt, int facility)
396 {
397         if (log_file == INVALID_HANDLE_VALUE)
398                 log_file = CreateFileA("syslog.txt", GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, 0, NULL);
399 }
400
401 void closelog(void)
402 {
403         CloseHandle(log_file);
404         log_file = INVALID_HANDLE_VALUE;
405 }
406
407 void syslog(int priority, const char *message, ... /* argument */)
408 {
409         va_list v;
410         int len;
411         char *output;
412         DWORD bytes_written;
413
414         if (log_file == INVALID_HANDLE_VALUE) {
415                 log_file = CreateFileA("syslog.txt", GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_ALWAYS, 0, NULL);
416         }
417
418         if (log_file == INVALID_HANDLE_VALUE) {
419                 log_err("syslog: failed to open log file\n");
420                 return;
421         }
422
423         va_start(v, message);
424         len = _vscprintf(message, v);
425         output = malloc(len + sizeof(char));
426         vsprintf(output, message, v);
427         WriteFile(log_file, output, len, &bytes_written, NULL);
428         va_end(v);
429         free(output);
430 }
431
432 int kill(pid_t pid, int sig)
433 {
434         errno = ESRCH;
435         return -1;
436 }
437
438 /*
439  * This is assumed to be used only by the network code,
440  * and so doesn't try and handle any of the other cases
441  */
442 int fcntl(int fildes, int cmd, ...)
443 {
444         /*
445          * non-blocking mode doesn't work the same as in BSD sockets,
446          * so ignore it.
447          */
448 #if 0
449         va_list ap;
450         int val, opt, status;
451
452         if (cmd == F_GETFL)
453                 return 0;
454         else if (cmd != F_SETFL) {
455                 errno = EINVAL;
456                 return -1;
457         }
458
459         va_start(ap, 1);
460
461         opt = va_arg(ap, int);
462         if (opt & O_NONBLOCK)
463                 val = 1;
464         else
465                 val = 0;
466
467         status = ioctlsocket((SOCKET)fildes, opt, &val);
468
469         if (status == SOCKET_ERROR) {
470                 errno = EINVAL;
471                 val = -1;
472         }
473
474         va_end(ap);
475
476         return val;
477 #endif
478 return 0;
479 }
480
481 /*
482  * Get the value of a local clock source.
483  * This implementation supports 2 clocks: CLOCK_MONOTONIC provides high-accuracy
484  * relative time, while CLOCK_REALTIME provides a low-accuracy wall time.
485  */
486 int clock_gettime(clockid_t clock_id, struct timespec *tp)
487 {
488         int rc = 0;
489
490         if (clock_id == CLOCK_MONOTONIC)
491         {
492                 static LARGE_INTEGER freq = {{0,0}};
493                 LARGE_INTEGER counts;
494                 uint64_t t;
495
496                 QueryPerformanceCounter(&counts);
497                 if (freq.QuadPart == 0)
498                         QueryPerformanceFrequency(&freq);
499
500                 tp->tv_sec = counts.QuadPart / freq.QuadPart;
501                 /* Get the difference between the number of ns stored
502                  * in 'tv_sec' and that stored in 'counts' */
503                 t = tp->tv_sec * freq.QuadPart;
504                 t = counts.QuadPart - t;
505                 /* 't' now contains the number of cycles since the last second.
506                  * We want the number of nanoseconds, so multiply out by 1,000,000,000
507                  * and then divide by the frequency. */
508                 t *= 1000000000;
509                 tp->tv_nsec = t / freq.QuadPart;
510         }
511         else if (clock_id == CLOCK_REALTIME)
512         {
513                 /* clock_gettime(CLOCK_REALTIME,...) is just an alias for gettimeofday with a
514                  * higher-precision field. */
515                 struct timeval tv;
516                 gettimeofday(&tv, NULL);
517                 tp->tv_sec = tv.tv_sec;
518                 tp->tv_nsec = tv.tv_usec * 1000;
519         } else {
520                 errno = EINVAL;
521                 rc = -1;
522         }
523
524         return rc;
525 }
526
527 int mlock(const void * addr, size_t len)
528 {
529         SIZE_T min, max;
530         BOOL success;
531         HANDLE process = GetCurrentProcess();
532
533         success = GetProcessWorkingSetSize(process, &min, &max);
534         if (!success) {
535                 errno = win_to_posix_error(GetLastError());
536                 return -1;
537         }
538
539         min += len;
540         max += len;
541         success = SetProcessWorkingSetSize(process, min, max);
542         if (!success) {
543                 errno = win_to_posix_error(GetLastError());
544                 return -1;
545         }
546
547         success = VirtualLock((LPVOID)addr, len);
548         if (!success) {
549                 errno = win_to_posix_error(GetLastError());
550                 return -1;
551         }
552
553         return 0;
554 }
555
556 int munlock(const void * addr, size_t len)
557 {
558         BOOL success = VirtualUnlock((LPVOID)addr, len);
559         if (!success) {
560                 errno = win_to_posix_error(GetLastError());
561                 return -1;
562         }
563
564         return 0;
565 }
566
567 pid_t waitpid(pid_t pid, int *stat_loc, int options)
568 {
569         log_err("%s is not implemented\n", __func__);
570         errno = ENOSYS;
571         return -1;
572 }
573
574 int usleep(useconds_t useconds)
575 {
576         Sleep(useconds / 1000);
577         return 0;
578 }
579
580 char *basename(char *path)
581 {
582         static char name[MAX_PATH];
583         int i;
584
585         if (path == NULL || strlen(path) == 0)
586                 return (char*)".";
587
588         i = strlen(path) - 1;
589
590         while (path[i] != '\\' && path[i] != '/' && i >= 0)
591                 i--;
592
593         strncpy(name, path + i + 1, MAX_PATH);
594
595         return name;
596 }
597
598 int fsync(int fildes)
599 {
600         HANDLE hFile = (HANDLE)_get_osfhandle(fildes);
601         if (!FlushFileBuffers(hFile)) {
602                 errno = win_to_posix_error(GetLastError());
603                 return -1;
604         }
605
606         return 0;
607 }
608
609 int nFileMappings = 0;
610 HANDLE fileMappings[1024];
611
612 int shmget(key_t key, size_t size, int shmflg)
613 {
614         int mapid = -1;
615         uint32_t size_low = size & 0xFFFFFFFF;
616         uint32_t size_high = ((uint64_t)size) >> 32;
617         HANDLE hMapping = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, (PAGE_EXECUTE_READWRITE | SEC_RESERVE), size_high, size_low, NULL);
618         if (hMapping != NULL) {
619                 fileMappings[nFileMappings] = hMapping;
620                 mapid = nFileMappings;
621                 nFileMappings++;
622         } else {
623                 errno = ENOSYS;
624         }
625
626         return mapid;
627 }
628
629 void *shmat(int shmid, const void *shmaddr, int shmflg)
630 {
631         void* mapAddr;
632         MEMORY_BASIC_INFORMATION memInfo;
633         mapAddr = MapViewOfFile(fileMappings[shmid], FILE_MAP_ALL_ACCESS, 0, 0, 0);
634         if (mapAddr == NULL) {
635                 errno = win_to_posix_error(GetLastError());
636                 return (void*)-1;
637         }
638
639         if (VirtualQuery(mapAddr, &memInfo, sizeof(memInfo)) == 0) {
640                 errno = win_to_posix_error(GetLastError());
641                 return (void*)-1;
642         }
643
644         mapAddr = VirtualAlloc(mapAddr, memInfo.RegionSize, MEM_COMMIT, PAGE_READWRITE);
645         if (mapAddr == NULL) {
646                 errno = win_to_posix_error(GetLastError());
647                 return (void*)-1;
648         }
649
650         return mapAddr;
651 }
652
653 int shmdt(const void *shmaddr)
654 {
655         if (!UnmapViewOfFile(shmaddr)) {
656                 errno = win_to_posix_error(GetLastError());
657                 return -1;
658         }
659
660         return 0;
661 }
662
663 int shmctl(int shmid, int cmd, struct shmid_ds *buf)
664 {
665         if (cmd == IPC_RMID) {
666                 fileMappings[shmid] = INVALID_HANDLE_VALUE;
667                 return 0;
668         } else {
669                 log_err("%s is not implemented\n", __func__);
670         }
671         errno = ENOSYS;
672         return -1;
673 }
674
675 int setuid(uid_t uid)
676 {
677         log_err("%s is not implemented\n", __func__);
678         errno = ENOSYS;
679         return -1;
680 }
681
682 int setgid(gid_t gid)
683 {
684         log_err("%s is not implemented\n", __func__);
685         errno = ENOSYS;
686         return -1;
687 }
688
689 int nice(int incr)
690 {
691         DWORD prioclass = NORMAL_PRIORITY_CLASS;
692         
693         if (incr < -15)
694                 prioclass = HIGH_PRIORITY_CLASS;
695         else if (incr < 0)
696                 prioclass = ABOVE_NORMAL_PRIORITY_CLASS;
697         else if (incr > 15)
698                 prioclass = IDLE_PRIORITY_CLASS;
699         else if (incr > 0)
700                 prioclass = BELOW_NORMAL_PRIORITY_CLASS;
701         
702         if (!SetPriorityClass(GetCurrentProcess(), prioclass))
703                 log_err("fio: SetPriorityClass failed\n");
704
705         return 0;
706 }
707
708 int getrusage(int who, struct rusage *r_usage)
709 {
710         const uint64_t SECONDS_BETWEEN_1601_AND_1970 = 11644473600;
711         FILETIME cTime, eTime, kTime, uTime;
712         time_t time;
713         HANDLE h;
714
715         memset(r_usage, 0, sizeof(*r_usage));
716
717         if (who == RUSAGE_SELF) {
718                 h = GetCurrentProcess();
719                 GetProcessTimes(h, &cTime, &eTime, &kTime, &uTime);
720         } else if (who == RUSAGE_THREAD) {
721                 h = GetCurrentThread();
722                 GetThreadTimes(h, &cTime, &eTime, &kTime, &uTime);
723         } else {
724                 log_err("fio: getrusage %d is not implemented\n", who);
725                 return -1;
726         }
727
728         time = ((uint64_t)uTime.dwHighDateTime << 32) + uTime.dwLowDateTime;
729         /* Divide by 10,000,000 to get the number of seconds and move the epoch from
730          * 1601 to 1970 */
731         time = (time_t)(((time)/10000000) - SECONDS_BETWEEN_1601_AND_1970);
732         r_usage->ru_utime.tv_sec = time;
733         /* getrusage() doesn't care about anything other than seconds, so set tv_usec to 0 */
734         r_usage->ru_utime.tv_usec = 0;
735         time = ((uint64_t)kTime.dwHighDateTime << 32) + kTime.dwLowDateTime;
736         /* Divide by 10,000,000 to get the number of seconds and move the epoch from
737          * 1601 to 1970 */
738         time = (time_t)(((time)/10000000) - SECONDS_BETWEEN_1601_AND_1970);
739         r_usage->ru_stime.tv_sec = time;
740         r_usage->ru_stime.tv_usec = 0;
741         return 0;
742 }
743
744 int posix_madvise(void *addr, size_t len, int advice)
745 {
746         return ENOSYS;
747 }
748
749 int fdatasync(int fildes)
750 {
751         return fsync(fildes);
752 }
753
754 ssize_t pwrite(int fildes, const void *buf, size_t nbyte,
755                 off_t offset)
756 {
757         int64_t pos = _telli64(fildes);
758         ssize_t len = _write(fildes, buf, nbyte);
759         _lseeki64(fildes, pos, SEEK_SET);
760         return len;
761 }
762
763 ssize_t pread(int fildes, void *buf, size_t nbyte, off_t offset)
764 {
765         int64_t pos = _telli64(fildes);
766         ssize_t len = read(fildes, buf, nbyte);
767         _lseeki64(fildes, pos, SEEK_SET);
768         return len;
769 }
770
771 ssize_t readv(int fildes, const struct iovec *iov, int iovcnt)
772 {
773         log_err("%s is not implemented\n", __func__);
774         errno = ENOSYS;
775         return -1;
776 }
777
778 ssize_t writev(int fildes, const struct iovec *iov, int iovcnt)
779 {
780         int i;
781         DWORD bytes_written = 0;
782         for (i = 0; i < iovcnt; i++)
783         {
784                 int len = send((SOCKET)fildes, iov[i].iov_base, iov[i].iov_len, 0);
785                 if (len == SOCKET_ERROR)
786                 {
787                         DWORD err = GetLastError();
788                         errno = win_to_posix_error(err);
789                         bytes_written = -1;
790                         break;
791                 }
792                 bytes_written += len;
793         }
794
795         return bytes_written;
796 }
797
798 long long strtoll(const char *restrict str, char **restrict endptr,
799                 int base)
800 {
801         return _strtoi64(str, endptr, base);
802 }
803
804 int poll(struct pollfd fds[], nfds_t nfds, int timeout)
805 {
806         struct timeval tv;
807         struct timeval *to = NULL;
808         fd_set readfds, writefds, exceptfds;
809         int i;
810         int rc;
811
812         if (timeout != -1) {
813                 to = &tv;
814                 to->tv_sec = timeout / 1000;
815                 to->tv_usec = (timeout % 1000) * 1000;
816         }
817
818         FD_ZERO(&readfds);
819         FD_ZERO(&writefds);
820         FD_ZERO(&exceptfds);
821
822         for (i = 0; i < nfds; i++)
823         {
824                 if (fds[i].fd < 0) {
825                         fds[i].revents = 0;
826                         continue;
827                 }
828
829                 if (fds[i].events & POLLIN)
830                         FD_SET(fds[i].fd, &readfds);
831
832                 if (fds[i].events & POLLOUT)
833                         FD_SET(fds[i].fd, &writefds);
834
835                 FD_SET(fds[i].fd, &exceptfds);
836         }
837         rc = select(nfds, &readfds, &writefds, &exceptfds, to);
838
839         if (rc != SOCKET_ERROR) {
840                 for (i = 0; i < nfds; i++)
841                 {
842                         if (fds[i].fd < 0) {
843                                 continue;
844                         }
845
846                         if ((fds[i].events & POLLIN) && FD_ISSET(fds[i].fd, &readfds))
847                                 fds[i].revents |= POLLIN;
848
849                         if ((fds[i].events & POLLOUT) && FD_ISSET(fds[i].fd, &writefds))
850                                 fds[i].revents |= POLLOUT;
851
852                         if (FD_ISSET(fds[i].fd, &exceptfds))
853                                 fds[i].revents |= POLLHUP;
854                 }
855         }
856         return rc;
857 }
858
859 int nanosleep(const struct timespec *rqtp, struct timespec *rmtp)
860 {
861         struct timeval tv;
862         DWORD ms_remaining;
863         DWORD ms_total = (rqtp->tv_sec * 1000) + (rqtp->tv_nsec / 1000000.0);
864
865         if (ms_total == 0)
866                 ms_total = 1;
867
868         ms_remaining = ms_total;
869
870         /* Since Sleep() can sleep for less than the requested time, add a loop to
871            ensure we only return after the requested length of time has elapsed */
872         do {
873                 fio_gettime(&tv, NULL);
874                 Sleep(ms_remaining);
875                 ms_remaining = ms_total - mtime_since_now(&tv);
876         } while (ms_remaining > 0 && ms_remaining < ms_total);
877
878         /* this implementation will never sleep for less than the requested time */
879         if (rmtp != NULL) {
880                 rmtp->tv_sec = 0;
881                 rmtp->tv_nsec = 0;
882         }
883
884         return 0;
885 }
886
887 DIR *opendir(const char *dirname)
888 {
889         struct dirent_ctx *dc = NULL;
890
891         /* See if we can open it. If not, we'll return an error here */
892         HANDLE file = CreateFileA(dirname, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
893         if (file != INVALID_HANDLE_VALUE) {
894                 CloseHandle(file);
895                 dc = (struct dirent_ctx*)malloc(sizeof(struct dirent_ctx));
896                 StringCchCopyA(dc->dirname, MAX_PATH, dirname);
897                 dc->find_handle = INVALID_HANDLE_VALUE;
898         } else {
899                 DWORD error = GetLastError();
900                 if (error == ERROR_FILE_NOT_FOUND)
901                         errno = ENOENT;
902
903                 else if (error == ERROR_PATH_NOT_FOUND)
904                         errno = ENOTDIR;
905                 else if (error == ERROR_TOO_MANY_OPEN_FILES)
906                         errno = ENFILE;
907                 else if (error == ERROR_ACCESS_DENIED)
908                         errno = EACCES;
909                 else
910                         errno = error;
911         }
912
913         return dc;
914 }
915
916 int closedir(DIR *dirp)
917 {
918         if (dirp != NULL && dirp->find_handle != INVALID_HANDLE_VALUE)
919                 FindClose(dirp->find_handle);
920
921         free(dirp);
922         return 0;
923 }
924
925 struct dirent *readdir(DIR *dirp)
926 {
927         static struct dirent de;
928         WIN32_FIND_DATA find_data;
929
930         if (dirp == NULL)
931                 return NULL;
932
933         if (dirp->find_handle == INVALID_HANDLE_VALUE) {
934                 char search_pattern[MAX_PATH];
935                 StringCchPrintfA(search_pattern, MAX_PATH-1, "%s\\*", dirp->dirname);
936                 dirp->find_handle = FindFirstFileA(search_pattern, &find_data);
937                 if (dirp->find_handle == INVALID_HANDLE_VALUE)
938                         return NULL;
939         } else {
940                 if (!FindNextFile(dirp->find_handle, &find_data))
941                         return NULL;
942         }
943
944         StringCchCopyA(de.d_name, MAX_PATH, find_data.cFileName);
945         de.d_ino = 0;
946
947         return &de;
948 }
949
950 uid_t geteuid(void)
951 {
952         log_err("%s is not implemented\n", __func__);
953         errno = ENOSYS;
954         return -1;
955 }
956
957 in_addr_t inet_network(const char *cp)
958 {
959         in_addr_t hbo;
960         in_addr_t nbo = inet_addr(cp);
961         hbo = ((nbo & 0xFF) << 24) + ((nbo & 0xFF00) << 8) + ((nbo & 0xFF0000) >> 8) + ((nbo & 0xFF000000) >> 24);
962         return hbo;
963 }
964
965 const char* inet_ntop(int af, const void *restrict src,
966                 char *restrict dst, socklen_t size)
967 {
968         INT status = SOCKET_ERROR;
969         WSADATA wsd;
970         char *ret = NULL;
971
972         if (af != AF_INET && af != AF_INET6) {
973                 errno = EAFNOSUPPORT;
974                 return NULL;
975         }
976
977         WSAStartup(MAKEWORD(2,2), &wsd);
978
979         if (af == AF_INET) {
980                 struct sockaddr_in si;
981                 DWORD len = size;
982                 memset(&si, 0, sizeof(si));
983                 si.sin_family = af;
984                 memcpy(&si.sin_addr, src, sizeof(si.sin_addr));
985                 status = WSAAddressToString((struct sockaddr*)&si, sizeof(si), NULL, dst, &len);
986         } else if (af == AF_INET6) {
987                 struct sockaddr_in6 si6;
988                 DWORD len = size;
989                 memset(&si6, 0, sizeof(si6));
990                 si6.sin6_family = af;
991                 memcpy(&si6.sin6_addr, src, sizeof(si6.sin6_addr));
992                 status = WSAAddressToString((struct sockaddr*)&si6, sizeof(si6), NULL, dst, &len);
993         }
994
995         if (status != SOCKET_ERROR)
996                 ret = dst;
997         else
998                 errno = ENOSPC;
999
1000         WSACleanup();
1001
1002         return ret;
1003 }
1004
1005 int inet_pton(int af, const char *restrict src, void *restrict dst)
1006 {
1007         INT status = SOCKET_ERROR;
1008         WSADATA wsd;
1009         int ret = 1;
1010
1011         if (af != AF_INET && af != AF_INET6) {
1012                 errno = EAFNOSUPPORT;
1013                 return -1;
1014         }
1015
1016         WSAStartup(MAKEWORD(2,2), &wsd);
1017
1018         if (af == AF_INET) {
1019                 struct sockaddr_in si;
1020                 INT len = sizeof(si);
1021                 memset(&si, 0, sizeof(si));
1022                 si.sin_family = af;
1023                 status = WSAStringToAddressA((char*)src, af, NULL, (struct sockaddr*)&si, &len);
1024                 if (status != SOCKET_ERROR)
1025                         memcpy(dst, &si.sin_addr, sizeof(si.sin_addr));
1026         } else if (af == AF_INET6) {
1027                 struct sockaddr_in6 si6;
1028                 INT len = sizeof(si6);
1029                 memset(&si6, 0, sizeof(si6));
1030                 si6.sin6_family = af;
1031                 status = WSAStringToAddressA((char*)src, af, NULL, (struct sockaddr*)&si6, &len);
1032                 if (status != SOCKET_ERROR)
1033                         memcpy(dst, &si6.sin6_addr, sizeof(si6.sin6_addr));
1034         }
1035
1036         if (status == SOCKET_ERROR) {
1037                 errno = ENOSPC;
1038                 ret = 0;
1039         }
1040
1041         WSACleanup();
1042
1043         return ret;
1044 }