UnixAsynchronousSocketChannelImpl.java 24.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 * Copyright 2008-2009 Sun Microsystems, Inc.  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
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 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 22 23 24 25 26 27 28 29 30 31 32 33 34
 *
 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 */

package sun.nio.ch;

import java.nio.channels.*;
import java.nio.ByteBuffer;
import java.net.*;
import java.util.concurrent.*;
import java.io.IOException;
import java.io.FileDescriptor;
import java.security.AccessController;
A
alanb 已提交
35
import sun.net.NetHooks;
36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63
import sun.security.action.GetPropertyAction;

/**
 * Unix implementation of AsynchronousSocketChannel
 */

class UnixAsynchronousSocketChannelImpl
    extends AsynchronousSocketChannelImpl implements Port.PollableChannel
{
    private final static NativeDispatcher nd = new SocketDispatcher();
    private static enum OpType { CONNECT, READ, WRITE };

    private static final boolean disableSynchronousRead;
    static {
        String propValue = AccessController.doPrivileged(
            new GetPropertyAction("sun.nio.ch.disableSynchronousRead", "false"));
        disableSynchronousRead = (propValue.length() == 0) ?
            true : Boolean.valueOf(propValue);
    }

    private final Port port;
    private final int fdVal;

    // used to ensure that the context for I/O operations that complete
    // ascynrhonously is visible to the pooled threads handling I/O events.
    private final Object updateLock = new Object();

    // pending connect (updateLock)
64 65 66 67
    private boolean connectPending;
    private CompletionHandler<Void,Object> connectHandler;
    private Object connectAttachment;
    private PendingFuture<Void,Object> connectFuture;
68

69
    // pending remote address (stateLock)
70 71 72
    private SocketAddress pendingRemote;

    // pending read (updateLock)
73 74 75
    private boolean readPending;
    private boolean isScatteringRead;
    private ByteBuffer readBuffer;
76
    private ByteBuffer[] readBuffers;
77 78 79 80
    private CompletionHandler<Number,Object> readHandler;
    private Object readAttachment;
    private PendingFuture<Number,Object> readFuture;
    private Future<?> readTimer;
81 82

    // pending write (updateLock)
83 84 85
    private boolean writePending;
    private boolean isGatheringWrite;
    private ByteBuffer writeBuffer;
86
    private ByteBuffer[] writeBuffers;
87 88 89 90
    private CompletionHandler<Number,Object> writeHandler;
    private Object writeAttachment;
    private PendingFuture<Number,Object> writeFuture;
    private Future<?> writeTimer;
91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143


    UnixAsynchronousSocketChannelImpl(Port port)
        throws IOException
    {
        super(port);

        // set non-blocking
        try {
            IOUtil.configureBlocking(fd, false);
        } catch (IOException x) {
            nd.close(fd);
            throw x;
        }

        this.port = port;
        this.fdVal = IOUtil.fdVal(fd);

        // add mapping from file descriptor to this channel
        port.register(fdVal, this);
    }

    // Constructor for sockets created by UnixAsynchronousServerSocketChannelImpl
    UnixAsynchronousSocketChannelImpl(Port port,
                                      FileDescriptor fd,
                                      InetSocketAddress remote)
        throws IOException
    {
        super(port, fd, remote);

        this.fdVal = IOUtil.fdVal(fd);
        IOUtil.configureBlocking(fd, false);

        try {
            port.register(fdVal, this);
        } catch (ShutdownChannelGroupException x) {
            // ShutdownChannelGroupException thrown if we attempt to register a
            // new channel after the group is shutdown
            throw new IOException(x);
        }

        this.port = port;
    }

    @Override
    public AsynchronousChannelGroupImpl group() {
        return port;
    }

    // register for events if there are outstanding I/O operations
    private void updateEvents() {
        assert Thread.holdsLock(updateLock);
        int events = 0;
144
        if (readPending)
145
            events |= Port.POLLIN;
146
        if (connectPending || writePending)
147 148 149 150 151
            events |= Port.POLLOUT;
        if (events != 0)
            port.startPoll(fdVal, events);
    }

152 153 154 155 156 157 158 159
    // invoke to finish read and/or write operations
    private void finish(boolean mayInvokeDirect,
                        boolean readable,
                        boolean writable)
    {
        boolean finishRead = false;
        boolean finishWrite = false;
        boolean finishConnect = false;
160 161 162

        // map event to pending result
        synchronized (updateLock) {
163 164 165
            if (readable && this.readPending) {
                this.readPending = false;
                finishRead = true;
166 167
            }
            if (writable) {
168 169 170 171 172 173
                if (this.writePending) {
                    this.writePending = false;
                    finishWrite = true;
                } else if (this.connectPending) {
                    this.connectPending = false;
                    finishConnect = true;
174 175 176 177 178 179 180
                }
            }
        }

        // complete the I/O operation. Special case for when channel is
        // ready for both reading and writing. In that case, submit task to
        // complete write if write operation has a completion handler.
181 182 183 184
        if (finishRead) {
            if (finishWrite)
                finishWrite(false);
            finishRead(mayInvokeDirect);
185 186
            return;
        }
187 188
        if (finishWrite) {
            finishWrite(mayInvokeDirect);
189
        }
190 191
        if (finishConnect) {
            finishConnect(mayInvokeDirect);
192 193 194
        }
    }

195 196 197 198 199 200 201 202 203 204
    /**
     * Invoked by event handler thread when file descriptor is polled
     */
    @Override
    public void onEvent(int events, boolean mayInvokeDirect) {
        boolean readable = (events & Port.POLLIN) > 0;
        boolean writable = (events & Port.POLLOUT) > 0;
        if ((events & (Port.POLLERR | Port.POLLHUP)) > 0) {
            readable = true;
            writable = true;
205
        }
206
        finish(mayInvokeDirect, readable, writable);
207 208 209 210 211 212 213 214 215 216 217
    }

    @Override
    void implClose() throws IOException {
        // remove the mapping
        port.unregister(fdVal);

        // close file descriptor
        nd.close(fd);

        // All outstanding I/O operations are required to fail
218
        finish(false, true, true);
219 220 221 222 223 224 225
    }

    @Override
    public void onCancel(PendingFuture<?,?> task) {
        if (task.getContext() == OpType.CONNECT)
            killConnect();
        if (task.getContext() == OpType.READ)
226
            killReading();
227
        if (task.getContext() == OpType.WRITE)
228
            killWriting();
229 230 231 232 233 234 235 236 237 238 239 240
    }

    // -- connect --

    private void setConnected() throws IOException {
        synchronized (stateLock) {
            state = ST_CONNECTED;
            localAddress = Net.localAddress(fd);
            remoteAddress = pendingRemote;
        }
    }

241
    private void finishConnect(boolean mayInvokeDirect) {
242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259
        Throwable e = null;
        try {
            begin();
            checkConnect(fdVal);
            setConnected();
        } catch (Throwable x) {
            if (x instanceof ClosedChannelException)
                x = new AsynchronousCloseException();
            e = x;
        } finally {
            end();
        }
        if (e != null) {
            // close channel if connection cannot be established
            try {
                close();
            } catch (IOException ignore) { }
        }
260 261 262 263 264 265 266 267


        // invoke handler and set result
        CompletionHandler<Void,Object> handler = connectHandler;
        Object att = connectAttachment;
        PendingFuture<Void,Object> future = connectFuture;
        if (handler == null) {
            future.setResult(null, e);
268
        } else {
269 270 271 272 273
            if (mayInvokeDirect) {
                Invoker.invokeUnchecked(handler, att, null, e);
            } else {
                Invoker.invokeIndirectly(this, handler, att, null, e);
            }
274 275 276 277 278
        }
    }

    @Override
    @SuppressWarnings("unchecked")
279 280 281
    <A> Future<Void> implConnect(SocketAddress remote,
                                 A attachment,
                                 CompletionHandler<Void,? super A> handler)
282 283
    {
        if (!isOpen()) {
284 285 286 287 288 289 290
            Throwable e = new ClosedChannelException();
            if (handler == null) {
                return CompletedFuture.withFailure(e);
            } else {
                Invoker.invoke(this, handler, attachment, null, e);
                return null;
            }
291 292 293 294 295 296 297 298 299 300
        }

        InetSocketAddress isa = Net.checkAddress(remote);

        // permission check
        SecurityManager sm = System.getSecurityManager();
        if (sm != null)
            sm.checkConnect(isa.getAddress().getHostAddress(), isa.getPort());

        // check and set state
A
alanb 已提交
301
        boolean notifyBeforeTcpConnect;
302 303 304 305 306 307 308
        synchronized (stateLock) {
            if (state == ST_CONNECTED)
                throw new AlreadyConnectedException();
            if (state == ST_PENDING)
                throw new ConnectionPendingException();
            state = ST_PENDING;
            pendingRemote = remote;
A
alanb 已提交
309
            notifyBeforeTcpConnect = (localAddress == null);
310 311 312 313 314
        }

        Throwable e = null;
        try {
            begin();
A
alanb 已提交
315 316 317
            // notify hook if unbound
            if (notifyBeforeTcpConnect)
                NetHooks.beforeTcpConnect(fd, isa.getAddress(), isa.getPort());
318 319 320
            int n = Net.connect(fd, isa.getAddress(), isa.getPort());
            if (n == IOStatus.UNAVAILABLE) {
                // connection could not be established immediately
321
                PendingFuture<Void,A> result = null;
322
                synchronized (updateLock) {
323 324 325 326 327 328 329 330
                    if (handler == null) {
                        result = new PendingFuture<Void,A>(this, OpType.CONNECT);
                        this.connectFuture = (PendingFuture<Void,Object>)result;
                    } else {
                        this.connectHandler = (CompletionHandler<Void,Object>)handler;
                        this.connectAttachment = attachment;
                    }
                    this.connectPending = true;
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
                    updateEvents();
                }
                return result;
            }
            setConnected();
        } catch (Throwable x) {
            if (x instanceof ClosedChannelException)
                x = new AsynchronousCloseException();
            e = x;
        } finally {
            end();
        }

        // close channel if connect fails
        if (e != null) {
            try {
                close();
            } catch (IOException ignore) { }
        }
350 351 352 353 354 355
        if (handler == null) {
            return CompletedFuture.withResult(null, e);
        } else {
            Invoker.invoke(this, handler, attachment, null, e);
            return null;
        }
356 357 358 359
    }

    // -- read --

360
    private void finishRead(boolean mayInvokeDirect) {
361
        int n = -1;
362 363 364 365 366 367 368 369 370
        Throwable exc = null;

        // copy fields as we can't access them after reading is re-enabled.
        boolean scattering = isScatteringRead;
        CompletionHandler<Number,Object> handler = readHandler;
        Object att = readAttachment;
        PendingFuture<Number,Object> future = readFuture;
        Future<?> timeout = readTimer;

371 372 373
        try {
            begin();

374 375
            if (scattering) {
                n = (int)IOUtil.read(fd, readBuffers, nd);
376
            } else {
377
                n = IOUtil.read(fd, readBuffer, -1, nd, null);
378 379 380
            }
            if (n == IOStatus.UNAVAILABLE) {
                // spurious wakeup, is this possible?
381 382 383
                synchronized (updateLock) {
                    readPending = true;
                }
384 385 386
                return;
            }

387 388 389 390
            // allow objects to be GC'ed.
            this.readBuffer = null;
            this.readBuffers = null;
            this.readAttachment = null;
391 392 393 394 395 396 397 398

            // allow another read to be initiated
            enableReading();

        } catch (Throwable x) {
            enableReading();
            if (x instanceof ClosedChannelException)
                x = new AsynchronousCloseException();
399
            exc = x;
400 401 402 403 404 405 406 407
        } finally {
            // restart poll in case of concurrent write
            synchronized (updateLock) {
                updateEvents();
            }
            end();
        }

408 409 410 411 412 413 414 415 416 417 418
        // cancel the associated timer
        if (timeout != null)
            timeout.cancel(false);

        // create result
        Number result = (exc != null) ? null : (scattering) ?
            (Number)Long.valueOf(n) : (Number)Integer.valueOf(n);

        // invoke handler or set result
        if (handler == null) {
            future.setResult(result, exc);
419
        } else {
420 421 422 423 424
            if (mayInvokeDirect) {
                Invoker.invokeUnchecked(handler, att, result, exc);
            } else {
                Invoker.invokeIndirectly(this, handler, att, result, exc);
            }
425 426 427 428 429
        }
    }

    private Runnable readTimeoutTask = new Runnable() {
        public void run() {
430 431 432 433 434 435 436 437 438 439 440 441
            CompletionHandler<Number,Object> handler = null;
            Object att = null;
            PendingFuture<Number,Object> future = null;

            synchronized (updateLock) {
                if (!readPending)
                    return;
                readPending = false;
                handler = readHandler;
                att = readAttachment;
                future = readFuture;
            }
442 443 444 445

            // kill further reading before releasing waiters
            enableReading(true);

446 447 448 449 450 451 452 453
            // invoke handler or set result
            Exception exc = new InterruptedByTimeoutException();
            if (handler == null) {
                future.setFailure(exc);
            } else {
                AsynchronousChannel ch = UnixAsynchronousSocketChannelImpl.this;
                Invoker.invokeIndirectly(ch, handler, att, null, exc);
            }
454 455 456 457 458 459 460 461
        }
    };

    /**
     * Initiates a read or scattering read operation
     */
    @Override
    @SuppressWarnings("unchecked")
462 463 464
    <V extends Number,A> Future<V> implRead(boolean isScatteringRead,
                                            ByteBuffer dst,
                                            ByteBuffer[] dsts,
465 466 467 468 469 470 471 472 473 474 475 476 477
                                            long timeout,
                                            TimeUnit unit,
                                            A attachment,
                                            CompletionHandler<V,? super A> handler)
    {
        // A synchronous read is not attempted if disallowed by system property
        // or, we are using a fixed thread pool and the completion handler may
        // not be invoked directly (because the thread is not a pooled thread or
        // there are too many handlers on the stack).
        Invoker.GroupAndInvokeCount myGroupAndInvokeCount = null;
        boolean invokeDirect = false;
        boolean attemptRead = false;
        if (!disableSynchronousRead) {
478 479 480 481 482 483 484 485
            if (handler == null) {
                attemptRead = true;
            } else {
                myGroupAndInvokeCount = Invoker.getGroupAndInvokeCount();
                invokeDirect = Invoker.mayInvokeDirect(myGroupAndInvokeCount, port);
                // okay to attempt read with user thread pool
                attemptRead = invokeDirect || !port.isFixedThreadPool();
            }
486 487
        }

488 489 490 491
        int n = IOStatus.UNAVAILABLE;
        Throwable exc = null;
        boolean pending = false;

492 493 494 495 496 497 498
        try {
            begin();

            if (attemptRead) {
                if (isScatteringRead) {
                    n = (int)IOUtil.read(fd, dsts, nd);
                } else {
499
                    n = IOUtil.read(fd, dst, -1, nd, null);
500 501 502 503
                }
            }

            if (n == IOStatus.UNAVAILABLE) {
504
                PendingFuture<V,A> result = null;
505
                synchronized (updateLock) {
506 507
                    this.isScatteringRead = isScatteringRead;
                    this.readBuffer = dst;
508
                    this.readBuffers = dsts;
509 510 511 512 513 514 515 516 517 518 519 520 521 522
                    if (handler == null) {
                        this.readHandler = null;
                        result = new PendingFuture<V,A>(this, OpType.READ);
                        this.readFuture = (PendingFuture<Number,Object>)result;
                        this.readAttachment = null;
                    } else {
                        this.readHandler = (CompletionHandler<Number,Object>)handler;
                        this.readAttachment = attachment;
                        this.readFuture = null;
                    }
                    if (timeout > 0L) {
                        this.readTimer = port.schedule(readTimeoutTask, timeout, unit);
                    }
                    this.readPending = true;
523 524
                    updateEvents();
                }
525
                pending = true;
526 527 528 529 530
                return result;
            }
        } catch (Throwable x) {
            if (x instanceof ClosedChannelException)
                x = new AsynchronousCloseException();
531
            exc = x;
532
        } finally {
533 534
            if (!pending)
                enableReading();
535 536 537
            end();
        }

538 539 540 541 542 543 544 545 546 547 548
        Number result = (exc != null) ? null : (isScatteringRead) ?
            (Number)Long.valueOf(n) : (Number)Integer.valueOf(n);

        // read completed immediately
        if (handler != null) {
            if (invokeDirect) {
                Invoker.invokeDirect(myGroupAndInvokeCount, handler, attachment, (V)result, exc);
            } else {
                Invoker.invokeIndirectly(this, handler, attachment, (V)result, exc);
            }
            return null;
549
        } else {
550
            return CompletedFuture.withResult((V)result, exc);
551 552 553 554 555
        }
    }

    // -- write --

556 557 558 559 560 561 562 563 564 565 566
    private void finishWrite(boolean mayInvokeDirect) {
        int n = -1;
        Throwable exc = null;

        // copy fields as we can't access them after reading is re-enabled.
        boolean gathering = this.isGatheringWrite;
        CompletionHandler<Number,Object> handler = this.writeHandler;
        Object att = this.writeAttachment;
        PendingFuture<Number,Object> future = this.writeFuture;
        Future<?> timer = this.writeTimer;

567 568 569
        try {
            begin();

570 571
            if (gathering) {
                n = (int)IOUtil.write(fd, writeBuffers, nd);
572
            } else {
573
                n = IOUtil.write(fd, writeBuffer, -1, nd, null);
574 575 576
            }
            if (n == IOStatus.UNAVAILABLE) {
                // spurious wakeup, is this possible?
577 578 579
                synchronized (updateLock) {
                    writePending = true;
                }
580 581 582
                return;
            }

583 584 585 586
            // allow objects to be GC'ed.
            this.writeBuffer = null;
            this.writeBuffers = null;
            this.writeAttachment = null;
587 588 589 590 591 592 593 594

            // allow another write to be initiated
            enableWriting();

        } catch (Throwable x) {
            enableWriting();
            if (x instanceof ClosedChannelException)
                x = new AsynchronousCloseException();
595
            exc = x;
596
        } finally {
597 598
            // restart poll in case of concurrent write
            synchronized (updateLock) {
599 600 601 602
                updateEvents();
            }
            end();
        }
603 604 605 606 607 608 609 610 611 612 613 614

        // cancel the associated timer
        if (timer != null)
            timer.cancel(false);

        // create result
        Number result = (exc != null) ? null : (gathering) ?
            (Number)Long.valueOf(n) : (Number)Integer.valueOf(n);

        // invoke handler or set result
        if (handler == null) {
            future.setResult(result, exc);
615
        } else {
616 617 618 619 620
            if (mayInvokeDirect) {
                Invoker.invokeUnchecked(handler, att, result, exc);
            } else {
                Invoker.invokeIndirectly(this, handler, att, result, exc);
            }
621 622 623 624 625
        }
    }

    private Runnable writeTimeoutTask = new Runnable() {
        public void run() {
626 627 628 629 630 631 632 633 634 635 636 637
            CompletionHandler<Number,Object> handler = null;
            Object att = null;
            PendingFuture<Number,Object> future = null;

            synchronized (updateLock) {
                if (!writePending)
                    return;
                writePending = false;
                handler = writeHandler;
                att = writeAttachment;
                future = writeFuture;
            }
638 639 640 641

            // kill further writing before releasing waiters
            enableWriting(true);

642 643 644 645 646 647 648 649
            // invoke handler or set result
            Exception exc = new InterruptedByTimeoutException();
            if (handler != null) {
                Invoker.invokeIndirectly(UnixAsynchronousSocketChannelImpl.this,
                    handler, att, null, exc);
            } else {
                future.setFailure(exc);
            }
650 651 652 653 654 655 656 657
        }
    };

    /**
     * Initiates a read or scattering read operation
     */
    @Override
    @SuppressWarnings("unchecked")
658 659 660
    <V extends Number,A> Future<V> implWrite(boolean isGatheringWrite,
                                             ByteBuffer src,
                                             ByteBuffer[] srcs,
661 662 663 664 665 666 667 668 669
                                             long timeout,
                                             TimeUnit unit,
                                             A attachment,
                                             CompletionHandler<V,? super A> handler)
    {
        Invoker.GroupAndInvokeCount myGroupAndInvokeCount =
            Invoker.getGroupAndInvokeCount();
        boolean invokeDirect = Invoker.mayInvokeDirect(myGroupAndInvokeCount, port);
        boolean attemptWrite = (handler == null) || invokeDirect ||
670 671 672 673 674
            !port.isFixedThreadPool();  // okay to attempt write with user thread pool

        int n = IOStatus.UNAVAILABLE;
        Throwable exc = null;
        boolean pending = false;
675 676 677 678 679 680 681 682

        try {
            begin();

            if (attemptWrite) {
                if (isGatheringWrite) {
                    n = (int)IOUtil.write(fd, srcs, nd);
                } else {
683
                    n = IOUtil.write(fd, src, -1, nd, null);
684 685 686 687
                }
            }

            if (n == IOStatus.UNAVAILABLE) {
688
                PendingFuture<V,A> result = null;
689
                synchronized (updateLock) {
690 691
                    this.isGatheringWrite = isGatheringWrite;
                    this.writeBuffer = src;
692
                    this.writeBuffers = srcs;
693 694 695 696 697 698 699 700 701 702 703 704 705 706
                    if (handler == null) {
                        this.writeHandler = null;
                        result = new PendingFuture<V,A>(this, OpType.WRITE);
                        this.writeFuture = (PendingFuture<Number,Object>)result;
                        this.writeAttachment = null;
                    } else {
                        this.writeHandler = (CompletionHandler<Number,Object>)handler;
                        this.writeAttachment = attachment;
                        this.writeFuture = null;
                    }
                    if (timeout > 0L) {
                        this.writeTimer = port.schedule(writeTimeoutTask, timeout, unit);
                    }
                    this.writePending = true;
707 708
                    updateEvents();
                }
709
                pending = true;
710 711 712 713 714
                return result;
            }
        } catch (Throwable x) {
            if (x instanceof ClosedChannelException)
                x = new AsynchronousCloseException();
715
            exc = x;
716
        } finally {
717 718
            if (!pending)
                enableWriting();
719 720
            end();
        }
721 722 723 724 725 726 727 728 729 730 731 732

        Number result = (exc != null) ? null : (isGatheringWrite) ?
            (Number)Long.valueOf(n) : (Number)Integer.valueOf(n);

        // write completed immediately
        if (handler != null) {
            if (invokeDirect) {
                Invoker.invokeDirect(myGroupAndInvokeCount, handler, attachment, (V)result, exc);
            } else {
                Invoker.invokeIndirectly(this, handler, attachment, (V)result, exc);
            }
            return null;
733
        } else {
734
            return CompletedFuture.withResult((V)result, exc);
735 736 737 738 739 740 741 742 743 744 745
        }
    }

    // -- Native methods --

    private static native void checkConnect(int fdVal) throws IOException;

    static {
        Util.load();
    }
}