blob: 85debe4d3856a6b93ca0113ae22da736014144b5 [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
Brian Carlstromfa42b442013-06-17 12:53:45 -07002 * copyright (C) 2011 The Android Open Source Project
Elliott Hughes2faa5f12012-01-30 14:42:07 -08003 *
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 */
Carl Shapiro6b6b5f02011-06-21 15:05:09 -070016
Carl Shapiro2ed144c2011-07-26 16:52:08 -070017#include <signal.h>
Ian Rogersbd5ea6a2014-04-16 16:34:44 -070018#include <stdio.h>
Ian Rogers866ac802014-05-16 12:27:03 -070019#include <stdlib.h>
Ian Rogersbd5ea6a2014-04-16 16:34:44 -070020#include <string.h>
Kenny Root570c0092013-09-11 15:15:09 -070021#include <algorithm>
Ian Rogers700a4022014-05-19 16:49:03 -070022#include <memory>
Carl Shapiro7b216702011-06-17 15:09:26 -070023
Carl Shapiro2ed144c2011-07-26 16:52:08 -070024#include "jni.h"
Brian Carlstrom0eba6332013-06-19 15:08:24 -070025#include "JniInvocation.h"
Elliott Hugheseac76672012-05-24 21:56:51 -070026#include "ScopedLocalRef.h"
27#include "toStringArray.h"
Carl Shapiro2ed144c2011-07-26 16:52:08 -070028
Elliott Hughes11d1b0c2012-01-23 16:57:47 -080029namespace art {
30
Carl Shapiro2ed144c2011-07-26 16:52:08 -070031// Determine whether or not the specified method is public.
Elliott Hughese84278b2012-03-22 10:06:53 -070032static bool IsMethodPublic(JNIEnv* env, jclass c, jmethodID method_id) {
33 ScopedLocalRef<jobject> reflected(env, env->ToReflectedMethod(c, method_id, JNI_FALSE));
Mathieu Chartier2cebb242015-04-21 16:50:40 -070034 if (reflected.get() == nullptr) {
Brian Carlstrom3320cf42011-10-04 14:58:28 -070035 fprintf(stderr, "Failed to get reflected method\n");
Carl Shapiro2ed144c2011-07-26 16:52:08 -070036 return false;
37 }
38 // We now have a Method instance. We need to call its
39 // getModifiers() method.
Brian Carlstromfa42b442013-06-17 12:53:45 -070040 jclass method_class = env->FindClass("java/lang/reflect/Method");
Mathieu Chartier2cebb242015-04-21 16:50:40 -070041 if (method_class == nullptr) {
Brian Carlstromfa42b442013-06-17 12:53:45 -070042 fprintf(stderr, "Failed to find class java.lang.reflect.Method\n");
43 return false;
44 }
45 jmethodID mid = env->GetMethodID(method_class, "getModifiers", "()I");
Mathieu Chartier2cebb242015-04-21 16:50:40 -070046 if (mid == nullptr) {
Elliott Hugheseac76672012-05-24 21:56:51 -070047 fprintf(stderr, "Failed to find java.lang.reflect.Method.getModifiers\n");
Carl Shapiro2ed144c2011-07-26 16:52:08 -070048 return false;
49 }
Elliott Hugheseac76672012-05-24 21:56:51 -070050 int modifiers = env->CallIntMethod(reflected.get(), mid);
Brian Carlstromfa42b442013-06-17 12:53:45 -070051 static const int PUBLIC = 0x0001; // java.lang.reflect.Modifiers.PUBLIC
52 if ((modifiers & PUBLIC) == 0) {
Mathieu Chartierfc58af42015-04-16 18:00:39 -070053 fprintf(stderr, "Modifiers mismatch\n");
Carl Shapiro2ed144c2011-07-26 16:52:08 -070054 return false;
55 }
56 return true;
57}
58
Elliott Hughes1bac54f2012-03-16 12:48:31 -070059static int InvokeMain(JNIEnv* env, char** argv) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -070060 // We want to call main() with a String array with our arguments in
61 // it. Create an array and populate it. Note argv[0] is not
62 // included.
Elliott Hughes0a96fe02011-08-19 10:22:04 -070063 ScopedLocalRef<jobjectArray> args(env, toStringArray(env, argv + 1));
Mathieu Chartier2cebb242015-04-21 16:50:40 -070064 if (args.get() == nullptr) {
Elliott Hughesd6fe38d2011-10-02 11:14:43 -070065 env->ExceptionDescribe();
66 return EXIT_FAILURE;
Carl Shapiro2ed144c2011-07-26 16:52:08 -070067 }
68
69 // Find [class].main(String[]).
70
71 // Convert "com.android.Blah" to "com/android/Blah".
Elliott Hughese5b0dc82011-08-23 09:59:02 -070072 std::string class_name(argv[0]);
Carl Shapiro2ed144c2011-07-26 16:52:08 -070073 std::replace(class_name.begin(), class_name.end(), '.', '/');
74
Elliott Hughes0dab4ec2011-08-11 12:19:32 -070075 ScopedLocalRef<jclass> klass(env, env->FindClass(class_name.c_str()));
Mathieu Chartier2cebb242015-04-21 16:50:40 -070076 if (klass.get() == nullptr) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -070077 fprintf(stderr, "Unable to locate class '%s'\n", class_name.c_str());
Elliott Hughesd6fe38d2011-10-02 11:14:43 -070078 env->ExceptionDescribe();
79 return EXIT_FAILURE;
Carl Shapiro2ed144c2011-07-26 16:52:08 -070080 }
81
Elliott Hughesd6fe38d2011-10-02 11:14:43 -070082 jmethodID method = env->GetStaticMethodID(klass.get(), "main", "([Ljava/lang/String;)V");
Mathieu Chartier2cebb242015-04-21 16:50:40 -070083 if (method == nullptr) {
Elliott Hughesd6fe38d2011-10-02 11:14:43 -070084 fprintf(stderr, "Unable to find static main(String[]) in '%s'\n", class_name.c_str());
85 env->ExceptionDescribe();
86 return EXIT_FAILURE;
Carl Shapiro2ed144c2011-07-26 16:52:08 -070087 }
88
89 // Make sure the method is public. JNI doesn't prevent us from
90 // calling a private method, so we have to check it explicitly.
91 if (!IsMethodPublic(env, klass.get(), method)) {
Elliott Hughesd6fe38d2011-10-02 11:14:43 -070092 fprintf(stderr, "Sorry, main() is not public in '%s'\n", class_name.c_str());
93 env->ExceptionDescribe();
94 return EXIT_FAILURE;
Carl Shapiro2ed144c2011-07-26 16:52:08 -070095 }
96
97 // Invoke main().
Carl Shapiro2ed144c2011-07-26 16:52:08 -070098 env->CallStaticVoidMethod(klass.get(), method, args.get());
Elliott Hughes0c8c6732011-10-02 16:14:13 -070099
100 // Check whether there was an uncaught exception. We don't log any uncaught exception here;
101 // detaching this thread will do that for us, but it will clear the exception (and invalidate
102 // our JNIEnv), so we need to check here.
103 return env->ExceptionCheck() ? EXIT_FAILURE : EXIT_SUCCESS;
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700104}
105
Elliott Hughes81ff3182012-03-23 20:35:56 -0700106// Parse arguments. Most of it just gets passed through to the runtime.
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700107// The JNI spec defines a handful of standard arguments.
Brian Carlstromfa42b442013-06-17 12:53:45 -0700108static int dalvikvm(int argc, char** argv) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700109 setvbuf(stdout, nullptr, _IONBF, 0);
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700110
111 // Skip over argv[0].
112 argv++;
113 argc--;
114
115 // If we're adding any additional stuff, e.g. function hook specifiers,
116 // add them to the count here.
117 //
Elliott Hughes81ff3182012-03-23 20:35:56 -0700118 // We're over-allocating, because this includes the options to the runtime
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700119 // plus the options to the program.
120 int option_count = argc;
Ian Rogers700a4022014-05-19 16:49:03 -0700121 std::unique_ptr<JavaVMOption[]> options(new JavaVMOption[option_count]());
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700122
123 // Copy options over. Everything up to the name of the class starts
124 // with a '-' (the function hook stuff is strictly internal).
125 //
126 // [Do we need to catch & handle "-jar" here?]
127 bool need_extra = false;
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700128 const char* lib = nullptr;
129 const char* what = nullptr;
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700130 int curr_opt, arg_idx;
131 for (curr_opt = arg_idx = 0; arg_idx < argc; arg_idx++) {
132 if (argv[arg_idx][0] != '-' && !need_extra) {
133 break;
134 }
Brian Carlstromfa42b442013-06-17 12:53:45 -0700135 if (strncmp(argv[arg_idx], "-XXlib:", strlen("-XXlib:")) == 0) {
136 lib = argv[arg_idx] + strlen("-XXlib:");
137 continue;
138 }
139
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700140 options[curr_opt++].optionString = argv[arg_idx];
141
142 // Some options require an additional argument.
143 need_extra = false;
Elliott Hughesd6fe38d2011-10-02 11:14:43 -0700144 if (strcmp(argv[arg_idx], "-classpath") == 0 || strcmp(argv[arg_idx], "-cp") == 0) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700145 need_extra = true;
Elliott Hughes81ff3182012-03-23 20:35:56 -0700146 what = argv[arg_idx];
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700147 }
148 }
149
150 if (need_extra) {
Elliott Hughes81ff3182012-03-23 20:35:56 -0700151 fprintf(stderr, "%s must be followed by an additional argument giving a value\n", what);
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700152 return EXIT_FAILURE;
153 }
154
Brian Carlstrom686107e2014-02-25 23:08:33 -0800155 if (curr_opt > option_count) {
Piotr Jastrzebski2eebc992014-10-17 12:40:38 +0100156 fprintf(stderr, "curr_opt(%d) > option_count(%d)\n", curr_opt, option_count);
Brian Carlstromfa42b442013-06-17 12:53:45 -0700157 abort();
158 return EXIT_FAILURE;
159 }
160
161 // Find the JNI_CreateJavaVM implementation.
Brian Carlstrom0eba6332013-06-19 15:08:24 -0700162 JniInvocation jni_invocation;
163 if (!jni_invocation.Init(lib)) {
164 fprintf(stderr, "Failed to initialize JNI invocation API from %s\n", lib);
Brian Carlstromfa42b442013-06-17 12:53:45 -0700165 return EXIT_FAILURE;
166 }
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700167
168 JavaVMInitArgs init_args;
Elliott Hughesf2682d52011-08-15 16:37:04 -0700169 init_args.version = JNI_VERSION_1_6;
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700170 init_args.options = options.get();
171 init_args.nOptions = curr_opt;
172 init_args.ignoreUnrecognized = JNI_FALSE;
173
Elliott Hughes81ff3182012-03-23 20:35:56 -0700174 // Start the runtime. The current thread becomes the main thread.
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700175 JavaVM* vm = nullptr;
176 JNIEnv* env = nullptr;
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700177 if (JNI_CreateJavaVM(&vm, &env, &init_args) != JNI_OK) {
Brian Carlstromfa42b442013-06-17 12:53:45 -0700178 fprintf(stderr, "Failed to initialize runtime (check log for details)\n");
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700179 return EXIT_FAILURE;
180 }
181
Brian Carlstrom686107e2014-02-25 23:08:33 -0800182 // Make sure they provided a class name. We do this after
183 // JNI_CreateJavaVM so that things like "-help" have the opportunity
184 // to emit a usage statement.
185 if (arg_idx == argc) {
186 fprintf(stderr, "Class name required\n");
187 return EXIT_FAILURE;
188 }
189
Elliott Hughes1bac54f2012-03-16 12:48:31 -0700190 int rc = InvokeMain(env, &argv[arg_idx]);
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700191
Elliott Hughes17057b12012-04-03 10:22:39 -0700192#if defined(NDEBUG)
193 // The DestroyJavaVM call will detach this thread for us. In debug builds, we don't want to
194 // detach because detaching disables the CheckSafeToLockOrUnlock checking.
Elliott Hughesf2682d52011-08-15 16:37:04 -0700195 if (vm->DetachCurrentThread() != JNI_OK) {
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700196 fprintf(stderr, "Warning: unable to detach main thread\n");
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700197 rc = EXIT_FAILURE;
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700198 }
Elliott Hughes17057b12012-04-03 10:22:39 -0700199#endif
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700200
Elliott Hughesf2682d52011-08-15 16:37:04 -0700201 if (vm->DestroyJavaVM() != 0) {
Elliott Hughes81ff3182012-03-23 20:35:56 -0700202 fprintf(stderr, "Warning: runtime did not shut down cleanly\n");
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700203 rc = EXIT_FAILURE;
Carl Shapiro2ed144c2011-07-26 16:52:08 -0700204 }
205
Elliott Hughesc1674ed2011-08-25 18:09:09 -0700206 return rc;
Carl Shapiro7b216702011-06-17 15:09:26 -0700207}
Elliott Hughes11d1b0c2012-01-23 16:57:47 -0800208
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700209} // namespace art
Elliott Hughes11d1b0c2012-01-23 16:57:47 -0800210
211int main(int argc, char** argv) {
Brian Carlstromfa42b442013-06-17 12:53:45 -0700212 return art::dalvikvm(argc, argv);
Elliott Hughes11d1b0c2012-01-23 16:57:47 -0800213}