1 /* Copyright Joyent, Inc. and other Node contributors. All rights reserved. 2 * Permission is hereby granted, free of charge, to any person obtaining a copy 3 * of this software and associated documentation files (the "Software"), to 4 * deal in the Software without restriction, including without limitation the 5 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 6 * sell copies of the Software, and to permit persons to whom the Software is 7 * furnished to do so, subject to the following conditions: 8 * 9 * The above copyright notice and this permission notice shall be included in 10 * all copies or substantial portions of the Software. 11 * 12 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 13 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 14 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 15 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 16 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 17 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 18 * IN THE SOFTWARE. 19 */ 20 21 #include "uv.h" 22 #include "internal.h" 23 24 #if TARGET_OS_IPHONE || MAC_OS_X_VERSION_MAX_ALLOWED < 1070 25 26 /* iOS (currently) doesn't provide the FSEvents-API (nor CoreServices) */ 27 /* macOS prior to 10.7 doesn't provide the full FSEvents API so use kqueue */ 28 29 int uv__fsevents_init(uv_fs_event_t* handle) { 30 return 0; 31 } 32 33 34 int uv__fsevents_close(uv_fs_event_t* handle) { 35 return 0; 36 } 37 38 39 void uv__fsevents_loop_delete(uv_loop_t* loop) { 40 } 41 42 #else /* TARGET_OS_IPHONE */ 43 44 #include "darwin-stub.h" 45 46 #include <dlfcn.h> 47 #include <assert.h> 48 #include <stdlib.h> 49 #include <pthread.h> 50 51 static const int kFSEventsModified = 52 kFSEventStreamEventFlagItemChangeOwner | 53 kFSEventStreamEventFlagItemFinderInfoMod | 54 kFSEventStreamEventFlagItemInodeMetaMod | 55 kFSEventStreamEventFlagItemModified | 56 kFSEventStreamEventFlagItemXattrMod; 57 58 static const int kFSEventsRenamed = 59 kFSEventStreamEventFlagItemCreated | 60 kFSEventStreamEventFlagItemRemoved | 61 kFSEventStreamEventFlagItemRenamed; 62 63 static const int kFSEventsSystem = 64 kFSEventStreamEventFlagUserDropped | 65 kFSEventStreamEventFlagKernelDropped | 66 kFSEventStreamEventFlagEventIdsWrapped | 67 kFSEventStreamEventFlagHistoryDone | 68 kFSEventStreamEventFlagMount | 69 kFSEventStreamEventFlagUnmount | 70 kFSEventStreamEventFlagRootChanged; 71 72 typedef struct uv__fsevents_event_s uv__fsevents_event_t; 73 typedef struct uv__cf_loop_signal_s uv__cf_loop_signal_t; 74 typedef struct uv__cf_loop_state_s uv__cf_loop_state_t; 75 76 enum uv__cf_loop_signal_type_e { 77 kUVCFLoopSignalRegular, 78 kUVCFLoopSignalClosing 79 }; 80 typedef enum uv__cf_loop_signal_type_e uv__cf_loop_signal_type_t; 81 82 struct uv__cf_loop_signal_s { 83 struct uv__queue member; 84 uv_fs_event_t* handle; 85 uv__cf_loop_signal_type_t type; 86 }; 87 88 struct uv__fsevents_event_s { 89 struct uv__queue member; 90 int events; 91 char path[1]; 92 }; 93 94 struct uv__cf_loop_state_s { 95 CFRunLoopRef loop; 96 CFRunLoopSourceRef signal_source; 97 int fsevent_need_reschedule; 98 FSEventStreamRef fsevent_stream; 99 uv_sem_t fsevent_sem; 100 uv_mutex_t fsevent_mutex; 101 struct uv__queue fsevent_handles; 102 unsigned int fsevent_handle_count; 103 }; 104 105 /* Forward declarations */ 106 static void uv__cf_loop_cb(void* arg); 107 static void* uv__cf_loop_runner(void* arg); 108 static int uv__cf_loop_signal(uv_loop_t* loop, 109 uv_fs_event_t* handle, 110 uv__cf_loop_signal_type_t type); 111 112 /* Lazy-loaded by uv__fsevents_global_init(). */ 113 static CFArrayRef (*pCFArrayCreate)(CFAllocatorRef, 114 const void**, 115 CFIndex, 116 const CFArrayCallBacks*); 117 static void (*pCFRelease)(CFTypeRef); 118 static void (*pCFRunLoopAddSource)(CFRunLoopRef, 119 CFRunLoopSourceRef, 120 CFStringRef); 121 static CFRunLoopRef (*pCFRunLoopGetCurrent)(void); 122 static void (*pCFRunLoopRemoveSource)(CFRunLoopRef, 123 CFRunLoopSourceRef, 124 CFStringRef); 125 static void (*pCFRunLoopRun)(void); 126 static CFRunLoopSourceRef (*pCFRunLoopSourceCreate)(CFAllocatorRef, 127 CFIndex, 128 CFRunLoopSourceContext*); 129 static void (*pCFRunLoopSourceSignal)(CFRunLoopSourceRef); 130 static void (*pCFRunLoopStop)(CFRunLoopRef); 131 static void (*pCFRunLoopWakeUp)(CFRunLoopRef); 132 static CFStringRef (*pCFStringCreateWithFileSystemRepresentation)( 133 CFAllocatorRef, 134 const char*); 135 static CFStringRef (*pkCFRunLoopDefaultMode); 136 static FSEventStreamRef (*pFSEventStreamCreate)(CFAllocatorRef, 137 FSEventStreamCallback, 138 FSEventStreamContext*, 139 CFArrayRef, 140 FSEventStreamEventId, 141 CFTimeInterval, 142 FSEventStreamCreateFlags); 143 static void (*pFSEventStreamInvalidate)(FSEventStreamRef); 144 static void (*pFSEventStreamRelease)(FSEventStreamRef); 145 static void (*pFSEventStreamScheduleWithRunLoop)(FSEventStreamRef, 146 CFRunLoopRef, 147 CFStringRef); 148 static int (*pFSEventStreamStart)(FSEventStreamRef); 149 static void (*pFSEventStreamStop)(FSEventStreamRef); 150 151 #define UV__FSEVENTS_PROCESS(handle, block) \ 152 do { \ 153 struct uv__queue events; \ 154 struct uv__queue* q; \ 155 uv__fsevents_event_t* event; \ 156 int err; \ 157 uv_mutex_lock(&(handle)->cf_mutex); \ 158 /* Split-off all events and empty original queue */ \ 159 uv__queue_move(&(handle)->cf_events, &events); \ 160 /* Get error (if any) and zero original one */ \ 161 err = (handle)->cf_error; \ 162 (handle)->cf_error = 0; \ 163 uv_mutex_unlock(&(handle)->cf_mutex); \ 164 /* Loop through events, deallocating each after processing */ \ 165 while (!uv__queue_empty(&events)) { \ 166 q = uv__queue_head(&events); \ 167 event = uv__queue_data(q, uv__fsevents_event_t, member); \ 168 uv__queue_remove(q); \ 169 /* NOTE: Checking uv__is_active() is required here, because handle \ 170 * callback may close handle and invoking it after it will lead to \ 171 * incorrect behaviour */ \ 172 if (!uv__is_closing((handle)) && uv__is_active((handle))) \ 173 block \ 174 /* Free allocated data */ \ 175 uv__free(event); \ 176 } \ 177 if (err != 0 && !uv__is_closing((handle)) && uv__is_active((handle))) \ 178 (handle)->cb((handle), NULL, 0, err); \ 179 } while (0) 180 181 182 /* Runs in UV loop's thread, when there're events to report to handle */ 183 static void uv__fsevents_cb(uv_async_t* cb) { 184 uv_fs_event_t* handle; 185 186 handle = cb->data; 187 188 UV__FSEVENTS_PROCESS(handle, { 189 handle->cb(handle, event->path[0] ? event->path : NULL, event->events, 0); 190 }); 191 } 192 193 194 /* Runs in CF thread, pushed event into handle's event list */ 195 static void uv__fsevents_push_event(uv_fs_event_t* handle, 196 struct uv__queue* events, 197 int err) { 198 assert(events != NULL || err != 0); 199 uv_mutex_lock(&handle->cf_mutex); 200 201 /* Concatenate two queues */ 202 if (events != NULL) 203 uv__queue_add(&handle->cf_events, events); 204 205 /* Propagate error */ 206 if (err != 0) 207 handle->cf_error = err; 208 uv_mutex_unlock(&handle->cf_mutex); 209 210 uv_async_send(handle->cf_cb); 211 } 212 213 214 /* Runs in CF thread, when there're events in FSEventStream */ 215 static void uv__fsevents_event_cb(const FSEventStreamRef streamRef, 216 void* info, 217 size_t numEvents, 218 void* eventPaths, 219 const FSEventStreamEventFlags eventFlags[], 220 const FSEventStreamEventId eventIds[]) { 221 size_t i; 222 int len; 223 char** paths; 224 char* path; 225 char* pos; 226 uv_fs_event_t* handle; 227 struct uv__queue* q; 228 uv_loop_t* loop; 229 uv__cf_loop_state_t* state; 230 uv__fsevents_event_t* event; 231 FSEventStreamEventFlags flags; 232 struct uv__queue head; 233 234 loop = info; 235 state = loop->cf_state; 236 assert(state != NULL); 237 paths = eventPaths; 238 239 /* For each handle */ 240 uv_mutex_lock(&state->fsevent_mutex); 241 uv__queue_foreach(q, &state->fsevent_handles) { 242 handle = uv__queue_data(q, uv_fs_event_t, cf_member); 243 uv__queue_init(&head); 244 245 /* Process and filter out events */ 246 for (i = 0; i < numEvents; i++) { 247 flags = eventFlags[i]; 248 249 /* Ignore system events */ 250 if (flags & kFSEventsSystem) 251 continue; 252 253 path = paths[i]; 254 len = strlen(path); 255 256 if (handle->realpath_len == 0) 257 continue; /* This should be unreachable */ 258 259 /* Filter out paths that are outside handle's request */ 260 if (len < handle->realpath_len) 261 continue; 262 263 /* Make sure that realpath actually named a directory, 264 * (unless watching root, which alone keeps a trailing slash on the realpath) 265 * or that we matched the whole string */ 266 if (handle->realpath_len != len && 267 handle->realpath_len > 1 && 268 path[handle->realpath_len] != '/') 269 continue; 270 271 if (memcmp(path, handle->realpath, handle->realpath_len) != 0) 272 continue; 273 274 if (!(handle->realpath_len == 1 && handle->realpath[0] == '/')) { 275 /* Remove common prefix, unless the watched folder is "/" */ 276 path += handle->realpath_len; 277 len -= handle->realpath_len; 278 279 if (len == 0) { 280 /* Since we're using fsevents to watch the file itself, 281 * realpath == path, and we now need to get the basename of the file back 282 * (for commonality with other codepaths and platforms). */ 283 while (len < handle->realpath_len && path[-1] != '/') { 284 path--; 285 len++; 286 } 287 /* Created and Removed seem to be always set, but don't make sense */ 288 flags &= ~kFSEventsRenamed; 289 } else { 290 /* Skip forward slash */ 291 path++; 292 len--; 293 } 294 } 295 296 /* Do not emit events from subdirectories (without option set) */ 297 if ((handle->cf_flags & UV_FS_EVENT_RECURSIVE) == 0 && *path != '\0') { 298 pos = strchr(path + 1, '/'); 299 if (pos != NULL) 300 continue; 301 } 302 303 event = uv__malloc(sizeof(*event) + len); 304 if (event == NULL) 305 break; 306 307 memset(event, 0, sizeof(*event)); 308 memcpy(event->path, path, len + 1); 309 event->events = UV_RENAME; 310 311 if (0 == (flags & kFSEventsRenamed)) { 312 if (0 != (flags & kFSEventsModified) || 313 0 == (flags & kFSEventStreamEventFlagItemIsDir)) 314 event->events = UV_CHANGE; 315 } 316 317 uv__queue_insert_tail(&head, &event->member); 318 } 319 320 if (!uv__queue_empty(&head)) 321 uv__fsevents_push_event(handle, &head, 0); 322 } 323 uv_mutex_unlock(&state->fsevent_mutex); 324 } 325 326 327 /* Runs in CF thread */ 328 static int uv__fsevents_create_stream(uv__cf_loop_state_t* state, 329 uv_loop_t* loop, 330 CFArrayRef paths) { 331 FSEventStreamContext ctx; 332 FSEventStreamRef ref; 333 CFAbsoluteTime latency; 334 FSEventStreamCreateFlags flags; 335 336 /* Initialize context */ 337 memset(&ctx, 0, sizeof(ctx)); 338 ctx.info = loop; 339 340 latency = 0.05; 341 342 /* Explanation of selected flags: 343 * 1. NoDefer - without this flag, events that are happening continuously 344 * (i.e. each event is happening after time interval less than `latency`, 345 * counted from previous event), will be deferred and passed to callback 346 * once they'll either fill whole OS buffer, or when this continuous stream 347 * will stop (i.e. there'll be delay between events, bigger than 348 * `latency`). 349 * Specifying this flag will invoke callback after `latency` time passed 350 * since event. 351 * 2. FileEvents - fire callback for file changes too (by default it is firing 352 * it only for directory changes). 353 */ 354 flags = kFSEventStreamCreateFlagNoDefer | kFSEventStreamCreateFlagFileEvents; 355 356 /* 357 * NOTE: It might sound like a good idea to remember last seen StreamEventId, 358 * but in reality one dir might have last StreamEventId less than, the other, 359 * that is being watched now. Which will cause FSEventStream API to report 360 * changes to files from the past. 361 */ 362 ref = pFSEventStreamCreate(NULL, 363 &uv__fsevents_event_cb, 364 &ctx, 365 paths, 366 kFSEventStreamEventIdSinceNow, 367 latency, 368 flags); 369 assert(ref != NULL); 370 371 pFSEventStreamScheduleWithRunLoop(ref, state->loop, *pkCFRunLoopDefaultMode); 372 if (!pFSEventStreamStart(ref)) { 373 pFSEventStreamInvalidate(ref); 374 pFSEventStreamRelease(ref); 375 return UV_EMFILE; 376 } 377 378 state->fsevent_stream = ref; 379 return 0; 380 } 381 382 383 /* Runs in CF thread */ 384 static void uv__fsevents_destroy_stream(uv__cf_loop_state_t* state) { 385 if (state->fsevent_stream == NULL) 386 return; 387 388 /* Stop emitting events */ 389 pFSEventStreamStop(state->fsevent_stream); 390 391 /* Release stream */ 392 pFSEventStreamInvalidate(state->fsevent_stream); 393 pFSEventStreamRelease(state->fsevent_stream); 394 state->fsevent_stream = NULL; 395 } 396 397 398 /* Runs in CF thread, when there're new fsevent handles to add to stream */ 399 static void uv__fsevents_reschedule(uv__cf_loop_state_t* state, 400 uv_loop_t* loop, 401 uv__cf_loop_signal_type_t type) { 402 struct uv__queue* q; 403 uv_fs_event_t* curr; 404 CFArrayRef cf_paths; 405 CFStringRef* paths; 406 unsigned int i; 407 int err; 408 unsigned int path_count; 409 410 paths = NULL; 411 cf_paths = NULL; 412 err = 0; 413 /* NOTE: `i` is used in deallocation loop below */ 414 i = 0; 415 416 /* Optimization to prevent O(n^2) time spent when starting to watch 417 * many files simultaneously 418 */ 419 uv_mutex_lock(&state->fsevent_mutex); 420 if (state->fsevent_need_reschedule == 0) { 421 uv_mutex_unlock(&state->fsevent_mutex); 422 goto final; 423 } 424 state->fsevent_need_reschedule = 0; 425 uv_mutex_unlock(&state->fsevent_mutex); 426 427 /* Destroy previous FSEventStream */ 428 uv__fsevents_destroy_stream(state); 429 430 /* Any failure below will be a memory failure */ 431 err = UV_ENOMEM; 432 433 /* Create list of all watched paths */ 434 uv_mutex_lock(&state->fsevent_mutex); 435 path_count = state->fsevent_handle_count; 436 if (path_count != 0) { 437 paths = uv__malloc(sizeof(*paths) * path_count); 438 if (paths == NULL) { 439 uv_mutex_unlock(&state->fsevent_mutex); 440 goto final; 441 } 442 443 q = &state->fsevent_handles; 444 for (; i < path_count; i++) { 445 q = uv__queue_next(q); 446 assert(q != &state->fsevent_handles); 447 curr = uv__queue_data(q, uv_fs_event_t, cf_member); 448 449 assert(curr->realpath != NULL); 450 paths[i] = 451 pCFStringCreateWithFileSystemRepresentation(NULL, curr->realpath); 452 if (paths[i] == NULL) { 453 uv_mutex_unlock(&state->fsevent_mutex); 454 goto final; 455 } 456 } 457 } 458 uv_mutex_unlock(&state->fsevent_mutex); 459 err = 0; 460 461 if (path_count != 0) { 462 /* Create new FSEventStream */ 463 cf_paths = pCFArrayCreate(NULL, (const void**) paths, path_count, NULL); 464 if (cf_paths == NULL) { 465 err = UV_ENOMEM; 466 goto final; 467 } 468 err = uv__fsevents_create_stream(state, loop, cf_paths); 469 } 470 471 final: 472 /* Deallocate all paths in case of failure */ 473 if (err != 0) { 474 if (cf_paths == NULL) { 475 while (i != 0) 476 pCFRelease(paths[--i]); 477 uv__free(paths); 478 } else { 479 /* CFArray takes ownership of both strings and original C-array */ 480 pCFRelease(cf_paths); 481 } 482 483 /* Broadcast error to all handles */ 484 uv_mutex_lock(&state->fsevent_mutex); 485 uv__queue_foreach(q, &state->fsevent_handles) { 486 curr = uv__queue_data(q, uv_fs_event_t, cf_member); 487 uv__fsevents_push_event(curr, NULL, err); 488 } 489 uv_mutex_unlock(&state->fsevent_mutex); 490 } 491 492 /* 493 * Main thread will block until the removal of handle from the list, 494 * we must tell it when we're ready. 495 * 496 * NOTE: This is coupled with `uv_sem_wait()` in `uv__fsevents_close` 497 */ 498 if (type == kUVCFLoopSignalClosing) 499 uv_sem_post(&state->fsevent_sem); 500 } 501 502 503 static int uv__fsevents_global_init(void) { 504 static pthread_mutex_t global_init_mutex = PTHREAD_MUTEX_INITIALIZER; 505 static void* core_foundation_handle; 506 static void* core_services_handle; 507 int err; 508 509 err = 0; 510 pthread_mutex_lock(&global_init_mutex); 511 if (core_foundation_handle != NULL) 512 goto out; 513 514 /* The libraries are never unloaded because we currently don't have a good 515 * mechanism for keeping a reference count. It's unlikely to be an issue 516 * but if it ever becomes one, we can turn the dynamic library handles into 517 * per-event loop properties and have the dynamic linker keep track for us. 518 */ 519 err = UV_ENOSYS; 520 core_foundation_handle = dlopen("/System/Library/Frameworks/" 521 "CoreFoundation.framework/" 522 "Versions/A/CoreFoundation", 523 RTLD_LAZY | RTLD_LOCAL); 524 if (core_foundation_handle == NULL) 525 goto out; 526 527 core_services_handle = dlopen("/System/Library/Frameworks/" 528 "CoreServices.framework/" 529 "Versions/A/CoreServices", 530 RTLD_LAZY | RTLD_LOCAL); 531 if (core_services_handle == NULL) 532 goto out; 533 534 err = UV_ENOENT; 535 #define V(handle, symbol) \ 536 do { \ 537 *(void **)(&p ## symbol) = dlsym((handle), #symbol); \ 538 if (p ## symbol == NULL) \ 539 goto out; \ 540 } \ 541 while (0) 542 V(core_foundation_handle, CFArrayCreate); 543 V(core_foundation_handle, CFRelease); 544 V(core_foundation_handle, CFRunLoopAddSource); 545 V(core_foundation_handle, CFRunLoopGetCurrent); 546 V(core_foundation_handle, CFRunLoopRemoveSource); 547 V(core_foundation_handle, CFRunLoopRun); 548 V(core_foundation_handle, CFRunLoopSourceCreate); 549 V(core_foundation_handle, CFRunLoopSourceSignal); 550 V(core_foundation_handle, CFRunLoopStop); 551 V(core_foundation_handle, CFRunLoopWakeUp); 552 V(core_foundation_handle, CFStringCreateWithFileSystemRepresentation); 553 V(core_foundation_handle, kCFRunLoopDefaultMode); 554 V(core_services_handle, FSEventStreamCreate); 555 V(core_services_handle, FSEventStreamInvalidate); 556 V(core_services_handle, FSEventStreamRelease); 557 V(core_services_handle, FSEventStreamScheduleWithRunLoop); 558 V(core_services_handle, FSEventStreamStart); 559 V(core_services_handle, FSEventStreamStop); 560 #undef V 561 err = 0; 562 563 out: 564 if (err && core_services_handle != NULL) { 565 dlclose(core_services_handle); 566 core_services_handle = NULL; 567 } 568 569 if (err && core_foundation_handle != NULL) { 570 dlclose(core_foundation_handle); 571 core_foundation_handle = NULL; 572 } 573 574 pthread_mutex_unlock(&global_init_mutex); 575 return err; 576 } 577 578 579 /* Runs in UV loop */ 580 static int uv__fsevents_loop_init(uv_loop_t* loop) { 581 CFRunLoopSourceContext ctx; 582 uv__cf_loop_state_t* state; 583 pthread_attr_t attr; 584 int err; 585 586 if (loop->cf_state != NULL) 587 return 0; 588 589 err = uv__fsevents_global_init(); 590 if (err) 591 return err; 592 593 state = uv__calloc(1, sizeof(*state)); 594 if (state == NULL) 595 return UV_ENOMEM; 596 597 err = uv_mutex_init(&loop->cf_mutex); 598 if (err) 599 goto fail_mutex_init; 600 601 err = uv_sem_init(&loop->cf_sem, 0); 602 if (err) 603 goto fail_sem_init; 604 605 uv__queue_init(&loop->cf_signals); 606 607 err = uv_sem_init(&state->fsevent_sem, 0); 608 if (err) 609 goto fail_fsevent_sem_init; 610 611 err = uv_mutex_init(&state->fsevent_mutex); 612 if (err) 613 goto fail_fsevent_mutex_init; 614 615 uv__queue_init(&state->fsevent_handles); 616 state->fsevent_need_reschedule = 0; 617 state->fsevent_handle_count = 0; 618 619 memset(&ctx, 0, sizeof(ctx)); 620 ctx.info = loop; 621 ctx.perform = uv__cf_loop_cb; 622 state->signal_source = pCFRunLoopSourceCreate(NULL, 0, &ctx); 623 if (state->signal_source == NULL) { 624 err = UV_ENOMEM; 625 goto fail_signal_source_create; 626 } 627 628 if (pthread_attr_init(&attr)) 629 abort(); 630 631 if (pthread_attr_setstacksize(&attr, uv__thread_stack_size())) 632 abort(); 633 634 loop->cf_state = state; 635 636 /* uv_thread_t is an alias for pthread_t. */ 637 err = UV__ERR(pthread_create(&loop->cf_thread, &attr, uv__cf_loop_runner, loop)); 638 639 if (pthread_attr_destroy(&attr)) 640 abort(); 641 642 if (err) 643 goto fail_thread_create; 644 645 /* Synchronize threads */ 646 uv_sem_wait(&loop->cf_sem); 647 return 0; 648 649 fail_thread_create: 650 loop->cf_state = NULL; 651 652 fail_signal_source_create: 653 uv_mutex_destroy(&state->fsevent_mutex); 654 655 fail_fsevent_mutex_init: 656 uv_sem_destroy(&state->fsevent_sem); 657 658 fail_fsevent_sem_init: 659 uv_sem_destroy(&loop->cf_sem); 660 661 fail_sem_init: 662 uv_mutex_destroy(&loop->cf_mutex); 663 664 fail_mutex_init: 665 uv__free(state); 666 return err; 667 } 668 669 670 /* Runs in UV loop */ 671 void uv__fsevents_loop_delete(uv_loop_t* loop) { 672 uv__cf_loop_signal_t* s; 673 uv__cf_loop_state_t* state; 674 struct uv__queue* q; 675 676 if (loop->cf_state == NULL) 677 return; 678 679 if (uv__cf_loop_signal(loop, NULL, kUVCFLoopSignalRegular) != 0) 680 abort(); 681 682 uv_thread_join(&loop->cf_thread); 683 uv_sem_destroy(&loop->cf_sem); 684 uv_mutex_destroy(&loop->cf_mutex); 685 686 /* Free any remaining data */ 687 while (!uv__queue_empty(&loop->cf_signals)) { 688 q = uv__queue_head(&loop->cf_signals); 689 s = uv__queue_data(q, uv__cf_loop_signal_t, member); 690 uv__queue_remove(q); 691 uv__free(s); 692 } 693 694 /* Destroy state */ 695 state = loop->cf_state; 696 uv_sem_destroy(&state->fsevent_sem); 697 uv_mutex_destroy(&state->fsevent_mutex); 698 pCFRelease(state->signal_source); 699 uv__free(state); 700 loop->cf_state = NULL; 701 } 702 703 704 /* Runs in CF thread. This is the CF loop's body */ 705 static void* uv__cf_loop_runner(void* arg) { 706 uv_loop_t* loop; 707 uv__cf_loop_state_t* state; 708 709 loop = arg; 710 state = loop->cf_state; 711 state->loop = pCFRunLoopGetCurrent(); 712 713 pCFRunLoopAddSource(state->loop, 714 state->signal_source, 715 *pkCFRunLoopDefaultMode); 716 717 uv_sem_post(&loop->cf_sem); 718 719 pCFRunLoopRun(); 720 pCFRunLoopRemoveSource(state->loop, 721 state->signal_source, 722 *pkCFRunLoopDefaultMode); 723 724 state->loop = NULL; 725 726 return NULL; 727 } 728 729 730 /* Runs in CF thread, executed after `uv__cf_loop_signal()` */ 731 static void uv__cf_loop_cb(void* arg) { 732 uv_loop_t* loop; 733 uv__cf_loop_state_t* state; 734 struct uv__queue* item; 735 struct uv__queue split_head; 736 uv__cf_loop_signal_t* s; 737 738 loop = arg; 739 state = loop->cf_state; 740 741 uv_mutex_lock(&loop->cf_mutex); 742 uv__queue_move(&loop->cf_signals, &split_head); 743 uv_mutex_unlock(&loop->cf_mutex); 744 745 while (!uv__queue_empty(&split_head)) { 746 item = uv__queue_head(&split_head); 747 uv__queue_remove(item); 748 749 s = uv__queue_data(item, uv__cf_loop_signal_t, member); 750 751 /* This was a termination signal */ 752 if (s->handle == NULL) 753 pCFRunLoopStop(state->loop); 754 else 755 uv__fsevents_reschedule(state, loop, s->type); 756 757 uv__free(s); 758 } 759 } 760 761 762 /* Runs in UV loop to notify CF thread */ 763 int uv__cf_loop_signal(uv_loop_t* loop, 764 uv_fs_event_t* handle, 765 uv__cf_loop_signal_type_t type) { 766 uv__cf_loop_signal_t* item; 767 uv__cf_loop_state_t* state; 768 769 item = uv__malloc(sizeof(*item)); 770 if (item == NULL) 771 return UV_ENOMEM; 772 773 item->handle = handle; 774 item->type = type; 775 776 uv_mutex_lock(&loop->cf_mutex); 777 uv__queue_insert_tail(&loop->cf_signals, &item->member); 778 779 state = loop->cf_state; 780 assert(state != NULL); 781 pCFRunLoopSourceSignal(state->signal_source); 782 pCFRunLoopWakeUp(state->loop); 783 784 uv_mutex_unlock(&loop->cf_mutex); 785 786 return 0; 787 } 788 789 790 /* Runs in UV loop to initialize handle */ 791 int uv__fsevents_init(uv_fs_event_t* handle) { 792 char* buf; 793 int err; 794 uv__cf_loop_state_t* state; 795 796 err = uv__fsevents_loop_init(handle->loop); 797 if (err) 798 return err; 799 800 /* Get absolute path to file */ 801 buf = realpath(handle->path, NULL); 802 if (buf == NULL) 803 return UV__ERR(errno); 804 handle->realpath = uv__strdup(buf); 805 free(buf); /* _Not_ uv__free. */ 806 if (handle->realpath == NULL) 807 return UV_ENOMEM; 808 handle->realpath_len = strlen(handle->realpath); 809 810 /* Initialize event queue */ 811 uv__queue_init(&handle->cf_events); 812 handle->cf_error = 0; 813 814 /* 815 * Events will occur in other thread. 816 * Initialize callback for getting them back into event loop's thread 817 */ 818 handle->cf_cb = uv__malloc(sizeof(*handle->cf_cb)); 819 if (handle->cf_cb == NULL) { 820 err = UV_ENOMEM; 821 goto fail_cf_cb_malloc; 822 } 823 824 handle->cf_cb->data = handle; 825 uv_async_init(handle->loop, handle->cf_cb, uv__fsevents_cb); 826 handle->cf_cb->flags |= UV_HANDLE_INTERNAL; 827 uv_unref((uv_handle_t*) handle->cf_cb); 828 829 err = uv_mutex_init(&handle->cf_mutex); 830 if (err) 831 goto fail_cf_mutex_init; 832 833 /* Insert handle into the list */ 834 state = handle->loop->cf_state; 835 uv_mutex_lock(&state->fsevent_mutex); 836 uv__queue_insert_tail(&state->fsevent_handles, &handle->cf_member); 837 state->fsevent_handle_count++; 838 state->fsevent_need_reschedule = 1; 839 uv_mutex_unlock(&state->fsevent_mutex); 840 841 /* Reschedule FSEventStream */ 842 assert(handle != NULL); 843 err = uv__cf_loop_signal(handle->loop, handle, kUVCFLoopSignalRegular); 844 if (err) 845 goto fail_loop_signal; 846 847 return 0; 848 849 fail_loop_signal: 850 uv_mutex_destroy(&handle->cf_mutex); 851 852 fail_cf_mutex_init: 853 uv__free(handle->cf_cb); 854 handle->cf_cb = NULL; 855 856 fail_cf_cb_malloc: 857 uv__free(handle->realpath); 858 handle->realpath = NULL; 859 handle->realpath_len = 0; 860 861 return err; 862 } 863 864 865 /* Runs in UV loop to de-initialize handle */ 866 int uv__fsevents_close(uv_fs_event_t* handle) { 867 int err; 868 uv__cf_loop_state_t* state; 869 870 if (handle->cf_cb == NULL) 871 return UV_EINVAL; 872 873 /* Remove handle from the list */ 874 state = handle->loop->cf_state; 875 uv_mutex_lock(&state->fsevent_mutex); 876 uv__queue_remove(&handle->cf_member); 877 state->fsevent_handle_count--; 878 state->fsevent_need_reschedule = 1; 879 uv_mutex_unlock(&state->fsevent_mutex); 880 881 /* Reschedule FSEventStream */ 882 assert(handle != NULL); 883 err = uv__cf_loop_signal(handle->loop, handle, kUVCFLoopSignalClosing); 884 if (err) 885 return UV__ERR(err); 886 887 /* Wait for deinitialization */ 888 uv_sem_wait(&state->fsevent_sem); 889 890 uv_close((uv_handle_t*) handle->cf_cb, (uv_close_cb) uv__free); 891 handle->cf_cb = NULL; 892 893 /* Free data in queue */ 894 UV__FSEVENTS_PROCESS(handle, { 895 /* NOP */ 896 }); 897 898 uv_mutex_destroy(&handle->cf_mutex); 899 uv__free(handle->realpath); 900 handle->realpath = NULL; 901 handle->realpath_len = 0; 902 903 return 0; 904 } 905 906 #endif /* TARGET_OS_IPHONE */ 907
Indexes created Tue May 26 00:24:38 UTC 2026