1 /*
2 * Copyright (c) 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 jdk.net;
27
28 import java.io.FileDescriptor;
29 import java.net.SocketException;
30 import java.net.SocketOption;
31 import java.security.AccessController;
32 import java.security.PrivilegedAction;
33 import java.util.Collections;
34 import java.util.Set;
35 import jdk.internal.access.JavaIOFileDescriptorAccess;
36 import jdk.internal.access.SharedSecrets;
37 import java.lang.annotation.Native;
38
39 /**
40 * Defines socket options specific to RDMA-based TCP sockets and channels.
41 *
42 * @since 12
43 */
44 public final class RdmaSocketOptions {
45
46 private static class RdmaSocketOption<T> implements SocketOption<T> {
47 private final String name;
48 private final Class<T> type;
49 RdmaSocketOption(String name, Class<T> type) {
50 this.name = name;
51 this.type = type;
52 }
53 @Override public String name() { return name; }
54 @Override public Class<T> type() { return type; }
55 @Override public String toString() { return name; }
56 }
57
58 private RdmaSocketOptions() { }
59
60 /**
61 * The integer size of the underlying RDMA send queue used by the
62 * platform for network I/O.
63 *
64 * The initial/default size of the RDMA send queue and the range of
65 * allowable values is system and device dependent although a negative
66 * size is not allowed.
67 *
68 * <p> An implementation allows this socket option to be set before the
69 * socket is bound or connected. Changing the value of this socket option
70 * after the socket is bound or connected has no effect.
71 *
72 * Valid for RDMA-based TCP sockets.
73 */
74 public static final SocketOption<Integer> RDMA_SQSIZE = new
75 RdmaSocketOption<Integer>("RDMA_SQSIZE", Integer.class);
76
77 /**
78 * The integer size of the underlying RDMA receive queue used by the
79 * platform for network I/O.
80 *
81 * The initial/default size of the RDMA receive queue and the range of
82 * allowable values is system and device dependent although a negative
83 * size is not allowed.
84 *
85 * <p> An implementation allows this socket option to be set before the
86 * socket is bound or connected. Changing the value of this socket option
87 * after the socket is bound or connected has no effect.
88 *
89 * Valid for RDMA-based TCP sockets.
90 */
91 public static final SocketOption<Integer> RDMA_RQSIZE = new
92 RdmaSocketOption<Integer>("RDMA_RQSIZE", Integer.class);
93
94 /**
95 * The integer size of the underlying RDMA inline data used by the
96 * platform for network I/O.
97 *
98 * The initial/default size of the RDMA inline data and the range of
99 * allowable values is system and device dependent although a negative
100 * size is not allowed.
101 *
102 * <p> An implementation allows this socket option to be set before the
103 * socket is bound or connected. Changing the value of this socket option
104 * after the socket is bound or connected has no effect.
105 *
106 * Valid for RDMA-based TCP sockets.
107 */
108 public static final SocketOption<Integer> RDMA_INLINE = new
109 RdmaSocketOption<Integer>("RDMA_INLINE", Integer.class);
110
111 @Native private static final int SQSIZE = 0x3001;
112
113 @Native private static final int RQSIZE = 0x3002;
114
115 @Native private static final int INLINE = 0x3003;
116
117 private static final PlatformRdmaSocketOptions platformRdmaSocketOptions =
118 PlatformRdmaSocketOptions.get();
119
120 private static final boolean rdmaSocketSupported =
121 platformRdmaSocketOptions.rdmaSocketSupported();
122
123 private static final Set<SocketOption<?>> rdmaOptions = options();
124
125 static Set<SocketOption<?>> options() {
126 if (rdmaSocketSupported)
127 return Set.of(RDMA_SQSIZE, RDMA_RQSIZE, RDMA_INLINE);
128 else
129 return Collections.<SocketOption<?>>emptySet();
130 }
131
132 static {
133 sun.net.ext.RdmaSocketOptions.register(
134 new sun.net.ext.RdmaSocketOptions(rdmaOptions) {
135
136 @Override
137 public void setOption(FileDescriptor fd,
138 SocketOption<?> option, Object value)
139 throws SocketException {
140 SecurityManager sm = System.getSecurityManager();
141 if (sm != null)
142 sm.checkPermission(new NetworkPermission("setOption."
143 + option.name()));
144
145 if (fd == null || !fd.valid())
146 throw new SocketException("socket closed");
147
148 if ((option == RDMA_SQSIZE) || (option == RDMA_RQSIZE)
149 || (option == RDMA_INLINE)) {
150 assert rdmaSocketSupported;
151
152 int val;
153 int opt;
154 if (option == RDMA_SQSIZE) {
155 if (value == null || (!(value instanceof Integer)))
156 throw new SocketException(
157 "Bad parameter for RDMA_SQSIZE");
158 val = ((Integer) value).intValue();
159 opt = SQSIZE;
160 if (val < 0)
161 throw new IllegalArgumentException(
162 "send queue size < 0");
163 } else if (option == RDMA_RQSIZE) {
164 if (value == null || (!(value instanceof Integer)))
165 throw new SocketException(
166 "Bad parameter for RDMA_RQSIZE");
167 val = ((Integer) value).intValue();
168 opt = RQSIZE;
169 if (val < 0)
170 throw new IllegalArgumentException(
171 "receive queue size < 0");
172 } else if (option == RDMA_INLINE) {
173 if (value == null || (!(value instanceof Integer)))
174 throw new SocketException(
175 "Bad parameter for RDMA_INLINE");
176 val = ((Integer) value).intValue();
177 opt = INLINE;
178 if (val < 0)
179 throw new IllegalArgumentException(
180 "inline size < 0");
181 } else {
182 throw new SocketException(
183 "unrecognized RDMA socket option: " + option);
184 }
185
186 setSockOpt(fd, opt, val);
187
188 } else {
189 throw new InternalError("Unexpected option " + option);
190 }
191 }
192
193 @Override
194 public Object getOption(FileDescriptor fd,
195 SocketOption<?> option) throws SocketException {
196 SecurityManager sm = System.getSecurityManager();
197 if (sm != null)
198 sm.checkPermission(new NetworkPermission("getOption."
199 + option.name()));
200
201 if (fd == null || !fd.valid())
202 throw new SocketException("socket closed");
203
204 if ((option == RDMA_SQSIZE) || (option == RDMA_RQSIZE)
205 || (option == RDMA_INLINE)) {
206 assert rdmaSocketSupported;
207 int opt;
208 if (option == RDMA_SQSIZE) {
209 opt = SQSIZE;
210 } else if (option == RDMA_RQSIZE) {
211 opt = RQSIZE;
212 } else {
213 opt = INLINE;
214 }
215 return getSockOpt(fd, opt);
216 } else {
217 throw new InternalError("Unexpected option " + option);
218 }
219 }
220 });
221 }
222
223 private static final JavaIOFileDescriptorAccess fdAccess =
224 SharedSecrets.getJavaIOFileDescriptorAccess();
225
226 private static void setSockOpt(FileDescriptor fd, int opt, int val)
227 throws SocketException {
228 platformRdmaSocketOptions.setSockOpt(fdAccess.get(fd), opt, val);
229 }
230
231 private static int getSockOpt(FileDescriptor fd, int opt)
232 throws SocketException {
233 return platformRdmaSocketOptions.getSockOpt(fdAccess.get(fd), opt);
234 }
235
236 static class PlatformRdmaSocketOptions {
237
238 protected PlatformRdmaSocketOptions() {}
239
240 @SuppressWarnings("unchecked")
241 private static PlatformRdmaSocketOptions newInstance(String cn) {
242 Class<PlatformRdmaSocketOptions> c;
243 try {
244 c = (Class<PlatformRdmaSocketOptions>)Class.forName(cn);
245 return c.getConstructor(new Class<?>[] { }).newInstance();
246 } catch (ReflectiveOperationException x) {
247 if (x.getCause() instanceof UnsupportedOperationException)
248 throw (UnsupportedOperationException)x.getCause();
249 throw new AssertionError(x);
250 }
251 }
252
253 private static PlatformRdmaSocketOptions create() {
254 String osname = AccessController.doPrivileged(
255 new PrivilegedAction<String>() {
256 public String run() {
257 return System.getProperty("os.name");
258 }
259 });
260 if ("Linux".equals(osname)) {
261 try {
262 return newInstance("jdk.net.LinuxRdmaSocketOptions");
263 } catch (UnsupportedOperationException uoe) {
264 return new PlatformRdmaSocketOptions();
265 }
266 }
267 return new PlatformRdmaSocketOptions();
268 }
269
270 private static final PlatformRdmaSocketOptions instance = create();
271
272 static PlatformRdmaSocketOptions get() {
273 return instance;
274 }
275
276 void setSockOpt(int fd, int opt, int value) throws SocketException {
277 throw new UnsupportedOperationException(
278 "unsupported socket option");
279 }
280
281 int getSockOpt(int fd, int opt) throws SocketException {
282 throw new UnsupportedOperationException(
283 "unsupported socket option");
284 }
285
286 boolean rdmaSocketSupported() {
287 return false;
288 }
289 }
290 }