libjack/thread.c

   1 /*
   2   Copyright (C) 2004 Paul Davis
   3
   4   This program is free software; you can redistribute it and/or modify
   5   it under the terms of the GNU Lesser General Public License as published by
   6   the Free Software Foundation; either version 2.1 of the License, or
   7   (at your option) any later version.
   8
   9   This program is distributed in the hope that it will be useful,
  10   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12   GNU Lesser General Public License for more details.
  13
  14   You should have received a copy of the GNU Lesser General Public License
  15   along with this program; if not, write to the Free Software
  16   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  17
  18   Thread creation function including workarounds for real-time scheduling
  19   behaviour on different glibc versions.
  20
  21
  22 */
  23
  24 #include <config.h>
  25
  26 #include <jack/jack.h>
  27 #include <jack/thread.h>
  28 #include <jack/internal.h>
  29
  30 #include <pthread.h>
  31 #include <sched.h>
  32 #include <stdio.h>
  33 #include <string.h>
  34 #include <errno.h>
  35
  36 #include "local.h"
  37
  38 #ifdef JACK_USE_MACH_THREADS
  39 #include <sysdeps/pThreadUtilities.h>
  40 #endif
  41
  42 static inline void
  43 log_result (char *msg, int res)
  44 {
  45         char outbuf[500];
  46         snprintf(outbuf, sizeof(outbuf),
  47                  "jack_client_create_thread: error %d %s: %s",
  48                  res, msg, strerror(res));
  49         jack_error(outbuf);
  50 }
  51
  52 static void
  53 maybe_get_capabilities (jack_client_t* client)
  54 {
  55 #ifdef USE_CAPABILITIES
  56
  57         if (client != 0) {
  58
  59                 jack_request_t req;
  60
  61                 if (client->engine->has_capabilities != 0) {
  62
  63                         /* we need to ask the engine for realtime capabilities
  64                            before trying to run the thread work function
  65                         */
  66
  67                         req.type = SetClientCapabilities;
  68                         req.x.cap_pid = getpid();
  69
  70                         jack_client_deliver_request (client, &req);
  71
  72                         if (req.status) {
  73
  74                                 /* what to do? engine is running realtime, it
  75                                    is using capabilities and has them
  76                                    (otherwise we would not get an error
  77                                    return) but for some reason it could not
  78                                    give the client the required capabilities.
  79                                    for now, allow the client to run, albeit
  80                                    non-realtime.
  81                                 */
  82
  83                                 jack_error ("could not receive realtime capabilities, "
  84                                             "client will run non-realtime");
  85
  86                         }
  87                 }
  88         }
  89 #endif /* USE_CAPABILITIES */
  90 }
  91
  92 static void*
  93 jack_thread_proxy (void* varg)
  94 {
  95         jack_thread_arg_t* arg = (jack_thread_arg_t*) varg;
  96         void* (*work)(void*);
  97         void* warg;
  98         jack_client_t* client = arg->client;
  99
 100         if (arg->realtime) {
 101                 maybe_get_capabilities (client);
 102                 jack_acquire_real_time_scheduling (pthread_self(), arg->priority);
 103         }
 104
 105         warg = arg->arg;
 106         work = arg->work_function;
 107
 108         free (arg);
 109
 110         return work (warg);
 111 }
 112
 113 int
 114 jack_client_create_thread (jack_client_t* client,
 115                            pthread_t* thread,
 116                            int priority,
 117                            int realtime,
 118                            void*(*start_routine)(void*),
 119                            void* arg)
 120 {
 121 #ifndef JACK_USE_MACH_THREADS
 122         pthread_attr_t attr;
 123         jack_thread_arg_t* thread_args;
 124 #endif /* !JACK_USE_MACH_THREADS */
 125
 126         int result = 0;
 127
 128         if (!realtime) {
 129                 result = pthread_create (thread, 0, start_routine, arg);
 130                 if (result) {
 131                         log_result("creating thread with default parameters",
 132                                    result);
 133                 }
 134                 return result;
 135         }
 136
 137         /* realtime thread. this disgusting mess is a reflection of
 138          * the 2nd-class nature of RT programming under POSIX in
 139          * general and Linux in particular.
 140          */
 141
 142 #ifndef JACK_USE_MACH_THREADS
 143
 144         pthread_attr_init(&attr);
 145         result = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
 146         if (result) {
 147                 log_result("requesting explicit scheduling", result);
 148                 return result;
 149         }
 150         result = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
 151         if (result) {
 152                 log_result("requesting joinable thread creation", result);
 153                 return result;
 154         }
 155 #ifdef __OpenBSD__
 156         result = pthread_attr_setscope(&attr, PTHREAD_SCOPE_PROCESS);
 157 #else
 158         result = pthread_attr_setscope(&attr, PTHREAD_SCOPE_SYSTEM);
 159 #endif
 160         if (result) {
 161                 log_result("requesting system scheduling scope", result);
 162                 return result;
 163         }
 164
 165         result = pthread_attr_setstacksize(&attr, THREAD_STACK);
 166         if (result) {
 167                 log_result("setting thread stack size", result);
 168                 return result;
 169         }
 170
 171         thread_args = (jack_thread_arg_t *) malloc (sizeof (jack_thread_arg_t));
 172
 173         thread_args->client = client;
 174         thread_args->work_function = start_routine;
 175         thread_args->arg = arg;
 176         thread_args->realtime = 1;
 177         thread_args->priority = priority;
 178
 179         result = pthread_create (thread, &attr, jack_thread_proxy, thread_args);
 180         if (result) {
 181                 log_result ("creating realtime thread", result);
 182                 return result;
 183         }
 184
 185 #else /* JACK_USE_MACH_THREADS */
 186
 187         result = pthread_create (thread, 0, start_routine, arg);
 188         if (result) {
 189                 log_result ("creating realtime thread", result);
 190                 return result;
 191         }
 192
 193         /* time constraint thread */
 194         setThreadToPriority (*thread, 96, TRUE, 10000000);
 195
 196 #endif /* JACK_USE_MACH_THREADS */
 197
 198         return 0;
 199 }
 200
 201 int
 202 jack_client_real_time_priority (jack_client_t* client)
 203 {
 204         if (!client->engine->real_time) {
 205                 return -1;
 206         }
 207
 208         return client->engine->client_priority;
 209 }
 210
 211 int
 212 jack_client_max_real_time_priority (jack_client_t* client)
 213 {
 214         if (!client->engine->real_time) {
 215                 return -1;
 216         }
 217
 218         return client->engine->max_client_priority;
 219 }
 220
 221 #if JACK_USE_MACH_THREADS
 222
 223 int
 224 jack_drop_real_time_scheduling (pthread_t thread)
 225 {
 226         setThreadToPriority(thread, 31, FALSE, 10000000);
 227         return 0;
 228 }
 229
 230 int
 231 jack_acquire_real_time_scheduling (pthread_t thread, int priority)
 232         //priority is unused
 233 {
 234         setThreadToPriority(thread, 96, TRUE, 10000000);
 235         return 0;
 236 }
 237
 238 #else /* !JACK_USE_MACH_THREADS */
 239
 240 int
 241 jack_drop_real_time_scheduling (pthread_t thread)
 242 {
 243         struct sched_param rtparam;
 244         int x;
 245
 246         memset (&rtparam, 0, sizeof (rtparam));
 247         rtparam.sched_priority = 0;
 248
 249         if ((x = pthread_setschedparam (thread, SCHED_OTHER, &rtparam)) != 0) {
 250                 jack_error ("cannot switch to normal scheduling priority(%s)\n",
 251                             strerror (errno));
 252                 return -1;
 253         }
 254         return 0;
 255 }
 256
 257 int
 258 jack_acquire_real_time_scheduling (pthread_t thread, int priority)
 259 {
 260         struct sched_param rtparam;
 261         int x;
 262
 263         memset (&rtparam, 0, sizeof (rtparam));
 264         rtparam.sched_priority = priority;
 265
 266         if ((x = pthread_setschedparam (thread, SCHED_FIFO, &rtparam)) != 0) {
 267                 jack_error ("cannot use real-time scheduling (FIFO at priority %d) "
 268                             "[for thread %d, from thread %d] (%d: %s)",
 269                             rtparam.sched_priority,
 270                             thread, pthread_self(),
 271                             x, strerror (x));
 272                 return -1;
 273         }
 274
 275         return 0;
 276 }
 277
 278 #endif /* JACK_USE_MACH_THREADS */
 279