sysdeps/posix/sprofil.c

   1 /* Copyright (C) 2001-2024 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C Library is free software; you can redistribute it and/or
   5    modify it under the terms of the GNU Lesser General Public
   6    License as published by the Free Software Foundation; either
   7    version 2.1 of the License, or (at your option) any later version.
   8
   9    The GNU C Library 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 GNU
  12    Lesser General Public License for more details.
  13
  14    You should have received a copy of the GNU Lesser General Public
  15    License along with the GNU C Library; if not, see
  16    <https://www.gnu.org/licenses/>.  */
  17
  18 #include <assert.h>
  19 #include <signal.h>
  20 #include <stdlib.h>
  21 #include <string.h>
  22 #include <unistd.h>
  23 #include <sigsetops.h>
  24
  25 #include <sys/time.h>
  26 #include <sys/profil.h>
  27
  28 #ifndef SIGPROF
  29 # include <gmon/sprofil.c>
  30 #else
  31
  32 #include <libc-internal.h>
  33
  34 struct region
  35   {
  36     size_t offset;
  37     size_t nsamples;
  38     unsigned int scale;
  39     union
  40       {
  41         void *vp;
  42         unsigned short *us;
  43         unsigned int *ui;
  44       }
  45     sample;
  46     size_t start;
  47     size_t end;
  48   };
  49
  50 struct prof_info
  51   {
  52     unsigned int num_regions;
  53     struct region *region;
  54     struct region *last, *overflow;
  55     struct itimerval saved_timer;
  56     struct sigaction saved_action;
  57   };
  58
  59 static unsigned int overflow_counter;
  60
  61 static struct region default_overflow_region =
  62   {
  63     .offset     = 0,
  64     .nsamples   = 1,
  65     .scale      = 2,
  66     .sample     = { &overflow_counter },
  67     .start      = 0,
  68     .end        = ~(size_t) 0
  69   };
  70
  71 static struct prof_info prof_info;
  72
  73 static unsigned long int
  74 pc_to_index (size_t pc, size_t offset, unsigned int scale, int prof_uint)
  75 {
  76   size_t i = (pc - offset) / (prof_uint ? sizeof (int) : sizeof (short));
  77
  78   if (sizeof (unsigned long long int) > sizeof (size_t))
  79     return (unsigned long long int) i * scale / 65536;
  80   else
  81     return i / 65536 * scale + i % 65536 * scale / 65536;
  82 }
  83
  84 static inline size_t
  85 index_to_pc (unsigned long int n, size_t offset, unsigned int scale,
  86              int prof_uint)
  87 {
  88   size_t pc, bin_size = (prof_uint ? sizeof (int) : sizeof (short));
  89
  90   if (sizeof (unsigned long long int) > sizeof (size_t))
  91     pc = offset + (unsigned long long int) n * bin_size * 65536ull / scale;
  92   else
  93     pc = (offset + n * bin_size / scale * 65536
  94           + n * bin_size % scale * 65536 / scale);
  95
  96   if (pc_to_index (pc, offset, scale, prof_uint) < n)
  97     /* Adjust for rounding error.  */
  98     ++pc;
  99
 100   assert (pc_to_index (pc - 1, offset, scale, prof_uint) < n
 101           && pc_to_index (pc, offset, scale, prof_uint) >= n);
 102
 103   return pc;
 104 }
 105
 106 static void
 107 profil_count (uintptr_t pcp, int prof_uint)
 108 {
 109   struct region *region, *r = prof_info.last;
 110   size_t lo, hi, mid, pc = pcp;
 111   unsigned long int i;
 112
 113   /* Fast path: pc is in same region as before.  */
 114   if (pc >= r->start && pc < r->end)
 115     region = r;
 116   else
 117     {
 118       /* Slow path: do a binary search for the right region.  */
 119       lo = 0; hi = prof_info.num_regions - 1;
 120       while (lo <= hi)
 121         {
 122           mid = (lo + hi) / 2;
 123
 124           r = prof_info.region + mid;
 125           if (pc >= r->start && pc < r->end)
 126             {
 127               prof_info.last = r;
 128               region = r;
 129               break;
 130             }
 131
 132           if (pc < r->start)
 133             hi = mid - 1;
 134           else
 135             lo = mid + 1;
 136         }
 137
 138       /* No matching region: increment overflow count.  There is no point
 139          in updating the cache here, as it won't hit anyhow.  */
 140       region = prof_info.overflow;
 141     }
 142
 143   i = pc_to_index (pc, region->offset, region->scale, prof_uint);
 144   if (i < r->nsamples)
 145     {
 146       if (prof_uint)
 147         {
 148           if (r->sample.ui[i] < (unsigned int) ~0)
 149             ++r->sample.ui[i];
 150         }
 151       else
 152         {
 153           if (r->sample.us[i] < (unsigned short) ~0)
 154             ++r->sample.us[i];
 155         }
 156     }
 157   else
 158     {
 159       if (prof_uint)
 160         ++prof_info.overflow->sample.ui[0];
 161       else
 162         ++prof_info.overflow->sample.us[0];
 163     }
 164 }
 165
 166 /* Get the machine-dependent definition of `__profil_counter', the signal
 167    handler for SIGPROF.  It calls `profil_count' (above) with the PC of the
 168    interrupted code.  */
 169 #define __profil_counter        __profil_counter_ushort
 170 #define profil_count(pc)        profil_count (pc, 0)
 171 #include <profil-counter.h>
 172
 173 #undef __profil_counter
 174 #undef profil_count
 175
 176 #define __profil_counter        __profil_counter_uint
 177 #define profil_count(pc)        profil_count (pc, 1)
 178 #include <profil-counter.h>
 179
 180 static int
 181 insert (int i, unsigned long int start, unsigned long int end, struct prof *p,
 182         int prof_uint)
 183 {
 184   struct region *r;
 185   size_t to_copy;
 186
 187   if (start >= end)
 188     return 0;           /* don't bother with empty regions */
 189
 190   if (prof_info.num_regions == 0)
 191     r = malloc (sizeof (*r));
 192   else
 193     r = realloc (prof_info.region, (prof_info.num_regions + 1) * sizeof (*r));
 194   if (r == NULL)
 195     return -1;
 196
 197   to_copy = prof_info.num_regions - i;
 198   if (to_copy > 0)
 199     memmove (r + i + 1, r + i, to_copy * sizeof (*r));
 200
 201   r[i].offset = p->pr_off;
 202   r[i].nsamples = p->pr_size / (prof_uint ? sizeof (int) : sizeof (short));
 203   r[i].scale = p->pr_scale;
 204   r[i].sample.vp = p->pr_base;
 205   r[i].start = start;
 206   r[i].end = end;
 207
 208   prof_info.region = r;
 209   ++prof_info.num_regions;
 210
 211   if (p->pr_off == 0 && p->pr_scale == 2)
 212     prof_info.overflow = r;
 213
 214   return 0;
 215 }
 216
 217 /* Add a new profiling region.  If the new region overlaps with
 218    existing ones, this may add multiple subregions so that the final
 219    data structure is free of overlaps.  The absence of overlaps makes
 220    it possible to use a binary search in profil_count().  Note that
 221    this function depends on new regions being presented in DECREASING
 222    ORDER of starting address.  */
 223
 224 static int
 225 add_region (struct prof *p, int prof_uint)
 226 {
 227   unsigned long int nsamples;
 228   size_t start, end;
 229   unsigned int i;
 230
 231   if (p->pr_scale < 2)
 232     return 0;
 233
 234   nsamples = p->pr_size / (prof_uint ? sizeof (int) : sizeof (short));
 235
 236   start = p->pr_off;
 237   end = index_to_pc (nsamples, p->pr_off, p->pr_scale, prof_uint);
 238
 239   /* Merge with existing regions.  */
 240   for (i = 0; i < prof_info.num_regions; ++i)
 241     {
 242       if (start < prof_info.region[i].start)
 243         {
 244           if (end < prof_info.region[i].start)
 245             break;
 246           else if (insert (i, start, prof_info.region[i].start, p, prof_uint)
 247                    < 0)
 248             return -1;
 249         }
 250       start = prof_info.region[i].end;
 251     }
 252   return insert (i, start, end, p, prof_uint);
 253 }
 254
 255 static int
 256 pcmp (const void *left, const void *right)
 257 {
 258   struct prof *l = *(struct prof **) left;
 259   struct prof *r = *(struct prof **) right;
 260
 261   if (l->pr_off < r->pr_off)
 262     return 1;
 263   else if (l->pr_off > r->pr_off)
 264     return -1;
 265   return 0;
 266 }
 267
 268 int
 269 __sprofil (struct prof *profp, int profcnt, struct timeval *tvp,
 270            unsigned int flags)
 271 {
 272   struct prof *p[profcnt];
 273   struct itimerval timer;
 274   struct sigaction act;
 275   int i;
 276
 277   if (tvp != NULL)
 278     {
 279       /* Return profiling period.  */
 280       unsigned long int t = 1000000 / __profile_frequency ();
 281       tvp->tv_sec  = t / 1000000;
 282       tvp->tv_usec = t % 1000000;
 283     }
 284
 285   if (prof_info.num_regions > 0)
 286     {
 287       /* Disable profiling.  */
 288       if (__setitimer (ITIMER_PROF, &prof_info.saved_timer, NULL) < 0)
 289         return -1;
 290
 291       if (__sigaction (SIGPROF, &prof_info.saved_action, NULL) < 0)
 292         return -1;
 293
 294       free (prof_info.region);
 295       return 0;
 296     }
 297
 298   prof_info.num_regions = 0;
 299   prof_info.region = NULL;
 300   prof_info.overflow = &default_overflow_region;
 301
 302   for (i = 0; i < profcnt; ++i)
 303     p[i] = profp + i;
 304
 305   /* Sort in order of decreasing starting address: */
 306   qsort (p, profcnt, sizeof (p[0]), pcmp);
 307
 308   /* Add regions in order of decreasing starting address: */
 309   for (i = 0; i < profcnt; ++i)
 310     if (add_region (p[i], (flags & PROF_UINT) != 0) < 0)
 311       {
 312         free (prof_info.region);
 313         prof_info.num_regions = 0;
 314         prof_info.region = NULL;
 315         return -1;
 316       }
 317
 318   if (prof_info.num_regions == 0)
 319     return 0;
 320
 321   prof_info.last = prof_info.region;
 322
 323   /* Install SIGPROF handler.  */
 324 #ifdef SA_SIGINFO
 325   act.sa_sigaction= flags & PROF_UINT
 326                     ? __profil_counter_uint
 327                     : __profil_counter_ushort;
 328   act.sa_flags = SA_SIGINFO;
 329 #else
 330   act.sa_handler = flags & PROF_UINT
 331                    ? (sighandler_t) __profil_counter_uint
 332                    : (sighandler_t) __profil_counter_ushort;
 333   act.sa_flags = 0;
 334 #endif
 335   act.sa_flags |= SA_RESTART;
 336   __sigfillset (&act.sa_mask);
 337   if (__sigaction (SIGPROF, &act, &prof_info.saved_action) < 0)
 338     return -1;
 339
 340   /* Setup profiling timer.  */
 341   timer.it_value.tv_sec  = 0;
 342   timer.it_value.tv_usec = 1;
 343   timer.it_interval = timer.it_value;
 344   return __setitimer (ITIMER_PROF, &timer, &prof_info.saved_timer);
 345 }
 346
 347 weak_alias (__sprofil, sprofil)
 348
 349 #endif /* SIGPROF */