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 991f6ee

Ryan Dahl 14 years ago
parent
b5d58f11cb
commit
7272dbdbc6
4 changed files with 141 additions and 12 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      deps/uv/include/uv.h
  2. 31
      deps/uv/src/unix/fs.c
  3. 112
      deps/uv/src/win/fs.c
  4. 9
      deps/uv/test/test-fs.c

1
deps/uv/include/uv.h
View File

@ -890,6 +890,7 @@ struct uv_fs_s {
uv_fs_cb cb;
ssize_t result;
void* ptr;
char* path;
int errorno;
UV_FS_PRIVATE_FIELDS
};

31
deps/uv/src/unix/fs.c
View File

@ -40,7 +40,7 @@
#define ARGS4(a,b,c,d) (a), (b), (c), (d)
#define WRAP_EIO(type, eiofunc, func, args) \
uv_fs_req_init(loop, req, type, cb); \
uv_fs_req_init(loop, req, type, path, cb); \
if (cb) { \
/* async */ \
uv_ref(loop); \
@ -61,7 +61,7 @@
static void uv_fs_req_init(uv_loop_t* loop, uv_fs_t* req, uv_fs_type fs_type,
uv_fs_cb cb) {
char* path, uv_fs_cb cb) {
/* Make sure the thread pool is initialized. */
uv_eio_init(loop);
@ -72,12 +72,16 @@ static void uv_fs_req_init(uv_loop_t* loop, uv_fs_t* req, uv_fs_type fs_type,
req->cb = cb;
req->result = 0;
req->ptr = NULL;
req->path = path ? strdup(path) : NULL;
req->errorno = 0;
req->eio = NULL;
}
void uv_fs_req_cleanup(uv_fs_t* req) {
free(req->path);
req->path = NULL;
switch (req->fs_type) {
case UV_FS_READDIR:
assert(req->ptr);
@ -168,13 +172,14 @@ static int uv__fs_after(eio_req* eio) {
int uv_fs_close(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
char* path = NULL;
WRAP_EIO(UV_FS_CLOSE, eio_close, close, ARGS1(file));
}
int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
int mode, uv_fs_cb cb) {
uv_fs_req_init(loop, req, UV_FS_OPEN, cb);
uv_fs_req_init(loop, req, UV_FS_OPEN, path, cb);
if (cb) {
/* async */
@ -202,7 +207,7 @@ int uv_fs_open(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
int uv_fs_read(uv_loop_t* loop, uv_fs_t* req, uv_file fd, void* buf,
size_t length, off_t offset, uv_fs_cb cb) {
uv_fs_req_init(loop, req, UV_FS_READ, cb);
uv_fs_req_init(loop, req, UV_FS_READ, NULL, cb);
if (cb) {
/* async */
@ -238,7 +243,7 @@ int uv_fs_unlink(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
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) {
uv_fs_req_init(loop, req, UV_FS_WRITE, cb);
uv_fs_req_init(loop, req, UV_FS_WRITE, NULL, cb);
if (cb) {
/* async */
@ -284,7 +289,7 @@ int uv_fs_readdir(uv_loop_t* loop, uv_fs_t* req, const char* path, int flags,
size_t size = 0;
size_t d_namlen = 0;
uv_fs_req_init(loop, req, UV_FS_READDIR, cb);
uv_fs_req_init(loop, req, UV_FS_READDIR, path, cb);
if (cb) {
/* async */
@ -340,7 +345,7 @@ int uv_fs_stat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
char* pathdup = path;
int pathlen;
uv_fs_req_init(loop, req, UV_FS_STAT, cb);
uv_fs_req_init(loop, req, UV_FS_STAT, path, cb);
/* TODO do this without duplicating the string. */
/* TODO security */
@ -383,7 +388,7 @@ int uv_fs_stat(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) {
uv_fs_req_init(loop, req, UV_FS_FSTAT, cb);
uv_fs_req_init(loop, req, UV_FS_FSTAT, NULL, cb);
if (cb) {
/* async */
@ -418,23 +423,27 @@ int uv_fs_rename(uv_loop_t* loop, uv_fs_t* req, const char* path, const char* ne
int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
char* path = NULL;
WRAP_EIO(UV_FS_FSYNC, eio_fsync, fsync, ARGS1(file))
}
int uv_fs_fdatasync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
char* path = NULL;
WRAP_EIO(UV_FS_FDATASYNC, eio_fdatasync, fdatasync, ARGS1(file))
}
int uv_fs_ftruncate(uv_loop_t* loop, uv_fs_t* req, uv_file file, off_t offset,
uv_fs_cb cb) {
char* path = NULL;
WRAP_EIO(UV_FS_FTRUNCATE, eio_ftruncate, ftruncate, ARGS2(file, offset))
}
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) {
char* path = NULL;
WRAP_EIO(UV_FS_SENDFILE, eio_sendfile, eio_sendfile_sync,
ARGS4(out_fd, in_fd, in_offset, length))
}
@ -471,7 +480,7 @@ int uv_fs_lstat(uv_loop_t* loop, uv_fs_t* req, const char* path, uv_fs_cb cb) {
char* pathdup = path;
int pathlen;
uv_fs_req_init(loop, req, UV_FS_LSTAT, cb);
uv_fs_req_init(loop, req, UV_FS_LSTAT, path, cb);
/* TODO do this without duplicating the string. */
/* TODO security */
@ -533,7 +542,7 @@ int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
status = -1;
uv_fs_req_init(loop, req, UV_FS_READLINK, cb);
uv_fs_req_init(loop, req, UV_FS_READLINK, path, cb);
if (cb) {
if ((req->eio = eio_readlink(path, EIO_PRI_DEFAULT, uv__fs_after, req))) {
@ -581,6 +590,7 @@ int uv_fs_readlink(uv_loop_t* loop, uv_fs_t* req, const char* path,
int uv_fs_fchmod(uv_loop_t* loop, uv_fs_t* req, uv_file file, int mode,
uv_fs_cb cb) {
char* path = NULL;
WRAP_EIO(UV_FS_FCHMOD, eio_fchmod, fchmod, ARGS2(file, mode))
}
@ -593,6 +603,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 gid,
uv_fs_cb cb) {
char* path = NULL;
WRAP_EIO(UV_FS_FCHOWN, eio_fchown, fchown, ARGS3(file, uid, gid))
}

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

@ -97,6 +97,7 @@ static void uv_fs_req_init_async(uv_loop_t* loop, uv_fs_t* req,
req->cb = cb;
req->result = 0;
req->ptr = NULL;
req->path = NULL; /* TODO https://github.com/joyent/libuv/issues/177 */
req->errorno = 0;
req->last_error = 0;
memset(&req->overlapped, 0, sizeof(req->overlapped));
@ -115,12 +116,119 @@ static void uv_fs_req_init_sync(uv_loop_t* loop, uv_fs_t* req,
req->errorno = 0;
}
/* this is where the CRT stores the current umask */
extern int _umaskval;
void fs__open(uv_fs_t* req, const char* path, int flags, int mode) {
int result = _open(path, flags, mode);
SET_REQ_RESULT(req, result);
DWORD access;
DWORD share;
SECURITY_ATTRIBUTES sa;
DWORD disposition;
DWORD attributes;
HANDLE file;
int result;
/* convert flags and mode to CreateFile parameters */
switch (flags & (_O_RDONLY | _O_WRONLY | _O_RDWR)) {
case _O_RDONLY:
access = GENERIC_READ;
break;
case _O_WRONLY:
access = GENERIC_WRITE;
break;
case _O_RDWR:
access = GENERIC_READ | GENERIC_WRITE;
break;
default:
result = -1;
goto end;
}
/*
* Here is where we deviate significantly from what CRT's _open()
* does. We indiscriminately use all the sharing modes, to match
* UNIX semantics. In particular, this ensures that the file can
* be deleted even whilst it's open, fixing issue #1449.
*/
share = FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE;
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.lpSecurityDescriptor = NULL;
if (flags & _O_NOINHERIT) {
sa.bInheritHandle = FALSE;
} else {
sa.bInheritHandle = TRUE;
}
switch (flags & (_O_CREAT | _O_EXCL | _O_TRUNC)) {
case 0:
case _O_EXCL:
disposition = OPEN_EXISTING;
break;
case _O_CREAT:
disposition = OPEN_ALWAYS;
break;
case _O_CREAT | _O_EXCL:
case _O_CREAT | _O_TRUNC | _O_EXCL:
disposition = CREATE_NEW;
break;
case _O_TRUNC:
case _O_TRUNC | _O_EXCL:
disposition = TRUNCATE_EXISTING;
break;
case _O_CREAT | _O_TRUNC:
disposition = CREATE_ALWAYS;
break;
default:
result = -1;
goto end;
}
attributes = FILE_ATTRIBUTE_NORMAL;
if (flags & _O_CREAT) {
if (!((mode & ~_umaskval) & _S_IWRITE)) {
attributes |= FILE_ATTRIBUTE_READONLY;
}
}
if (flags & _O_TEMPORARY ) {
attributes |= FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_TEMPORARY;
access |= DELETE;
}
if (flags & _O_SHORT_LIVED) {
attributes |= FILE_ATTRIBUTE_TEMPORARY;
}
switch (flags & (_O_SEQUENTIAL | _O_RANDOM)) {
case 0:
break;
case _O_SEQUENTIAL:
attributes |= FILE_FLAG_SEQUENTIAL_SCAN;
break;
case _O_RANDOM:
attributes |= FILE_FLAG_RANDOM_ACCESS;
break;
default:
result = -1;
goto end;
}
file = CreateFileA(path,
access,
share,
&sa,
disposition,
attributes,
NULL);
if (file == INVALID_HANDLE_VALUE) {
result = -1;
goto end;
}
result = _open_osfhandle((intptr_t)file, flags);
end:
SET_REQ_RESULT(req, result);
}
void fs__close(uv_fs_t* req, uv_file file) {
int result = _close(file);

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

@ -240,6 +240,8 @@ static void open_cb(uv_fs_t* req) {
ASSERT(0);
}
open_cb_count++;
ASSERT(req->path);
ASSERT(memcmp(req->path, "test_file2\0", 11) == 0);
uv_fs_req_cleanup(req);
memset(buf, 0, sizeof(buf));
r = uv_fs_read(loop, &read_req, open_req1.result, buf, sizeof(buf), -1,
@ -306,6 +308,8 @@ static void mkdir_cb(uv_fs_t* req) {
ASSERT(req->fs_type == UV_FS_MKDIR);
ASSERT(req->result != -1);
mkdir_cb_count++;
ASSERT(req->path);
ASSERT(memcmp(req->path, "test_dir\0", 9) == 0);
uv_fs_req_cleanup(req);
}
@ -315,6 +319,8 @@ static void rmdir_cb(uv_fs_t* req) {
ASSERT(req->fs_type == UV_FS_RMDIR);
ASSERT(req->result != -1);
rmdir_cb_count++;
ASSERT(req->path);
ASSERT(memcmp(req->path, "test_dir\0", 9) == 0);
uv_fs_req_cleanup(req);
}
@ -327,6 +333,8 @@ static void readdir_cb(uv_fs_t* req) {
ASSERT(memcmp(req->ptr, "file1\0file2\0", 12) == 0
|| memcmp(req->ptr, "file2\0file1\0", 12) == 0);
readdir_cb_count++;
ASSERT(req->path);
ASSERT(memcmp(req->path, "test_dir\0", 9) == 0);
uv_fs_req_cleanup(req);
ASSERT(!req->ptr);
}
@ -544,6 +552,7 @@ TEST_IMPL(fs_async_dir) {
r = uv_fs_readdir(loop, &readdir_req, "test_dir", 0, NULL);
readdir_cb(&readdir_req);
r = uv_fs_stat(loop, &stat_req, "test_dir", stat_cb);
ASSERT(r == 0);
uv_run(loop);

Write Preview
Loading…
Cancel
Save