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;
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);
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 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)
{
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);
+ return -1;
}
long long strtoll(const char *restrict str, char **restrict endptr,
projects / fio.git / blobdiff