Line 0
Link Here
|
|
|
1 |
/*- |
2 |
* Copyright (c) 2016 Rozhuk Ivan <rozhuk.im@gmail.com> |
3 |
* All rights reserved. |
4 |
* |
5 |
* Redistribution and use in source and binary forms, with or without |
6 |
* modification, are permitted provided that the following conditions |
7 |
* are met: |
8 |
* 1. Redistributions of source code must retain the above copyright |
9 |
* notice, this list of conditions and the following disclaimer. |
10 |
* 2. Redistributions in binary form must reproduce the above copyright |
11 |
* notice, this list of conditions and the following disclaimer in the |
12 |
* documentation and/or other materials provided with the distribution. |
13 |
* |
14 |
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
15 |
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
16 |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
17 |
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
18 |
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
19 |
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
20 |
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
21 |
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
22 |
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
23 |
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
24 |
* SUCH DAMAGE. |
25 |
* |
26 |
* Author: Rozhuk Ivan <rozhuk.im@gmail.com> |
27 |
* |
28 |
*/ |
29 |
|
30 |
#include <sys/param.h> |
31 |
#include <sys/types.h> |
32 |
#include <sys/event.h> |
33 |
#include <sys/stat.h> |
34 |
#include <sys/fcntl.h> /* open, fcntl */ |
35 |
|
36 |
#include <inttypes.h> |
37 |
#include <stdlib.h> /* malloc, exit */ |
38 |
#include <unistd.h> /* close, write, sysconf */ |
39 |
#include <string.h> /* bcopy, bzero, memcpy, memmove, memset, strerror... */ |
40 |
#include <errno.h> |
41 |
#include <dirent.h> // opendir, readdir |
42 |
|
43 |
#include "kqueue_fnm.h" |
44 |
|
45 |
|
46 |
/* Preallocate items count. */ |
47 |
#ifndef FILES_ALLOC_BLK_SIZE |
48 |
# define FILES_ALLOC_BLK_SIZE 8 |
49 |
#endif |
50 |
|
51 |
typedef struct file_info_s { /* Directory file. */ |
52 |
struct dirent de; /* d_reclen used for action. */ |
53 |
struct stat sb; |
54 |
} file_info_t, *file_info_p; |
55 |
|
56 |
|
57 |
typedef struct kqueue_file_mon_data_s { |
58 |
int fd; /* fd for notify kqueue(). */ |
59 |
int is_dir; |
60 |
char path[(PATH_MAX + 2)]; |
61 |
size_t path_size; |
62 |
size_t ppath_size; /* Parent path size. */ |
63 |
void *udata; |
64 |
/* For dir. */ |
65 |
file_info_p files; |
66 |
volatile size_t files_count; |
67 |
size_t files_allocated; |
68 |
} kqueue_file_mon_data_t; |
69 |
|
70 |
|
71 |
typedef struct kqueue_file_nonify_monitor_s { |
72 |
int fd; /* kqueue() fd. */ |
73 |
} kqueue_fnm_t; |
74 |
|
75 |
|
76 |
#ifdef O_EVTONLY |
77 |
# define OPEN_FILE_FLAGS O_EVTONLY |
78 |
#else |
79 |
# define OPEN_FILE_FLAGS (O_RDONLY | O_NOFOLLOW) |
80 |
#endif |
81 |
|
82 |
#define IS_NAME_DOTS(__name) ((__name)[0] == '.' && \ |
83 |
((__name)[1] == '\0' || \ |
84 |
((__name)[1] == '.' && (__name)[2] == '\0'))) |
85 |
#define zalloc(__size) calloc(1, (__size)) |
86 |
|
87 |
|
88 |
static inline int |
89 |
mem_cmpn(const void *buf1, const size_t buf1_size, |
90 |
const void *buf2, const size_t buf2_size) { |
91 |
|
92 |
if (buf1_size != buf2_size) |
93 |
return (((buf1_size > buf2_size) ? 127 : -127)); |
94 |
if (0 == buf1_size || buf1 == buf2) |
95 |
return (0); |
96 |
if (NULL == buf1) |
97 |
return (-127); |
98 |
if (NULL == buf2) |
99 |
return (127); |
100 |
return (memcmp(buf1, buf2, buf1_size)); |
101 |
} |
102 |
|
103 |
#if !defined(__FreeBSD_version) || __FreeBSD_version < 1100000 |
104 |
static inline void * |
105 |
reallocarray(void *buf, const size_t nmemb, const size_t size) { |
106 |
size_t nmemb_size; |
107 |
|
108 |
nmemb_size = (nmemb * size); |
109 |
if (0 == nmemb_size) { |
110 |
if (0 != nmemb && |
111 |
0 != size) { /* Overflow. */ |
112 |
errno = ENOMEM; |
113 |
return (NULL); |
114 |
} |
115 |
nmemb_size ++; |
116 |
} else if (((nmemb | size) & (SIZE_T_MAX << (sizeof(size_t) * 4))) && |
117 |
(nmemb_size / size) != nmemb) { /* size_t overflow. */ |
118 |
errno = ENOMEM; |
119 |
return (NULL); |
120 |
} |
121 |
return (realloc(buf, nmemb_size)); |
122 |
} |
123 |
#endif |
124 |
|
125 |
static inline int |
126 |
realloc_items(void **items, const size_t item_size, |
127 |
size_t *allocated, const size_t alloc_blk_cnt, const size_t count) { |
128 |
size_t allocated_prev, allocated_new; |
129 |
uint8_t *items_new; |
130 |
|
131 |
if (NULL == items || NULL == allocated || 0 == alloc_blk_cnt) |
132 |
return (EINVAL); |
133 |
allocated_prev = (*allocated); |
134 |
if (NULL != (*items) && |
135 |
allocated_prev > count && |
136 |
allocated_prev <= (count + alloc_blk_cnt)) |
137 |
return (0); |
138 |
allocated_new = (((count / alloc_blk_cnt) + 1) * alloc_blk_cnt); |
139 |
items_new = (uint8_t*)reallocarray((*items), item_size, allocated_new); |
140 |
if (NULL == items_new) /* Realloc fail! */ |
141 |
return (ENOMEM); |
142 |
if (allocated_new > allocated_prev) { /* Init new mem. */ |
143 |
bzero((items_new + (allocated_prev * item_size)), |
144 |
((allocated_new - allocated_prev) * item_size)); |
145 |
} |
146 |
(*items) = items_new; |
147 |
(*allocated) = allocated_new; |
148 |
|
149 |
return (0); |
150 |
} |
151 |
|
152 |
|
153 |
static void |
154 |
kqueue_file_mon_data_clean(kqueue_file_mon_data_p fmd) { |
155 |
|
156 |
if (NULL == fmd) |
157 |
return; |
158 |
close(fmd->fd); |
159 |
fmd->fd = -1; |
160 |
free(fmd->files); |
161 |
fmd->files = NULL; |
162 |
fmd->files_count = 0; |
163 |
fmd->files_allocated = 0; |
164 |
} |
165 |
|
166 |
static void |
167 |
kqueue_file_mon_data_free(kqueue_file_mon_data_p fmd) { |
168 |
|
169 |
if (NULL == fmd) |
170 |
return; |
171 |
close(fmd->fd); |
172 |
free(fmd->files); |
173 |
free(fmd); |
174 |
} |
175 |
|
176 |
static kqueue_file_mon_data_p |
177 |
kqueue_file_mon_data_alloc(const char *path, void *udata) { |
178 |
kqueue_file_mon_data_p fmd; |
179 |
DIR *d = NULL; |
180 |
struct dirent *de; |
181 |
struct stat sb; |
182 |
|
183 |
if (NULL == path) |
184 |
return (NULL); |
185 |
fmd = zalloc(sizeof(kqueue_file_mon_data_t)); |
186 |
if (NULL == fmd) |
187 |
return (NULL); |
188 |
fmd->fd = open(path, OPEN_FILE_FLAGS); |
189 |
if (-1 == fmd->fd) |
190 |
goto err_out; |
191 |
if (0 != fstat(fmd->fd, &sb)) |
192 |
goto err_out; |
193 |
/* Remember args. */ |
194 |
fmd->is_dir = (S_ISDIR(sb.st_mode) ? 1 : 0); |
195 |
fmd->path_size = strlcpy(fmd->path, path, sizeof(fmd->path)); |
196 |
fmd->udata = udata; |
197 |
|
198 |
/* Get parent filder name. */ |
199 |
if (fmd->is_dir) { |
200 |
/* Be sure that folder contain trailing '/'. */ |
201 |
if ('/' != fmd->path[(fmd->path_size - 1)]) { |
202 |
fmd->path[fmd->path_size] = '/'; |
203 |
fmd->path[(fmd->path_size + 1)] = 0; |
204 |
fmd->path_size ++; |
205 |
} |
206 |
/* Skip last '/' for parent dir search. */ |
207 |
fmd->ppath_size = (fmd->path_size - 1); |
208 |
} else { |
209 |
fmd->ppath_size = fmd->path_size; |
210 |
} |
211 |
/* Find parent dir path size. */ |
212 |
while (0 < fmd->ppath_size && '/' != fmd->path[(fmd->ppath_size - 1)]) { |
213 |
fmd->ppath_size --; |
214 |
} |
215 |
|
216 |
/* Dir special processing. */ |
217 |
if (0 == fmd->is_dir) |
218 |
return (fmd); |
219 |
/* Read and remember dir content. */ |
220 |
d = opendir(path); |
221 |
if (NULL == d) |
222 |
goto err_out; |
223 |
for (;;) { |
224 |
if (0 != realloc_items((void**)&fmd->files, sizeof(file_info_t), |
225 |
&fmd->files_allocated, FILES_ALLOC_BLK_SIZE, fmd->files_count)) |
226 |
goto err_out; |
227 |
/* Get file name from folder. */ |
228 |
if (0 != readdir_r(d, &fmd->files[fmd->files_count].de, &de)) |
229 |
break; |
230 |
if (NULL == de) |
231 |
break; |
232 |
if (IS_NAME_DOTS(de->d_name)) |
233 |
continue; |
234 |
/* Get file attrs. */ |
235 |
if (0 != fstatat(fmd->fd, de->d_name, |
236 |
&fmd->files[fmd->files_count].sb, |
237 |
AT_SYMLINK_NOFOLLOW)) { |
238 |
bzero(&fmd->files[fmd->files_count].sb, sizeof(struct stat)); |
239 |
} |
240 |
fmd->files_count ++; |
241 |
} |
242 |
closedir(d); |
243 |
return (fmd); |
244 |
|
245 |
err_out: |
246 |
if (NULL != d) { |
247 |
closedir(d); |
248 |
} |
249 |
kqueue_file_mon_data_free(fmd); |
250 |
return (NULL); |
251 |
} |
252 |
|
253 |
|
254 |
static inline int |
255 |
kqueue_file_mon_data_find_de(kqueue_file_mon_data_p fmd, struct dirent *de, |
256 |
size_t *idx) { |
257 |
size_t i; |
258 |
|
259 |
if (NULL == fmd || NULL == de || NULL == idx) |
260 |
return (0); |
261 |
for (i = 0; i < fmd->files_count; i ++) { |
262 |
if (de->d_fileno != fmd->files[i].de.d_fileno || |
263 |
de->d_type != fmd->files[i].de.d_type) |
264 |
continue; |
265 |
(*idx) = i; |
266 |
return (1); |
267 |
} |
268 |
(*idx) = fmd->files_count; |
269 |
return (0); |
270 |
} |
271 |
|
272 |
static void |
273 |
kqueue_handle_changes(kqueue_fnm_p kfnm, kqueue_file_mon_data_p fmd, |
274 |
kfnm_event_handler_cb cb_func) { |
275 |
DIR *d; |
276 |
struct dirent *de; |
277 |
file_info_t fi; |
278 |
size_t i, j, k; |
279 |
|
280 |
if (NULL == kfnm || NULL == fmd || NULL == cb_func) |
281 |
return; |
282 |
if (0 != fstat(fmd->fd, &fi.sb) || |
283 |
0 == fi.sb.st_nlink) { |
284 |
kqueue_file_mon_data_clean(fmd); |
285 |
cb_func(kfnm, fmd, fmd->udata, KF_EVENT_DELETED, |
286 |
fmd->path, "", NULL); |
287 |
return; |
288 |
} |
289 |
if (0 == fmd->is_dir) { |
290 |
fmd->path[fmd->ppath_size] = 0; |
291 |
cb_func(kfnm, fmd, fmd->udata, KF_EVENT_CHANGED, fmd->path, |
292 |
(fmd->path + fmd->ppath_size), NULL); |
293 |
fmd->path[fmd->ppath_size] = '/'; |
294 |
return; |
295 |
} |
296 |
/* Dir processing. */ |
297 |
d = opendir(fmd->path); |
298 |
if (NULL == d) |
299 |
return; |
300 |
/* Mark all as removed. */ |
301 |
for (i = 0; i < fmd->files_count; i ++) { |
302 |
fmd->files[i].de.d_reclen = KF_EVENT_DELETED; |
303 |
} |
304 |
|
305 |
/* Update dir. */ |
306 |
while (0 == readdir_r(d, &fi.de, &de)) { |
307 |
if (NULL == de) |
308 |
break; |
309 |
if (IS_NAME_DOTS(de->d_name)) |
310 |
continue; |
311 |
/* Get file stat. */ |
312 |
if (0 != fstatat(fmd->fd, de->d_name, &fi.sb, AT_SYMLINK_NOFOLLOW)) { |
313 |
bzero(&fi.sb, sizeof(struct stat)); /* Fail, set to zero. */ |
314 |
} |
315 |
/* Is new file/folder? */ |
316 |
if (0 == kqueue_file_mon_data_find_de(fmd, de, &i)) { /* Add new. */ |
317 |
if (0 != realloc_items((void**)&fmd->files, sizeof(file_info_t), |
318 |
&fmd->files_allocated, FILES_ALLOC_BLK_SIZE, fmd->files_count)) |
319 |
goto err_out; |
320 |
memcpy(&fmd->files[fmd->files_count], &fi, sizeof(file_info_t)); |
321 |
fmd->files[fmd->files_count].de.d_reclen = KF_EVENT_CREATED; |
322 |
fmd->files_count ++; |
323 |
/* Notify. */ |
324 |
cb_func(kfnm, fmd, fmd->udata, KF_EVENT_CREATED, |
325 |
fmd->path, de->d_name, NULL); |
326 |
continue; |
327 |
} |
328 |
/* Is renamed? */ |
329 |
if (0 != mem_cmpn(de->d_name, de->d_namlen, |
330 |
fmd->files[i].de.d_name, fmd->files[i].de.d_namlen)) { |
331 |
/* Notify. */ |
332 |
cb_func(kfnm, fmd, fmd->udata, KF_EVENT_RENAMED, |
333 |
fmd->path, fmd->files[i].de.d_name, de->d_name); |
334 |
/* Update. */ |
335 |
memcpy(&fmd->files[i], &fi, sizeof(file_info_t)); |
336 |
fmd->files[i].de.d_reclen = KF_EVENT_RENAMED; |
337 |
continue; |
338 |
} |
339 |
/* Is modified? */ |
340 |
if (0 != memcmp(&fmd->files[i].sb, &fi.sb, sizeof(struct stat))) { |
341 |
memcpy(&fmd->files[i].sb, &fi.sb, sizeof(struct stat)); /* Update stat. */ |
342 |
fmd->files[i].de.d_reclen = KF_EVENT_CHANGED; |
343 |
/* Notify. */ |
344 |
cb_func(kfnm, fmd, fmd->udata, KF_EVENT_CHANGED, |
345 |
fmd->path, de->d_name, NULL); |
346 |
continue; |
347 |
} |
348 |
/* Not changed. */ |
349 |
fmd->files[i].de.d_reclen = KF_EVENT_NOT_CHANGED; |
350 |
} |
351 |
/* Remove marked as removed. */ |
352 |
for (i = 0; i < fmd->files_count; i ++) { |
353 |
if (KF_EVENT_DELETED != fmd->files[i].de.d_reclen) |
354 |
continue; |
355 |
/* Look for next non removed item + notify. */ |
356 |
for (j = (i + 1); j < fmd->files_count; j ++) { |
357 |
if (KF_EVENT_DELETED != fmd->files[j].de.d_reclen) |
358 |
break; |
359 |
} |
360 |
/* Notify. */ |
361 |
for (k = i; k < j; k ++) { |
362 |
cb_func(kfnm, fmd, fmd->udata, KF_EVENT_DELETED, |
363 |
fmd->path, fmd->files[k].de.d_name, NULL); |
364 |
} |
365 |
memmove(&fmd->files[i], &fmd->files[j], |
366 |
(sizeof(file_info_t) * (fmd->files_count - j))); |
367 |
fmd->files_count -= (j - i); |
368 |
} |
369 |
|
370 |
|
371 |
err_out: |
372 |
if (NULL != d) { |
373 |
closedir(d); |
374 |
} |
375 |
return; |
376 |
} |
377 |
|
378 |
static void |
379 |
kqueue_handle_rename(kqueue_fnm_p kfnm, kqueue_file_mon_data_p fmd, |
380 |
kfnm_event_handler_cb cb_func) { |
381 |
DIR *d; |
382 |
struct dirent *de, dedat; |
383 |
struct stat sb; |
384 |
char old_filename[(MAXNAMLEN + 2)]; |
385 |
size_t old_filename_size; |
386 |
|
387 |
if (NULL == kfnm || NULL == fmd || NULL == cb_func) |
388 |
return; |
389 |
if (0 != fstat(fmd->fd, &sb) || |
390 |
0 == sb.st_nlink) { |
391 |
notify_removed: |
392 |
kqueue_file_mon_data_clean(fmd); |
393 |
cb_func(kfnm, fmd, fmd->udata, KF_EVENT_DELETED, |
394 |
fmd->path, "", NULL); |
395 |
return; |
396 |
} |
397 |
/* Save old file name. */ |
398 |
old_filename_size = (fmd->path_size - fmd->ppath_size - fmd->is_dir); |
399 |
memcpy(old_filename, |
400 |
(fmd->path + fmd->ppath_size), |
401 |
old_filename_size); |
402 |
old_filename[old_filename_size] = 0; |
403 |
|
404 |
/* Get parent folder name. */ |
405 |
fmd->path[fmd->ppath_size] = 0; |
406 |
/* Try to open. */ |
407 |
d = opendir(fmd->path); |
408 |
/* Restore '/' after parent folder. */ |
409 |
fmd->path[fmd->ppath_size] = '/'; |
410 |
if (NULL == d) |
411 |
return; |
412 |
/* Find new name by inode. */ |
413 |
while (0 == readdir_r(d, &dedat, &de)) { |
414 |
if (NULL == de) |
415 |
break; |
416 |
if (de->d_fileno == sb.st_ino) |
417 |
break; |
418 |
} |
419 |
closedir(d); |
420 |
if (NULL == de) |
421 |
goto notify_removed; /* Not found. */ |
422 |
/* Update name. */ |
423 |
if ((sizeof(fmd->path) - 2) <= (fmd->ppath_size + de->d_namlen)) |
424 |
return; /* Too long. */ |
425 |
memcpy((fmd->path + fmd->ppath_size), de->d_name, de->d_namlen); |
426 |
fmd->path_size = (fmd->ppath_size + de->d_namlen); |
427 |
/* Add last '/' for dir. */ |
428 |
fmd->path[fmd->path_size] = '/'; |
429 |
fmd->path_size += fmd->is_dir; |
430 |
fmd->path[fmd->path_size] = 0; |
431 |
/* Notify. */ |
432 |
cb_func(kfnm, fmd, fmd->udata, KF_EVENT_RENAMED, |
433 |
fmd->path, old_filename, de->d_name); |
434 |
} |
435 |
|
436 |
|
437 |
void |
438 |
kqueue_fnm_free(kqueue_fnm_p kfnm) { |
439 |
|
440 |
if (NULL == kfnm) |
441 |
return; |
442 |
close(kfnm->fd); |
443 |
kfnm->fd = -1; |
444 |
free(kfnm); |
445 |
} |
446 |
|
447 |
kqueue_fnm_p |
448 |
kqueue_fnm_create(void) { |
449 |
kqueue_fnm_p kfnm; |
450 |
|
451 |
kfnm = zalloc(sizeof(kqueue_fnm_t)); |
452 |
if (NULL == kfnm) |
453 |
return (NULL); |
454 |
kfnm->fd = kqueue(); |
455 |
if (-1 == kfnm->fd) |
456 |
goto err_out; |
457 |
return (kfnm); |
458 |
|
459 |
err_out: |
460 |
kqueue_fnm_free(kfnm); |
461 |
return (NULL); |
462 |
} |
463 |
|
464 |
kqueue_file_mon_data_p |
465 |
kqueue_fnm_add(kqueue_fnm_p kfnm, const char *path, void *udata) { |
466 |
struct kevent kev; |
467 |
struct timespec ke_timeout; |
468 |
kqueue_file_mon_data_p fmd; |
469 |
|
470 |
if (NULL == kfnm || NULL == path) |
471 |
return (NULL); |
472 |
fmd = (void*)kqueue_file_mon_data_alloc(path, udata); |
473 |
if (NULL == fmd) |
474 |
return (NULL); |
475 |
kev.ident = fmd->fd; |
476 |
kev.filter = EVFILT_VNODE; |
477 |
kev.flags = (EV_ADD | EV_CLEAR); |
478 |
kev.fflags = (NOTE_DELETE | NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB | NOTE_RENAME | NOTE_REVOKE); |
479 |
kev.udata = (void*)fmd; |
480 |
bzero(&ke_timeout, sizeof(ke_timeout)); |
481 |
if (-1 == kevent(kfnm->fd, &kev, 1, NULL, 0, &ke_timeout)) { |
482 |
kqueue_file_mon_data_free(fmd); |
483 |
return (NULL); |
484 |
} |
485 |
return (fmd); |
486 |
} |
487 |
|
488 |
void |
489 |
kqueue_fnm_del(kqueue_fnm_p kfnm, kqueue_file_mon_data_p fmd) { |
490 |
|
491 |
if (NULL == kfnm || NULL == fmd) |
492 |
return; |
493 |
kqueue_file_mon_data_free(fmd); |
494 |
} |
495 |
|
496 |
|
497 |
int |
498 |
kqueue_fnm_get_ev_recv_fd(kqueue_fnm_p kfnm) { |
499 |
|
500 |
if (NULL == kfnm) |
501 |
return (-1); |
502 |
return (kfnm->fd); |
503 |
} |
504 |
|
505 |
void |
506 |
kqueue_fnm_process_events(kqueue_fnm_p kfnm, kfnm_event_handler_cb cb_func) { |
507 |
struct kevent kev; |
508 |
struct timespec ke_timeout; |
509 |
kqueue_file_mon_data_p fmd; |
510 |
|
511 |
if (NULL == kfnm || NULL == cb_func) |
512 |
return; |
513 |
/* Get and process events. */ |
514 |
bzero(&ke_timeout, sizeof(ke_timeout)); |
515 |
while (0 < kevent(kfnm->fd, NULL, 0, &kev, 1, &ke_timeout)) { |
516 |
if (EVFILT_VNODE != kev.filter || |
517 |
0 == kev.udata) |
518 |
continue; /* Unknown event or no associated data, skip. */ |
519 |
fmd = (kqueue_file_mon_data_p)kev.udata; |
520 |
|
521 |
if (EV_ERROR & kev.flags) { |
522 |
kev.flags |= NOTE_REVOKE; /* Treat error as unmount. */ |
523 |
} |
524 |
if (NOTE_RENAME & kev.fflags) { |
525 |
kqueue_handle_rename(kfnm, fmd, cb_func); |
526 |
} |
527 |
if ((NOTE_WRITE | NOTE_EXTEND | NOTE_ATTRIB) & kev.fflags) { |
528 |
kqueue_handle_changes(kfnm, fmd, cb_func); |
529 |
} |
530 |
if ((NOTE_DELETE | NOTE_REVOKE) & kev.fflags) { |
531 |
kqueue_file_mon_data_clean(fmd); |
532 |
cb_func(kfnm, fmd, fmd->udata, KF_EVENT_DELETED, |
533 |
fmd->path, "", NULL); |
534 |
} |
535 |
} |
536 |
} |