1 /*
2 * Copyright (c) 2008, 2018, 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.security.AccessController;
30 import java.security.PrivilegedAction;
31 import java.util.*;
32 import java.io.IOException;
33 import jdk.internal.misc.Unsafe;
34
35 import static sun.nio.fs.UnixNativeDispatcher.*;
36 import static sun.nio.fs.UnixConstants.*;
37
38 /**
39 * Linux implementation of WatchService based on inotify.
40 *
41 * In summary a background thread polls inotify plus a socket used for the wakeup
42 * mechanism. Requests to add or remove a watch, or close the watch service,
43 * cause the thread to wakeup and process the request. Events are processed
44 * by the thread which causes it to signal/queue the corresponding watch keys.
45 */
46
47 class LinuxWatchService
48 extends AbstractWatchService
49 {
50 private static final Unsafe unsafe = Unsafe.getUnsafe();
51
52 // background thread to read change events
53 private final Poller poller;
54
55 LinuxWatchService(UnixFileSystem fs) throws IOException {
56 // initialize inotify
57 int ifd = - 1;
58 try {
59 ifd = inotifyInit();
60 } catch (UnixException x) {
61 String msg = (x.errno() == EMFILE) ?
62 "User limit of inotify instances reached or too many open files" :
63 x.errorString();
64 throw new IOException(msg);
65 }
66
67 // configure inotify to be non-blocking
68 // create socketpair used in the close mechanism
69 int sp[] = new int[2];
70 try {
71 configureBlocking(ifd, false);
72 socketpair(sp);
73 configureBlocking(sp[0], false);
74 } catch (UnixException x) {
75 UnixNativeDispatcher.close(ifd);
76 throw new IOException(x.errorString());
77 }
78
79 this.poller = new Poller(fs, this, ifd, sp);
80 this.poller.start();
81 }
82
83 @Override
84 WatchKey register(Path dir,
85 WatchEvent.Kind<?>[] events,
86 WatchEvent.Modifier... modifiers)
87 throws IOException
88 {
89 // delegate to poller
90 return poller.register(dir, events, modifiers);
91 }
92
93 @Override
94 void implClose() throws IOException {
95 // delegate to poller
96 poller.close();
97 }
98
99 /**
100 * WatchKey implementation
101 */
102 private static class LinuxWatchKey extends AbstractWatchKey {
103 // inotify descriptor
104 private final int ifd;
105 // watch descriptor
106 private volatile int wd;
107
108 LinuxWatchKey(UnixPath dir, LinuxWatchService watcher, int ifd, int wd) {
109 super(dir, watcher);
110 this.ifd = ifd;
111 this.wd = wd;
112 }
113
114 int descriptor() {
115 return wd;
116 }
117
118 void invalidate(boolean remove) {
119 if (remove) {
120 try {
121 inotifyRmWatch(ifd, wd);
122 } catch (UnixException x) {
123 // ignore
124 }
125 }
126 wd = -1;
127 }
128
129 @Override
130 public boolean isValid() {
131 return (wd != -1);
132 }
133
134 @Override
135 public void cancel() {
136 if (isValid()) {
137 // delegate to poller
138 ((LinuxWatchService)watcher()).poller.cancel(this);
139 }
140 }
141 }
142
143 /**
144 * Background thread to read from inotify
145 */
146 private static class Poller extends AbstractPoller {
147 /**
148 * struct inotify_event {
149 * int wd;
150 * uint32_t mask;
151 * uint32_t len;
152 * char name __flexarr; // present if len > 0
153 * } act_t;
154 */
155 private static final int SIZEOF_INOTIFY_EVENT = eventSize();
156 private static final int[] offsets = eventOffsets();
157 private static final int OFFSETOF_WD = offsets[0];
158 private static final int OFFSETOF_MASK = offsets[1];
159 private static final int OFFSETOF_LEN = offsets[3];
160 private static final int OFFSETOF_NAME = offsets[4];
161
162 private static final int IN_MODIFY = 0x00000002;
163 private static final int IN_ATTRIB = 0x00000004;
164 private static final int IN_MOVED_FROM = 0x00000040;
165 private static final int IN_MOVED_TO = 0x00000080;
166 private static final int IN_CREATE = 0x00000100;
167 private static final int IN_DELETE = 0x00000200;
168
169 private static final int IN_UNMOUNT = 0x00002000;
170 private static final int IN_Q_OVERFLOW = 0x00004000;
171 private static final int IN_IGNORED = 0x00008000;
172
173 // sizeof buffer for when polling inotify
174 private static final int BUFFER_SIZE = 8192;
175
176 private final UnixFileSystem fs;
177 private final LinuxWatchService watcher;
178
179 // inotify file descriptor
180 private final int ifd;
181 // socketpair used to shutdown polling thread
182 private final int socketpair[];
183 // maps watch descriptor to Key
184 private final Map<Integer,LinuxWatchKey> wdToKey;
185 // address of read buffer
186 private final long address;
187
188 Poller(UnixFileSystem fs, LinuxWatchService watcher, int ifd, int[] sp) {
189 this.fs = fs;
190 this.watcher = watcher;
191 this.ifd = ifd;
192 this.socketpair = sp;
193 this.wdToKey = new HashMap<>();
194 this.address = unsafe.allocateMemory(BUFFER_SIZE);
195 }
196
197 @Override
198 void wakeup() throws IOException {
199 // write to socketpair to wakeup polling thread
200 try {
201 write(socketpair[1], address, 1);
202 } catch (UnixException x) {
203 throw new IOException(x.errorString());
204 }
205 }
206
207 @Override
208 Object implRegister(Path obj,
209 Set<? extends WatchEvent.Kind<?>> events,
210 WatchEvent.Modifier... modifiers)
211 {
212 UnixPath dir = (UnixPath)obj;
213
214 int mask = 0;
215 for (WatchEvent.Kind<?> event: events) {
216 if (event == StandardWatchEventKinds.ENTRY_CREATE) {
217 mask |= IN_CREATE | IN_MOVED_TO;
218 continue;
219 }
220 if (event == StandardWatchEventKinds.ENTRY_DELETE) {
221 mask |= IN_DELETE | IN_MOVED_FROM;
222 continue;
223 }
224 if (event == StandardWatchEventKinds.ENTRY_MODIFY) {
225 mask |= IN_MODIFY | IN_ATTRIB;
226 continue;
227 }
228 }
229
230 // no modifiers supported at this time
231 if (modifiers.length > 0) {
232 for (WatchEvent.Modifier modifier: modifiers) {
233 if (modifier == null)
234 return new NullPointerException();
235 if (!ExtendedOptions.SENSITIVITY_HIGH.matches(modifier) &&
236 !ExtendedOptions.SENSITIVITY_MEDIUM.matches(modifier) &&
237 !ExtendedOptions.SENSITIVITY_LOW.matches(modifier)) {
238 return new UnsupportedOperationException("Modifier not supported");
239 }
240 }
241 }
242
243 // check file is directory
244 UnixFileAttributes attrs = null;
245 try {
246 attrs = UnixFileAttributes.get(dir, true);
247 } catch (UnixException x) {
248 return x.asIOException(dir);
249 }
250 if (!attrs.isDirectory()) {
251 return new NotDirectoryException(dir.getPathForExceptionMessage());
252 }
253
254 // register with inotify (replaces existing mask if already registered)
255 int wd = -1;
256 try {
257 NativeBuffer buffer =
258 NativeBuffers.asNativeBuffer(dir.getByteArrayForSysCalls());
259 try {
260 wd = inotifyAddWatch(ifd, buffer.address(), mask);
261 } finally {
262 buffer.release();
263 }
264 } catch (UnixException x) {
265 if (x.errno() == ENOSPC) {
266 return new IOException("User limit of inotify watches reached");
267 }
268 return x.asIOException(dir);
269 }
270
271 // ensure watch descriptor is in map
272 LinuxWatchKey key = wdToKey.get(wd);
273 if (key == null) {
274 key = new LinuxWatchKey(dir, watcher, ifd, wd);
275 wdToKey.put(wd, key);
276 }
277 return key;
278 }
279
280 // cancel single key
281 @Override
282 void implCancelKey(WatchKey obj) {
283 LinuxWatchKey key = (LinuxWatchKey)obj;
284 if (key.isValid()) {
285 wdToKey.remove(key.descriptor());
286 key.invalidate(true);
287 }
288 }
289
290 // close watch service
291 @Override
292 void implCloseAll() {
293 // invalidate all keys
294 for (Map.Entry<Integer,LinuxWatchKey> entry: wdToKey.entrySet()) {
295 entry.getValue().invalidate(true);
296 }
297 wdToKey.clear();
298
299 // free resources
300 unsafe.freeMemory(address);
301 UnixNativeDispatcher.close(socketpair[0]);
302 UnixNativeDispatcher.close(socketpair[1]);
303 UnixNativeDispatcher.close(ifd);
304 }
305
306 /**
307 * Poller main loop
308 */
309 @Override
310 public void run() {
311 try {
312 for (;;) {
313 int nReady, bytesRead;
314
315 // wait for close or inotify event
316 nReady = poll(ifd, socketpair[0]);
317
318 // read from inotify
319 try {
320 bytesRead = read(ifd, address, BUFFER_SIZE);
321 } catch (UnixException x) {
322 if (x.errno() != EAGAIN && x.errno() != EWOULDBLOCK)
323 throw x;
324 bytesRead = 0;
325 }
326
327 // iterate over buffer to decode events
328 int offset = 0;
329 while (offset < bytesRead) {
330 long event = address + offset;
331 int wd = unsafe.getInt(event + OFFSETOF_WD);
332 int mask = unsafe.getInt(event + OFFSETOF_MASK);
333 int len = unsafe.getInt(event + OFFSETOF_LEN);
334
335 // file name
336 UnixPath name = null;
337 if (len > 0) {
338 int actual = len;
339
340 // null-terminated and maybe additional null bytes to
341 // align the next event
342 while (actual > 0) {
343 long last = event + OFFSETOF_NAME + actual - 1;
344 if (unsafe.getByte(last) != 0)
345 break;
346 actual--;
347 }
348 if (actual > 0) {
349 byte[] buf = new byte[actual];
350 unsafe.copyMemory(null, event + OFFSETOF_NAME,
351 buf, Unsafe.ARRAY_BYTE_BASE_OFFSET, actual);
352 name = new UnixPath(fs, buf);
353 }
354 }
355
356 // process event
357 processEvent(wd, mask, name);
358
359 offset += (SIZEOF_INOTIFY_EVENT + len);
360 }
361
362 // process any pending requests
363 if ((nReady > 1) || (nReady == 1 && bytesRead == 0)) {
364 try {
365 read(socketpair[0], address, BUFFER_SIZE);
366 boolean shutdown = processRequests();
367 if (shutdown)
368 break;
369 } catch (UnixException x) {
370 if (x.errno() != EAGAIN && x.errno() != EWOULDBLOCK)
371 throw x;
372 }
373 }
374 }
375 } catch (UnixException x) {
376 x.printStackTrace();
377 }
378 }
379
380
381 /**
382 * map inotify event to WatchEvent.Kind
383 */
384 private WatchEvent.Kind<?> maskToEventKind(int mask) {
385 if ((mask & IN_MODIFY) > 0)
386 return StandardWatchEventKinds.ENTRY_MODIFY;
387 if ((mask & IN_ATTRIB) > 0)
388 return StandardWatchEventKinds.ENTRY_MODIFY;
389 if ((mask & IN_CREATE) > 0)
390 return StandardWatchEventKinds.ENTRY_CREATE;
391 if ((mask & IN_MOVED_TO) > 0)
392 return StandardWatchEventKinds.ENTRY_CREATE;
393 if ((mask & IN_DELETE) > 0)
394 return StandardWatchEventKinds.ENTRY_DELETE;
395 if ((mask & IN_MOVED_FROM) > 0)
396 return StandardWatchEventKinds.ENTRY_DELETE;
397 return null;
398 }
399
400 /**
401 * Process event from inotify
402 */
403 private void processEvent(int wd, int mask, final UnixPath name) {
404 // overflow - signal all keys
405 if ((mask & IN_Q_OVERFLOW) > 0) {
406 for (Map.Entry<Integer,LinuxWatchKey> entry: wdToKey.entrySet()) {
407 entry.getValue()
408 .signalEvent(StandardWatchEventKinds.OVERFLOW, null);
409 }
410 return;
411 }
412
413 // lookup wd to get key
414 LinuxWatchKey key = wdToKey.get(wd);
415 if (key == null)
416 return; // should not happen
417
418 // file deleted
419 if ((mask & IN_IGNORED) > 0) {
420 wdToKey.remove(wd);
421 key.invalidate(false);
422 key.signal();
423 return;
424 }
425
426 // event for directory itself
427 if (name == null)
428 return;
429
430 // map to event and queue to key
431 WatchEvent.Kind<?> kind = maskToEventKind(mask);
432 if (kind != null) {
433 key.signalEvent(kind, name);
434 }
435 }
436 }
437
438 // -- native methods --
439
440 // sizeof inotify_event
441 private static native int eventSize();
442
443 // offsets of inotify_event
444 private static native int[] eventOffsets();
445
446 private static native int inotifyInit() throws UnixException;
447
448 private static native int inotifyAddWatch(int fd, long pathAddress, int mask)
449 throws UnixException;
450
451 private static native void inotifyRmWatch(int fd, int wd)
452 throws UnixException;
453
454 private static native void configureBlocking(int fd, boolean blocking)
455 throws UnixException;
456
457 private static native void socketpair(int[] sv) throws UnixException;
458
459 private static native int poll(int fd1, int fd2) throws UnixException;
460
461 static {
462 AccessController.doPrivileged(new PrivilegedAction<>() {
463 public Void run() {
464 System.loadLibrary("nio");
465 return null;
466 }});
467 }
468 }