1 /*
2 * Copyright (c) 2012, 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.ch;
27
28 import java.io.IOException;
29 import java.nio.channels.*;
30 import java.nio.channels.spi.*;
31 import java.util.Map;
32 import java.util.HashMap;
33 import java.util.Iterator;
34
35 /**
36 * Selector implementation based on the Solaris event port mechanism.
37 */
38
39 class EventPortSelectorImpl
40 extends SelectorImpl
41 {
42 private final EventPortWrapper pollWrapper;
43
44 // Maps from file descriptors to keys
45 private Map<Integer,SelectionKeyImpl> fdToKey;
46
47 // True if this Selector has been closed
48 private boolean closed = false;
49
50 // Lock for interrupt triggering and clearing
51 private final Object interruptLock = new Object();
52 private boolean interruptTriggered = false;
53
54 /**
55 * Package private constructor called by factory method in
56 * the abstract superclass Selector.
57 */
58 EventPortSelectorImpl(SelectorProvider sp) throws IOException {
59 super(sp);
60 pollWrapper = new EventPortWrapper();
61 fdToKey = new HashMap<>();
62 }
63
64 protected int doSelect(long timeout) throws IOException {
65 if (closed)
66 throw new ClosedSelectorException();
67 processDeregisterQueue();
68 int entries;
69 try {
70 begin();
71 entries = pollWrapper.poll(timeout);
72 } finally {
73 end();
74 }
75 processDeregisterQueue();
76 int numKeysUpdated = updateSelectedKeys(entries);
77 if (pollWrapper.interrupted()) {
78 synchronized (interruptLock) {
79 interruptTriggered = false;
80 }
81 }
82 return numKeysUpdated;
83 }
84
85 private int updateSelectedKeys(int entries) {
86 int numKeysUpdated = 0;
87 for (int i=0; i<entries; i++) {
88 int nextFD = pollWrapper.getDescriptor(i);
89 SelectionKeyImpl ski = fdToKey.get(Integer.valueOf(nextFD));
90 if (ski != null) {
91 int rOps = pollWrapper.getEventOps(i);
92 if (selectedKeys.contains(ski)) {
93 if (ski.channel.translateAndSetReadyOps(rOps, ski)) {
94 numKeysUpdated++;
95 }
96 } else {
97 ski.channel.translateAndSetReadyOps(rOps, ski);
98 if ((ski.nioReadyOps() & ski.nioInterestOps()) != 0) {
99 selectedKeys.add(ski);
100 numKeysUpdated++;
101 }
102 }
103 }
104 }
105 return numKeysUpdated;
106 }
107
108 protected void implClose() throws IOException {
109 if (closed)
110 return;
111 closed = true;
112
113 // prevent further wakeup
114 synchronized (interruptLock) {
115 interruptTriggered = true;
116 }
117
118 pollWrapper.close();
119 selectedKeys = null;
120
121 // Deregister channels
122 Iterator<SelectionKey> i = keys.iterator();
123 while (i.hasNext()) {
124 SelectionKeyImpl ski = (SelectionKeyImpl)i.next();
125 deregister(ski);
126 SelectableChannel selch = ski.channel();
127 if (!selch.isOpen() && !selch.isRegistered())
128 ((SelChImpl)selch).kill();
129 i.remove();
130 }
131 }
132
133 protected void implRegister(SelectionKeyImpl ski) {
134 int fd = IOUtil.fdVal(ski.channel.getFD());
135 fdToKey.put(Integer.valueOf(fd), ski);
136 keys.add(ski);
137 }
138
139 protected void implDereg(SelectionKeyImpl ski) throws IOException {
140 int i = ski.getIndex();
141 assert (i >= 0);
142 int fd = ski.channel.getFDVal();
143 fdToKey.remove(Integer.valueOf(fd));
144 pollWrapper.release(fd);
145 ski.setIndex(-1);
146 keys.remove(ski);
147 selectedKeys.remove(ski);
148 deregister((AbstractSelectionKey)ski);
149 SelectableChannel selch = ski.channel();
150 if (!selch.isOpen() && !selch.isRegistered())
151 ((SelChImpl)selch).kill();
152 }
153
154 public void putEventOps(SelectionKeyImpl sk, int ops) {
155 if (closed)
156 throw new ClosedSelectorException();
157 int fd = sk.channel.getFDVal();
158 pollWrapper.setInterest(fd, ops);
159 }
160
161 public Selector wakeup() {
162 synchronized (interruptLock) {
163 if (!interruptTriggered) {
164 pollWrapper.interrupt();
165 interruptTriggered = true;
166 }
167 }
168 return this;
169 }
170 }