jdk8-mips64-public/hotspot: src/os/solaris/vm/dtraceJSDT

src/os/solaris/vm/dtraceJSDT_solaris.cpp@754c24457b20 (annotated)

src/os/solaris/vm/dtraceJSDT_solaris.cpp

Wed, 27 Mar 2013 19:21:18 +0100

author: tschatzl
date: Wed, 27 Mar 2013 19:21:18 +0100
changeset 4854: 754c24457b20
parent 4037: da91efe96a93
child 6876: 710a3c8b516e
permissions: -rw-r--r--

7112912: Message "Error occurred during initialization of VM" on boxes with lots of RAM
Summary: Ergonomics now also takes available virtual memory into account when deciding for a heap size. The helper method to determine the maximum allocatable memory block now uses the appropriate OS specific calls to retrieve available virtual memory for the java process. In 32 bit environments this method now also searches for the maximum actually reservable amount of memory. Merge previously separate implementations for Linux/BSD/Solaris into a single method.
Reviewed-by: jmasa, tamao

 /*
  * Copyright (c) 2005, 2012, Oracle and/or its affiliates. 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.
  *
  * 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,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  *
  */
 #include "precompiled.hpp"
 #include "classfile/javaClasses.hpp"
 #include "code/codeBlob.hpp"
 #include "memory/allocation.hpp"
 #include "prims/jvm.h"
 #include "runtime/dtraceJSDT.hpp"
 #include "runtime/jniHandles.hpp"
 #include "runtime/os.hpp"
 #include "runtime/signature.hpp"
 #include "utilities/globalDefinitions.hpp"
 #ifdef HAVE_DTRACE_H
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <dtrace.h>
 static const char* devname    = "/dev/dtrace/helper";
 static const char* olddevname = "/devices/pseudo/dtrace@0:helper";
 static const char* string_sig = "uintptr_t";
 static const char* int_sig    = "long";
 static const char* long_sig   = "long long";
 static void printDOFHelper(dof_helper_t* helper);
 static int dofhelper_open() {
   int fd;
   if ((fd = open64(devname, O_RDWR)) < 0) {
     // Optimize next calls
     devname = olddevname;
     if ((fd = open64(devname, O_RDWR)) < 0) {
       return -1;
     }
   }
   return fd;
 }
 static jint dof_register(jstring module, uint8_t* dof, void* modaddr) {
   int probe;
   dof_helper_t dh;
   int fd;
   memset(&dh, 0, sizeof(dh));
   char* module_name = java_lang_String::as_utf8_string(
         JNIHandles::resolve_non_null(module));
   jio_snprintf(dh.dofhp_mod, sizeof(dh.dofhp_mod), "%s", module_name);
   dh.dofhp_dof  = (uint64_t)dof;
   dh.dofhp_addr = (uint64_t)modaddr;
   fd = dofhelper_open();
   if (fd < 0)
     return -1;
   probe = ioctl(fd, DTRACEHIOC_ADDDOF, &dh);
   close(fd);
   if (PrintDTraceDOF) {
     printDOFHelper(&dh);
     tty->print_cr("DOF helper id = %d", probe);
   }
   return probe;
 }
 int DTraceJSDT::pd_activate(
     void* moduleBaseAddress, jstring module,
     jint providers_count, JVM_DTraceProvider* providers) {
   // We need sections:
   //  (1) STRTAB
   //  (
   //    (2) PROVIDER
   //    (3) PROBES
   //    (4) PROBOFFS
   //    (5) PROBARGS
   //  ) * Number of Providers
   // Type of sections we create
   enum {
     STRTAB = 0,
     PROVIDERS = 1,
     PROBES = 2,
     PROBE_OFFSETS = 3,
     ARG_OFFSETS = 4,
     NUM_SECTIONS = 5
   };
   static int alignment_for[NUM_SECTIONS] = { 1, 4, 8, 4, 1 };
   ResourceMark rm;
   uint32_t num_sections = 1 + 4 * providers_count;
   uint32_t offset = sizeof(dof_hdr_t) + (num_sections * sizeof(dof_sec_t));
   uint32_t* secoffs = NEW_RESOURCE_ARRAY(uint32_t, num_sections);
   uint32_t* secsize = NEW_RESOURCE_ARRAY(uint32_t, num_sections);
   // Store offsets of all strings here in such order:
   //  zero-string (always 0)
   //  provider1-name
   //    probe1-function
   //    probe1-name
   //    arg-1
   //    arg-2
   //    ...
   //    probe2-function
   //    probe2-name
   //    arg-1
   //    arg-2
   //  provider2-name
   //    ...
   uint32_t strcount  = 0;
   // Count the number of strings we'll need
   for(int prvc = 0; prvc < providers_count; ++prvc) {
     JVM_DTraceProvider* provider = &providers[prvc];
     // Provider name
     ++strcount;
     for(int prbc = 0; prbc < provider->probe_count; ++prbc) {
       JVM_DTraceProbe* p = &(provider->probes[prbc]);
       Symbol* sig = Method::resolve_jmethod_id(p->method)->signature();
       // function + name + one per argument
       strcount += 2 + ArgumentCount(sig).size();
     }
   }
   // Create place for string offsets
   uint32_t* stroffs = NEW_RESOURCE_ARRAY(uint32_t, strcount + 1);
   uint32_t string_index = 0;
   uint32_t curstr = 0;
   // First we need an empty string: ""
   stroffs[curstr++] = string_index;
   string_index += strlen("") + 1;
   for(int prvc = 0; prvc < providers_count; ++prvc) {
     JVM_DTraceProvider* provider = &providers[prvc];
     char* provider_name = java_lang_String::as_utf8_string(
         JNIHandles::resolve_non_null(provider->name));
     stroffs[curstr++] = string_index;
     string_index += strlen(provider_name) + 1;
     // All probes
     for(int prbc = 0; prbc < provider->probe_count; ++prbc) {
       JVM_DTraceProbe* p = &(provider->probes[prbc]);
       char* function = java_lang_String::as_utf8_string(
           JNIHandles::resolve_non_null(p->function));
       stroffs[curstr++] = string_index;
       string_index += strlen(function) + 1;
       char* name = java_lang_String::as_utf8_string(
           JNIHandles::resolve_non_null(p->name));
       stroffs[curstr++] = string_index;
       string_index += strlen(name) + 1;
       Symbol* sig = Method::resolve_jmethod_id(p->method)->signature();
       SignatureStream ss(sig);
       for ( ; !ss.at_return_type(); ss.next()) {
         BasicType bt = ss.type();
         const char* t = NULL;
         if (bt == T_OBJECT &&
             ss.as_symbol_or_null() == vmSymbols::java_lang_String()) {
           t = string_sig;
         } else if (bt == T_LONG) {
           t = long_sig;
         } else {
           t = int_sig;
         }
         stroffs[curstr++] = string_index;
         string_index += strlen(t) + 1;
       }
     }
   }
   secoffs[STRTAB] = offset;
   secsize[STRTAB] = string_index;
   offset += string_index;
   // Calculate the size of the rest
   for(int prvc = 0; prvc < providers_count; ++prvc) {
     JVM_DTraceProvider* provider = &providers[prvc];
     size_t provider_sec  = PROVIDERS     + prvc * 4;
     size_t probe_sec     = PROBES        + prvc * 4;
     size_t probeoffs_sec = PROBE_OFFSETS + prvc * 4;
     size_t argoffs_sec   = ARG_OFFSETS   + prvc * 4;
     // Allocate space for the provider data struction
     secoffs[provider_sec] = align_size_up(offset, alignment_for[PROVIDERS]);
     secsize[provider_sec] = sizeof(dof_provider_t);
     offset = secoffs[provider_sec] + secsize[provider_sec];
     // Allocate space for all the probes
     secoffs[probe_sec] = align_size_up(offset, alignment_for[PROBES]);
     secsize[probe_sec] = sizeof(dof_probe_t) * provider->probe_count;
     offset = secoffs[probe_sec] + secsize[probe_sec];
     // Allocate space for the probe offsets
     secoffs[probeoffs_sec] = align_size_up(offset, alignment_for[PROBE_OFFSETS]);
     secsize[probeoffs_sec] = sizeof(uint32_t) * provider->probe_count;
     offset = secoffs[probeoffs_sec] + secsize[probeoffs_sec];
     // We need number of arguments argoffs
     uint32_t argscount = 0;
     for(int prbc = 0; prbc < provider->probe_count; ++prbc) {
        JVM_DTraceProbe* p = &(provider->probes[prbc]);
        Symbol* sig = Method::resolve_jmethod_id(p->method)->signature();
        argscount += ArgumentCount(sig).size();
     }
     secoffs[argoffs_sec] = align_size_up(offset, alignment_for[ARG_OFFSETS]);
     secsize[argoffs_sec] = sizeof(uint8_t) * argscount;
     offset = secoffs[argoffs_sec] + secsize[argoffs_sec];
   }
   uint32_t size = offset;
   uint8_t* dof = NEW_RESOURCE_ARRAY(uint8_t, size);
   if (!dof) {
     return -1;
   }
   memset((void*)dof, 0, size);
   // Fill memory with proper values
   dof_hdr_t* hdr = (dof_hdr_t*)dof;
   hdr->dofh_ident[DOF_ID_MAG0]     = DOF_MAG_MAG0;
   hdr->dofh_ident[DOF_ID_MAG1]     = DOF_MAG_MAG1;
   hdr->dofh_ident[DOF_ID_MAG2]     = DOF_MAG_MAG2;
   hdr->dofh_ident[DOF_ID_MAG3]     = DOF_MAG_MAG3;
   hdr->dofh_ident[DOF_ID_MODEL]    = DOF_MODEL_NATIVE;  // No variants
   hdr->dofh_ident[DOF_ID_ENCODING] = DOF_ENCODE_NATIVE; // No variants
   hdr->dofh_ident[DOF_ID_VERSION]  = DOF_VERSION_1;     // No variants
   hdr->dofh_ident[DOF_ID_DIFVERS]  = DIF_VERSION_2;     // No variants
   // all other fields of ident to zero
   hdr->dofh_flags   = 0;
   hdr->dofh_hdrsize = sizeof(dof_hdr_t);
   hdr->dofh_secsize = sizeof(dof_sec_t);
   hdr->dofh_secnum  = num_sections;
   hdr->dofh_secoff  = sizeof(dof_hdr_t);
   hdr->dofh_loadsz  = size;
   hdr->dofh_filesz  = size;
   // First section: STRTAB
   dof_sec_t* sec = (dof_sec_t*)(dof + sizeof(dof_hdr_t));
   sec->dofs_type    = DOF_SECT_STRTAB;
   sec->dofs_align   = alignment_for[STRTAB];
   sec->dofs_flags   = DOF_SECF_LOAD;
   sec->dofs_entsize = 0;
   sec->dofs_offset  = secoffs[STRTAB];
   sec->dofs_size    = secsize[STRTAB];
   // Make data for this section
   char* str = (char*)(dof + sec->dofs_offset);
   *str = 0; str += 1; // ""
   // Run through all strings again
   for(int prvc = 0; prvc < providers_count; ++prvc) {
     JVM_DTraceProvider* provider = &providers[prvc];
     char* provider_name = java_lang_String::as_utf8_string(
         JNIHandles::resolve_non_null(provider->name));
     strcpy(str, provider_name);
     str += strlen(provider_name) + 1;
     // All probes
     for(int prbc = 0; prbc < provider->probe_count; ++prbc) {
       JVM_DTraceProbe* p = &(provider->probes[prbc]);
       char* function = java_lang_String::as_utf8_string(
           JNIHandles::resolve_non_null(p->function));
       strcpy(str, function);
       str += strlen(str) + 1;
       char* name = java_lang_String::as_utf8_string(
           JNIHandles::resolve_non_null(p->name));
       strcpy(str, name);
       str += strlen(name) + 1;
       Symbol* sig = Method::resolve_jmethod_id(p->method)->signature();
       SignatureStream ss(sig);
       for ( ; !ss.at_return_type(); ss.next()) {
         BasicType bt = ss.type();
         const char* t;
         if (bt == T_OBJECT &&
             ss.as_symbol_or_null() == vmSymbols::java_lang_String()) {
           t = string_sig;
         } else if (bt == T_LONG) {
           t = long_sig;
         } else {
           t = int_sig;
         }
         strcpy(str, t);
         str += strlen(t) + 1;
       }
     }
   }
   curstr = 1;
   for(int prvc = 0; prvc < providers_count; ++prvc) {
     JVM_DTraceProvider* provider = &providers[prvc];
     size_t provider_sec  = PROVIDERS     + prvc * 4;
     size_t probe_sec     = PROBES        + prvc * 4;
     size_t probeoffs_sec = PROBE_OFFSETS + prvc * 4;
     size_t argoffs_sec   = ARG_OFFSETS   + prvc * 4;
     // PROVIDER ///////////////////////////////////////////////////////////////
     // Section header
     sec = (dof_sec_t*)
         (dof + sizeof(dof_hdr_t) + sizeof(dof_sec_t) * provider_sec);
     sec->dofs_type    = DOF_SECT_PROVIDER;
     sec->dofs_align   = alignment_for[PROVIDERS];
     sec->dofs_flags   = DOF_SECF_LOAD;
     sec->dofs_entsize = 0;
     sec->dofs_offset  = secoffs[provider_sec];
     sec->dofs_size    = secsize[provider_sec];
     // Make provider decriiption
     dof_provider_t* prv = (dof_provider_t*)(dof + sec->dofs_offset);
     prv->dofpv_strtab   = STRTAB;
     prv->dofpv_probes   = probe_sec;
     prv->dofpv_prargs   = argoffs_sec;
     prv->dofpv_proffs   = probeoffs_sec;
     prv->dofpv_name     = stroffs[curstr++]; // Index in string table
     prv->dofpv_provattr = DOF_ATTR(
         provider->providerAttributes.nameStability,
         provider->providerAttributes.dataStability,
         provider->providerAttributes.dependencyClass);
     prv->dofpv_modattr = DOF_ATTR(
         provider->moduleAttributes.nameStability,
         provider->moduleAttributes.dataStability,
         provider->moduleAttributes.dependencyClass);
     prv->dofpv_funcattr = DOF_ATTR(
         provider->functionAttributes.nameStability,
         provider->functionAttributes.dataStability,
         provider->functionAttributes.dependencyClass);
     prv->dofpv_nameattr = DOF_ATTR(
         provider->nameAttributes.nameStability,
         provider->nameAttributes.dataStability,
         provider->nameAttributes.dependencyClass);
     prv->dofpv_argsattr = DOF_ATTR(
         provider->argsAttributes.nameStability,
         provider->argsAttributes.dataStability,
         provider->argsAttributes.dependencyClass);
     // PROBES /////////////////////////////////////////////////////////////////
     // Section header
     sec = (dof_sec_t*)
         (dof + sizeof(dof_hdr_t) + sizeof(dof_sec_t) * probe_sec);
     sec->dofs_type    = DOF_SECT_PROBES;
     sec->dofs_align   = alignment_for[PROBES];
     sec->dofs_flags   = DOF_SECF_LOAD;
     sec->dofs_entsize = sizeof(dof_probe_t);
     sec->dofs_offset  = secoffs[probe_sec];
     sec->dofs_size    = secsize[probe_sec];
     // Make probes descriptions
     uint32_t argsoffs = 0;
     for(int prbc = 0; prbc < provider->probe_count; ++prbc) {
       JVM_DTraceProbe* probe = &(provider->probes[prbc]);
       Method* m = Method::resolve_jmethod_id(probe->method);
       int arg_count = ArgumentCount(m->signature()).size();
       assert(m->code() != NULL, "must have an nmethod");
       dof_probe_t* prb =
          (dof_probe_t*)(dof + sec->dofs_offset + prbc * sizeof(dof_probe_t));
       prb->dofpr_addr   = (uint64_t)m->code()->entry_point();
       prb->dofpr_func   = stroffs[curstr++]; // Index in string table
       prb->dofpr_name   = stroffs[curstr++]; // Index in string table
       prb->dofpr_nargv  = stroffs[curstr  ]; // Index in string table
       // We spent siglen strings here
       curstr += arg_count;
       prb->dofpr_xargv  = prb->dofpr_nargv;  // Same bunch of strings
       prb->dofpr_argidx = argsoffs;
       prb->dofpr_offidx = prbc;
       prb->dofpr_nargc  = arg_count;
       prb->dofpr_xargc  = arg_count;
       prb->dofpr_noffs  = 1; // Number of offsets
       // Next bunch of offsets
       argsoffs += arg_count;
     }
     // PROFFS /////////////////////////////////////////////////////////////////
     // Section header
     sec = (dof_sec_t*)
         (dof + sizeof(dof_hdr_t) + sizeof(dof_sec_t) * probeoffs_sec);
     sec->dofs_type    = DOF_SECT_PROFFS;
     sec->dofs_align   = alignment_for[PROBE_OFFSETS];
     sec->dofs_flags   = DOF_SECF_LOAD;
     sec->dofs_entsize = sizeof(uint32_t);
     sec->dofs_offset  = secoffs[probeoffs_sec];
     sec->dofs_size    = secsize[probeoffs_sec];
     // Make offsets
     for (int prbc = 0; prbc < provider->probe_count; ++prbc) {
       uint32_t* pof =
           (uint32_t*)(dof + sec->dofs_offset + sizeof(uint32_t) * prbc);
       JVM_DTraceProbe* probe = &(provider->probes[prbc]);
       Method* m = Method::resolve_jmethod_id(probe->method);
       *pof = m->code()->trap_offset();
     }
     // PRARGS /////////////////////////////////////////////////////////////////
     // Section header
     sec = (dof_sec_t*)
         (dof + sizeof(dof_hdr_t) + sizeof(dof_sec_t) * argoffs_sec);
     sec->dofs_type    = DOF_SECT_PRARGS;
     sec->dofs_align   = alignment_for[ARG_OFFSETS];
     sec->dofs_flags   = DOF_SECF_LOAD;
     sec->dofs_entsize = sizeof(uint8_t);
     sec->dofs_offset  = secoffs[argoffs_sec];
     sec->dofs_size    = secsize[argoffs_sec];
     // Make arguments
     uint8_t* par = (uint8_t*)(dof + sec->dofs_offset);
     for (int prbc = 0; prbc < provider->probe_count; ++prbc) {
       JVM_DTraceProbe* p = &(provider->probes[prbc]);
       Symbol* sig = Method::resolve_jmethod_id(p->method)->signature();
       uint8_t count = (uint8_t)ArgumentCount(sig).size();
       for (uint8_t i = 0; i < count; ++i) {
         *par++ = i;
       }
     }
   }
   // Register module
   return dof_register(module, dof, moduleBaseAddress);
 }
 void DTraceJSDT::pd_dispose(int handle) {
   int fd;
   if (handle == -1) {
     return;
   }
   fd = dofhelper_open();
   if (fd < 0)
     return;
   ioctl(fd, DTRACEHIOC_REMOVE, handle);
   close(fd);
 }
 jboolean DTraceJSDT::pd_is_supported() {
   int fd = dofhelper_open();
   if (fd < 0) {
     return false;
   }
   close(fd);
   return true;
 }
 static const char* dofSecTypeFor(uint32_t type) {
   switch (type) {
     case 0:  return "DOF_SECT_NONE";
     case 1:  return "DOF_SECT_COMMENTS";
     case 2:  return "DOF_SECT_SOURCE";
     case 3:  return "DOF_SECT_ECBDESC";
     case 4:  return "DOF_SECT_PROBEDESC";
     case 5:  return "DOF_SECT_ACTDESC";
     case 6:  return "DOF_SECT_DIFOHDR";
     case 7:  return "DOF_SECT_DIF";
     case 8:  return "DOF_SECT_STRTAB";
     case 9:  return "DOF_SECT_VARTAB";
     case 10: return "DOF_SECT_RELTAB";
     case 11: return "DOF_SECT_TYPETAB";
     case 12: return "DOF_SECT_URELHDR";
     case 13: return "DOF_SECT_KRELHDR";
     case 14: return "DOF_SECT_OPTDESC";
     case 15: return "DOF_SECT_PROVIDER";
     case 16: return "DOF_SECT_PROBES";
     case 17: return "DOF_SECT_PRARGS";
     case 18: return "DOF_SECT_PROFFS";
     case 19: return "DOF_SECT_INTTAB";
     case 20: return "DOF_SECT_UTSNAME";
     case 21: return "DOF_SECT_XLTAB";
     case 22: return "DOF_SECT_XLMEMBERS";
     case 23: return "DOF_SECT_XLIMPORT";
     case 24: return "DOF_SECT_XLEXPORT";
     case 25: return "DOF_SECT_PREXPORT";
     case 26: return "DOF_SECT_PRENOFFS";
     default: return "<unknown>";
   }
 }
 static void printDOFStringTabSec(void* dof, dof_sec_t* sec) {
   size_t tab = sec->dofs_offset;
   size_t limit = sec->dofs_size;
   tty->print_cr("//   String Table:");
   for (size_t idx = 0; idx < limit; /*empty*/) {
     char* str = ((char*)dof) + tab + idx;
     tty->print_cr("//   [0x%x + 0x%x] '%s'", tab, idx, str);
     idx += strlen(str) + 1;
   }
 }
 static void printDOFProviderSec(void* dof, dof_sec_t* sec) {
   dof_provider_t* prov = (dof_provider_t*)((char*)dof + sec->dofs_offset);
   tty->print_cr("//   dof_provider_t {");
   tty->print_cr("//     dofpv_strtab = %d", prov->dofpv_strtab);
   tty->print_cr("//     dofpv_probes = %d", prov->dofpv_probes);
   tty->print_cr("//     dofpv_prargs = %d", prov->dofpv_prargs);
   tty->print_cr("//     dofpv_proffs = %d", prov->dofpv_proffs);
   tty->print_cr("//     dofpv_name = 0x%x", prov->dofpv_name);
   tty->print_cr("//     dofpv_provattr = 0x%08x", prov->dofpv_provattr);
   tty->print_cr("//     dofpv_modattr = 0x%08x", prov->dofpv_modattr);
   tty->print_cr("//     dofpv_funcattr = 0x%08x", prov->dofpv_funcattr);
   tty->print_cr("//     dofpv_nameattr = 0x%08x", prov->dofpv_nameattr);
   tty->print_cr("//     dofpv_argsattr = 0x%08x", prov->dofpv_argsattr);
   tty->print_cr("//   }");
 }
 static void printDOFProbesSec(void* dof, dof_sec_t* sec) {
   size_t idx = sec->dofs_offset;
   size_t limit = idx + sec->dofs_size;
   for (size_t idx = sec->dofs_offset; idx < limit; idx += sec->dofs_entsize) {
     dof_probe_t* prb = (dof_probe_t*)((char*)dof + idx);
     tty->print_cr("//   dof_probe_t {");
     tty->print_cr("//     dofpr_addr = 0x%016llx", prb->dofpr_addr);
     tty->print_cr("//     dofpr_func = 0x%x", prb->dofpr_func);
     tty->print_cr("//     dofpr_name = 0x%x", prb->dofpr_name);
     tty->print_cr("//     dofpr_nargv = 0x%x", prb->dofpr_nargv);
     tty->print_cr("//     dofpr_xargv = 0x%x", prb->dofpr_xargv);
     tty->print_cr("//     dofpr_argidx = 0x%x", prb->dofpr_argidx);
     tty->print_cr("//     dofpr_offidx = 0x%x", prb->dofpr_offidx);
     tty->print_cr("//     dofpr_nargc = %d", prb->dofpr_nargc);
     tty->print_cr("//     dofpr_xargc = %d", prb->dofpr_xargc);
     tty->print_cr("//     dofpr_noffs = %d", prb->dofpr_noffs);
     tty->print_cr("//   }");
   }
 }
 static void printDOFOffsetsSec(void* dof, dof_sec_t* sec) {
   size_t tab = sec->dofs_offset;
   size_t limit = sec->dofs_size;
   tty->print_cr("//   Offsets:");
   for (size_t idx = 0; idx < limit; idx += sec->dofs_entsize) {
     uint32_t* off = (uint32_t*)((char*)dof + tab + idx);
     tty->print_cr("//   [0x%x + 0x%x]: %d", tab, idx, *off);
   }
 }
 static void printDOFArgsSec(void* dof, dof_sec_t* sec) {
   size_t tab = sec->dofs_offset;
   size_t limit = sec->dofs_size;
   tty->print_cr("//   Arguments:");
   for (size_t idx = 0; idx < limit; idx += sec->dofs_entsize) {
     uint8_t* arg = (uint8_t*)((char*)dof + tab + idx);
     tty->print_cr("//   [0x%x + 0x%x]: %d", tab, idx, *arg);
   }
 }
 static void printDOFSection(void* dof, dof_sec_t* sec) {
   tty->print_cr("//   dof_sec_t {");
   tty->print_cr("//     dofs_type = 0x%x /* %s */",
                 sec->dofs_type, dofSecTypeFor(sec->dofs_type));
   tty->print_cr("//     dofs_align = %d", sec->dofs_align);
   tty->print_cr("//     dofs_flags = 0x%x", sec->dofs_flags);
   tty->print_cr("//     dofs_entsize = %d", sec->dofs_entsize);
   tty->print_cr("//     dofs_offset = 0x%llx", sec->dofs_offset);
   tty->print_cr("//     dofs_size = %lld", sec->dofs_size);
   tty->print_cr("//   }");
   switch (sec->dofs_type) {
     case DOF_SECT_STRTAB:    printDOFStringTabSec(dof, sec); break;
     case DOF_SECT_PROVIDER:  printDOFProviderSec(dof, sec);  break;
     case DOF_SECT_PROBES:    printDOFProbesSec(dof, sec);    break;
     case DOF_SECT_PROFFS:    printDOFOffsetsSec(dof, sec);   break;
     case DOF_SECT_PRARGS:    printDOFArgsSec(dof, sec);      break;
     default: tty->print_cr("//   <section type not recognized>");
   }
 }
 static void printDOFHeader(dof_hdr_t* hdr) {
   tty->print_cr("//   dof_hdr_t {");
   tty->print_cr("//     dofh_ident[DOF_ID_MAG0] = 0x%x",
                 hdr->dofh_ident[DOF_ID_MAG0]);
   tty->print_cr("//     dofh_ident[DOF_ID_MAG1] = 0x%x",
                 hdr->dofh_ident[DOF_ID_MAG1]);
   tty->print_cr("//     dofh_ident[DOF_ID_MAG2] = 0x%x",
                 hdr->dofh_ident[DOF_ID_MAG2]);
   tty->print_cr("//     dofh_ident[DOF_ID_MAG3] = 0x%x",
                 hdr->dofh_ident[DOF_ID_MAG3]);
   tty->print_cr("//     dofh_ident[DOF_ID_MODEL] = 0x%x",
                 hdr->dofh_ident[DOF_ID_MODEL]);
   tty->print_cr("//     dofh_ident[DOF_ID_ENCODING] = 0x%x",
                 hdr->dofh_ident[DOF_ID_ENCODING]);
   tty->print_cr("//     dofh_ident[DOF_ID_VERSION] = 0x%x",
                 hdr->dofh_ident[DOF_ID_VERSION]);
   tty->print_cr("//     dofh_ident[DOF_ID_DIFVERS] = 0x%x",
                 hdr->dofh_ident[DOF_ID_DIFVERS]);
   tty->print_cr("//     dofh_flags = 0x%x", hdr->dofh_flags);
   tty->print_cr("//     dofh_hdrsize = %d", hdr->dofh_hdrsize);
   tty->print_cr("//     dofh_secsize = %d", hdr->dofh_secsize);
   tty->print_cr("//     dofh_secnum = %d", hdr->dofh_secnum);
   tty->print_cr("//     dofh_secoff = %lld", hdr->dofh_secoff);
   tty->print_cr("//     dofh_loadsz = %lld", hdr->dofh_loadsz);
   tty->print_cr("//     dofh_filesz = %lld", hdr->dofh_filesz);
   tty->print_cr("//   }");
 }
 static void printDOF(void* dof) {
   dof_hdr_t* hdr = (dof_hdr_t*)dof;
   printDOFHeader(hdr);
   for (int i = 0; i < hdr->dofh_secnum; ++i) {
     dof_sec_t* sec =
       (dof_sec_t*)((char*)dof + sizeof(dof_hdr_t) + i * sizeof(dof_sec_t));
     tty->print_cr("//   [Section #%d]", i);
     printDOFSection(dof, sec);
   }
 }
 static void printDOFHelper(dof_helper_t* helper) {
   tty->print_cr("// dof_helper_t {");
   tty->print_cr("//   dofhp_mod = \"%s\"", helper->dofhp_mod);
   tty->print_cr("//   dofhp_addr = 0x%016llx", helper->dofhp_addr);
   tty->print_cr("//   dofhp_dof = 0x%016llx", helper->dofhp_dof);
   printDOF((void*)helper->dofhp_dof);
   tty->print_cr("// }");
   size_t len = ((dof_hdr_t*)helper)->dofh_loadsz;
   tty->print_data((void*)helper->dofhp_dof, len, true);
 }
 #else // ndef HAVE_DTRACE_H
 // Get here if we're not building on at least Solaris 10
 int DTraceJSDT::pd_activate(
   void* baseAddress, jstring module,
   jint provider_count, JVM_DTraceProvider* providers) {
   return -1;
 }
 void DTraceJSDT::pd_dispose(int handle) {
 }
 jboolean DTraceJSDT::pd_is_supported() {
   return false;
 }
 #endif

Mercurial > jdk8-mips64-public > hotspot / annotate

src/os/solaris/vm/dtraceJSDT_solaris.cpp@754c24457b20 (annotated)

src/os/solaris/vm/dtraceJSDT_solaris.cpp