// posix.cc -- Helper functions for POSIX-flavored OSs.
|
// posix.cc -- Helper functions for POSIX-flavored OSs.
|
|
|
/* Copyright (C) 2000, 2001, 2002, 2006 Free Software Foundation
|
/* Copyright (C) 2000, 2001, 2002, 2006 Free Software Foundation
|
|
|
This file is part of libgcj.
|
This file is part of libgcj.
|
|
|
This software is copyrighted work licensed under the terms of the
|
This software is copyrighted work licensed under the terms of the
|
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
|
Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
|
details. */
|
details. */
|
|
|
#include <config.h>
|
#include <config.h>
|
|
|
#include "posix.h"
|
#include "posix.h"
|
|
|
#include <stdlib.h>
|
#include <stdlib.h>
|
#include <errno.h>
|
#include <errno.h>
|
#include <signal.h>
|
#include <signal.h>
|
#include <stdio.h>
|
#include <stdio.h>
|
|
|
#ifdef HAVE_DLFCN_H
|
#ifdef HAVE_DLFCN_H
|
#include <dlfcn.h>
|
#include <dlfcn.h>
|
#endif
|
#endif
|
|
|
#include <jvm.h>
|
#include <jvm.h>
|
#include <java-stack.h>
|
#include <java-stack.h>
|
#include <java/lang/Thread.h>
|
#include <java/lang/Thread.h>
|
#include <java/io/InterruptedIOException.h>
|
#include <java/io/InterruptedIOException.h>
|
#include <java/util/Properties.h>
|
#include <java/util/Properties.h>
|
|
|
#if defined (ECOS)
|
#if defined (ECOS)
|
extern "C" unsigned long long _clock (void);
|
extern "C" unsigned long long _clock (void);
|
#endif
|
#endif
|
|
|
#if defined(HAVE_PROC_SELF_EXE)
|
#if defined(HAVE_PROC_SELF_EXE)
|
static char exec_name[20];
|
static char exec_name[20];
|
// initialized in _Jv_platform_initialize()
|
// initialized in _Jv_platform_initialize()
|
#endif
|
#endif
|
|
|
const char *_Jv_ThisExecutable (void)
|
const char *_Jv_ThisExecutable (void)
|
{
|
{
|
#if defined(DISABLE_MAIN_ARGS)
|
#if defined(DISABLE_MAIN_ARGS)
|
return "[Embedded App]";
|
return "[Embedded App]";
|
#elif defined(HAVE_PROC_SELF_EXE)
|
#elif defined(HAVE_PROC_SELF_EXE)
|
return exec_name;
|
return exec_name;
|
// initialized in _Jv_platform_initialize()
|
// initialized in _Jv_platform_initialize()
|
#else
|
#else
|
return _Jv_GetSafeArg (0);
|
return _Jv_GetSafeArg (0);
|
#endif
|
#endif
|
}
|
}
|
|
|
// gettimeofday implementation.
|
// gettimeofday implementation.
|
jlong
|
jlong
|
_Jv_platform_gettimeofday ()
|
_Jv_platform_gettimeofday ()
|
{
|
{
|
#if defined (HAVE_GETTIMEOFDAY)
|
#if defined (HAVE_GETTIMEOFDAY)
|
timeval tv;
|
timeval tv;
|
gettimeofday (&tv, NULL);
|
gettimeofday (&tv, NULL);
|
return (tv.tv_sec * 1000LL) + (tv.tv_usec / 1000LL);
|
return (tv.tv_sec * 1000LL) + (tv.tv_usec / 1000LL);
|
#elif defined (HAVE_TIME)
|
#elif defined (HAVE_TIME)
|
return time (NULL) * 1000LL;
|
return time (NULL) * 1000LL;
|
#elif defined (HAVE_FTIME)
|
#elif defined (HAVE_FTIME)
|
struct timeb t;
|
struct timeb t;
|
ftime (&t);
|
ftime (&t);
|
return (t.time * 1000LL) + t.millitm;
|
return (t.time * 1000LL) + t.millitm;
|
#elif defined (ECOS)
|
#elif defined (ECOS)
|
// FIXME.
|
// FIXME.
|
return _clock();
|
return _clock();
|
#else
|
#else
|
// In the absence of any function, time remains forever fixed.
|
// In the absence of any function, time remains forever fixed.
|
return 23000;
|
return 23000;
|
#endif
|
#endif
|
}
|
}
|
|
|
jlong
|
jlong
|
_Jv_platform_nanotime ()
|
_Jv_platform_nanotime ()
|
{
|
{
|
#ifdef HAVE_CLOCK_GETTIME
|
#ifdef HAVE_CLOCK_GETTIME
|
struct timespec now;
|
struct timespec now;
|
clockid_t id;
|
clockid_t id;
|
#ifdef CLOCK_MONOTONIC
|
#ifdef CLOCK_MONOTONIC
|
id = CLOCK_MONOTONIC;
|
id = CLOCK_MONOTONIC;
|
#elif defined (CLOCK_HIGHRES)
|
#elif defined (CLOCK_HIGHRES)
|
id = CLOCK_HIGHRES;
|
id = CLOCK_HIGHRES;
|
#else
|
#else
|
id = CLOCK_REALTIME;
|
id = CLOCK_REALTIME;
|
#endif
|
#endif
|
if (clock_gettime (id, &now) == 0)
|
if (clock_gettime (id, &now) == 0)
|
{
|
{
|
jlong result = (jlong) now.tv_sec;
|
jlong result = (jlong) now.tv_sec;
|
result = result * 1000000000LL + now.tv_nsec;
|
result = result * 1000000000LL + now.tv_nsec;
|
return result;
|
return result;
|
}
|
}
|
// clock_gettime failed, but we can fall through.
|
// clock_gettime failed, but we can fall through.
|
#endif // HAVE_CLOCK_GETTIME
|
#endif // HAVE_CLOCK_GETTIME
|
#if defined (HAVE_GETTIMEOFDAY)
|
#if defined (HAVE_GETTIMEOFDAY)
|
{
|
{
|
timeval tv;
|
timeval tv;
|
gettimeofday (&tv, NULL);
|
gettimeofday (&tv, NULL);
|
return (tv.tv_sec * 1000000000LL) + tv.tv_usec * 1000LL;
|
return (tv.tv_sec * 1000000000LL) + tv.tv_usec * 1000LL;
|
}
|
}
|
#else
|
#else
|
return _Jv_platform_gettimeofday () * 1000000LL;
|
return _Jv_platform_gettimeofday () * 1000000LL;
|
#endif
|
#endif
|
}
|
}
|
|
|
// Platform-specific VM initialization.
|
// Platform-specific VM initialization.
|
void
|
void
|
_Jv_platform_initialize (void)
|
_Jv_platform_initialize (void)
|
{
|
{
|
#if defined (HAVE_SIGACTION)
|
#if defined (HAVE_SIGACTION)
|
// We only want this on POSIX systems.
|
// We only want this on POSIX systems.
|
struct sigaction act;
|
struct sigaction act;
|
act.sa_handler = SIG_IGN;
|
act.sa_handler = SIG_IGN;
|
sigemptyset (&act.sa_mask);
|
sigemptyset (&act.sa_mask);
|
act.sa_flags = 0;
|
act.sa_flags = 0;
|
sigaction (SIGPIPE, &act, NULL);
|
sigaction (SIGPIPE, &act, NULL);
|
#else
|
#else
|
signal (SIGPIPE, SIG_IGN);
|
signal (SIGPIPE, SIG_IGN);
|
#endif
|
#endif
|
|
|
#if defined (HAVE_PROC_SELF_EXE)
|
#if defined (HAVE_PROC_SELF_EXE)
|
// Compute our executable name
|
// Compute our executable name
|
sprintf (exec_name, "/proc/%d/exe", getpid ());
|
sprintf (exec_name, "/proc/%d/exe", getpid ());
|
#endif
|
#endif
|
}
|
}
|
|
|
// Set platform-specific System properties.
|
// Set platform-specific System properties.
|
void
|
void
|
_Jv_platform_initProperties (java::util::Properties* newprops)
|
_Jv_platform_initProperties (java::util::Properties* newprops)
|
{
|
{
|
// A convenience define.
|
// A convenience define.
|
#define SET(Prop,Val) \
|
#define SET(Prop,Val) \
|
newprops->put(JvNewStringLatin1 (Prop), JvNewStringLatin1 (Val))
|
newprops->put(JvNewStringLatin1 (Prop), JvNewStringLatin1 (Val))
|
|
|
SET ("file.separator", "/");
|
SET ("file.separator", "/");
|
SET ("path.separator", ":");
|
SET ("path.separator", ":");
|
SET ("line.separator", "\n");
|
SET ("line.separator", "\n");
|
const char *tmpdir = ::getenv("TMPDIR");
|
const char *tmpdir = ::getenv("TMPDIR");
|
if (! tmpdir)
|
if (! tmpdir)
|
tmpdir = "/tmp";
|
tmpdir = "/tmp";
|
SET ("java.io.tmpdir", tmpdir);
|
SET ("java.io.tmpdir", tmpdir);
|
const char *zoneinfodir = ::getenv("TZDATA");
|
const char *zoneinfodir = ::getenv("TZDATA");
|
if (! zoneinfodir)
|
if (! zoneinfodir)
|
zoneinfodir = "/usr/share/zoneinfo";
|
zoneinfodir = "/usr/share/zoneinfo";
|
SET ("gnu.java.util.zoneinfo.dir", zoneinfodir);
|
SET ("gnu.java.util.zoneinfo.dir", zoneinfodir);
|
}
|
}
|
|
|
static inline void
|
static inline void
|
internal_gettimeofday (struct timeval *result)
|
internal_gettimeofday (struct timeval *result)
|
{
|
{
|
#if defined (HAVE_GETTIMEOFDAY)
|
#if defined (HAVE_GETTIMEOFDAY)
|
gettimeofday (result, NULL);
|
gettimeofday (result, NULL);
|
#else
|
#else
|
jlong val = _Jv_platform_gettimeofday ();
|
jlong val = _Jv_platform_gettimeofday ();
|
result->tv_sec = val / 1000;
|
result->tv_sec = val / 1000;
|
result->tv_usec = (val % 1000) * 1000;
|
result->tv_usec = (val % 1000) * 1000;
|
#endif /* HAVE_GETTIMEOFDAY */
|
#endif /* HAVE_GETTIMEOFDAY */
|
}
|
}
|
|
|
// A wrapper for select() which ignores EINTR.
|
// A wrapper for select() which ignores EINTR.
|
int
|
int
|
_Jv_select (int n, fd_set *readfds, fd_set *writefds,
|
_Jv_select (int n, fd_set *readfds, fd_set *writefds,
|
fd_set *exceptfds, struct timeval *timeout)
|
fd_set *exceptfds, struct timeval *timeout)
|
{
|
{
|
#ifdef HAVE_SELECT
|
#ifdef HAVE_SELECT
|
// If we have a timeout, compute the absolute ending time.
|
// If we have a timeout, compute the absolute ending time.
|
struct timeval end, delay;
|
struct timeval end, delay;
|
if (timeout)
|
if (timeout)
|
{
|
{
|
internal_gettimeofday (&end);
|
internal_gettimeofday (&end);
|
end.tv_usec += timeout->tv_usec;
|
end.tv_usec += timeout->tv_usec;
|
if (end.tv_usec >= 1000000)
|
if (end.tv_usec >= 1000000)
|
{
|
{
|
++end.tv_sec;
|
++end.tv_sec;
|
end.tv_usec -= 1000000;
|
end.tv_usec -= 1000000;
|
}
|
}
|
end.tv_sec += timeout->tv_sec;
|
end.tv_sec += timeout->tv_sec;
|
delay = *timeout;
|
delay = *timeout;
|
}
|
}
|
else
|
else
|
{
|
{
|
// Placate compiler.
|
// Placate compiler.
|
delay.tv_sec = delay.tv_usec = 0;
|
delay.tv_sec = delay.tv_usec = 0;
|
}
|
}
|
|
|
while (1)
|
while (1)
|
{
|
{
|
int r = select (n, readfds, writefds, exceptfds,
|
int r = select (n, readfds, writefds, exceptfds,
|
timeout ? &delay : NULL);
|
timeout ? &delay : NULL);
|
if (r != -1 || errno != EINTR)
|
if (r != -1 || errno != EINTR)
|
return r;
|
return r;
|
|
|
// Here we know we got EINTR.
|
// Here we know we got EINTR.
|
if (java::lang::Thread::interrupted ())
|
if (java::lang::Thread::interrupted ())
|
throw new java::io::InterruptedIOException (JvNewStringLatin1 ("select interrupted"));
|
throw new java::io::InterruptedIOException (JvNewStringLatin1 ("select interrupted"));
|
|
|
struct timeval after;
|
struct timeval after;
|
if (timeout)
|
if (timeout)
|
{
|
{
|
internal_gettimeofday (&after);
|
internal_gettimeofday (&after);
|
// Now compute new timeout argument.
|
// Now compute new timeout argument.
|
delay.tv_usec = end.tv_usec - after.tv_usec;
|
delay.tv_usec = end.tv_usec - after.tv_usec;
|
delay.tv_sec = end.tv_sec - after.tv_sec;
|
delay.tv_sec = end.tv_sec - after.tv_sec;
|
if (delay.tv_usec < 0)
|
if (delay.tv_usec < 0)
|
{
|
{
|
--delay.tv_sec;
|
--delay.tv_sec;
|
delay.tv_usec += 1000000;
|
delay.tv_usec += 1000000;
|
}
|
}
|
if (delay.tv_sec < 0)
|
if (delay.tv_sec < 0)
|
{
|
{
|
// We assume that the user wants a valid select() call
|
// We assume that the user wants a valid select() call
|
// more than precise timing. So if we get a series of
|
// more than precise timing. So if we get a series of
|
// EINTR we just keep trying with delay 0 until we get a
|
// EINTR we just keep trying with delay 0 until we get a
|
// valid result.
|
// valid result.
|
delay.tv_sec = 0;
|
delay.tv_sec = 0;
|
}
|
}
|
}
|
}
|
}
|
}
|
#else /* HAVE_SELECT */
|
#else /* HAVE_SELECT */
|
return 0;
|
return 0;
|
#endif
|
#endif
|
}
|
}
|
|
|
// Given an address, find the object that defines it and the nearest
|
// Given an address, find the object that defines it and the nearest
|
// defined symbol to that address. Returns 0 if no object defines this
|
// defined symbol to that address. Returns 0 if no object defines this
|
// address.
|
// address.
|
int
|
int
|
_Jv_platform_dladdr (void *addr, _Jv_AddrInfo *info)
|
_Jv_platform_dladdr (void *addr, _Jv_AddrInfo *info)
|
{
|
{
|
int ret_val = 0;
|
int ret_val = 0;
|
|
|
#if defined (HAVE_DLFCN_H) && defined (HAVE_DLADDR)
|
#if defined (HAVE_DLFCN_H) && defined (HAVE_DLADDR)
|
Dl_info addr_info;
|
Dl_info addr_info;
|
ret_val = dladdr (addr, &addr_info);
|
ret_val = dladdr (addr, &addr_info);
|
if (ret_val != 0)
|
if (ret_val != 0)
|
{
|
{
|
info->file_name = addr_info.dli_fname;
|
info->file_name = addr_info.dli_fname;
|
info->base = addr_info.dli_fbase;
|
info->base = addr_info.dli_fbase;
|
info->sym_name = addr_info.dli_sname;
|
info->sym_name = addr_info.dli_sname;
|
info->sym_addr = addr_info.dli_saddr;
|
info->sym_addr = addr_info.dli_saddr;
|
}
|
}
|
#else
|
#else
|
info->file_name = NULL;
|
info->file_name = NULL;
|
info->base = NULL;
|
info->base = NULL;
|
info->sym_name = NULL;
|
info->sym_name = NULL;
|
info->sym_addr = NULL;
|
info->sym_addr = NULL;
|
#endif
|
#endif
|
|
|
return ret_val;
|
return ret_val;
|
}
|
}
|
|
|
