authorgravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-08-07 21:06:21-04:00
committergravatar for andrew@ziglang.orgAndrew Kelley <andrew@ziglang.org> 2018-08-07 21:06:21-04:00
log5cbfe392beb26520554e7ec6ae7c67df47cc7e04
treeb1a0091b0827ddba0acb5050ebcbfa889fada870
parent1a28f09684679ebc7006a4ba690f318be810c163

implement std.event.fs.Watch for macos

2 files changed, 300 insertions(+), 148 deletions(-)

std/event/fs.zig+234-110
......@@ -1,8 +1,10 @@
1const builtin = @import("builtin");
12const std = @import("../index.zig");
23const event = std.event;
34const assert = std.debug.assert;
45const os = std.os;
56const mem = std.mem;
7const posix = os.posix;
68
79pub const RequestNode = std.atomic.Queue(Request).Node;
810
......@@ -19,8 +21,7 @@ pub const Request = struct {
1921 pub const Msg = union(enum) {
2022 PWriteV: PWriteV,
2123 PReadV: PReadV,
22 OpenRead: OpenRead,
23 OpenRW: OpenRW,
24 Open: Open,
2425 Close: Close,
2526 WriteFile: WriteFile,
2627 End, // special - means the fs thread should exit
......@@ -43,19 +44,12 @@ pub const Request = struct {
4344 pub const Error = os.File.ReadError;
4445 };
4546
46 pub const OpenRead = struct {
47 pub const Open = struct {
4748 /// must be null terminated. TODO https://github.com/ziglang/zig/issues/265
4849 path: []const u8,
49 result: Error!os.FileHandle,
50
51 pub const Error = os.File.OpenError;
52 };
53
54 pub const OpenRW = struct {
55 /// must be null terminated. TODO https://github.com/ziglang/zig/issues/265
56 path: []const u8,
57 result: Error!os.FileHandle,
50 flags: u32,
5851 mode: os.File.Mode,
52 result: Error!os.FileHandle,
5953
6054 pub const Error = os.File.OpenError;
6155 };
......@@ -77,7 +71,7 @@ pub const Request = struct {
7771};
7872
7973/// data - just the inner references - must live until pwritev promise completes.
80pub async fn pwritev(loop: *event.Loop, fd: os.FileHandle, offset: usize, data: []const []const u8) !void {
74pub async fn pwritev(loop: *event.Loop, fd: os.FileHandle, data: []const []const u8, offset: usize) !void {
8175 // workaround for https://github.com/ziglang/zig/issues/1194
8276 suspend {
8377 resume @handle();
......@@ -94,8 +88,8 @@ pub async fn pwritev(loop: *event.Loop, fd: os.FileHandle, offset: usize, data:
9488 }
9589
9690 var req_node = RequestNode{
97 .prev = undefined,
98 .next = undefined,
91 .prev = null,
92 .next = null,
9993 .data = Request{
10094 .msg = Request.Msg{
10195 .PWriteV = Request.Msg.PWriteV{
......@@ -107,14 +101,16 @@ pub async fn pwritev(loop: *event.Loop, fd: os.FileHandle, offset: usize, data:
107101 },
108102 .finish = Request.Finish{
109103 .TickNode = event.Loop.NextTickNode{
110 .prev = undefined,
111 .next = undefined,
104 .prev = null,
105 .next = null,
112106 .data = @handle(),
113107 },
114108 },
115109 },
116110 };
117111
112 errdefer loop.posixFsCancel(&req_node);
113
118114 suspend {
119115 loop.posixFsRequest(&req_node);
120116 }
......@@ -123,7 +119,7 @@ pub async fn pwritev(loop: *event.Loop, fd: os.FileHandle, offset: usize, data:
123119}
124120
125121/// data - just the inner references - must live until pwritev promise completes.
126pub async fn preadv(loop: *event.Loop, fd: os.FileHandle, offset: usize, data: []const []u8) !usize {
122pub async fn preadv(loop: *event.Loop, fd: os.FileHandle, data: []const []u8, offset: usize) !usize {
127123 //const data_dupe = try mem.dupe(loop.allocator, []const u8, data);
128124 //defer loop.allocator.free(data_dupe);
129125
......@@ -143,8 +139,8 @@ pub async fn preadv(loop: *event.Loop, fd: os.FileHandle, offset: usize, data: [
143139 }
144140
145141 var req_node = RequestNode{
146 .prev = undefined,
147 .next = undefined,
142 .prev = null,
143 .next = null,
148144 .data = Request{
149145 .msg = Request.Msg{
150146 .PReadV = Request.Msg.PReadV{
......@@ -156,14 +152,16 @@ pub async fn preadv(loop: *event.Loop, fd: os.FileHandle, offset: usize, data: [
156152 },
157153 .finish = Request.Finish{
158154 .TickNode = event.Loop.NextTickNode{
159 .prev = undefined,
160 .next = undefined,
155 .prev = null,
156 .next = null,
161157 .data = @handle(),
162158 },
163159 },
164160 },
165161 };
166162
163 errdefer loop.posixFsCancel(&req_node);
164
167165 suspend {
168166 loop.posixFsRequest(&req_node);
169167 }
......@@ -171,7 +169,9 @@ pub async fn preadv(loop: *event.Loop, fd: os.FileHandle, offset: usize, data: [
171169 return req_node.data.msg.PReadV.result;
172170}
173171
174pub async fn openRead(loop: *event.Loop, path: []const u8) os.File.OpenError!os.FileHandle {
172pub async fn open(
173 loop: *event.Loop, path: []const u8, flags: u32, mode: os.File.Mode,
174) os.File.OpenError!os.FileHandle {
175175 // workaround for https://github.com/ziglang/zig/issues/1194
176176 suspend {
177177 resume @handle();
......@@ -181,30 +181,39 @@ pub async fn openRead(loop: *event.Loop, path: []const u8) os.File.OpenError!os.
181181 defer loop.allocator.free(path_with_null);
182182
183183 var req_node = RequestNode{
184 .prev = undefined,
185 .next = undefined,
184 .prev = null,
185 .next = null,
186186 .data = Request{
187187 .msg = Request.Msg{
188 .OpenRead = Request.Msg.OpenRead{
188 .Open = Request.Msg.Open{
189189 .path = path_with_null[0..path.len],
190 .flags = flags,
191 .mode = mode,
190192 .result = undefined,
191193 },
192194 },
193195 .finish = Request.Finish{
194196 .TickNode = event.Loop.NextTickNode{
195 .prev = undefined,
196 .next = undefined,
197 .prev = null,
198 .next = null,
197199 .data = @handle(),
198200 },
199201 },
200202 },
201203 };
202204
205 errdefer loop.posixFsCancel(&req_node);
206
203207 suspend {
204208 loop.posixFsRequest(&req_node);
205209 }
206210
207 return req_node.data.msg.OpenRead.result;
211 return req_node.data.msg.Open.result;
212}
213
214pub async fn openRead(loop: *event.Loop, path: []const u8) os.File.OpenError!os.FileHandle {
215 const flags = posix.O_LARGEFILE | posix.O_RDONLY | posix.O_CLOEXEC;
216 return await (async open(loop, path, flags, 0) catch unreachable);
208217}
209218
210219/// Creates if does not exist. Does not truncate.
......@@ -213,59 +222,29 @@ pub async fn openReadWrite(
213222 path: []const u8,
214223 mode: os.File.Mode,
215224) os.File.OpenError!os.FileHandle {
216 // workaround for https://github.com/ziglang/zig/issues/1194
217 suspend {
218 resume @handle();
219 }
220
221 const path_with_null = try std.cstr.addNullByte(loop.allocator, path);
222 defer loop.allocator.free(path_with_null);
223
224 var req_node = RequestNode{
225 .prev = undefined,
226 .next = undefined,
227 .data = Request{
228 .msg = Request.Msg{
229 .OpenRW = Request.Msg.OpenRW{
230 .path = path_with_null[0..path.len],
231 .mode = mode,
232 .result = undefined,
233 },
234 },
235 .finish = Request.Finish{
236 .TickNode = event.Loop.NextTickNode{
237 .prev = undefined,
238 .next = undefined,
239 .data = @handle(),
240 },
241 },
242 },
243 };
244
245 suspend {
246 loop.posixFsRequest(&req_node);
247 }
248
249 return req_node.data.msg.OpenRW.result;
225 const flags = posix.O_LARGEFILE | posix.O_RDWR | posix.O_CREAT | posix.O_CLOEXEC;
226 return await (async open(loop, path, flags, mode) catch unreachable);
250227}
251228
252229/// This abstraction helps to close file handles in defer expressions
253230/// without the possibility of failure and without the use of suspend points.
254231/// Start a `CloseOperation` before opening a file, so that you can defer
255/// `CloseOperation.deinit`.
232/// `CloseOperation.finish`.
233/// If you call `setHandle` then finishing will close the fd; otherwise finishing
234/// will deallocate the `CloseOperation`.
256235pub const CloseOperation = struct {
257236 loop: *event.Loop,
258237 have_fd: bool,
259238 close_req_node: RequestNode,
260239
261 pub fn create(loop: *event.Loop) (error{OutOfMemory}!*CloseOperation) {
240 pub fn start(loop: *event.Loop) (error{OutOfMemory}!*CloseOperation) {
262241 const self = try loop.allocator.createOne(CloseOperation);
263242 self.* = CloseOperation{
264243 .loop = loop,
265244 .have_fd = false,
266245 .close_req_node = RequestNode{
267 .prev = undefined,
268 .next = undefined,
246 .prev = null,
247 .next = null,
269248 .data = Request{
270249 .msg = Request.Msg{
271250 .Close = Request.Msg.Close{ .fd = undefined },
......@@ -278,7 +257,7 @@ pub const CloseOperation = struct {
278257 }
279258
280259 /// Defer this after creating.
281 pub fn deinit(self: *CloseOperation) void {
260 pub fn finish(self: *CloseOperation) void {
282261 if (self.have_fd) {
283262 self.loop.posixFsRequest(&self.close_req_node);
284263 } else {
......@@ -290,6 +269,16 @@ pub const CloseOperation = struct {
290269 self.close_req_node.data.msg.Close.fd = handle;
291270 self.have_fd = true;
292271 }
272
273 /// Undo a `setHandle`.
274 pub fn clearHandle(self: *CloseOperation) void {
275 self.have_fd = false;
276 }
277
278 pub fn getHandle(self: *CloseOperation) os.FileHandle {
279 assert(self.have_fd);
280 return self.close_req_node.data.msg.Close.fd;
281 }
293282};
294283
295284/// contents must remain alive until writeFile completes.
......@@ -308,8 +297,8 @@ pub async fn writeFileMode(loop: *event.Loop, path: []const u8, contents: []cons
308297 defer loop.allocator.free(path_with_null);
309298
310299 var req_node = RequestNode{
311 .prev = undefined,
312 .next = undefined,
300 .prev = null,
301 .next = null,
313302 .data = Request{
314303 .msg = Request.Msg{
315304 .WriteFile = Request.Msg.WriteFile{
......@@ -321,14 +310,16 @@ pub async fn writeFileMode(loop: *event.Loop, path: []const u8, contents: []cons
321310 },
322311 .finish = Request.Finish{
323312 .TickNode = event.Loop.NextTickNode{
324 .prev = undefined,
325 .next = undefined,
313 .prev = null,
314 .next = null,
326315 .data = @handle(),
327316 },
328317 },
329318 },
330319 };
331320
321 errdefer loop.posixFsCancel(&req_node);
322
332323 suspend {
333324 loop.posixFsRequest(&req_node);
334325 }
......@@ -340,8 +331,8 @@ pub async fn writeFileMode(loop: *event.Loop, path: []const u8, contents: []cons
340331/// is closed.
341332/// Caller owns returned memory.
342333pub async fn readFile(loop: *event.Loop, file_path: []const u8, max_size: usize) ![]u8 {
343 var close_op = try CloseOperation.create(loop);
344 defer close_op.deinit();
334 var close_op = try CloseOperation.start(loop);
335 defer close_op.finish();
345336
346337 const path_with_null = try std.cstr.addNullByte(loop.allocator, file_path);
347338 defer loop.allocator.free(path_with_null);
......@@ -356,7 +347,7 @@ pub async fn readFile(loop: *event.Loop, file_path: []const u8, max_size: usize)
356347 try list.ensureCapacity(list.len + os.page_size);
357348 const buf = list.items[list.len..];
358349 const buf_array = [][]u8{buf};
359 const amt = try await (async preadv(loop, fd, list.len, buf_array) catch unreachable);
350 const amt = try await (async preadv(loop, fd, buf_array, list.len) catch unreachable);
360351 list.len += amt;
361352 if (list.len > max_size) {
362353 return error.FileTooBig;
......@@ -370,19 +361,38 @@ pub async fn readFile(loop: *event.Loop, file_path: []const u8, max_size: usize)
370361pub fn Watch(comptime V: type) type {
371362 return struct {
372363 channel: *event.Channel(Event),
373 putter: promise,
374 wd_table: WdTable,
375 table_lock: event.Lock,
376 inotify_fd: i32,
364 os_data: OsData,
365
366 const OsData = switch (builtin.os) {
367 builtin.Os.macosx => struct{
368 file_table: FileTable,
369 table_lock: event.Lock,
370
371 const FileTable = std.AutoHashMap([]const u8, *Put);
372 const Put = struct {
373 putter: promise,
374 value_ptr: *V,
375 };
376 },
377 builtin.Os.linux => struct {
378 putter: promise,
379 inotify_fd: i32,
380 wd_table: WdTable,
381 table_lock: event.Lock,
382
383 const FileTable = std.AutoHashMap([]const u8, V);
384 },
385 else => @compileError("Unsupported OS"),
386 };
377387
378388 const WdTable = std.AutoHashMap(i32, Dir);
379 const FileTable = std.AutoHashMap([]const u8, V);
389 const FileToHandle = std.AutoHashMap([]const u8, promise);
380390
381391 const Self = this;
382392
383393 const Dir = struct {
384394 dirname: []const u8,
385 file_table: FileTable,
395 file_table: OsData.FileTable,
386396 };
387397
388398 pub const Event = union(enum) {
......@@ -392,26 +402,140 @@ pub fn Watch(comptime V: type) type {
392402 pub const Error = error{
393403 UserResourceLimitReached,
394404 SystemResources,
405 AccessDenied,
395406 };
396407 };
397408
398409 pub fn create(loop: *event.Loop, event_buf_count: usize) !*Self {
399 const inotify_fd = try os.linuxINotifyInit1(os.linux.IN_NONBLOCK | os.linux.IN_CLOEXEC);
400 errdefer os.close(inotify_fd);
401
402410 const channel = try event.Channel(Self.Event).create(loop, event_buf_count);
403411 errdefer channel.destroy();
404412
405 var result: *Self = undefined;
406 _ = try async<loop.allocator> eventPutter(inotify_fd, channel, &result);
407 return result;
413 switch (builtin.os) {
414 builtin.Os.linux => {
415 const inotify_fd = try os.linuxINotifyInit1(os.linux.IN_NONBLOCK | os.linux.IN_CLOEXEC);
416 errdefer os.close(inotify_fd);
417
418 var result: *Self = undefined;
419 _ = try async<loop.allocator> linuxEventPutter(inotify_fd, channel, &result);
420 return result;
421 },
422 builtin.Os.macosx => {
423 const self = try loop.allocator.createOne(Self);
424 errdefer loop.allocator.destroy(self);
425
426 self.* = Self{
427 .channel = channel,
428 .os_data = OsData{
429 .table_lock = event.Lock.init(loop),
430 .file_table = OsData.FileTable.init(loop.allocator),
431 },
432 };
433 return self;
434 },
435 else => @compileError("Unsupported OS"),
436 }
408437 }
409438
410439 pub fn destroy(self: *Self) void {
411 cancel self.putter;
440 switch (builtin.os) {
441 builtin.Os.macosx => {
442 self.os_data.table_lock.deinit();
443 var it = self.os_data.file_table.iterator();
444 while (it.next()) |entry| {
445 cancel entry.value.putter;
446 self.channel.loop.allocator.free(entry.key);
447 }
448 self.channel.destroy();
449 },
450 builtin.Os.linux => cancel self.os_data.putter,
451 else => @compileError("Unsupported OS"),
452 }
412453 }
413454
414455 pub async fn addFile(self: *Self, file_path: []const u8, value: V) !?V {
456 switch (builtin.os) {
457 builtin.Os.macosx => return await (async addFileMacosx(self, file_path, value) catch unreachable),
458 builtin.Os.linux => return await (async addFileLinux(self, file_path, value) catch unreachable),
459 else => @compileError("Unsupported OS"),
460 }
461 }
462
463 async fn addFileMacosx(self: *Self, file_path: []const u8, value: V) !?V {
464 const resolved_path = try os.path.resolve(self.channel.loop.allocator, file_path);
465 var resolved_path_consumed = false;
466 defer if (!resolved_path_consumed) self.channel.loop.allocator.free(resolved_path);
467
468 var close_op = try CloseOperation.start(self.channel.loop);
469 var close_op_consumed = false;
470 defer if (!close_op_consumed) close_op.finish();
471
472 const flags = posix.O_SYMLINK|posix.O_EVTONLY;
473 const mode = 0;
474 const fd = try await (async open(self.channel.loop, resolved_path, flags, mode) catch unreachable);
475 close_op.setHandle(fd);
476
477 var put_data: *OsData.Put = undefined;
478 const putter = try async self.kqPutEvents(close_op, value, &put_data);
479 close_op_consumed = true;
480 errdefer cancel putter;
481
482 const result = blk: {
483 const held = await (async self.os_data.table_lock.acquire() catch unreachable);
484 defer held.release();
485
486 const gop = try self.os_data.file_table.getOrPut(resolved_path);
487 if (gop.found_existing) {
488 const prev_value = gop.kv.value.value_ptr.*;
489 cancel gop.kv.value.putter;
490 gop.kv.value = put_data;
491 break :blk prev_value;
492 } else {
493 resolved_path_consumed = true;
494 gop.kv.value = put_data;
495 break :blk null;
496 }
497 };
498
499 return result;
500 }
501
502 async fn kqPutEvents(self: *Self, close_op: *CloseOperation, value: V, out_put: **OsData.Put) void {
503 // TODO https://github.com/ziglang/zig/issues/1194
504 suspend {
505 resume @handle();
506 }
507
508 var value_copy = value;
509 var put = OsData.Put{
510 .putter = @handle(),
511 .value_ptr = &value_copy,
512 };
513 out_put.* = &put;
514 self.channel.loop.beginOneEvent();
515
516 defer {
517 close_op.finish();
518 self.channel.loop.finishOneEvent();
519 }
520
521 while (true) {
522 (await (async self.channel.loop.bsdWaitKev(
523 @intCast(usize, close_op.getHandle()), posix.EVFILT_VNODE, posix.NOTE_WRITE,
524 ) catch unreachable)) catch |err| switch (err) {
525 error.EventNotFound => unreachable,
526 error.ProcessNotFound => unreachable,
527 error.AccessDenied, error.SystemResources => {
528 // TODO https://github.com/ziglang/zig/issues/769
529 const casted_err = @errSetCast(error{AccessDenied,SystemResources}, err);
530 await (async self.channel.put(Self.Event{ .Err = casted_err }) catch unreachable);
531 },
532 };
533
534 await (async self.channel.put(Self.Event{ .CloseWrite = value_copy }) catch unreachable);
535 }
536 }
537
538 async fn addFileLinux(self: *Self, file_path: []const u8, value: V) !?V {
415539 const dirname = os.path.dirname(file_path) orelse ".";
416540 const dirname_with_null = try std.cstr.addNullByte(self.channel.loop.allocator, dirname);
417541 var dirname_with_null_consumed = false;
......@@ -423,20 +547,20 @@ pub fn Watch(comptime V: type) type {
423547 defer if (!basename_with_null_consumed) self.channel.loop.allocator.free(basename_with_null);
424548
425549 const wd = try os.linuxINotifyAddWatchC(
426 self.inotify_fd,
550 self.os_data.inotify_fd,
427551 dirname_with_null.ptr,
428552 os.linux.IN_CLOSE_WRITE | os.linux.IN_ONLYDIR | os.linux.IN_EXCL_UNLINK,
429553 );
430554 // wd is either a newly created watch or an existing one.
431555
432 const held = await (async self.table_lock.acquire() catch unreachable);
556 const held = await (async self.os_data.table_lock.acquire() catch unreachable);
433557 defer held.release();
434558
435 const gop = try self.wd_table.getOrPut(wd);
559 const gop = try self.os_data.wd_table.getOrPut(wd);
436560 if (!gop.found_existing) {
437561 gop.kv.value = Dir{
438562 .dirname = dirname_with_null,
439 .file_table = FileTable.init(self.channel.loop.allocator),
563 .file_table = OsData.FileTable.init(self.channel.loop.allocator),
440564 };
441565 dirname_with_null_consumed = true;
442566 }
......@@ -458,7 +582,7 @@ pub fn Watch(comptime V: type) type {
458582 @panic("TODO");
459583 }
460584
461 async fn eventPutter(inotify_fd: i32, channel: *event.Channel(Event), out_watch: **Self) void {
585 async fn linuxEventPutter(inotify_fd: i32, channel: *event.Channel(Event), out_watch: **Self) void {
462586 // TODO https://github.com/ziglang/zig/issues/1194
463587 suspend {
464588 resume @handle();
......@@ -467,27 +591,27 @@ pub fn Watch(comptime V: type) type {
467591 const loop = channel.loop;
468592
469593 var watch = Self{
470 .putter = @handle(),
471594 .channel = channel,
472 .wd_table = WdTable.init(loop.allocator),
473 .table_lock = event.Lock.init(loop),
474 .inotify_fd = inotify_fd,
595 .os_data = OsData{
596 .putter = @handle(),
597 .inotify_fd = inotify_fd,
598 .wd_table = WdTable.init(loop.allocator),
599 .table_lock = event.Lock.init(loop),
600 },
475601 };
476602 out_watch.* = &watch;
477603
478604 loop.beginOneEvent();
479605
480606 defer {
481 watch.table_lock.deinit();
482 {
483 var wd_it = watch.wd_table.iterator();
484 while (wd_it.next()) |wd_entry| {
485 var file_it = wd_entry.value.file_table.iterator();
486 while (file_it.next()) |file_entry| {
487 loop.allocator.free(file_entry.key);
488 }
489 loop.allocator.free(wd_entry.value.dirname);
607 watch.os_data.table_lock.deinit();
608 var wd_it = watch.os_data.wd_table.iterator();
609 while (wd_it.next()) |wd_entry| {
610 var file_it = wd_entry.value.file_table.iterator();
611 while (file_it.next()) |file_entry| {
612 loop.allocator.free(file_entry.key);
490613 }
614 loop.allocator.free(wd_entry.value.dirname);
491615 }
492616 loop.finishOneEvent();
493617 os.close(inotify_fd);
......@@ -511,10 +635,10 @@ pub fn Watch(comptime V: type) type {
511635 const basename_ptr = ptr + @sizeOf(os.linux.inotify_event);
512636 const basename_with_null = basename_ptr[0 .. std.cstr.len(basename_ptr) + 1];
513637 const user_value = blk: {
514 const held = await (async watch.table_lock.acquire() catch unreachable);
638 const held = await (async watch.os_data.table_lock.acquire() catch unreachable);
515639 defer held.release();
516640
517 const dir = &watch.wd_table.get(ev.wd).?.value;
641 const dir = &watch.os_data.wd_table.get(ev.wd).?.value;
518642 if (dir.file_table.get(basename_with_null)) |entry| {
519643 break :blk entry.value;
520644 } else {
......@@ -572,7 +696,7 @@ test "write a file, watch it, write it again" {
572696 try loop.initMultiThreaded(allocator);
573697 defer loop.deinit();
574698
575 var result: error!void = undefined;
699 var result: error!void = error.ResultNeverWritten;
576700 const handle = try async<allocator> testFsWatchCantFail(&loop, &result);
577701 defer cancel handle;
578702
......@@ -615,7 +739,7 @@ async fn testFsWatch(loop: *event.Loop) !void {
615739 {
616740 defer os.close(fd);
617741
618 try await try async pwritev(loop, fd, line2_offset, []const []const u8{"lorem ipsum"});
742 try await try async pwritev(loop, fd, []const []const u8{"lorem ipsum"}, line2_offset);
619743 }
620744
621745 ev_consumed = true;
std/event/loop.zig+66-38
......@@ -116,7 +116,7 @@ pub const Loop = struct {
116116 switch (builtin.os) {
117117 builtin.Os.linux => {
118118 self.os_data.fs_queue = std.atomic.Queue(fs.Request).init();
119 self.os_data.fs_queue_len = 0;
119 self.os_data.fs_queue_item = 0;
120120 // we need another thread for the file system because Linux does not have an async
121121 // file system I/O API.
122122 self.os_data.fs_end_request = fs.RequestNode{
......@@ -201,9 +201,6 @@ pub const Loop = struct {
201201 },
202202 };
203203
204 self.os_data.kevents = try self.allocator.alloc(posix.Kevent, extra_thread_count);
205 errdefer self.allocator.free(self.os_data.kevents);
206
207204 const empty_kevs = ([*]posix.Kevent)(undefined)[0..0];
208205
209206 for (self.eventfd_resume_nodes) |*eventfd_node, i| {
......@@ -230,15 +227,6 @@ pub const Loop = struct {
230227 _ = try os.bsdKEvent(self.os_data.kqfd, kevent_array, empty_kevs, null);
231228 eventfd_node.data.kevent.flags = posix.EV_CLEAR | posix.EV_ENABLE;
232229 eventfd_node.data.kevent.fflags = posix.NOTE_TRIGGER;
233 // this one is for waiting for events
234 self.os_data.kevents[i] = posix.Kevent{
235 .ident = i,
236 .filter = posix.EVFILT_USER,
237 .flags = 0,
238 .fflags = 0,
239 .data = 0,
240 .udata = @ptrToInt(&eventfd_node.data.base),
241 };
242230 }
243231
244232 // Pre-add so that we cannot get error.SystemResources
......@@ -257,16 +245,16 @@ pub const Loop = struct {
257245 self.os_data.final_kevent.fflags = posix.NOTE_TRIGGER;
258246
259247 self.os_data.fs_kevent_wake = posix.Kevent{
260 .ident = extra_thread_count + 1,
248 .ident = 0,
261249 .filter = posix.EVFILT_USER,
262 .flags = posix.EV_ADD,
250 .flags = posix.EV_ADD|posix.EV_ENABLE,
263251 .fflags = posix.NOTE_TRIGGER,
264252 .data = 0,
265253 .udata = undefined,
266254 };
267255
268256 self.os_data.fs_kevent_wait = posix.Kevent{
269 .ident = extra_thread_count + 1,
257 .ident = 0,
270258 .filter = posix.EVFILT_USER,
271259 .flags = posix.EV_ADD|posix.EV_CLEAR,
272260 .fflags = 0,
......@@ -349,7 +337,6 @@ pub const Loop = struct {
349337 self.allocator.free(self.eventfd_resume_nodes);
350338 },
351339 builtin.Os.macosx => {
352 self.allocator.free(self.os_data.kevents);
353340 os.close(self.os_data.kqfd);
354341 os.close(self.os_data.fs_kqfd);
355342 },
......@@ -384,12 +371,8 @@ pub const Loop = struct {
384371 }
385372
386373 pub fn linuxRemoveFd(self: *Loop, fd: i32) void {
387 self.linuxRemoveFdNoCounter(fd);
388 self.finishOneEvent();
389 }
390
391 fn linuxRemoveFdNoCounter(self: *Loop, fd: i32) void {
392374 os.linuxEpollCtl(self.os_data.epollfd, os.linux.EPOLL_CTL_DEL, fd, undefined) catch {};
375 self.finishOneEvent();
393376 }
394377
395378 pub async fn linuxWaitFd(self: *Loop, fd: i32, flags: u32) !void {
......@@ -404,6 +387,50 @@ pub const Loop = struct {
404387 }
405388 }
406389
390 pub async fn bsdWaitKev(self: *Loop, ident: usize, filter: i16, fflags: u32) !void {
391 defer self.bsdRemoveKev(ident, filter);
392 suspend {
393 // TODO explicitly put this memory in the coroutine frame #1194
394 var resume_node = ResumeNode{
395 .id = ResumeNode.Id.Basic,
396 .handle = @handle(),
397 };
398 try self.bsdAddKev(&resume_node, ident, filter, fflags);
399 }
400 }
401
402 /// resume_node must live longer than the promise that it holds a reference to.
403 pub fn bsdAddKev(self: *Loop, resume_node: *ResumeNode, ident: usize, filter: i16, fflags: u32) !void {
404 self.beginOneEvent();
405 errdefer self.finishOneEvent();
406 var kev = posix.Kevent{
407 .ident = ident,
408 .filter = filter,
409 .flags = posix.EV_ADD|posix.EV_ENABLE|posix.EV_CLEAR,
410 .fflags = fflags,
411 .data = 0,
412 .udata = @ptrToInt(resume_node),
413 };
414 const kevent_array = (*[1]posix.Kevent)(&kev);
415 const empty_kevs = ([*]posix.Kevent)(undefined)[0..0];
416 _ = try os.bsdKEvent(self.os_data.kqfd, kevent_array, empty_kevs, null);
417 }
418
419 pub fn bsdRemoveKev(self: *Loop, ident: usize, filter: i16) void {
420 var kev = posix.Kevent{
421 .ident = ident,
422 .filter = filter,
423 .flags = posix.EV_DELETE,
424 .fflags = 0,
425 .data = 0,
426 .udata = 0,
427 };
428 const kevent_array = (*[1]posix.Kevent)(&kev);
429 const empty_kevs = ([*]posix.Kevent)(undefined)[0..0];
430 _ = os.bsdKEvent(self.os_data.kqfd, kevent_array, empty_kevs, null) catch undefined;
431 self.finishOneEvent();
432 }
433
407434 fn dispatch(self: *Loop) void {
408435 while (self.available_eventfd_resume_nodes.pop()) |resume_stack_node| {
409436 const next_tick_node = self.next_tick_queue.get() orelse {
......@@ -598,7 +625,8 @@ pub const Loop = struct {
598625 },
599626 builtin.Os.macosx => {
600627 var eventlist: [1]posix.Kevent = undefined;
601 const count = os.bsdKEvent(self.os_data.kqfd, self.os_data.kevents, eventlist[0..], null) catch unreachable;
628 const empty_kevs = ([*]posix.Kevent)(undefined)[0..0];
629 const count = os.bsdKEvent(self.os_data.kqfd, empty_kevs, eventlist[0..], null) catch unreachable;
602630 for (eventlist[0..count]) |ev| {
603631 const resume_node = @intToPtr(*ResumeNode, ev.udata);
604632 const handle = resume_node.handle;
......@@ -617,7 +645,6 @@ pub const Loop = struct {
617645 self.finishOneEvent();
618646 }
619647 }
620 break;
621648 },
622649 builtin.Os.windows => {
623650 var completion_key: usize = undefined;
......@@ -662,8 +689,8 @@ pub const Loop = struct {
662689 _ = os.bsdKEvent(self.os_data.fs_kqfd, fs_kevs, empty_kevs, null) catch unreachable;
663690 },
664691 builtin.Os.linux => {
665 _ = @atomicRmw(i32, &self.os_data.fs_queue_len, AtomicRmwOp.Add, 1, AtomicOrder.SeqCst); // let this wrap
666 const rc = os.linux.futex_wake(@ptrToInt(&self.os_data.fs_queue_len), os.linux.FUTEX_WAKE, 1);
692 _ = @atomicRmw(u8, &self.os_data.fs_queue_item, AtomicRmwOp.Xchg, 1, AtomicOrder.SeqCst);
693 const rc = os.linux.futex_wake(@ptrToInt(&self.os_data.fs_queue_item), os.linux.FUTEX_WAKE, 1);
667694 switch (os.linux.getErrno(rc)) {
668695 0 => {},
669696 posix.EINVAL => unreachable,
......@@ -674,11 +701,18 @@ pub const Loop = struct {
674701 }
675702 }
676703
704 fn posixFsCancel(self: *Loop, request_node: *fs.RequestNode) void {
705 if (self.os_data.fs_queue.remove(request_node)) {
706 self.finishOneEvent();
707 }
708 }
709
677710 fn posixFsRun(self: *Loop) void {
678 var processed_count: i32 = 0; // we let this wrap
679711 while (true) {
712 if (builtin.os == builtin.Os.linux) {
713 _ = @atomicRmw(u8, &self.os_data.fs_queue_item, AtomicRmwOp.Xchg, 0, AtomicOrder.SeqCst);
714 }
680715 while (self.os_data.fs_queue.get()) |node| {
681 processed_count +%= 1;
682716 switch (node.data.msg) {
683717 @TagType(fs.Request.Msg).End => return,
684718 @TagType(fs.Request.Msg).PWriteV => |*msg| {
......@@ -687,13 +721,8 @@ pub const Loop = struct {
687721 @TagType(fs.Request.Msg).PReadV => |*msg| {
688722 msg.result = os.posix_preadv(msg.fd, msg.iov.ptr, msg.iov.len, msg.offset);
689723 },
690 @TagType(fs.Request.Msg).OpenRead => |*msg| {
691 const flags = posix.O_LARGEFILE | posix.O_RDONLY | posix.O_CLOEXEC;
692 msg.result = os.posixOpenC(msg.path.ptr, flags, 0);
693 },
694 @TagType(fs.Request.Msg).OpenRW => |*msg| {
695 const flags = posix.O_LARGEFILE | posix.O_RDWR | posix.O_CREAT | posix.O_CLOEXEC;
696 msg.result = os.posixOpenC(msg.path.ptr, flags, msg.mode);
724 @TagType(fs.Request.Msg).Open => |*msg| {
725 msg.result = os.posixOpenC(msg.path.ptr, msg.flags, msg.mode);
697726 },
698727 @TagType(fs.Request.Msg).Close => |*msg| os.close(msg.fd),
699728 @TagType(fs.Request.Msg).WriteFile => |*msg| blk: {
......@@ -718,7 +747,7 @@ pub const Loop = struct {
718747 }
719748 switch (builtin.os) {
720749 builtin.Os.linux => {
721 const rc = os.linux.futex_wait(@ptrToInt(&self.os_data.fs_queue_len), os.linux.FUTEX_WAIT, processed_count, null);
750 const rc = os.linux.futex_wait(@ptrToInt(&self.os_data.fs_queue_item), os.linux.FUTEX_WAIT, 0, null);
722751 switch (os.linux.getErrno(rc)) {
723752 0 => continue,
724753 posix.EINTR => continue,
......@@ -742,7 +771,7 @@ pub const Loop = struct {
742771 final_eventfd: i32,
743772 final_eventfd_event: os.linux.epoll_event,
744773 fs_thread: *os.Thread,
745 fs_queue_len: i32, // we let this wrap
774 fs_queue_item: u8,
746775 fs_queue: std.atomic.Queue(fs.Request),
747776 fs_end_request: fs.RequestNode,
748777 },
......@@ -757,7 +786,6 @@ pub const Loop = struct {
757786 const MacOsData = struct {
758787 kqfd: i32,
759788 final_kevent: posix.Kevent,
760 kevents: []posix.Kevent,
761789 fs_kevent_wake: posix.Kevent,
762790 fs_kevent_wait: posix.Kevent,
763791 fs_thread: *os.Thread,