lukechilds
/
node
mirror of https://github.com/lukechilds/node.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Upgrade libuv to a8017fd

Ryan Dahl 14 years ago
parent
ef523e5719
commit
ece5c64504
3 changed files with 68 additions and 78 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 2
      deps/uv/include/uv-private/uv-win.h
  2. 134
      deps/uv/src/win/fs.c
  3. 10
      deps/uv/test/test-fs.c

2
deps/uv/include/uv-private/uv-win.h
View File

@ -248,7 +248,7 @@ RB_HEAD(uv_timer_tree_s, uv_timer_s);
#define UV_FS_PRIVATE_FIELDS \ #define UV_FS_PRIVATE_FIELDS \
int flags; \ int flags; \
int last_error; \ int last_error; \
struct _stat stat; \ struct _stati64 stat; \
void* arg0; \ void* arg0; \
union { \ union { \
struct { \ struct { \

134
deps/uv/src/win/fs.c
View File

@ -88,7 +88,7 @@ void uv_fs_init() {
static void uv_fs_req_init_async(uv_loop_t* loop, uv_fs_t* req, static void uv_fs_req_init_async(uv_loop_t* loop, uv_fs_t* req,
uv_fs_type fs_type, uv_fs_cb cb) { uv_fs_type fs_type, const char* path, uv_fs_cb cb) {
uv_req_init(loop, (uv_req_t*) req); uv_req_init(loop, (uv_req_t*) req);
req->type = UV_FS; req->type = UV_FS;
req->loop = loop; req->loop = loop;
@ -97,7 +97,7 @@ static void uv_fs_req_init_async(uv_loop_t* loop, uv_fs_t* req,
req->cb = cb; req->cb = cb;
req->result = 0; req->result = 0;
req->ptr = NULL; req->ptr = NULL;
req->path = NULL; /* TODO https://github.com/joyent/libuv/issues/177 */ req->path = path ? strdup(path) : NULL;
req->errorno = 0; req->errorno = 0;
req->last_error = 0; req->last_error = 0;
memset(&req->overlapped, 0, sizeof(req->overlapped)); memset(&req->overlapped, 0, sizeof(req->overlapped));
@ -113,6 +113,7 @@ static void uv_fs_req_init_sync(uv_loop_t* loop, uv_fs_t* req,
req->fs_type = fs_type; req->fs_type = fs_type;
req->result = 0; req->result = 0;
req->ptr = NULL; req->ptr = NULL;
req->path = NULL;
req->errorno = 0; req->errorno = 0;
} }
@ -356,7 +357,7 @@ done:
void fs__stat(uv_fs_t* req, const char* path) { void fs__stat(uv_fs_t* req, const char* path) {
int result; int result;
result = _stat(path, &req->stat); result = _stati64(path, &req->stat);
if (result == -1) { if (result == -1) {
req->ptr = NULL; req->ptr = NULL;
} else { } else {
@ -370,7 +371,7 @@ void fs__stat(uv_fs_t* req, const char* path) {
void fs__fstat(uv_fs_t* req, uv_file file) { void fs__fstat(uv_fs_t* req, uv_file file) {
int result; int result;
result = _fstat(file, &req->stat); result = _fstati64(file, &req->stat);
if (result == -1) { if (result == -1) {
req->ptr = NULL; req->ptr = NULL;
} else { } else {
@ -644,7 +645,7 @@ static DWORD WINAPI uv_fs_thread_proc(void* parameter) {
switch (req->fs_type) { switch (req->fs_type) {
case UV_FS_OPEN: case UV_FS_OPEN:
fs__open(req, (const char*)req->arg0, (int)req->arg1, (int)req->arg2); fs__open(req, req->path, (int)req->arg0, (int)req->arg1);
break; break;
case UV_FS_CLOSE: case UV_FS_CLOSE:
fs__close(req, (uv_file)req->arg0); fs__close(req, (uv_file)req->arg0);
@ -664,26 +665,26 @@ static DWORD WINAPI uv_fs_thread_proc(void* parameter) {
(off_t) req->arg3); (off_t) req->arg3);
break; break;
case UV_FS_UNLINK: case UV_FS_UNLINK:
fs__unlink(req, (const char*)req->arg0); fs__unlink(req, req->path);
break; break;
case UV_FS_MKDIR: case UV_FS_MKDIR:
fs__mkdir(req, (const char*)req->arg0, (int)req->arg1); fs__mkdir(req, req->path, (int)req->arg0);
break; break;
case UV_FS_RMDIR: case UV_FS_RMDIR:
fs__rmdir(req, (const char*)req->arg0); fs__rmdir(req, req->path);
break; break;
case UV_FS_READDIR: case UV_FS_READDIR:
fs__readdir(req, (const char*)req->arg0, (int)req->arg1); fs__readdir(req, req->path, (int)req->arg0);
break; break;
case UV_FS_STAT: case UV_FS_STAT:
case UV_FS_LSTAT: case UV_FS_LSTAT:
fs__stat(req, (const char*)req->arg0); fs__stat(req, req->path);
break; break;
case UV_FS_FSTAT: case UV_FS_FSTAT:
fs__fstat(req, (uv_file)req->arg0); fs__fstat(req, (uv_file)req->arg0);
break; break;
case UV_FS_RENAME: case UV_FS_RENAME:
fs__rename(req, (const char*)req->arg0, (const char*)req->arg1); fs__rename(req, req->path, (const char*)req->arg0);
break; break;
case UV_FS_FSYNC: case UV_FS_FSYNC:
case UV_FS_FDATASYNC: case UV_FS_FDATASYNC:
@ -700,25 +701,25 @@ static DWORD WINAPI uv_fs_thread_proc(void* parameter) {
(size_t) req->arg3); (size_t) req->arg3);
break; break;
case UV_FS_CHMOD: case UV_FS_CHMOD:
fs__chmod(req, (const char*)req->arg0, (int)req->arg1); fs__chmod(req, req->path, (int)req->arg0);
break; break;
case UV_FS_FCHMOD: case UV_FS_FCHMOD:
fs__fchmod(req, (uv_file)req->arg0, (int)req->arg1); fs__fchmod(req, (uv_file)req->arg0, (int)req->arg1);
break; break;
case UV_FS_UTIME: case UV_FS_UTIME:
fs__utime(req, (const char*)req->arg0, req->arg4, req->arg5); fs__utime(req, req->path, req->arg4, req->arg5);
break; break;
case UV_FS_FUTIME: case UV_FS_FUTIME:
fs__futime(req, (uv_file)req->arg0, req->arg4, req->arg5); fs__futime(req, (uv_file)req->arg0, req->arg4, req->arg5);
break; break;
case UV_FS_LINK: case UV_FS_LINK:
fs__link(req, (const char*)req->arg0, (const char*)req->arg1); fs__link(req, req->path, (const char*)req->arg0);
break; break;
case UV_FS_SYMLINK: case UV_FS_SYMLINK:
fs__symlink(req, (const char*)req->arg0, (const char*)req->arg1, (int)req->arg2); fs__symlink(req, req->path, (const char*)req->arg0, (int)req->arg1);
break; break;
case UV_FS_READLINK: case UV_FS_READLINK:
fs__readlink(req, (const char*)req->arg0); fs__readlink(req, req->path);
break; break;
case UV_FS_CHOWN: case UV_FS_CHOWN:
case UV_FS_FCHOWN: case UV_FS_FCHOWN:
@ -737,9 +738,8 @@ static DWORD WINAPI uv_fs_thread_proc(void* parameter) {
int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
int mode, uv_fs_cb cb) { int mode, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_OPEN, cb); uv_fs_req_init_async(loop, req, UV_FS_OPEN, path, cb);
WRAP_REQ_ARGS3(req, path, flags, mode); WRAP_REQ_ARGS2(req, flags, mode);
STRDUP_ARG(req, 0);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
uv_fs_req_init_sync(loop, req, UV_FS_OPEN); uv_fs_req_init_sync(loop, req, UV_FS_OPEN);
@ -753,7 +753,7 @@ int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_CLOSE, cb); uv_fs_req_init_async(loop, req, UV_FS_CLOSE, NULL, cb);
WRAP_REQ_ARGS1(req, file); WRAP_REQ_ARGS1(req, file);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
@ -769,7 +769,7 @@ int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf, int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf,
size_t length, off_t offset, uv_fs_cb cb) { size_t length, off_t offset, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_READ, cb); uv_fs_req_init_async(loop, req, UV_FS_READ, NULL, cb);
WRAP_REQ_ARGS4(req, file, buf, length, offset); WRAP_REQ_ARGS4(req, file, buf, length, offset);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
@ -785,7 +785,7 @@ int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf,
int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf, int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf,
size_t length, off_t offset, uv_fs_cb cb) { size_t length, off_t offset, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_WRITE, cb); uv_fs_req_init_async(loop, req, UV_FS_WRITE, NULL, cb);
WRAP_REQ_ARGS4(req, file, buf, length, offset); WRAP_REQ_ARGS4(req, file, buf, length, offset);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
@ -801,9 +801,7 @@ int uv_fs_write(uv_loop_t* loop, uv_fs_t* req, uv_file file, void* buf,
int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
uv_fs_cb cb) { uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_UNLINK, cb); uv_fs_req_init_async(loop, req, UV_FS_UNLINK, path, cb);
WRAP_REQ_ARGS1(req, path);
STRDUP_ARG(req, 0);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
uv_fs_req_init_sync(loop, req, UV_FS_UNLINK); uv_fs_req_init_sync(loop, req, UV_FS_UNLINK);
@ -818,9 +816,8 @@ int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
uv_fs_cb cb) { uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_MKDIR, cb); uv_fs_req_init_async(loop, req, UV_FS_MKDIR, path, cb);
WRAP_REQ_ARGS2(req, path, mode); WRAP_REQ_ARGS1(req, mode);
STRDUP_ARG(req, 0);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
uv_fs_req_init_sync(loop, req, UV_FS_MKDIR); uv_fs_req_init_sync(loop, req, UV_FS_MKDIR);
@ -834,9 +831,7 @@ int uv_fs_mkdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) { int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_RMDIR, cb); uv_fs_req_init_async(loop, req, UV_FS_RMDIR, path, cb);
WRAP_REQ_ARGS1(req, path);
STRDUP_ARG(req, 0);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
uv_fs_req_init_sync(loop, req, UV_FS_RMDIR); uv_fs_req_init_sync(loop, req, UV_FS_RMDIR);
@ -851,9 +846,8 @@ int uv_fs_rmdir(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags, int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
uv_fs_cb cb) { uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_READDIR, cb); uv_fs_req_init_async(loop, req, UV_FS_READDIR, path, cb);
WRAP_REQ_ARGS2(req, path, flags); WRAP_REQ_ARGS1(req, flags);
STRDUP_ARG(req, 0);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
uv_fs_req_init_sync(loop, req, UV_FS_READDIR); uv_fs_req_init_sync(loop, req, UV_FS_READDIR);
@ -868,10 +862,9 @@ int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path, int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path,
const char* new_path, uv_fs_cb cb) { const char* new_path, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_LINK, cb); uv_fs_req_init_async(loop, req, UV_FS_LINK, path, cb);
WRAP_REQ_ARGS2(req, path, new_path); WRAP_REQ_ARGS1(req, new_path);
STRDUP_ARG(req, 0); STRDUP_ARG(req, 0);
STRDUP_ARG(req, 1);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
uv_fs_req_init_sync(loop, req, UV_FS_LINK); uv_fs_req_init_sync(loop, req, UV_FS_LINK);
@ -886,10 +879,9 @@ int uv_fs_link(uv_loop_t* loop, uv_fs_t* req, const char* path,
int uv_fs_symlink(uv_loop_t* loop, uv_fs_t* req, const char* path, int uv_fs_symlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
const char* new_path, int flags, uv_fs_cb cb) { const char* new_path, int flags, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_SYMLINK, cb); uv_fs_req_init_async(loop, req, UV_FS_SYMLINK, path, cb);
WRAP_REQ_ARGS3(req, path, new_path, flags); WRAP_REQ_ARGS2(req, new_path, flags);
STRDUP_ARG(req, 0); STRDUP_ARG(req, 0);
STRDUP_ARG(req, 1);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
uv_fs_req_init_sync(loop, req, UV_FS_SYMLINK); uv_fs_req_init_sync(loop, req, UV_FS_SYMLINK);
@ -904,9 +896,7 @@ int uv_fs_symlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path, int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
uv_fs_cb cb) { uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_READLINK, cb); uv_fs_req_init_async(loop, req, UV_FS_READLINK, path, cb);
WRAP_REQ_ARGS1(req, path);
STRDUP_ARG(req, 0);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
uv_fs_req_init_sync(loop, req, UV_FS_READLINK); uv_fs_req_init_sync(loop, req, UV_FS_READLINK);
@ -921,9 +911,8 @@ int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, int uid, int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, int uid,
int gid, uv_fs_cb cb) { int gid, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_CHOWN, cb); uv_fs_req_init_async(loop, req, UV_FS_CHOWN, path, cb);
WRAP_REQ_ARGS3(req, path, uid, gid); WRAP_REQ_ARGS2(req, uid, gid);
STRDUP_ARG(req, 0);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
uv_fs_req_init_sync(loop, req, UV_FS_CHOWN); uv_fs_req_init_sync(loop, req, UV_FS_CHOWN);
@ -938,7 +927,7 @@ int uv_fs_chown(uv_loop_t* loop, uv_fs_t* req, const char* path, int uid,
int uv_fs_fchown(uv_loop_t* loop, uv_fs_t* req, uv_file file, int uid, int uv_fs_fchown(uv_loop_t* loop, uv_fs_t* req, uv_file file, int uid,
int gid, uv_fs_cb cb) { int gid, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_FCHOWN, cb); uv_fs_req_init_async(loop, req, UV_FS_FCHOWN, NULL, cb);
WRAP_REQ_ARGS3(req, file, uid, gid); WRAP_REQ_ARGS3(req, file, uid, gid);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
@ -966,13 +955,11 @@ int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
} }
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_STAT, cb); uv_fs_req_init_async(loop, req, UV_FS_STAT, NULL, cb);
if (path2) { if (path2) {
WRAP_REQ_ARGS1(req, path2); req->path = path2;
req->flags |= UV_FS_FREE_ARG0;
} else { } else {
WRAP_REQ_ARGS1(req, path); req->path = strdup(path);
STRDUP_ARG(req, 0);
} }
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
@ -1005,13 +992,11 @@ int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
} }
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_LSTAT, cb); uv_fs_req_init_async(loop, req, UV_FS_LSTAT, NULL, cb);
if (path2) { if (path2) {
WRAP_REQ_ARGS1(req, path2); req->path = path2;
req->flags |= UV_FS_FREE_ARG0;
} else { } else {
WRAP_REQ_ARGS1(req, path); req->path = strdup(path);
STRDUP_ARG(req, 0);
} }
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
@ -1030,7 +1015,7 @@ int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_FSTAT, cb); uv_fs_req_init_async(loop, req, UV_FS_FSTAT, NULL, cb);
WRAP_REQ_ARGS1(req, file); WRAP_REQ_ARGS1(req, file);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
@ -1046,10 +1031,9 @@ int uv_fs_fstat(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path, int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path,
const char* new_path, uv_fs_cb cb) { const char* new_path, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_RENAME, cb); uv_fs_req_init_async(loop, req, UV_FS_RENAME, path, cb);
WRAP_REQ_ARGS2(req, path, new_path); WRAP_REQ_ARGS1(req, new_path);
STRDUP_ARG(req, 0); STRDUP_ARG(req, 0);
STRDUP_ARG(req, 1);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
uv_fs_req_init_sync(loop, req, UV_FS_RENAME); uv_fs_req_init_sync(loop, req, UV_FS_RENAME);
@ -1063,7 +1047,7 @@ int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path,
int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_FDATASYNC, cb); uv_fs_req_init_async(loop, req, UV_FS_FDATASYNC, NULL, cb);
WRAP_REQ_ARGS1(req, file); WRAP_REQ_ARGS1(req, file);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
@ -1078,7 +1062,7 @@ int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) { int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_FSYNC, cb); uv_fs_req_init_async(loop, req, UV_FS_FSYNC, NULL, cb);
WRAP_REQ_ARGS1(req, file); WRAP_REQ_ARGS1(req, file);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
@ -1094,7 +1078,7 @@ int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file file, int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file file,
off_t offset, uv_fs_cb cb) { off_t offset, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_FTRUNCATE, cb); uv_fs_req_init_async(loop, req, UV_FS_FTRUNCATE, NULL, cb);
WRAP_REQ_ARGS2(req, file, offset); WRAP_REQ_ARGS2(req, file, offset);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
@ -1110,7 +1094,7 @@ int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file file,
int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file out_fd, int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file out_fd,
uv_file in_fd, off_t in_offset, size_t length, uv_fs_cb cb) { uv_file in_fd, off_t in_offset, size_t length, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_SENDFILE, cb); uv_fs_req_init_async(loop, req, UV_FS_SENDFILE, NULL, cb);
WRAP_REQ_ARGS4(req, out_fd, in_fd, in_offset, length); WRAP_REQ_ARGS4(req, out_fd, in_fd, in_offset, length);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
@ -1126,9 +1110,8 @@ int uv_fs_sendfile(uv_loop_t* loop, uv_fs_t* req, uv_file out_fd,
int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode, int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
uv_fs_cb cb) { uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_CHMOD, cb); uv_fs_req_init_async(loop, req, UV_FS_CHMOD, path, cb);
WRAP_REQ_ARGS2(req, path, mode); WRAP_REQ_ARGS1(req, mode);
STRDUP_ARG(req, 0);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
uv_fs_req_init_sync(loop, req, UV_FS_CHMOD); uv_fs_req_init_sync(loop, req, UV_FS_CHMOD);
@ -1143,7 +1126,7 @@ int uv_fs_chmod(uv_loop_t* loop, uv_fs_t* req, const char* path, int mode,
int uv_fs_fchmod(uv_loop_t* loop, uv_fs_t* req, uv_file file, int mode, int uv_fs_fchmod(uv_loop_t* loop, uv_fs_t* req, uv_file file, int mode,
uv_fs_cb cb) { uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_FCHMOD, cb); uv_fs_req_init_async(loop, req, UV_FS_FCHMOD, NULL, cb);
WRAP_REQ_ARGS2(req, file, mode); WRAP_REQ_ARGS2(req, file, mode);
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
} else { } else {
@ -1159,9 +1142,7 @@ int uv_fs_fchmod(uv_loop_t* loop, uv_fs_t* req, uv_file file, int mode,
int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime, int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime,
double mtime, uv_fs_cb cb) { double mtime, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_UTIME, cb); uv_fs_req_init_async(loop, req, UV_FS_UTIME, path, cb);
WRAP_REQ_ARGS1(req, path);
STRDUP_ARG(req, 0);
req->arg4 = (ssize_t)atime; req->arg4 = (ssize_t)atime;
req->arg5 = (ssize_t)mtime; req->arg5 = (ssize_t)mtime;
QUEUE_FS_TP_JOB(loop, req); QUEUE_FS_TP_JOB(loop, req);
@ -1178,7 +1159,7 @@ int uv_fs_utime(uv_loop_t* loop, uv_fs_t* req, const char* path, double atime,
int uv_fs_futime(uv_loop_t* loop, uv_fs_t* req, uv_file file, double atime, int uv_fs_futime(uv_loop_t* loop, uv_fs_t* req, uv_file file, double atime,
double mtime, uv_fs_cb cb) { double mtime, uv_fs_cb cb) {
if (cb) { if (cb) {
uv_fs_req_init_async(loop, req, UV_FS_FUTIME, cb); uv_fs_req_init_async(loop, req, UV_FS_FUTIME, NULL, cb);
WRAP_REQ_ARGS1(req, file); WRAP_REQ_ARGS1(req, file);
req->arg4 = (ssize_t)atime; req->arg4 = (ssize_t)atime;
req->arg5 = (ssize_t)mtime; req->arg5 = (ssize_t)mtime;
@ -1223,6 +1204,11 @@ void uv_fs_req_cleanup(uv_fs_t* req) {
req->ptr = NULL; req->ptr = NULL;
if (req->path) {
free(req->path);
req->path = NULL;
}
if (req->flags & UV_FS_ASYNC_QUEUED) { if (req->flags & UV_FS_ASYNC_QUEUED) {
uv_unref(loop); uv_unref(loop);
} }

10
deps/uv/test/test-fs.c
View File

@ -36,7 +36,7 @@
# include <io.h> # include <io.h>
# define unlink _unlink # define unlink _unlink
# define rmdir _rmdir # define rmdir _rmdir
# define stat _stat # define stat _stati64
# define open _open # define open _open
# define write _write # define write _write
# define lseek _lseek # define lseek _lseek
@ -550,8 +550,12 @@ TEST_IMPL(fs_async_dir) {
/* sync uv_fs_readdir */ /* sync uv_fs_readdir */
r = uv_fs_readdir(loop, &readdir_req, "test_dir", 0, NULL); r = uv_fs_readdir(loop, &readdir_req, "test_dir", 0, NULL);
readdir_cb(&readdir_req); ASSERT(readdir_req.result == 2);
ASSERT(readdir_req.ptr);
ASSERT(memcmp(readdir_req.ptr, "file1\0file2\0", 12) == 0
|| memcmp(readdir_req.ptr, "file2\0file1\0", 12) == 0);
uv_fs_req_cleanup(&readdir_req);
ASSERT(!readdir_req.ptr);
r = uv_fs_stat(loop, &stat_req, "test_dir", stat_cb); r = uv_fs_stat(loop, &stat_req, "test_dir", stat_cb);
ASSERT(r == 0); ASSERT(r == 0);

Write Preview
Loading…
Cancel
Save