1 /*

     2  * Copyright (c) 2016, 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;

    27 

    28 import jdk.internal.misc.Unsafe;

    29 import jdk.jfr.internal.consumer.RecordingInput;

    30 

    31 /**

    32  * Class must reside in a package with package restriction.

    33  *

    34  * Users should not have direct access to underlying memory.

    35  *

    36  */

    37 public final class EventWriter {

    38     private static final Unsafe unsafe = Unsafe.getUnsafe();

    39     private final static JVM jvm = JVM.getJVM();

    40 

    41     private long startPosition;

    42     private long startPositionAddress;

    43     private long currentPosition;

    44     private long maxPosition;

    45     private final long threadID;

    46     private PlatformEventType eventType;

    47     private int maxEventSize;

    48     private boolean started;

    49     private boolean valid;

    50     private boolean flushOnEnd;

    51     // set by the JVM, not private to avoid being optimized out

    52     boolean notified;

    53 

    54     public static EventWriter getEventWriter() {

    55         EventWriter ew = (EventWriter)JVM.getEventWriter();

    56         return ew != null ? ew : JVM.newEventWriter();

    57     }

    58 

    59     public void putBoolean(boolean i) {

    60         if (isValidForSize(Byte.BYTES)) {

    61             currentPosition += Bits.putBoolean(currentPosition, i);

    62         }

    63     }

    64 

    65     public void putByte(byte i) {

    66         if (isValidForSize(Byte.BYTES)) {

    67             unsafe.putByte(currentPosition, i);

    68             ++currentPosition;

    69         }

    70     }

    71 

    72     public void putChar(char v) {

    73         if (isValidForSize(Character.BYTES + 1)) {

    74             putUncheckedLong(v);

    75         }

    76     }

    77 

    78     private void putUncheckedChar(char v) {

    79         putUncheckedLong(v);

    80     }

    81 

    82     public void putShort(short v) {

    83         if (isValidForSize(Short.BYTES + 1)) {

    84             putUncheckedLong(v & 0xFFFF);

    85         }

    86     }

    87 

    88     public void putInt(int v) {

    89         if (isValidForSize(Integer.BYTES + 1)) {

    90             putUncheckedLong(v & 0x00000000ffffffffL);

    91         }

    92     }

    93 

    94     private void putUncheckedInt(int v) {

    95         putUncheckedLong(v & 0x00000000ffffffffL);

    96     }

    97 

    98     public void putFloat(float i) {

    99         if (isValidForSize(Float.BYTES)) {

   100             currentPosition += Bits.putFloat(currentPosition, i);

   101         }

   102     }

   103 

   104     public void putLong(long v) {

   105         if (isValidForSize(Long.BYTES + 1)) {

   106             putUncheckedLong(v);

   107         }

   108     }

   109 

   110     public void putDouble(double i) {

   111         if (isValidForSize(Double.BYTES)) {

   112             currentPosition += Bits.putDouble(currentPosition, i);

   113         }

   114     }

   115 

   116     public void putString(String s, StringPool pool) {

   117         if (s == null) {

   118             putByte(RecordingInput.STRING_ENCODING_NULL);

   119             return;

   120         }

   121         int length = s.length();

   122         if (length == 0) {

   123             putByte(RecordingInput.STRING_ENCODING_EMPTY_STRING);

   124             return;

   125         }

   126         if (length > StringPool.MIN_LIMIT && length < StringPool.MAX_LIMIT) {

   127             long l = StringPool.addString(s);

   128             if (l > 0) {

   129                 putByte(RecordingInput.STRING_ENCODING_CONSTANT_POOL);

   130                 putLong(l);

   131                 return;

   132             }

   133         }

   134         putStringValue(s);

   135         return;

   136     }

   137 

   138     private void putStringValue(String s) {

   139         int length = s.length();

   140         if (isValidForSize(1 + 5 + 3 * length)) {

   141             putUncheckedByte(RecordingInput.STRING_ENCODING_CHAR_ARRAY); // 1 byte

   142             putUncheckedInt(length); // max 5 bytes

   143             for (int i = 0; i < length; i++) {

   144                 putUncheckedChar(s.charAt(i)); // max 3 bytes

   145             }

   146         }

   147     }

   148 

   149     public void putEventThread() {

   150         putLong(threadID);

   151     }

   152 

   153     public void putThread(Thread athread) {

   154         if (athread == null) {

   155             putLong(0L);

   156         } else {

   157             putLong(jvm.getThreadId(athread));

   158         }

   159     }

   160 

   161     public void putClass(Class<?> aClass) {

   162         if (aClass == null) {

   163             putLong(0L);

   164         } else {

   165             putLong(JVM.getClassIdNonIntrinsic(aClass));

   166         }

   167     }

   168 

   169     public void putStackTrace() {

   170         if (eventType.getStackTraceEnabled()) {

   171             putLong(jvm.getStackTraceId(eventType.getStackTraceOffset()));

   172         } else {

   173             putLong(0L);

   174         }

   175     }

   176 

   177     private void reserveEventSizeField() {

   178         // move currentPosition Integer.Bytes offset from start position

   179         if (isValidForSize(Integer.BYTES)) {

   180             currentPosition += Integer.BYTES;

   181         }

   182     }

   183 

   184     private void reset() {

   185         currentPosition = startPosition;

   186         if (flushOnEnd) {

   187             flushOnEnd = flush();

   188         }

   189         valid = true;

   190         started = false;

   191     }

   192 

   193     private boolean isValidForSize(int requestedSize) {

   194         if (!valid) {

   195             return false;

   196         }

   197         if (currentPosition + requestedSize > maxPosition) {

   198             flushOnEnd = flush(usedSize(), requestedSize);

   199             // retry

   200             if (currentPosition + requestedSize > maxPosition) {

   201                 Logger.log(LogTag.JFR_SYSTEM,

   202                            LogLevel.WARN, () ->

   203                                "Unable to commit. Requested size " + requestedSize + " too large");

   204                 valid = false;

   205                 return false;

   206             }

   207         }

   208         return true;

   209     }

   210 

   211     private boolean isNotified() {

   212         return notified;

   213     }

   214 

   215     private void resetNotified() {

   216         notified = false;

   217     }

   218 

   219     private int usedSize() {

   220         return (int) (currentPosition - startPosition);

   221     }

   222 

   223     private boolean flush() {

   224         return flush(usedSize(), 0);

   225     }

   226 

   227     private boolean flush(int usedSize, int requestedSize) {

   228         return JVM.flush(this, usedSize, requestedSize);

   229     }

   230 

   231     public boolean beginEvent(PlatformEventType eventType) {

   232         if (started) {

   233             // recursive write attempt

   234             return false;

   235         }

   236         started = true;

   237         this.eventType = eventType;

   238         reserveEventSizeField();

   239         putLong(eventType.getId());

   240         return true;

   241     }

   242 

   243     public boolean endEvent() {

   244         if (!valid) {

   245             reset();

   246             return true;

   247         }

   248         final int eventSize = usedSize();

   249         if (eventSize > maxEventSize) {

   250             reset();

   251             return true;

   252         }

   253         Bits.putInt(startPosition, makePaddedInt(eventSize));

   254         if (isNotified()) {

   255             resetNotified();

   256             reset();

   257             // returning false will trigger restart of the event write attempt

   258             return false;

   259         }

   260         startPosition = currentPosition;

   261         unsafe.putAddress(startPositionAddress, startPosition);

   262         // the event is now committed

   263         if (flushOnEnd) {

   264             flushOnEnd = flush();

   265         }

   266         started = false;

   267         return true;

   268     }

   269 

   270     private EventWriter(long startPos, long maxPos, long startPosAddress, long threadID, boolean valid) {

   271         startPosition = currentPosition = startPos;

   272         maxPosition = maxPos;

   273         startPositionAddress = startPosAddress;

   274         this.threadID = threadID;

   275         started = false;

   276         flushOnEnd = false;

   277         this.valid = valid;

   278         notified = false;

   279         // event may not exceed size for a padded integer

   280         maxEventSize = (1 << 28) -1;

   281     }

   282 

   283     private static int makePaddedInt(int v) {

   284         // bit  0-6 + pad => bit 24 - 31

   285         long b1 = (((v >>> 0) & 0x7F) | 0x80) << 24;

   286 

   287         // bit  7-13 + pad => bit 16 - 23

   288         long b2 = (((v >>> 7) & 0x7F) | 0x80) << 16;

   289 

   290         // bit 14-20 + pad => bit  8 - 15

   291         long b3 = (((v >>> 14) & 0x7F) | 0x80) << 8;

   292 

   293         // bit 21-28       => bit  0 -  7

   294         long b4 = (((v >>> 21) & 0x7F)) << 0;

   295 

   296         return (int) (b1 + b2 + b3 + b4);

   297     }

   298 

   299     private void putUncheckedLong(long v) {

   300         if ((v & ~0x7FL) == 0L) {

   301             putUncheckedByte((byte) v); // 0-6

   302             return;

   303         }

   304         putUncheckedByte((byte) (v | 0x80L)); // 0-6

   305         v >>>= 7;

   306         if ((v & ~0x7FL) == 0L) {

   307             putUncheckedByte((byte) v); // 7-13

   308             return;

   309         }

   310         putUncheckedByte((byte) (v | 0x80L)); // 7-13

   311         v >>>= 7;

   312         if ((v & ~0x7FL) == 0L) {

   313             putUncheckedByte((byte) v); // 14-20

   314             return;

   315         }

   316         putUncheckedByte((byte) (v | 0x80L)); // 14-20

   317         v >>>= 7;

   318         if ((v & ~0x7FL) == 0L) {

   319             putUncheckedByte((byte) v); // 21-27

   320             return;

   321         }

   322         putUncheckedByte((byte) (v | 0x80L)); // 21-27

   323         v >>>= 7;

   324         if ((v & ~0x7FL) == 0L) {

   325             putUncheckedByte((byte) v); // 28-34

   326             return;

   327         }

   328         putUncheckedByte((byte) (v | 0x80L)); // 28-34

   329         v >>>= 7;

   330         if ((v & ~0x7FL) == 0L) {

   331             putUncheckedByte((byte) v); // 35-41

   332             return;

   333         }

   334         putUncheckedByte((byte) (v | 0x80L)); // 35-41

   335         v >>>= 7;

   336         if ((v & ~0x7FL) == 0L) {

   337             putUncheckedByte((byte) v); // 42-48

   338             return;

   339         }

   340         putUncheckedByte((byte) (v | 0x80L)); // 42-48

   341         v >>>= 7;

   342 

   343         if ((v & ~0x7FL) == 0L) {

   344             putUncheckedByte((byte) v); // 49-55

   345             return;

   346         }

   347         putUncheckedByte((byte) (v | 0x80L)); // 49-55

   348         putUncheckedByte((byte) (v >>> 7)); // 56-63, last byte as is.

   349     }

   350 

   351     private void putUncheckedByte(byte i) {

   352         unsafe.putByte(currentPosition, i);

   353         ++currentPosition;

   354     }

   355 }