--- /dev/null	2016-10-25 08:46:44.038854975 +0200
+++ new/src/share/vm/evtrace/traceReaderThread.cpp	2016-10-25 10:40:15.418781656 +0200
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2014, 2015, Dynatrace and/or its affiliates. All rights reserved.
+ *
+ * This file is part of the Lock Contention Tracing Subsystem for the HotSpot
+ * Virtual Machine, which is developed at Christian Doppler Laboratory on
+ * Monitoring and Evolution of Very-Large-Scale Software Systems. Please
+ * contact us at <http://mevss.jku.at/> if you need additional information
+ * or have any questions.
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "evtrace/traceReaderThread.hpp"
+
+#include "evtrace/traceManager.hpp"
+
+#include "runtime/javaCalls.hpp"
+
+TraceReaderThread::TraceReaderThread(oop obj)
+: JavaThread(trace_reader_thread_entry),
+  _object(obj),
+  _is_polling_queue(false)
+{
+}
+
+TraceReaderThread::~TraceReaderThread() {
+  TraceManager::thread_is_exiting(this);
+}
+
+void TraceReaderThread::trace_reader_thread_entry(JavaThread* thread, TRAPS) {
+  TraceReaderThread *self = (TraceReaderThread *) thread;
+  JavaValue result(T_VOID);
+  Klass* klass = SystemDictionary::resolve_or_fail(vmSymbols::sun_evtracing_TraceReaderThread(), true, CHECK);
+  JavaCalls::call_virtual(&result,
+                          self->_object,
+                          klass,
+                          vmSymbols::run_method_name(),
+                          vmSymbols::void_method_signature(),
+                          CHECK);
+}
+
+TraceReaderThread* TraceReaderThread::start(Handle flushq, Handle freeq, TRAPS) {
+  Klass* rt_klass = SystemDictionary::resolve_or_fail(vmSymbols::sun_evtracing_TraceReaderThread(), true, CHECK_NULL);
+  instanceKlassHandle rt_khandle(THREAD, rt_klass);
+  rt_khandle->initialize(CHECK_NULL);
+  instanceHandle rt_obj = rt_khandle->allocate_instance_handle(CHECK_NULL);
+
+  JavaValue result(T_VOID);
+  JavaCalls::call_special(&result,
+                          rt_obj,
+                          rt_khandle,
+                          vmSymbols::object_initializer_name(),
+                          vmSymbols::TraceReaderThread_constructor_signature(),
+                          flushq,
+                          freeq,
+                          CHECK_NULL);
+
+  Klass* t_klass = SystemDictionary::resolve_or_fail(vmSymbols::java_lang_Thread(), true, CHECK_NULL);
+  instanceKlassHandle t_khandle(THREAD, t_klass);
+  instanceHandle t_obj = t_khandle->allocate_instance_handle(CHECK_NULL);
+
+  const char thread_name[] = "Trace Reader Thread";
+  Handle string = java_lang_String::create_from_str(thread_name, CHECK_NULL);
+
+  // Initialize thread_oop to put it into the system threadGroup
+  Handle thread_group(THREAD, Universe::system_thread_group());
+  JavaCalls::call_special(&result,
+                          t_obj,
+                          t_khandle,
+                          vmSymbols::object_initializer_name(),
+                          vmSymbols::threadgroup_string_void_signature(),
+                          thread_group,
+                          string,
+                          CHECK_NULL);
+
+  TraceReaderThread *trt = NULL;
+  {
+    MutexLocker mu(Threads_lock);
+    trt = new TraceReaderThread(rt_obj());
+
+    if (trt == NULL || trt->osthread() == NULL) {
+      vm_exit_during_initialization("java.lang.OutOfMemoryError", "unable to create new native thread");
+    }
+    java_lang_Thread::set_thread(t_obj(), trt);
+    java_lang_Thread::set_daemon(t_obj());
+
+    trt->set_threadObj(t_obj());
+    Threads::add(trt);
+    Thread::start(trt);
+  }
+  return trt;
+}
+
+void TraceReaderThread::shutdown(TRAPS) {
+  Klass* rt_klass = SystemDictionary::resolve_or_fail(vmSymbols::sun_evtracing_TraceReaderThread(), true, CHECK);
+  instanceKlassHandle rt_khandle(THREAD, rt_klass);
+
+  JavaValue result(T_VOID);
+  JavaCalls::call_virtual(&result,
+                          Handle(_object),
+                          rt_khandle,
+                          vmSymbols::shutdown_method_name(),
+                          vmSymbols::void_method_signature(),
+                          CHECK);
+}
+
+void TraceReaderThread::oops_do(OopClosure* f, CLDClosure* cld_f, CodeBlobClosure* cf) {
+  JavaThread::oops_do(f, cld_f, cf);
+
+  f->do_oop(&_object);
+}