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 java.io.BufferedInputStream;

    29 import java.io.IOException;

    30 import java.io.InputStream;

    31 import java.lang.annotation.Annotation;

    32 import java.util.ArrayList;

    33 import java.util.Collections;

    34 import java.util.HashMap;

    35 import java.util.LinkedHashMap;

    36 import java.util.List;

    37 import java.util.Map;

    38 import java.util.Objects;

    39 

    40 import jdk.internal.org.xml.sax.Attributes;

    41 import jdk.internal.org.xml.sax.EntityResolver;

    42 import jdk.internal.org.xml.sax.SAXException;

    43 import jdk.internal.org.xml.sax.helpers.DefaultHandler;

    44 import jdk.internal.util.xml.SAXParser;

    45 import jdk.internal.util.xml.impl.SAXParserImpl;

    46 import jdk.jfr.AnnotationElement;

    47 import jdk.jfr.Category;

    48 import jdk.jfr.Description;

    49 import jdk.jfr.Enabled;

    50 import jdk.jfr.Experimental;

    51 import jdk.jfr.Label;

    52 import jdk.jfr.Period;

    53 import jdk.jfr.Relational;

    54 import jdk.jfr.StackTrace;

    55 import jdk.jfr.Threshold;

    56 import jdk.jfr.TransitionFrom;

    57 import jdk.jfr.TransitionTo;

    58 import jdk.jfr.Unsigned;

    59 

    60 final class MetadataHandler extends DefaultHandler implements EntityResolver {

    61 

    62     static class TypeElement {

    63         List<FieldElement> fields = new ArrayList<>();

    64         String name;

    65         String label;

    66         String description;

    67         String category;

    68         String superType;

    69         String period;

    70         boolean thread;

    71         boolean startTime;

    72         boolean stackTrace;

    73         boolean cutoff;

    74         boolean isEvent;

    75         boolean experimental;

    76         boolean valueType;

    77     }

    78 

    79     static class FieldElement {

    80         TypeElement referenceType;

    81         String name;

    82         String label;

    83         String description;

    84         String contentType;

    85         String typeName;

    86         String transition;

    87         String relation;

    88         boolean struct;

    89         boolean array;

    90         boolean experimental;

    91         boolean unsigned;

    92     }

    93 

    94     static class XmlType {

    95         String name;

    96         String javaType;

    97         String contentType;

    98         boolean unsigned;

    99     }

   100 

   101     final Map<String, TypeElement> types = new LinkedHashMap<>(200);

   102     final Map<String, XmlType> xmlTypes = new HashMap<>(20);

   103     final Map<String, AnnotationElement> xmlContentTypes = new HashMap<>(20);

   104     final List<String> relations = new ArrayList<>();

   105     long eventTypeId = 255;

   106     long structTypeId = 33;

   107     FieldElement currentField;

   108     TypeElement currentType;

   109 

   110     @Override

   111     public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {

   112         switch (qName) {

   113         case "XmlType":

   114             XmlType xmlType = new XmlType();

   115             xmlType.name = attributes.getValue("name");

   116             xmlType.javaType = attributes.getValue("javaType");

   117             xmlType.contentType = attributes.getValue("contentType");

   118             xmlType.unsigned = Boolean.valueOf(attributes.getValue("unsigned"));

   119             xmlTypes.put(xmlType.name, xmlType);

   120             break;

   121         case "Type":

   122         case "Event":

   123             currentType = new TypeElement();

   124             currentType.name = attributes.getValue("name");

   125             currentType.label = attributes.getValue("label");

   126             currentType.description = attributes.getValue("description");

   127             currentType.category = attributes.getValue("category");

   128             currentType.thread = getBoolean(attributes, "thread", false);

   129             currentType.stackTrace = getBoolean(attributes, "stackTrace", false);

   130             currentType.startTime = getBoolean(attributes, "startTime", true);

   131             currentType.period = attributes.getValue("period");

   132             currentType.cutoff = getBoolean(attributes, "cutoff", false);

   133             currentType.experimental = getBoolean(attributes, "experimental", false);

   134             currentType.isEvent = qName.equals("Event");

   135             break;

   136         case "Field":

   137             currentField = new FieldElement();

   138             currentField.struct = getBoolean(attributes, "struct", false);

   139             currentField.array = getBoolean(attributes, "array", false);

   140             currentField.name = attributes.getValue("name");

   141             currentField.label = attributes.getValue("label");

   142             currentField.typeName = attributes.getValue("type");

   143             currentField.description = attributes.getValue("description");

   144             currentField.experimental = getBoolean(attributes, "experimental", false);

   145             currentField.contentType = attributes.getValue("contentType");

   146             currentField.relation = attributes.getValue("relation");

   147             currentField.transition = attributes.getValue("transition");

   148             break;

   149         case "XmlContentType":

   150             String name = attributes.getValue("name");

   151             String type = attributes.getValue("annotationType");

   152             String value = attributes.getValue("annotationValue");

   153             Class<? extends Annotation> annotationType = createAnnotationClass(type);

   154             AnnotationElement ae = value == null ? new AnnotationElement(annotationType) : new AnnotationElement(annotationType, value);

   155             xmlContentTypes.put(name, ae);

   156             break;

   157         case "Relation":

   158             String n = attributes.getValue("name");

   159             relations.add(n);

   160             break;

   161         }

   162     }

   163 

   164     @SuppressWarnings("unchecked")

   165     private Class<? extends Annotation> createAnnotationClass(String type) {

   166         try {

   167             if (!type.startsWith("jdk.jfr.")) {

   168                 throw new IllegalStateException("Incorrect type " + type + ". Annotation class must be located in jdk.jfr package.");

   169             }

   170             Class<?> c = Class.forName(type, true, null);

   171             return (Class<? extends Annotation>) c;

   172         } catch (ClassNotFoundException cne) {

   173             throw new IllegalStateException(cne);

   174         }

   175     }

   176 

   177     private boolean getBoolean(Attributes attributes, String name, boolean defaultValue) {

   178         String value = attributes.getValue(name);

   179         return value == null ? defaultValue : Boolean.valueOf(value);

   180     }

   181 

   182     @Override

   183     public void endElement(String uri, String localName, String qName) {

   184         switch (qName) {

   185         case "Type":

   186         case "Event":

   187             types.put(currentType.name, currentType);

   188             currentType = null;

   189             break;

   190         case "Field":

   191             currentType.fields.add(currentField);

   192             currentField = null;

   193             break;

   194         }

   195     }

   196 

   197     public static List<Type> createTypes() throws IOException {

   198         SAXParser parser = new SAXParserImpl();

   199         MetadataHandler t = new MetadataHandler();

   200         try (InputStream is = new BufferedInputStream(SecuritySupport.getResourceAsStream("/jdk/jfr/internal/types/metadata.xml"))) {

   201             Logger.log(LogTag.JFR_SYSTEM, LogLevel.DEBUG, () -> "Parsing metadata.xml");

   202             try {

   203                 parser.parse(is, t);

   204                 return t.buildTypes();

   205             } catch (Exception e) {

   206                 e.printStackTrace();

   207                 throw new IOException(e);

   208             }

   209         }

   210     }

   211 

   212     private List<Type> buildTypes() {

   213         removeXMLConvenience();

   214         Map<String, Type> typeMap = buildTypeMap();

   215         Map<String, AnnotationElement> relationMap = buildRelationMap(typeMap);

   216         addFields(typeMap, relationMap);

   217         return trimTypes(typeMap);

   218     }

   219 

   220     private Map<String, AnnotationElement> buildRelationMap(Map<String, Type> typeMap) {

   221         Map<String, AnnotationElement> relationMap = new HashMap<>();

   222         for (String relation : relations) {

   223             Type relationType = new Type(Type.TYPES_PREFIX + relation, Type.SUPER_TYPE_ANNOTATION, eventTypeId++);

   224             relationType.setAnnotations(Collections.singletonList(new AnnotationElement(Relational.class)));

   225             AnnotationElement ae = PrivateAccess.getInstance().newAnnotation(relationType, Collections.emptyList(), true);

   226             relationMap.put(relation, ae);

   227             typeMap.put(relationType.getName(), relationType);

   228         }

   229         return relationMap;

   230     }

   231 

   232     private List<Type> trimTypes(Map<String, Type> lookup) {

   233         List<Type> trimmedTypes = new ArrayList<>(lookup.size());

   234         for (Type t : lookup.values()) {

   235             t.trimFields();

   236             trimmedTypes.add(t);

   237         }

   238         return trimmedTypes;

   239     }

   240 

   241     private void addFields(Map<String, Type> lookup, Map<String, AnnotationElement> relationMap) {

   242         for (TypeElement te : types.values()) {

   243             Type type = lookup.get(te.name);

   244             if (te.isEvent) {

   245                 boolean periodic = te.period!= null;

   246                 TypeLibrary.addImplicitFields(type, periodic, te.startTime && !periodic, te.thread, te.stackTrace && !periodic, te.cutoff);

   247             }

   248             for (FieldElement f : te.fields) {

   249                 Type fieldType = Type.getKnownType(f.typeName);

   250                 if (fieldType == null) {

   251                     fieldType = Objects.requireNonNull(lookup.get(f.referenceType.name));

   252                 }

   253                 List<AnnotationElement> aes = new ArrayList<>();

   254                 if (f.unsigned) {

   255                     aes.add(new AnnotationElement(Unsigned.class));

   256                 }

   257                 if (f.contentType != null) {

   258                     aes.add(Objects.requireNonNull(xmlContentTypes.get(f.contentType)));

   259                 }

   260                 if (f.relation != null) {

   261                     aes.add(Objects.requireNonNull(relationMap.get(f.relation)));

   262                 }

   263                 if (f.label != null) {

   264                     aes.add(new AnnotationElement(Label.class, f.label));

   265                 }

   266                 if (f.experimental) {

   267                     aes.add(new AnnotationElement(Experimental.class));

   268                 }

   269                 if (f.description != null) {

   270                     aes.add(new AnnotationElement(Description.class, f.description));

   271                 }

   272                 if ("from".equals(f.transition)) {

   273                     aes.add(new AnnotationElement(TransitionFrom.class));

   274                 }

   275                 if ("to".equals(f.transition)) {

   276                     aes.add(new AnnotationElement(TransitionTo.class));

   277                 }

   278                 boolean constantPool = !f.struct && f.referenceType != null;

   279                 type.add(PrivateAccess.getInstance().newValueDescriptor(f.name, fieldType, aes, f.array ? 1 : 0, constantPool, null));

   280             }

   281         }

   282     }

   283 

   284     private Map<String, Type> buildTypeMap() {

   285         Map<String, Type> typeMap = new HashMap<>();

   286         for (Type type : Type.getKnownTypes()) {

   287             typeMap.put(type.getName(), type);

   288         }

   289 

   290         for (TypeElement t : types.values()) {

   291             List<AnnotationElement> aes = new ArrayList<>();

   292             if (t.category != null) {

   293                 aes.add(new AnnotationElement(Category.class, buildCategoryArray(t.category)));

   294             }

   295             if (t.label != null) {

   296                 aes.add(new AnnotationElement(Label.class, t.label));

   297             }

   298             if (t.description != null) {

   299                 aes.add(new AnnotationElement(Description.class, t.description));

   300             }

   301             if (t.isEvent) {

   302                 if (t.period != null) {

   303                     aes.add(new AnnotationElement(Period.class, t.period));

   304                 } else {

   305                     if (t.startTime) {

   306                         aes.add(new AnnotationElement(Threshold.class, "0 ns"));

   307                     }

   308                     if (t.stackTrace) {

   309                         aes.add(new AnnotationElement(StackTrace.class, true));

   310                     }

   311                 }

   312                 if (t.cutoff) {

   313                     aes.add(new AnnotationElement(Cutoff.class, Cutoff.INIFITY));

   314                 }

   315             }

   316             if (t.experimental) {

   317                 aes.add(new AnnotationElement(Experimental.class));

   318             }

   319             Type type;

   320             if (t.isEvent) {

   321                 aes.add(new AnnotationElement(Enabled.class, false));

   322                 type = new PlatformEventType(t.name,  eventTypeId++, false, true);

   323             } else {

   324                 // Struct types had their own XML-element in the past. To have id assigned in the

   325                 // same order as generated .hpp file do some tweaks here.

   326                 boolean valueType = t.name.endsWith("StackFrame") || t.valueType;

   327                 type = new Type(t.name, null, valueType ?  eventTypeId++ : nextTypeId(t.name), false);

   328             }

   329             type.setAnnotations(aes);

   330             typeMap.put(t.name, type);

   331         }

   332         return typeMap;

   333     }

   334 

   335     private long nextTypeId(String name) {

   336         if (Type.THREAD.getName().equals(name)) {

   337             return Type.THREAD.getId();

   338         }

   339         if (Type.STRING.getName().equals(name)) {

   340             return Type.STRING.getId();

   341         }

   342         if (Type.CLASS.getName().equals(name)) {

   343             return Type.CLASS.getId();

   344         }

   345         for (Type type : Type.getKnownTypes()) {

   346             if (type.getName().equals(name)) {

   347                 return type.getId();

   348             }

   349         }

   350         return structTypeId++;

   351     }

   352 

   353     private String[] buildCategoryArray(String category) {

   354         List<String> categories = new ArrayList<>();

   355         StringBuilder sb = new StringBuilder();

   356         for (char c : category.toCharArray()) {

   357             if (c == ',') {

   358                 categories.add(sb.toString().trim());

   359                 sb.setLength(0);

   360             } else {

   361                 sb.append(c);

   362             }

   363         }

   364         categories.add(sb.toString().trim());

   365         return categories.toArray(new String[0]);

   366     }

   367 

   368     private void removeXMLConvenience() {

   369         for (TypeElement t : types.values()) {

   370             XmlType xmlType = xmlTypes.get(t.name);

   371             if (xmlType != null && xmlType.javaType != null) {

   372                 t.name = xmlType.javaType; // known type, i.e primitive

   373             } else {

   374                 if (t.isEvent) {

   375                     t.name = Type.EVENT_NAME_PREFIX + t.name;

   376                 } else {

   377                     t.name = Type.TYPES_PREFIX + t.name;

   378                 }

   379             }

   380         }

   381 

   382         for (TypeElement t : types.values()) {

   383             for (FieldElement f : t.fields) {

   384                 f.referenceType = types.get(f.typeName);

   385                 XmlType xmlType = xmlTypes.get(f.typeName);

   386                 if (xmlType != null) {

   387                     if (xmlType.javaType != null) {

   388                         f.typeName = xmlType.javaType;

   389                     }

   390                     if (xmlType.contentType != null) {

   391                         f.contentType = xmlType.contentType;

   392                     }

   393                     if (xmlType.unsigned) {

   394                         f.unsigned = true;

   395                     }

   396                 }

   397                 if (f.struct && f.referenceType != null) {

   398                     f.referenceType.valueType = true;

   399                 }

   400             }

   401         }

   402     }

   403 }