--- old/src/share/vm/memory/metaspace.cpp	2014-03-05 17:27:06.682776954 +0100
+++ new/src/share/vm/memory/metaspace.cpp	2014-03-05 17:27:06.586776949 +0100
@@ -3355,6 +3355,8 @@
   MetaWord* result = loader_data->metaspace_non_null()->allocate(word_size, mdtype);
 
   if (result == NULL) {
+    tracer()->report_metaspace_allocation_failure(loader_data, word_size, type, mdtype);
+
     // Allocation failed.
     if (is_init_completed()) {
       // Only start a GC if the bootstrapping has completed.
@@ -3423,6 +3425,16 @@
   }
 }
 
+const char* Metaspace::metadata_type_name(Metaspace::MetadataType mdtype) {
+  switch (mdtype) {
+    case Metaspace::ClassType: return "Class Type";
+    case Metaspace::NonClassType: return "Non Class Type";
+    default:
+      assert(false, err_msg("Got bad mdtype: %d", (int) mdtype));
+      return NULL;
+  }
+}
+
 void Metaspace::record_allocation(void* ptr, MetaspaceObj::Type type, size_t word_size) {
   assert(DumpSharedSpaces, "sanity");
 
--- old/src/share/vm/memory/metaspace.hpp	2014-03-05 17:27:07.238776980 +0100
+++ new/src/share/vm/memory/metaspace.hpp	2014-03-05 17:27:07.146776975 +0100
@@ -241,6 +241,8 @@
   static void report_metadata_oome(ClassLoaderData* loader_data, size_t word_size,
                                    MetadataType mdtype, TRAPS);
 
+  static const char* metadata_type_name(Metaspace::MetadataType mdtype);
+
   void print_on(outputStream* st) const;
   // Debugging support
   void verify();
--- old/src/share/vm/memory/metaspaceTracer.cpp	2014-03-05 17:27:07.766777004 +0100
+++ new/src/share/vm/memory/metaspaceTracer.cpp	2014-03-05 17:27:07.674777000 +0100
@@ -23,9 +23,15 @@
  */
 
 #include "precompiled.hpp"
+#include "classfile/classLoaderData.hpp"
 #include "memory/metaspaceTracer.hpp"
+#include "runtime/frame.hpp"
+#include "runtime/os.hpp"
+#include "runtime/thread.inline.hpp"
 #include "trace/tracing.hpp"
 #include "trace/traceBackend.hpp"
+#include "utilities/decoder.hpp"
+#include "utilities/ostream.hpp"
 
 void MetaspaceTracer::report_gc_threshold(size_t old_val,
                                           size_t new_val,
@@ -38,3 +44,77 @@
     event.commit();
   }
 }
+
+static bool get_method_name(address pc, char *buf, size_t buflen) {
+  if (os::address_is_in_vm(pc) && Decoder::can_decode_C_frame_in_vm()) {
+    return os::dll_address_to_function_name(pc, buf, (int) buflen, 0);
+  }
+  return false;
+}
+
+static bool is_valid_frame_in_vm(const frame* f) {
+  return f->pc() && os::address_is_in_vm(f->pc()) && !f->is_java_frame();
+}
+
+static void write_vm_stack_trace(outputStream *stream) {
+  const size_t max_num_frames = 64;
+  size_t num_frames = 0;
+
+  const size_t buflen = 256;
+  char *buf = NEW_RESOURCE_ARRAY(char, buflen);
+
+  Thread* current_thread = Thread::current();
+  frame fr = os::current_frame();
+  while (is_valid_frame_in_vm(&fr) && num_frames < max_num_frames) {
+    if (get_method_name(fr.pc(), buf, buflen)) {
+      stream->print_cr("%s", buf);
+    } else {
+      stream->print_cr(PTR_FORMAT, fr.pc());
+    }
+
+    // Check if it safe to get the caller's stack frame.
+    if (fr.safe_for_sender(current_thread)) {
+      fr = os::get_sender_for_C_frame(&fr);
+    } else {
+      // Not safe to traverse the stack any further.
+      return;
+    }
+
+    num_frames++;
+  }
+}
+
+void MetaspaceTracer::report_metaspace_allocation_failure(ClassLoaderData *cld,
+                                                          size_t word_size,
+                                                          MetaspaceObj::Type objtype,
+                                                          Metaspace::MetadataType mdtype) const {
+  EventMetaspaceAllocationFailure event;
+  if (event.should_commit()) {
+    if (cld->is_anonymous()) {
+      event.set_classLoader(NULL);
+      event.set_anonymousClassLoader(true);
+    } else {
+      if (cld->is_the_null_class_loader_data()) {
+        event.set_classLoader((Klass*) NULL);
+      } else {
+        event.set_classLoader(cld->class_loader()->klass());
+      }
+      event.set_anonymousClassLoader(false);
+    }
+
+#ifdef _WINDOWS
+    // Can not walk the stack on Windows using the frame pointer.
+    event.set_nativeStackTrace(NULL);
+#else
+    ResourceMark rm;
+    stringStream stack_trace;
+    write_vm_stack_trace(&stack_trace);
+    event.set_nativeStackTrace(stack_trace.as_string());
+#endif
+
+    event.set_size(word_size * BytesPerWord);
+    event.set_metadataType((u1) mdtype);
+    event.set_metaspaceObjectType((u1) objtype);
+    event.commit();
+  }
+}
--- old/src/share/vm/memory/metaspaceTracer.hpp	2014-03-05 17:27:08.294777029 +0100
+++ new/src/share/vm/memory/metaspaceTracer.hpp	2014-03-05 17:27:08.202777024 +0100
@@ -26,13 +26,22 @@
 #define SHARE_VM_MEMORY_METASPACE_TRACER_HPP
 
 #include "memory/allocation.hpp"
+#include "memory/metaspace.hpp"
 #include "memory/metaspaceGCThresholdUpdater.hpp"
 
+class ClassLoaderData;
+class frame;
+class ouputStream;
+
 class MetaspaceTracer : public CHeapObj<mtTracing> {
  public:
   void report_gc_threshold(size_t old_val,
                            size_t new_val,
                            MetaspaceGCThresholdUpdater::Type updater) const;
+  void report_metaspace_allocation_failure(ClassLoaderData *cld,
+                                           size_t word_size,
+                                           MetaspaceObj::Type objtype,
+                                           Metaspace::MetadataType mdtype) const;
 };
 
 #endif // SHARE_VM_MEMORY_METASPACE_TRACER_HPP
--- old/src/share/vm/trace/trace.xml	2014-03-05 17:27:08.822777053 +0100
+++ new/src/share/vm/trace/trace.xml	2014-03-05 17:27:08.730777049 +0100
@@ -205,6 +205,15 @@
       <value type="GCTHRESHOLDUPDATER" field="updater" label="Updater" />
     </event>
 
+    <event id="MetaspaceAllocationFailure" path="vm/gc/metaspace/allocation_failure" label="Metaspace Allocation Failure" is_instant="true" has_stacktrace="true">
+      <value type="CLASS" field="classLoader" label="Class Loader" />
+      <value type="BOOLEAN" field="anonymousClassLoader" label="Anonymous Class Loader" />
+      <value type="UTF8" field="nativeStackTrace" label="Native Stack Trace" />
+      <value type="BYTES64" field="size" label="Size" />
+      <value type="METADATATYPE" field="metadataType" label="Metadata Type" />
+      <value type="METASPACEOBJTYPE" field="metaspaceObjectType" label="Metaspace Object Type" />
+    </event>
+
     <event id="PSHeapSummary" path="vm/gc/heap/ps_summary" label="Parallel Scavenge Heap Summary" is_instant="true">
       <value type="UINT" field="gcId" label="GC ID" relation="GC_ID"/>
       <value type="GCWHEN" field="when" label="When" />
--- old/src/share/vm/trace/tracetypes.xml	2014-03-05 17:27:09.366777078 +0100
+++ new/src/share/vm/trace/tracetypes.xml	2014-03-05 17:27:09.262777074 +0100
@@ -140,6 +140,16 @@
       <value type="UTF8" field="type" label="type" />
     </content_type>
 
+    <content_type id="MetadataType" hr_name="Metadata Type"
+                  type="U1" jvm_type="METADATATYPE">
+      <value type="UTF8" field="type" label="type" />
+    </content_type>
+
+    <content_type id="MetaspaceObjectType" hr_name="Metaspace Object Type"
+                  type="U1" jvm_type="METASPACEOBJTYPE">
+      <value type="UTF8" field="type" label="type" />
+    </content_type>
+
     <content_type id="NARROW_OOP_MODE" hr_name="Narrow Oop Mode"
                   type="U1" jvm_type="NARROWOOPMODE">
       <value type="UTF8" field="mode" label="mode" />
@@ -337,6 +347,14 @@
     <primary_type symbol="REFERENCETYPE" datatype="U1"
                   contenttype="REFERENCETYPE" type="u1" sizeop="sizeof(u1)" />
 
+    <!-- METADATATYPE -->
+    <primary_type symbol="METADATATYPE" datatype="U1"
+                  contenttype="METADATATYPE" type="u1" sizeop="sizeof(u1)" />
+
+    <!-- METADATAOBJTYPE -->
+    <primary_type symbol="METASPACEOBJTYPE" datatype="U1"
+                  contenttype="METASPACEOBJTYPE" type="u1" sizeop="sizeof(u1)" />
+
     <!-- NARROWOOPMODE -->
     <primary_type symbol="NARROWOOPMODE" datatype="U1"
                   contenttype="NARROWOOPMODE" type="u1" sizeop="sizeof(u1)" />