1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26 
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28 
  29 /*
  30  * All routines in this file are for processing new-style, *versioned*
  31  * mon.out format. Together with rdelf.c, lookup.c and profv.h, these
  32  * form the complete set of files to profile new-style mon.out files.
  33  */
  34 
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include "conv.h"
  38 #include "profv.h"
  39 
  40 bool            time_in_ticks = FALSE;
  41 size_t          n_pcsamples, n_accounted_ticks, n_zeros, total_funcs;
  42 unsigned char   sort_flag;
  43 
  44 mod_info_t      modules;
  45 size_t          n_modules = 1;  /* always include the aout object */
  46 
  47 struct stat     aout_stat, monout_stat;
  48 profrec_t       *profsym;
  49 
  50 int
  51 cmp_by_name(const void *arg1, const void *arg2)
  52 {
  53         profrec_t *a = (profrec_t *)arg1;
  54         profrec_t *b = (profrec_t *)arg2;
  55 
  56         return (strcmp(a->demangled_name, b->demangled_name));
  57 }
  58 
  59 static void
  60 setup_demangled_names(void)
  61 {
  62         const char      *p;
  63         char    *nbp, *nbe, *namebuf;
  64         size_t  cur_len = 0, namebuf_sz = BUCKET_SZ;
  65         size_t  i, namelen;
  66 
  67         if ((namebuf = malloc(namebuf_sz)) == NULL) {
  68                 (void) fprintf(stderr, "%s: can't allocate %d bytes\n",
  69                     cmdname, namebuf_sz);
  70                 exit(ERR_MEMORY);
  71         }
  72 
  73         nbp = namebuf;
  74         nbe = namebuf + namebuf_sz;
  75 
  76         for (i = 0; i < total_funcs; i++) {
  77                 p = conv_demangle_name(profsym[i].name);
  78                 if (p == profsym[i].name)
  79                         continue;
  80 
  81                 namelen = strlen(p);
  82                 if ((nbp + namelen + 1) > nbe) {
  83                         namebuf_sz += BUCKET_SZ;
  84                         namebuf = realloc(namebuf, namebuf_sz);
  85                         if (namebuf == NULL) {
  86                                 (void) fprintf(stderr,
  87                                     "%s: can't alloc %d bytes\n",
  88                                     cmdname, BUCKET_SZ);
  89                                 exit(ERR_MEMORY);
  90                         }
  91 
  92                         nbp = namebuf + cur_len;
  93                         nbe = namebuf + namebuf_sz;
  94                 }
  95 
  96                 (void) strcpy(nbp, p);
  97                 profsym[i].demangled_name = nbp;
  98 
  99                 nbp += namelen + 1;
 100                 cur_len += namelen + 1;
 101                 free((void *)p);
 102         }
 103 }
 104 
 105 int
 106 cmp_by_time(const void *arg1, const void *arg2)
 107 {
 108         profrec_t *a = (profrec_t *)arg1;
 109         profrec_t *b = (profrec_t *)arg2;
 110 
 111         if (a->percent_time > b->percent_time)
 112                 return (-1);
 113         else if (a->percent_time < b->percent_time)
 114                 return (1);
 115         else
 116                 return (0);
 117 }
 118 
 119 int
 120 cmp_by_ncalls(const void *arg1, const void *arg2)
 121 {
 122         profrec_t *a = (profrec_t *)arg1;
 123         profrec_t *b = (profrec_t *)arg2;
 124 
 125         if (a->ncalls > b->ncalls)
 126                 return (-1);
 127         else if (a->ncalls < b->ncalls)
 128                 return (1);
 129         else
 130                 return (0);
 131 
 132 }
 133 
 134 static void
 135 print_profile_data(void)
 136 {
 137         int             i;
 138         int             (*sort_func)(const void *, const void *);
 139         mod_info_t      *mi;
 140         double          cumsecs = 0;
 141         char            filler[20];
 142 
 143         /*
 144          * Sort the compiled data; the sort flags are mutually exclusive.
 145          */
 146         switch (sort_flag) {
 147                 case BY_NCALLS:
 148                         sort_func = cmp_by_ncalls;
 149                         break;
 150 
 151                 case BY_NAME:
 152                         if (Cflag)
 153                                 setup_demangled_names();
 154                         sort_func = cmp_by_name;
 155                         break;
 156 
 157                 case BY_ADDRESS:
 158                         sort_flag |= BY_ADDRESS;
 159                         sort_func = NULL;       /* already sorted by addr */
 160                         break;
 161 
 162                 case BY_TIME:           /* default is to sort by time */
 163                 default:
 164                         sort_func = cmp_by_time;
 165         }
 166 
 167 
 168         if (sort_func) {
 169                 qsort(profsym, total_funcs, sizeof (profrec_t), sort_func);
 170         }
 171 
 172         /*
 173          * If we're sorting by name, and if it is a verbose print, we wouldn't
 174          * have set up the print_mid fields yet.
 175          */
 176         if ((flags & F_VERBOSE) && (sort_flag == BY_NAME)) {
 177                 for (i = 0; i < total_funcs; i++) {
 178                         /*
 179                          * same as previous or next (if there's one) ?
 180                          */
 181                         if (i && (strcmp(profsym[i].demangled_name,
 182                             profsym[i-1].demangled_name) == 0)) {
 183                                 profsym[i].print_mid = TRUE;
 184                         } else if ((i < (total_funcs - 1)) &&
 185                             (strcmp(profsym[i].demangled_name,
 186                             profsym[i+1].demangled_name) == 0)) {
 187                                 profsym[i].print_mid = TRUE;
 188                         }
 189                 }
 190         }
 191 
 192         /*
 193          * The actual printing part.
 194          */
 195         if (!(flags & F_NHEAD)) {
 196                 if (flags & F_PADDR)
 197                         (void) printf("        %s", atitle);
 198 
 199                 if (time_in_ticks)
 200                         (void) puts(
 201                             " %Time   Tiks  Cumtiks  #Calls   tiks/call  Name");
 202                 else
 203                         (void) puts(
 204                             " %Time Seconds Cumsecs  #Calls   msec/call  Name");
 205         }
 206 
 207         mi = NULL;
 208         for (i = 0; i < total_funcs; i++) {
 209                 /*
 210                  * Since the same value may denote different symbols in
 211                  * different shared objects, it is debatable if it is
 212                  * meaningful to print addresses at all. Especially so
 213                  * if we were asked to sort by symbol addresses.
 214                  *
 215                  * If we've to sort by address, I think it is better to sort
 216                  * it on a per-module basis and if verbose mode is on too,
 217                  * print a newline to separate out modules.
 218                  */
 219                 if ((flags & F_VERBOSE) && (sort_flag == BY_ADDRESS)) {
 220                         if (mi != profsym[i].module) {
 221                                 (void) printf("\n");
 222                                 mi = profsym[i].module;
 223                         }
 224                 }
 225 
 226                 if (flags & F_PADDR) {
 227                         if (aformat[2] == 'x')
 228                                 (void) printf("%16llx ", profsym[i].addr);
 229                         else
 230                                 (void) printf("%16llo ", profsym[i].addr);
 231                 }
 232 
 233                 cumsecs += profsym[i].seconds;
 234                 (void) printf("%6.1f%8.2f%8.2f", profsym[i].percent_time,
 235                     profsym[i].seconds, cumsecs);
 236 
 237                 (void) printf("%8d%12.4f  ",
 238                     profsym[i].ncalls, profsym[i].msecs_per_call);
 239 
 240                 if (profsym[i].print_mid)
 241                         (void) printf("%d:", (profsym[i].module)->id);
 242 
 243                 (void) printf("%s\n", profsym[i].demangled_name);
 244         }
 245 
 246         if (flags & F_PADDR)
 247                 (void) sprintf(filler, "%16s", "");
 248         else
 249                 filler[0] = 0;
 250 
 251         if (flags & F_VERBOSE) {
 252                 (void) puts("\n");
 253                 (void) printf("%s   Total Object Modules     %7d\n",
 254                     filler, n_modules);
 255                 (void) printf("%s   Qualified Symbols        %7d\n",
 256                     filler, total_funcs);
 257                 (void) printf("%s   Symbols with zero usage  %7d\n",
 258                     filler, n_zeros);
 259                 (void) printf("%s   Total pc-hits            %7d\n",
 260                     filler, n_pcsamples);
 261                 (void) printf("%s   Accounted pc-hits        %7d\n",
 262                     filler, n_accounted_ticks);
 263                 if ((!gflag) && (n_pcsamples - n_accounted_ticks)) {
 264                         (void) printf("%s   Missed pc-hits (try -g)  %7d\n\n",
 265                             filler, n_pcsamples - n_accounted_ticks);
 266                 } else {
 267                         (void) printf("%s   Missed pc-hits           %7d\n\n",
 268                             filler, n_pcsamples - n_accounted_ticks);
 269                 }
 270                 (void) printf("%s   Module info\n", filler);
 271                 for (mi = &modules; mi; mi = mi->next)
 272                         (void) printf("%s      %d: `%s'\n", filler,
 273                             mi->id, mi->path);
 274         }
 275 }
 276 
 277 int
 278 name_cmp(const void *arg1, const void *arg2)
 279 {
 280         profnames_t *a = (profnames_t *)arg1;
 281         profnames_t *b = (profnames_t *)arg2;
 282 
 283         return (strcmp(a->name, b->name));
 284 }
 285 
 286 static void
 287 check_dupnames(void)
 288 {
 289         int             i;
 290         profnames_t     *pn;
 291 
 292         pn = calloc(total_funcs, sizeof (profnames_t));
 293         if (pn == NULL) {
 294                 (void) fprintf(stderr, "%s: no room for %d bytes\n",
 295                     cmdname, total_funcs * sizeof (profnames_t));
 296                 exit(ERR_MEMORY);
 297         }
 298 
 299         for (i = 0; i < total_funcs; i++) {
 300                 pn[i].name = profsym[i].demangled_name;
 301                 pn[i].pfrec = &profsym[i];
 302         }
 303 
 304         qsort(pn, total_funcs, sizeof (profnames_t), name_cmp);
 305 
 306         for (i = 0; i < total_funcs; i++) {
 307                 /*
 308                  * same as previous or next (if there's one) ?
 309                  */
 310                 if (i && (strcmp(pn[i].name, pn[i-1].name) == 0))
 311                         (pn[i].pfrec)->print_mid = TRUE;
 312                 else if ((i < (total_funcs - 1)) &&
 313                     (strcmp(pn[i].name, pn[i+1].name) == 0)) {
 314                         (pn[i].pfrec)->print_mid = TRUE;
 315                 }
 316         }
 317 
 318         free(pn);
 319 }
 320 
 321 static void
 322 compute_times(nltype *nl, profrec_t *psym)
 323 {
 324         static int      first_time = TRUE;
 325         static long     hz;
 326 
 327         if (first_time) {
 328                 if ((hz = sysconf(_SC_CLK_TCK)) == -1)
 329                         time_in_ticks = TRUE;
 330                 first_time = FALSE;
 331         }
 332 
 333         if (time_in_ticks) {
 334                 psym->seconds = (double)nl->nticks;
 335                 if (nl->ncalls) {
 336                         psym->msecs_per_call = (double)nl->nticks /
 337                             (double)nl->ncalls;
 338                 } else
 339                         psym->msecs_per_call = (double)0.0;
 340         } else {
 341                 psym->seconds = (double)nl->nticks / (double)hz;
 342                 if (nl->ncalls) {
 343                         psym->msecs_per_call =
 344                             ((double)psym->seconds * 1000.0) /
 345                             (double)nl->ncalls;
 346                 } else
 347                         psym->msecs_per_call = (double)0.0;
 348         }
 349 
 350         if (n_pcsamples) {
 351                 psym->percent_time =
 352                     ((double)nl->nticks / (double)n_pcsamples) * 100;
 353         }
 354 }
 355 
 356 static void
 357 collect_profsyms(void)
 358 {
 359         mod_info_t      *mi;
 360         nltype          *nl;
 361         size_t          i, ndx;
 362 
 363 
 364         for (mi = &modules; mi; mi = mi->next)
 365                 total_funcs += mi->nfuncs;
 366 
 367         profsym = calloc(total_funcs, sizeof (profrec_t));
 368         if (profsym == NULL) {
 369                 (void) fprintf(stderr, "%s: no room for %d bytes\n",
 370                     cmdname, total_funcs * sizeof (profrec_t));
 371                 exit(ERR_MEMORY);
 372         }
 373 
 374         ndx = 0;
 375         for (mi = &modules; mi; mi = mi->next) {
 376                 nl = mi->nl;
 377                 for (i = 0; i < mi->nfuncs; i++) {
 378                         /*
 379                          * I think F_ZSYMS doesn't make sense for the new
 380                          * mon.out format, since we don't have a profiling
 381                          * *range*, per se. But the man page demands it,
 382                          * so...
 383                          */
 384                         if ((nl[i].ncalls == 0) && (nl[i].nticks == 0)) {
 385                                 n_zeros++;
 386                                 if (!(flags & F_ZSYMS))
 387                                         continue;
 388                         }
 389 
 390                         /*
 391                          * Initially, we set demangled_name to be
 392                          * the same as name. If Cflag is set, we later
 393                          * change this to be the demangled name ptr.
 394                          */
 395                         profsym[ndx].addr = nl[i].value;
 396                         profsym[ndx].ncalls = nl[i].ncalls;
 397                         profsym[ndx].name = nl[i].name;
 398                         profsym[ndx].demangled_name = nl[i].name;
 399                         profsym[ndx].module = mi;
 400                         profsym[ndx].print_mid = FALSE;
 401                         compute_times(&nl[i], &profsym[ndx]);
 402                         ndx++;
 403                 }
 404         }
 405 
 406         /*
 407          * Adjust total_funcs to actual printable funcs
 408          */
 409         total_funcs = ndx;
 410 }
 411 
 412 static void
 413 assign_pcsamples(mod_info_t *module, Address *pcsmpl,
 414     size_t n_samples)
 415 {
 416         Address         *pcptr, *pcse = pcsmpl + n_samples;
 417         Address         nxt_func;
 418         nltype          *nl;
 419         size_t          nticks;
 420 
 421         /* Locate the first pc-hit for this module */
 422         if ((pcptr = locate(pcsmpl, n_samples, module->load_base)) == NULL)
 423                 return;                 /* no pc-hits in this module */
 424 
 425         /* Assign all pc-hits in this module to appropriate functions */
 426         while ((pcptr < pcse) && (*pcptr < module->load_end)) {
 427 
 428                 /* Update the corresponding function's time */
 429                 if (nl = nllookup(module, *pcptr, &nxt_func)) {
 430                         /*
 431                          * Collect all pc-hits in this function. Each
 432                          * pc-hit counts as 1 tick.
 433                          */
 434                         nticks = 0;
 435                         while ((pcptr < pcse) && (*pcptr < nxt_func)) {
 436                                 nticks++;
 437                                 pcptr++;
 438                         }
 439 
 440                         nl->nticks += nticks;
 441                         n_accounted_ticks += nticks;
 442                 } else {
 443                         /*
 444                          * pc sample could not be assigned to function;
 445                          * probably in a PLT
 446                          */
 447                         pcptr++;
 448                 }
 449         }
 450 }
 451 
 452 static int
 453 pc_cmp(const void *arg1, const void *arg2)
 454 {
 455         Address *pc1 = (Address *)arg1;
 456         Address *pc2 = (Address *)arg2;
 457 
 458         if (*pc1 > *pc2)
 459                 return (1);
 460 
 461         if (*pc1 < *pc2)
 462                 return (-1);
 463 
 464         return (0);
 465 }
 466 
 467 static void
 468 process_pcsamples(ProfBuffer *bufp)
 469 {
 470         Address         *pc_samples;
 471         mod_info_t      *mi;
 472         size_t          nelem = bufp->bufsize;
 473 
 474         /* buffer with no pc samples ? */
 475         if (nelem == 0)
 476                 return;
 477 
 478         /* Allocate for the pcsample chunk */
 479         pc_samples = (Address *) calloc(nelem, sizeof (Address));
 480         if (pc_samples == NULL) {
 481                 (void) fprintf(stderr, "%s: no room for %d sample pc's\n",
 482                     cmdname, nelem);
 483                 exit(ERR_MEMORY);
 484         }
 485 
 486         (void) memcpy(pc_samples, (caddr_t)bufp + bufp->buffer,
 487             nelem * sizeof (Address));
 488 
 489         /* Sort the pc samples */
 490         qsort(pc_samples, nelem, sizeof (Address), pc_cmp);
 491 
 492         /*
 493          * Assign pcsamples to functions in the currently active
 494          * module list
 495          */
 496         for (mi = &modules; mi; mi = mi->next) {
 497                 if (mi->active == FALSE)
 498                         continue;
 499                 assign_pcsamples(mi, pc_samples, nelem);
 500         }
 501 
 502         free(pc_samples);
 503 
 504         /* Update total number of pcsamples read so far */
 505         n_pcsamples += nelem;
 506 }
 507 
 508 static void
 509 process_cgraph(ProfCallGraph *cgp)
 510 {
 511         mod_info_t      *mi;
 512         Address         f_end;
 513         Index           callee_off;
 514         ProfFunction    *calleep;
 515         nltype          *nl;
 516 
 517         for (callee_off = cgp->functions; callee_off;
 518             callee_off = calleep->next_to) {
 519 
 520                 /* LINTED: pointer cast */
 521                 calleep = (ProfFunction *)((char *)cgp + callee_off);
 522                 if (calleep->count == 0)
 523                         continue;
 524 
 525                 /*
 526                  * If we cannot identify a callee with a module, we
 527                  * cannot get to its namelist, just skip it.
 528                  */
 529                 for (mi = &modules; mi; mi = mi->next) {
 530                         if (mi->active == FALSE)
 531                                 continue;
 532 
 533                         if (calleep->topc >= mi->load_base &&
 534                             calleep->topc < mi->load_end) {
 535                                 /*
 536                                  * nllookup() returns the next lower entry
 537                                  * point on a miss. So just make sure the
 538                                  * callee's pc is not outside this function
 539                                  */
 540                                 if (nl = nllookup(mi, calleep->topc, 0)) {
 541                                         f_end = mi->load_base + (nl->value -
 542                                             mi->txt_origin) + nl->size;
 543                                         if (calleep->topc < f_end)
 544                                                 nl->ncalls += calleep->count;
 545                                 }
 546                         }
 547                 }
 548         }
 549 }
 550 
 551 static mod_info_t *
 552 get_shobj_syms(char *pathname, GElf_Addr ld_base, GElf_Addr ld_end)
 553 {
 554         mod_info_t      *mi;
 555 
 556         /* Create a new module element */
 557         if ((mi = malloc(sizeof (mod_info_t))) == NULL) {
 558                 (void) fprintf(stderr, "%s: no room for %d bytes\n",
 559                     cmdname, sizeof (mod_info_t));
 560                 exit(ERR_MEMORY);
 561         }
 562 
 563         mi->path = malloc(strlen(pathname) + 1);
 564         if (mi->path == NULL) {
 565                 (void) fprintf(stderr, "%s: can't allocate %d bytes\n",
 566                     cmdname, strlen(pathname) + 1);
 567                 exit(ERR_MEMORY);
 568         }
 569         (void) strcpy(mi->path, pathname);
 570         mi->next = NULL;
 571 
 572         get_syms(pathname, mi);
 573 
 574         /* and fill in info... */
 575         mi->id = n_modules + 1;
 576         mi->load_base = ld_base;
 577         mi->load_end = ld_end;
 578         mi->active = TRUE;
 579 
 580         n_modules++;
 581 
 582         return (mi);
 583 }
 584 
 585 /*
 586  * Two modules overlap each other if they don't lie completely *outside*
 587  * each other.
 588  */
 589 static bool
 590 does_overlap(ProfModule *new, mod_info_t *old)
 591 {
 592         /* case 1: new module lies completely *before* the old one */
 593         if (new->startaddr < old->load_base && new->endaddr <= old->load_base)
 594                 return (FALSE);
 595 
 596         /* case 2: new module lies completely *after* the old one */
 597         if (new->startaddr >= old->load_end && new->endaddr >= old->load_end)
 598                 return (FALSE);
 599 
 600         /* probably a dlopen: the modules overlap each other */
 601         return (TRUE);
 602 }
 603 
 604 static bool
 605 is_same_as_aout(char *modpath, struct stat *buf)
 606 {
 607         if (stat(modpath, buf) == -1) {
 608                 perror(modpath);
 609                 exit(ERR_SYSCALL);
 610         }
 611 
 612         if ((buf->st_dev == aout_stat.st_dev) &&
 613             (buf->st_ino == aout_stat.st_ino)) {
 614                 return (TRUE);
 615         } else
 616                 return (FALSE);
 617 }
 618 
 619 static void
 620 process_modules(ProfModuleList *modlp)
 621 {
 622         ProfModule      *newmodp;
 623         mod_info_t      *mi, *last, *new_module;
 624         char            *so_path;
 625         bool            more_modules = TRUE;
 626         struct stat     so_statbuf;
 627 
 628         /* Check version of module type object */
 629         if (modlp->version > PROF_MODULES_VER) {
 630                 (void) fprintf(stderr,
 631                     "%s: unsupported version %d for modules\n",
 632                     cmdname, modlp->version);
 633                 exit(ERR_INPUT);
 634         }
 635 
 636 
 637         /*
 638          * Scan the PROF_MODULES_T list and add modules to current list
 639          * of modules, if they're not present already
 640          */
 641         /* LINTED: pointer cast */
 642         newmodp = (ProfModule *)((caddr_t)modlp + modlp->modules);
 643         do {
 644                 /*
 645                  * Since the aout could've been renamed after its run, we
 646                  * should see if current module overlaps aout. If it does, it
 647                  * is probably the renamed aout. We should also skip any other
 648                  * non-sharedobj's that we see (or should we report an error ?)
 649                  */
 650                 so_path = (caddr_t)modlp + newmodp->path;
 651                 if (does_overlap(newmodp, &modules) ||
 652                     is_same_as_aout(so_path, &so_statbuf) ||
 653                     (!is_shared_obj(so_path))) {
 654                         if (!newmodp->next)
 655                                 more_modules = FALSE;
 656 
 657                         /* LINTED: pointer cast */
 658                         newmodp = (ProfModule *)
 659                             ((caddr_t)modlp + newmodp->next);
 660                         continue;
 661                 }
 662 
 663                 /*
 664                  * Check all modules (leave the first one, 'cos that
 665                  * is the program executable info). If this module is already
 666                  * there in the list, skip it.
 667                  */
 668                 last = &modules;
 669                 while ((mi = last->next) != NULL) {
 670                         /*
 671                          * We expect the full pathname for all shared objects
 672                          * needed by the program executable. In this case, we
 673                          * simply need to compare the paths to see if they are
 674                          * the same file.
 675                          */
 676                         if (strcmp(mi->path, so_path) == 0)
 677                                 break;
 678 
 679                         /*
 680                          * Check if this new shared object will overlap any
 681                          * existing module. If yes, deactivate the old one.
 682                          */
 683                         if (does_overlap(newmodp, mi))
 684                                 mi->active = FALSE;
 685 
 686                         last = mi;
 687                 }
 688 
 689                 /* Module already there, skip it */
 690                 if (mi != NULL) {
 691                         mi->load_base = newmodp->startaddr;
 692                         mi->load_end = newmodp->endaddr;
 693                         mi->active = TRUE;
 694                         if (!newmodp->next)
 695                                 more_modules = FALSE;
 696 
 697                         /* LINTED: pointer cast */
 698                         newmodp = (ProfModule *)
 699                             ((caddr_t)modlp + newmodp->next);
 700                         continue;
 701                 }
 702 
 703                 /*
 704                  * Check if mon.out is outdated with respect to the new
 705                  * module we want to add
 706                  */
 707                 if (monout_stat.st_mtime < so_statbuf.st_mtime) {
 708                         (void) fprintf(stderr,
 709                             "%s: newer shared obj %s outdates profile info\n",
 710                             cmdname, so_path);
 711                         exit(ERR_INPUT);
 712                 }
 713 
 714                 /* Create this module's nameslist */
 715                 new_module = get_shobj_syms(so_path,
 716                     newmodp->startaddr, newmodp->endaddr);
 717 
 718                 /* Add it to the tail of active module list */
 719                 last->next = new_module;
 720 
 721                 /*
 722                  * Move to the next module in the PROF_MODULES_T list
 723                  * (if present)
 724                  */
 725                 if (!newmodp->next)
 726                         more_modules = FALSE;
 727 
 728                 /* LINTED: pointer cast */
 729                 newmodp = (ProfModule *)((caddr_t)modlp + newmodp->next);
 730 
 731         } while (more_modules);
 732 }
 733 
 734 static void
 735 process_mon_out(caddr_t memp, size_t fsz)
 736 {
 737         ProfObject      *objp;
 738         caddr_t         file_end;
 739         bool            found_pcsamples = FALSE, found_cgraph = FALSE;
 740 
 741         /*
 742          * Save file end pointer and start after header
 743          */
 744         file_end = memp + fsz;
 745         /* LINTED: pointer cast */
 746         objp = (ProfObject *)(memp + ((ProfHeader *)memp)->size);
 747         while ((caddr_t)objp < file_end) {
 748                 switch (objp->type) {
 749                         case PROF_MODULES_T :
 750                                 process_modules((ProfModuleList *)objp);
 751                                 break;
 752 
 753                         case PROF_CALLGRAPH_T :
 754                                 process_cgraph((ProfCallGraph *)objp);
 755                                 found_cgraph = TRUE;
 756                                 break;
 757 
 758                         case PROF_BUFFER_T :
 759                                 process_pcsamples((ProfBuffer *)objp);
 760                                 found_pcsamples = TRUE;
 761                                 break;
 762 
 763                         default :
 764                                 (void) fprintf(stderr,
 765                                     "%s: unknown prof object type=%d\n",
 766                                     cmdname, objp->type);
 767                                 exit(ERR_INPUT);
 768                 }
 769                 /* LINTED: pointer cast */
 770                 objp = (ProfObject *)((caddr_t)objp + objp->size);
 771         }
 772 
 773         if (!found_cgraph || !found_pcsamples) {
 774                 (void) fprintf(stderr,
 775                     "%s: missing callgraph/pcsamples in `%s'\n",
 776                     cmdname, mon_fn);
 777                 exit(ERR_INPUT);
 778         }
 779 
 780         if ((caddr_t)objp > file_end) {
 781                 (void) fprintf(stderr, "%s: malformed file `%s'\n",
 782                     cmdname, mon_fn);
 783                 exit(ERR_INPUT);
 784         }
 785 }
 786 
 787 static void
 788 get_aout_syms(char *pathname, mod_info_t *mi)
 789 {
 790         mi->path = malloc(strlen(pathname) + 1);
 791         if (mi->path == NULL) {
 792                 (void) fprintf(stderr, "%s: can't allocate %d bytes\n",
 793                     cmdname, strlen(pathname) + 1);
 794                 exit(ERR_MEMORY);
 795         }
 796 
 797         (void) strcpy(mi->path, pathname);
 798         mi->next = NULL;
 799 
 800         get_syms(pathname, mi);
 801 
 802         mi->id = 1;
 803         mi->load_base = mi->txt_origin;
 804         mi->load_end = mi->data_end;
 805         mi->active = TRUE;
 806 }
 807 
 808 void
 809 profver(void)
 810 {
 811         int             fd;
 812         unsigned int    magic_num;
 813         bool            invalid_version;
 814         caddr_t         fmem;
 815         ProfHeader      prof_hdr;
 816 
 817         /*
 818          * Check the magic and see if this is versioned or *old-style*
 819          * mon.out.
 820          */
 821         if ((fd = open(mon_fn, O_RDONLY)) == -1) {
 822                 perror(mon_fn);
 823                 exit(ERR_SYSCALL);
 824         }
 825         if (read(fd, (char *)&magic_num, sizeof (unsigned int)) == -1) {
 826                 perror("read");
 827                 exit(ERR_SYSCALL);
 828         }
 829         if (magic_num != (unsigned int) PROF_MAGIC) {
 830                 (void) close(fd);
 831                 return;
 832         }
 833 
 834 
 835 
 836         /*
 837          * Check versioning info. For now, let's say we provide
 838          * backward compatibility, so we accept all older versions.
 839          */
 840         (void) lseek(fd, 0L, SEEK_SET);
 841         if (read(fd, (char *)&prof_hdr, sizeof (ProfHeader)) == -1) {
 842                 perror("read");
 843                 exit(ERR_SYSCALL);
 844         }
 845         invalid_version = FALSE;
 846         if (prof_hdr.h_major_ver > PROF_MAJOR_VERSION)
 847                 invalid_version = TRUE;
 848         else if (prof_hdr.h_major_ver == PROF_MAJOR_VERSION) {
 849                 if (prof_hdr.h_minor_ver > PROF_MINOR_VERSION)
 850                 invalid_version = FALSE;
 851         }
 852         if (invalid_version) {
 853                 (void) fprintf(stderr,
 854                     "%s: mon.out version %d.%d not supported\n",
 855                     cmdname, prof_hdr.h_major_ver, prof_hdr.h_minor_ver);
 856                 exit(ERR_INPUT);
 857         }
 858 
 859 
 860 
 861         /*
 862          * Map mon.out onto memory.
 863          */
 864         if (stat(mon_fn, &monout_stat) == -1) {
 865                 perror(mon_fn);
 866                 exit(ERR_SYSCALL);
 867         }
 868         if ((fmem = mmap(0, monout_stat.st_size,
 869             PROT_READ, MAP_PRIVATE, fd, 0)) == MAP_FAILED) {
 870                 perror("mmap");
 871                 exit(ERR_SYSCALL);
 872         }
 873         (void) close(fd);
 874 
 875 
 876         /*
 877          * Now, read program executable's symbol table. Also save it's
 878          * stat in aout_stat for use while processing mon.out
 879          */
 880         if (stat(sym_fn, &aout_stat) == -1) {
 881                 perror(sym_fn);
 882                 exit(ERR_SYSCALL);
 883         }
 884         get_aout_syms(sym_fn, &modules);
 885 
 886         /*
 887          * Process the mon.out, all shared objects it references
 888          * and collect statistics on ticks spent in each function,
 889          * number of calls, etc.
 890          */
 891         process_mon_out(fmem, monout_stat.st_size);
 892 
 893         /*
 894          * Based on the flags and the statistics we've got, create
 895          * a list of relevant symbols whose profiling details should
 896          * be printed
 897          */
 898         collect_profsyms();
 899 
 900         /*
 901          * Check for duplicate names in output. We need to print the
 902          * module id's if verbose. Also, if we are sorting by name anyway,
 903          * we don't need to check for duplicates here. We'll do that later.
 904          */
 905         if ((flags & F_VERBOSE) && (sort_flag != BY_NAME))
 906                 check_dupnames();
 907 
 908         /*
 909          * Print output
 910          */
 911         print_profile_data();
 912 
 913 
 914         (void) munmap(fmem, monout_stat.st_size);
 915         exit(0);
 916 }