1 /*
2 * Copyright (c) 2014, 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #include "JavaVirtualMachine.h"
27 #include "Platform.h"
28 #include "PlatformString.h"
29 #include "FilePath.h"
30 #include "Package.h"
31 #include "Helpers.h"
32 #include "Messages.h"
33 #include "Macros.h"
34
35 #include "jni.h"
36
37 #include <map>
38 #include <list>
39 #include <sstream>
40
41
42 bool RunVM() {
43 JavaVirtualMachine javavm;
44
45 bool result = javavm.StartJVM();
46
47 if (!result) {
48 Platform& platform = Platform::GetInstance();
49 platform.ShowMessage(_T("Failed to launch JVM\n"));
50 }
51
52 return result;
53 }
54
55 //----------------------------------------------------------------------------
56
57 JavaOptions::JavaOptions(): FOptions(NULL) {
58 }
59
60 JavaOptions::~JavaOptions() {
61 if (FOptions != NULL) {
62 for (unsigned int index = 0; index < GetCount(); index++) {
63 delete[] FOptions[index].optionString;
64 }
65
66 delete[] FOptions;
67 }
68 }
69
70 void JavaOptions::AppendValue(const TString Key, TString Value, void* Extra) {
71 JavaOptionItem item;
72 item.name = Key;
73 item.value = Value;
74 item.extraInfo = Extra;
75 FItems.push_back(item);
76 }
77
78 void JavaOptions::AppendValue(const TString Key, TString Value) {
79 AppendValue(Key, Value, NULL);
80 }
81
82 void JavaOptions::AppendValue(const TString Key) {
83 AppendValue(Key, _T(""), NULL);
84 }
85
86 void JavaOptions::AppendValues(OrderedMap<TString, TString> Values) {
87 if (Values.GetAllowDuplicates()) {
88 for (int i = 0; i < (int)Values.Count(); i++) {
89 TString name, value;
90
91 bool bResult = Values.GetKey(i, name);
92 bResult &= Values.GetValue(i, value);
93
94 if (bResult) {
95 AppendValue(name, value);
96 }
97 }
98 } else { // In case we asked to add values from OrderedMap with allow
99 // duplicates set to false. Not used now, but should avoid possible
100 // bugs.
101 std::vector<TString> orderedKeys = Values.GetKeys();
102
103 for (std::vector<TString>::const_iterator iterator = orderedKeys.begin();
104 iterator != orderedKeys.end(); iterator++) {
105 TString name = *iterator;
106 TString value;
107
108 if (Values.GetValue(name, value) == true) {
109 AppendValue(name, value);
110 }
111 }
112 }
113 }
114
115 void JavaOptions::ReplaceValue(const TString Key, TString Value) {
116 for (std::list<JavaOptionItem>::iterator iterator = FItems.begin();
117 iterator != FItems.end(); iterator++) {
118
119 TString lkey = iterator->name;
120
121 if (lkey == Key) {
122 JavaOptionItem item = *iterator;
123 item.value = Value;
124 iterator = FItems.erase(iterator);
125 FItems.insert(iterator, item);
126 break;
127 }
128 }
129 }
130
131 std::list<TString> JavaOptions::ToList() {
132 std::list<TString> result;
133 Macros& macros = Macros::GetInstance();
134
135 for (std::list<JavaOptionItem>::const_iterator iterator = FItems.begin();
136 iterator != FItems.end(); iterator++) {
137 TString key = iterator->name;
138 TString value = iterator->value;
139 TString option = Helpers::NameValueToString(key, value);
140 option = macros.ExpandMacros(option);
141 result.push_back(option);
142 }
143
144 return result;
145 }
146
147 size_t JavaOptions::GetCount() {
148 return FItems.size();
149 }
150
151 //----------------------------------------------------------------------------
152
153 JavaVirtualMachine::JavaVirtualMachine() {
154 }
155
156 JavaVirtualMachine::~JavaVirtualMachine(void) {
157 }
158
159 bool JavaVirtualMachine::StartJVM() {
160 Platform& platform = Platform::GetInstance();
161 Package& package = Package::GetInstance();
162
163 TString classpath = package.GetClassPath();
164 TString modulepath = package.GetModulePath();
165 JavaOptions options;
166
167 if (modulepath.empty() == false) {
168 options.AppendValue(_T("-Djava.module.path"), modulepath);
169 }
170
171 options.AppendValue(_T("-Djava.library.path"),
172 package.GetPackageAppDirectory() + FilePath::PathSeparator()
173 + package.GetPackageLauncherDirectory());
174 options.AppendValue(
175 _T("-Djava.launcher.path"), package.GetPackageLauncherDirectory());
176 options.AppendValues(package.GetJavaOptions());
177
178 #ifdef DEBUG
179 if (package.Debugging() == dsJava) {
180 options.AppendValue(_T("-Xdebug"), _T(""));
181 options.AppendValue(
182 _T("-Xrunjdwp:transport=dt_socket,server=y,suspend=y,address=localhost:5005"),
183 _T(""));
184 platform.ShowMessage(_T("localhost:5005"));
185 }
186 #endif // DEBUG
187
188 TString maxHeapSizeOption;
189 TString minHeapSizeOption;
190
191
192 if (package.GetMemoryState() == PackageBootFields::msAuto) {
193 TPlatformNumber memorySize = package.GetMemorySize();
194 TString memory =
195 PlatformString((size_t)memorySize).toString() + _T("m");
196 maxHeapSizeOption = TString(_T("-Xmx")) + memory;
197 options.AppendValue(maxHeapSizeOption, _T(""));
198
199 if (memorySize > 256)
200 minHeapSizeOption = _T("-Xms256m");
201 else
202 minHeapSizeOption = _T("-Xms") + memory;
203
204 options.AppendValue(minHeapSizeOption, _T(""));
205 }
206
207 TString mainClassName = package.GetMainClassName();
208 TString mainModule = package.GetMainModule();
209
210 if (mainClassName.empty() == true && mainModule.empty() == true) {
211 Messages& messages = Messages::GetInstance();
212 platform.ShowMessage(messages.GetMessage(NO_MAIN_CLASS_SPECIFIED));
213 return false;
214 }
215
216 configureLibrary();
217
218 // Initialize the arguments to JLI_Launch()
219 //
220 // On Mac OS X JLI_Launch spawns a new thread that actually starts the JVM.
221 // This new thread simply re-runs main(argc, argv). Therefore we do not
222 // want to add new args if we are still in the original main thread so we
223 // will treat them as command line args provided by the user ...
224 // Only propagate original set of args first time.
225
226 options.AppendValue(_T("-classpath"));
227 options.AppendValue(classpath);
228
229 std::list<TString> vmargs;
230 vmargs.push_back(package.GetCommandName());
231
232 if (package.HasSplashScreen() == true) {
233 options.AppendValue(TString(_T("-splash:"))
234 + package.GetSplashScreenFileName(), _T(""));
235 }
236
237 if (mainModule.empty() == true) {
238 options.AppendValue(Helpers::ConvertJavaPathToId(mainClassName),
239 _T(""));
240 } else {
241 options.AppendValue(_T("-m"));
242 options.AppendValue(mainModule);
243 }
244
245 return launchVM(options, vmargs);
246 }
247
248 void JavaVirtualMachine::configureLibrary() {
249 Platform& platform = Platform::GetInstance();
250 Package& package = Package::GetInstance();
251 TString libName = package.GetJavaLibraryFileName();
252 platform.addPlatformDependencies(&javaLibrary);
253 javaLibrary.Load(libName);
254 }
255
256 bool JavaVirtualMachine::launchVM(JavaOptions& options,
257 std::list<TString>& vmargs) {
258 Platform& platform = Platform::GetInstance();
259 Package& package = Package::GetInstance();
260
261 #ifdef MAC
262 // Mac adds a ProcessSerialNumber to args when launched from .app
263 // filter out the psn since they it's not expected in the app
264 if (platform.IsMainThread() == false) {
265 std::list<TString> loptions = options.ToList();
266 vmargs.splice(vmargs.end(), loptions,
267 loptions.begin(), loptions.end());
268 }
269 #else
270 std::list<TString> loptions = options.ToList();
271 vmargs.splice(vmargs.end(), loptions, loptions.begin(), loptions.end());
272 #endif
273
274 std::list<TString> largs = package.GetArgs();
275 vmargs.splice(vmargs.end(), largs, largs.begin(), largs.end());
276
277 size_t argc = vmargs.size();
278 DynamicBuffer<char*> argv(argc + 1);
279 if (argv.GetData() == NULL) {
280 return false;
281 }
282
283 unsigned int index = 0;
284 for (std::list<TString>::const_iterator iterator = vmargs.begin();
285 iterator != vmargs.end(); iterator++) {
286 TString item = *iterator;
287 std::string arg = PlatformString(item).toStdString();
288 #ifdef DEBUG
289 printf("%i %s\n", index, arg.c_str());
290 #endif // DEBUG
291 argv[index] = PlatformString::duplicate(arg.c_str());
292 index++;
293 }
294
295 argv[argc] = NULL;
296
297 // On Mac we can only free the boot fields if the calling thread is
298 // not the main thread.
299 #ifdef MAC
300 if (platform.IsMainThread() == false) {
301 package.FreeBootFields();
302 }
303 #else
304 package.FreeBootFields();
305 #endif // MAC
306
307 if (javaLibrary.JavaVMCreate(argc, argv.GetData()) == true) {
308 return true;
309 }
310
311 for (index = 0; index < argc; index++) {
312 if (argv[index] != NULL) {
313 delete[] argv[index];
314 }
315 }
316
317 return false;
318 }