1 /*

     2  * Copyright (c) 2013, 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.jfr.internal.instrument;

    27 

    28 import java.io.IOException;

    29 import java.nio.ByteBuffer;

    30 

    31 import jdk.jfr.events.FileForceEvent;

    32 import jdk.jfr.events.FileReadEvent;

    33 import jdk.jfr.events.FileWriteEvent;

    34 

    35 /**

    36  * See {@link JITracer} for an explanation of this code.

    37  */

    38 @JIInstrumentationTarget("sun.nio.ch.FileChannelImpl")

    39 final class FileChannelImplInstrumentor {

    40 

    41     private FileChannelImplInstrumentor() {

    42     }

    43 

    44     private String path;

    45 

    46     @SuppressWarnings("deprecation")

    47     @JIInstrumentationMethod

    48     public void force(boolean metaData) throws IOException {

    49         FileForceEvent event = FileForceEvent.EVENT.get();

    50         if (!event.isEnabled()) {

    51             force(metaData);

    52             return;

    53         }

    54         try {

    55             event.begin();

    56             force(metaData);

    57         } finally {

    58             event.path = path;

    59             event.metaData = metaData;

    60             event.commit();

    61             event.reset();

    62         }

    63     }

    64 

    65     @SuppressWarnings("deprecation")

    66     @JIInstrumentationMethod

    67     public int read(ByteBuffer dst) throws IOException {

    68         FileReadEvent event = FileReadEvent.EVENT.get();

    69         if (!event.isEnabled()) {

    70             return read(dst);

    71         }

    72         int bytesRead = 0;

    73         try {

    74             event.begin();

    75             bytesRead = read(dst);

    76         } finally {

    77             if (bytesRead < 0) {

    78                 event.endOfFile = true;

    79             } else {

    80                 event.bytesRead = bytesRead;

    81             }

    82             event.path = path;

    83             event.commit();

    84             event.reset();

    85         }

    86         return bytesRead;

    87     }

    88 

    89     @SuppressWarnings("deprecation")

    90     @JIInstrumentationMethod

    91     public int read(ByteBuffer dst, long position) throws IOException {

    92         FileReadEvent event = FileReadEvent.EVENT.get();

    93         if (!event.isEnabled()) {

    94             return read(dst, position);

    95         }

    96         int bytesRead = 0;

    97         try {

    98             event.begin();

    99             bytesRead = read(dst, position);

   100         } finally {

   101             if (bytesRead < 0) {

   102                 event.endOfFile = true;

   103             } else {

   104                 event.bytesRead = bytesRead;

   105             }

   106             event.path = path;

   107             event.commit();

   108             event.reset();

   109         }

   110         return bytesRead;

   111     }

   112 

   113     @SuppressWarnings("deprecation")

   114     @JIInstrumentationMethod

   115     public long read(ByteBuffer[] dsts, int offset, int length) throws IOException {

   116         FileReadEvent event = FileReadEvent.EVENT.get();

   117         if (!event.isEnabled()) {

   118             return read(dsts, offset, length);

   119         }

   120         long bytesRead = 0;

   121         try {

   122             event.begin();

   123             bytesRead = read(dsts, offset, length);

   124         } finally {

   125             if (bytesRead < 0) {

   126                 event.endOfFile = true;

   127             } else {

   128                 event.bytesRead = bytesRead;

   129             }

   130             event.path = path;

   131             event.commit();

   132             event.reset();

   133         }

   134         return bytesRead;

   135     }

   136 

   137     @SuppressWarnings("deprecation")

   138     @JIInstrumentationMethod

   139     public int write(ByteBuffer src) throws IOException {

   140         FileWriteEvent event = FileWriteEvent.EVENT.get();

   141         if (!event.isEnabled()) {

   142             return write(src);

   143         }

   144         int bytesWritten = 0;

   145         try {

   146             event.begin();

   147             bytesWritten = write(src);

   148         } finally {

   149             event.bytesWritten = bytesWritten > 0 ? bytesWritten : 0;

   150             event.path = path;

   151             event.commit();

   152             event.reset();

   153         }

   154         return bytesWritten;

   155     }

   156 

   157     @SuppressWarnings("deprecation")

   158     @JIInstrumentationMethod

   159     public int write(ByteBuffer src, long position) throws IOException {

   160         FileWriteEvent event = FileWriteEvent.EVENT.get();

   161         if (!event.isEnabled()) {

   162             return write(src, position);

   163         }

   164 

   165         int bytesWritten = 0;

   166         try {

   167             event.begin();

   168             bytesWritten = write(src, position);

   169         } finally {

   170             event.bytesWritten = bytesWritten > 0 ? bytesWritten : 0;

   171             event.path = path;

   172             event.commit();

   173             event.reset();

   174         }

   175         return bytesWritten;

   176     }

   177 

   178     @SuppressWarnings("deprecation")

   179     @JIInstrumentationMethod

   180     public long write(ByteBuffer[] srcs, int offset, int length) throws IOException {

   181         FileWriteEvent event = FileWriteEvent.EVENT.get();

   182         if (!event.isEnabled()) {

   183             return write(srcs, offset, length);

   184         }

   185         long bytesWritten = 0;

   186         try {

   187             event.begin();

   188             bytesWritten = write(srcs, offset, length);

   189         } finally {

   190             event.bytesWritten = bytesWritten > 0 ? bytesWritten : 0;

   191             event.path = path;

   192             event.commit();

   193             event.reset();

   194         }

   195         return bytesWritten;

   196     }

   197 }