1 /*
   2  * Copyright (c) 2013, 2019, 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.jfr.internal.instrument;
  27 
  28 import java.io.IOException;
  29 import java.net.InetSocketAddress;
  30 import java.nio.ByteBuffer;
  31 
  32 import jdk.jfr.events.SocketReadEvent;
  33 import jdk.jfr.events.SocketWriteEvent;
  34 
  35 /**
  36  * See {@link JITracer} for an explanation of this code.
  37  */
  38 @JIInstrumentationTarget("sun.nio.ch.SocketChannelImpl")
  39 final class SocketChannelImplInstrumentor {
  40 
  41     private SocketChannelImplInstrumentor() {
  42     }
  43 
  44     private InetSocketAddress remoteAddress;
  45 
  46     @SuppressWarnings("deprecation")
  47     @JIInstrumentationMethod
  48     public int read(ByteBuffer dst) throws IOException {
  49         SocketReadEvent event = SocketReadEvent.EVENT.get();
  50         if (!event.isEnabled()) {
  51             return read(dst);
  52         }
  53         int bytesRead = 0;
  54         try {
  55             event.begin();
  56             bytesRead = read(dst);
  57         } finally {
  58             event.end();
  59             if (event.shouldCommit())  {
  60                 String hostString  = remoteAddress.getAddress().toString();
  61                 int delimiterIndex = hostString.lastIndexOf('/');
  62 
  63                 event.host      = hostString.substring(0, delimiterIndex);
  64                 event.address   = hostString.substring(delimiterIndex + 1);
  65                 event.port      = remoteAddress.getPort();
  66                 if (bytesRead < 0) {
  67                     event.endOfStream = true;
  68                 } else {
  69                     event.bytesRead = bytesRead;
  70                 }
  71                 event.timeout   = 0;
  72 
  73                 event.commit();
  74                 event.reset();
  75             }
  76         }
  77         return bytesRead;
  78     }
  79 
  80     @SuppressWarnings("deprecation")
  81     @JIInstrumentationMethod
  82     public long read(ByteBuffer[] dsts, int offset, int length) throws IOException {
  83         SocketReadEvent event = SocketReadEvent.EVENT.get();
  84         if(!event.isEnabled()) {
  85             return read(dsts, offset, length);
  86         }
  87 
  88         long bytesRead = 0;
  89         try {
  90             event.begin();
  91             bytesRead = read(dsts, offset, length);
  92         } finally {
  93             event.end();
  94             if (event.shouldCommit()) {
  95                 String hostString  = remoteAddress.getAddress().toString();
  96                 int delimiterIndex = hostString.lastIndexOf('/');
  97 
  98                 event.host      = hostString.substring(0, delimiterIndex);
  99                 event.address   = hostString.substring(delimiterIndex + 1);
 100                 event.port      = remoteAddress.getPort();
 101                 if (bytesRead < 0) {
 102                     event.endOfStream = true;
 103                 } else {
 104                     event.bytesRead = bytesRead;
 105                 }
 106                 event.timeout   = 0;
 107 
 108                 event.commit();
 109                 event.reset();
 110             }
 111         }
 112         return bytesRead;
 113     }
 114 
 115     @SuppressWarnings("deprecation")
 116     @JIInstrumentationMethod
 117     public int write(ByteBuffer buf) throws IOException {
 118         SocketWriteEvent event = SocketWriteEvent.EVENT.get();
 119         if (!event.isEnabled()) {
 120             return write(buf);
 121         }
 122 
 123         int bytesWritten = 0;
 124         try {
 125             event.begin();
 126             bytesWritten = write(buf);
 127         } finally {
 128             event.end();
 129             if (event.shouldCommit()) {
 130                 String hostString  = remoteAddress.getAddress().toString();
 131                 int delimiterIndex = hostString.lastIndexOf('/');
 132 
 133                 event.host         = hostString.substring(0, delimiterIndex);
 134                 event.address      = hostString.substring(delimiterIndex + 1);
 135                 event.port         = remoteAddress.getPort();
 136                 event.bytesWritten = bytesWritten < 0 ? 0 : bytesWritten;
 137 
 138                 event.commit();
 139                 event.reset();
 140             }
 141         }
 142         return bytesWritten;
 143     }
 144 
 145     @SuppressWarnings("deprecation")
 146     @JIInstrumentationMethod
 147     public long write(ByteBuffer[] srcs, int offset, int length) throws IOException {
 148         SocketWriteEvent event = SocketWriteEvent.EVENT.get();
 149         if (!event.isEnabled()) {
 150             return write(srcs, offset, length);
 151         }
 152         long bytesWritten = 0;
 153         try {
 154             event.begin();
 155             bytesWritten = write(srcs, offset, length);
 156         } finally {
 157             event.end();
 158             if (event.shouldCommit()) {
 159                 String hostString  = remoteAddress.getAddress().toString();
 160                 int delimiterIndex = hostString.lastIndexOf('/');
 161 
 162                 event.host         = hostString.substring(0, delimiterIndex);
 163                 event.address      = hostString.substring(delimiterIndex + 1);
 164                 event.port         = remoteAddress.getPort();
 165                 event.bytesWritten = bytesWritten < 0 ? 0 : bytesWritten;
 166 
 167                 event.commit();
 168                 event.reset();
 169             }
 170         }
 171         return bytesWritten;
 172     }
 173 
 174 }