src/solaris/hpi/native_threads/src/threads_linux.c - toolchain/jdk/jdk9_jdk - Git at Google

 /*
  * Copyright (c) 1999, 2000, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 /*
  * Implementation of notposix.h on Linux.
  */

 #include <pthread.h>
 #include <signal.h>
 #include <string.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <fcntl.h>
 #include <time.h>

 #include "hpi_impl.h"
 #include "monitor_md.h"
 #include "threads_md.h"
 #include "np.h"

 #undef LOG_THREADS

 /* Global lock used when calling np_suspend and np_resume */
 static pthread_mutex_t sr_lock;

 /* Semaphore used to acknowledge when the handler has received HANDLER_SIG */
 static sem_t sr_sem;

 /* The tid of the thread being suspended/resumed */
 static sys_thread_t *sr_tid;

 int sr_sigsusp;
 int sr_sigresu;

 static void prtsigset(char *s, sigset_t *set)
 {
     int sig;
     dprintf(2, "%s:", s);
     for (sig = 1; sig < _NSIG; sig++) {
         if (sigismember(set, sig)) {
             dprintf(2, " %d", sig);
         }
     }
     dprintf(2, "\n");
 }

 /*
  * Handler function invoked when a thread's execution is suspended
  * We have to be careful that only async-safe functions are
  * called here. I'm not even sure if calling sysThreadSelf is safe so
  * we temporarily stash SP in a global variable instead.
  */
 static void
 #ifdef SA_SIGINFO
 susp_handler(int sig, siginfo_t* info, void* arg)
 #else
 susp_handler(int sig)
 #endif
 {
     sys_thread_t *tid = sr_tid;
     sigset_t set;
     /* Save the current SP */
     tid->sp = &tid;
     sem_post(&sr_sem);
     sigfillset(&set);
     sigdelset(&set,(sr_sigresu));
     /* block until we receive resume signal. */
     sigsuspend(&set);
 }

 static void
 #ifdef SA_SIGINFO
 resu_handler(int sig, siginfo_t* info, void* arg)
 #else
 resu_handler(int sig)
 #endif
 {
     return;
 }

 /*
  * Initialize signal handlers for suspend and resume}.
  */
 int
 np_initialize()
 {
     struct sigaction act;
     char *s;
     int err;

     /* Signal numbers used to suspend and resume */
 #if __GLIBC__ == 2 && __GLIBC_MINOR__ == 0
 #ifdef SIGUNUSED
     sr_sigsusp = SIGUNUSED;
 #else
     sr_sigsusp = SIGLOST;
 #endif
 #ifdef SIGPWR
     sr_sigresu = SIGPWR;
 #else
     sr_sigresu = SIGXFSZ;
 #endif
 #else
     /* use real time signals */
     /* currently __SIGRTMIN, +1, +2 are all used by LinuxThreads */
     sr_sigsusp = SIGRTMIN + 3;
     sr_sigresu = SIGRTMIN + 4;
 #endif

     /* Set up signal handler for suspend and resume */
 #if defined(SA_SIGINFO) && !defined(__sparc__)
     act.sa_handler = 0;
     act.sa_sigaction = susp_handler;
 #else
     act.sa_handler = (__sighandler_t) susp_handler;
 #endif
 #ifdef SA_SIGINFO
     act.sa_flags = SA_RESTART | SA_SIGINFO;
 #else
     act.sa_flags = SA_RESTART;
 #endif
     sigfillset(&act.sa_mask);
     if (sigaction(sr_sigsusp, &act, 0) == -1) {
         return -1;
     }
 #if defined(SA_SIGINFO) && !defined(__sparc__)
     act.sa_handler = 0;
     act.sa_sigaction = resu_handler;
 #else
     act.sa_handler = (__sighandler_t) resu_handler;
 #endif
 #ifdef SA_SIGINFO
     act.sa_flags = SA_SIGINFO;
 #else
     act.sa_flags = 0;
 #endif
     sigfillset(&act.sa_mask);
     if (sigaction(sr_sigresu, &act, 0) == -1) {
         return -1;
     }

     /* Initialize semaphore used by np_{suspend/resume} */
     if (sem_init(&sr_sem, 0, 0) == -1) {
         return SYS_ERR;
     }

     /* Initialize mutex used by np_{suspend/resume} */
     err = mutexInit(&sr_lock);
     sysAssert(err == 0);

     return SYS_OK;
 }

 int
 np_initial_suspend(sys_thread_t* tid)
 {
     int count;

     tid->selfsuspended = (tid == sysThreadSelf());
     sysAssert(tid->selfsuspended);

     count = tid->suspend_count++;
     sysAssert(count == 0);

 #ifdef LOG_THREADS
     dprintf(2,
             "[Initial self-suspend [tid = %ld, sys_thread = %ld]\n",
             pthread_self(), tid->sys_thread);
 #endif

     /* Order should not matter but doing the post first should be faster */
     sem_post(&tid->sem_suspended);
     do {
         sem_wait(&tid->sem_selfsuspend);
     } while (tid->selfsuspended); /* paranoid */
     return 0;
 }


 int
 np_suspend(sys_thread_t *tid)
 {
     int count, ret = 0;

     int err = mutexLock(&sr_lock);
     sysAssert(err == 0);

     tid->selfsuspended = (tid == sysThreadSelf());

     count = tid->suspend_count++;
 #ifdef LOG_THREADS
     dprintf(2, "[Suspending fromtid = %ld, tid = %ld, pid = %d, count = %d]\n",
             pthread_self(), tid->sys_thread, tid->lwp_id, count);
 #endif
     if (count == 0) {
         if (tid->selfsuspended) {
 #ifdef LOG_THREADS
             dprintf(2,
                     "[Self-suspending [tid = %ld, sys_thread = %ld]\n",
                     pthread_self(), tid->sys_thread);
 #endif
             mutexUnlock(&sr_lock);
             do {
                 sem_wait(&tid->sem_selfsuspend);
             } while (tid->selfsuspended);
             /* [jk] What is the correct return value here?
                There was no error, but when we return the thread
                has already been resumed. */
             return SYS_OK;

         } else {
             sr_tid = tid;
             ret = pthread_kill(tid->sys_thread, sr_sigsusp);
             if (ret == 0) {
                 sem_wait(&sr_sem);
             }
 #ifdef LOG_THREADS
             dprintf(2,
                     "[Suspended fromtid = %ld, pthread_kill(%ld, %d) = %d]\n",
                     pthread_self(), tid->sys_thread, sr_sigsusp, ret);
 #endif
         }
     }

     err = mutexUnlock(&sr_lock);
     sysAssert(err == 0);

     return ret == 0 ? SYS_OK : SYS_ERR;
 }

 int
 np_continue(sys_thread_t *tid)
 {
     int count, ret = 0;

     int err = mutexLock(&sr_lock);
     sysAssert(err == 0);

     count = --tid->suspend_count;
 #ifdef LOG_THREADS
     dprintf(2, "[Resuming fromtid = %ld, tid = %ld, pid = %d, count = %d]\n",
             pthread_self(), tid->sys_thread, tid->lwp_id, count);
 #endif
     if (count == 0) {
         if (tid->selfsuspended) {
             tid->selfsuspended = 0;
             sem_post(&tid->sem_selfsuspend);
         } else {
             sr_tid = tid;
             ret = pthread_kill(tid->sys_thread, sr_sigresu);
         }
 #ifdef LOG_THREADS
         dprintf(2, "[Resumed fromtid = %ld, pthread_kill(%ld, %d) = %d]\n",
                 pthread_self(), tid->sys_thread, sr_sigresu, ret);
 #endif
     } else if (count < 0) {
         /* Ignore attempts to resume a thread that has not been suspended */
         tid->suspend_count = 0;
     }

      err = mutexUnlock(&sr_lock);
      sysAssert(err == 0);

      return ret == 0 ? SYS_OK : SYS_ERR;
 }

 /*
  * Get the stack base and size.
  */
 int
 np_stackinfo(void **addr, long *size)
 {
     /* For now assume stack is 2 meg, from internals.h. */
 #define STACK_SIZE (2 * 1024 * 1024)
     void *p;
     char *sp = (char *)&p;  /* rougly %esp */

     *addr = (void *)(((unsigned long)sp | (STACK_SIZE-1))+1) - 1;
     *size = STACK_SIZE;

     return SYS_OK;
 }

 typedef unsigned long ulong_t;
 #define VALID_SP(sp, bottom, top) \
        (((ulong_t)(sp)) < ((ulong_t)(bottom)) && ((ulong_t)(sp)) > ((ulong_t)(top)))

 /*
  * Go into single threaded mode for GC.
  */
 int
 np_single()
 {
     sys_thread_t *tid;
     pthread_t me = pthread_self();
     int i;

 #ifdef LOG_THREADS
     dprintf(2, "[Entering np_single: thread count = %d]\n", ActiveThreadCount);
 #endif
     /* Stop all other threads. */
     tid = ThreadQueue;
     for (i = 0; i < ActiveThreadCount && tid != 0; i++) {
         if ((tid->sys_thread != me) && (tid->state != SUSPENDED)) {
             np_suspend(tid);
             sysAssert(VALID_SP(tid->sp, tid->stack_bottom, tid->stack_top));
             tid->onproc = FALSE; /* REMIND: Might not need this */
         }
         tid = tid->next;
     }
 #ifdef LOG_THREADS
     dprintf(2, "[Leaving np_single]\n");
 #endif
     return SYS_OK;
 }

 /*
  * Per thread initialization.
  */
 void
 np_initialize_thread(sys_thread_t *tid)
 {
     sigset_t set;

     /* Block SIGQUIT so that it can be handled by the SIGQUIT handler thread */
     sigemptyset(&set);
     sigaddset(&set, SIGQUIT);
     pthread_sigmask(SIG_BLOCK, &set, 0);
     /* Set process id */
     tid->lwp_id = getpid();
     tid->suspend_count = 0;

     /* Semaphore used for self-suspension */
     sem_init(&tid->sem_selfsuspend, 0, 0);
     tid->selfsuspended = 0;

 #ifdef LOG_THREADS
     dprintf(2, "[Init thread, tid = %ld, pid = %d, base = %p, size = %lu]\n",
             pthread_self(), tid->lwp_id, tid->stack_bottom, tid->stack_size);
 #endif
 }

 void
 np_free_thread(sys_thread_t *tid)
 {
     sem_destroy(&tid->sem_selfsuspend);
 }

 /*
  * Recover from single threaded mode after GC.
  */
 void
 np_multi()
 {
     int i;
     sys_thread_t *tid;
     pthread_t me = pthread_self();

     tid = ThreadQueue;
     for (i = 0; i < ActiveThreadCount && tid != 0; i++) {
         if ((tid->sys_thread != me) && (tid->state != SUSPENDED)) {
             np_continue(tid);
         }
         tid = tid->next;
     }
 }

 void
 np_profiler_init(sys_thread_t *tid)
 {
 }

 int
 np_profiler_suspend(sys_thread_t *tid)
 {
     return np_suspend(tid);
 }

 int
 np_profiler_continue(sys_thread_t *tid)
 {
     return np_continue(tid);
 }

 bool_t
 np_profiler_thread_is_running(sys_thread_t *tid)
 {
     return TRUE;
 }
	/*
	* Copyright (c) 1999, 2000, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	/*
	* Implementation of notposix.h on Linux.
	*/

	#include <pthread.h>
	#include <signal.h>
	#include <string.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <fcntl.h>
	#include <time.h>

	#include "hpi_impl.h"
	#include "monitor_md.h"
	#include "threads_md.h"
	#include "np.h"

	#undef LOG_THREADS

	/* Global lock used when calling np_suspend and np_resume */
	static pthread_mutex_t sr_lock;

	/* Semaphore used to acknowledge when the handler has received HANDLER_SIG */
	static sem_t sr_sem;

	/* The tid of the thread being suspended/resumed */
	static sys_thread_t *sr_tid;

	int sr_sigsusp;
	int sr_sigresu;

	static void prtsigset(char s, sigset_t set)
	{
	int sig;
	dprintf(2, "%s:", s);
	for (sig = 1; sig < _NSIG; sig++) {
	if (sigismember(set, sig)) {
	dprintf(2, " %d", sig);
	}
	}
	dprintf(2, "\n");
	}

	/*
	* Handler function invoked when a thread's execution is suspended
	* We have to be careful that only async-safe functions are
	* called here. I'm not even sure if calling sysThreadSelf is safe so
	* we temporarily stash SP in a global variable instead.
	*/
	static void
	#ifdef SA_SIGINFO
	susp_handler(int sig, siginfo_t* info, void* arg)
	#else
	susp_handler(int sig)
	#endif
	{
	sys_thread_t *tid = sr_tid;
	sigset_t set;
	/* Save the current SP */
	tid->sp = &tid;
	sem_post(&sr_sem);
	sigfillset(&set);
	sigdelset(&set,(sr_sigresu));
	/* block until we receive resume signal. */
	sigsuspend(&set);
	}

	static void
	#ifdef SA_SIGINFO
	resu_handler(int sig, siginfo_t* info, void* arg)
	#else
	resu_handler(int sig)
	#endif
	{
	return;
	}

	/*
	* Initialize signal handlers for suspend and resume}.
	*/
	int
	np_initialize()
	{
	struct sigaction act;
	char *s;
	int err;

	/* Signal numbers used to suspend and resume */
	#if __GLIBC__ == 2 && __GLIBC_MINOR__ == 0
	#ifdef SIGUNUSED
	sr_sigsusp = SIGUNUSED;
	#else
	sr_sigsusp = SIGLOST;
	#endif
	#ifdef SIGPWR
	sr_sigresu = SIGPWR;
	#else
	sr_sigresu = SIGXFSZ;
	#endif
	#else
	/* use real time signals */
	/* currently __SIGRTMIN, +1, +2 are all used by LinuxThreads */
	sr_sigsusp = SIGRTMIN + 3;
	sr_sigresu = SIGRTMIN + 4;
	#endif

	/* Set up signal handler for suspend and resume */
	#if defined(SA_SIGINFO) && !defined(__sparc__)
	act.sa_handler = 0;
	act.sa_sigaction = susp_handler;
	#else
	act.sa_handler = (__sighandler_t) susp_handler;
	#endif
	#ifdef SA_SIGINFO
	act.sa_flags = SA_RESTART \| SA_SIGINFO;
	#else
	act.sa_flags = SA_RESTART;
	#endif
	sigfillset(&act.sa_mask);
	if (sigaction(sr_sigsusp, &act, 0) == -1) {
	return -1;
	}
	#if defined(SA_SIGINFO) && !defined(__sparc__)
	act.sa_handler = 0;
	act.sa_sigaction = resu_handler;
	#else
	act.sa_handler = (__sighandler_t) resu_handler;
	#endif
	#ifdef SA_SIGINFO
	act.sa_flags = SA_SIGINFO;
	#else
	act.sa_flags = 0;
	#endif
	sigfillset(&act.sa_mask);
	if (sigaction(sr_sigresu, &act, 0) == -1) {
	return -1;
	}

	/* Initialize semaphore used by np_{suspend/resume} */
	if (sem_init(&sr_sem, 0, 0) == -1) {
	return SYS_ERR;
	}

	/* Initialize mutex used by np_{suspend/resume} */
	err = mutexInit(&sr_lock);
	sysAssert(err == 0);

	return SYS_OK;
	}

	int
	np_initial_suspend(sys_thread_t* tid)
	{
	int count;

	tid->selfsuspended = (tid == sysThreadSelf());
	sysAssert(tid->selfsuspended);

	count = tid->suspend_count++;
	sysAssert(count == 0);

	#ifdef LOG_THREADS
	dprintf(2,
	"[Initial self-suspend [tid = %ld, sys_thread = %ld]\n",
	pthread_self(), tid->sys_thread);
	#endif

	/* Order should not matter but doing the post first should be faster */
	sem_post(&tid->sem_suspended);
	do {
	sem_wait(&tid->sem_selfsuspend);
	} while (tid->selfsuspended); /* paranoid */
	return 0;
	}


	int
	np_suspend(sys_thread_t *tid)
	{
	int count, ret = 0;

	int err = mutexLock(&sr_lock);
	sysAssert(err == 0);

	tid->selfsuspended = (tid == sysThreadSelf());

	count = tid->suspend_count++;
	#ifdef LOG_THREADS
	dprintf(2, "[Suspending fromtid = %ld, tid = %ld, pid = %d, count = %d]\n",
	pthread_self(), tid->sys_thread, tid->lwp_id, count);
	#endif
	if (count == 0) {
	if (tid->selfsuspended) {
	#ifdef LOG_THREADS
	dprintf(2,
	"[Self-suspending [tid = %ld, sys_thread = %ld]\n",
	pthread_self(), tid->sys_thread);
	#endif
	mutexUnlock(&sr_lock);
	do {
	sem_wait(&tid->sem_selfsuspend);
	} while (tid->selfsuspended);
	/* [jk] What is the correct return value here?
	There was no error, but when we return the thread
	has already been resumed. */
	return SYS_OK;

	} else {
	sr_tid = tid;
	ret = pthread_kill(tid->sys_thread, sr_sigsusp);
	if (ret == 0) {
	sem_wait(&sr_sem);
	}
	#ifdef LOG_THREADS
	dprintf(2,
	"[Suspended fromtid = %ld, pthread_kill(%ld, %d) = %d]\n",
	pthread_self(), tid->sys_thread, sr_sigsusp, ret);
	#endif
	}
	}

	err = mutexUnlock(&sr_lock);
	sysAssert(err == 0);

	return ret == 0 ? SYS_OK : SYS_ERR;
	}

	int
	np_continue(sys_thread_t *tid)
	{
	int count, ret = 0;

	int err = mutexLock(&sr_lock);
	sysAssert(err == 0);

	count = --tid->suspend_count;
	#ifdef LOG_THREADS
	dprintf(2, "[Resuming fromtid = %ld, tid = %ld, pid = %d, count = %d]\n",
	pthread_self(), tid->sys_thread, tid->lwp_id, count);
	#endif
	if (count == 0) {
	if (tid->selfsuspended) {
	tid->selfsuspended = 0;
	sem_post(&tid->sem_selfsuspend);
	} else {
	sr_tid = tid;
	ret = pthread_kill(tid->sys_thread, sr_sigresu);
	}
	#ifdef LOG_THREADS
	dprintf(2, "[Resumed fromtid = %ld, pthread_kill(%ld, %d) = %d]\n",
	pthread_self(), tid->sys_thread, sr_sigresu, ret);
	#endif
	} else if (count < 0) {
	/* Ignore attempts to resume a thread that has not been suspended */
	tid->suspend_count = 0;
	}

	err = mutexUnlock(&sr_lock);
	sysAssert(err == 0);

	return ret == 0 ? SYS_OK : SYS_ERR;
	}

	/*
	* Get the stack base and size.
	*/
	int
	np_stackinfo(void *addr, long size)
	{
	/* For now assume stack is 2 meg, from internals.h. */
	#define STACK_SIZE (2 * 1024 * 1024)
	void *p;
	char sp = (char )&p; /* rougly %esp */

	addr = (void )(((unsigned long)sp \| (STACK_SIZE-1))+1) - 1;
	*size = STACK_SIZE;

	return SYS_OK;
	}

	typedef unsigned long ulong_t;
	#define VALID_SP(sp, bottom, top) \
	(((ulong_t)(sp)) < ((ulong_t)(bottom)) && ((ulong_t)(sp)) > ((ulong_t)(top)))

	/*
	* Go into single threaded mode for GC.
	*/
	int
	np_single()
	{
	sys_thread_t *tid;
	pthread_t me = pthread_self();
	int i;

	#ifdef LOG_THREADS
	dprintf(2, "[Entering np_single: thread count = %d]\n", ActiveThreadCount);
	#endif
	/* Stop all other threads. */
	tid = ThreadQueue;
	for (i = 0; i < ActiveThreadCount && tid != 0; i++) {
	if ((tid->sys_thread != me) && (tid->state != SUSPENDED)) {
	np_suspend(tid);
	sysAssert(VALID_SP(tid->sp, tid->stack_bottom, tid->stack_top));
	tid->onproc = FALSE; /* REMIND: Might not need this */
	}
	tid = tid->next;
	}
	#ifdef LOG_THREADS
	dprintf(2, "[Leaving np_single]\n");
	#endif
	return SYS_OK;
	}

	/*
	* Per thread initialization.
	*/
	void
	np_initialize_thread(sys_thread_t *tid)
	{
	sigset_t set;

	/* Block SIGQUIT so that it can be handled by the SIGQUIT handler thread */
	sigemptyset(&set);
	sigaddset(&set, SIGQUIT);
	pthread_sigmask(SIG_BLOCK, &set, 0);
	/* Set process id */
	tid->lwp_id = getpid();
	tid->suspend_count = 0;

	/* Semaphore used for self-suspension */
	sem_init(&tid->sem_selfsuspend, 0, 0);
	tid->selfsuspended = 0;

	#ifdef LOG_THREADS
	dprintf(2, "[Init thread, tid = %ld, pid = %d, base = %p, size = %lu]\n",
	pthread_self(), tid->lwp_id, tid->stack_bottom, tid->stack_size);
	#endif
	}

	void
	np_free_thread(sys_thread_t *tid)
	{
	sem_destroy(&tid->sem_selfsuspend);
	}

	/*
	* Recover from single threaded mode after GC.
	*/
	void
	np_multi()
	{
	int i;
	sys_thread_t *tid;
	pthread_t me = pthread_self();

	tid = ThreadQueue;
	for (i = 0; i < ActiveThreadCount && tid != 0; i++) {
	if ((tid->sys_thread != me) && (tid->state != SUSPENDED)) {
	np_continue(tid);
	}
	tid = tid->next;
	}
	}

	void
	np_profiler_init(sys_thread_t *tid)
	{
	}

	int
	np_profiler_suspend(sys_thread_t *tid)
	{
	return np_suspend(tid);
	}

	int
	np_profiler_continue(sys_thread_t *tid)
	{
	return np_continue(tid);
	}

	bool_t
	np_profiler_thread_is_running(sys_thread_t *tid)
	{
	return TRUE;
	}