libjava/java/lang/natRuntime.cc

   1 // natRuntime.cc - Implementation of native side of Runtime class.
   2
   3 /* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006  Free Software Foundation
   4
   5    This file is part of libgcj.
   6
   7 This software is copyrighted work licensed under the terms of the
   8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   9 details.  */
  10
  11 #include <config.h>
  12 #include <platform.h>
  13
  14 #include <stdlib.h>
  15
  16 #include <gcj/cni.h>
  17 #include <jvm.h>
  18 #include <java-props.h>
  19 #include <java-stack.h>
  20 #include <java/lang/Long.h>
  21 #include <java/lang/Runtime.h>
  22 #include <java/lang/UnknownError.h>
  23 #include <java/lang/UnsatisfiedLinkError.h>
  24 #include <gnu/gcj/runtime/FinalizerThread.h>
  25 #include <java/io/File.h>
  26 #include <java/util/TimeZone.h>
  27 #include <java/lang/StringBuffer.h>
  28 #include <java/lang/Process.h>
  29 #include <java/lang/ConcreteProcess.h>
  30 #include <java/lang/ClassLoader.h>
  31
  32 #include <jni.h>
  33
  34 #ifdef HAVE_PWD_H
  35 #include <pwd.h>
  36 #endif
  37 #include <errno.h>
  38
  39 #ifdef HAVE_LOCALE_H
  40 #include <locale.h>
  41 #endif
  42
  43 #ifdef HAVE_LANGINFO_H
  44 #include <langinfo.h>
  45 #endif
  46
  47 \f
  48
  49 #ifdef USE_LTDL
  50 #include <ltdl.h>
  51
  52 /* FIXME: we don't always need this.  The next libtool will let us use
  53    AC_LTDL_PREOPEN to see if we do.  */
  54 extern const lt_dlsymlist lt_preloaded_symbols[1] = { { 0, 0 } };
  55
  56 struct lookup_data
  57 {
  58   const char *symname;
  59   void *result;
  60 };
  61
  62 static int
  63 find_symbol (lt_dlhandle handle, lt_ptr data)
  64 {
  65   lookup_data *ld = (lookup_data *) data;
  66   ld->result = lt_dlsym (handle, ld->symname);
  67   return ld->result != NULL;
  68 }
  69
  70 void *
  71 _Jv_FindSymbolInExecutable (const char *symname)
  72 {
  73   lookup_data data;
  74   data.symname = symname;
  75   data.result = NULL;
  76   lt_dlforeach (find_symbol, (lt_ptr) &data);
  77   return data.result;
  78 }
  79
  80 #else
  81
  82 void *
  83 _Jv_FindSymbolInExecutable (const char *)
  84 {
  85   return NULL;
  86 }
  87
  88 #endif /* USE_LTDL */
  89
  90 \f
  91
  92 void
  93 java::lang::Runtime::runFinalizationForExit ()
  94 {
  95   if (finalizeOnExit)
  96     _Jv_RunAllFinalizers ();
  97 }
  98
  99 void
 100 java::lang::Runtime::exitInternal (jint status)
 101 {
 102   // Make status right for Unix.  This is perhaps strange.
 103   if (status < 0 || status > 255)
 104     status = 255;
 105
 106   ::exit (status);
 107 }
 108
 109 jlong
 110 java::lang::Runtime::freeMemory (void)
 111 {
 112   return _Jv_GCFreeMemory ();
 113 }
 114
 115 void
 116 java::lang::Runtime::gc (void)
 117 {
 118   _Jv_RunGC ();
 119 }
 120
 121 #ifdef USE_LTDL
 122 // List of names for JNI_OnLoad.
 123 static const char *onload_names[] = _Jv_platform_onload_names;
 124 #endif
 125
 126 void
 127 java::lang::Runtime::_load (jstring path, jboolean do_search)
 128 {
 129   JvSynchronize sync (this);
 130   using namespace java::lang;
 131 #ifdef USE_LTDL
 132   jint len = _Jv_GetStringUTFLength (path);
 133   char buf[len + 1 + strlen (_Jv_platform_solib_prefix)
 134            + strlen (_Jv_platform_solib_suffix)];
 135   int offset = 0;
 136   if (do_search)
 137     {
 138       strcpy (buf, _Jv_platform_solib_prefix);
 139       offset = strlen (_Jv_platform_solib_prefix);
 140     }
 141   jsize total = JvGetStringUTFRegion (path, 0, path->length(), &buf[offset]);
 142   buf[offset + total] = '\0';
 143
 144   char *lib_name = buf;
 145
 146   if (do_search)
 147     {
 148       ClassLoader *look = _Jv_StackTrace::GetFirstNonSystemClassLoader ();
 149
 150       if (look != NULL)
 151         {
 152           // Don't include solib prefix in string passed to
 153           // findLibrary.
 154           jstring name = look->findLibrary(JvNewStringUTF(&buf[offset]));
 155           if (name != NULL)
 156             {
 157               len = _Jv_GetStringUTFLength (name);
 158               lib_name = (char *) _Jv_AllocBytes(len + 1);
 159               total = JvGetStringUTFRegion (name, 0,
 160                                             name->length(), lib_name);
 161               lib_name[total] = '\0';
 162               // Don't append suffixes any more; we have the full file
 163               // name.
 164               do_search = false;
 165             }
 166         }
 167     }
 168
 169   lt_dlhandle h;
 170   // FIXME: make sure path is absolute.
 171   {
 172     // Synchronize on java.lang.Class. This is to protect the class chain from
 173     // concurrent modification by class registration calls which may be run
 174     // during the dlopen().
 175     JvSynchronize sync (&java::lang::Class::class$);
 176     h = do_search ? lt_dlopenext (lib_name) : lt_dlopen (lib_name);
 177   }
 178   if (h == NULL)
 179     {
 180       const char *msg = lt_dlerror ();
 181       jstring str = JvNewStringLatin1 (lib_name);
 182       str = str->concat (JvNewStringLatin1 (": "));
 183       str = str->concat (JvNewStringLatin1 (msg));
 184       throw new UnsatisfiedLinkError (str);
 185     }
 186
 187   // Search for JNI_OnLoad function.
 188   void *onload = NULL;
 189   const char **name = onload_names;
 190   while (*name != NULL)
 191     {
 192       onload = lt_dlsym (h, *name);
 193       if (onload != NULL)
 194         break;
 195       ++name;
 196     }
 197
 198   if (onload != NULL)
 199     {
 200       JavaVM *vm = _Jv_GetJavaVM ();
 201       if (vm == NULL)
 202         {
 203           // FIXME: what?
 204           return;
 205         }
 206       jint vers = ((jint (JNICALL *) (JavaVM *, void *)) onload) (vm, NULL);
 207       if (vers != JNI_VERSION_1_1 && vers != JNI_VERSION_1_2
 208           && vers != JNI_VERSION_1_4)
 209         {
 210           // FIXME: unload the library.
 211           throw new UnsatisfiedLinkError (JvNewStringLatin1 ("unrecognized version from JNI_OnLoad"));
 212         }
 213     }
 214 #else
 215   throw new UnknownError
 216     (JvNewStringLatin1 (do_search
 217                         ? "Runtime.loadLibrary not implemented"
 218                         : "Runtime.load not implemented"));
 219 #endif /* USE_LTDL */
 220 }
 221
 222 jboolean
 223 java::lang::Runtime::loadLibraryInternal (jstring lib)
 224 {
 225   JvSynchronize sync (this);
 226   using namespace java::lang;
 227 #ifdef USE_LTDL
 228   jint len = _Jv_GetStringUTFLength (lib);
 229   char buf[len + 1];
 230   jsize total = JvGetStringUTFRegion (lib, 0, lib->length(), buf);
 231   buf[total] = '\0';
 232   // FIXME: make sure path is absolute.
 233   lt_dlhandle h = lt_dlopenext (buf);
 234   return h != NULL;
 235 #else
 236   return false;
 237 #endif /* USE_LTDL */
 238 }
 239
 240 void
 241 java::lang::Runtime::init (void)
 242 {
 243 #ifdef USE_LTDL
 244   lt_dlinit ();
 245   // Set module load path.
 246   lt_dlsetsearchpath (_Jv_Module_Load_Path);
 247   // Make sure self is opened.
 248   lt_dlopen (NULL);
 249 #endif
 250 }
 251
 252 void
 253 java::lang::Runtime::runFinalization (void)
 254 {
 255   gnu::gcj::runtime::FinalizerThread::finalizerReady ();
 256 }
 257
 258 jlong
 259 java::lang::Runtime::totalMemory (void)
 260 {
 261   return _Jv_GCTotalMemory ();
 262 }
 263
 264 jlong
 265 java::lang::Runtime::maxMemory (void)
 266 {
 267   // We don't have a maximum.  FIXME: we might if we ask the GC for
 268   // one.
 269   return Long::MAX_VALUE;
 270 }
 271
 272 void
 273 java::lang::Runtime::traceInstructions (jboolean)
 274 {
 275   // Do nothing.
 276 }
 277
 278 void
 279 java::lang::Runtime::traceMethodCalls (jboolean)
 280 {
 281   // Do nothing.
 282 }
 283
 284 java::lang::Process *
 285 java::lang::Runtime::execInternal (jstringArray cmd,
 286                                    jstringArray env,
 287                                    java::io::File *dir)
 288 {
 289   return new java::lang::ConcreteProcess (cmd, env, dir);
 290 }
 291
 292 jint
 293 java::lang::Runtime::availableProcessors (void)
 294 {
 295   // FIXME: find the real value.
 296   return 1;
 297 }
 298
 299 jstring
 300 java::lang::Runtime::nativeGetLibname (jstring pathname, jstring libname)
 301 {
 302   java::lang::StringBuffer *sb = new java::lang::StringBuffer ();
 303   sb->append(pathname);
 304   if (pathname->length() > 0)
 305     sb->append (_Jv_platform_file_separator);
 306
 307   sb->append (JvNewStringLatin1 (_Jv_platform_solib_prefix));
 308   sb->append(libname);
 309   sb->append (JvNewStringLatin1 (_Jv_platform_solib_suffix));
 310
 311   return sb->toString();
 312 }