/* Profiling of shared libraries. Copyright (C) 1997 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Ulrich Drepper , 1997. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the GNU C Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include #include #include #include #include #include #include #include #include #include #include #include /* The LD_PROFILE feature has to be implemented different to the normal profiling using the gmon/ functions. The problem is that an arbitrary amount of processes simulataneously can be run using profiling and all write the results in the same file. To provide this mechanism one could implement a complicated mechanism to merge the content of two profiling runs or one could extend the file format to allow more than one data set. For the second solution we would have the problem that the file can grow in size beyond any limit and both solutions have the problem that the concurrency of writing the results is a big problem. Another much simpler method is to use mmap to map the same file in all using programs and modify the data in the mmap'ed area and so also automatically on the disk. Using the MAP_SHARED option of mmap(2) this can be done without big problems in more than one file. This approach is very different from the normal profiling. We have to use the profiling data in exactly the way they are expected to be written to disk. */ extern char *_strerror_internal __P ((int, char *buf, size_t)); extern int __profile_frequency __P ((void)); static struct gmonparam param; /* We define a special type to address the elements of the arc table. This is basically the `gmon_cg_arc_record' format but it includes the room for the tag and it uses real types. */ struct here_cg_arc_record { char tag; uintptr_t from_pc __attribute__ ((packed)); uintptr_t self_pc __attribute__ ((packed)); uint32_t count __attribute__ ((packed)); }; static struct here_cg_arc_record *data; void _dl_start_profile (struct link_map *map, const char *output_dir) { char *filename; int fd; struct stat st; const ElfW(Phdr) *ph; ElfW(Addr) mapstart = ~((ElfW(Addr)) 0); ElfW(Addr) mapend = 0; off_t expected_size; struct gmon_hdr gmon_hdr; struct gmon_hist_hdr hist_hdr; struct gmon_hdr *addr; char *hist; /* Compute the size of the sections which contain program code. */ for (ph = map->l_phdr; ph < &map->l_phdr[map->l_phnum]; ++ph) if (ph->p_type == PT_LOAD && (ph->p_flags & PF_X)) { ElfW(Addr) start = (ph->p_vaddr & ~(_dl_pagesize - 1)); ElfW(Addr) end = ((ph->p_vaddr + ph->p_memsz + _dl_pagesize - 1) & ~(_dl_pagesize - 1)); if (start < mapstart) mapstart = start; if (end > mapend) mapend = end; } /* Now we can compute the size of the profiling data. This is done with the same formulars as in `monstartup' (see gmon.c). */ param.state = GMON_PROF_OFF; param.lowpc = mapstart + map->l_addr; param.highpc = mapend + map->l_addr; param.textsize = mapend - mapstart; param.kcountsize = param.textsize / HISTFRACTION; param.hashfraction = HASHFRACTION; param.log_hashfraction = -1; if ((HASHFRACTION & (HASHFRACTION - 1)) == 0) /* If HASHFRACTION is a power of two, mcount can use shifting instead of integer division. Precompute shift amount. */ param.log_hashfraction = ffs (param.hashfraction * sizeof (*param.froms)) - 1; param.fromssize = param.textsize / HASHFRACTION; param.tolimit = param.textsize * ARCDENSITY / 100; if (param.tolimit < MINARCS) param.tolimit = MINARCS; if (param.tolimit > MAXARCS) param.tolimit = MAXARCS; param.tossize = param.tolimit * sizeof (struct tostruct); expected_size = (sizeof (struct gmon_hdr) + 1 + sizeof (struct gmon_hist_hdr) + ((1 + sizeof (struct gmon_cg_arc_record)) * (param.fromssize / sizeof (*param.froms)))); /* Create the gmon_hdr we expect or write. */ memset (&gmon_hdr, '\0', sizeof (struct gmon_hdr)); memcpy (&gmon_hdr.cookie[0], GMON_MAGIC, sizeof (gmon_hdr.cookie)); *(int32_t *) gmon_hdr.version = GMON_VERSION; /* Create the hist_hdr we expect or write. */ *(char **) hist_hdr.low_pc = (char *) mapstart; *(char **) hist_hdr.high_pc = (char *) mapend; *(int32_t *) hist_hdr.hist_size = param.kcountsize / sizeof (HISTCOUNTER); *(int32_t *) hist_hdr.prof_rate = __profile_frequency (); strncpy (hist_hdr.dimen, "seconds", sizeof (hist_hdr.dimen)); hist_hdr.dimen_abbrev = 's'; /* First determine the output name. We write in the directory OUTPUT_DIR and the name is composed from the shared objects soname (or the file name) and the ending ".profile". */ filename = (char *) alloca (strlen (output_dir) + 1 + strlen (_dl_profile) + sizeof ".profile"); __stpcpy (__stpcpy (__stpcpy (__stpcpy (filename, output_dir), "/"), _dl_profile), ".profile"); fd = __open (filename, O_RDWR | O_CREAT, 0666); if (fd == -1) /* We cannot write the profiling data so don't do anthing. */ return; if (fstat (fd, &st) < 0 || !S_ISREG (st.st_mode)) { /* Not stat'able or not a regular file => don't use it. */ close (fd); return; } /* Test the size. If it does not match what we expect from the size values in the map MAP we don't use it and warn the user. */ if (st.st_size == 0) { /* We have to create the file. */ char buf[_dl_pagesize]; memset (buf, '\0', _dl_pagesize); if (__lseek (fd, expected_size & ~(_dl_pagesize - 1), SEEK_SET) == -1) { char buf[400]; int errnum; cannot_create: errnum = errno; __close (fd); _dl_sysdep_error (filename, ": cannot create file: ", _strerror_internal (errnum, buf, sizeof buf), "\n", NULL); return; } if (TEMP_FAILURE_RETRY (__write (fd, buf, (expected_size & (_dl_pagesize - 1)))) < 0) goto cannot_create; } else if (st.st_size != expected_size) { __close (fd); wrong_format: _dl_sysdep_error (filename, ": file is no correct profile data file for `", _dl_profile, "'\n", NULL); return; } addr = (void *) __mmap (NULL, expected_size, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_FILE, fd, 0); if (addr == (void *) -1) { char buf[400]; int errnum = errno; __close (fd); _dl_sysdep_error (filename, ": cannot map file: ", _strerror_internal (errnum, buf, sizeof buf), "\n", NULL); return; } /* We don't need the file desriptor anymore. */ __close (fd); /* Pointer to data after the header. */ hist = (char *) (addr + 1); /* Compute pointer to array of the arc information. */ data = (struct here_cg_arc_record *) (hist + 1 + sizeof (struct gmon_hist_hdr)); if (st.st_size == 0) { /* Create the signature. */ size_t cnt; memcpy (addr, &gmon_hdr, sizeof (struct gmon_hdr)); *hist = GMON_TAG_TIME_HIST; memcpy (hist + 1, &hist_hdr, sizeof (struct gmon_hist_hdr)); for (cnt = 0; cnt < param.fromssize / sizeof (*param.froms); ++cnt) data[cnt].tag = GMON_TAG_CG_ARC; } else { /* Test the signature in the file. */ if (memcmp (addr, &gmon_hdr, sizeof (struct gmon_hdr)) != 0 || *hist != GMON_TAG_TIME_HIST || memcmp (hist + 1, &hist_hdr, sizeof (struct gmon_hist_hdr)) != 0) goto wrong_format; } /* Turn on profiling. */ param.state = GMON_PROF_ON; } void _dl_mcount (ElfW(Addr) frompc, ElfW(Addr) selfpc) { if (param.state != GMON_PROF_ON) return; param.state = GMON_PROF_BUSY; /* Compute relative addresses. The shared object can be loaded at any address. The value of frompc could be anything. We cannot restrict it in any way, just set to a fixed value (0) in case it is outside the allowed range. These calls show up as calls from in the gprof output. */ frompc -= param.lowpc; if (frompc >= param.textsize) frompc = 0; selfpc -= param.lowpc; param.state = GMON_PROF_ON; }