Lines Matching +full:fs +full:- +full:err
40 #include "req-inl.h"
41 #include "handle-inl.h"
42 #include "fs-fd-hash-inl.h"
63 &req->work_req, \
69 uv__fs_work(&req->work_req); \
70 return req->result; \
77 req->result = (result_value); \
78 assert(req->result != -1); \
83 req->sys_errno_ = (sys_errno); \
84 req->result = uv_translate_sys_error(req->sys_errno_); \
89 req->result = (uv_errno); \
90 req->sys_errno_ = (sys_errno); \
94 if (fd == -1) { \
95 req->result = UV_EBADF; \
96 req->sys_errno_ = ERROR_INVALID_HANDLE; \
104 filetime -= 116444736 * BILLION; in uv__filetime_to_timespec()
105 ts->tv_sec = (long) (filetime / (10 * MILLION)); in uv__filetime_to_timespec()
106 ts->tv_nsec = (long) ((filetime - ts->tv_sec * 10 * MILLION) * 100U); in uv__filetime_to_timespec()
107 if (ts->tv_nsec < 0) { in uv__filetime_to_timespec()
108 ts->tv_sec -= 1; in uv__filetime_to_timespec()
109 ts->tv_nsec += 1e9; in uv__filetime_to_timespec()
116 (filetime_ptr)->dwLowDateTime = (uint64_t) bigtime & 0xFFFFFFFF; \
117 (filetime_ptr)->dwHighDateTime = (uint64_t) bigtime >> 32; \
169 return -1; in fs__readlink_handle()
172 if (reparse_data->ReparseTag == IO_REPARSE_TAG_SYMLINK) { in fs__readlink_handle()
174 w_target = reparse_data->SymbolicLinkReparseBuffer.PathBuffer + in fs__readlink_handle()
175 (reparse_data->SymbolicLinkReparseBuffer.SubstituteNameOffset / in fs__readlink_handle()
178 reparse_data->SymbolicLinkReparseBuffer.SubstituteNameLength / in fs__readlink_handle()
184 * is win32-namespaced then the user must have explicitly made it so, and in fs__readlink_handle()
199 w_target_len -= 4; in fs__readlink_handle()
206 /* \??\UNC\<server>\<share>\ - make sure the final path looks like in fs__readlink_handle()
210 w_target_len -= 6; in fs__readlink_handle()
214 } else if (reparse_data->ReparseTag == IO_REPARSE_TAG_MOUNT_POINT) { in fs__readlink_handle()
216 w_target = reparse_data->MountPointReparseBuffer.PathBuffer + in fs__readlink_handle()
217 (reparse_data->MountPointReparseBuffer.SubstituteNameOffset / in fs__readlink_handle()
219 w_target_len = reparse_data->MountPointReparseBuffer.SubstituteNameLength / in fs__readlink_handle()
237 return -1; in fs__readlink_handle()
242 w_target_len -= 4; in fs__readlink_handle()
244 } else if (reparse_data->ReparseTag == IO_REPARSE_TAG_APPEXECLINK) { in fs__readlink_handle()
246 if (reparse_data->AppExecLinkReparseBuffer.StringCount < 3) { in fs__readlink_handle()
248 return -1; in fs__readlink_handle()
250 w_target = reparse_data->AppExecLinkReparseBuffer.StringList; in fs__readlink_handle()
257 return -1; in fs__readlink_handle()
264 return -1; in fs__readlink_handle()
273 return -1; in fs__readlink_handle()
279 return -1; in fs__readlink_handle()
320 req->file.pathw = NULL; in fs__capture_path()
321 req->fs.info.new_pathw = NULL; in fs__capture_path()
322 req->path = NULL; in fs__capture_path()
335 req->file.pathw = pos; in fs__capture_path()
338 req->file.pathw = NULL; in fs__capture_path()
343 req->fs.info.new_pathw = pos; in fs__capture_path()
346 req->fs.info.new_pathw = NULL; in fs__capture_path()
349 req->path = path; in fs__capture_path()
352 assert(path_len == buf_sz - (pos - buf) * sizeof(WCHAR)); in fs__capture_path()
353 req->path = (char*) pos; in fs__capture_path()
356 req->flags |= UV_FS_FREE_PATHS; in fs__capture_path()
366 req->loop = loop; in uv__fs_req_init()
367 req->flags = 0; in uv__fs_req_init()
368 req->fs_type = fs_type; in uv__fs_req_init()
369 req->sys_errno_ = 0; in uv__fs_req_init()
370 req->result = 0; in uv__fs_req_init()
371 req->ptr = NULL; in uv__fs_req_init()
372 req->path = NULL; in uv__fs_req_init()
373 req->cb = cb; in uv__fs_req_init()
374 memset(&req->fs, 0, sizeof(req->fs)); in uv__fs_req_init()
385 int flags = req->fs.info.file_flags; in fs__open()
438 * https://github.com/nodejs/node-v0.x-archive/issues/1449. in fs__open()
474 if (!((req->fs.info.mode & ~current_umask) & _S_IWRITE)) { in fs__open()
546 file = CreateFileW(req->file.pathw, in fs__open()
634 int fd = req->file.fd; in fs__close()
654 if (result == -1) { in fs__close()
670 if (pep != NULL && pep->ExceptionRecord != NULL && in fs__filemap_ex_filter()
671 pep->ExceptionRecord->NumberParameters >= 3) { in fs__filemap_ex_filter()
672 NTSTATUS status = (NTSTATUS)pep->ExceptionRecord->ExceptionInformation[3]; in fs__filemap_ex_filter()
684 int fd = req->file.fd; /* VERIFY_FD done in fs__read */ in fs__read_filemap()
685 int rw_flags = fd_info->flags & in fs__read_filemap()
698 if (fd_info->is_directory) { in fs__read_filemap()
703 if (req->fs.info.offset == -1) { in fs__read_filemap()
704 pos = fd_info->current_pos; in fs__read_filemap()
706 pos.QuadPart = req->fs.info.offset; in fs__read_filemap()
710 if (pos.QuadPart >= fd_info->size.QuadPart) { in fs__read_filemap()
716 for (index = 0; index < req->fs.info.nbufs; ++index) { in fs__read_filemap()
717 read_size += req->fs.info.bufs[index].len; in fs__read_filemap()
720 fd_info->size.QuadPart - pos.QuadPart); in fs__read_filemap()
729 view_base.QuadPart = pos.QuadPart - view_offset; in fs__read_filemap()
730 view = MapViewOfFile(fd_info->mapping, in fs__read_filemap()
742 index < req->fs.info.nbufs && done_read < read_size; in fs__read_filemap()
744 size_t this_read_size = MIN(req->fs.info.bufs[index].len, in fs__read_filemap()
745 read_size - done_read); in fs__read_filemap()
747 int err = 0; in fs__read_filemap() local
750 memcpy(req->fs.info.bufs[index].base, in fs__read_filemap()
756 GetExceptionInformation(), &err)) { in fs__read_filemap()
757 SET_REQ_WIN32_ERROR(req, err); in fs__read_filemap()
771 if (req->fs.info.offset == -1) { in fs__read_filemap()
772 fd_info->current_pos = end_pos; in fs__read_filemap()
781 int fd = req->file.fd; in fs__read()
782 int64_t offset = req->fs.info.offset; in fs__read()
811 if (offset != -1) { in fs__read()
827 if (offset != -1) { in fs__read()
834 req->fs.info.bufs[index].base, in fs__read()
835 req->fs.info.bufs[index].len, in fs__read()
840 } while (result && index < req->fs.info.nbufs); in fs__read()
864 int fd = req->file.fd; /* VERIFY_FD done in fs__write */ in fs__write_filemap()
865 int force_append = fd_info->flags & UV_FS_O_APPEND; in fs__write_filemap()
866 int rw_flags = fd_info->flags & in fs__write_filemap()
880 if (fd_info->is_directory) { in fs__write_filemap()
886 for (index = 0; index < req->fs.info.nbufs; ++index) { in fs__write_filemap()
887 write_size += req->fs.info.bufs[index].len; in fs__write_filemap()
896 pos = fd_info->size; in fs__write_filemap()
897 } else if (req->fs.info.offset == -1) { in fs__write_filemap()
898 pos = fd_info->current_pos; in fs__write_filemap()
900 pos.QuadPart = req->fs.info.offset; in fs__write_filemap()
906 if (end_pos.QuadPart > fd_info->size.QuadPart) { in fs__write_filemap()
907 if (fd_info->mapping != INVALID_HANDLE_VALUE) { in fs__write_filemap()
908 CloseHandle(fd_info->mapping); in fs__write_filemap()
911 fd_info->mapping = CreateFileMapping(file, in fs__write_filemap()
917 if (fd_info->mapping == NULL) { in fs__write_filemap()
920 fd_info->mapping = INVALID_HANDLE_VALUE; in fs__write_filemap()
921 fd_info->size.QuadPart = 0; in fs__write_filemap()
922 fd_info->current_pos.QuadPart = 0; in fs__write_filemap()
927 fd_info->size = end_pos; in fs__write_filemap()
932 view_base.QuadPart = pos.QuadPart - view_offset; in fs__write_filemap()
933 view = MapViewOfFile(fd_info->mapping, in fs__write_filemap()
944 for (index = 0; index < req->fs.info.nbufs; ++index) { in fs__write_filemap()
946 int err = 0; in fs__write_filemap() local
950 req->fs.info.bufs[index].base, in fs__write_filemap()
951 req->fs.info.bufs[index].len); in fs__write_filemap()
955 GetExceptionInformation(), &err)) { in fs__write_filemap()
956 SET_REQ_WIN32_ERROR(req, err); in fs__write_filemap()
961 done_write += req->fs.info.bufs[index].len; in fs__write_filemap()
975 if (req->fs.info.offset == -1) { in fs__write_filemap()
976 fd_info->current_pos = end_pos; in fs__write_filemap()
987 int fd = req->file.fd; in fs__write()
988 int64_t offset = req->fs.info.offset; in fs__write()
1016 if (offset != -1) { in fs__write()
1032 if (offset != -1) { in fs__write()
1039 req->fs.info.bufs[index].base, in fs__write()
1040 req->fs.info.bufs[index].len, in fs__write()
1045 } while (result && index < req->fs.info.nbufs); in fs__write()
1065 int result = _wrmdir(req->file.pathw); in fs__rmdir()
1066 if (result == -1) in fs__rmdir()
1074 const WCHAR* pathw = req->file.pathw; in fs__unlink()
1102 * path refers to a non-symlink directory, report EPERM as mandated by in fs__unlink()
1125 /* Remove read-only attribute */ in fs__unlink()
1161 /* TODO: use req->mode. */ in fs__mkdir()
1162 if (CreateDirectoryW(req->file.pathw, NULL)) { in fs__mkdir()
1166 if (req->sys_errno_ == ERROR_INVALID_NAME || in fs__mkdir()
1167 req->sys_errno_ == ERROR_DIRECTORY) in fs__mkdir()
1168 req->result = UV_EINVAL; in fs__mkdir()
1186 path = (char*)req->path; in fs__mktemp()
1187 len = wcslen(req->file.pathw); in fs__mktemp()
1188 ep = req->file.pathw + len; in fs__mktemp()
1189 if (len < num_x || wcsncmp(ep - num_x, L"XXXXXX", num_x)) { in fs__mktemp()
1201 cp = ep - num_x; in fs__mktemp()
1208 if (req->result >= 0) { in fs__mktemp()
1210 wcstombs(path + len - num_x, ep - num_x, num_x); in fs__mktemp()
1214 } while (--tries); in fs__mktemp()
1225 if (CreateDirectoryW(req->file.pathw, NULL)) { in fs__mkdtemp_func()
1248 file = CreateFileW(req->file.pathw, in fs__mkstemp_func()
1313 * According to MSDN, the buffer must be aligned at an 8-byte boundary. in fs__scandir()
1326 CreateFileW(req->file.pathw, in fs__scandir()
1372 next_entry_offset = info->NextEntryOffset; in fs__scandir()
1375 wchar_len = info->FileNameLength / sizeof info->FileName[0]; in fs__scandir()
1381 while (wchar_len > 0 && info->FileName[wchar_len - 1] == L'\0') in fs__scandir()
1382 wchar_len -= 1; in fs__scandir()
1386 if (wchar_len == 1 && info->FileName[0] == L'.') in fs__scandir()
1388 if (wchar_len == 2 && info->FileName[0] == L'.' && in fs__scandir()
1389 info->FileName[1] == L'.') in fs__scandir()
1392 /* Compute the space required to store the filename as WTF-8. */ in fs__scandir()
1393 wtf8_len = uv_utf16_length_as_wtf8(&info->FileName[0], wchar_len); in fs__scandir()
1419 /* Convert file name to UTF-8. */ in fs__scandir()
1420 wtf8 = &dirent->d_name[0]; in fs__scandir()
1421 if (uv_utf16_to_wtf8(&info->FileName[0], wchar_len, &wtf8, &wtf8_len) != 0) in fs__scandir()
1425 if (info->FileAttributes & FILE_ATTRIBUTE_DEVICE) in fs__scandir()
1426 dirent->d_type = UV__DT_CHAR; in fs__scandir()
1427 else if (info->FileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) in fs__scandir()
1428 dirent->d_type = UV__DT_LINK; in fs__scandir()
1429 else if (info->FileAttributes & FILE_ATTRIBUTE_DIRECTORY) in fs__scandir()
1430 dirent->d_type = UV__DT_DIR; in fs__scandir()
1432 dirent->d_type = UV__DT_FILE; in fs__scandir()
1462 req->ptr = dirents; in fs__scandir()
1464 req->flags |= UV_FS_FREE_PTR; in fs__scandir()
1469 req->fs.info.nbufs = 0; in fs__scandir()
1493 uv__free(dirents[--dirents_used]); in fs__scandir()
1505 pathw = req->file.pathw; in fs__opendir()
1525 else if (IS_SLASH(pathw[len - 1])) in fs__opendir()
1537 dir->dir_handle = FindFirstFileW(find_path, &dir->find_data); in fs__opendir()
1540 if (dir->dir_handle == INVALID_HANDLE_VALUE && in fs__opendir()
1546 dir->need_find_call = FALSE; in fs__opendir()
1547 req->ptr = dir; in fs__opendir()
1554 req->ptr = NULL; in fs__opendir()
1566 req->flags |= UV_FS_FREE_PTR; in fs__readdir()
1567 dir = req->ptr; in fs__readdir()
1568 dirents = dir->dirents; in fs__readdir()
1569 memset(dirents, 0, dir->nentries * sizeof(*dir->dirents)); in fs__readdir()
1570 find_data = &dir->find_data; in fs__readdir()
1573 while (dirent_idx < dir->nentries) { in fs__readdir()
1574 if (dir->need_find_call && FindNextFileW(dir->dir_handle, find_data) == 0) { in fs__readdir()
1581 if (find_data->cFileName[0] == L'.' && in fs__readdir()
1582 (find_data->cFileName[1] == L'\0' || in fs__readdir()
1583 (find_data->cFileName[1] == L'.' && in fs__readdir()
1584 find_data->cFileName[2] == L'\0'))) { in fs__readdir()
1585 dir->need_find_call = TRUE; in fs__readdir()
1589 r = uv__convert_utf16_to_utf8((const WCHAR*) &find_data->cFileName, in fs__readdir()
1590 -1, in fs__readdir()
1596 if ((find_data->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) in fs__readdir()
1598 else if ((find_data->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) != 0) in fs__readdir()
1600 else if ((find_data->dwFileAttributes & FILE_ATTRIBUTE_DEVICE) != 0) in fs__readdir()
1606 dir->need_find_call = TRUE; in fs__readdir()
1624 dir = req->ptr; in fs__closedir()
1625 FindClose(dir->dir_handle); in fs__closedir()
1626 uv__free(req->ptr); in fs__closedir()
1648 return -1; in fs__stat_handle()
1654 statbuf->st_mode = _S_IFCHR; in fs__stat_handle()
1655 statbuf->st_mode |= (_S_IREAD | _S_IWRITE) | ((_S_IREAD | _S_IWRITE) >> 3) | in fs__stat_handle()
1657 statbuf->st_nlink = 1; in fs__stat_handle()
1658 statbuf->st_blksize = 4096; in fs__stat_handle()
1659 statbuf->st_rdev = FILE_DEVICE_NULL << 16; in fs__stat_handle()
1672 return -1; in fs__stat_handle()
1683 statbuf->st_dev = 0; in fs__stat_handle()
1686 return -1; in fs__stat_handle()
1688 statbuf->st_dev = volume_info.VolumeSerialNumber; in fs__stat_handle()
1695 * makes little sense because the semantics are so different: the 'read-only' in fs__stat_handle()
1700 * reasons. Windows however just makes the file read-only, which makes it in fs__stat_handle()
1701 * impossible to delete the file afterwards, since read-only files can't be in fs__stat_handle()
1707 * And uv_fs_chmod should probably just fail on windows or be a total no-op. in fs__stat_handle()
1710 statbuf->st_mode = 0; in fs__stat_handle()
1729 return -1; in fs__stat_handle()
1730 statbuf->st_mode |= S_IFLNK; in fs__stat_handle()
1731 statbuf->st_size = target_length; in fs__stat_handle()
1734 if (statbuf->st_mode == 0) { in fs__stat_handle()
1736 statbuf->st_mode |= _S_IFDIR; in fs__stat_handle()
1737 statbuf->st_size = 0; in fs__stat_handle()
1739 statbuf->st_mode |= _S_IFREG; in fs__stat_handle()
1740 statbuf->st_size = file_info.StandardInformation.EndOfFile.QuadPart; in fs__stat_handle()
1745 statbuf->st_mode |= _S_IREAD | (_S_IREAD >> 3) | (_S_IREAD >> 6); in fs__stat_handle()
1747 statbuf->st_mode |= (_S_IREAD | _S_IWRITE) | ((_S_IREAD | _S_IWRITE) >> 3) | in fs__stat_handle()
1750 uv__filetime_to_timespec(&statbuf->st_atim, in fs__stat_handle()
1752 uv__filetime_to_timespec(&statbuf->st_ctim, in fs__stat_handle()
1754 uv__filetime_to_timespec(&statbuf->st_mtim, in fs__stat_handle()
1756 uv__filetime_to_timespec(&statbuf->st_birthtim, in fs__stat_handle()
1759 statbuf->st_ino = file_info.InternalInformation.IndexNumber.QuadPart; in fs__stat_handle()
1761 /* st_blocks contains the on-disk allocation size in 512-byte units. */ in fs__stat_handle()
1762 statbuf->st_blocks = in fs__stat_handle()
1765 statbuf->st_nlink = file_info.StandardInformation.NumberOfLinks; in fs__stat_handle()
1768 * and writing to the disk. That is, for any definition of 'optimal' - it's in fs__stat_handle()
1769 * supposed to at least avoid read-update-write behavior when writing to the in fs__stat_handle()
1783 statbuf->st_blksize = 4096; in fs__stat_handle()
1788 statbuf->st_flags = 0; in fs__stat_handle()
1793 statbuf->st_gid = 0; in fs__stat_handle()
1794 statbuf->st_uid = 0; in fs__stat_handle()
1795 statbuf->st_rdev = 0; in fs__stat_handle()
1796 statbuf->st_gen = 0; in fs__stat_handle()
1806 if (len > 1 && pathw[len - 2] != L':' && in fs__stat_prepare_path()
1807 (pathw[len - 1] == L'\\' || pathw[len - 1] == L'/')) { in fs__stat_prepare_path()
1808 pathw[len - 1] = '\0'; in fs__stat_prepare_path()
1848 error = fs__stat_impl_from_path(req->file.pathw, do_lstat, &req->statbuf); in fs__stat_impl()
1863 req->ptr = &req->statbuf; in fs__stat_impl()
1884 statbuf->st_mode = file_type == UV_TTY ? _S_IFCHR : _S_IFIFO; in fs__fstat_handle()
1885 statbuf->st_nlink = 1; in fs__fstat_handle()
1886 statbuf->st_rdev = (file_type == UV_TTY ? FILE_DEVICE_CONSOLE : FILE_DEVICE_NAMED_PIPE) << 16; in fs__fstat_handle()
1887 statbuf->st_ino = (uintptr_t) handle; in fs__fstat_handle()
1894 return -1; in fs__fstat_handle()
1900 fs__stat_prepare_path(req->file.pathw); in fs__stat()
1906 fs__stat_prepare_path(req->file.pathw); in fs__lstat()
1912 int fd = req->file.fd; in fs__fstat()
1924 if (fs__fstat_handle(fd, handle, &req->statbuf) != 0) { in fs__fstat()
1929 req->ptr = &req->statbuf; in fs__fstat()
1935 if (!MoveFileExW(req->file.pathw, req->fs.info.new_pathw, MOVEFILE_REPLACE_EXISTING)) { in fs__rename()
1945 int fd = req->file.fd; in fs__sync_impl()
1950 result = FlushFileBuffers(uv__get_osfhandle(fd)) ? 0 : -1; in fs__sync_impl()
1951 if (result == -1) { in fs__sync_impl()
1970 int fd = req->file.fd; in fs__ftruncate()
1992 eof_info.EndOfFile.QuadPart = req->fs.info.offset; in fs__ftruncate()
2051 flags = req->fs.info.file_flags; in fs__copyfile()
2060 if (CopyFileW(req->file.pathw, req->fs.info.new_pathw, overwrite) != 0) { in fs__copyfile()
2066 if (req->result != UV_EBUSY) in fs__copyfile()
2070 if (fs__stat_impl_from_path(req->file.pathw, 0, &statbuf) != 0 || in fs__copyfile()
2071 fs__stat_impl_from_path(req->fs.info.new_pathw, 0, &new_statbuf) != 0) { in fs__copyfile()
2083 int fd_in = req->file.fd, fd_out = req->fs.info.fd_out; in fs__sendfile()
2084 size_t length = req->fs.info.bufsml[0].len; in fs__sendfile()
2085 int64_t offset = req->fs.info.offset; in fs__sendfile()
2095 if (offset != -1) { in fs__sendfile()
2099 if (result_offset == -1) { in fs__sendfile()
2100 result = -1; in fs__sendfile()
2106 } else if (n == -1) { in fs__sendfile()
2107 result = -1; in fs__sendfile()
2111 length -= n; in fs__sendfile()
2114 if (n == -1) { in fs__sendfile()
2115 result = -1; in fs__sendfile()
2130 DWORD attr = GetFileAttributesW(req->file.pathw); in fs__access()
2139 * - write access wasn't requested, in fs__access()
2140 * - or the file isn't read-only, in fs__access()
2141 * - or it's a directory. in fs__access()
2142 * (Directories cannot be read-only on Windows.) in fs__access()
2144 if (!(req->fs.info.mode & W_OK) || in fs__access()
2156 int result = _wchmod(req->file.pathw, req->fs.info.mode); in fs__chmod()
2157 if (result == -1) in fs__chmod()
2165 int fd = req->file.fd; in fs__fchmod()
2193 /* Set Archive flag, otherwise setting or clearing the read-only in fs__fchmod()
2211 if (req->fs.info.mode & _S_IWRITE) { in fs__fchmod()
2257 return -1; in fs__utime_handle()
2299 error = fs__utime_impl_from_path(req->file.pathw, in fs__utime_impl()
2300 req->fs.time.atime, in fs__utime_impl()
2301 req->fs.time.mtime, in fs__utime_impl()
2327 int fd = req->file.fd; in fs__futime()
2338 if (fs__utime_handle(handle, req->fs.time.atime, req->fs.time.mtime) != 0) { in fs__futime()
2352 DWORD r = CreateHardLinkW(req->fs.info.new_pathw, req->file.pathw, NULL); in fs__link()
2402 path_buf = (WCHAR*)&(buffer->MountPointReparseBuffer.PathBuffer); in fs__create_junction()
2427 len = path_buf_len - start; in fs__create_junction()
2430 buffer->MountPointReparseBuffer.SubstituteNameOffset = start * sizeof(WCHAR); in fs__create_junction()
2431 buffer->MountPointReparseBuffer.SubstituteNameLength = len * sizeof(WCHAR); in fs__create_junction()
2452 len = path_buf_len - start; in fs__create_junction()
2459 buffer->MountPointReparseBuffer.PrintNameOffset = start * sizeof(WCHAR); in fs__create_junction()
2460 buffer->MountPointReparseBuffer.PrintNameLength = len * sizeof(WCHAR); in fs__create_junction()
2468 used_data_size = used_buf_size - in fs__create_junction()
2472 buffer->ReparseTag = IO_REPARSE_TAG_MOUNT_POINT; in fs__create_junction()
2473 buffer->ReparseDataLength = used_data_size; in fs__create_junction()
2474 buffer->Reserved = 0; in fs__create_junction()
2534 int err; in fs__symlink() local
2536 pathw = req->file.pathw; in fs__symlink()
2537 new_pathw = req->fs.info.new_pathw; in fs__symlink()
2539 if (req->fs.info.file_flags & UV_FS_SYMLINK_JUNCTION) { in fs__symlink()
2544 if (req->fs.info.file_flags & UV_FS_SYMLINK_DIR) in fs__symlink()
2554 /* Something went wrong. We will test if it is because of user-mode in fs__symlink()
2557 err = GetLastError(); in fs__symlink()
2558 if (err == ERROR_INVALID_PARAMETER && in fs__symlink()
2560 /* This system does not support user-mode symlinks. We will clear the in fs__symlink()
2566 SET_REQ_WIN32_ERROR(req, err); in fs__symlink()
2574 handle = CreateFileW(req->file.pathw, in fs__readlink()
2587 assert(req->ptr == NULL); in fs__readlink()
2588 if (fs__readlink_handle(handle, (char**) &req->ptr, NULL) != 0) { in fs__readlink()
2592 req->result = UV_EINVAL; in fs__readlink()
2597 req->flags |= UV_FS_FREE_PTR; in fs__readlink()
2612 return -1; in fs__realpath_handle()
2618 return -1; in fs__realpath_handle()
2626 return -1; in fs__realpath_handle()
2635 w_realpath_len -= 6; in fs__realpath_handle()
2640 w_realpath_len -= 4; in fs__realpath_handle()
2644 return -1; in fs__realpath_handle()
2656 handle = CreateFileW(req->file.pathw, in fs__realpath()
2668 assert(req->ptr == NULL); in fs__realpath()
2669 if (fs__realpath_handle(handle, (char**) &req->ptr) == -1) { in fs__realpath()
2676 req->flags |= UV_FS_FREE_PTR; in fs__realpath()
2704 pathw = req->file.pathw; in fs__statfs()
2711 DWORD err; in fs__statfs() local
2717 err = GetLastError(); in fs__statfs()
2718 is_second = pathw != req->file.pathw; in fs__statfs()
2719 if (err != ERROR_DIRECTORY || is_second) { in fs__statfs()
2723 SET_REQ_WIN32_ERROR(req, err); in fs__statfs()
2734 ret = GetFullPathNameW(req->file.pathw, in fs__statfs()
2740 SET_REQ_WIN32_ERROR(req, err); in fs__statfs()
2756 if (pathw != req->file.pathw) { in fs__statfs()
2766 stat_fs->f_type = 0; in fs__statfs()
2767 stat_fs->f_bsize = bytes_per_sector * sectors_per_cluster; in fs__statfs()
2768 stat_fs->f_blocks = total_clusters; in fs__statfs()
2769 stat_fs->f_bfree = free_clusters; in fs__statfs()
2770 stat_fs->f_bavail = free_clusters; in fs__statfs()
2771 stat_fs->f_files = 0; in fs__statfs()
2772 stat_fs->f_ffree = 0; in fs__statfs()
2773 req->ptr = stat_fs; in fs__statfs()
2774 req->flags |= UV_FS_FREE_PTR; in fs__statfs()
2783 assert(req->type == UV_FS); in uv__fs_work()
2786 switch (req->fs_type) { in uv__fs_work()
2833 uv__req_unregister(req->loop, req); in uv__fs_done()
2836 assert(req->result == 0); in uv__fs_done()
2840 req->cb(req); in uv__fs_done()
2848 if (req->flags & UV_FS_CLEANEDUP) in uv_fs_req_cleanup()
2851 if (req->flags & UV_FS_FREE_PATHS) in uv_fs_req_cleanup()
2852 uv__free(req->file.pathw); in uv_fs_req_cleanup()
2854 if (req->flags & UV_FS_FREE_PTR) { in uv_fs_req_cleanup()
2855 if (req->fs_type == UV_FS_SCANDIR && req->ptr != NULL) in uv_fs_req_cleanup()
2857 else if (req->fs_type == UV_FS_READDIR) in uv_fs_req_cleanup()
2860 uv__free(req->ptr); in uv_fs_req_cleanup()
2863 if (req->fs.info.bufs != req->fs.info.bufsml) in uv_fs_req_cleanup()
2864 uv__free(req->fs.info.bufs); in uv_fs_req_cleanup()
2866 req->path = NULL; in uv_fs_req_cleanup()
2867 req->file.pathw = NULL; in uv_fs_req_cleanup()
2868 req->fs.info.new_pathw = NULL; in uv_fs_req_cleanup()
2869 req->fs.info.bufs = NULL; in uv_fs_req_cleanup()
2870 req->ptr = NULL; in uv_fs_req_cleanup()
2872 req->flags |= UV_FS_CLEANEDUP; in uv_fs_req_cleanup()
2878 int err; in uv_fs_open() local
2881 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_open()
2882 if (err) { in uv_fs_open()
2883 SET_REQ_WIN32_ERROR(req, err); in uv_fs_open()
2884 return req->result; in uv_fs_open()
2887 req->fs.info.file_flags = flags; in uv_fs_open()
2888 req->fs.info.mode = mode; in uv_fs_open()
2895 req->file.fd = fd; in uv_fs_close()
2914 req->file.fd = fd; in uv_fs_read()
2916 req->fs.info.nbufs = nbufs; in uv_fs_read()
2917 req->fs.info.bufs = req->fs.info.bufsml; in uv_fs_read()
2918 if (nbufs > ARRAY_SIZE(req->fs.info.bufsml)) in uv_fs_read()
2919 req->fs.info.bufs = uv__malloc(nbufs * sizeof(*bufs)); in uv_fs_read()
2921 if (req->fs.info.bufs == NULL) { in uv_fs_read()
2926 memcpy(req->fs.info.bufs, bufs, nbufs * sizeof(*bufs)); in uv_fs_read()
2928 req->fs.info.offset = offset; in uv_fs_read()
2947 req->file.fd = fd; in uv_fs_write()
2949 req->fs.info.nbufs = nbufs; in uv_fs_write()
2950 req->fs.info.bufs = req->fs.info.bufsml; in uv_fs_write()
2951 if (nbufs > ARRAY_SIZE(req->fs.info.bufsml)) in uv_fs_write()
2952 req->fs.info.bufs = uv__malloc(nbufs * sizeof(*bufs)); in uv_fs_write()
2954 if (req->fs.info.bufs == NULL) { in uv_fs_write()
2959 memcpy(req->fs.info.bufs, bufs, nbufs * sizeof(*bufs)); in uv_fs_write()
2961 req->fs.info.offset = offset; in uv_fs_write()
2968 int err; in uv_fs_unlink() local
2971 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_unlink()
2972 if (err) { in uv_fs_unlink()
2973 SET_REQ_WIN32_ERROR(req, err); in uv_fs_unlink()
2974 return req->result; in uv_fs_unlink()
2983 int err; in uv_fs_mkdir() local
2986 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_mkdir()
2987 if (err) { in uv_fs_mkdir()
2988 SET_REQ_WIN32_ERROR(req, err); in uv_fs_mkdir()
2989 return req->result; in uv_fs_mkdir()
2992 req->fs.info.mode = mode; in uv_fs_mkdir()
3001 int err; in uv_fs_mkdtemp() local
3004 err = fs__capture_path(req, tpl, NULL, TRUE); in uv_fs_mkdtemp()
3005 if (err) { in uv_fs_mkdtemp()
3006 SET_REQ_WIN32_ERROR(req, err); in uv_fs_mkdtemp()
3007 return req->result; in uv_fs_mkdtemp()
3018 int err; in uv_fs_mkstemp() local
3021 err = fs__capture_path(req, tpl, NULL, TRUE); in uv_fs_mkstemp()
3022 if (err) { in uv_fs_mkstemp()
3023 SET_REQ_WIN32_ERROR(req, err); in uv_fs_mkstemp()
3024 return req->result; in uv_fs_mkstemp()
3032 int err; in uv_fs_rmdir() local
3035 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_rmdir()
3036 if (err) { in uv_fs_rmdir()
3037 SET_REQ_WIN32_ERROR(req, err); in uv_fs_rmdir()
3038 return req->result; in uv_fs_rmdir()
3047 int err; in uv_fs_scandir() local
3050 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_scandir()
3051 if (err) { in uv_fs_scandir()
3052 SET_REQ_WIN32_ERROR(req, err); in uv_fs_scandir()
3053 return req->result; in uv_fs_scandir()
3056 req->fs.info.file_flags = flags; in uv_fs_scandir()
3064 int err; in uv_fs_opendir() local
3067 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_opendir()
3068 if (err) { in uv_fs_opendir()
3069 SET_REQ_WIN32_ERROR(req, err); in uv_fs_opendir()
3070 return req->result; in uv_fs_opendir()
3082 dir->dirents == NULL || in uv_fs_readdir()
3083 dir->dir_handle == INVALID_HANDLE_VALUE) { in uv_fs_readdir()
3088 req->ptr = dir; in uv_fs_readdir()
3101 req->ptr = dir; in uv_fs_closedir()
3107 int err; in uv_fs_link() local
3110 err = fs__capture_path(req, path, new_path, cb != NULL); in uv_fs_link()
3111 if (err) { in uv_fs_link()
3112 SET_REQ_WIN32_ERROR(req, err); in uv_fs_link()
3113 return req->result; in uv_fs_link()
3122 int err; in uv_fs_symlink() local
3125 err = fs__capture_path(req, path, new_path, cb != NULL); in uv_fs_symlink()
3126 if (err) { in uv_fs_symlink()
3127 SET_REQ_WIN32_ERROR(req, err); in uv_fs_symlink()
3128 return req->result; in uv_fs_symlink()
3131 req->fs.info.file_flags = flags; in uv_fs_symlink()
3138 int err; in uv_fs_readlink() local
3141 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_readlink()
3142 if (err) { in uv_fs_readlink()
3143 SET_REQ_WIN32_ERROR(req, err); in uv_fs_readlink()
3144 return req->result; in uv_fs_readlink()
3153 int err; in uv_fs_realpath() local
3162 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_realpath()
3163 if (err) { in uv_fs_realpath()
3164 SET_REQ_WIN32_ERROR(req, err); in uv_fs_realpath()
3165 return req->result; in uv_fs_realpath()
3174 int err; in uv_fs_chown() local
3177 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_chown()
3178 if (err) { in uv_fs_chown()
3179 SET_REQ_WIN32_ERROR(req, err); in uv_fs_chown()
3180 return req->result; in uv_fs_chown()
3196 int err; in uv_fs_lchown() local
3199 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_lchown()
3200 if (err) { in uv_fs_lchown()
3201 SET_REQ_WIN32_ERROR(req, err); in uv_fs_lchown()
3202 return req->result; in uv_fs_lchown()
3210 int err; in uv_fs_stat() local
3213 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_stat()
3214 if (err) { in uv_fs_stat()
3215 SET_REQ_WIN32_ERROR(req, err); in uv_fs_stat()
3216 return req->result; in uv_fs_stat()
3224 int err; in uv_fs_lstat() local
3227 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_lstat()
3228 if (err) { in uv_fs_lstat()
3229 SET_REQ_WIN32_ERROR(req, err); in uv_fs_lstat()
3230 return req->result; in uv_fs_lstat()
3239 req->file.fd = fd; in uv_fs_fstat()
3246 int err; in uv_fs_rename() local
3249 err = fs__capture_path(req, path, new_path, cb != NULL); in uv_fs_rename()
3250 if (err) { in uv_fs_rename()
3251 SET_REQ_WIN32_ERROR(req, err); in uv_fs_rename()
3252 return req->result; in uv_fs_rename()
3261 req->file.fd = fd; in uv_fs_fsync()
3268 req->file.fd = fd; in uv_fs_fdatasync()
3276 req->file.fd = fd; in uv_fs_ftruncate()
3277 req->fs.info.offset = offset; in uv_fs_ftruncate()
3288 int err; in uv_fs_copyfile() local
3299 err = fs__capture_path(req, path, new_path, cb != NULL); in uv_fs_copyfile()
3300 if (err) { in uv_fs_copyfile()
3301 SET_REQ_WIN32_ERROR(req, err); in uv_fs_copyfile()
3302 return req->result; in uv_fs_copyfile()
3305 req->fs.info.file_flags = flags; in uv_fs_copyfile()
3313 req->file.fd = fd_in; in uv_fs_sendfile()
3314 req->fs.info.fd_out = fd_out; in uv_fs_sendfile()
3315 req->fs.info.offset = in_offset; in uv_fs_sendfile()
3316 req->fs.info.bufsml[0].len = length; in uv_fs_sendfile()
3326 int err; in uv_fs_access() local
3329 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_access()
3330 if (err) { in uv_fs_access()
3331 SET_REQ_WIN32_ERROR(req, err); in uv_fs_access()
3332 return req->result; in uv_fs_access()
3335 req->fs.info.mode = flags; in uv_fs_access()
3342 int err; in uv_fs_chmod() local
3345 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_chmod()
3346 if (err) { in uv_fs_chmod()
3347 SET_REQ_WIN32_ERROR(req, err); in uv_fs_chmod()
3348 return req->result; in uv_fs_chmod()
3351 req->fs.info.mode = mode; in uv_fs_chmod()
3359 req->file.fd = fd; in uv_fs_fchmod()
3360 req->fs.info.mode = mode; in uv_fs_fchmod()
3367 int err; in uv_fs_utime() local
3370 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_utime()
3371 if (err) { in uv_fs_utime()
3372 SET_REQ_WIN32_ERROR(req, err); in uv_fs_utime()
3373 return req->result; in uv_fs_utime()
3376 req->fs.time.atime = atime; in uv_fs_utime()
3377 req->fs.time.mtime = mtime; in uv_fs_utime()
3385 req->file.fd = fd; in uv_fs_futime()
3386 req->fs.time.atime = atime; in uv_fs_futime()
3387 req->fs.time.mtime = mtime; in uv_fs_futime()
3393 int err; in uv_fs_lutime() local
3396 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_lutime()
3397 if (err) { in uv_fs_lutime()
3398 SET_REQ_WIN32_ERROR(req, err); in uv_fs_lutime()
3399 return req->result; in uv_fs_lutime()
3402 req->fs.time.atime = atime; in uv_fs_lutime()
3403 req->fs.time.mtime = mtime; in uv_fs_lutime()
3412 int err; in uv_fs_statfs() local
3415 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_statfs()
3416 if (err) { in uv_fs_statfs()
3417 SET_REQ_WIN32_ERROR(req, err); in uv_fs_statfs()
3418 return req->result; in uv_fs_statfs()
3425 return req->sys_errno_; in uv_fs_get_system_error()