#include <unistd.h>
#include <dirent.h>
#include <pthread.h>
+#include <time.h>
#include <semaphore.h>
#include <sys/shm.h>
#include <sys/mman.h>
#include <sys/uio.h>
#include <sys/resource.h>
#include <sys/poll.h>
+#include <sys/wait.h>
+#include <setjmp.h>
#include "../os-windows.h"
+#include "../../lib/hweight.h"
extern unsigned long mtime_since_now(struct timeval *);
extern void fio_gettime(struct timeval *, void *);
const char *format,
va_list argptr);
+int win_to_posix_error(DWORD winerr)
+{
+ switch (winerr)
+ {
+ case ERROR_FILE_NOT_FOUND: return ENOENT;
+ case ERROR_PATH_NOT_FOUND: return ENOENT;
+ case ERROR_ACCESS_DENIED: return EACCES;
+ case ERROR_INVALID_HANDLE: return EBADF;
+ case ERROR_NOT_ENOUGH_MEMORY: return ENOMEM;
+ case ERROR_INVALID_DATA: return EINVAL;
+ case ERROR_OUTOFMEMORY: return ENOMEM;
+ case ERROR_INVALID_DRIVE: return ENODEV;
+ case ERROR_NOT_SAME_DEVICE: return EXDEV;
+ case ERROR_WRITE_PROTECT: return EROFS;
+ case ERROR_BAD_UNIT: return ENODEV;
+ case ERROR_SHARING_VIOLATION: return EACCES;
+ case ERROR_LOCK_VIOLATION: return EACCES;
+ case ERROR_SHARING_BUFFER_EXCEEDED: return ENOLCK;
+ case ERROR_HANDLE_DISK_FULL: return ENOSPC;
+ case ERROR_NOT_SUPPORTED: return ENOSYS;
+ case ERROR_FILE_EXISTS: return EEXIST;
+ case ERROR_CANNOT_MAKE: return EPERM;
+ case ERROR_INVALID_PARAMETER: return EINVAL;
+ case ERROR_NO_PROC_SLOTS: return EAGAIN;
+ case ERROR_BROKEN_PIPE: return EPIPE;
+ case ERROR_OPEN_FAILED: return EIO;
+ case ERROR_NO_MORE_SEARCH_HANDLES: return ENFILE;
+ case ERROR_CALL_NOT_IMPLEMENTED: return ENOSYS;
+ case ERROR_INVALID_NAME: return ENOENT;
+ case ERROR_WAIT_NO_CHILDREN: return ECHILD;
+ case ERROR_CHILD_NOT_COMPLETE: return EBUSY;
+ case ERROR_DIR_NOT_EMPTY: return ENOTEMPTY;
+ case ERROR_SIGNAL_REFUSED: return EIO;
+ case ERROR_BAD_PATHNAME: return ENOENT;
+ case ERROR_SIGNAL_PENDING: return EBUSY;
+ case ERROR_MAX_THRDS_REACHED: return EAGAIN;
+ case ERROR_BUSY: return EBUSY;
+ case ERROR_ALREADY_EXISTS: return EEXIST;
+ case ERROR_NO_SIGNAL_SENT: return EIO;
+ case ERROR_FILENAME_EXCED_RANGE: return EINVAL;
+ case ERROR_META_EXPANSION_TOO_LONG: return EINVAL;
+ case ERROR_INVALID_SIGNAL_NUMBER: return EINVAL;
+ case ERROR_THREAD_1_INACTIVE: return EINVAL;
+ case ERROR_BAD_PIPE: return EINVAL;
+ case ERROR_PIPE_BUSY: return EBUSY;
+ case ERROR_NO_DATA: return EPIPE;
+ case ERROR_MORE_DATA: return EAGAIN;
+ case ERROR_DIRECTORY: return ENOTDIR;
+ case ERROR_PIPE_CONNECTED: return EBUSY;
+ case ERROR_NO_TOKEN: return EINVAL;
+ case ERROR_PROCESS_ABORTED: return EFAULT;
+ case ERROR_BAD_DEVICE: return ENODEV;
+ case ERROR_BAD_USERNAME: return EINVAL;
+ case ERROR_OPEN_FILES: return EAGAIN;
+ case ERROR_ACTIVE_CONNECTIONS: return EAGAIN;
+ case ERROR_DEVICE_IN_USE: return EAGAIN;
+ case ERROR_INVALID_AT_INTERRUPT_TIME: return EINTR;
+ case ERROR_IO_DEVICE: return EIO;
+ case ERROR_NOT_OWNER: return EPERM;
+ case ERROR_END_OF_MEDIA: return ENOSPC;
+ case ERROR_EOM_OVERFLOW: return ENOSPC;
+ case ERROR_BEGINNING_OF_MEDIA: return ESPIPE;
+ case ERROR_SETMARK_DETECTED: return ESPIPE;
+ case ERROR_NO_DATA_DETECTED: return ENOSPC;
+ case ERROR_POSSIBLE_DEADLOCK: return EDEADLOCK;
+ case ERROR_CRC: return EIO;
+ case ERROR_NEGATIVE_SEEK: return EINVAL;
+ case ERROR_DISK_FULL: return ENOSPC;
+ case ERROR_NOACCESS: return EFAULT;
+ case ERROR_FILE_INVALID: return ENXIO;
+ }
+
+ return winerr;
+}
+
+int GetNumLogicalProcessors(void)
+{
+ SYSTEM_LOGICAL_PROCESSOR_INFORMATION *processor_info = NULL;
+ DWORD len = 0;
+ DWORD num_processors = 0;
+ DWORD error = 0;
+ DWORD i;
+
+ while (!GetLogicalProcessorInformation(processor_info, &len)) {
+ error = GetLastError();
+ if (error == ERROR_INSUFFICIENT_BUFFER)
+ processor_info = malloc(len);
+ else {
+ log_err("Error: GetLogicalProcessorInformation failed: %d\n", error);
+ return -1;
+ }
+
+ if (processor_info == NULL) {
+ log_err("Error: failed to allocate memory for GetLogicalProcessorInformation");
+ return -1;
+ }
+ }
+
+ for (i = 0; i < len / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION); i++)
+ {
+ if (processor_info[i].Relationship == RelationProcessorCore)
+ num_processors += hweight64(processor_info[i].ProcessorMask);
+ }
+
+ free(processor_info);
+ return num_processors;
+}
+
long sysconf(int name)
{
- long long val = -1;
- DWORD len;
- SYSTEM_LOGICAL_PROCESSOR_INFORMATION processorInfo;
+ long val = -1;
+ long val2 = -1;
SYSTEM_INFO sysInfo;
MEMORYSTATUSEX status;
switch (name)
{
case _SC_NPROCESSORS_ONLN:
- len = sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
- GetLogicalProcessorInformation(&processorInfo, &len);
- val = len / sizeof(SYSTEM_LOGICAL_PROCESSOR_INFORMATION);
+ val = GetNumLogicalProcessors();
+ if (val == -1)
+ log_err("sysconf(_SC_NPROCESSORS_ONLN) failed\n");
+
break;
case _SC_PAGESIZE:
case _SC_PHYS_PAGES:
status.dwLength = sizeof(status);
- GlobalMemoryStatusEx(&status);
- val = status.ullTotalPhys;
+ val2 = sysconf(_SC_PAGESIZE);
+ if (GlobalMemoryStatusEx(&status) && val2 != -1)
+ val = status.ullTotalPhys / val2;
+ else
+ log_err("sysconf(_SC_PHYS_PAGES) failed\n");
break;
default:
log_err("sysconf(%d) is not implemented\n", name);
if ((flags & MAP_ANON) | (flags & MAP_ANONYMOUS))
{
allocAddr = VirtualAlloc(addr, len, MEM_COMMIT, vaProt);
+ if (allocAddr == NULL)
+ errno = win_to_posix_error(GetLastError());
}
return allocAddr;
int munmap(void *addr, size_t len)
{
- return !VirtualFree(addr, 0, MEM_RELEASE);
+ if (!VirtualFree(addr, 0, MEM_RELEASE)) {
+ errno = win_to_posix_error(GetLastError());
+ return -1;
+ }
+
+ return 0;
}
int fork(void)
{
log_err("%s is not implemented\n", __func__);
errno = ENOSYS;
- return (-1);
+ return -1;
}
pid_t setsid(void)
{
log_err("%s is not implemented\n", __func__);
errno = ENOSYS;
- return (-1);
+ return -1;
}
static HANDLE log_file = INVALID_HANDLE_VALUE;
int kill(pid_t pid, int sig)
{
errno = ESRCH;
- return (-1);
+ return -1;
}
/*
return 0;
else if (cmd != F_SETFL) {
errno = EINVAL;
- return (-1);
+ return -1;
}
va_start(ap, 1);
{
static LARGE_INTEGER freq = {{0,0}};
LARGE_INTEGER counts;
+ uint64_t t;
QueryPerformanceCounter(&counts);
if (freq.QuadPart == 0)
tp->tv_sec = counts.QuadPart / freq.QuadPart;
/* Get the difference between the number of ns stored
* in 'tv_sec' and that stored in 'counts' */
- uint64_t t = tp->tv_sec * freq.QuadPart;
+ t = tp->tv_sec * freq.QuadPart;
t = counts.QuadPart - t;
/* 't' now contains the number of cycles since the last second.
* We want the number of nanoseconds, so multiply out by 1,000,000,000
int mlock(const void * addr, size_t len)
{
- return !VirtualLock((LPVOID)addr, len);
+ SIZE_T min, max;
+ BOOL success;
+ HANDLE process = GetCurrentProcess();
+
+ success = GetProcessWorkingSetSize(process, &min, &max);
+ if (!success) {
+ errno = win_to_posix_error(GetLastError());
+ return -1;
+ }
+
+ min += len;
+ max += len;
+ success = SetProcessWorkingSetSize(process, min, max);
+ if (!success) {
+ errno = win_to_posix_error(GetLastError());
+ return -1;
+ }
+
+ success = VirtualLock((LPVOID)addr, len);
+ if (!success) {
+ errno = win_to_posix_error(GetLastError());
+ return -1;
+ }
+
+ return 0;
}
int munlock(const void * addr, size_t len)
{
- return !VirtualUnlock((LPVOID)addr, len);
+ BOOL success = VirtualUnlock((LPVOID)addr, len);
+ if (!success) {
+ errno = win_to_posix_error(GetLastError());
+ return -1;
+ }
+
+ return 0;
}
pid_t waitpid(pid_t pid, int *stat_loc, int options)
return name;
}
-int posix_fallocate(int fd, off_t offset, off_t len)
-{
- const int BUFFER_SIZE = 256 * 1024;
- int rc = 0;
- char *buf;
- unsigned int write_len;
- unsigned int bytes_written;
- off_t bytes_remaining = len;
-
- if (len == 0 || offset < 0)
- return EINVAL;
-
- buf = malloc(BUFFER_SIZE);
-
- if (buf == NULL)
- return ENOMEM;
-
- memset(buf, 0, BUFFER_SIZE);
-
- int64_t prev_pos = _telli64(fd);
-
- if (_lseeki64(fd, offset, SEEK_SET) == -1)
- return errno;
-
- while (bytes_remaining > 0) {
- if (bytes_remaining < BUFFER_SIZE)
- write_len = (unsigned int)bytes_remaining;
- else
- write_len = BUFFER_SIZE;
-
- bytes_written = _write(fd, buf, write_len);
- if (bytes_written == -1) {
- rc = errno;
- break;
- }
-
- /* Don't allow Windows to cache the write: flush it to disk */
- _commit(fd);
-
- bytes_remaining -= bytes_written;
- }
-
- free(buf);
- _lseeki64(fd, prev_pos, SEEK_SET);
- return rc;
-}
-
-int ftruncate(int fildes, off_t length)
-{
- BOOL bSuccess;
- int64_t prev_pos = _telli64(fildes);
- _lseeki64(fildes, length, SEEK_SET);
- HANDLE hFile = (HANDLE)_get_osfhandle(fildes);
- bSuccess = SetEndOfFile(hFile);
- _lseeki64(fildes, prev_pos, SEEK_SET);
- return !bSuccess;
-}
-
int fsync(int fildes)
{
HANDLE hFile = (HANDLE)_get_osfhandle(fildes);
- return !FlushFileBuffers(hFile);
+ if (!FlushFileBuffers(hFile)) {
+ errno = win_to_posix_error(GetLastError());
+ return -1;
+ }
+
+ return 0;
}
int nFileMappings = 0;
void* mapAddr;
MEMORY_BASIC_INFORMATION memInfo;
mapAddr = MapViewOfFile(fileMappings[shmid], FILE_MAP_ALL_ACCESS, 0, 0, 0);
- VirtualQuery(mapAddr, &memInfo, sizeof(memInfo));
+ if (mapAddr == NULL) {
+ errno = win_to_posix_error(GetLastError());
+ return (void*)-1;
+ }
+
+ if (VirtualQuery(mapAddr, &memInfo, sizeof(memInfo)) == 0) {
+ errno = win_to_posix_error(GetLastError());
+ return (void*)-1;
+ }
+
mapAddr = VirtualAlloc(mapAddr, memInfo.RegionSize, MEM_COMMIT, PAGE_READWRITE);
+ if (mapAddr == NULL) {
+ errno = win_to_posix_error(GetLastError());
+ return (void*)-1;
+ }
+
return mapAddr;
}
int shmdt(const void *shmaddr)
{
- return !UnmapViewOfFile(shmaddr);
+ if (!UnmapViewOfFile(shmaddr)) {
+ errno = win_to_posix_error(GetLastError());
+ return -1;
+ }
+
+ return 0;
}
int shmctl(int shmid, int cmd, struct shmid_ds *buf)
} else {
log_err("%s is not implemented\n", __func__);
}
- return (-1);
+ errno = ENOSYS;
+ return -1;
}
int setuid(uid_t uid)
{
log_err("%s is not implemented\n", __func__);
errno = ENOSYS;
- return (-1);
+ return -1;
}
int setgid(gid_t gid)
{
log_err("%s is not implemented\n", __func__);
errno = ENOSYS;
- return (-1);
+ return -1;
}
int nice(int incr)
const uint64_t SECONDS_BETWEEN_1601_AND_1970 = 11644473600;
FILETIME cTime, eTime, kTime, uTime;
time_t time;
+ HANDLE h;
memset(r_usage, 0, sizeof(*r_usage));
- HANDLE hProcess = GetCurrentProcess();
- GetProcessTimes(hProcess, &cTime, &eTime, &kTime, &uTime);
+ if (who == RUSAGE_SELF) {
+ h = GetCurrentProcess();
+ GetProcessTimes(h, &cTime, &eTime, &kTime, &uTime);
+ } else if (who == RUSAGE_THREAD) {
+ h = GetCurrentThread();
+ GetThreadTimes(h, &cTime, &eTime, &kTime, &uTime);
+ } else {
+ log_err("fio: getrusage %d is not implemented\n", who);
+ return -1;
+ }
+
time = ((uint64_t)uTime.dwHighDateTime << 32) + uTime.dwLowDateTime;
/* Divide by 10,000,000 to get the number of seconds and move the epoch from
* 1601 to 1970 */
return 0;
}
-int posix_fadvise(int fd, off_t offset, off_t len, int advice)
-{
- return 0;
-}
-
int posix_madvise(void *addr, size_t len, int advice)
{
log_err("%s is not implemented\n", __func__);
{
log_err("%s is not implemented\n", __func__);
errno = ENOSYS;
- return (-1);
+ return -1;
}
ssize_t writev(int fildes, const struct iovec *iov, int iovcnt)
{
- log_err("%s is not implemented\n", __func__);
- errno = ENOSYS;
- return (-1);
+ int i;
+ DWORD bytes_written = 0;
+ for (i = 0; i < iovcnt; i++)
+ {
+ int len = send((SOCKET)fildes, iov[i].iov_base, iov[i].iov_len, 0);
+ if (len == SOCKET_ERROR)
+ {
+ DWORD err = GetLastError();
+ errno = win_to_posix_error(err);
+ bytes_written = -1;
+ break;
+ }
+ bytes_written += len;
+ }
+
+ return bytes_written;
}
long long strtoll(const char *restrict str, char **restrict endptr,
return _strtoi64(str, endptr, base);
}
-char *strsep(char **stringp, const char *delim)
-{
- char *orig = *stringp;
- BOOL gotMatch = FALSE;
- int i = 0;
- int j = 0;
-
- if (*stringp == NULL)
- return NULL;
-
- while ((*stringp)[i] != '\0') {
- j = 0;
- while (delim[j] != '\0') {
- if ((*stringp)[i] == delim[j]) {
- gotMatch = TRUE;
- (*stringp)[i] = '\0';
- *stringp = *stringp + i + 1;
- break;
- }
- j++;
- }
- if (gotMatch)
- break;
-
- i++;
- }
-
- if (!gotMatch)
- *stringp = NULL;
-
- return orig;
-}
-
int poll(struct pollfd fds[], nfds_t nfds, int timeout)
{
struct timeval tv;
FD_SET(fds[i].fd, &exceptfds);
}
-
rc = select(nfds, &readfds, &writefds, &exceptfds, to);
if (rc != SOCKET_ERROR) {
fds[i].revents |= POLLHUP;
}
}
-
return rc;
}
DIR *opendir(const char *dirname)
{
- struct dirent_ctx *dc = NULL;
-
- /* See if we can open it. If not, we'll return an error here */
- HANDLE file = CreateFileA(dirname, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
- if (file != INVALID_HANDLE_VALUE) {
- CloseHandle(file);
- dc = (struct dirent_ctx*)malloc(sizeof(struct dirent_ctx));
- StringCchCopyA(dc->dirname, MAX_PATH, dirname);
- dc->find_handle = INVALID_HANDLE_VALUE;
- } else {
- DWORD error = GetLastError();
- if (error == ERROR_FILE_NOT_FOUND)
- errno = ENOENT;
-
- else if (error == ERROR_PATH_NOT_FOUND)
- errno = ENOTDIR;
- else if (error == ERROR_TOO_MANY_OPEN_FILES)
- errno = ENFILE;
- else if (error == ERROR_ACCESS_DENIED)
- errno = EACCES;
- else
- errno = error;
- }
-
- return dc;
+ struct dirent_ctx *dc = NULL;
+
+ /* See if we can open it. If not, we'll return an error here */
+ HANDLE file = CreateFileA(dirname, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
+ if (file != INVALID_HANDLE_VALUE) {
+ CloseHandle(file);
+ dc = (struct dirent_ctx*)malloc(sizeof(struct dirent_ctx));
+ StringCchCopyA(dc->dirname, MAX_PATH, dirname);
+ dc->find_handle = INVALID_HANDLE_VALUE;
+ } else {
+ DWORD error = GetLastError();
+ if (error == ERROR_FILE_NOT_FOUND)
+ errno = ENOENT;
+
+ else if (error == ERROR_PATH_NOT_FOUND)
+ errno = ENOTDIR;
+ else if (error == ERROR_TOO_MANY_OPEN_FILES)
+ errno = ENFILE;
+ else if (error == ERROR_ACCESS_DENIED)
+ errno = EACCES;
+ else
+ errno = error;
+ }
+
+ return dc;
}
int closedir(DIR *dirp)
{
- if (dirp != NULL && dirp->find_handle != INVALID_HANDLE_VALUE)
- FindClose(dirp->find_handle);
+ if (dirp != NULL && dirp->find_handle != INVALID_HANDLE_VALUE)
+ FindClose(dirp->find_handle);
- free(dirp);
- return 0;
+ free(dirp);
+ return 0;
}
struct dirent *readdir(DIR *dirp)
return -1;
}
+in_addr_t inet_network(const char *cp)
+{
+ in_addr_t hbo;
+ in_addr_t nbo = inet_addr(cp);
+ hbo = ((nbo & 0xFF) << 24) + ((nbo & 0xFF00) << 8) + ((nbo & 0xFF0000) >> 8) + ((nbo & 0xFF000000) >> 24);
+ return hbo;
+}
+
const char* inet_ntop(int af, const void *restrict src,
char *restrict dst, socklen_t size)
{
return ret;
}
-int inet_aton(const char *cp, struct in_addr *inp)
-{
- return inet_pton(AF_INET, cp, inp);
-}
-
int inet_pton(int af, const char *restrict src, void *restrict dst)
{
INT status = SOCKET_ERROR;