Mercurial > hg > truffle

comparison src/share/vm/prims/jvm.cpp @ 8866:16885e702c88

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
7198429: need checked categorization of caller-sensitive methods in the JDK Reviewed-by: kvn, jrose
author twisti
date Mon, 25 Mar 2013 17:13:26 -0700
parents 927a311d00f9
children cd9ad42dfde0
comparison
equal deleted inserted replaced
8865:818a1ac7da7a 8866:16885e702c88
28 #include "classfile/javaClasses.hpp" 28 #include "classfile/javaClasses.hpp"
29 #include "classfile/symbolTable.hpp" 29 #include "classfile/symbolTable.hpp"
30 #include "classfile/systemDictionary.hpp" 30 #include "classfile/systemDictionary.hpp"
31 #include "classfile/vmSymbols.hpp" 31 #include "classfile/vmSymbols.hpp"
32 #include "gc_interface/collectedHeap.inline.hpp" 32 #include "gc_interface/collectedHeap.inline.hpp"
33 #include "interpreter/bytecode.hpp"
33 #include "memory/oopFactory.hpp" 34 #include "memory/oopFactory.hpp"
34 #include "memory/universe.inline.hpp" 35 #include "memory/universe.inline.hpp"
35 #include "oops/fieldStreams.hpp" 36 #include "oops/fieldStreams.hpp"
36 #include "oops/instanceKlass.hpp" 37 #include "oops/instanceKlass.hpp"
37 #include "oops/objArrayKlass.hpp" 38 #include "oops/objArrayKlass.hpp"
663 // Misc. class handling /////////////////////////////////////////////////////////// 664 // Misc. class handling ///////////////////////////////////////////////////////////
664 665
665 666
666 JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env, int depth)) 667 JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env, int depth))
667 JVMWrapper("JVM_GetCallerClass"); 668 JVMWrapper("JVM_GetCallerClass");
668 Klass* k = thread->security_get_caller_class(depth); 669
669 return (k == NULL) ? NULL : (jclass) JNIHandles::make_local(env, k->java_mirror()); 670 // Pre-JDK 8 and early builds of JDK 8 don't have a CallerSensitive annotation.
671 if (SystemDictionary::reflect_CallerSensitive_klass() == NULL) {
672 Klass* k = thread->security_get_caller_class(depth);
673 return (k == NULL) ? NULL : (jclass) JNIHandles::make_local(env, k->java_mirror());
674 } else {
675 // Basic handshaking with Java_sun_reflect_Reflection_getCallerClass
676 assert(depth == -1, "wrong handshake depth");
677 }
678
679 // Getting the class of the caller frame.
680 //
681 // The call stack at this point looks something like this:
682 //
683 // [0] [ @CallerSensitive public sun.reflect.Reflection.getCallerClass ]
684 // [1] [ @CallerSensitive API.method ]
685 // [.] [ (skipped intermediate frames) ]
686 // [n] [ caller ]
687 vframeStream vfst(thread);
688 // Cf. LibraryCallKit::inline_native_Reflection_getCallerClass
689 for (int n = 0; !vfst.at_end(); vfst.security_next(), n++) {
690 Method* m = vfst.method();
691 assert(m != NULL, "sanity");
692 switch (n) {
693 case 0:
694 // This must only be called from Reflection.getCallerClass
695 if (m->intrinsic_id() != vmIntrinsics::_getCallerClass) {
696 THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "JVM_GetCallerClass must only be called from Reflection.getCallerClass");
697 }
698 // fall-through
699 case 1:
700 // Frame 0 and 1 must be caller sensitive.
701 if (!m->caller_sensitive()) {
702 THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), err_msg("CallerSensitive annotation expected at frame %d", n));
703 }
704 break;
705 default:
706 if (!m->is_ignored_by_security_stack_walk()) {
707 // We have reached the desired frame; return the holder class.
708 return (jclass) JNIHandles::make_local(env, m->method_holder()->java_mirror());
709 }
710 break;
711 }
712 }
713 return NULL;
670 JVM_END 714 JVM_END
671 715
672 716
673 JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf)) 717 JVM_ENTRY(jclass, JVM_FindPrimitiveClass(JNIEnv* env, const char* utf))
674 JVMWrapper("JVM_FindPrimitiveClass"); 718 JVMWrapper("JVM_FindPrimitiveClass");
3158 JvmtiVMObjectAllocEventCollector oam; 3202 JvmtiVMObjectAllocEventCollector oam;
3159 // Collect linked list of (handles to) method holders 3203 // Collect linked list of (handles to) method holders
3160 KlassLink* first = NULL; 3204 KlassLink* first = NULL;
3161 KlassLink* last = NULL; 3205 KlassLink* last = NULL;
3162 int depth = 0; 3206 int depth = 0;
3163 3207 vframeStream vfst(thread);
3164 for(vframeStream vfst(thread); !vfst.at_end(); vfst.security_get_caller_frame(1)) { 3208
3209 if (SystemDictionary::reflect_CallerSensitive_klass() != NULL) {
3210 // This must only be called from SecurityManager.getClassContext
3211 Method* m = vfst.method();
3212 if (!(m->method_holder() == SystemDictionary::SecurityManager_klass() &&
3213 m->name() == vmSymbols::getClassContext_name() &&
3214 m->signature() == vmSymbols::void_class_array_signature())) {
3215 THROW_MSG_NULL(vmSymbols::java_lang_InternalError(), "JVM_GetClassContext must only be called from SecurityManager.getClassContext");
3216 }
3217 }
3218
3219 // Collect method holders
3220 for (; !vfst.at_end(); vfst.security_next()) {
3221 Method* m = vfst.method();
3165 // Native frames are not returned 3222 // Native frames are not returned
3166 if (!vfst.method()->is_native()) { 3223 if (!m->is_ignored_by_security_stack_walk() && !m->is_native()) {
3167 Klass* holder = vfst.method()->method_holder(); 3224 Klass* holder = m->method_holder();
3168 assert(holder->is_klass(), "just checking"); 3225 assert(holder->is_klass(), "just checking");
3169 depth++; 3226 depth++;
3170 KlassLink* l = new KlassLink(KlassHandle(thread, holder)); 3227 KlassLink* l = new KlassLink(KlassHandle(thread, holder));
3171 if (first == NULL) { 3228 if (first == NULL) {
3172 first = last = l; 3229 first = last = l;