sysdeps/mach/hurd/profil.c

   1 /* Low-level statistical profiling support function.  Mach/Hurd version.
   2    Copyright (C) 1995-2015 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, see
  17    <http://www.gnu.org/licenses/>.  */
  18
  19 #include <sys/types.h>
  20 #include <unistd.h>
  21 #include <errno.h>
  22 #include <hurd.h>
  23 #include <mach/mach4.h>
  24 #include <mach/pc_sample.h>
  25 #include <cthreads.h>
  26 #include <assert.h>
  27 #include <libc-internal.h>
  28
  29
  30 #define MAX_PC_SAMPLES  512     /* XXX ought to be exported in kernel hdr */
  31
  32 static thread_t profile_thread = MACH_PORT_NULL;
  33 static u_short *samples;
  34 static size_t maxsamples;
  35 static size_t pc_offset;
  36 static size_t sample_scale;
  37 static sampled_pc_seqno_t seqno;
  38 static spin_lock_t lock = SPIN_LOCK_INITIALIZER;
  39 static mach_msg_timeout_t collector_timeout; /* ms between collections.  */
  40 static int profile_tick;
  41
  42 /* Reply port used by profiler thread */
  43 static mach_port_t profil_reply_port;
  44
  45 /* Forwards */
  46 static kern_return_t profil_task_get_sampled_pcs (mach_port_t,
  47                                                   sampled_pc_seqno_t *,
  48                                                   sampled_pc_array_t,
  49                                                   mach_msg_type_number_t *);
  50 static void fetch_samples (void);
  51 static void profile_waiter (void);
  52
  53 /* Enable statistical profiling, writing samples of the PC into at most
  54    SIZE bytes of SAMPLE_BUFFER; every processor clock tick while profiling
  55    is enabled, the system examines the user PC and increments
  56    SAMPLE_BUFFER[((PC - OFFSET) / 2) * SCALE / 65536].  If SCALE is zero,
  57    disable profiling.  Returns zero on success, -1 on error.  */
  58
  59 static error_t
  60 update_waiter (u_short *sample_buffer, size_t size, size_t offset, u_int scale)
  61 {
  62   error_t err;
  63
  64   if (profile_thread == MACH_PORT_NULL)
  65     {
  66       /* Set up the profiling collector thread.  */
  67       err = __thread_create (__mach_task_self (), &profile_thread);
  68       if (! err)
  69         err = __mach_setup_thread (__mach_task_self (), profile_thread,
  70                                    &profile_waiter, NULL, NULL);
  71     }
  72   else
  73     err = 0;
  74
  75   if (! err)
  76     {
  77       err = __task_enable_pc_sampling (__mach_task_self (), &profile_tick,
  78                                        SAMPLED_PC_PERIODIC);
  79       if (!err && sample_scale == 0)
  80         /* Profiling was not turned on, so the collector thread was
  81            suspended.  Resume it.  */
  82         err = __thread_resume (profile_thread);
  83       if (! err)
  84         {
  85           samples = sample_buffer;
  86           maxsamples = size / sizeof *sample_buffer;
  87           pc_offset = offset;
  88           sample_scale = scale;
  89           /* Calculate a good period for the collector thread.  From TICK
  90              and the kernel buffer size we get the length of time it takes
  91              to fill the buffer; translate that to milliseconds for
  92              mach_msg, and chop it in half for general lag factor.  */
  93           collector_timeout = MAX_PC_SAMPLES * profile_tick / 1000 / 2;
  94         }
  95     }
  96
  97   return err;
  98 }
  99
 100 int
 101 __profile_frequency (void)
 102 {
 103   return profile_tick;
 104 }
 105 libc_hidden_def (__profile_frequency)
 106
 107 int
 108 __profil (u_short *sample_buffer, size_t size, size_t offset, u_int scale)
 109 {
 110   error_t err;
 111
 112   __spin_lock (&lock);
 113
 114   if (scale == 0)
 115     {
 116       /* Disable profiling.  */
 117       int count;
 118
 119       if (profile_thread != MACH_PORT_NULL)
 120         __thread_suspend (profile_thread);
 121
 122       /* Fetch the last set of samples */
 123       if (sample_scale)
 124         fetch_samples ();
 125
 126       err = __task_disable_pc_sampling (__mach_task_self (), &count);
 127       sample_scale = 0;
 128       seqno = 0;
 129     }
 130   else
 131     err = update_waiter (sample_buffer, size, offset, scale);
 132
 133   __spin_unlock (&lock);
 134
 135   return err ? __hurd_fail (err) : 0;
 136 }
 137 weak_alias (__profil, profil)
 138
 139 /* Fetch PC samples.  This function must be very careful not to depend
 140    on Hurd threadvar variables.  We arrange that by using a special
 141    stub arranged for at the end of this file. */
 142 static void
 143 fetch_samples (void)
 144 {
 145   sampled_pc_t pc_samples[MAX_PC_SAMPLES];
 146   mach_msg_type_number_t nsamples, i;
 147   error_t err;
 148
 149   nsamples = MAX_PC_SAMPLES;
 150
 151   err = profil_task_get_sampled_pcs (__mach_task_self (), &seqno,
 152                                      pc_samples, &nsamples);
 153   if (err)
 154     {
 155       static error_t special_profil_failure;
 156       static volatile int a, b, c;
 157
 158       special_profil_failure = err;
 159       a = 1;
 160       b = 0;
 161       while (1)
 162         c = a / b;
 163     }
 164
 165   for (i = 0; i < nsamples; ++i)
 166     {
 167       /* Do arithmetic in long long to avoid overflow problems. */
 168       long long pc_difference = pc_samples[i].pc - pc_offset;
 169       size_t idx = ((pc_difference / 2) * sample_scale) / 65536;
 170       if (idx < maxsamples)
 171         ++samples[idx];
 172     }
 173 }
 174
 175
 176 /* This function must be very careful not to depend on Hurd threadvar
 177    variables.  We arrange that by using special stubs arranged for at the
 178    end of this file. */
 179 static void
 180 profile_waiter (void)
 181 {
 182   mach_msg_header_t msg;
 183   mach_port_t timeout_reply_port;
 184
 185   profil_reply_port = __mach_reply_port ();
 186   timeout_reply_port = __mach_reply_port ();
 187
 188   while (1)
 189     {
 190       __spin_lock (&lock);
 191
 192       fetch_samples ();
 193
 194       __spin_unlock (&lock);
 195
 196       __mach_msg (&msg, MACH_RCV_MSG|MACH_RCV_TIMEOUT, 0, sizeof msg,
 197                   timeout_reply_port, collector_timeout, MACH_PORT_NULL);
 198     }
 199 }
 200 \f
 201 /* Fork interaction */
 202
 203 /* Before fork, lock the interlock so that we are in a clean state. */
 204 static void
 205 fork_profil_prepare (void)
 206 {
 207   __spin_lock (&lock);
 208 }
 209 text_set_element (_hurd_fork_prepare_hook, fork_profil_prepare);
 210
 211 /* In the parent, unlock the interlock once fork is complete. */
 212 static void
 213 fork_profil_parent (void)
 214 {
 215   __spin_unlock (&lock);
 216 }
 217 text_set_element (_hurd_fork_parent_hook, fork_profil_parent);
 218
 219 /* In the child, unlock the interlock, and start a profiling thread up
 220    if necessary. */
 221 static void
 222 fork_profil_child (void)
 223 {
 224   u_short *sb;
 225   size_t n, o, ss;
 226   error_t err;
 227
 228   __spin_unlock (&lock);
 229
 230   if (profile_thread != MACH_PORT_NULL)
 231     {
 232       __mach_port_deallocate (__mach_task_self (), profile_thread);
 233       profile_thread = MACH_PORT_NULL;
 234     }
 235
 236   sb = samples;
 237   samples = NULL;
 238   n = maxsamples;
 239   maxsamples = 0;
 240   o = pc_offset;
 241   pc_offset = 0;
 242   ss = sample_scale;
 243   sample_scale = 0;
 244
 245   if (ss != 0)
 246     {
 247       err = update_waiter (sb, n * sizeof *sb, o, ss);
 248       assert_perror (err);
 249     }
 250 }
 251 text_set_element (_hurd_fork_child_hook, fork_profil_child);
 252
 253
 254 \f
 255
 256 /* Special RPC stubs for profile_waiter are made by including the normal
 257    source code, with special CPP state to prevent it from doing the
 258    usual thing. */
 259
 260 /* Include these first; then our #define's will take full effect, not
 261    being overridden. */
 262 #include <mach/mig_support.h>
 263
 264 /* This need not do anything; it is always associated with errors, which
 265    are fatal in profile_waiter anyhow. */
 266 #define __mig_put_reply_port(foo)
 267
 268 /* Use our static variable instead of the usual threadvar mechanism for
 269    this. */
 270 #define __mig_get_reply_port() profil_reply_port
 271
 272 /* Make the functions show up as static */
 273 #define mig_external static
 274
 275 /* Turn off the attempt to generate ld aliasing records. */
 276 #undef weak_alias
 277 #define weak_alias(a,b)
 278
 279 /* And change their names to avoid confusing disasters. */
 280 #define __vm_deallocate_rpc profil_vm_deallocate
 281 #define __task_get_sampled_pcs profil_task_get_sampled_pcs
 282
 283 /* And include the source code */
 284 #include <../mach/RPC_task_get_sampled_pcs.c>