src/thread/pthread/SDL_systhread.c
author Ryan C. Gordon
Tue, 24 Jan 2017 16:18:25 -0500
changeset 10850 c9dc0068b0e7
parent 10737 3406a0f8b041
child 10983 9f9160df4f1f
permissions -rw-r--r--
configure: report libsamplerate support status.
     1 /*
     2   Simple DirectMedia Layer
     3   Copyright (C) 1997-2017 Sam Lantinga <slouken@libsdl.org>
     4 
     5   This software is provided 'as-is', without any express or implied
     6   warranty.  In no event will the authors be held liable for any damages
     7   arising from the use of this software.
     8 
     9   Permission is granted to anyone to use this software for any purpose,
    10   including commercial applications, and to alter it and redistribute it
    11   freely, subject to the following restrictions:
    12 
    13   1. The origin of this software must not be misrepresented; you must not
    14      claim that you wrote the original software. If you use this software
    15      in a product, an acknowledgment in the product documentation would be
    16      appreciated but is not required.
    17   2. Altered source versions must be plainly marked as such, and must not be
    18      misrepresented as being the original software.
    19   3. This notice may not be removed or altered from any source distribution.
    20 */
    21 
    22 #include "../../SDL_internal.h"
    23 
    24 #include <pthread.h>
    25 
    26 #if HAVE_PTHREAD_NP_H
    27 #include <pthread_np.h>
    28 #endif
    29 
    30 #include <signal.h>
    31 
    32 #ifdef __LINUX__
    33 #include <sys/time.h>
    34 #include <sys/resource.h>
    35 #include <sys/syscall.h>
    36 #include <unistd.h>
    37 #endif /* __LINUX__ */
    38 
    39 #if defined(__LINUX__) || defined(__MACOSX__) || defined(__IPHONEOS__)
    40 #include <dlfcn.h>
    41 #ifndef RTLD_DEFAULT
    42 #define RTLD_DEFAULT NULL
    43 #endif
    44 #endif
    45 
    46 #include "SDL_platform.h"
    47 #include "SDL_thread.h"
    48 #include "../SDL_thread_c.h"
    49 #include "../SDL_systhread.h"
    50 #ifdef __ANDROID__
    51 #include "../../core/android/SDL_android.h"
    52 #endif
    53 
    54 #ifdef __HAIKU__
    55 #include <be/kernel/OS.h>
    56 #endif
    57 
    58 #include "SDL_assert.h"
    59 
    60 #ifndef __NACL__
    61 /* List of signals to mask in the subthreads */
    62 static const int sig_list[] = {
    63     SIGHUP, SIGINT, SIGQUIT, SIGPIPE, SIGALRM, SIGTERM, SIGCHLD, SIGWINCH,
    64     SIGVTALRM, SIGPROF, 0
    65 };
    66 #endif
    67 
    68 static void *
    69 RunThread(void *data)
    70 {
    71 #ifdef __ANDROID__
    72     Android_JNI_SetupThread();
    73 #endif
    74     SDL_RunThread(data);
    75     return NULL;
    76 }
    77 
    78 #if defined(__MACOSX__) || defined(__IPHONEOS__)
    79 static SDL_bool checked_setname = SDL_FALSE;
    80 static int (*ppthread_setname_np)(const char*) = NULL;
    81 #elif defined(__LINUX__)
    82 static SDL_bool checked_setname = SDL_FALSE;
    83 static int (*ppthread_setname_np)(pthread_t, const char*) = NULL;
    84 #endif
    85 int
    86 SDL_SYS_CreateThread(SDL_Thread * thread, void *args)
    87 {
    88     pthread_attr_t type;
    89 
    90     /* do this here before any threads exist, so there's no race condition. */
    91     #if defined(__MACOSX__) || defined(__IPHONEOS__) || defined(__LINUX__)
    92     if (!checked_setname) {
    93         void *fn = dlsym(RTLD_DEFAULT, "pthread_setname_np");
    94         #if defined(__MACOSX__) || defined(__IPHONEOS__)
    95         ppthread_setname_np = (int(*)(const char*)) fn;
    96         #elif defined(__LINUX__)
    97         ppthread_setname_np = (int(*)(pthread_t, const char*)) fn;
    98         #endif
    99         checked_setname = SDL_TRUE;
   100     }
   101     #endif
   102 
   103     /* Set the thread attributes */
   104     if (pthread_attr_init(&type) != 0) {
   105         return SDL_SetError("Couldn't initialize pthread attributes");
   106     }
   107     pthread_attr_setdetachstate(&type, PTHREAD_CREATE_JOINABLE);
   108     
   109     /* Set caller-requested stack size. Otherwise: use the system default. */
   110     if (thread->stacksize) {
   111         pthread_attr_setstacksize(&type, (size_t) thread->stacksize);
   112     }
   113 
   114     /* Create the thread and go! */
   115     if (pthread_create(&thread->handle, &type, RunThread, args) != 0) {
   116         return SDL_SetError("Not enough resources to create thread");
   117     }
   118 
   119     return 0;
   120 }
   121 
   122 void
   123 SDL_SYS_SetupThread(const char *name)
   124 {
   125 #if !defined(__NACL__)
   126     int i;
   127     sigset_t mask;
   128 #endif /* !__NACL__ */
   129 
   130     if (name != NULL) {
   131         #if defined(__MACOSX__) || defined(__IPHONEOS__) || defined(__LINUX__)
   132         SDL_assert(checked_setname);
   133         if (ppthread_setname_np != NULL) {
   134             #if defined(__MACOSX__) || defined(__IPHONEOS__)
   135             ppthread_setname_np(name);
   136             #elif defined(__LINUX__)
   137             ppthread_setname_np(pthread_self(), name);
   138             #endif
   139         }
   140         #elif HAVE_PTHREAD_SETNAME_NP
   141             #if defined(__NETBSD__)
   142             pthread_setname_np(pthread_self(), "%s", name);
   143             #else
   144             pthread_setname_np(pthread_self(), name);
   145             #endif
   146         #elif HAVE_PTHREAD_SET_NAME_NP
   147             pthread_set_name_np(pthread_self(), name);
   148         #elif defined(__HAIKU__)
   149             /* The docs say the thread name can't be longer than B_OS_NAME_LENGTH. */
   150             char namebuf[B_OS_NAME_LENGTH];
   151             SDL_snprintf(namebuf, sizeof (namebuf), "%s", name);
   152             namebuf[sizeof (namebuf) - 1] = '\0';
   153             rename_thread(find_thread(NULL), namebuf);
   154         #endif
   155     }
   156 
   157    /* NativeClient does not yet support signals.*/
   158 #if !defined(__NACL__)
   159     /* Mask asynchronous signals for this thread */
   160     sigemptyset(&mask);
   161     for (i = 0; sig_list[i]; ++i) {
   162         sigaddset(&mask, sig_list[i]);
   163     }
   164     pthread_sigmask(SIG_BLOCK, &mask, 0);
   165 #endif /* !__NACL__ */
   166 
   167 
   168 #ifdef PTHREAD_CANCEL_ASYNCHRONOUS
   169     /* Allow ourselves to be asynchronously cancelled */
   170     {
   171         int oldstate;
   172         pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &oldstate);
   173     }
   174 #endif
   175 }
   176 
   177 SDL_threadID
   178 SDL_ThreadID(void)
   179 {
   180     return ((SDL_threadID) pthread_self());
   181 }
   182 
   183 int
   184 SDL_SYS_SetThreadPriority(SDL_ThreadPriority priority)
   185 {
   186 #if __NACL__ 
   187     /* FIXME: Setting thread priority does not seem to be supported in NACL */
   188     return 0;
   189 #elif __LINUX__
   190     int value;
   191 
   192     if (priority == SDL_THREAD_PRIORITY_LOW) {
   193         value = 19;
   194     } else if (priority == SDL_THREAD_PRIORITY_HIGH) {
   195         value = -20;
   196     } else {
   197         value = 0;
   198     }
   199     if (setpriority(PRIO_PROCESS, syscall(SYS_gettid), value) < 0) {
   200         /* Note that this fails if you're trying to set high priority
   201            and you don't have root permission. BUT DON'T RUN AS ROOT!
   202 
   203            You can grant the ability to increase thread priority by
   204            running the following command on your application binary:
   205                sudo setcap 'cap_sys_nice=eip' <application>
   206          */
   207         return SDL_SetError("setpriority() failed");
   208     }
   209     return 0;
   210 #else
   211     struct sched_param sched;
   212     int policy;
   213     pthread_t thread = pthread_self();
   214 
   215     if (pthread_getschedparam(thread, &policy, &sched) < 0) {
   216         return SDL_SetError("pthread_getschedparam() failed");
   217     }
   218     if (priority == SDL_THREAD_PRIORITY_LOW) {
   219         sched.sched_priority = sched_get_priority_min(policy);
   220     } else if (priority == SDL_THREAD_PRIORITY_HIGH) {
   221         sched.sched_priority = sched_get_priority_max(policy);
   222     } else {
   223         int min_priority = sched_get_priority_min(policy);
   224         int max_priority = sched_get_priority_max(policy);
   225         sched.sched_priority = (min_priority + (max_priority - min_priority) / 2);
   226     }
   227     if (pthread_setschedparam(thread, policy, &sched) < 0) {
   228         return SDL_SetError("pthread_setschedparam() failed");
   229     }
   230     return 0;
   231 #endif /* linux */
   232 }
   233 
   234 void
   235 SDL_SYS_WaitThread(SDL_Thread * thread)
   236 {
   237     pthread_join(thread->handle, 0);
   238 }
   239 
   240 void
   241 SDL_SYS_DetachThread(SDL_Thread * thread)
   242 {
   243     pthread_detach(thread->handle);
   244 }
   245 
   246 /* vi: set ts=4 sw=4 expandtab: */