1 /*
2 * Copyright (c) 2008, 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package sun.nio.fs;
27
28 import java.nio.file.*;
29 import java.util.*;
30 import java.io.IOException;
31 import jdk.internal.misc.Unsafe;
32
33 import static sun.nio.fs.UnixConstants.*;
34
35 /**
36 * Solaris implementation of WatchService based on file events notification
37 * facility.
38 */
39
40 class SolarisWatchService
41 extends AbstractWatchService
42 {
43 private static final Unsafe unsafe = Unsafe.getUnsafe();
44 private static int addressSize = unsafe.addressSize();
45
46 private static int dependsArch(int value32, int value64) {
47 return (addressSize == 4) ? value32 : value64;
48 }
49
50 /*
51 * typedef struct port_event {
52 * int portev_events;
53 * ushort_t portev_source;
54 * ushort_t portev_pad;
55 * uintptr_t portev_object;
56 * void *portev_user;
57 * } port_event_t;
58 */
59 private static final int SIZEOF_PORT_EVENT = dependsArch(16, 24);
60 private static final int OFFSETOF_EVENTS = 0;
61 private static final int OFFSETOF_SOURCE = 4;
62 private static final int OFFSETOF_OBJECT = 8;
63
64 /*
65 * typedef struct file_obj {
66 * timestruc_t fo_atime;
67 * timestruc_t fo_mtime;
68 * timestruc_t fo_ctime;
69 * uintptr_t fo_pad[3];
70 * char *fo_name;
71 * } file_obj_t;
72 */
73 private static final int SIZEOF_FILEOBJ = dependsArch(40, 80);
74 private static final int OFFSET_FO_NAME = dependsArch(36, 72);
75
76 // port sources
77 private static final short PORT_SOURCE_USER = 3;
78 private static final short PORT_SOURCE_FILE = 7;
79
80 // user-watchable events
81 private static final int FILE_MODIFIED = 0x00000002;
82 private static final int FILE_ATTRIB = 0x00000004;
83 private static final int FILE_NOFOLLOW = 0x10000000;
84
85 // exception events
86 private static final int FILE_DELETE = 0x00000010;
87 private static final int FILE_RENAME_TO = 0x00000020;
88 private static final int FILE_RENAME_FROM = 0x00000040;
89 private static final int UNMOUNTED = 0x20000000;
90 private static final int MOUNTEDOVER = 0x40000000;
91
92 // background thread to read change events
93 private final Poller poller;
94
95 SolarisWatchService(UnixFileSystem fs) throws IOException {
96 int port = -1;
97 try {
98 port = portCreate();
99 } catch (UnixException x) {
100 throw new IOException(x.errorString());
101 }
102
103 this.poller = new Poller(fs, this, port);
104 this.poller.start();
105 }
106
107 @Override
108 WatchKey register(Path dir,
109 WatchEvent.Kind<?>[] events,
110 WatchEvent.Modifier... modifiers)
111 throws IOException
112 {
113 // delegate to poller
114 return poller.register(dir, events, modifiers);
115 }
116
117 @Override
118 void implClose() throws IOException {
119 // delegate to poller
120 poller.close();
121 }
122
123 /**
124 * WatchKey implementation
125 */
126 private class SolarisWatchKey extends AbstractWatchKey
127 implements DirectoryNode
128 {
129 private final UnixFileKey fileKey;
130
131 // pointer to native file_obj object
132 private final long object;
133
134 // events (may be changed). set to null when watch key is invalid
135 private volatile Set<? extends WatchEvent.Kind<?>> events;
136
137 // map of entries in directory; created lazily; accessed only by
138 // poller thread.
139 private Map<Path,EntryNode> children = new HashMap<>();
140
141 SolarisWatchKey(SolarisWatchService watcher,
142 UnixPath dir,
143 UnixFileKey fileKey,
144 long object,
145 Set<? extends WatchEvent.Kind<?>> events)
146 {
147 super(dir, watcher);
148 this.fileKey = fileKey;
149 this.object = object;
150 this.events = events;
151 }
152
153 UnixPath getDirectory() {
154 return (UnixPath)watchable();
155 }
156
157 UnixFileKey getFileKey() {
158 return fileKey;
159 }
160
161 @Override
162 public long object() {
163 return object;
164 }
165
166 void invalidate() {
167 events = null;
168 }
169
170 Set<? extends WatchEvent.Kind<?>> events() {
171 return events;
172 }
173
174 void setEvents(Set<? extends WatchEvent.Kind<?>> events) {
175 this.events = events;
176 }
177
178 Map<Path,EntryNode> children() {
179 return children;
180 }
181
182 @Override
183 public boolean isValid() {
184 return events != null;
185 }
186
187 @Override
188 public void cancel() {
189 if (isValid()) {
190 // delegate to poller
191 poller.cancel(this);
192 }
193 }
194
195 @Override
196 public void addChild(Path name, EntryNode node) {
197 children.put(name, node);
198 }
199
200 @Override
201 public void removeChild(Path name) {
202 children.remove(name);
203 }
204
205 @Override
206 public EntryNode getChild(Path name) {
207 return children.get(name);
208 }
209 }
210
211 /**
212 * Background thread to read from port
213 */
214 private class Poller extends AbstractPoller {
215
216 // maximum number of events to read per call to port_getn
217 private static final int MAX_EVENT_COUNT = 128;
218
219 // events that map to ENTRY_DELETE
220 private static final int FILE_REMOVED =
221 (FILE_DELETE|FILE_RENAME_TO|FILE_RENAME_FROM);
222
223 // events that tell us not to re-associate the object
224 private static final int FILE_EXCEPTION =
225 (FILE_REMOVED|UNMOUNTED|MOUNTEDOVER);
226
227 // address of event buffers (used to receive events with port_getn)
228 private final long bufferAddress;
229
230 private final SolarisWatchService watcher;
231
232 // the I/O port
233 private final int port;
234
235 // maps file key (dev/inode) to WatchKey
236 private final Map<UnixFileKey,SolarisWatchKey> fileKey2WatchKey;
237
238 // maps file_obj object to Node
239 private final Map<Long,Node> object2Node;
240
241 /**
242 * Create a new instance
243 */
244 Poller(UnixFileSystem fs, SolarisWatchService watcher, int port) {
245 this.watcher = watcher;
246 this.port = port;
247 this.bufferAddress =
248 unsafe.allocateMemory(SIZEOF_PORT_EVENT * MAX_EVENT_COUNT);
249 this.fileKey2WatchKey = new HashMap<UnixFileKey,SolarisWatchKey>();
250 this.object2Node = new HashMap<Long,Node>();
251 }
252
253 @Override
254 void wakeup() throws IOException {
255 // write to port to wakeup polling thread
256 try {
257 portSend(port, 0);
258 } catch (UnixException x) {
259 throw new IOException(x.errorString());
260 }
261 }
262
263 @Override
264 Object implRegister(Path obj,
265 Set<? extends WatchEvent.Kind<?>> events,
266 WatchEvent.Modifier... modifiers)
267 {
268 // no modifiers supported at this time
269 if (modifiers.length > 0) {
270 for (WatchEvent.Modifier modifier: modifiers) {
271 if (modifier == null)
272 return new NullPointerException();
273 if (!ExtendedOptions.SENSITIVITY_HIGH.matches(modifier) &&
274 !ExtendedOptions.SENSITIVITY_MEDIUM.matches(modifier) &&
275 !ExtendedOptions.SENSITIVITY_LOW.matches(modifier)) {
276 return new UnsupportedOperationException("Modifier not supported");
277 }
278 }
279 }
280
281 UnixPath dir = (UnixPath)obj;
282
283 // check file is directory
284 UnixFileAttributes attrs = null;
285 try {
286 attrs = UnixFileAttributes.get(dir, true);
287 } catch (UnixException x) {
288 return x.asIOException(dir);
289 }
290 if (!attrs.isDirectory()) {
291 return new NotDirectoryException(dir.getPathForExceptionMessage());
292 }
293
294 // if already registered then update the events and return existing key
295 UnixFileKey fileKey = attrs.fileKey();
296 SolarisWatchKey watchKey = fileKey2WatchKey.get(fileKey);
297 if (watchKey != null) {
298 try {
299 updateEvents(watchKey, events);
300 } catch (UnixException x) {
301 return x.asIOException(dir);
302 }
303 return watchKey;
304 }
305
306 // register directory
307 long object = 0L;
308 try {
309 object = registerImpl(dir, (FILE_MODIFIED | FILE_ATTRIB));
310 } catch (UnixException x) {
311 return x.asIOException(dir);
312 }
313
314 // create watch key and insert it into maps
315 watchKey = new SolarisWatchKey(watcher, dir, fileKey, object, events);
316 object2Node.put(object, watchKey);
317 fileKey2WatchKey.put(fileKey, watchKey);
318
319 // register all entries in directory
320 registerChildren(dir, watchKey, false, false);
321
322 return watchKey;
323 }
324
325 // release resources for single entry
326 void releaseChild(EntryNode node) {
327 long object = node.object();
328 if (object != 0L) {
329 object2Node.remove(object);
330 releaseObject(object, true);
331 node.setObject(0L);
332 }
333 }
334
335 // release resources for entries in directory
336 void releaseChildren(SolarisWatchKey key) {
337 for (EntryNode node: key.children().values()) {
338 releaseChild(node);
339 }
340 }
341
342 // cancel single key
343 @Override
344 void implCancelKey(WatchKey obj) {
345 SolarisWatchKey key = (SolarisWatchKey)obj;
346 if (key.isValid()) {
347 fileKey2WatchKey.remove(key.getFileKey());
348
349 // release resources for entries
350 releaseChildren(key);
351
352 // release resources for directory
353 long object = key.object();
354 object2Node.remove(object);
355 releaseObject(object, true);
356
357 // and finally invalidate the key
358 key.invalidate();
359 }
360 }
361
362 // close watch service
363 @Override
364 void implCloseAll() {
365 // release all native resources
366 for (Long object: object2Node.keySet()) {
367 releaseObject(object, true);
368 }
369
370 // invalidate all keys
371 for (Map.Entry<UnixFileKey,SolarisWatchKey> entry: fileKey2WatchKey.entrySet()) {
372 entry.getValue().invalidate();
373 }
374
375 // clean-up
376 object2Node.clear();
377 fileKey2WatchKey.clear();
378
379 // free global resources
380 unsafe.freeMemory(bufferAddress);
381 UnixNativeDispatcher.close(port);
382 }
383
384 /**
385 * Poller main loop. Blocks on port_getn waiting for events and then
386 * processes them.
387 */
388 @Override
389 public void run() {
390 try {
391 for (;;) {
392 int n = portGetn(port, bufferAddress, MAX_EVENT_COUNT);
393 assert n > 0;
394
395 long address = bufferAddress;
396 for (int i=0; i<n; i++) {
397 boolean shutdown = processEvent(address);
398 if (shutdown)
399 return;
400 address += SIZEOF_PORT_EVENT;
401 }
402 }
403 } catch (UnixException x) {
404 x.printStackTrace();
405 }
406 }
407
408 /**
409 * Process a single port_event
410 *
411 * Returns true if poller thread is requested to shutdown.
412 */
413 boolean processEvent(long address) {
414 // pe->portev_source
415 short source = unsafe.getShort(address + OFFSETOF_SOURCE);
416 // pe->portev_object
417 long object = unsafe.getAddress(address + OFFSETOF_OBJECT);
418 // pe->portev_events
419 int events = unsafe.getInt(address + OFFSETOF_EVENTS);
420
421 // user event is trigger to process pending requests
422 if (source != PORT_SOURCE_FILE) {
423 if (source == PORT_SOURCE_USER) {
424 // process any pending requests
425 boolean shutdown = processRequests();
426 if (shutdown)
427 return true;
428 }
429 return false;
430 }
431
432 // lookup object to get Node
433 Node node = object2Node.get(object);
434 if (node == null) {
435 // should not happen
436 return false;
437 }
438
439 // As a workaround for 6642290 and 6636438/6636412 we don't use
440 // FILE_EXCEPTION events to tell use not to register the file.
441 // boolean reregister = (events & FILE_EXCEPTION) == 0;
442 boolean reregister = true;
443
444 // If node is EntryNode then event relates to entry in directory
445 // If node is a SolarisWatchKey (DirectoryNode) then event relates
446 // to a watched directory.
447 boolean isDirectory = (node instanceof SolarisWatchKey);
448 if (isDirectory) {
449 processDirectoryEvents((SolarisWatchKey)node, events);
450 } else {
451 boolean ignore = processEntryEvents((EntryNode)node, events);
452 if (ignore)
453 reregister = false;
454 }
455
456 // need to re-associate to get further events
457 if (reregister) {
458 try {
459 events = FILE_MODIFIED | FILE_ATTRIB;
460 if (!isDirectory) events |= FILE_NOFOLLOW;
461 portAssociate(port,
462 PORT_SOURCE_FILE,
463 object,
464 events);
465 } catch (UnixException x) {
466 // unable to re-register
467 reregister = false;
468 }
469 }
470
471 // object is not re-registered so release resources. If
472 // object is a watched directory then signal key
473 if (!reregister) {
474 // release resources
475 object2Node.remove(object);
476 releaseObject(object, false);
477
478 // if watch key then signal it
479 if (isDirectory) {
480 SolarisWatchKey key = (SolarisWatchKey)node;
481 fileKey2WatchKey.remove( key.getFileKey() );
482 key.invalidate();
483 key.signal();
484 } else {
485 // if entry then remove it from parent
486 EntryNode entry = (EntryNode)node;
487 SolarisWatchKey key = (SolarisWatchKey)entry.parent();
488 key.removeChild(entry.name());
489 }
490 }
491
492 return false;
493 }
494
495 /**
496 * Process directory events. If directory is modified then re-scan
497 * directory to register any new entries
498 */
499 void processDirectoryEvents(SolarisWatchKey key, int mask) {
500 if ((mask & (FILE_MODIFIED | FILE_ATTRIB)) != 0) {
501 registerChildren(key.getDirectory(), key,
502 key.events().contains(StandardWatchEventKinds.ENTRY_CREATE),
503 key.events().contains(StandardWatchEventKinds.ENTRY_DELETE));
504 }
505 }
506
507 /**
508 * Process events for entries in registered directories. Returns {@code
509 * true} if events are ignored because the watch key has been cancelled.
510 */
511 boolean processEntryEvents(EntryNode node, int mask) {
512 SolarisWatchKey key = (SolarisWatchKey)node.parent();
513 Set<? extends WatchEvent.Kind<?>> events = key.events();
514 if (events == null) {
515 // key has been cancelled so ignore event
516 return true;
517 }
518
519 // entry modified
520 if (((mask & (FILE_MODIFIED | FILE_ATTRIB)) != 0) &&
521 events.contains(StandardWatchEventKinds.ENTRY_MODIFY))
522 {
523 key.signalEvent(StandardWatchEventKinds.ENTRY_MODIFY, node.name());
524 }
525
526
527 return false;
528 }
529
530 /**
531 * Registers all entries in the given directory
532 *
533 * The {@code sendCreateEvents} and {@code sendDeleteEvents} parameters
534 * indicates if ENTRY_CREATE and ENTRY_DELETE events should be queued
535 * when new entries are found. When initially registering a directory
536 * they will always be false. When re-scanning a directory then it
537 * depends on if the events are enabled or not.
538 */
539 void registerChildren(UnixPath dir,
540 SolarisWatchKey parent,
541 boolean sendCreateEvents,
542 boolean sendDeleteEvents)
543 {
544 boolean isModifyEnabled =
545 parent.events().contains(StandardWatchEventKinds.ENTRY_MODIFY) ;
546
547 // reset visited flag on entries so that we can detect file deletes
548 for (EntryNode node: parent.children().values()) {
549 node.setVisited(false);
550 }
551
552 try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
553 for (Path entry: stream) {
554 Path name = entry.getFileName();
555
556 // skip entry if already registered
557 EntryNode node = parent.getChild(name);
558 if (node != null) {
559 node.setVisited(true);
560 continue;
561 }
562
563 // new entry found
564
565 long object = 0L;
566 int errno = 0;
567 boolean addNode = false;
568
569 // if ENTRY_MODIFY enabled then we register the entry for events
570 if (isModifyEnabled) {
571 try {
572 UnixPath path = (UnixPath)entry;
573 int events = (FILE_NOFOLLOW | FILE_MODIFIED | FILE_ATTRIB);
574 object = registerImpl(path, events);
575 addNode = true;
576 } catch (UnixException x) {
577 errno = x.errno();
578 }
579 } else {
580 addNode = true;
581 }
582
583 if (addNode) {
584 // create node
585 node = new EntryNode(object, (UnixPath)entry.getFileName(), parent);
586 node.setVisited(true);
587 // tell the parent about it
588 parent.addChild(entry.getFileName(), node);
589 if (object != 0L)
590 object2Node.put(object, node);
591 }
592
593 // send ENTRY_CREATE event for the new file
594 // send ENTRY_DELETE event for files that were deleted immediately
595 boolean deleted = (errno == ENOENT);
596 if (sendCreateEvents && (addNode || deleted))
597 parent.signalEvent(StandardWatchEventKinds.ENTRY_CREATE, name);
598 if (sendDeleteEvents && deleted)
599 parent.signalEvent(StandardWatchEventKinds.ENTRY_DELETE, name);
600
601 }
602 } catch (DirectoryIteratorException | IOException x) {
603 // queue OVERFLOW event so that user knows to re-scan directory
604 parent.signalEvent(StandardWatchEventKinds.OVERFLOW, null);
605 return;
606 }
607
608 // clean-up and send ENTRY_DELETE events for any entries that were
609 // not found
610 Iterator<Map.Entry<Path,EntryNode>> iterator =
611 parent.children().entrySet().iterator();
612 while (iterator.hasNext()) {
613 Map.Entry<Path,EntryNode> entry = iterator.next();
614 EntryNode node = entry.getValue();
615 if (!node.isVisited()) {
616 long object = node.object();
617 if (object != 0L) {
618 object2Node.remove(object);
619 releaseObject(object, true);
620 }
621 if (sendDeleteEvents)
622 parent.signalEvent(StandardWatchEventKinds.ENTRY_DELETE, node.name());
623 iterator.remove();
624 }
625 }
626 }
627
628 /**
629 * Update watch key's events. If ENTRY_MODIFY changes to be enabled
630 * then register each file in the directory; If ENTRY_MODIFY changed to
631 * be disabled then unregister each file.
632 */
633 void updateEvents(SolarisWatchKey key, Set<? extends WatchEvent.Kind<?>> events)
634 throws UnixException
635 {
636
637 // update events, remembering if ENTRY_MODIFY was previously
638 // enabled or disabled.
639 boolean oldModifyEnabled = key.events()
640 .contains(StandardWatchEventKinds.ENTRY_MODIFY);
641 key.setEvents(events);
642
643 // check if ENTRY_MODIFY has changed
644 boolean newModifyEnabled = events
645 .contains(StandardWatchEventKinds.ENTRY_MODIFY);
646 if (newModifyEnabled != oldModifyEnabled) {
647 UnixException ex = null;
648 for (EntryNode node: key.children().values()) {
649 if (newModifyEnabled) {
650 // register
651 UnixPath path = key.getDirectory().resolve(node.name());
652 int ev = (FILE_NOFOLLOW | FILE_MODIFIED | FILE_ATTRIB);
653 try {
654 long object = registerImpl(path, ev);
655 object2Node.put(object, node);
656 node.setObject(object);
657 } catch (UnixException x) {
658 // if file has been deleted then it will be detected
659 // as a FILE_MODIFIED event on the directory
660 if (x.errno() != ENOENT) {
661 ex = x;
662 break;
663 }
664 }
665 } else {
666 // unregister
667 releaseChild(node);
668 }
669 }
670
671 // an error occurred
672 if (ex != null) {
673 releaseChildren(key);
674 throw ex;
675 }
676 }
677 }
678
679 /**
680 * Calls port_associate to register the given path.
681 * Returns pointer to fileobj structure that is allocated for
682 * the registration.
683 */
684 long registerImpl(UnixPath dir, int events)
685 throws UnixException
686 {
687 // allocate memory for the path (file_obj->fo_name field)
688 byte[] path = dir.getByteArrayForSysCalls();
689 int len = path.length;
690 long name = unsafe.allocateMemory(len+1);
691 unsafe.copyMemory(path, Unsafe.ARRAY_BYTE_BASE_OFFSET, null,
692 name, (long)len);
693 unsafe.putByte(name + len, (byte)0);
694
695 // allocate memory for filedatanode structure - this is the object
696 // to port_associate
697 long object = unsafe.allocateMemory(SIZEOF_FILEOBJ);
698 unsafe.setMemory(null, object, SIZEOF_FILEOBJ, (byte)0);
699 unsafe.putAddress(object + OFFSET_FO_NAME, name);
700
701 // associate the object with the port
702 try {
703 portAssociate(port,
704 PORT_SOURCE_FILE,
705 object,
706 events);
707 } catch (UnixException x) {
708 // debugging
709 if (x.errno() == EAGAIN) {
710 System.err.println("The maximum number of objects associated "+
711 "with the port has been reached");
712 }
713
714 unsafe.freeMemory(name);
715 unsafe.freeMemory(object);
716 throw x;
717 }
718 return object;
719 }
720
721 /**
722 * Frees all resources for an file_obj object; optionally remove
723 * association from port
724 */
725 void releaseObject(long object, boolean dissociate) {
726 // remove association
727 if (dissociate) {
728 try {
729 portDissociate(port, PORT_SOURCE_FILE, object);
730 } catch (UnixException x) {
731 // ignore
732 }
733 }
734
735 // free native memory
736 long name = unsafe.getAddress(object + OFFSET_FO_NAME);
737 unsafe.freeMemory(name);
738 unsafe.freeMemory(object);
739 }
740 }
741
742 /**
743 * A node with native (file_obj) resources
744 */
745 private static interface Node {
746 long object();
747 }
748
749 /**
750 * A directory node with a map of the entries in the directory
751 */
752 private static interface DirectoryNode extends Node {
753 void addChild(Path name, EntryNode node);
754 void removeChild(Path name);
755 EntryNode getChild(Path name);
756 }
757
758 /**
759 * An implementation of a node that is an entry in a directory.
760 */
761 private static class EntryNode implements Node {
762 private long object;
763 private final UnixPath name;
764 private final DirectoryNode parent;
765 private boolean visited;
766
767 EntryNode(long object, UnixPath name, DirectoryNode parent) {
768 this.object = object;
769 this.name = name;
770 this.parent = parent;
771 }
772
773 @Override
774 public long object() {
775 return object;
776 }
777
778 void setObject(long ptr) {
779 this.object = ptr;
780 }
781
782 UnixPath name() {
783 return name;
784 }
785
786 DirectoryNode parent() {
787 return parent;
788 }
789
790 boolean isVisited() {
791 return visited;
792 }
793
794 void setVisited(boolean v) {
795 this.visited = v;
796 }
797 }
798
799 // -- native methods --
800
801 private static native void init();
802
803 private static native int portCreate() throws UnixException;
804
805 private static native void portAssociate(int port, int source, long object, int events)
806 throws UnixException;
807
808 private static native void portDissociate(int port, int source, long object)
809 throws UnixException;
810
811 private static native void portSend(int port, int events)
812 throws UnixException;
813
814 private static native int portGetn(int port, long address, int max)
815 throws UnixException;
816
817 static {
818 jdk.internal.loader.BootLoader.loadLibrary("nio");
819 init();
820 }
821 }