|
160
|
1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved.
|
|
|
2 *
|
|
|
3 * Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
4 * of this software and associated documentation files (the "Software"), to
|
|
|
5 * deal in the Software without restriction, including without limitation the
|
|
|
6 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
|
7 * sell copies of the Software, and to permit persons to whom the Software is
|
|
|
8 * furnished to do so, subject to the following conditions:
|
|
|
9 *
|
|
|
10 * The above copyright notice and this permission notice shall be included in
|
|
|
11 * all copies or substantial portions of the Software.
|
|
|
12 *
|
|
|
13 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
14 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
15 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
16 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
17 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
18 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
19 * IN THE SOFTWARE.
|
|
|
20 */
|
|
|
21
|
|
|
22 #include "uv.h"
|
|
|
23 #include "uv-common.h"
|
|
|
24
|
|
|
25 #ifdef _WIN32
|
|
|
26 #include "win/internal.h"
|
|
|
27 #include "win/handle-inl.h"
|
|
|
28 #define uv__make_close_pending(h) uv__want_endgame((h)->loop, (h))
|
|
|
29 #else
|
|
|
30 #include "unix/internal.h"
|
|
|
31 #endif
|
|
|
32
|
|
|
33 #include <assert.h>
|
|
|
34 #include <stdlib.h>
|
|
|
35 #include <string.h>
|
|
|
36
|
|
|
37 struct poll_ctx {
|
|
|
38 uv_fs_poll_t* parent_handle;
|
|
|
39 int busy_polling;
|
|
|
40 unsigned int interval;
|
|
|
41 uint64_t start_time;
|
|
|
42 uv_loop_t* loop;
|
|
|
43 uv_fs_poll_cb poll_cb;
|
|
|
44 uv_timer_t timer_handle;
|
|
|
45 uv_fs_t fs_req; /* TODO(bnoordhuis) mark fs_req internal */
|
|
|
46 uv_stat_t statbuf;
|
|
|
47 struct poll_ctx* previous; /* context from previous start()..stop() period */
|
|
|
48 char path[1]; /* variable length */
|
|
|
49 };
|
|
|
50
|
|
|
51 static int statbuf_eq(const uv_stat_t* a, const uv_stat_t* b);
|
|
|
52 static void poll_cb(uv_fs_t* req);
|
|
|
53 static void timer_cb(uv_timer_t* timer);
|
|
|
54 static void timer_close_cb(uv_handle_t* timer);
|
|
|
55
|
|
|
56 static uv_stat_t zero_statbuf;
|
|
|
57
|
|
|
58
|
|
|
59 int uv_fs_poll_init(uv_loop_t* loop, uv_fs_poll_t* handle) {
|
|
|
60 uv__handle_init(loop, (uv_handle_t*)handle, UV_FS_POLL);
|
|
|
61 handle->poll_ctx = NULL;
|
|
|
62 return 0;
|
|
|
63 }
|
|
|
64
|
|
|
65
|
|
|
66 int uv_fs_poll_start(uv_fs_poll_t* handle,
|
|
|
67 uv_fs_poll_cb cb,
|
|
|
68 const char* path,
|
|
|
69 unsigned int interval) {
|
|
|
70 struct poll_ctx* ctx;
|
|
|
71 uv_loop_t* loop;
|
|
|
72 size_t len;
|
|
|
73 int err;
|
|
|
74
|
|
|
75 if (uv_is_active((uv_handle_t*)handle))
|
|
|
76 return 0;
|
|
|
77
|
|
|
78 loop = handle->loop;
|
|
|
79 len = strlen(path);
|
|
|
80 ctx = uv__calloc(1, sizeof(*ctx) + len);
|
|
|
81
|
|
|
82 if (ctx == NULL)
|
|
|
83 return UV_ENOMEM;
|
|
|
84
|
|
|
85 ctx->loop = loop;
|
|
|
86 ctx->poll_cb = cb;
|
|
|
87 ctx->interval = interval ? interval : 1;
|
|
|
88 ctx->start_time = uv_now(loop);
|
|
|
89 ctx->parent_handle = handle;
|
|
|
90 memcpy(ctx->path, path, len + 1);
|
|
|
91
|
|
|
92 err = uv_timer_init(loop, &ctx->timer_handle);
|
|
|
93 if (err < 0)
|
|
|
94 goto error;
|
|
|
95
|
|
|
96 ctx->timer_handle.flags |= UV_HANDLE_INTERNAL;
|
|
|
97 uv__handle_unref(&ctx->timer_handle);
|
|
|
98
|
|
|
99 err = uv_fs_stat(loop, &ctx->fs_req, ctx->path, poll_cb);
|
|
|
100 if (err < 0)
|
|
|
101 goto error;
|
|
|
102
|
|
|
103 if (handle->poll_ctx != NULL)
|
|
|
104 ctx->previous = handle->poll_ctx;
|
|
|
105 handle->poll_ctx = ctx;
|
|
|
106 uv__handle_start(handle);
|
|
|
107
|
|
|
108 return 0;
|
|
|
109
|
|
|
110 error:
|
|
|
111 uv__free(ctx);
|
|
|
112 return err;
|
|
|
113 }
|
|
|
114
|
|
|
115
|
|
|
116 int uv_fs_poll_stop(uv_fs_poll_t* handle) {
|
|
|
117 struct poll_ctx* ctx;
|
|
|
118
|
|
|
119 if (!uv_is_active((uv_handle_t*)handle))
|
|
|
120 return 0;
|
|
|
121
|
|
|
122 ctx = handle->poll_ctx;
|
|
|
123 assert(ctx != NULL);
|
|
|
124 assert(ctx->parent_handle == handle);
|
|
|
125
|
|
|
126 /* Close the timer if it's active. If it's inactive, there's a stat request
|
|
|
127 * in progress and poll_cb will take care of the cleanup.
|
|
|
128 */
|
|
|
129 if (uv_is_active((uv_handle_t*)&ctx->timer_handle))
|
|
|
130 uv_close((uv_handle_t*)&ctx->timer_handle, timer_close_cb);
|
|
|
131
|
|
|
132 uv__handle_stop(handle);
|
|
|
133
|
|
|
134 return 0;
|
|
|
135 }
|
|
|
136
|
|
|
137
|
|
|
138 int uv_fs_poll_getpath(uv_fs_poll_t* handle, char* buffer, size_t* size) {
|
|
|
139 struct poll_ctx* ctx;
|
|
|
140 size_t required_len;
|
|
|
141
|
|
|
142 if (buffer == NULL || size == NULL || *size == 0)
|
|
|
143 return UV_EINVAL;
|
|
|
144
|
|
|
145 if (!uv_is_active((uv_handle_t*)handle)) {
|
|
|
146 *size = 0;
|
|
|
147 return UV_EINVAL;
|
|
|
148 }
|
|
|
149
|
|
|
150 ctx = handle->poll_ctx;
|
|
|
151 assert(ctx != NULL);
|
|
|
152
|
|
|
153 required_len = strlen(ctx->path);
|
|
|
154 if (required_len >= *size) {
|
|
|
155 *size = required_len + 1;
|
|
|
156 return UV_ENOBUFS;
|
|
|
157 }
|
|
|
158
|
|
|
159 memcpy(buffer, ctx->path, required_len);
|
|
|
160 *size = required_len;
|
|
|
161 buffer[required_len] = '\0';
|
|
|
162
|
|
|
163 return 0;
|
|
|
164 }
|
|
|
165
|
|
|
166
|
|
|
167 void uv__fs_poll_close(uv_fs_poll_t* handle) {
|
|
|
168 uv_fs_poll_stop(handle);
|
|
|
169
|
|
|
170 if (handle->poll_ctx == NULL)
|
|
|
171 uv__make_close_pending((uv_handle_t*)handle);
|
|
|
172 }
|
|
|
173
|
|
|
174
|
|
|
175 static void timer_cb(uv_timer_t* timer) {
|
|
|
176 struct poll_ctx* ctx;
|
|
|
177
|
|
|
178 ctx = container_of(timer, struct poll_ctx, timer_handle);
|
|
|
179 assert(ctx->parent_handle != NULL);
|
|
|
180 assert(ctx->parent_handle->poll_ctx == ctx);
|
|
|
181 ctx->start_time = uv_now(ctx->loop);
|
|
|
182
|
|
|
183 if (uv_fs_stat(ctx->loop, &ctx->fs_req, ctx->path, poll_cb))
|
|
|
184 abort();
|
|
|
185 }
|
|
|
186
|
|
|
187
|
|
|
188 static void poll_cb(uv_fs_t* req) {
|
|
|
189 uv_stat_t* statbuf;
|
|
|
190 struct poll_ctx* ctx;
|
|
|
191 uint64_t interval;
|
|
|
192 uv_fs_poll_t* handle;
|
|
|
193
|
|
|
194 ctx = container_of(req, struct poll_ctx, fs_req);
|
|
|
195 handle = ctx->parent_handle;
|
|
|
196
|
|
|
197 if (!uv_is_active((uv_handle_t*)handle) || uv__is_closing(handle))
|
|
|
198 goto out;
|
|
|
199
|
|
|
200 if (req->result != 0) {
|
|
|
201 if (ctx->busy_polling != req->result) {
|
|
|
202 ctx->poll_cb(ctx->parent_handle,
|
|
|
203 req->result,
|
|
|
204 &ctx->statbuf,
|
|
|
205 &zero_statbuf);
|
|
|
206 ctx->busy_polling = req->result;
|
|
|
207 }
|
|
|
208 goto out;
|
|
|
209 }
|
|
|
210
|
|
|
211 statbuf = &req->statbuf;
|
|
|
212
|
|
|
213 if (ctx->busy_polling != 0)
|
|
|
214 if (ctx->busy_polling < 0 || !statbuf_eq(&ctx->statbuf, statbuf))
|
|
|
215 ctx->poll_cb(ctx->parent_handle, 0, &ctx->statbuf, statbuf);
|
|
|
216
|
|
|
217 ctx->statbuf = *statbuf;
|
|
|
218 ctx->busy_polling = 1;
|
|
|
219
|
|
|
220 out:
|
|
|
221 uv_fs_req_cleanup(req);
|
|
|
222
|
|
|
223 if (!uv_is_active((uv_handle_t*)handle) || uv__is_closing(handle)) {
|
|
|
224 uv_close((uv_handle_t*)&ctx->timer_handle, timer_close_cb);
|
|
|
225 return;
|
|
|
226 }
|
|
|
227
|
|
|
228 /* Reschedule timer, subtract the delay from doing the stat(). */
|
|
|
229 interval = ctx->interval;
|
|
|
230 interval -= (uv_now(ctx->loop) - ctx->start_time) % interval;
|
|
|
231
|
|
|
232 if (uv_timer_start(&ctx->timer_handle, timer_cb, interval, 0))
|
|
|
233 abort();
|
|
|
234 }
|
|
|
235
|
|
|
236
|
|
|
237 static void timer_close_cb(uv_handle_t* timer) {
|
|
|
238 struct poll_ctx* ctx;
|
|
|
239 struct poll_ctx* it;
|
|
|
240 struct poll_ctx* last;
|
|
|
241 uv_fs_poll_t* handle;
|
|
|
242
|
|
|
243 ctx = container_of(timer, struct poll_ctx, timer_handle);
|
|
|
244 handle = ctx->parent_handle;
|
|
|
245 if (ctx == handle->poll_ctx) {
|
|
|
246 handle->poll_ctx = ctx->previous;
|
|
|
247 if (handle->poll_ctx == NULL && uv__is_closing(handle))
|
|
|
248 uv__make_close_pending((uv_handle_t*)handle);
|
|
|
249 } else {
|
|
|
250 for (last = handle->poll_ctx, it = last->previous;
|
|
|
251 it != ctx;
|
|
|
252 last = it, it = it->previous) {
|
|
|
253 assert(last->previous != NULL);
|
|
|
254 }
|
|
|
255 last->previous = ctx->previous;
|
|
|
256 }
|
|
|
257 uv__free(ctx);
|
|
|
258 }
|
|
|
259
|
|
|
260
|
|
|
261 static int statbuf_eq(const uv_stat_t* a, const uv_stat_t* b) {
|
|
|
262 return a->st_ctim.tv_nsec == b->st_ctim.tv_nsec
|
|
|
263 && a->st_mtim.tv_nsec == b->st_mtim.tv_nsec
|
|
|
264 && a->st_birthtim.tv_nsec == b->st_birthtim.tv_nsec
|
|
|
265 && a->st_ctim.tv_sec == b->st_ctim.tv_sec
|
|
|
266 && a->st_mtim.tv_sec == b->st_mtim.tv_sec
|
|
|
267 && a->st_birthtim.tv_sec == b->st_birthtim.tv_sec
|
|
|
268 && a->st_size == b->st_size
|
|
|
269 && a->st_mode == b->st_mode
|
|
|
270 && a->st_uid == b->st_uid
|
|
|
271 && a->st_gid == b->st_gid
|
|
|
272 && a->st_ino == b->st_ino
|
|
|
273 && a->st_dev == b->st_dev
|
|
|
274 && a->st_flags == b->st_flags
|
|
|
275 && a->st_gen == b->st_gen;
|
|
|
276 }
|
|
|
277
|
|
|
278
|
|
|
279 #if defined(_WIN32)
|
|
|
280
|
|
|
281 #include "win/internal.h"
|
|
|
282 #include "win/handle-inl.h"
|
|
|
283
|
|
|
284 void uv__fs_poll_endgame(uv_loop_t* loop, uv_fs_poll_t* handle) {
|
|
|
285 assert(handle->flags & UV_HANDLE_CLOSING);
|
|
|
286 assert(!(handle->flags & UV_HANDLE_CLOSED));
|
|
|
287 uv__handle_close(handle);
|
|
|
288 }
|
|
|
289
|
|
|
290 #endif /* _WIN32 */
|
