Home | History | Annotate | Download | only in dalvikvm
      1 /*
      2  * copyright (C) 2011 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #include <signal.h>
     18 
     19 #include <cstdio>
     20 #include <cstring>
     21 #include <string>
     22 
     23 #include "jni.h"
     24 #include "JniInvocation.h"
     25 #include "ScopedLocalRef.h"
     26 #include "toStringArray.h"
     27 #include "UniquePtr.h"
     28 
     29 namespace art {
     30 
     31 // Determine whether or not the specified method is public.
     32 static bool IsMethodPublic(JNIEnv* env, jclass c, jmethodID method_id) {
     33   ScopedLocalRef<jobject> reflected(env, env->ToReflectedMethod(c, method_id, JNI_FALSE));
     34   if (reflected.get() == NULL) {
     35     fprintf(stderr, "Failed to get reflected method\n");
     36     return false;
     37   }
     38   // We now have a Method instance.  We need to call its
     39   // getModifiers() method.
     40   jclass method_class = env->FindClass("java/lang/reflect/Method");
     41   if (method_class == NULL) {
     42     fprintf(stderr, "Failed to find class java.lang.reflect.Method\n");
     43     return false;
     44   }
     45   jmethodID mid = env->GetMethodID(method_class, "getModifiers", "()I");
     46   if (mid == NULL) {
     47     fprintf(stderr, "Failed to find java.lang.reflect.Method.getModifiers\n");
     48     return false;
     49   }
     50   int modifiers = env->CallIntMethod(reflected.get(), mid);
     51   static const int PUBLIC = 0x0001;  // java.lang.reflect.Modifiers.PUBLIC
     52   if ((modifiers & PUBLIC) == 0) {
     53     return false;
     54   }
     55   return true;
     56 }
     57 
     58 static int InvokeMain(JNIEnv* env, char** argv) {
     59   // We want to call main() with a String array with our arguments in
     60   // it.  Create an array and populate it.  Note argv[0] is not
     61   // included.
     62   ScopedLocalRef<jobjectArray> args(env, toStringArray(env, argv + 1));
     63   if (args.get() == NULL) {
     64     env->ExceptionDescribe();
     65     return EXIT_FAILURE;
     66   }
     67 
     68   // Find [class].main(String[]).
     69 
     70   // Convert "com.android.Blah" to "com/android/Blah".
     71   std::string class_name(argv[0]);
     72   std::replace(class_name.begin(), class_name.end(), '.', '/');
     73 
     74   ScopedLocalRef<jclass> klass(env, env->FindClass(class_name.c_str()));
     75   if (klass.get() == NULL) {
     76     fprintf(stderr, "Unable to locate class '%s'\n", class_name.c_str());
     77     env->ExceptionDescribe();
     78     return EXIT_FAILURE;
     79   }
     80 
     81   jmethodID method = env->GetStaticMethodID(klass.get(), "main", "([Ljava/lang/String;)V");
     82   if (method == NULL) {
     83     fprintf(stderr, "Unable to find static main(String[]) in '%s'\n", class_name.c_str());
     84     env->ExceptionDescribe();
     85     return EXIT_FAILURE;
     86   }
     87 
     88   // Make sure the method is public.  JNI doesn't prevent us from
     89   // calling a private method, so we have to check it explicitly.
     90   if (!IsMethodPublic(env, klass.get(), method)) {
     91     fprintf(stderr, "Sorry, main() is not public in '%s'\n", class_name.c_str());
     92     env->ExceptionDescribe();
     93     return EXIT_FAILURE;
     94   }
     95 
     96   // Invoke main().
     97   env->CallStaticVoidMethod(klass.get(), method, args.get());
     98 
     99   // Check whether there was an uncaught exception. We don't log any uncaught exception here;
    100   // detaching this thread will do that for us, but it will clear the exception (and invalidate
    101   // our JNIEnv), so we need to check here.
    102   return env->ExceptionCheck() ? EXIT_FAILURE : EXIT_SUCCESS;
    103 }
    104 
    105 // Parse arguments.  Most of it just gets passed through to the runtime.
    106 // The JNI spec defines a handful of standard arguments.
    107 static int dalvikvm(int argc, char** argv) {
    108   setvbuf(stdout, NULL, _IONBF, 0);
    109 
    110   // Skip over argv[0].
    111   argv++;
    112   argc--;
    113 
    114   // If we're adding any additional stuff, e.g. function hook specifiers,
    115   // add them to the count here.
    116   //
    117   // We're over-allocating, because this includes the options to the runtime
    118   // plus the options to the program.
    119   int option_count = argc;
    120   UniquePtr<JavaVMOption[]> options(new JavaVMOption[option_count]());
    121 
    122   // Copy options over.  Everything up to the name of the class starts
    123   // with a '-' (the function hook stuff is strictly internal).
    124   //
    125   // [Do we need to catch & handle "-jar" here?]
    126   bool need_extra = false;
    127   const char* lib = NULL;
    128   const char* what = NULL;
    129   int curr_opt, arg_idx;
    130   for (curr_opt = arg_idx = 0; arg_idx < argc; arg_idx++) {
    131     if (argv[arg_idx][0] != '-' && !need_extra) {
    132       break;
    133     }
    134     if (strncmp(argv[arg_idx], "-XXlib:", strlen("-XXlib:")) == 0) {
    135       lib = argv[arg_idx] + strlen("-XXlib:");
    136       continue;
    137     }
    138 
    139     options[curr_opt++].optionString = argv[arg_idx];
    140 
    141     // Some options require an additional argument.
    142     need_extra = false;
    143     if (strcmp(argv[arg_idx], "-classpath") == 0 || strcmp(argv[arg_idx], "-cp") == 0) {
    144       need_extra = true;
    145       what = argv[arg_idx];
    146     }
    147   }
    148 
    149   if (need_extra) {
    150     fprintf(stderr, "%s must be followed by an additional argument giving a value\n", what);
    151     return EXIT_FAILURE;
    152   }
    153 
    154   // Make sure they provided a class name.
    155   if (arg_idx == argc) {
    156     fprintf(stderr, "Class name required\n");
    157     return EXIT_FAILURE;
    158   }
    159 
    160   // insert additional internal options here
    161 
    162   if (curr_opt >= option_count) {
    163     fprintf(stderr, "curr_opt(%d) >= option_count(%d)\n", curr_opt, option_count);
    164     abort();
    165     return EXIT_FAILURE;
    166   }
    167 
    168   // Find the JNI_CreateJavaVM implementation.
    169   JniInvocation jni_invocation;
    170   if (!jni_invocation.Init(lib)) {
    171     fprintf(stderr, "Failed to initialize JNI invocation API from %s\n", lib);
    172     return EXIT_FAILURE;
    173   }
    174 
    175   JavaVMInitArgs init_args;
    176   init_args.version = JNI_VERSION_1_6;
    177   init_args.options = options.get();
    178   init_args.nOptions = curr_opt;
    179   init_args.ignoreUnrecognized = JNI_FALSE;
    180 
    181   // Start the runtime. The current thread becomes the main thread.
    182   JavaVM* vm = NULL;
    183   JNIEnv* env = NULL;
    184   if (JNI_CreateJavaVM(&vm, &env, &init_args) != JNI_OK) {
    185     fprintf(stderr, "Failed to initialize runtime (check log for details)\n");
    186     return EXIT_FAILURE;
    187   }
    188 
    189   int rc = InvokeMain(env, &argv[arg_idx]);
    190 
    191 #if defined(NDEBUG)
    192   // The DestroyJavaVM call will detach this thread for us. In debug builds, we don't want to
    193   // detach because detaching disables the CheckSafeToLockOrUnlock checking.
    194   if (vm->DetachCurrentThread() != JNI_OK) {
    195     fprintf(stderr, "Warning: unable to detach main thread\n");
    196     rc = EXIT_FAILURE;
    197   }
    198 #endif
    199 
    200   if (vm->DestroyJavaVM() != 0) {
    201     fprintf(stderr, "Warning: runtime did not shut down cleanly\n");
    202     rc = EXIT_FAILURE;
    203   }
    204 
    205   return rc;
    206 }
    207 
    208 }  // namespace art
    209 
    210 int main(int argc, char** argv) {
    211   return art::dalvikvm(argc, argv);
    212 }
    213