int Booster::launchProcess() { setEnvironmentBeforeLaunch(); // Load the application and find out the address of main() loadMain(); // make booster specific initializations unless booster is in boot mode if (!m_bootMode) preinit(); #ifdef WITH_COVERAGE __gcov_flush(); #endif // Close syslog closelog(); // Jump to main() const int retVal = m_appData->entry()(m_appData->argc(), const_cast<char **>(m_appData->argv())); #ifdef WITH_COVERAGE __gcov_flush(); #endif return retVal; }
// Forwards Unix signals from invoker to the invoked process static void sig_forwarder(int sig) { if (g_invoked_pid >= 0) { if (kill(g_invoked_pid, sig) != 0) { if (sig == SIGTERM && errno == ESRCH) { report(report_info, "Can't send signal SIGTERM to application [%i] " "because application is already terminated. \n", g_invoked_pid); } else { report(report_error, "Can't send signal %i to application [%i]: %s \n", sig, g_invoked_pid, strerror(errno)); } } // Restore signal handlers sigs_restore(); // Write signal number to the self-pipe char signal_id = (char) sig; write(g_signal_pipe[1], &signal_id, 1); // Send the signal to itself using the default handler raise(sig); #ifdef WITH_COVERAGE __gcov_flush(); #endif } }
int main(int argc, char *argv[]) { otInstance *instance; #if OPENTHREAD_EXAMPLES_POSIX if (setjmp(gResetJump)) { alarm(0); #if OPENTHREAD_ENABLE_COVERAGE __gcov_flush(); #endif execvp(argv[0], argv); } #endif #if OPENTHREAD_ENABLE_MULTIPLE_INSTANCES size_t otInstanceBufferLength = 0; uint8_t *otInstanceBuffer = NULL; #endif pseudo_reset: otSysInit(argc, argv); #if OPENTHREAD_ENABLE_MULTIPLE_INSTANCES // Call to query the buffer size (void)otInstanceInit(NULL, &otInstanceBufferLength); // Call to allocate the buffer otInstanceBuffer = (uint8_t *)malloc(otInstanceBufferLength); assert(otInstanceBuffer); // Initialize OpenThread with the buffer instance = otInstanceInit(otInstanceBuffer, &otInstanceBufferLength); #else instance = otInstanceInitSingle(); #endif assert(instance); otCliUartInit(instance); #if OPENTHREAD_ENABLE_DIAG otDiagInit(instance); #endif while (!otSysPseudoResetWasRequested()) { otTaskletsProcess(instance); otSysProcessDrivers(instance); } otInstanceFinalize(instance); #if OPENTHREAD_ENABLE_MULTIPLE_INSTANCES free(otInstanceBuffer); #endif goto pseudo_reset; return 0; }
int gcov_flush(cp_grant_id_t grantid, int bufsize) { /* Initialize global state. */ pos=0; grant = grantid; gcov_buff_sz = bufsize; assert(!gcov_enable); assert(!gcov_opened); gcov_enable = 1; /* Trigger copying. * This function is not always available, but there is a do-nothing * version in libc so that executables can be linked even without * this code ever being activated. */ __gcov_flush(); /* Mark the end of the data, stop. */ add_int(GCOVOP_END); assert(!gcov_opened); assert(gcov_enable); gcov_enable = 0; /* Return number of bytes used in buffer. */ return pos; }
static void _log( const gchar *log_domain, GLogLevelFlags log_level, const gchar *message, gpointer nothing G_GNUC_UNUSED) { gint64 timenow = qev_time / G_USEC_PER_SEC; gchar date[1024]; #ifdef QEV_LOG_DEBUG struct tm *now; now = localtime(&timenow); strftime(date, sizeof(date), "%H:%M:%S", now); #else snprintf(date, sizeof(date), "%" G_GINT64_FORMAT, timenow); #endif qev_lock_write_lock(&_lock); fprintf(_log_file, "%s - %s [%s] %s\n", log_domain, _get_level(log_level), date, message); qev_lock_write_unlock(&_lock); #ifdef QEV_TESTING __gcov_flush(); #endif }
static void coverage_exit(void *unused) { #if CONFIG_DEBUG_COVERAGE printk(BIOS_DEBUG, "Syncing coverage data.\n"); #endif __gcov_flush(); }
int __gcov_execle (const char *path, char *arg, ...) { va_list ap, aq; unsigned i, length; char **args; char **envp; __gcov_flush (); va_start (ap, arg); va_copy (aq, ap); length = 2; while (va_arg (ap, char *)) length++; va_end (ap); args = (char **) alloca (length * sizeof (void *)); args[0] = arg; for (i = 1; i < length; i++) args[i] = va_arg (aq, char *); envp = va_arg (aq, char **); va_end (aq); return execve (path, args, envp); }
void JNI_OnUnload (JavaVM, void *) { #ifndef __ANDROID__ __gcov_flush (); #endif }
void my_handler (int signum) { printf ("received signal\n"); printf ("%llu\n", i); __gcov_flush (); /* dump coverage data on receiving SIGUSR1 */ }
/** * Exit calling process with exit(0) using a standard syslog message. * This function should be called from the main thread of a server process in * a "safe" context for calling exit(). Any service specific thing should be * cleaned up before calling this function. By calling exit(), registered exit * functions are called before the process is terminated. */ void daemon_exit(void) { syslog(LOG_NOTICE, "exiting for shutdown"); if (__gcov_flush) { __gcov_flush(); } _Exit(0); }
pid_t __gcov_fork (void) { pid_t pid; __gcov_flush (); pid = fork (); if (pid == 0) __GTHREAD_MUTEX_INIT_FUNCTION (&__gcov_flush_mx); return pid; }
void quickExit(int code) { #ifdef MONGO_GCOV __gcov_flush(); #endif #if __has_feature(address_sanitizer) __lsan_do_leak_check(); #endif ::_exit(code); }
pid_t __gcov_fork (void) { pid_t pid; extern __gthread_mutex_t __gcov_flush_mx; __gcov_flush (); pid = fork (); if (pid == 0) __GTHREAD_MUTEX_INIT_FUNCTION (&__gcov_flush_mx); return pid; }
/** * \brief Send to master information that test suite finished its execution * * GREENTEA_TEST_ENV_END and GREENTEA_TEST_ENV_EXIT messages * are sent just before test suite execution finishes (noting * else to do). You can place it just before you return from your * main() function. * * Code coverage: If MEBD_CFG_DEBUG_OPTIONS_COVERAGE is set in the * project via build configuration function will output series * of code coverage messages GREENTEA_TEST_ENV_LCOV_START with code * coverage binary data. This data is captured by Greentea and can * be used to generate LCOV reports. * * \param result Test suite result from DUT (0 - FAIl, !0 - SUCCESS) * */ static void greentea_notify_completion(const int result) { const char *val = result ? GREENTEA_TEST_ENV_SUCCESS : GREENTEA_TEST_ENV_FAILURE; #ifdef MBED_CFG_DEBUG_OPTIONS_COVERAGE coverage_report = true; __gcov_flush(); coverage_report = false; #endif greentea_metrics_report(); greentea_send_kv(GREENTEA_TEST_ENV_END, val); greentea_send_kv(GREENTEA_TEST_ENV_EXIT, 0); }
void netstats(void) { pid_read(0); // include all processes printf("Displaying network statistics only for sandboxes using a new network namespace.\n"); // print processes while (1) { // set pid table int i; int itv = 5; // 5 second interval pid_read(0); // start rx/tx measurements for (i = 0; i < max_pids; i++) { if (pids[i].level == 1) get_stats(i); } // wait 5 seconds firemon_sleep(itv); // grab screen size struct winsize sz; int row = 24; int col = 80; if (!ioctl(0, TIOCGWINSZ, &sz)) { col = sz.ws_col; row = sz.ws_row; } // start printing firemon_clrscr(); char *header = get_header(); if (strlen(header) > (size_t)col) header[col] = '\0'; printf("%s\n", header); if (row > 0) row--; free(header); // start rx/tx measurements for (i = 0; i < max_pids; i++) { if (pids[i].level == 1) { get_stats(i); print_proc(i, itv, col); } } #ifdef HAVE_GCOV __gcov_flush(); #endif } }
int main() { int argc = 1; char* argv[] = {""}; printf("--- Test Start ---\n"); // Required for automated testing testing::InitGoogleTest(&argc, argv); RUN_ALL_TESTS(); __gcov_flush(); // Required for coverage testing printf("--- Test End ---\n"); // Required for automated testing return 0; }
void sighandler (int signo) { #ifdef SIMPLE_WAY exit (signo); #else extern void __gcov_flush (); // flush out gcov stats data __gcov_flush (); // raise the signal again to crash process raise (signo); #endif }
/** @brief Kill the program in silence */ void xbt_abort(void) { #ifdef COVERAGE /* Call __gcov_flush on abort when compiling with coverage options. */ extern void __gcov_flush(void); __gcov_flush(); #endif #ifdef _WIN32 /* It was said *in silence*. We don't want to see the error message printed * by the Microsoft's implementation of abort(). */ raise(SIGABRT); signal(SIGABRT, SIG_DFL); raise(SIGABRT); #endif abort(); }
// return -1 if error, 0 if no error void copy_file_as_user(const char *srcname, const char *destname, uid_t uid, gid_t gid, mode_t mode) { pid_t child = fork(); if (child < 0) errExit("fork"); if (child == 0) { // drop privileges drop_privs(0); // copy, set permissions and ownership int rv = copy_file(srcname, destname, uid, gid, mode); // already a regular user if (rv) fprintf(stderr, "Warning: cannot transfer .Xauthority in private home directory\n"); #ifdef HAVE_GCOV __gcov_flush(); #endif _exit(0); } // wait for the child to finish waitpid(child, NULL, 0); }
int tp_unittest_main(const char* path) { #ifdef RUN_ON_DEVICE #ifdef APP_IOS char gcdaFolder[1024] = ""; unsigned long uPathLen = 1024; GetDocumentPath(gcdaFolder, uPathLen); setenv("GCOV_PREFIX", gcdaFolder, 1); setenv("GCOV_PREFIX_STRIP", "1", 1); #endif #ifdef ANDROID setenv("GCOV_PREFIX", "/sdcard/wme_gcov/", 1); setenv("GCOV_PREFIX_STRIP", "6", 1); #endif #endif int argc = 1; const char *argv[] = {"tp_unittest_main"}; if (NULL == path || strlen(path) <= 0) return 1; char xmlPath[1024] = ""; sprintf(xmlPath, "xml:%s", path); printf("absolute path for XML:%s\n", xmlPath); ::testing::GTEST_FLAG(output) = xmlPath; ::testing::InitGoogleTest(&argc, (char **)argv); if(!g_sGTestFilter.empty()) { ::testing::FLAGS_gtest_filter = g_sGTestFilter.c_str(); } int ret = RUN_ALL_TESTS(); #ifdef ENABLED_GCOV_FLAG #if defined(MACOS) || defined(APP_IOS) __gcov_flush(); #endif #ifdef ANDROID exit(0); #endif #endif return ret; }
void fs_mkdir(const char *name) { EUID_ASSERT(); // check directory name invalid_filename(name, 0); // no globbing char *expanded = expand_macros(name); if (strncmp(expanded, cfg.homedir, strlen(cfg.homedir)) != 0 && strncmp(expanded, "/tmp", 4) != 0) { fprintf(stderr, "Error: only directories in user home or /tmp are supported by mkdir\n"); exit(1); } struct stat s; if (stat(expanded, &s) == 0) { // file exists, do nothing goto doexit; } // create directory pid_t child = fork(); if (child < 0) errExit("fork"); if (child == 0) { // drop privileges drop_privs(0); // create directory mkdir_recursive(expanded); #ifdef HAVE_GCOV __gcov_flush(); #endif _exit(0); } // wait for the child to finish waitpid(child, NULL, 0); doexit: free(expanded); }
// return -1 if error, 0 if no error void touch_file_as_user(const char *fname, uid_t uid, gid_t gid, mode_t mode) { pid_t child = fork(); if (child < 0) errExit("fork"); if (child == 0) { // drop privileges drop_privs(0); FILE *fp = fopen(fname, "w"); if (fp) { fprintf(fp, "\n"); SET_PERMS_STREAM(fp, uid, gid, mode); fclose(fp); } #ifdef HAVE_GCOV __gcov_flush(); #endif _exit(0); } // wait for the child to finish waitpid(child, NULL, 0); }
int __gcov_execve (const char *path, char *const argv[], char *const envp[]) { __gcov_flush (); return execve (path, argv, envp); }
int __gcov_execvp (const char *path, char *const argv[]) { __gcov_flush (); return execvp (path, argv); }
void appimage_set(const char *appimage) { assert(appimage); assert(devloop == NULL); // don't call this twice! EUID_ASSERT(); #ifdef LOOP_CTL_GET_FREE // test for older kernels; this definition is found in /usr/include/linux/loop.h // check appimage file invalid_filename(appimage); if (access(appimage, R_OK) == -1) { fprintf(stderr, "Error: cannot access AppImage file\n"); exit(1); } // get appimage type and ELF size // a value of 0 means we are dealing with a type1 appimage long unsigned int size = appimage2_size(appimage); if (arg_debug) printf("AppImage ELF size %lu\n", size); // open appimage file /* coverity[toctou] */ int ffd = open(appimage, O_RDONLY|O_CLOEXEC); if (ffd == -1) { fprintf(stderr, "Error: cannot open AppImage file\n"); exit(1); } // find or allocate a free loop device to use EUID_ROOT(); int cfd = open("/dev/loop-control", O_RDWR); if (cfd == -1) { fprintf(stderr, "Error: /dev/loop-control interface is not supported by your kernel\n"); exit(1); } int devnr = ioctl(cfd, LOOP_CTL_GET_FREE); if (devnr == -1) { fprintf(stderr, "Error: cannot allocate a new loopback device\n"); exit(1); } close(cfd); if (asprintf(&devloop, "/dev/loop%d", devnr) == -1) errExit("asprintf"); int lfd = open(devloop, O_RDONLY); if (lfd == -1) { fprintf(stderr, "Error: cannot open %s\n", devloop); exit(1); } if (ioctl(lfd, LOOP_SET_FD, ffd) == -1) { fprintf(stderr, "Error: cannot configure the loopback device\n"); exit(1); } if (size) { struct loop_info64 info; memset(&info, 0, sizeof(struct loop_info64)); info.lo_offset = size; if (ioctl(lfd, LOOP_SET_STATUS64, &info) == -1) errExit("configure appimage offset"); } close(lfd); close(ffd); EUID_USER(); // creates appimage mount point perms 0700 if (asprintf(&mntdir, "%s/.appimage-%u", RUN_FIREJAIL_APPIMAGE_DIR, getpid()) == -1) errExit("asprintf"); EUID_ROOT(); mkdir_attr(mntdir, 0700, getuid(), getgid()); EUID_USER(); // mount char *mode; if (asprintf(&mode, "mode=700,uid=%d,gid=%d", getuid(), getgid()) == -1) errExit("asprintf"); EUID_ROOT(); if (size == 0) { if (mount(devloop, mntdir, "iso9660",MS_MGC_VAL|MS_RDONLY, mode) < 0) errExit("mounting appimage"); } else { if (mount(devloop, mntdir, "squashfs",MS_MGC_VAL|MS_RDONLY, mode) < 0) errExit("mounting appimage"); } if (arg_debug) printf("appimage mounted on %s\n", mntdir); EUID_USER(); // set environment if (setenv("APPIMAGE", appimage, 1) < 0) errExit("setenv"); if (mntdir && setenv("APPDIR", mntdir, 1) < 0) errExit("setenv"); // build new command line if (asprintf(&cfg.command_line, "%s/AppRun", mntdir) == -1) errExit("asprintf"); free(mode); #ifdef HAVE_GCOV __gcov_flush(); #endif #else fprintf(stderr, "Error: /dev/loop-control interface is not supported by your kernel\n"); exit(1); #endif }
void profile_read(const char *fname) { EUID_ASSERT(); // exit program if maximum include level was reached if (include_level > MAX_INCLUDE_LEVEL) { fprintf(stderr, "Error: maximum profile include level was reached\n"); exit(1); } // check file invalid_filename(fname); if (strlen(fname) == 0 || is_dir(fname)) { fprintf(stderr, "Error: invalid profile file\n"); exit(1); } if (access(fname, R_OK)) { // if the file ends in ".local", do not exit const char *base = gnu_basename(fname); char *ptr = strstr(base, ".local"); if (ptr && strlen(ptr) == 6) return; fprintf(stderr, "Error: cannot access profile file\n"); exit(1); } // allow debuggers if (arg_allow_debuggers) { char *tmp = strrchr(fname, '/'); if (tmp && *(tmp + 1) != '\0') { tmp++; if (strcmp(tmp, "disable-devel.inc") == 0) return; } } // open profile file: FILE *fp = fopen(fname, "r"); if (fp == NULL) { fprintf(stderr, "Error: cannot open profile file %s\n", fname); exit(1); } int msg_printed = 0; // read the file line by line char buf[MAX_READ + 1]; int lineno = 0; while (fgets(buf, MAX_READ, fp)) { ++lineno; // remove empty space - ptr in allocated memory char *ptr = line_remove_spaces(buf); if (ptr == NULL) continue; // comments if (*ptr == '#' || *ptr == '\0') { free(ptr); continue; } // process quiet if (strcmp(ptr, "quiet") == 0) { arg_quiet = 1; free(ptr); continue; } if (!msg_printed) { if (!arg_quiet) fprintf(stderr, "Reading profile %s\n", fname); msg_printed = 1; } // process include if (strncmp(ptr, "include ", 8) == 0) { include_level++; // extract profile filename and new skip params char *newprofile = ptr + 8; // profile name // expand ${HOME}/ in front of the new profile file char *newprofile2 = expand_home(newprofile, cfg.homedir); // recursivity profile_read((newprofile2)? newprofile2:newprofile); include_level--; if (newprofile2) free(newprofile2); free(ptr); continue; } // verify syntax, exit in case of error if (profile_check_line(ptr, lineno, fname)) profile_add(ptr); // we cannot free ptr here, data is extracted from ptr and linked as a pointer in cfg structure // else { // free(ptr); // } #ifdef HAVE_GCOV __gcov_flush(); #endif } fclose(fp); }
static void gcov_handler(int signum) { __gcov_flush(); exit(1); }
// disable shm in pulseaudio void pulseaudio_init(void) { struct stat s; // do we have pulseaudio in the system? if (stat("/etc/pulse/client.conf", &s) == -1) { if (arg_debug) printf("/etc/pulse/client.conf not found\n"); return; } // create the new user pulseaudio directory if (mkdir(RUN_PULSE_DIR, 0700) == -1) errExit("mkdir"); // make it a mount point and add mount flags if (mount(RUN_PULSE_DIR, RUN_PULSE_DIR, NULL, MS_BIND, NULL) < 0 || mount(NULL, RUN_PULSE_DIR, NULL, MS_NOEXEC|MS_NODEV|MS_NOSUID|MS_BIND|MS_REMOUNT, NULL) < 0) errExit("mount RUN_PULSE_DIR"); // create the new client.conf file char *pulsecfg = NULL; if (asprintf(&pulsecfg, "%s/client.conf", RUN_PULSE_DIR) == -1) errExit("asprintf"); if (copy_file("/etc/pulse/client.conf", pulsecfg, -1, -1, 0644)) // root needed errExit("copy_file"); FILE *fp = fopen(pulsecfg, "a+"); if (!fp) errExit("fopen"); fprintf(fp, "%s", "\nenable-shm = no\n"); SET_PERMS_STREAM(fp, getuid(), getgid(), 0644); fclose(fp); // hand over the directory to the user if (set_perms(RUN_PULSE_DIR, getuid(), getgid(), 0700)) errExit("set_perms"); // create ~/.config/pulse directory if not present char *dir1; if (asprintf(&dir1, "%s/.config", cfg.homedir) == -1) errExit("asprintf"); if (lstat(dir1, &s) == -1) { pid_t child = fork(); if (child < 0) errExit("fork"); if (child == 0) { // drop privileges drop_privs(0); int rv = mkdir(dir1, 0755); if (rv == 0) { if (set_perms(dir1, getuid(), getgid(), 0755)) {;} // do nothing } #ifdef HAVE_GCOV __gcov_flush(); #endif _exit(0); } // wait for the child to finish waitpid(child, NULL, 0); fs_logger2("create", dir1); } else { // we expect a user owned directory if (!S_ISDIR(s.st_mode) || s.st_uid != getuid()) { if (S_ISLNK(s.st_mode)) fprintf(stderr, "Error: user .config is a symbolic link\n"); else fprintf(stderr, "Error: user .config is not a directory owned by the current user\n"); exit(1); } } free(dir1); if (asprintf(&dir1, "%s/.config/pulse", cfg.homedir) == -1) errExit("asprintf"); if (lstat(dir1, &s) == -1) { pid_t child = fork(); if (child < 0) errExit("fork"); if (child == 0) { // drop privileges drop_privs(0); int rv = mkdir(dir1, 0700); if (rv == 0) { if (set_perms(dir1, getuid(), getgid(), 0700)) {;} // do nothing } #ifdef HAVE_GCOV __gcov_flush(); #endif _exit(0); } // wait for the child to finish waitpid(child, NULL, 0); fs_logger2("create", dir1); } else { // we expect a user owned directory if (!S_ISDIR(s.st_mode) || s.st_uid != getuid()) { if (S_ISLNK(s.st_mode)) fprintf(stderr, "Error: user .config/pulse is a symbolic link\n"); else fprintf(stderr, "Error: user .config/pulse is not a directory owned by the current user\n"); exit(1); } } free(dir1); // if we have ~/.config/pulse mount the new directory, else set environment variable. char *homeusercfg; if (asprintf(&homeusercfg, "%s/.config/pulse", cfg.homedir) == -1) errExit("asprintf"); if (stat(homeusercfg, &s) == 0) { // get a file descriptor for ~/.config/pulse, fails if there is any symlink int fd = safe_fd(homeusercfg, O_PATH|O_DIRECTORY|O_NOFOLLOW|O_CLOEXEC); if (fd == -1) errExit("safe_fd"); // confirm the actual mount destination is owned by the user if (fstat(fd, &s) == -1 || s.st_uid != getuid()) errExit("fstat"); // mount via the link in /proc/self/fd char *proc; if (asprintf(&proc, "/proc/self/fd/%d", fd) == -1) errExit("asprintf"); if (mount(RUN_PULSE_DIR, proc, "none", MS_BIND, NULL) < 0) errExit("mount pulseaudio"); fs_logger2("tmpfs", homeusercfg); free(proc); close(fd); // check /proc/self/mountinfo to confirm the mount is ok MountData *mptr = get_last_mount(); if (strcmp(mptr->dir, homeusercfg) != 0 || strcmp(mptr->fstype, "tmpfs") != 0) errLogExit("invalid pulseaudio mount"); char *p; if (asprintf(&p, "%s/client.conf", homeusercfg) == -1) errExit("asprintf"); fs_logger2("create", p); free(p); } else { // set environment if (setenv("PULSE_CLIENTCONFIG", pulsecfg, 1) < 0) errExit("setenv"); } free(pulsecfg); free(homeusercfg); }
static void unix_signal_handler (int signum, siginfo_t * si, ucontext_t * uc) { uword fatal = 0; /* These come in handy when looking at core files from optimized images */ last_signum = signum; last_faulting_address = (uword) si->si_addr; syslog_msg = format (syslog_msg, "received signal %U, PC %U", format_signal, signum, format_ucontext_pc, uc); if (signum == SIGSEGV) syslog_msg = format (syslog_msg, ", faulting address %p", si->si_addr); switch (signum) { /* these (caught) signals cause the application to exit */ case SIGTERM: /* * Ignore SIGTERM if it's sent before we're ready. */ if (unix_main.vlib_main && unix_main.vlib_main->main_loop_exit_set) { syslog (LOG_ERR | LOG_DAEMON, "received SIGTERM, exiting..."); unix_main.vlib_main->main_loop_exit_now = 1; } else syslog (LOG_ERR | LOG_DAEMON, "IGNORE early SIGTERM..."); break; /* fall through */ case SIGQUIT: case SIGINT: case SIGILL: case SIGBUS: case SIGSEGV: case SIGHUP: case SIGFPE: case SIGABRT: fatal = 1; break; /* by default, print a message and continue */ default: fatal = 0; break; } #ifdef CLIB_GCOV /* * Test framework sends SIGTERM, so we need to flush the * code coverage stats here. */ { void __gcov_flush (void); __gcov_flush (); } #endif /* Null terminate. */ vec_add1 (syslog_msg, 0); if (fatal) { syslog (LOG_ERR | LOG_DAEMON, "%s", syslog_msg); /* Address of callers: outer first, inner last. */ uword callers[15]; uword n_callers = clib_backtrace (callers, ARRAY_LEN (callers), 0); int i; for (i = 0; i < n_callers; i++) { vec_reset_length (syslog_msg); syslog_msg = format (syslog_msg, "#%-2d 0x%016lx %U%c", i, callers[i], format_clib_elf_symbol_with_address, callers[i], 0); syslog (LOG_ERR | LOG_DAEMON, "%s", syslog_msg); } /* have to remove SIGABRT to avoid recusive - os_exit calling abort() */ unsetup_signal_handlers (SIGABRT); os_exit (1); } else clib_warning ("%s", syslog_msg); }
pid_t __gcov_fork (void) { __gcov_flush (); return fork (); }