ULONG APIENTRY thread_exception_handler(EXCEPTIONREPORTRECORD *pReportRec,
EXCEPTIONREGISTRATIONRECORD *pRegRec,
CONTEXTRECORD *pContext,
PVOID p)
{
int c;
if (pReportRec->fHandlerFlags & EH_NESTED_CALL) {
return XCPT_CONTINUE_SEARCH;
}
if (pReportRec->ExceptionNum == XCPT_ACCESS_VIOLATION ||
pReportRec->ExceptionNum == XCPT_INTEGER_DIVIDE_BY_ZERO) {
ap_log_error(APLOG_MARK, APLOG_ERR, 0, ap_server_conf,
"caught exception in worker thread, initiating child shutdown pid=%d", getpid());
for (c=0; c<HARD_THREAD_LIMIT; c++) {
if (ap_scoreboard_image->servers[child_slot][c].tid == _gettid()) {
ap_scoreboard_image->servers[child_slot][c].status = SERVER_DEAD;
break;
}
}
/* Shut down process ASAP, it could be quite unhealthy & leaking resources */
shutdown_pending = 1;
ap_scoreboard_image->parent[child_slot].quiescing = 1;
kill(getpid(), SIGHUP);
DosUnwindException(UNWIND_ALL, 0, 0);
}
return XCPT_CONTINUE_SEARCH;
}
/**
* Cleans up after system_Init() and system_Configure().
*/
void system_End(void)
{
if( tidIPCFirst == _gettid())
{
HPIPE hpipe;
ULONG ulAction;
ULONG cbActual;
ULONG rc;
do
{
rc = DosOpen( VLC_IPC_PIPE, &hpipe, &ulAction, 0, 0,
OPEN_ACTION_OPEN_IF_EXISTS,
OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYREADWRITE |
OPEN_FLAGS_FAIL_ON_ERROR,
NULL );
if( rc == ERROR_PIPE_BUSY )
DosWaitNPipe( VLC_IPC_PIPE, -1 );
else if( rc )
DosSleep( 1 );
} while( rc );
/* Ask for IPCHelper to quit */
ULONG ulCmd = IPC_CMD_QUIT;
DosWrite( hpipe, &ulCmd, sizeof( ulCmd ), &cbActual );
DosClose( hpipe );
TID tid = tidIPCHelper;
DosWaitThread( &tid, DCWW_WAIT );
}
}
/**
* Wrapper which unpacks the params and calls thread function.
*/
static void rtThreadNativeMain(void *pvArgs)
{
/*
* Block SIGALRM - required for timer-posix.cpp.
* This is done to limit harm done by OSes which doesn't do special SIGALRM scheduling.
* It will not help much if someone creates threads directly using pthread_create. :/
*/
sigset_t SigSet;
sigemptyset(&SigSet);
sigaddset(&SigSet, SIGALRM);
sigprocmask(SIG_BLOCK, &SigSet, NULL);
/*
* Call common main.
*/
PRTTHREADINT pThread = (PRTTHREADINT)pvArgs;
*g_ppCurThread = pThread;
#ifdef fibGetTidPid
rtThreadMain(pThread, fibGetTidPid(), &pThread->szName[0]);
#else
rtThreadMain(pThread, _gettid(), &pThread->szName[0]);
#endif
*g_ppCurThread = NULL;
_endthread();
}
gboolean
arv_make_thread_high_priority (int nice_level)
{
GDBusConnection *bus;
GError *error = NULL;
bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
if (error != NULL) {
arv_warning_misc ("Failed to connect to system bus: %s", error->message);
g_error_free (error);
return FALSE;
}
arv_rtkit_make_high_priority (bus, _gettid(), nice_level, &error);
g_object_unref (bus);
if (error != NULL) {
arv_warning_misc ("Failed to connect high priority: %s", error->message);
g_error_free (error);
return FALSE;
}
arv_debug_misc ("Nice level successfully changed to %d", nice_level);
return TRUE;
}
int rtkit_make_high_priority(DBusConnection *connection, pid_t thread, int nice_level) {
DBusMessage *m = NULL, *r = NULL;
dbus_uint64_t u64;
dbus_int32_t s32;
DBusError error;
int ret;
dbus_error_init(&error);
if (thread == 0)
thread = _gettid();
if (!(m = dbus_message_new_method_call(
RTKIT_SERVICE_NAME,
RTKIT_OBJECT_PATH,
"org.freedesktop.RealtimeKit1",
"MakeThreadHighPriority"))) {
ret = -ENOMEM;
goto finish;
}
u64 = (dbus_uint64_t) thread;
s32 = (dbus_int32_t) nice_level;
if (!dbus_message_append_args(
m,
DBUS_TYPE_UINT64, &u64,
DBUS_TYPE_INT32, &s32,
DBUS_TYPE_INVALID)) {
ret = -ENOMEM;
goto finish;
}
if (!(r = dbus_connection_send_with_reply_and_block(connection, m, -1, &error))) {
ret = translate_error(error.name);
goto finish;
}
if (dbus_set_error_from_message(&error, r)) {
ret = translate_error(error.name);
goto finish;
}
ret = 0;
finish:
if (m)
dbus_message_unref(m);
if (r)
dbus_message_unref(r);
dbus_error_free(&error);
return ret;
}
RTDECL(RTNATIVETHREAD) RTThreadNativeSelf(void)
{
#ifdef fibGetTidPid
return fibGetTidPid();
#else
return _gettid();
#endif
}
gboolean
arv_make_thread_realtime (int priority)
{
struct sched_param p;
memset(&p, 0, sizeof(p));
p.sched_priority = priority;
if (sched_setscheduler(_gettid (), SCHED_RR|SCHED_RESET_ON_FORK, &p) < 0
&& errno == EPERM) {
struct rlimit rlim;
GDBusConnection *bus;
GError *error = NULL;
memset(&rlim, 0, sizeof(rlim));
rlim.rlim_cur = rlim.rlim_max = 100000000ULL; /* 100ms */
if ((setrlimit(RLIMIT_RTTIME, &rlim) < 0)) {
arv_warning_misc ("Failed to set RLIMIT_RTTIME: %s", strerror (errno));
return FALSE;
}
bus = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error);
if (error != NULL) {
arv_warning_misc ("Failed to connect to system bus: %s", error->message);
g_error_free (error);
return FALSE;
}
arv_rtkit_make_realtime(bus, _gettid (), p.sched_priority, &error);
g_object_unref (bus);
if (error != NULL) {
arv_warning_misc ("Failed to connect make realtime: %s", error->message);
g_error_free (error);
return FALSE;
}
arv_debug_misc ("Thread became realtime with priority %d", priority);
return TRUE;
}
return TRUE;
}
static void vlc_rwlock_wrunlock (vlc_rwlock_t *lock)
{
vlc_mutex_lock (&lock->mutex);
assert (lock->writer == _gettid ());
assert (lock->readers == 0);
lock->writer = 0; /* Write unlock */
/* Let reader and writer compete. Scheduler decides who wins. */
vlc_cond_broadcast (&lock->wait);
vlc_mutex_unlock (&lock->mutex);
}
static void worker( void *arg )
{
printf("Testing in tid = %d\n", _gettid());
test1();
test2();
test3();
test4();
test5();
test6();
test7();
}
void vlc_rwlock_wrlock (vlc_rwlock_t *lock)
{
vlc_mutex_lock (&lock->mutex);
if (unlikely(lock->writers == ULONG_MAX))
abort ();
lock->writers++;
/* Wait until nobody owns the lock in either way. */
while ((lock->readers > 0) || (lock->writer != 0))
vlc_cond_wait (&lock->wait, &lock->mutex);
lock->writers--;
assert (lock->writer == 0);
lock->writer = _gettid ();
vlc_mutex_unlock (&lock->mutex);
}
/**
* Wrapper which unpacks the params and calls thread function.
*/
static void rtThreadNativeMain(void *pvArgs)
{
rtThreadOs2BlockSigAlarm();
/*
* Call common main.
*/
PRTTHREADINT pThread = (PRTTHREADINT)pvArgs;
*g_ppCurThread = pThread;
#ifdef fibGetTidPid
rtThreadMain(pThread, fibGetTidPid(), &pThread->szName[0]);
#else
rtThreadMain(pThread, _gettid(), &pThread->szName[0]);
#endif
*g_ppCurThread = NULL;
_endthread();
}
void system_Configure( libvlc_int_t *p_this, int i_argc, const char *const ppsz_argv[] )
{
if( var_InheritBool( p_this, "high-priority" ) )
{
if( !DosSetPriority( PRTYS_PROCESS, PRTYC_REGULAR, PRTYD_MAXIMUM, 0 ) )
{
msg_Dbg( p_this, "raised process priority" );
}
else
{
msg_Dbg( p_this, "could not raise process priority" );
}
}
if( var_InheritBool( p_this, "one-instance" )
|| ( var_InheritBool( p_this, "one-instance-when-started-from-file" )
&& var_InheritBool( p_this, "started-from-file" ) ) )
{
HPIPE hpipe;
ULONG ulAction;
ULONG rc;
msg_Info( p_this, "one instance mode ENABLED");
/* Use a named pipe to check if another instance is already running */
for(;;)
{
rc = DosOpen( VLC_IPC_PIPE, &hpipe, &ulAction, 0, 0,
OPEN_ACTION_OPEN_IF_EXISTS,
OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYREADWRITE |
OPEN_FLAGS_FAIL_ON_ERROR,
NULL );
if( rc == ERROR_PIPE_BUSY )
DosWaitNPipe( VLC_IPC_PIPE, -1 );
else
break;
}
if( rc )
{
rc = DosCreateNPipe( VLC_IPC_PIPE, &hpipeIPC,
NP_ACCESS_DUPLEX,
NP_WAIT | NP_TYPE_MESSAGE |
NP_READMODE_MESSAGE | 0x01,
32768, 32768, 0 );
if( rc )
{
/* Failed to create a named pipe. Just ignore the option and
* go on as normal. */
msg_Err( p_this, "one instance mode DISABLED "
"(a named pipe couldn't be created)" );
return;
}
/* We are the 1st instance. */
/* Save the tid of the first instance */
tidIPCFirst = _gettid();
/* Run the helper thread */
tidIPCHelper = _beginthread( IPCHelperThread, NULL, 1024 * 1024,
p_this );
if( tidIPCHelper == -1 )
{
msg_Err( p_this, "one instance mode DISABLED "
"(IPC helper thread couldn't be created)");
tidIPCFirst = -1;
}
}
else
{
/* Another instance is running */
ULONG ulCmd = var_InheritBool( p_this, "playlist-enqueue") ?
IPC_CMD_ENQUEUE : IPC_CMD_GO;
ULONG cbActual;
/* Write a command */
DosWrite( hpipe, &ulCmd, sizeof( ulCmd ), &cbActual );
/* We assume that the remaining parameters are filenames
* and their input options */
/* Write a count of arguments */
DosWrite( hpipe, &i_argc, sizeof( i_argc ), &cbActual );
for( int i_opt = 0; i_opt < i_argc; i_opt++ )
{
/* We need to resolve relative paths in this instance */
char *mrl;
if( strstr( ppsz_argv[ i_opt ], "://" ))
mrl = strdup( ppsz_argv[ i_opt ] );
else
mrl = vlc_path2uri( ppsz_argv[ i_opt ], NULL );
if( !mrl )
mrl = ( char * )ppsz_argv[ i_opt ];
size_t i_len = strlen( mrl ) + 1;
/* Write a length of an argument */
DosWrite( hpipe, &i_len, sizeof( i_len ), &cbActual );
/* Write an argument */
DosWrite( hpipe, mrl, i_len, &cbActual );
if( mrl != ppsz_argv[ i_opt ])
free( mrl );
}
/* Close a named pipe of a client side */
DosClose( hpipe );
/* Bye bye */
system_End();
exit( 0 );
}
}
}
/*
*time: level: process[pid]: [tid] tag: message
* [verbose ]
*/
static int _log_print(int lvl, const char *tag,
const char *file, int line,
const char *func, const char *msg)
{
int ret = 0, i = 0;
struct iovec vec[LOG_IOVEC_MAX];
char s_time[LOG_TIME_SIZE];
char s_lvl[LOG_LEVEL_SIZE];
char s_tag[LOG_TAG_SIZE];
char s_pname[LOG_PNAME_SIZE];
char s_pid[LOG_PNAME_SIZE];
char s_tid[LOG_PNAME_SIZE];
char s_file[LOG_TEXT_SIZE];
char s_msg[LOG_BUF_SIZE];
pthread_mutex_lock(&_log_mutex);
log_get_time(s_time, sizeof(s_time), 0);
if (_log_fp == stderr || _log_fd == STDERR_FILENO) {
switch(lvl) {
case LOG_EMERG:
case LOG_ALERT:
case LOG_CRIT:
case LOG_ERR:
snprintf(s_lvl, sizeof(s_lvl),
B_RED("[%7s]"), _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), RED("%s"), msg);
break;
case LOG_WARNING:
snprintf(s_lvl, sizeof(s_lvl),
B_YELLOW("[%7s]"), _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), YELLOW("%s"), msg);
break;
case LOG_INFO:
snprintf(s_lvl, sizeof(s_lvl),
B_GREEN("[%7s]"), _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), GREEN("%s"), msg);
break;
case LOG_DEBUG:
snprintf(s_lvl, sizeof(s_lvl),
B_WHITE("[%7s]"), _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), WHITE("%s"), msg);
break;
default:
snprintf(s_lvl, sizeof(s_lvl),
"[%7s]", _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), "%s", msg);
break;
}
} else {
snprintf(s_lvl, sizeof(s_lvl),
"[%7s]", _log_level_str[lvl]);
snprintf(s_msg, sizeof(s_msg), "%s", msg);
}
if (CHECK_LOG_PREFIX(_log_prefix, LOG_PIDTID_BIT)) {
snprintf(s_pname, sizeof(s_pname), "[%s ", _proc_name);
snprintf(s_pid, sizeof(s_pid), "pid:%d ", getpid());
snprintf(s_tid, sizeof(s_tid), "tid:%d]", _gettid());
snprintf(s_tag, sizeof(s_tag), "[%s]", tag);
snprintf(s_file, sizeof(s_file), "[%s:%d: %s] ", file, line, func);
}
if (CHECK_LOG_PREFIX(_log_prefix, LOG_FUNCLINE_BIT)) {
snprintf(s_file, sizeof(s_file), "[%s:%d: %s] ", file, line, func);
}
i = -1;
if (CHECK_LOG_PREFIX(_log_prefix, LOG_TIMESTAMP_BIT)) {
vec[++i].iov_base = (void *)s_time;
vec[i].iov_len = strlen(s_time);
}
if (CHECK_LOG_PREFIX(_log_prefix, LOG_PIDTID_BIT)) {
vec[++i].iov_base = (void *)s_pname;
vec[i].iov_len = strlen(s_pname);
vec[++i].iov_base = (void *)s_pid;
vec[i].iov_len = strlen(s_pid);
vec[++i].iov_base = (void *)s_tid;
vec[i].iov_len = strlen(s_tid);
}
vec[++i].iov_base = (void *)s_lvl;
vec[i].iov_len = strlen(s_lvl);
if (CHECK_LOG_PREFIX(_log_prefix, LOG_TAG_BIT)) {
vec[++i].iov_base = (void *)s_tag;
vec[i].iov_len = strlen(s_tag);
}
if (CHECK_LOG_PREFIX(_log_prefix, LOG_FUNCLINE_BIT)) {
vec[++i].iov_base = (void *)s_file;
vec[i].iov_len = strlen(s_file);
}
vec[++i].iov_base = (void *)s_msg;
vec[i].iov_len = strlen(s_msg);
if (UNLIKELY(!_log_syslog)) {
ret = _log_handle->write(vec, i+1);
}
pthread_mutex_unlock(&_log_mutex);
return ret;
}
void libcx_trace(unsigned traceGroup, const char *file, int line, const char *func, const char *format, ...)
{
if (!gLogInstance && !get_log_instance())
return;
va_list args;
char *msg;
unsigned cch;
int n;
ULONG ts;
enum { MaxBuf = 513 };
msg = (char *)alloca(MaxBuf);
if (!msg)
return;
DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &ts, sizeof(ts));
if (gLogToConsole)
{
/*
* Logging to the console differs from logging to the file: 1) we want to
* put PID in prefix (since there may be more than one PID logging) and
* 2) we want to visually differentiate from the normal program output so
* we prefix it with stars too.
*/
if (file != NULL && line != 0 && func != NULL)
n = snprintf(msg, MaxBuf, "*** %08lx %04x:%02x %s:%d:%s: ", ts, getpid(), _gettid(), _getname(file), line, func);
else if (file == NULL && line == 0 && func == NULL)
n = snprintf(msg, MaxBuf, "*** %08lx %04x:%02x ", ts, getpid(), _gettid());
else
n = 0;
}
else
{
/*
* Try to match the standard LIBC log file formatting as much as we can
* TODO: Add a flag to LIBC to suppress the standard legend in the log header
*/
if (file != NULL && line != 0 && func != NULL)
n = snprintf(msg, MaxBuf, "%08lx %02x %s:%d:%s: ", ts, _gettid(), _getname(file), line, func);
else if (file == NULL && line == 0 && func == NULL)
n = snprintf(msg, MaxBuf, "%08lx %02x ", ts, _gettid());
else
n = 0;
}
if (n < MaxBuf)
{
va_start(args, format);
n += vsnprintf(msg + n, MaxBuf - n, format, args);
va_end(args);
}
if (n < MaxBuf)
cch = n;
else
cch = MaxBuf - 1;
__libc_LogRaw(gLogInstance, traceGroup | __LIBC_LOG_MSGF_FLUSH, msg, cch);
}