mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-02-19 07:48:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

std.event.fs.preadv windows implementation

Browse Source
This commit is contained in:
Andrew Kelley 2018-08-08 16:55:19 -04:00
parent 8b456927be
commit c63ec9886a
4 changed files with 175 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

226
std/event/fs.zig
View File

@ -89,9 +89,10 @@ pub async fn pwritevWindows(loop: *Loop, fd: os.FileHandle, data: []const []cons
if (data.len == 0) return;
if (data.len == 1) return await (async pwriteWindows(loop, fd, data[0], offset) catch unreachable);
const data_copy = std.mem.dupe(loop.allocator, []const u8, data);
const data_copy = try std.mem.dupe(loop.allocator, []const u8, data);
defer loop.allocator.free(data_copy);
// TODO do these in parallel
var off = offset;
for (data_copy) |buf| {
try await (async pwriteWindows(loop, fd, buf, off) catch unreachable);
@ -120,6 +121,9 @@ pub async fn pwriteWindows(loop: *Loop, fd: os.FileHandle, data: []const u8, off
.OffsetHigh = @truncate(u32, offset >> 32),
.hEvent = null,
};
loop.beginOneEvent();
errdefer loop.finishOneEvent();
errdefer {
_ = windows.CancelIoEx(fd, &overlapped);
}
@ -192,9 +196,89 @@ pub async fn pwritevPosix(loop: *Loop, fd: os.FileHandle, data: []const []const
/// data - just the inner references - must live until preadv promise completes.
pub async fn preadv(loop: *Loop, fd: os.FileHandle, data: []const []u8, offset: usize) !usize {
//const data_dupe = try mem.dupe(loop.allocator, []const u8, data);
//defer loop.allocator.free(data_dupe);
assert(data.len != 0);
switch (builtin.os) {
builtin.Os.macosx,
builtin.Os.linux,
=> return await (async preadvPosix(loop, fd, data, offset) catch unreachable),
builtin.Os.windows,
=> return await (async preadvWindows(loop, fd, data, offset) catch unreachable),
else => @compileError("Unsupported OS"),
}
}
pub async fn preadvWindows(loop: *Loop, fd: os.FileHandle, data: []const []u8, offset: u64) !usize {
assert(data.len != 0);
if (data.len == 1) return await (async preadWindows(loop, fd, data[0], offset) catch unreachable);
const data_copy = try std.mem.dupe(loop.allocator, []u8, data);
defer loop.allocator.free(data_copy);
// TODO do these in parallel?
var off: usize = 0;
var iov_i: usize = 0;
var inner_off: usize = 0;
while (true) {
const v = data_copy[iov_i];
const amt_read = try await (async preadWindows(loop, fd, v[inner_off .. v.len-inner_off], offset + off) catch unreachable);
off += amt_read;
inner_off += amt_read;
if (inner_off == v.len) {
iov_i += 1;
inner_off = 0;
if (iov_i == data_copy.len) {
return off;
}
}
if (amt_read == 0) return off; // EOF
}
}
pub async fn preadWindows(loop: *Loop, fd: os.FileHandle, data: []u8, offset: u64) !usize {
// workaround for https://github.com/ziglang/zig/issues/1194
suspend {
resume @handle();
}
var resume_node = Loop.ResumeNode.Basic{
.base = Loop.ResumeNode{
.id = Loop.ResumeNode.Id.Basic,
.handle = @handle(),
},
};
const completion_key = @ptrToInt(&resume_node.base);
_ = try os.windowsCreateIoCompletionPort(fd, loop.os_data.io_port, completion_key, undefined);
var overlapped = windows.OVERLAPPED{
.Internal = 0,
.InternalHigh = 0,
.Offset = @truncate(u32, offset),
.OffsetHigh = @truncate(u32, offset >> 32),
.hEvent = null,
};
loop.beginOneEvent();
errdefer loop.finishOneEvent();
errdefer {
_ = windows.CancelIoEx(fd, &overlapped);
}
suspend {
_ = windows.ReadFile(fd, data.ptr, @intCast(windows.DWORD, data.len), null, &overlapped);
}
var bytes_transferred: windows.DWORD = undefined;
if (windows.GetOverlappedResult(fd, &overlapped, &bytes_transferred, windows.FALSE) == 0) {
const err = windows.GetLastError();
return switch (err) {
windows.ERROR.IO_PENDING => unreachable,
windows.ERROR.OPERATION_ABORTED => error.OperationAborted,
windows.ERROR.BROKEN_PIPE => error.BrokenPipe,
else => os.unexpectedErrorWindows(err),
};
}
return usize(bytes_transferred);
}
/// data - just the inner references - must live until preadv promise completes.
pub async fn preadvPosix(loop: *Loop, fd: os.FileHandle, data: []const []u8, offset: usize) !usize {
// workaround for https://github.com/ziglang/zig/issues/1194
suspend {
resume @handle();
@ -287,8 +371,23 @@ pub async fn openPosix(
}
pub async fn openRead(loop: *Loop, path: []const u8) os.File.OpenError!os.FileHandle {
const flags = posix.O_LARGEFILE | posix.O_RDONLY | posix.O_CLOEXEC;
return await (async openPosix(loop, path, flags, os.File.default_mode) catch unreachable);
switch (builtin.os) {
builtin.Os.macosx, builtin.Os.linux => {
const flags = posix.O_LARGEFILE | posix.O_RDONLY | posix.O_CLOEXEC;
return await (async openPosix(loop, path, flags, os.File.default_mode) catch unreachable);
},
builtin.Os.windows => return os.windowsOpen(
loop.allocator,
path,
windows.GENERIC_READ,
windows.FILE_SHARE_READ,
windows.OPEN_EXISTING,
windows.FILE_ATTRIBUTE_NORMAL | windows.FILE_FLAG_OVERLAPPED,
),
else => @compileError("Unsupported OS"),
}
}
/// Creates if does not exist. Truncates the file if it exists.
@ -325,8 +424,23 @@ pub async fn openReadWrite(
path: []const u8,
mode: os.File.Mode,
) os.File.OpenError!os.FileHandle {
const flags = posix.O_LARGEFILE | posix.O_RDWR | posix.O_CREAT | posix.O_CLOEXEC;
return await (async openPosix(loop, path, flags, mode) catch unreachable);
switch (builtin.os) {
builtin.Os.macosx, builtin.Os.linux => {
const flags = posix.O_LARGEFILE | posix.O_RDWR | posix.O_CREAT | posix.O_CLOEXEC;
return await (async openPosix(loop, path, flags, mode) catch unreachable);
},
builtin.Os.windows => return os.windowsOpen(
loop.allocator,
path,
windows.GENERIC_WRITE|windows.GENERIC_READ,
windows.FILE_SHARE_WRITE | windows.FILE_SHARE_READ | windows.FILE_SHARE_DELETE,
windows.OPEN_ALWAYS,
windows.FILE_ATTRIBUTE_NORMAL | windows.FILE_FLAG_OVERLAPPED,
),
else => @compileError("Unsupported OS"),
}
}
/// This abstraction helps to close file handles in defer expressions
@ -340,62 +454,64 @@ pub const CloseOperation = struct {
os_data: OsData,
const OsData = switch (builtin.os) {
builtin.Os.linux,
builtin.Os.macosx,
=> struct {
have_fd: bool,
close_req_node: RequestNode,
},
builtin.Os.windows,
=> struct {
builtin.Os.linux, builtin.Os.macosx => OsDataPosix,
builtin.Os.windows => struct {
handle: ?os.FileHandle,
},
else => @compileError("Unsupported OS"),
};
const OsDataPosix = struct {
have_fd: bool,
close_req_node: RequestNode,
};
pub fn start(loop: *Loop) (error{OutOfMemory}!*CloseOperation) {
const self = try loop.allocator.createOne(CloseOperation);
self.* = CloseOperation{
.loop = loop,
.os_data = switch (builtin.os) {
builtin.Os.linux,
builtin.Os.macosx,
=> OsData{
.have_fd = false,
.close_req_node = RequestNode{
.prev = null,
.next = null,
.data = Request{
.msg = Request.Msg{
.Close = Request.Msg.Close{ .fd = undefined },
},
.finish = Request.Finish{ .DeallocCloseOperation = self },
},
},
},
builtin.Os.windows,
=> OsData{ .handle = null },
builtin.Os.linux, builtin.Os.macosx => initOsDataPosix(self),
builtin.Os.windows => OsData{ .handle = null },
else => @compileError("Unsupported OS"),
},
};
return self;
}
fn initOsDataPosix(self: *CloseOperation) OsData {
return OsData{
.have_fd = false,
.close_req_node = RequestNode{
.prev = null,
.next = null,
.data = Request{
.msg = Request.Msg{
.Close = Request.Msg.Close{ .fd = undefined },
},
.finish = Request.Finish{ .DeallocCloseOperation = self },
},
},
};
}
/// Defer this after creating.
pub fn finish(self: *CloseOperation) void {
switch (builtin.os) {
builtin.Os.linux,
builtin.Os.macosx,
=> {
if (self.have_fd) {
self.loop.posixFsRequest(&self.close_req_node);
if (self.os_data.have_fd) {
self.loop.posixFsRequest(&self.os_data.close_req_node);
} else {
self.loop.allocator.destroy(self);
}
},
builtin.Os.windows,
=> {
if (self.handle) |handle| {
if (self.os_data.handle) |handle| {
os.close(handle);
}
self.loop.allocator.destroy(self);
@ -409,12 +525,12 @@ pub const CloseOperation = struct {
builtin.Os.linux,
builtin.Os.macosx,
=> {
self.close_req_node.data.msg.Close.fd = handle;
self.have_fd = true;
self.os_data.close_req_node.data.msg.Close.fd = handle;
self.os_data.have_fd = true;
},
builtin.Os.windows,
=> {
self.handle = handle;
self.os_data.handle = handle;
},
else => @compileError("Unsupported OS"),
}
@ -426,11 +542,11 @@ pub const CloseOperation = struct {
builtin.Os.linux,
builtin.Os.macosx,
=> {
self.have_fd = false;
self.os_data.have_fd = false;
},
builtin.Os.windows,
=> {
self.handle = null;
self.os_data.handle = null;
},
else => @compileError("Unsupported OS"),
}
@ -441,12 +557,12 @@ pub const CloseOperation = struct {
builtin.Os.linux,
builtin.Os.macosx,
=> {
assert(self.have_fd);
return self.close_req_node.data.msg.Close.fd;
assert(self.os_data.have_fd);
return self.os_data.close_req_node.data.msg.Close.fd;
},
builtin.Os.windows,
=> {
return self.handle.?;
return self.os_data.handle.?;
},
else => @compileError("Unsupported OS"),
}
@ -949,15 +1065,15 @@ async fn testFsWatch(loop: *Loop) !void {
const read_contents = try await try async readFile(loop, file_path, 1024 * 1024);
assert(mem.eql(u8, read_contents, contents));
// now watch the file
var watch = try Watch(void).create(loop, 0);
defer watch.destroy();
//// now watch the file
//var watch = try Watch(void).create(loop, 0);
//defer watch.destroy();
assert((try await try async watch.addFile(file_path, {})) == null);
//assert((try await try async watch.addFile(file_path, {})) == null);
const ev = try async watch.channel.get();
var ev_consumed = false;
defer if (!ev_consumed) cancel ev;
//const ev = try async watch.channel.get();
//var ev_consumed = false;
//defer if (!ev_consumed) cancel ev;
// overwrite line 2
const fd = try await try async openReadWrite(loop, file_path, os.File.default_mode);
@ -967,11 +1083,11 @@ async fn testFsWatch(loop: *Loop) !void {
try await try async pwritev(loop, fd, []const []const u8{"lorem ipsum"}, line2_offset);
}
ev_consumed = true;
switch ((try await ev).id) {
WatchEventId.CloseWrite => {},
WatchEventId.Delete => @panic("wrong event"),
}
//ev_consumed = true;
//switch ((try await ev).id) {
// WatchEventId.CloseWrite => {},
// WatchEventId.Delete => @panic("wrong event"),
//}
const contents_updated = try await try async readFile(loop, file_path, 1024 * 1024);
assert(mem.eql(u8, contents_updated,

4
std/event/loop.zig
View File

@ -702,9 +702,7 @@ pub const Loop = struct {
},
}
resume handle;
if (resume_node_id == ResumeNode.Id.EventFd) {
self.finishOneEvent();
}
self.finishOneEvent();
},
else => @compileError("unsupported OS"),
}

2
std/os/file.zig
View File

@ -353,7 +353,7 @@ pub const File = struct {
while (index < buffer.len) {
const want_read_count = @intCast(windows.DWORD, math.min(windows.DWORD(@maxValue(windows.DWORD)), buffer.len - index));
var amt_read: windows.DWORD = undefined;
if (windows.ReadFile(self.handle, @ptrCast(*c_void, buffer.ptr + index), want_read_count, &amt_read, null) == 0) {
if (windows.ReadFile(self.handle, buffer.ptr + index, want_read_count, &amt_read, null) == 0) {
const err = windows.GetLastError();
return switch (err) {
windows.ERROR.OPERATION_ABORTED => continue,

4
std/os/windows/kernel32.zig
View File

@ -131,9 +131,9 @@ pub extern "kernel32" stdcallcc fn QueryPerformanceFrequency(lpFrequency: *LARGE
pub extern "kernel32" stdcallcc fn ReadFile(
in_hFile: HANDLE,
out_lpBuffer: *c_void,
out_lpBuffer: [*]u8,
in_nNumberOfBytesToRead: DWORD,
out_lpNumberOfBytesRead: *DWORD,
out_lpNumberOfBytesRead: ?*DWORD,
in_out_lpOverlapped: ?*OVERLAPPED,
) BOOL;