--- a/src/jdk.net/share/classes/jdk/net/ExtendedSocketOptions.java	Fri Nov 10 03:27:43 2017 +0000
+++ b/src/jdk.net/share/classes/jdk/net/ExtendedSocketOptions.java	Mon Nov 13 14:03:36 2017 +0530
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -67,20 +67,53 @@
     public static final SocketOption<SocketFlow> SO_FLOW_SLA = new
         ExtSocketOption<SocketFlow>("SO_FLOW_SLA", SocketFlow.class);
 
+    /**
+     * Disable Delayed Acknowledgements.
+     *
+     * <p>
+     * This socket option can be used to reduce or disable delayed
+     * acknowledgments (ACKs). When {@code TCP_QUICKACK} is enabled, ACKs are
+     * sent immediately, rather than delayed if needed in accordance to normal
+     * TCP operation. This option is not permanent, it only enables a switch to
+     * or from {@code TCP_QUICKACK} mode. Subsequent operations of the TCP
+     * protocol will once again disable/enable {@code TCP_QUICKACK} mode
+     * depending on internal protocol processing and factors such as delayed ACK
+     * timeouts occurring and data transfer, therefore this option needs to be
+     * set with {@code setOption} after each operation of TCP on a given socket.
+     *
+     * <p>
+     * The value of this socket option is a {@code Boolean} that represents
+     * whether the option is enabled or disabled. The socket option is specific
+     * to stream-oriented sockets using the TCP/IP protocol. The exact semantics
+     * of this socket option are socket type and system dependent.
+     *
+     * @since 10
+     */
+    public static final SocketOption<Boolean> TCP_QUICKACK =
+            new ExtSocketOption<Boolean>("TCP_QUICKACK", Boolean.class);
 
     private static final PlatformSocketOptions platformSocketOptions =
             PlatformSocketOptions.get();
 
     private static final boolean flowSupported =
             platformSocketOptions.flowSupported();
+    private static final boolean quickAckSupported =
+            platformSocketOptions.quickAckSupported();
 
     private static final Set<SocketOption<?>> extendedOptions = options();
 
     static Set<SocketOption<?>> options() {
-        if (flowSupported)
-            return Set.of(SO_FLOW_SLA);
-        else
+        if (flowSupported) {
+            if (quickAckSupported) {
+                return Set.of(SO_FLOW_SLA, TCP_QUICKACK);
+            } else {
+                return Set.of(SO_FLOW_SLA);
+            }
+        } else if (quickAckSupported) {
+            return Set.of(TCP_QUICKACK);
+        } else {
             return Collections.<SocketOption<?>>emptySet();
+        }
     }
 
     static {
@@ -105,6 +138,8 @@
                     assert flowSupported;
                     SocketFlow flow = checkValueType(value, option.type());
                     setFlowOption(fd, flow);
+                } else if (option == TCP_QUICKACK) {
+                    setQuickAckOption(fd, (boolean) value);
                 } else {
                     throw new InternalError("Unexpected option " + option);
                 }
@@ -127,6 +162,8 @@
                     SocketFlow flow = SocketFlow.create();
                     getFlowOption(fd, flow);
                     return flow;
+                } else if (option == TCP_QUICKACK) {
+                    return getQuickAckOption(fd);
                 } else {
                     throw new InternalError("Unexpected option " + option);
                 }
@@ -156,12 +193,21 @@
     }
 
     private static void getFlowOption(FileDescriptor fd, SocketFlow f)
-        throws SocketException
-    {
+            throws SocketException {
         int status = platformSocketOptions.getFlowOption(fdAccess.get(fd), f);
         f.status(status);  // augment the given flow with the status
     }
 
+    private static void setQuickAckOption(FileDescriptor fd, boolean enable)
+            throws SocketException {
+        platformSocketOptions.setQuickAck(fdAccess.get(fd), enable);
+    }
+
+    private static Object getQuickAckOption(FileDescriptor fd)
+            throws SocketException {
+        return platformSocketOptions.getQuickAck(fdAccess.get(fd));
+    }
+
     static class PlatformSocketOptions {
 
         protected PlatformSocketOptions() {}
@@ -184,9 +230,13 @@
                             return System.getProperty("os.name");
                         }
                     });
-            if ("SunOS".equals(osname))
+            if ("SunOS".equals(osname)) {
                 return newInstance("jdk.net.SolarisSocketOptions");
-            return new PlatformSocketOptions();
+            } else if ("Linux".equals(osname)) {
+                return newInstance("jdk.net.LinuxSocketOptions");
+            } else {
+                return new PlatformSocketOptions();
+            }
         }
 
         private static final PlatformSocketOptions instance = create();
@@ -208,5 +258,17 @@
         boolean flowSupported() {
             return false;
         }
+
+        void setQuickAck(int fd, boolean on) throws SocketException {
+            throw new UnsupportedOperationException("unsupported TCP_QUICKACK option");
+        }
+
+        boolean getQuickAck(int fd) throws SocketException {
+            throw new UnsupportedOperationException("unsupported TCP_QUICKACK option");
+        }
+
+        boolean quickAckSupported() {
+            return false;
+        }
     }
 }