Home | History | Annotate | Download | only in openjdkjvm 
      1 /* Copyright (C) 2014 The Android Open Source Project
      2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
      3  *
      4  * This file implements interfaces from the file jvm.h. This implementation
      5  * is licensed under the same terms as the file jvm.h.  The
      6  * copyright and license information for the file jvm.h follows.
      7  *
      8  * Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
      9  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
     10  *
     11  * This code is free software; you can redistribute it and/or modify it
     12  * under the terms of the GNU General Public License version 2 only, as
     13  * published by the Free Software Foundation.  Oracle designates this
     14  * particular file as subject to the "Classpath" exception as provided
     15  * by Oracle in the LICENSE file that accompanied this code.
     16  *
     17  * This code is distributed in the hope that it will be useful, but WITHOUT
     18  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
     19  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
     20  * version 2 for more details (a copy is included in the LICENSE file that
     21  * accompanied this code).
     22  *
     23  * You should have received a copy of the GNU General Public License version
     24  * 2 along with this work; if not, write to the Free Software Foundation,
     25  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
     26  *
     27  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
     28  * or visit www.oracle.com if you need additional information or have any
     29  * questions.
     30  */
     31 
     32 /*
     33  * Services that OpenJDK expects the VM to provide.
     34  */
     35 #include <dlfcn.h>
     36 #include <limits.h>
     37 #include <stdio.h>
     38 #include <sys/ioctl.h>
     39 #include <sys/socket.h>
     40 #include <sys/time.h>
     41 #include <unistd.h>
     42 
     43 #include <android-base/logging.h>
     44 
     45 #include "../../libcore/ojluni/src/main/native/jvm.h"  // TODO(narayan): fix it
     46 
     47 #include "base/macros.h"
     48 #include "common_throws.h"
     49 #include "gc/heap.h"
     50 #include "handle_scope-inl.h"
     51 #include "jni/java_vm_ext.h"
     52 #include "jni/jni_internal.h"
     53 #include "mirror/class_loader.h"
     54 #include "mirror/string-inl.h"
     55 #include "monitor.h"
     56 #include "native/scoped_fast_native_object_access-inl.h"
     57 #include "nativehelper/scoped_local_ref.h"
     58 #include "nativehelper/scoped_utf_chars.h"
     59 #include "runtime.h"
     60 #include "scoped_thread_state_change-inl.h"
     61 #include "thread.h"
     62 #include "thread_list.h"
     63 #include "verify_object.h"
     64 
     65 #undef LOG_TAG
     66 #define LOG_TAG "artopenjdk"
     67 
     68 /* posix open() with extensions; used by e.g. ZipFile */
     69 JNIEXPORT jint JVM_Open(const char* fname, jint flags, jint mode) {
     70     /*
     71      * Some code seems to want the special return value JVM_EEXIST if the
     72      * file open fails due to O_EXCL.
     73      */
     74     // Don't use JVM_O_DELETE, it's problematic with FUSE, see b/28901232.
     75     if (flags & JVM_O_DELETE) {
     76         LOG(FATAL) << "JVM_O_DELETE option is not supported (while opening: '"
     77                    << fname << "')";
     78     }
     79 
     80     flags |= O_CLOEXEC;
     81     int fd = TEMP_FAILURE_RETRY(open(fname, flags & ~JVM_O_DELETE, mode));
     82     if (fd < 0) {
     83         int err = errno;
     84         if (err == EEXIST) {
     85             return JVM_EEXIST;
     86         } else {
     87             return -1;
     88         }
     89     }
     90 
     91     return fd;
     92 }
     93 
     94 /* posix close() */
     95 JNIEXPORT jint JVM_Close(jint fd) {
     96     // don't want TEMP_FAILURE_RETRY here -- file is closed even if EINTR
     97     return close(fd);
     98 }
     99 
    100 /* posix read() */
    101 JNIEXPORT jint JVM_Read(jint fd, char* buf, jint nbytes) {
    102     return TEMP_FAILURE_RETRY(read(fd, buf, nbytes));
    103 }
    104 
    105 /* posix write(); is used to write messages to stderr */
    106 JNIEXPORT jint JVM_Write(jint fd, char* buf, jint nbytes) {
    107     return TEMP_FAILURE_RETRY(write(fd, buf, nbytes));
    108 }
    109 
    110 /* posix lseek() */
    111 JNIEXPORT jlong JVM_Lseek(jint fd, jlong offset, jint whence) {
    112 #if !defined(__APPLE__)
    113     // NOTE: Using TEMP_FAILURE_RETRY here is busted for LP32 on glibc - the return
    114     // value will be coerced into an int32_t.
    115     //
    116     // lseek64 isn't specified to return EINTR so it shouldn't be necessary
    117     // anyway.
    118     return lseek64(fd, offset, whence);
    119 #else
    120     // NOTE: This code is compiled for Mac OS but isn't ever run on that
    121     // platform.
    122     return lseek(fd, offset, whence);
    123 #endif
    124 }
    125 
    126 /*
    127  * "raw monitors" seem to be expected to behave like non-recursive pthread
    128  * mutexes.  They're used by ZipFile.
    129  */
    130 JNIEXPORT void* JVM_RawMonitorCreate(void) {
    131     pthread_mutex_t* mutex =
    132         reinterpret_cast<pthread_mutex_t*>(malloc(sizeof(pthread_mutex_t)));
    133     CHECK(mutex != nullptr);
    134     CHECK_PTHREAD_CALL(pthread_mutex_init, (mutex, nullptr), "JVM_RawMonitorCreate");
    135     return mutex;
    136 }
    137 
    138 JNIEXPORT void JVM_RawMonitorDestroy(void* mon) {
    139     CHECK_PTHREAD_CALL(pthread_mutex_destroy,
    140                        (reinterpret_cast<pthread_mutex_t*>(mon)),
    141                        "JVM_RawMonitorDestroy");
    142     free(mon);
    143 }
    144 
    145 JNIEXPORT jint JVM_RawMonitorEnter(void* mon) {
    146     return pthread_mutex_lock(reinterpret_cast<pthread_mutex_t*>(mon));
    147 }
    148 
    149 JNIEXPORT void JVM_RawMonitorExit(void* mon) {
    150     CHECK_PTHREAD_CALL(pthread_mutex_unlock,
    151                        (reinterpret_cast<pthread_mutex_t*>(mon)),
    152                        "JVM_RawMonitorExit");
    153 }
    154 
    155 JNIEXPORT char* JVM_NativePath(char* path) {
    156     return path;
    157 }
    158 
    159 JNIEXPORT jint JVM_GetLastErrorString(char* buf, int len) {
    160 #if defined(__GLIBC__) || defined(__BIONIC__)
    161   if (len == 0) {
    162     return 0;
    163   }
    164 
    165   const int err = errno;
    166   char* result = strerror_r(err, buf, len);
    167   if (result != buf) {
    168     strncpy(buf, result, len);
    169     buf[len - 1] = '\0';
    170   }
    171 
    172   return strlen(buf);
    173 #else
    174   UNUSED(buf);
    175   UNUSED(len);
    176   return -1;
    177 #endif
    178 }
    179 
    180 JNIEXPORT int jio_fprintf(FILE* fp, const char* fmt, ...) {
    181     va_list args;
    182 
    183     va_start(args, fmt);
    184     int len = jio_vfprintf(fp, fmt, args);
    185     va_end(args);
    186 
    187     return len;
    188 }
    189 
    190 JNIEXPORT int jio_vfprintf(FILE* fp, const char* fmt, va_list args) {
    191     assert(fp != nullptr);
    192     return vfprintf(fp, fmt, args);
    193 }
    194 
    195 /* posix fsync() */
    196 JNIEXPORT jint JVM_Sync(jint fd) {
    197     return TEMP_FAILURE_RETRY(fsync(fd));
    198 }
    199 
    200 JNIEXPORT void* JVM_FindLibraryEntry(void* handle, const char* name) {
    201     return dlsym(handle, name);
    202 }
    203 
    204 JNIEXPORT jlong JVM_CurrentTimeMillis(JNIEnv* env ATTRIBUTE_UNUSED,
    205                                       jclass clazz ATTRIBUTE_UNUSED) {
    206     struct timeval tv;
    207     gettimeofday(&tv, (struct timezone *) nullptr);
    208     jlong when = tv.tv_sec * 1000LL + tv.tv_usec / 1000;
    209     return when;
    210 }
    211 
    212 JNIEXPORT jint JVM_Socket(jint domain, jint type, jint protocol) {
    213     return TEMP_FAILURE_RETRY(socket(domain, type, protocol));
    214 }
    215 
    216 JNIEXPORT jint JVM_InitializeSocketLibrary() {
    217   return 0;
    218 }
    219 
    220 int jio_vsnprintf(char *str, size_t count, const char *fmt, va_list args) {
    221   if ((intptr_t)count <= 0) return -1;
    222   return vsnprintf(str, count, fmt, args);
    223 }
    224 
    225 int jio_snprintf(char *str, size_t count, const char *fmt, ...) {
    226   va_list args;
    227   int len;
    228   va_start(args, fmt);
    229   len = jio_vsnprintf(str, count, fmt, args);
    230   va_end(args);
    231   return len;
    232 }
    233 
    234 JNIEXPORT jint JVM_SetSockOpt(jint fd, int level, int optname,
    235     const char* optval, int optlen) {
    236   return TEMP_FAILURE_RETRY(setsockopt(fd, level, optname, optval, optlen));
    237 }
    238 
    239 JNIEXPORT jint JVM_SocketShutdown(jint fd, jint howto) {
    240   return TEMP_FAILURE_RETRY(shutdown(fd, howto));
    241 }
    242 
    243 JNIEXPORT jint JVM_GetSockOpt(jint fd, int level, int optname, char* optval,
    244   int* optlen) {
    245   socklen_t len = *optlen;
    246   int cc = TEMP_FAILURE_RETRY(getsockopt(fd, level, optname, optval, &len));
    247   *optlen = len;
    248   return cc;
    249 }
    250 
    251 JNIEXPORT jint JVM_GetSockName(jint fd, struct sockaddr* addr, int* addrlen) {
    252   socklen_t len = *addrlen;
    253   int cc = TEMP_FAILURE_RETRY(getsockname(fd, addr, &len));
    254   *addrlen = len;
    255   return cc;
    256 }
    257 
    258 JNIEXPORT jint JVM_SocketAvailable(jint fd, jint* result) {
    259   if (TEMP_FAILURE_RETRY(ioctl(fd, FIONREAD, result)) < 0) {
    260       return JNI_FALSE;
    261   }
    262 
    263   return JNI_TRUE;
    264 }
    265 
    266 JNIEXPORT jint JVM_Send(jint fd, char* buf, jint nBytes, jint flags) {
    267   return TEMP_FAILURE_RETRY(send(fd, buf, nBytes, flags));
    268 }
    269 
    270 JNIEXPORT jint JVM_SocketClose(jint fd) {
    271   // Don't want TEMP_FAILURE_RETRY here -- file is closed even if EINTR.
    272   return close(fd);
    273 }
    274 
    275 JNIEXPORT jint JVM_Listen(jint fd, jint count) {
    276   return TEMP_FAILURE_RETRY(listen(fd, count));
    277 }
    278 
    279 JNIEXPORT jint JVM_Connect(jint fd, struct sockaddr* addr, jint addrlen) {
    280   return TEMP_FAILURE_RETRY(connect(fd, addr, addrlen));
    281 }
    282 
    283 JNIEXPORT int JVM_GetHostName(char* name, int namelen) {
    284   return TEMP_FAILURE_RETRY(gethostname(name, namelen));
    285 }
    286 
    287 JNIEXPORT jstring JVM_InternString(JNIEnv* env, jstring jstr) {
    288   art::ScopedFastNativeObjectAccess soa(env);
    289   art::ObjPtr<art::mirror::String> s = soa.Decode<art::mirror::String>(jstr);
    290   return soa.AddLocalReference<jstring>(s->Intern());
    291 }
    292 
    293 JNIEXPORT jlong JVM_FreeMemory(void) {
    294   return art::Runtime::Current()->GetHeap()->GetFreeMemory();
    295 }
    296 
    297 JNIEXPORT jlong JVM_TotalMemory(void) {
    298   return art::Runtime::Current()->GetHeap()->GetTotalMemory();
    299 }
    300 
    301 JNIEXPORT jlong JVM_MaxMemory(void) {
    302   return art::Runtime::Current()->GetHeap()->GetMaxMemory();
    303 }
    304 
    305 JNIEXPORT void JVM_GC(void) {
    306   if (art::Runtime::Current()->IsExplicitGcDisabled()) {
    307       LOG(INFO) << "Explicit GC skipped.";
    308       return;
    309   }
    310   art::Runtime::Current()->GetHeap()->CollectGarbage(/* clear_soft_references */ false);
    311 }
    312 
    313 JNIEXPORT __attribute__((noreturn)) void JVM_Exit(jint status) {
    314   LOG(INFO) << "System.exit called, status: " << status;
    315   art::Runtime::Current()->CallExitHook(status);
    316   exit(status);
    317 }
    318 
    319 JNIEXPORT jstring JVM_NativeLoad(JNIEnv* env,
    320                                  jstring javaFilename,
    321                                  jobject javaLoader,
    322                                  jclass caller) {
    323   ScopedUtfChars filename(env, javaFilename);
    324   if (filename.c_str() == nullptr) {
    325     return nullptr;
    326   }
    327 
    328   std::string error_msg;
    329   {
    330     art::JavaVMExt* vm = art::Runtime::Current()->GetJavaVM();
    331     bool success = vm->LoadNativeLibrary(env,
    332                                          filename.c_str(),
    333                                          javaLoader,
    334                                          caller,
    335                                          &error_msg);
    336     if (success) {
    337       return nullptr;
    338     }
    339   }
    340 
    341   // Don't let a pending exception from JNI_OnLoad cause a CheckJNI issue with NewStringUTF.
    342   env->ExceptionClear();
    343   return env->NewStringUTF(error_msg.c_str());
    344 }
    345 
    346 JNIEXPORT void JVM_StartThread(JNIEnv* env, jobject jthread, jlong stack_size, jboolean daemon) {
    347   art::Thread::CreateNativeThread(env, jthread, stack_size, daemon == JNI_TRUE);
    348 }
    349 
    350 JNIEXPORT void JVM_SetThreadPriority(JNIEnv* env, jobject jthread, jint prio) {
    351   art::ScopedObjectAccess soa(env);
    352   art::MutexLock mu(soa.Self(), *art::Locks::thread_list_lock_);
    353   art::Thread* thread = art::Thread::FromManagedThread(soa, jthread);
    354   if (thread != nullptr) {
    355     thread->SetNativePriority(prio);
    356   }
    357 }
    358 
    359 JNIEXPORT void JVM_Yield(JNIEnv* env ATTRIBUTE_UNUSED, jclass threadClass ATTRIBUTE_UNUSED) {
    360   sched_yield();
    361 }
    362 
    363 JNIEXPORT void JVM_Sleep(JNIEnv* env, jclass threadClass ATTRIBUTE_UNUSED,
    364                          jobject java_lock, jlong millis) {
    365   art::ScopedFastNativeObjectAccess soa(env);
    366   art::ObjPtr<art::mirror::Object> lock = soa.Decode<art::mirror::Object>(java_lock);
    367   art::Monitor::Wait(art::Thread::Current(), lock.Ptr(), millis, 0, true, art::kSleeping);
    368 }
    369 
    370 JNIEXPORT jobject JVM_CurrentThread(JNIEnv* env, jclass unused ATTRIBUTE_UNUSED) {
    371   art::ScopedFastNativeObjectAccess soa(env);
    372   return soa.AddLocalReference<jobject>(soa.Self()->GetPeer());
    373 }
    374 
    375 JNIEXPORT void JVM_Interrupt(JNIEnv* env, jobject jthread) {
    376   art::ScopedFastNativeObjectAccess soa(env);
    377   art::MutexLock mu(soa.Self(), *art::Locks::thread_list_lock_);
    378   art::Thread* thread = art::Thread::FromManagedThread(soa, jthread);
    379   if (thread != nullptr) {
    380     thread->Interrupt(soa.Self());
    381   }
    382 }
    383 
    384 JNIEXPORT jboolean JVM_IsInterrupted(JNIEnv* env, jobject jthread, jboolean clearInterrupted) {
    385   if (clearInterrupted) {
    386     return static_cast<art::JNIEnvExt*>(env)->GetSelf()->Interrupted() ? JNI_TRUE : JNI_FALSE;
    387   } else {
    388     art::ScopedFastNativeObjectAccess soa(env);
    389     art::MutexLock mu(soa.Self(), *art::Locks::thread_list_lock_);
    390     art::Thread* thread = art::Thread::FromManagedThread(soa, jthread);
    391     return (thread != nullptr) ? thread->IsInterrupted() : JNI_FALSE;
    392   }
    393 }
    394 
    395 JNIEXPORT jboolean JVM_HoldsLock(JNIEnv* env, jclass unused ATTRIBUTE_UNUSED, jobject jobj) {
    396   art::ScopedObjectAccess soa(env);
    397   art::ObjPtr<art::mirror::Object> object = soa.Decode<art::mirror::Object>(jobj);
    398   if (object == nullptr) {
    399     art::ThrowNullPointerException("object == null");
    400     return JNI_FALSE;
    401   }
    402   return soa.Self()->HoldsLock(object);
    403 }
    404 
    405 JNIEXPORT void JVM_SetNativeThreadName(JNIEnv* env, jobject jthread, jstring java_name) {
    406   ScopedUtfChars name(env, java_name);
    407   {
    408     art::ScopedObjectAccess soa(env);
    409     if (soa.Decode<art::mirror::Object>(jthread) == soa.Self()->GetPeer()) {
    410       soa.Self()->SetThreadName(name.c_str());
    411       return;
    412     }
    413   }
    414   // Suspend thread to avoid it from killing itself while we set its name. We don't just hold the
    415   // thread list lock to avoid this, as setting the thread name causes mutator to lock/unlock
    416   // in the DDMS send code.
    417   art::ThreadList* thread_list = art::Runtime::Current()->GetThreadList();
    418   bool timed_out;
    419   // Take suspend thread lock to avoid races with threads trying to suspend this one.
    420   art::Thread* thread;
    421   {
    422     thread = thread_list->SuspendThreadByPeer(jthread,
    423                                               true,
    424                                               art::SuspendReason::kInternal,
    425                                               &timed_out);
    426   }
    427   if (thread != nullptr) {
    428     {
    429       art::ScopedObjectAccess soa(env);
    430       thread->SetThreadName(name.c_str());
    431     }
    432     bool resumed = thread_list->Resume(thread, art::SuspendReason::kInternal);
    433     DCHECK(resumed);
    434   } else if (timed_out) {
    435     LOG(ERROR) << "Trying to set thread name to '" << name.c_str() << "' failed as the thread "
    436         "failed to suspend within a generous timeout.";
    437   }
    438 }
    439 
    440 JNIEXPORT __attribute__((noreturn)) jint JVM_IHashCode(JNIEnv* env ATTRIBUTE_UNUSED,
    441                              jobject javaObject ATTRIBUTE_UNUSED) {
    442   UNIMPLEMENTED(FATAL) << "JVM_IHashCode is not implemented";
    443   UNREACHABLE();
    444 }
    445 
    446 JNIEXPORT __attribute__((noreturn)) jlong JVM_NanoTime(JNIEnv* env ATTRIBUTE_UNUSED, jclass unused ATTRIBUTE_UNUSED) {
    447   UNIMPLEMENTED(FATAL) << "JVM_NanoTime is not implemented";
    448   UNREACHABLE();
    449 }
    450 
    451 JNIEXPORT __attribute__((noreturn)) void JVM_ArrayCopy(JNIEnv* /* env */, jclass /* unused */, jobject /* javaSrc */,
    452                              jint /* srcPos */, jobject /* javaDst */, jint /* dstPos */,
    453                              jint /* length */) {
    454   UNIMPLEMENTED(FATAL) << "JVM_ArrayCopy is not implemented";
    455   UNREACHABLE();
    456 }
    457 
    458 JNIEXPORT __attribute__((noreturn)) jint JVM_FindSignal(const char* name ATTRIBUTE_UNUSED) {
    459   LOG(FATAL) << "JVM_FindSignal is not implemented";
    460   UNREACHABLE();
    461 }
    462 
    463 JNIEXPORT __attribute__((noreturn)) void* JVM_RegisterSignal(jint signum ATTRIBUTE_UNUSED, void* handler ATTRIBUTE_UNUSED) {
    464   LOG(FATAL) << "JVM_RegisterSignal is not implemented";
    465   UNREACHABLE();
    466 }
    467 
    468 JNIEXPORT __attribute__((noreturn)) jboolean JVM_RaiseSignal(jint signum ATTRIBUTE_UNUSED) {
    469   LOG(FATAL) << "JVM_RaiseSignal is not implemented";
    470   UNREACHABLE();
    471 }
    472 
    473 JNIEXPORT __attribute__((noreturn))  void JVM_Halt(jint code) {
    474   exit(code);
    475 }
    476 
    477 JNIEXPORT jboolean JVM_IsNaN(jdouble d) {
    478   return isnan(d);
    479 }
    480