Lines Matching refs:req
52 if (req == NULL) \
54 uv__fs_req_init(loop, req, subtype, cb); \
61 uv__req_register(loop, req); \
63 &req->work_req, \
69 uv__fs_work(&req->work_req); \
70 return req->result; \
75 #define SET_REQ_RESULT(req, result_value) \ argument
77 req->result = (result_value); \
78 assert(req->result != -1); \
81 #define SET_REQ_WIN32_ERROR(req, sys_errno) \ argument
83 req->sys_errno_ = (sys_errno); \
84 req->result = uv_translate_sys_error(req->sys_errno_); \
87 #define SET_REQ_UV_ERROR(req, uv_errno, sys_errno) \ argument
89 req->result = (uv_errno); \
90 req->sys_errno_ = (sys_errno); \
93 #define VERIFY_FD(fd, req) \ argument
95 req->result = UV_EBADF; \
96 req->sys_errno_ = ERROR_INVALID_HANDLE; \
287 INLINE static int fs__capture_path(uv_fs_t* req, const char* path, in fs__capture_path() argument
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()
353 req->path = (char*) pos; in fs__capture_path()
356 req->flags |= UV_FS_FREE_PATHS; in fs__capture_path()
362 INLINE static void uv__fs_req_init(uv_loop_t* loop, uv_fs_t* req, in uv__fs_req_init() argument
365 UV_REQ_INIT(req, UV_FS); in uv__fs_req_init()
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()
378 void fs__open(uv_fs_t* req) { in fs__open() argument
385 int flags = req->fs.info.file_flags; 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()
559 SET_REQ_UV_ERROR(req, UV_EISDIR, error); in fs__open()
561 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__open()
573 SET_REQ_UV_ERROR(req, UV_EMFILE, ERROR_TOO_MANY_OPEN_FILES); in fs__open()
575 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__open()
577 SET_REQ_WIN32_ERROR(req, (DWORD) UV_UNKNOWN); in fs__open()
588 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__open()
599 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__open()
616 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__open()
626 SET_REQ_RESULT(req, fd); in fs__open()
630 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER); in fs__open()
633 void fs__close(uv_fs_t* req) { in fs__close() argument
634 int fd = req->file.fd; in fs__close()
638 VERIFY_FD(fd, req); in fs__close()
656 SET_REQ_UV_ERROR(req, UV_EBADF, ERROR_INVALID_HANDLE); in fs__close()
658 SET_REQ_RESULT(req, 0); in fs__close()
683 void fs__read_filemap(uv_fs_t* req, struct uv__fd_info_s* fd_info) { in fs__read_filemap() argument
684 int fd = req->file.fd; /* VERIFY_FD done in fs__read */ in fs__read_filemap()
695 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_FLAGS); in fs__read_filemap()
699 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_FUNCTION); in fs__read_filemap()
703 if (req->fs.info.offset == -1) { in fs__read_filemap()
706 pos.QuadPart = req->fs.info.offset; in fs__read_filemap()
711 SET_REQ_RESULT(req, 0); 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()
722 SET_REQ_RESULT(req, 0); in fs__read_filemap()
736 SET_REQ_WIN32_ERROR(req, GetLastError()); 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()
750 memcpy(req->fs.info.bufs[index].base, in fs__read_filemap()
757 SET_REQ_WIN32_ERROR(req, err); in fs__read_filemap()
767 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__read_filemap()
771 if (req->fs.info.offset == -1) { in fs__read_filemap()
776 SET_REQ_RESULT(req, read_size); in fs__read_filemap()
780 void fs__read(uv_fs_t* req) { in fs__read() argument
781 int fd = req->file.fd; in fs__read()
782 int64_t offset = req->fs.info.offset; in fs__read()
795 VERIFY_FD(fd, req); in fs__read()
798 fs__read_filemap(req, &fd_info); in fs__read()
807 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE); 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()
846 SET_REQ_RESULT(req, bytes); in fs__read()
854 SET_REQ_RESULT(req, bytes); in fs__read()
856 SET_REQ_WIN32_ERROR(req, error); in fs__read()
862 void fs__write_filemap(uv_fs_t* req, HANDLE file, in fs__write_filemap() argument
864 int fd = req->file.fd; /* VERIFY_FD done in fs__write */ in fs__write_filemap()
877 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_FLAGS); in fs__write_filemap()
881 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_FUNCTION); 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()
891 SET_REQ_RESULT(req, 0); in fs__write_filemap()
897 } else if (req->fs.info.offset == -1) { in fs__write_filemap()
900 pos.QuadPart = req->fs.info.offset; in fs__write_filemap()
918 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__write_filemap()
939 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__write_filemap()
944 for (index = 0; index < req->fs.info.nbufs; ++index) { in fs__write_filemap()
950 req->fs.info.bufs[index].base, in fs__write_filemap()
951 req->fs.info.bufs[index].len); 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()
966 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__write_filemap()
971 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__write_filemap()
975 if (req->fs.info.offset == -1) { in fs__write_filemap()
983 SET_REQ_RESULT(req, done_write); in fs__write_filemap()
986 void fs__write(uv_fs_t* req) { in fs__write() argument
987 int fd = req->file.fd; in fs__write()
988 int64_t offset = req->fs.info.offset; in fs__write()
1001 VERIFY_FD(fd, req); in fs__write()
1007 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE); in fs__write()
1012 fs__write_filemap(req, handle, &fd_info); 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()
1051 SET_REQ_RESULT(req, bytes); in fs__write()
1059 SET_REQ_WIN32_ERROR(req, error); in fs__write()
1064 void fs__rmdir(uv_fs_t* req) { in fs__rmdir() argument
1065 int result = _wrmdir(req->file.pathw); in fs__rmdir()
1067 SET_REQ_WIN32_ERROR(req, _doserrno); in fs__rmdir()
1069 SET_REQ_RESULT(req, 0); in fs__rmdir()
1073 void fs__unlink(uv_fs_t* req) { in fs__unlink() argument
1074 const WCHAR* pathw = req->file.pathw; in fs__unlink()
1090 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__unlink()
1095 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__unlink()
1107 SET_REQ_WIN32_ERROR(req, ERROR_ACCESS_DENIED); in fs__unlink()
1118 SET_REQ_WIN32_ERROR(req, error); in fs__unlink()
1137 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status)); in fs__unlink()
1151 SET_REQ_SUCCESS(req); in fs__unlink()
1153 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status)); in fs__unlink()
1160 void fs__mkdir(uv_fs_t* req) { in fs__mkdir() argument
1162 if (CreateDirectoryW(req->file.pathw, NULL)) { in fs__mkdir()
1163 SET_REQ_RESULT(req, 0); in fs__mkdir()
1165 SET_REQ_WIN32_ERROR(req, GetLastError()); 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()
1172 typedef int (*uv__fs_mktemp_func)(uv_fs_t* req);
1175 void fs__mktemp(uv_fs_t* req, uv__fs_mktemp_func func) { in fs__mktemp() argument
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()
1190 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER); in fs__mktemp()
1197 SET_REQ_UV_ERROR(req, UV_EIO, ERROR_IO_DEVICE); in fs__mktemp()
1207 if (func(req)) { in fs__mktemp()
1208 if (req->result >= 0) { in fs__mktemp()
1216 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__mktemp()
1223 static int fs__mkdtemp_func(uv_fs_t* req) { in fs__mkdtemp_func() argument
1225 if (CreateDirectoryW(req->file.pathw, NULL)) { in fs__mkdtemp_func()
1226 SET_REQ_RESULT(req, 0); in fs__mkdtemp_func()
1231 SET_REQ_WIN32_ERROR(req, error); in fs__mkdtemp_func()
1239 void fs__mkdtemp(uv_fs_t* req) { in fs__mkdtemp() argument
1240 fs__mktemp(req, fs__mkdtemp_func); in fs__mkdtemp()
1244 static int fs__mkstemp_func(uv_fs_t* req) { in fs__mkstemp_func() argument
1248 file = CreateFileW(req->file.pathw, in fs__mkstemp_func()
1263 SET_REQ_WIN32_ERROR(req, error); in fs__mkstemp_func()
1277 SET_REQ_UV_ERROR(req, UV_EMFILE, ERROR_TOO_MANY_OPEN_FILES); in fs__mkstemp_func()
1279 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__mkstemp_func()
1281 SET_REQ_WIN32_ERROR(req, UV_UNKNOWN); in fs__mkstemp_func()
1286 SET_REQ_RESULT(req, fd); in fs__mkstemp_func()
1292 void fs__mkstemp(uv_fs_t* req) { in fs__mkstemp() argument
1293 fs__mktemp(req, fs__mkstemp_func); in fs__mkstemp()
1297 void fs__scandir(uv_fs_t* req) { in fs__scandir() argument
1326 CreateFileW(req->file.pathw, in fs__scandir()
1462 req->ptr = dirents; in fs__scandir()
1464 req->flags |= UV_FS_FREE_PTR; in fs__scandir()
1466 SET_REQ_RESULT(req, dirents_used); in fs__scandir()
1469 req->fs.info.nbufs = 0; in fs__scandir()
1474 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status)); in fs__scandir()
1478 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__scandir()
1482 SET_REQ_UV_ERROR(req, UV_ENOTDIR, ERROR_DIRECTORY); in fs__scandir()
1486 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); in fs__scandir()
1498 void fs__opendir(uv_fs_t* req) { in fs__opendir() argument
1505 pathw = req->file.pathw; in fs__opendir()
1511 SET_REQ_UV_ERROR(req, UV_ENOTDIR, ERROR_DIRECTORY); in fs__opendir()
1517 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); in fs__opendir()
1532 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); in fs__opendir()
1542 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__opendir()
1547 req->ptr = dir; in fs__opendir()
1548 SET_REQ_RESULT(req, 0); in fs__opendir()
1554 req->ptr = NULL; in fs__opendir()
1557 void fs__readdir(uv_fs_t* req) { in fs__readdir() argument
1566 req->flags |= UV_FS_FREE_PTR; in fs__readdir()
1567 dir = req->ptr; in fs__readdir()
1610 SET_REQ_RESULT(req, dirent_idx); in fs__readdir()
1614 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__readdir()
1621 void fs__closedir(uv_fs_t* req) { in fs__closedir() argument
1624 dir = req->ptr; in fs__closedir()
1626 uv__free(req->ptr); in fs__closedir()
1627 SET_REQ_RESULT(req, 0); in fs__closedir()
1845 INLINE static void fs__stat_impl(uv_fs_t* req, int do_lstat) { in fs__stat_impl() argument
1848 error = fs__stat_impl_from_path(req->file.pathw, do_lstat, &req->statbuf); in fs__stat_impl()
1854 fs__stat_impl(req, 0); in fs__stat_impl()
1857 SET_REQ_WIN32_ERROR(req, error); in fs__stat_impl()
1863 req->ptr = &req->statbuf; in fs__stat_impl()
1864 SET_REQ_RESULT(req, 0); in fs__stat_impl()
1899 static void fs__stat(uv_fs_t* req) { in fs__stat() argument
1900 fs__stat_prepare_path(req->file.pathw); in fs__stat()
1901 fs__stat_impl(req, 0); in fs__stat()
1905 static void fs__lstat(uv_fs_t* req) { in fs__lstat() argument
1906 fs__stat_prepare_path(req->file.pathw); in fs__lstat()
1907 fs__stat_impl(req, 1); in fs__lstat()
1911 static void fs__fstat(uv_fs_t* req) { in fs__fstat() argument
1912 int fd = req->file.fd; in fs__fstat()
1915 VERIFY_FD(fd, req); in fs__fstat()
1920 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE); in fs__fstat()
1924 if (fs__fstat_handle(fd, handle, &req->statbuf) != 0) { in fs__fstat()
1925 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__fstat()
1929 req->ptr = &req->statbuf; in fs__fstat()
1930 SET_REQ_RESULT(req, 0); in fs__fstat()
1934 static void fs__rename(uv_fs_t* req) { in fs__rename() argument
1935 if (!MoveFileExW(req->file.pathw, req->fs.info.new_pathw, MOVEFILE_REPLACE_EXISTING)) { in fs__rename()
1936 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__rename()
1940 SET_REQ_RESULT(req, 0); in fs__rename()
1944 INLINE static void fs__sync_impl(uv_fs_t* req) { in fs__sync_impl() argument
1945 int fd = req->file.fd; in fs__sync_impl()
1948 VERIFY_FD(fd, req); in fs__sync_impl()
1952 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__sync_impl()
1954 SET_REQ_RESULT(req, result); in fs__sync_impl()
1959 static void fs__fsync(uv_fs_t* req) { in fs__fsync() argument
1960 fs__sync_impl(req); in fs__fsync()
1964 static void fs__fdatasync(uv_fs_t* req) { in fs__fdatasync() argument
1965 fs__sync_impl(req); in fs__fdatasync()
1969 static void fs__ftruncate(uv_fs_t* req) { in fs__ftruncate() argument
1970 int fd = req->file.fd; in fs__ftruncate()
1977 VERIFY_FD(fd, req); in fs__ftruncate()
1983 SET_REQ_WIN32_ERROR(req, ERROR_ACCESS_DENIED); in fs__ftruncate()
1992 eof_info.EndOfFile.QuadPart = req->fs.info.offset; in fs__ftruncate()
2001 SET_REQ_RESULT(req, 0); in fs__ftruncate()
2003 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(status)); in fs__ftruncate()
2030 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__ftruncate()
2045 static void fs__copyfile(uv_fs_t* req) { in fs__copyfile() argument
2051 flags = req->fs.info.file_flags; in fs__copyfile()
2054 SET_REQ_UV_ERROR(req, UV_ENOSYS, ERROR_NOT_SUPPORTED); in fs__copyfile()
2060 if (CopyFileW(req->file.pathw, req->fs.info.new_pathw, overwrite) != 0) { in fs__copyfile()
2061 SET_REQ_RESULT(req, 0); in fs__copyfile()
2065 SET_REQ_WIN32_ERROR(req, GetLastError()); 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()
2077 SET_REQ_RESULT(req, 0); in fs__copyfile()
2082 static void fs__sendfile(uv_fs_t* req) { in fs__sendfile() argument
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()
2125 SET_REQ_RESULT(req, result); in fs__sendfile()
2129 static void fs__access(uv_fs_t* req) { in fs__access() argument
2130 DWORD attr = GetFileAttributesW(req->file.pathw); in fs__access()
2133 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__access()
2144 if (!(req->fs.info.mode & W_OK) || in fs__access()
2147 SET_REQ_RESULT(req, 0); in fs__access()
2149 SET_REQ_WIN32_ERROR(req, UV_EPERM); in fs__access()
2155 static void fs__chmod(uv_fs_t* req) { in fs__chmod() argument
2156 int result = _wchmod(req->file.pathw, req->fs.info.mode); in fs__chmod()
2158 SET_REQ_WIN32_ERROR(req, _doserrno); in fs__chmod()
2160 SET_REQ_RESULT(req, 0); in fs__chmod()
2164 static void fs__fchmod(uv_fs_t* req) { in fs__fchmod() argument
2165 int fd = req->file.fd; in fs__fchmod()
2172 VERIFY_FD(fd, req); in fs__fchmod()
2176 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__fchmod()
2187 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status)); in fs__fchmod()
2202 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status)); in fs__fchmod()
2211 if (req->fs.info.mode & _S_IWRITE) { in fs__fchmod()
2224 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status)); in fs__fchmod()
2239 SET_REQ_WIN32_ERROR(req, pRtlNtStatusToDosError(nt_status)); in fs__fchmod()
2244 SET_REQ_SUCCESS(req); in fs__fchmod()
2296 INLINE static void fs__utime_impl(uv_fs_t* req, int do_lutime) { in fs__utime_impl() argument
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()
2309 fs__utime_impl(req, 0); in fs__utime_impl()
2312 SET_REQ_WIN32_ERROR(req, error); in fs__utime_impl()
2318 SET_REQ_RESULT(req, 0); in fs__utime_impl()
2321 static void fs__utime(uv_fs_t* req) { in fs__utime() argument
2322 fs__utime_impl(req, /* do_lutime */ 0); in fs__utime()
2326 static void fs__futime(uv_fs_t* req) { in fs__futime() argument
2327 int fd = req->file.fd; in fs__futime()
2329 VERIFY_FD(fd, req); in fs__futime()
2334 SET_REQ_WIN32_ERROR(req, ERROR_INVALID_HANDLE); in fs__futime()
2338 if (fs__utime_handle(handle, req->fs.time.atime, req->fs.time.mtime) != 0) { in fs__futime()
2339 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__futime()
2343 SET_REQ_RESULT(req, 0); in fs__futime()
2346 static void fs__lutime(uv_fs_t* req) { in fs__lutime() argument
2347 fs__utime_impl(req, /* do_lutime */ 1); in fs__lutime()
2351 static void fs__link(uv_fs_t* req) { in fs__link() argument
2352 DWORD r = CreateHardLinkW(req->fs.info.new_pathw, req->file.pathw, NULL); in fs__link()
2354 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__link()
2356 SET_REQ_RESULT(req, 0); in fs__link()
2360 static void fs__create_junction(uv_fs_t* req, const WCHAR* path, in fs__create_junction() argument
2385 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_NOT_SUPPORTED); in fs__create_junction()
2478 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__create_junction()
2493 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__create_junction()
2506 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__create_junction()
2514 SET_REQ_RESULT(req, 0); in fs__create_junction()
2530 static void fs__symlink(uv_fs_t* req) { in fs__symlink() argument
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()
2540 fs__create_junction(req, pathw, new_pathw); in fs__symlink()
2544 if (req->fs.info.file_flags & UV_FS_SYMLINK_DIR) in fs__symlink()
2550 SET_REQ_RESULT(req, 0); in fs__symlink()
2564 fs__symlink(req); in fs__symlink()
2566 SET_REQ_WIN32_ERROR(req, err); in fs__symlink()
2571 static void fs__readlink(uv_fs_t* req) { in fs__readlink() argument
2574 handle = CreateFileW(req->file.pathw, in fs__readlink()
2583 SET_REQ_WIN32_ERROR(req, GetLastError()); 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()
2590 SET_REQ_WIN32_ERROR(req, error); in fs__readlink()
2592 req->result = UV_EINVAL; in fs__readlink()
2597 req->flags |= UV_FS_FREE_PTR; in fs__readlink()
2598 SET_REQ_RESULT(req, 0); in fs__readlink()
2653 static void fs__realpath(uv_fs_t* req) { in fs__realpath() argument
2656 handle = CreateFileW(req->file.pathw, in fs__realpath()
2664 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__realpath()
2668 assert(req->ptr == NULL); in fs__realpath()
2669 if (fs__realpath_handle(handle, (char**) &req->ptr) == -1) { in fs__realpath()
2671 SET_REQ_WIN32_ERROR(req, GetLastError()); in fs__realpath()
2676 req->flags |= UV_FS_FREE_PTR; in fs__realpath()
2677 SET_REQ_RESULT(req, 0); in fs__realpath()
2681 static void fs__chown(uv_fs_t* req) { in fs__chown() argument
2682 SET_REQ_RESULT(req, 0); in fs__chown()
2686 static void fs__fchown(uv_fs_t* req) { in fs__fchown() argument
2687 SET_REQ_RESULT(req, 0); in fs__fchown()
2691 static void fs__lchown(uv_fs_t* req) { in fs__lchown() argument
2692 SET_REQ_RESULT(req, 0); in fs__lchown()
2696 static void fs__statfs(uv_fs_t* req) { in fs__statfs() argument
2704 pathw = req->file.pathw; in fs__statfs()
2718 is_second = pathw != req->file.pathw; in fs__statfs()
2723 SET_REQ_WIN32_ERROR(req, err); in fs__statfs()
2730 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); in fs__statfs()
2734 ret = GetFullPathNameW(req->file.pathw, in fs__statfs()
2740 SET_REQ_WIN32_ERROR(req, err); in fs__statfs()
2746 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); in fs__statfs()
2756 if (pathw != req->file.pathw) { in fs__statfs()
2762 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); in fs__statfs()
2773 req->ptr = stat_fs; in fs__statfs()
2774 req->flags |= UV_FS_FREE_PTR; in fs__statfs()
2775 SET_REQ_RESULT(req, 0); in fs__statfs()
2780 uv_fs_t* req; in uv__fs_work() local
2782 req = container_of(w, uv_fs_t, work_req); in uv__fs_work()
2783 assert(req->type == UV_FS); in uv__fs_work()
2785 #define XX(uc, lc) case UV_FS_##uc: fs__##lc(req); break; in uv__fs_work()
2786 switch (req->fs_type) { in uv__fs_work()
2830 uv_fs_t* req; in uv__fs_done() local
2832 req = container_of(w, uv_fs_t, work_req); in uv__fs_done()
2833 uv__req_unregister(req->loop, req); in uv__fs_done()
2836 assert(req->result == 0); in uv__fs_done()
2837 SET_REQ_UV_ERROR(req, UV_ECANCELED, 0); in uv__fs_done()
2840 req->cb(req); in uv__fs_done()
2844 void uv_fs_req_cleanup(uv_fs_t* req) { in uv_fs_req_cleanup() argument
2845 if (req == NULL) in uv_fs_req_cleanup()
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()
2856 uv__fs_scandir_cleanup(req); in uv_fs_req_cleanup()
2857 else if (req->fs_type == UV_FS_READDIR) in uv_fs_req_cleanup()
2858 uv__fs_readdir_cleanup(req); 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()
2876 int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, in uv_fs_open() argument
2881 err = fs__capture_path(req, path, NULL, cb != NULL); 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()
2893 int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) { in uv_fs_close() argument
2895 req->file.fd = fd; in uv_fs_close()
2901 uv_fs_t* req, in uv_fs_read() argument
2910 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER); in uv_fs_read()
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()
2922 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); 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()
2934 uv_fs_t* req, in uv_fs_write() argument
2943 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER); in uv_fs_write()
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()
2955 SET_REQ_UV_ERROR(req, UV_ENOMEM, ERROR_OUTOFMEMORY); 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()
2966 int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, in uv_fs_unlink() argument
2971 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_unlink()
2973 SET_REQ_WIN32_ERROR(req, err); in uv_fs_unlink()
2974 return req->result; in uv_fs_unlink()
2981 int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, in uv_fs_mkdir() argument
2986 err = fs__capture_path(req, path, NULL, cb != NULL); 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()
2998 uv_fs_t* req, in uv_fs_mkdtemp() argument
3004 err = fs__capture_path(req, tpl, NULL, TRUE); in uv_fs_mkdtemp()
3006 SET_REQ_WIN32_ERROR(req, err); in uv_fs_mkdtemp()
3007 return req->result; in uv_fs_mkdtemp()
3015 uv_fs_t* req, in uv_fs_mkstemp() argument
3021 err = fs__capture_path(req, tpl, NULL, TRUE); in uv_fs_mkstemp()
3023 SET_REQ_WIN32_ERROR(req, err); in uv_fs_mkstemp()
3024 return req->result; in uv_fs_mkstemp()
3031 int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { in uv_fs_rmdir() argument
3035 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_rmdir()
3037 SET_REQ_WIN32_ERROR(req, err); in uv_fs_rmdir()
3038 return req->result; in uv_fs_rmdir()
3045 int uv_fs_scandir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, in uv_fs_scandir() argument
3050 err = fs__capture_path(req, path, NULL, cb != NULL); 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()
3061 uv_fs_t* req, in uv_fs_opendir() argument
3067 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_opendir()
3069 SET_REQ_WIN32_ERROR(req, err); in uv_fs_opendir()
3070 return req->result; in uv_fs_opendir()
3076 uv_fs_t* req, in uv_fs_readdir() argument
3084 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER); in uv_fs_readdir()
3088 req->ptr = dir; in uv_fs_readdir()
3093 uv_fs_t* req, in uv_fs_closedir() argument
3098 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER); in uv_fs_closedir()
3101 req->ptr = dir; in uv_fs_closedir()
3105 int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path, in uv_fs_link() argument
3110 err = fs__capture_path(req, path, new_path, cb != NULL); in uv_fs_link()
3112 SET_REQ_WIN32_ERROR(req, err); in uv_fs_link()
3113 return req->result; in uv_fs_link()
3120 int uv_fs_symlink(uv_loop_t* loop, uv_fs_t* req, const char* path, in uv_fs_symlink() argument
3125 err = fs__capture_path(req, path, new_path, cb != NULL); 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()
3136 int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path, in uv_fs_readlink() argument
3141 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_readlink()
3143 SET_REQ_WIN32_ERROR(req, err); in uv_fs_readlink()
3144 return req->result; in uv_fs_readlink()
3151 int uv_fs_realpath(uv_loop_t* loop, uv_fs_t* req, const char* path, in uv_fs_realpath() argument
3158 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER); in uv_fs_realpath()
3162 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_realpath()
3164 SET_REQ_WIN32_ERROR(req, err); in uv_fs_realpath()
3165 return req->result; in uv_fs_realpath()
3172 int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_uid_t uid, in uv_fs_chown() argument
3177 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_chown()
3179 SET_REQ_WIN32_ERROR(req, err); in uv_fs_chown()
3180 return req->result; in uv_fs_chown()
3187 int uv_fs_fchown(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_uid_t uid, in uv_fs_fchown() argument
3194 int uv_fs_lchown(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_uid_t uid, in uv_fs_lchown() argument
3199 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_lchown()
3201 SET_REQ_WIN32_ERROR(req, err); in uv_fs_lchown()
3202 return req->result; in uv_fs_lchown()
3209 int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { in uv_fs_stat() argument
3213 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_stat()
3215 SET_REQ_WIN32_ERROR(req, err); in uv_fs_stat()
3216 return req->result; in uv_fs_stat()
3223 int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { in uv_fs_lstat() argument
3227 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_lstat()
3229 SET_REQ_WIN32_ERROR(req, err); in uv_fs_lstat()
3230 return req->result; in uv_fs_lstat()
3237 int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) { in uv_fs_fstat() argument
3239 req->file.fd = fd; in uv_fs_fstat()
3244 int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path, in uv_fs_rename() argument
3249 err = fs__capture_path(req, path, new_path, cb != NULL); in uv_fs_rename()
3251 SET_REQ_WIN32_ERROR(req, err); in uv_fs_rename()
3252 return req->result; in uv_fs_rename()
3259 int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) { in uv_fs_fsync() argument
3261 req->file.fd = fd; in uv_fs_fsync()
3266 int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file fd, uv_fs_cb cb) { in uv_fs_fdatasync() argument
3268 req->file.fd = fd; in uv_fs_fdatasync()
3273 int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file fd, in uv_fs_ftruncate() argument
3276 req->file.fd = fd; in uv_fs_ftruncate()
3277 req->fs.info.offset = offset; in uv_fs_ftruncate()
3283 uv_fs_t* req, in uv_fs_copyfile() argument
3295 SET_REQ_UV_ERROR(req, UV_EINVAL, ERROR_INVALID_PARAMETER); in uv_fs_copyfile()
3299 err = fs__capture_path(req, path, new_path, cb != NULL); 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()
3310 int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file fd_out, in uv_fs_sendfile() argument
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()
3322 uv_fs_t* req, in uv_fs_access() argument
3329 err = fs__capture_path(req, path, NULL, cb != NULL); 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()
3340 int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, in uv_fs_chmod() argument
3345 err = fs__capture_path(req, path, NULL, cb != NULL); 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()
3356 int uv_fs_fchmod(uv_loop_t* loop, uv_fs_t* req, uv_file fd, int mode, in uv_fs_fchmod() argument
3359 req->file.fd = fd; in uv_fs_fchmod()
3360 req->fs.info.mode = mode; in uv_fs_fchmod()
3365 int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime, in uv_fs_utime() argument
3370 err = fs__capture_path(req, path, NULL, cb != NULL); 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()
3382 int uv_fs_futime(uv_loop_t* loop, uv_fs_t* req, uv_file fd, double atime, in uv_fs_futime() argument
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()
3391 int uv_fs_lutime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime, in uv_fs_lutime() argument
3396 err = fs__capture_path(req, path, NULL, cb != NULL); 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()
3409 uv_fs_t* req, in uv_fs_statfs() argument
3415 err = fs__capture_path(req, path, NULL, cb != NULL); in uv_fs_statfs()
3417 SET_REQ_WIN32_ERROR(req, err); in uv_fs_statfs()
3418 return req->result; in uv_fs_statfs()
3424 int uv_fs_get_system_error(const uv_fs_t* req) { in uv_fs_get_system_error() argument
3425 return req->sys_errno_; in uv_fs_get_system_error()
