--- /dev/null
+/*
+ * Copyright (c) 2007 Apple Inc. All rights reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <libkern/OSAtomic.h>
+#include <mach/mach.h>
+#include <mach/mach_vm.h>
+#include <sys/sysctl.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <pthread.h>
+#include <errno.h>
+#include "stack_logging.h"
+#include "malloc_printf.h"
+#include "_simple.h" // as included by malloc.c, this defines ASL_LEVEL_INFO
+
+#pragma mark -
+#pragma mark Defines
+
+#ifdef TEST_DISK_STACK_LOGGING
+#define _malloc_printf fprintf
+#undef ASL_LEVEL_INFO
+#define ASL_LEVEL_INFO stderr
+#endif
+
+#define STACK_LOGGING_THREAD_HASH_SIZE 2048 // must be an even power of two
+#define STACK_LOGGING_MAX_STACK_SIZE 512
+#define STACK_LOGGING_BLOCK_WRITING_SIZE 8192
+#define STACK_LOGGING_NUMBER_RECENT_BACKTRACES 50
+#define STACK_LOGGING_FORCE_FULL_BACKTRACE_EVERY 100
+#define STACK_LOGGING_MAX_THREAD_COLLISIONS 3
+#define STACK_LOGGING_MIN_SAME_FRAMES 3
+#define STACK_LOGGING_MAX_SIMUL_REMOTE_TASKS_INSPECTED 3
+#define STACK_LOGGING_REMOTE_CACHE_DEFAULT_COLLISION_ALLOWANCE 5
+#define STACK_LOGGING_REMOTE_CACHE_DEFAULT_NODE_CAPACITY 1 << 14 // <2mb for 32->32, ~3mb for (32->64 || 64->32), ~4mb for 64->64
+#define STACK_LOGGING_REMOTE_CACHE_COLLISION_GROWTH_RATE 3
+#define STACK_LOGGING_REMOTE_LINKS_PER_BLOCK (1 << 20) // this sets a maximum number of malloc/frees that can be read in to: 1^30;
+ // this means if the .index file is >24gb, remote access will start to fail.
+ // note: at this point, the .stack file will probably be ~56gb on top of that and
+ // it'll also be using around 20 gb of memory in the analyzing process...
+ // all of these are 64-bit stats; the 32-bit analyzing process limits are lower.
+ // in short, if you want to analyze a process making > 1 billion malloc/frees
+ // (after compaction), bump this number slightly.
+
+#pragma mark -
+#pragma mark Macros
+
+#define STACK_LOGGING_FLAGS(longlongvar) (uint8_t)((uint64_t)(longlongvar) >> 56)
+#define STACK_LOGGING_OFFSET(longlongvar) ((longlongvar) & 0x00FFFFFFFFFFFFFFull)
+#define STACK_LOGGING_OFFSET_AND_FLAGS(longlongvar, realshortvar) (((uint64_t)(longlongvar) & 0x00FFFFFFFFFFFFFFull) | ((uint64_t)(realshortvar) << 56))
+
+#pragma mark -
+#pragma mark Types
+
+#pragma mark - stack_logging_backtrace_event
+typedef struct {
+ int16_t offset_delta; // may want to expand this one; should always be < 0.
+ uint16_t num_identical_frames;
+ uint16_t num_new_hot_frames; // count of backtrace[]
+} stack_logging_backtrace_event;
+
+#pragma mark - stack_logging_index_event
+typedef struct {
+ uintptr_t argument;
+ uintptr_t address;
+ uint64_t offset_and_flags; // top 8 bits are actually the flags!
+} stack_logging_index_event;
+
+#pragma mark - stack_logging_index_event32
+typedef struct {
+ uint32_t argument;
+ uint32_t address;
+ uint64_t offset_and_flags; // top 8 bits are actually the flags!
+} stack_logging_index_event32;
+
+#pragma mark - stack_logging_index_event64
+typedef struct {
+ uint64_t argument;
+ uint64_t address;
+ uint64_t offset_and_flags; // top 8 bits are actually the flags!
+} stack_logging_index_event64;
+
+#pragma mark - thread_backtrace_history
+// for management of previous backtraces (by thread):
+typedef struct {
+ vm_address_t thread;
+ uint32_t hash_pos;
+ uint64_t logging_index;
+ int64_t logging_offset;
+ uint32_t full_backtrace_countdown;
+ uint32_t backtrace_length;
+ uintptr_t *backtrace;
+} thread_backtrace_history;
+
+#pragma mark - stack_buffer_shared_memory
+// for storing/looking up allocations that haven't yet be written to disk; consistent size across 32/64-bit processes.
+// It's important that these fields don't change alignment due to the architecture because they may be accessed from an
+// analyzing process with a different arch - hence the pragmas.
+#pragma pack(push,4)
+typedef struct {
+ uint64_t start_index_offset;
+ uint64_t start_stack_offset;
+ uint32_t next_free_index_buffer_offset;
+ uint32_t next_free_stack_buffer_offset;
+ char index_buffer[STACK_LOGGING_BLOCK_WRITING_SIZE];
+ char stack_buffer[STACK_LOGGING_BLOCK_WRITING_SIZE];
+} stack_buffer_shared_memory;
+#pragma pack(pop)
+
+#pragma mark - index_ll_node
+// linked-list node in table for allocations of a single address
+typedef struct index_ll_node {
+ struct index_ll_node *next;
+ uint64_t index_file_offset;
+} index_ll_node;
+
+#pragma mark - remote_index_node32
+// 32-bit target process address slot in table
+typedef struct {
+ uint32_t address;
+ index_ll_node *linked_list;
+ index_ll_node *last_link;
+} remote_index_node32;
+
+#pragma mark - remote_index_node64
+// 64-bit target process variant
+typedef struct {
+ uint64_t address;
+ index_ll_node *linked_list;
+ index_ll_node *last_link;
+} remote_index_node64;
+
+#pragma mark - remote_index_cache
+// for caching index information client-side:
+typedef struct {
+ size_t cache_size;
+ size_t cache_node_capacity;
+ uint32_t collision_allowance;
+ uint64_t cache_node_count; // Debug only.
+ uint64_t cache_llnode_count; // Debug only.
+ size_t in_use_node_size; // sizeof(remote_index_node32) || sizeof(remote_index_node64)
+ void *table_memory; // this can be malloced; it's on the client side.
+ remote_index_node32 *casted_table32; // represents table memory as 32-bit.
+ remote_index_node64 *casted_table64; // ditto, 64-bit
+ stack_buffer_shared_memory *shmem; // shared memory
+ stack_buffer_shared_memory snapshot; // memory snapshot of the remote process' shared memory
+ uint32_t last_pre_written_index_size;
+ uint64_t last_index_file_offset;
+ index_ll_node *blocks[1024];
+ uint32_t current_block;
+ uint32_t next_block_index;
+} remote_index_cache;
+
+#pragma mark - remote_task_file_streams
+// for reading stack history information from remote processes:
+typedef struct {
+ task_t remote_task;
+ pid_t remote_pid;
+ int32_t task_is_64_bit;
+ int32_t in_use_count;
+ FILE *index_file_stream;
+ FILE *stack_file_stream;
+ remote_index_cache *cache;
+} remote_task_file_streams;
+
+#pragma mark -
+#pragma mark Constants
+
+static stack_buffer_shared_memory *pre_write_buffers;
+static char *pre_write_backtrace_event_buffer = NULL;
+static char *pre_write_index_buffer = NULL;
+
+static OSSpinLock stack_logging_lock = OS_SPINLOCK_INIT;
+static uint64_t current_logging_index = 0;
+static int64_t total_offset = 0;
+
+// single-thread access variables
+static vm_address_t stack_buffer[STACK_LOGGING_NUMBER_RECENT_BACKTRACES][STACK_LOGGING_MAX_STACK_SIZE];
+static thread_backtrace_history thread_buffer[STACK_LOGGING_THREAD_HASH_SIZE];
+static int32_t current_stack_buffer = 0;
+static uintptr_t last_logged_malloc_address = 0;
+static uint32_t last_logged_backtrace_offset_diff = 0;
+static thread_backtrace_history compaction_saved_differencing_history;
+
+// Constants to define stack logging directory and path names.
+// Files will get written to /tmp/stack-logs.<pid>.<progname>.XXXXXX/stack-logs.{index,stacks}
+// The directory is securely created with mkdtemp() and the files inside it just have static names for simplicity.
+static const char *temporary_directory = "/tmp";
+static const char *stack_logging_directory_base_name = "stack-logs.";
+static const char *index_file_name = "stack-logs.index";
+static const char *stack_file_name = "stack-logs.stacks";
+
+static char stack_logs_directory[PATH_MAX];
+static char index_file_path[PATH_MAX];
+static char stack_file_path[PATH_MAX];
+static int index_file_descriptor = -1;
+static int stack_file_descriptor = -1;
+
+// for accessing remote log files
+static remote_task_file_streams remote_fds[STACK_LOGGING_MAX_SIMUL_REMOTE_TASKS_INSPECTED];
+static uint32_t next_remote_task_fd = 0;
+static uint32_t remote_task_fd_count = 0;
+static OSSpinLock remote_fd_list_lock = OS_SPINLOCK_INIT;
+
+// activation variables
+
+static int logging_use_compaction = 1; // set this to zero to always disable compaction.
+
+// We set malloc_logger to NULL to disable logging, if we encounter errors
+// during file writing
+typedef void (malloc_logger_t)(uint32_t type, uintptr_t arg1, uintptr_t arg2, uintptr_t arg3, uintptr_t result, uint32_t num_hot_frames_to_skip);
+extern malloc_logger_t *malloc_logger;
+
+#pragma mark -
+#pragma mark Disk Stack Logging
+
+static void delete_log_files(void); // pre-declare
+
+static void
+append_int(char * filename, pid_t pid)
+{
+ unsigned int value;
+ size_t len;
+ unsigned int i;
+ unsigned int count;
+
+ len = strlen(filename);
+
+ count = 0;
+ value = pid;
+ while (value > 0) {
+ value /= 10;
+ count ++;
+ }
+
+ filename[len + count] = 0;
+
+ value = pid;
+ for(i = 0 ; i < count ; i ++) {
+ filename[len + count - 1 - i] = '0' + value % 10;
+ value /= 10;
+ }
+}
+
+// If successful, returns path to directory that was created. Otherwise returns NULL.
+static char *
+create_log_files(void)
+{
+ pid_t pid = getpid();
+ const char *progname = getprogname();
+ char path_name[PATH_MAX];
+ char *created_directory = NULL;
+
+ // WARNING! use of snprintf can induce malloc() calls
+ strlcpy(stack_logs_directory, temporary_directory, PATH_MAX);
+ strlcat(stack_logs_directory, "/", PATH_MAX);
+ strlcat(stack_logs_directory, stack_logging_directory_base_name, PATH_MAX);
+ append_int(stack_logs_directory, pid);
+ if (progname && progname[0] != '\0') {
+ strlcat(stack_logs_directory, ".", PATH_MAX);
+ strlcat(stack_logs_directory, progname, PATH_MAX);
+ }
+ strlcat(stack_logs_directory, ".XXXXXX", PATH_MAX);
+
+ // Securely make temporary directory for the log files, then create the files.
+ if (mkdtemp(stack_logs_directory) == stack_logs_directory) {
+ strlcpy(path_name, stack_logs_directory, PATH_MAX);
+ strlcat(path_name, "/", PATH_MAX);
+ strlcat(path_name, index_file_name, PATH_MAX);
+ strlcpy(index_file_path, path_name, PATH_MAX);
+ index_file_descriptor = open(path_name, O_WRONLY | O_TRUNC | O_CREAT, 0600);
+
+ strlcpy(path_name, stack_logs_directory, PATH_MAX);
+ strlcat(path_name, "/", PATH_MAX);
+ strlcat(path_name, stack_file_name, PATH_MAX);
+ strlcpy(stack_file_path, path_name, PATH_MAX);
+ stack_file_descriptor = open(path_name, O_WRONLY | O_TRUNC | O_CREAT, 0600);
+
+ if (index_file_descriptor == -1 || stack_file_descriptor == -1) {
+ _malloc_printf(ASL_LEVEL_INFO, "unable to create stack log files in directory %s\n", stack_logs_directory);
+ delete_log_files();
+ created_directory = NULL;
+ } else {
+ _malloc_printf(ASL_LEVEL_INFO, "stack logs being written into %s\n", stack_logs_directory);
+ created_directory = stack_logs_directory;
+ }
+ } else {
+ _malloc_printf(ASL_LEVEL_INFO, "unable to create stack log directory %s\n", stack_logs_directory);
+ created_directory = NULL;
+ }
+ return created_directory;
+}
+
+// This function may be called from either the target process when exiting, or from either the the target process or
+// a stack log analysis process, when reaping orphaned stack log files.
+// Returns -1 if the files exist and they couldn't be removed, returns 0 otherwise.
+static int
+delete_log_files_in_directory(char *logdir)
+{
+ char path_name[PATH_MAX];
+ int unlink_count = 0;
+ int failure_count = 0;
+ struct stat statbuf;
+
+ if (logdir == NULL || logdir[0] == '\0') return 0;
+
+ strlcpy(path_name, logdir, PATH_MAX);
+ strlcat(path_name, "/", PATH_MAX);
+ strlcat(path_name, index_file_name, PATH_MAX);
+ if (unlink(path_name) == 0) {
+ unlink_count++;
+ } else if (stat(path_name, &statbuf) == 0) {
+ failure_count++;
+ }
+
+ strlcpy(path_name, logdir, PATH_MAX);
+ strlcat(path_name, "/", PATH_MAX);
+ strlcat(path_name, stack_file_name, PATH_MAX);
+ if (unlink(path_name) == 0) {
+ unlink_count++;
+ } else if (stat(path_name, &statbuf) == 0) {
+ failure_count++;
+ }
+
+ if (rmdir(logdir) == -1) failure_count++;
+
+ return (failure_count > 0) ? -1 : 0;
+}
+
+// This function will be called from atexit() in the target process.
+static void
+delete_log_files(void)
+{
+ if (stack_logs_directory == NULL || stack_logs_directory[0] == '\0') return;
+
+ if (delete_log_files_in_directory(stack_logs_directory) == 0) {
+ _malloc_printf(ASL_LEVEL_INFO, "stack logs deleted from %s\n", stack_logs_directory);
+ stack_file_path[0] = '\0';
+ index_file_path[0] = '\0';
+ } else {
+ _malloc_printf(ASL_LEVEL_INFO, "unable to delete stack logs from %s\n", stack_logs_directory);
+ }
+}
+
+static bool
+is_process_running(pid_t pid)
+{
+ struct kinfo_proc kpt[1];
+ size_t size = sizeof(struct kinfo_proc);
+ int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
+
+ sysctl(mib, 4, kpt, &size, NULL, 0); // size is either 1 or 0 entries when we ask for a single pid
+
+ return (size==sizeof(struct kinfo_proc));
+}
+
+// The log files can be quite large and aren't too useful after the process that created them no longer exists.
+// Normally they should get removed when the process exits, but if the process crashed the log files might remain.
+// So, reap any stack log files for processes that no longer exist.
+//
+// lf the remove_for_this_pid flag is set, then any log files that already exist for the current process will also be deleted.
+// Those log files are probably the result of this process having been exec'ed from another one (without a fork()).
+// The remove_for_this_pid flag is only set for a target process (one just starting logging); a stack logging "client"
+// process reaps log files too, but if we're using stack logging on the client process itself, then we don't want to remove
+// its own log files.
+static void
+reap_orphaned_log_files(bool remove_for_this_pid)
+{
+ DIR *dp;
+ struct dirent *entry;
+ int prefix_length;
+ char prefix_name[PATH_MAX];
+ char pathname[PATH_MAX];
+ pid_t current_pid = getpid();
+
+ if ((dp = opendir(temporary_directory)) == NULL) {
+ return;
+ }
+
+ strlcpy(prefix_name, stack_logging_directory_base_name, PATH_MAX);
+ prefix_length = strlen(prefix_name);
+
+ while ( (entry = readdir(dp)) != NULL ) {
+ if ( entry->d_type == DT_DIR && ( strncmp( entry->d_name, prefix_name, prefix_length) == 0 ) ) {
+ long pid = strtol(&entry->d_name[prefix_length], (char **)NULL, 10);
+ if ( (! is_process_running(pid)) || (remove_for_this_pid && pid == current_pid) ) {
+ strlcpy(pathname, temporary_directory, PATH_MAX);
+ strlcat(pathname, "/", PATH_MAX);
+ strlcat(pathname, entry->d_name, PATH_MAX);
+ if (delete_log_files_in_directory(pathname) == 0) {
+ if (remove_for_this_pid && pid == current_pid) {
+ _malloc_printf(ASL_LEVEL_INFO, "stack logs deleted from %s\n", pathname);
+ } else {
+ _malloc_printf(ASL_LEVEL_INFO, "process %d no longer exists, stack logs deleted from %s\n", pid, pathname);
+ }
+ }
+ }
+ }
+ }
+ closedir(dp);
+}
+
+/*
+ * Since there a many errors that could cause stack logging to get disabled, this is a convenience method
+ * for disabling any future logging in this process and for informing the user.
+ */
+static void
+disable_stack_logging(void)
+{
+ _malloc_printf(ASL_LEVEL_INFO, "stack logging disabled due to previous errors.\n");
+ stack_logging_enable_logging = 0;
+ malloc_logger = NULL;
+}
+
+/* A wrapper around write() that will try to reopen the index/stack file and
+ * write to it if someone closed it underneath us (e.g. the process we just
+ * started decide to close all file descriptors except stin/err/out). Some
+ * programs like to do that and calling abort() on them is rude.
+ */
+static ssize_t
+robust_write(int fd, const void *buf, size_t nbyte) {
+ extern int errno;
+ ssize_t written = write(fd, buf, nbyte);
+ if (written == -1 && errno == EBADF) {
+ char *file_to_reopen = NULL;
+ int *fd_to_reset = NULL;
+
+ // descriptor was closed on us. We need to reopen it
+ if (fd == index_file_descriptor) {
+ file_to_reopen = index_file_path;
+ fd_to_reset = &index_file_descriptor;
+ }
+ else if (fd == stack_file_descriptor) {
+ file_to_reopen = stack_file_path;
+ fd_to_reset = &stack_file_descriptor;
+ } else {
+ // We don't know about this file. Return (and abort()).
+ _malloc_printf(ASL_LEVEL_INFO, "Unknown file descriptor (it's neither the index file, nor the stacks file)\n");
+ return -1;
+ }
+
+ // The file *should* already exist. If not, fail.
+ fd = open(file_to_reopen, O_WRONLY | O_APPEND);
+ if (fd < 3) {
+ // If we somehow got stdin/out/err, we need to relinquish them and
+ // get another fd.
+ int fds_to_close[3] = { 0 };
+ while (fd < 3) {
+ if (fd == -1) {
+ _malloc_printf(ASL_LEVEL_INFO, "unable to re-open stack log file %s\n", file_to_reopen);
+ delete_log_files();
+ return -1;
+ }
+ fds_to_close[fd] = 1;
+ fd = dup(fd);
+ }
+
+ // We have an fd we like. Close the ones we opened.
+ if (fds_to_close[0]) close(0);
+ if (fds_to_close[1]) close(1);
+ if (fds_to_close[2]) close(2);
+ }
+
+ *fd_to_reset = fd;
+ written = write(fd, buf, nbyte);
+ }
+ return written;
+}
+
+static void
+flush_data(void)
+{
+ ssize_t written; // signed size_t
+ size_t remaining;
+ char * p;
+
+ if (index_file_descriptor == -1) {
+ if (create_log_files() == NULL) {
+ return;
+ }
+ }
+
+ // Write the events before the index so that hopefully the events will be on disk if the index refers to them.
+ p = pre_write_backtrace_event_buffer;
+ remaining = (size_t)pre_write_buffers->next_free_stack_buffer_offset;
+ while (remaining > 0) {
+ written = robust_write(stack_file_descriptor, p, remaining);
+ if (written == -1) {
+ _malloc_printf(ASL_LEVEL_INFO, "Unable to write to stack logging file %s (%s)\n", stack_file_path, strerror(errno));
+ disable_stack_logging();
+ return;
+ }
+ p += written;
+ remaining -= written;
+ }
+ p = pre_write_index_buffer;
+ remaining = (size_t)pre_write_buffers->next_free_index_buffer_offset;
+ while (remaining > 0) {
+ written = robust_write(index_file_descriptor, p, remaining);
+ if (written == -1) {
+ _malloc_printf(ASL_LEVEL_INFO, "Unable to write to stack logging file %s (%s)\n", index_file_path, strerror(errno));
+ disable_stack_logging();
+ return;
+ }
+ p += written;
+ remaining -= written;
+ }
+
+ pre_write_buffers->start_stack_offset += pre_write_buffers->next_free_stack_buffer_offset;
+ pre_write_buffers->start_index_offset += pre_write_buffers->next_free_index_buffer_offset;
+ pre_write_buffers->next_free_index_buffer_offset = pre_write_buffers->next_free_stack_buffer_offset = 0;
+}
+
+static void
+prepare_to_log_stacks(void)
+{
+ if (!pre_write_buffers) {
+ last_logged_malloc_address = 0ul;
+ logging_use_compaction = (stack_logging_dontcompact ? 0 : logging_use_compaction);
+
+ // Create a shared memory region to hold the pre-write index and stack buffers. This will allow remote analysis processes to access
+ // these buffers to get logs for even the most recent allocations. The remote process will need to pause this process to assure that
+ // the contents of these buffers don't change while being inspected.
+ char shmem_name_string[PATH_MAX];
+ strlcpy(shmem_name_string, stack_logging_directory_base_name, (size_t)PATH_MAX);
+ append_int(shmem_name_string, getpid());
+
+ int shmid = shm_open(shmem_name_string, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR);
+ if (shmid < 0) {
+ // Failed to create shared memory region; turn off stack logging.
+ _malloc_printf(ASL_LEVEL_INFO, "error while allocating shared memory for disk-based stack logging output buffers\n");
+ disable_stack_logging();
+ return;
+ }
+
+ size_t full_shared_mem_size = sizeof(stack_buffer_shared_memory);
+ ftruncate(shmid, (off_t)full_shared_mem_size);
+ pre_write_buffers = (stack_buffer_shared_memory*)mmap(0, full_shared_mem_size, PROT_READ | PROT_WRITE, MAP_SHARED, shmid, (off_t)0);
+ close(shmid);
+
+ if (!pre_write_buffers) {
+ _malloc_printf(ASL_LEVEL_INFO, "error mapping in shared memory for disk-based stack logging output buffers\n");
+ disable_stack_logging();
+ return;
+ }
+
+ // Store and use the buffer offsets in shared memory so that they can be accessed remotely
+ pre_write_buffers->start_index_offset = pre_write_buffers->start_stack_offset = 0ull;
+ pre_write_buffers->next_free_index_buffer_offset = pre_write_buffers->next_free_stack_buffer_offset = 0;
+ pre_write_backtrace_event_buffer = pre_write_buffers->stack_buffer;
+ pre_write_index_buffer = pre_write_buffers->index_buffer;
+
+ // malloc() can be called by the following, so these need to be done outside the stack_logging_lock but after the buffers have been set up.
+ atexit(delete_log_files); // atexit() can call malloc()
+ reap_orphaned_log_files(true); // this calls opendir() which calls malloc()
+
+ // this call to flush data ensures that the log files (while possibly empty) exist; analyzing processes will rely on this assumption.
+ flush_data();
+ }
+}
+
+void
+__disk_stack_logging_log_stack(uint32_t type_flags, uintptr_t zone_ptr, uintptr_t size, uintptr_t ptr_arg, uintptr_t return_val, uint32_t num_hot_to_skip)
+{
+ if (!stack_logging_enable_logging) return;
+
+ // check incoming data
+ if (type_flags & stack_logging_type_alloc && type_flags & stack_logging_type_dealloc) {
+ uintptr_t swapper = size;
+ size = ptr_arg;
+ ptr_arg = swapper;
+ if (ptr_arg == return_val) return; // realloc had no effect, skipping
+
+ if (ptr_arg == 0) { // realloc(NULL, size) same as malloc(size)
+ type_flags ^= stack_logging_type_dealloc;
+ } else {
+ // realloc(arg1, arg2) -> result is same as free(arg1); malloc(arg2) -> result
+ __disk_stack_logging_log_stack(stack_logging_type_dealloc, zone_ptr, ptr_arg, (uintptr_t)0, (uintptr_t)0, num_hot_to_skip + 1);
+ __disk_stack_logging_log_stack(stack_logging_type_alloc, zone_ptr, size, (uintptr_t)0, return_val, num_hot_to_skip + 1);
+ return;
+ }
+ }
+ if (type_flags & stack_logging_type_dealloc) {
+ if (size) {
+ ptr_arg = size;
+ size = 0;
+ } else return; // free(nil)
+ }
+ if (type_flags & stack_logging_type_alloc && return_val == 0) return; // alloc that failed
+
+ type_flags &= 0x7;
+
+ // now actually begin
+ prepare_to_log_stacks();
+
+ // since there could have been a fatal (to stack logging) error such as the log files not being created, check this variable before continuing
+ if (!stack_logging_enable_logging) return;
+ vm_address_t self_thread = (vm_address_t)pthread_self(); // use pthread_self() rather than mach_thread_self() to avoid system call
+
+ // lock and enter
+ OSSpinLockLock(&stack_logging_lock);
+
+ // compaction
+ if (last_logged_malloc_address && (type_flags & stack_logging_type_dealloc) && STACK_LOGGING_DISGUISE(ptr_arg) == last_logged_malloc_address) {
+ // *waves hand* the last allocation never occurred
+ pre_write_buffers->next_free_index_buffer_offset -= (uint32_t)sizeof(stack_logging_index_event);
+ pre_write_buffers->next_free_stack_buffer_offset -= last_logged_backtrace_offset_diff;
+ total_offset -= (int64_t)last_logged_backtrace_offset_diff;
+ last_logged_malloc_address = 0ul;
+
+ // not going to subtract from the current_stack_buffer or current_logging_index indecies;
+ // there is no intention to restore the previously held stack. the differencing history
+ // must be reset to its previous value, though.
+ thread_buffer[compaction_saved_differencing_history.hash_pos] = compaction_saved_differencing_history;
+
+ OSSpinLockUnlock(&stack_logging_lock);
+ return;
+ }
+
+ // locate previous backtrace for this thread
+ short difference = 1;
+
+ uint32_t collisions = STACK_LOGGING_MAX_THREAD_COLLISIONS;
+ uint32_t hashed_thread = self_thread & (STACK_LOGGING_THREAD_HASH_SIZE-1);
+ while (thread_buffer[hashed_thread].thread && thread_buffer[hashed_thread].thread != self_thread) {
+ if (--collisions == 0) {
+ difference = 0;
+ break;
+ }
+ hashed_thread++;
+ }
+
+ // gather stack
+ uint32_t count;
+ thread_stack_pcs(stack_buffer[current_stack_buffer], STACK_LOGGING_MAX_STACK_SIZE, &count);
+ stack_buffer[current_stack_buffer][count++] = self_thread + 1; // stuffing thread # in the coldest slot. Add 1 to match what the old stack logging did.
+ num_hot_to_skip += 2;
+ if (count <= num_hot_to_skip) {
+ // Oops! Didn't get a valid backtrace from thread_stack_pcs().
+ OSSpinLockUnlock(&stack_logging_lock);
+ return;
+ }
+
+ // easy access variables
+ thread_backtrace_history *historical = &thread_buffer[hashed_thread];
+ vm_address_t *frames = stack_buffer[current_stack_buffer];
+
+ // increment as necessary
+ current_logging_index++;
+ current_stack_buffer++;
+ if (current_stack_buffer == STACK_LOGGING_NUMBER_RECENT_BACKTRACES) current_stack_buffer = 0;
+
+ // difference (if possible)
+ if (historical->logging_index + STACK_LOGGING_NUMBER_RECENT_BACKTRACES <= current_logging_index) difference = 0;
+ else if (historical->full_backtrace_countdown == 0) difference = 0;
+
+ uint32_t sameness = 0;
+ if (difference) {
+ uint32_t old_count = historical->backtrace_length;
+ int32_t new_count = (int32_t)count;
+ while (old_count-- && new_count-- > (int32_t)num_hot_to_skip) {
+ if (historical->backtrace[old_count] == frames[new_count]) sameness++;
+ else break;
+ }
+
+ if (sameness < STACK_LOGGING_MIN_SAME_FRAMES) { // failure; pretend nothing was the same
+ difference = 0;
+ }
+ }
+
+ // create events for byte storage
+ count -= num_hot_to_skip;
+ stack_logging_backtrace_event current_event;
+ current_event.num_identical_frames = (difference ? sameness : 0);
+ current_event.num_new_hot_frames = (difference ? count - sameness : count);
+ current_event.offset_delta = (difference ? historical->logging_offset - total_offset : 0);
+ int64_t this_offset_change = sizeof(stack_logging_backtrace_event) + (current_event.num_new_hot_frames * sizeof(uintptr_t));
+
+ stack_logging_index_event current_index;
+ if (type_flags & stack_logging_type_alloc) {
+ current_index.address = STACK_LOGGING_DISGUISE(return_val);
+ current_index.argument = size;
+ if (logging_use_compaction) {
+ last_logged_malloc_address = current_index.address; // disguised
+ last_logged_backtrace_offset_diff = (uint32_t)this_offset_change;
+ compaction_saved_differencing_history = *historical;
+ }
+ } else {
+ current_index.address = STACK_LOGGING_DISGUISE(ptr_arg);
+ current_index.argument = 0ul;
+ last_logged_malloc_address = 0ul;
+ }
+ current_index.offset_and_flags = STACK_LOGGING_OFFSET_AND_FLAGS(total_offset, type_flags);
+
+ // prepare for differencing next time
+ historical->backtrace = (uintptr_t*)(frames + num_hot_to_skip);
+ historical->backtrace_length = count;
+ if (difference) historical->full_backtrace_countdown--;
+ else historical->full_backtrace_countdown = STACK_LOGGING_FORCE_FULL_BACKTRACE_EVERY;
+ historical->logging_index = current_logging_index;
+ historical->logging_offset = total_offset;
+ historical->thread = self_thread;
+ historical->hash_pos = hashed_thread;
+
+ // flush the data buffer to disk if necessary
+ if (pre_write_buffers->next_free_stack_buffer_offset + this_offset_change >= STACK_LOGGING_BLOCK_WRITING_SIZE) {
+ flush_data();
+ } else if (pre_write_buffers->next_free_index_buffer_offset + sizeof(stack_logging_index_event) >= STACK_LOGGING_BLOCK_WRITING_SIZE) {
+ flush_data();
+ }
+
+ // store bytes in buffers
+ memcpy(pre_write_index_buffer+pre_write_buffers->next_free_index_buffer_offset, ¤t_index, sizeof(stack_logging_index_event));
+ memcpy(pre_write_backtrace_event_buffer+pre_write_buffers->next_free_stack_buffer_offset, ¤t_event, sizeof(stack_logging_backtrace_event));
+ memcpy(pre_write_backtrace_event_buffer+pre_write_buffers->next_free_stack_buffer_offset+sizeof(stack_logging_backtrace_event), frames+num_hot_to_skip, (size_t)this_offset_change - sizeof(stack_logging_backtrace_event));
+ pre_write_buffers->next_free_index_buffer_offset += (uint32_t)sizeof(stack_logging_index_event);
+ pre_write_buffers->next_free_stack_buffer_offset += (uint32_t)this_offset_change;
+ total_offset += this_offset_change;
+
+ OSSpinLockUnlock(&stack_logging_lock);
+}
+
+#pragma mark -
+#pragma mark Remote Stack Log Access
+
+#pragma mark - Design notes:
+
+/*
+
+this first one will look through the index, find the "stack_identifier" (i.e. the offset in the log file), and call the third function listed here.
+extern kern_return_t __mach_stack_logging_get_frames(task_t task, mach_vm_address_t address, mach_vm_address_t *stack_frames_buffer, uint32_t max_stack_frames, uint32_t *num_frames);
+ // Gets the last allocation record about address
+
+if !address, will load both index and stack logs and iterate through (expensive)
+else will load just index, search for stack, and then use third function here to retrieve. (also expensive)
+extern kern_return_t __mach_stack_logging_enumerate_records(task_t task, mach_vm_address_t address, void enumerator(mach_stack_logging_record_t, void *), void *context);
+ // Applies enumerator to all records involving address sending context as enumerator's second parameter; if !address, applies enumerator to all records
+
+this function will load the stack file, look for the stack, and follow up to STACK_LOGGING_FORCE_FULL_BACKTRACE_EVERY references to reconstruct.
+extern kern_return_t __mach_stack_logging_frames_for_uniqued_stack(task_t task, uint64_t stack_identifier, mach_vm_address_t *stack_frames_buffer, uint32_t max_stack_frames, uint32_t *count);
+ // Given a uniqued_stack fills stack_frames_buffer
+
+*/
+
+#pragma mark - caching
+
+static inline size_t hash_index_32(uint32_t address, size_t max_pos) __attribute__((always_inline));
+static inline size_t hash_index_32(uint32_t address, size_t max_pos) {
+// return (((OSSwapInt32(address >> 2) << 3) & 0x96AAAA98) ^ (address >> 2)) % (max_pos-1);
+ return (address >> 2) % (max_pos-1); // simplicity rules.
+}
+
+static inline size_t hash_index_64(uint64_t address, size_t max_pos) __attribute__((always_inline));
+static inline size_t hash_index_64(uint64_t address, size_t max_pos) {
+// return (size_t)((((OSSwapInt64(address >> 3) << 2) & 0x54AA0A0AAA54ull) ^ (address >> 3)) % (max_pos - 1));
+ return (size_t)((address >> 3) % (max_pos-1)); // simplicity rules.
+}
+
+static void
+transfer_node_ll32(remote_index_cache *cache, remote_index_node32 *old_node)
+{
+ uint32_t collisions = 0;
+ size_t pos = hash_index_32(old_node->address, cache->cache_node_capacity);
+ do {
+ if (cache->casted_table32[pos].address == old_node->address) { // hit like this shouldn't happen.
+ fprintf(stderr, "impossible collision! two address==address lists! (transfer_node_ll32)\n");
+ break;
+ } else if (cache->casted_table32[pos].address == 0) { // empty
+ cache->casted_table32[pos] = *old_node;
+ break;
+ } else {
+ pos++;
+ if (pos >= cache->cache_node_capacity) pos = 0;
+ }
+ collisions++;
+ } while (collisions <= cache->collision_allowance);
+
+ if (collisions > cache->collision_allowance) {
+ fprintf(stderr, "reporting bad hash function! disk stack logging reader %lu bit. (transfer_node_ll32)\n", sizeof(void*)*8);
+ }
+}
+
+static void
+transfer_node_ll64(remote_index_cache *cache, remote_index_node64 *old_node)
+{
+ uint32_t collisions = 0;
+ size_t pos = hash_index_64(old_node->address, cache->cache_node_capacity);
+ do {
+ if (cache->casted_table64[pos].address == old_node->address) { // hit!
+ fprintf(stderr, "impossible collision! two address==address lists! (transfer_node_ll64)\n");
+ break;
+ } else if (cache->casted_table64[pos].address == 0) { // empty
+ cache->casted_table64[pos] = *old_node;
+ break;
+ } else {
+ pos++;
+ if (pos >= cache->cache_node_capacity) pos = 0;
+ }
+ collisions++;
+ } while (collisions <= cache->collision_allowance);
+
+ if (collisions > cache->collision_allowance) {
+ fprintf(stderr, "reporting bad hash function! disk stack logging reader %lu bit. (transfer_node_ll64)\n", sizeof(void*)*8);
+ }
+}
+
+static void
+expand_cache(remote_index_cache *cache)
+{
+ // keep old stats
+ size_t old_node_capacity = cache->cache_node_capacity;
+ uint64_t old_node_count = cache->cache_node_count;
+ uint64_t old_llnode_count = cache->cache_llnode_count;
+ void *old_table = cache->table_memory;
+
+ // double size
+ cache->cache_size <<= 1;
+ cache->cache_node_capacity <<= 1;
+ cache->collision_allowance += STACK_LOGGING_REMOTE_CACHE_COLLISION_GROWTH_RATE;
+ cache->table_memory = (void*)calloc(cache->cache_node_capacity, cache->in_use_node_size);
+ if (cache->casted_table32) cache->casted_table32 = cache->table_memory;
+ else cache->casted_table64 = cache->table_memory;
+
+ // repopulate (expensive!)
+ size_t i;
+ if (cache->casted_table32) { // if target is 32-bit
+ remote_index_node32 *casted_old_table = (remote_index_node32*)old_table;
+ for (i = 0; i < old_node_capacity; i++) {
+ if (casted_old_table[i].address) {
+ transfer_node_ll32(cache, &casted_old_table[i]);
+ }
+ }
+ } else {
+ remote_index_node64 *casted_old_table = (remote_index_node64*)old_table;
+ for (i = 0; i < old_node_capacity; i++) {
+ if (casted_old_table[i].address) {
+ transfer_node_ll64(cache, &casted_old_table[i]);
+ }
+ }
+ }
+
+ cache->cache_node_count = old_node_count;
+ cache->cache_llnode_count = old_llnode_count;
+ free(old_table);
+// printf("cache expanded to %0.2f mb (eff: %3.0f%%, capacity: %lu, nodes: %llu, llnodes: %llu)\n", ((float)(cache->cache_size))/(1 << 20), ((float)(cache->cache_node_count)*100.0)/((float)(cache->cache_node_capacity)), cache->cache_node_capacity, cache->cache_node_count, cache->cache_llnode_count);
+}
+
+static void
+insert_node32(remote_index_cache *cache, uint32_t address, uint64_t index_file_offset)
+{
+ uint32_t collisions = 0;
+ size_t pos = hash_index_32(address, cache->cache_node_capacity);
+
+ if (cache->next_block_index >= STACK_LOGGING_REMOTE_LINKS_PER_BLOCK) {
+ cache->next_block_index = 0;
+ cache->current_block++;
+ cache->blocks[cache->current_block] = (index_ll_node*)malloc(STACK_LOGGING_REMOTE_LINKS_PER_BLOCK*sizeof(index_ll_node));
+/* printf("node buffer added. total nodes: %ul (%u buffers, %0.2f mb)\n", STACK_LOGGING_REMOTE_LINKS_PER_BLOCK*(cache->current_block+1),
+ cache->current_block+1, ((float)(STACK_LOGGING_REMOTE_LINKS_PER_BLOCK*sizeof(index_ll_node)*(cache->current_block+1)))/(1 << 20));
+*/
+ }
+ index_ll_node *new_node = &cache->blocks[cache->current_block][cache->next_block_index++];
+ new_node->index_file_offset = index_file_offset;
+ new_node->next = NULL;
+
+ bool inserted = false;
+ while (!inserted) {
+ if (cache->casted_table32[pos].address == address) { // hit!
+ cache->casted_table32[pos].last_link->next = new_node; // insert at end
+ cache->casted_table32[pos].last_link = new_node;
+ inserted = true;
+ break;
+ } else if (cache->casted_table32[pos].address == 0) { // empty
+ cache->casted_table32[pos].address = address;
+ cache->casted_table32[pos].linked_list = new_node;
+ cache->casted_table32[pos].last_link = new_node;
+ cache->cache_node_count++;
+ inserted = true;
+ break;
+ } else {
+ pos++;
+ if (pos >= cache->cache_node_capacity) pos = 0;
+ }
+ collisions++;
+ if (collisions > cache->collision_allowance) {
+ expand_cache(cache);
+ pos = hash_index_32(address, cache->cache_node_capacity);
+ collisions = 0;
+ }
+ }
+
+ cache->cache_llnode_count++;
+
+}
+
+static void
+insert_node64(remote_index_cache *cache, uint64_t address, uint64_t index_file_offset)
+{
+ uint32_t collisions = 0;
+ size_t pos = hash_index_64(address, cache->cache_node_capacity);
+
+ if (cache->next_block_index >= STACK_LOGGING_REMOTE_LINKS_PER_BLOCK) {
+ cache->next_block_index = 0;
+ cache->current_block++;
+ cache->blocks[cache->current_block] = (index_ll_node*)malloc(STACK_LOGGING_REMOTE_LINKS_PER_BLOCK*sizeof(index_ll_node));
+ }
+ index_ll_node *new_node = &cache->blocks[cache->current_block][cache->next_block_index++];
+ new_node->index_file_offset = index_file_offset;
+ new_node->next = NULL;
+
+ bool inserted = false;
+ while (!inserted) {
+ if (cache->casted_table64[pos].address == address) { // hit!
+ cache->casted_table64[pos].last_link->next = new_node; // insert at end
+ cache->casted_table64[pos].last_link = new_node;
+ inserted = true;
+ break;
+ } else if (cache->casted_table64[pos].address == 0) { // empty
+ cache->casted_table64[pos].address = address;
+ cache->casted_table64[pos].linked_list = new_node;
+ cache->casted_table64[pos].last_link = new_node;
+ inserted = true;
+ break;
+ } else {
+ pos++;
+ if (pos >= cache->cache_node_capacity) pos = 0;
+ }
+ collisions++;
+ if (collisions > cache->collision_allowance) {
+ expand_cache(cache);
+ pos = hash_index_64(address, cache->cache_node_capacity);
+ collisions = 0;
+ }
+ }
+
+}
+
+static void
+update_cache_for_file_streams(remote_task_file_streams *descriptors)
+{
+ remote_index_cache *cache = descriptors->cache;
+
+ // create from scratch if necessary.
+ if (!cache) {
+ descriptors->cache = cache = (remote_index_cache*)calloc((size_t)1, sizeof(remote_index_cache));
+ cache->cache_node_capacity = STACK_LOGGING_REMOTE_CACHE_DEFAULT_NODE_CAPACITY;
+ cache->collision_allowance = STACK_LOGGING_REMOTE_CACHE_DEFAULT_COLLISION_ALLOWANCE;
+ cache->cache_node_count = cache->cache_llnode_count = 0;
+ cache->last_index_file_offset = 0;
+ cache->next_block_index = 0;
+ cache->current_block = 0;
+ cache->blocks[0] = (index_ll_node*)malloc(STACK_LOGGING_REMOTE_LINKS_PER_BLOCK*sizeof(index_ll_node));
+ cache->in_use_node_size = (descriptors->task_is_64_bit ? sizeof(remote_index_node64) : sizeof(remote_index_node32));
+ cache->cache_size = cache->cache_node_capacity*cache->in_use_node_size;
+ cache->table_memory = (void*)calloc(cache->cache_node_capacity, cache->in_use_node_size);
+ if (descriptors->task_is_64_bit) cache->casted_table64 = (remote_index_node64*)(cache->table_memory);
+ else cache->casted_table32 = (remote_index_node32*)(cache->table_memory);
+
+ // now map in the shared memory, if possible
+ char shmem_name_string[PATH_MAX];
+ strlcpy(shmem_name_string, stack_logging_directory_base_name, (size_t)PATH_MAX);
+ append_int(shmem_name_string, descriptors->remote_pid);
+
+ int shmid = shm_open(shmem_name_string, O_RDWR, S_IRUSR | S_IWUSR);
+ if (shmid >= 0) {
+ cache->shmem = mmap(0, sizeof(stack_buffer_shared_memory), PROT_READ | PROT_WRITE, MAP_SHARED, shmid, (off_t)0);
+ close(shmid);
+ }
+
+ if (shmid < 0 || cache->shmem == NULL) {
+ // failed to connect to the shared memory region; warn and continue.
+ _malloc_printf(ASL_LEVEL_INFO, "warning: unable to connect to remote process' shared memory; allocation histories may not be up-to-date.\n");
+ }
+ }
+
+ // suspend and see how much updating there is to do. there are three scenarios, listed below
+ bool update_snapshot = false;
+ if (descriptors->remote_task != mach_task_self()) {
+ task_suspend(descriptors->remote_task);
+ }
+
+ struct stat file_statistics;
+ fstat(fileno(descriptors->index_file_stream), &file_statistics);
+ size_t read_size = (descriptors->task_is_64_bit ? sizeof(stack_logging_index_event64) : sizeof(stack_logging_index_event32));
+ uint64_t read_this_update = 0;
+
+ // the delta indecies is a complex number; there are three cases:
+ // 1. there is no shared memory (or we can't connect); diff the last_index_file_offset from the filesize.
+ // 2. the only updates have been in shared memory; disk file didn't change at all. delta_indecies should be zero, scan snapshot only.
+ // 3. the updates have flushed to disk, meaning that most likely there is new data on disk that wasn't read from shared memory.
+ // correct delta_indecies for the pre-scanned amount and read the new data from disk and shmem.
+ uint64_t delta_indecies = (file_statistics.st_size - cache->last_index_file_offset) / read_size;
+ uint32_t last_snapshot_scan_index = 0;
+ if (delta_indecies && cache->shmem) {
+ // case 3: add cache scanned to known from disk and recalc
+ cache->last_index_file_offset += cache->snapshot.next_free_index_buffer_offset;
+ delta_indecies = (file_statistics.st_size - cache->last_index_file_offset) / read_size;
+ update_snapshot = true;
+ } else if (cache->shmem) {
+ // case 2: set the last snapshot scan count so we don't rescan something we've seen.
+ last_snapshot_scan_index = cache->snapshot.next_free_index_buffer_offset / (uint32_t)read_size;
+ }
+
+ // no update necessary for the file; check if need a snapshot.
+ if (delta_indecies == 0) {
+ if (cache->shmem && !update_snapshot) {
+ update_snapshot = (cache->shmem->next_free_index_buffer_offset != cache->snapshot.next_free_index_buffer_offset);
+ }
+ }
+
+ // if a snapshot is necessary, memcpy from remote frozen process' memory
+ // note: there were two ways to do this Ð spin lock or suspend. suspend allows us to
+ // analyze processes even if they were artificially suspended. with a lock, there'd be
+ // worry that the target was suspended with the lock taken.
+ if (update_snapshot) {
+ memcpy(&cache->snapshot, cache->shmem, sizeof(stack_buffer_shared_memory));
+ }
+
+ // resume
+ if (descriptors->remote_task != mach_task_self()) {
+ task_resume(descriptors->remote_task);
+ }
+
+ if (!update_snapshot && delta_indecies == 0) return; // absolutely no updating needed.
+
+ FILE *the_index = (descriptors->index_file_stream);
+
+ // prepare for the read; target process could be 32 or 64 bit.
+
+ stack_logging_index_event32 *target_32_index = NULL;
+ stack_logging_index_event64 *target_64_index = NULL;
+
+ // perform the update from the file
+ uint32_t i;
+ if (delta_indecies) {
+ char bufferSpace[4096]; // 4 kb
+ target_32_index = (stack_logging_index_event32*)bufferSpace;
+ target_64_index = (stack_logging_index_event64*)bufferSpace;
+ size_t number_slots = (size_t)(4096/read_size);
+
+ size_t read_count = 0;
+ if (fseeko(the_index, (off_t)(cache->last_index_file_offset), SEEK_SET)) {
+ fprintf(stderr, "error while attempting to cache information from remote stack index file. (update_cache_for_file_streams)\n");
+ }
+ off_t current_index_position = cache->last_index_file_offset;
+ do {
+ number_slots = MIN(delta_indecies - read_this_update, number_slots);
+ read_count = fread(bufferSpace, read_size, number_slots, the_index);
+ if (descriptors->task_is_64_bit) {
+ for (i = 0; i < read_count; i++) {
+ insert_node64(cache, STACK_LOGGING_DISGUISE(target_64_index[i].address), (uint64_t)current_index_position);
+ read_this_update++;
+ current_index_position += read_size;
+ }
+ } else {
+ for (i = 0; i < read_count; i++) {
+ insert_node32(cache, STACK_LOGGING_DISGUISE(target_32_index[i].address), (uint64_t)current_index_position);
+ read_this_update++;
+ current_index_position += read_size;
+ }
+ }
+ } while (read_count);
+
+ if (read_this_update < delta_indecies) {
+ fprintf(stderr, "insufficient data in remote stack index file; expected more records.\n");
+ }
+ cache->last_index_file_offset += read_this_update * read_size;
+ }
+
+ if (update_snapshot) {
+ target_32_index = (stack_logging_index_event32*)(cache->snapshot.index_buffer);
+ target_64_index = (stack_logging_index_event64*)(cache->snapshot.index_buffer);
+
+ uint32_t free_snapshot_scan_index = cache->snapshot.next_free_index_buffer_offset / (uint32_t)read_size;
+ off_t current_index_position = cache->snapshot.start_index_offset;
+ if (descriptors->task_is_64_bit) {
+ for (i = last_snapshot_scan_index; i < free_snapshot_scan_index; i++) {
+ insert_node64(cache, STACK_LOGGING_DISGUISE(target_64_index[i].address), (uint64_t)(current_index_position + (i * read_size)));
+ }
+ } else {
+ for (i = last_snapshot_scan_index; i < free_snapshot_scan_index; i++) {
+ insert_node32(cache, STACK_LOGGING_DISGUISE(target_32_index[i].address), (uint64_t)(current_index_position + (i * read_size)));
+ }
+ }
+ }
+
+}
+
+static void
+destroy_cache_for_file_streams(remote_task_file_streams *descriptors)
+{
+ uint32_t i;
+ for (i = 0; i <= descriptors->cache->current_block; i++) {
+ free(descriptors->cache->blocks[i]); // clears the linked list nodes.
+ }
+ if (descriptors->cache->shmem) {
+ munmap(descriptors->cache->shmem, sizeof(stack_buffer_shared_memory));
+ }
+ free(descriptors->cache->table_memory);
+ free(descriptors->cache);
+ descriptors->cache = NULL;
+}
+
+#pragma mark - internal
+
+// In the stack log analysis process, find the stack logging files for target process <pid>
+// by scanning the temporary directory for directory entries with names of the form "stack-logs.<pid>."
+// If we find such a directory then open the stack logging files in there.
+static void
+open_log_files(pid_t pid, remote_task_file_streams *this_task_streams)
+{
+ DIR *dp;
+ struct dirent *entry;
+ int prefix_length;
+ char prefix_name[PATH_MAX];
+ char pathname[PATH_MAX];
+
+ reap_orphaned_log_files(false); // reap any left-over log files (for non-existant processes, but not for this analysis process)
+
+ if ((dp = opendir(temporary_directory)) == NULL) {
+ return;
+ }
+
+ // It's OK to use snprintf in this routine since it should only be called by the clients
+ // of stack logging, and thus calls to malloc are OK.
+ snprintf(prefix_name, PATH_MAX, "%s%d.", stack_logging_directory_base_name, pid); // make sure to use "%s%d." rather than just "%s%d" to match the whole pid
+ prefix_length = strlen(prefix_name);
+
+ while ( (entry = readdir(dp)) != NULL ) {
+ if ( strncmp( entry->d_name, prefix_name, prefix_length) == 0 ) {
+ snprintf(pathname, PATH_MAX, "%s/%s/%s", temporary_directory, entry->d_name, index_file_name);
+ this_task_streams->index_file_stream = fopen(pathname, "r");
+
+ snprintf(pathname, PATH_MAX, "%s/%s/%s", temporary_directory, entry->d_name, stack_file_name);
+ this_task_streams->stack_file_stream = fopen(pathname, "r");
+
+ break;
+ }
+ }
+ closedir(dp);
+}
+
+static remote_task_file_streams*
+retain_file_streams_for_task(task_t task)
+{
+ OSSpinLockLock(&remote_fd_list_lock);
+
+ // see if they're already in use
+ uint32_t i = 0;
+ for (i = 0; i < remote_task_fd_count; i++) {
+ if (remote_fds[i].remote_task == task) {
+ remote_fds[i].in_use_count++;
+ OSSpinLockUnlock(&remote_fd_list_lock);
+ return &remote_fds[i];
+ }
+ }
+
+ // open them
+ uint32_t failures = 0;
+ if (remote_task_fd_count == STACK_LOGGING_MAX_SIMUL_REMOTE_TASKS_INSPECTED) {
+ while (remote_fds[next_remote_task_fd].in_use_count > 0) {
+ next_remote_task_fd++;
+ if (next_remote_task_fd == STACK_LOGGING_MAX_SIMUL_REMOTE_TASKS_INSPECTED) next_remote_task_fd = 0;
+ failures++;
+ if (failures >= STACK_LOGGING_MAX_SIMUL_REMOTE_TASKS_INSPECTED) {
+ OSSpinLockUnlock(&remote_fd_list_lock);
+ return NULL;
+ }
+ }
+ fclose(remote_fds[next_remote_task_fd].index_file_stream);
+ fclose(remote_fds[next_remote_task_fd].stack_file_stream);
+ destroy_cache_for_file_streams(&remote_fds[next_remote_task_fd]);
+ }
+
+ pid_t pid;
+ kern_return_t err = pid_for_task(task, &pid);
+ if (err != KERN_SUCCESS) {
+ OSSpinLockUnlock(&remote_fd_list_lock);
+ return NULL;
+ }
+
+ remote_task_file_streams *this_task_streams = &remote_fds[next_remote_task_fd];
+
+ open_log_files(pid, this_task_streams);
+
+ // check if opens failed
+ if (this_task_streams->index_file_stream == NULL || this_task_streams->stack_file_stream == NULL) {
+ if (this_task_streams->index_file_stream) fclose(this_task_streams->index_file_stream);
+ if (this_task_streams->stack_file_stream) fclose(this_task_streams->stack_file_stream);
+ OSSpinLockUnlock(&remote_fd_list_lock);
+ return NULL;
+ }
+
+ // check if target pid is running 64-bit
+ int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, pid };
+ struct kinfo_proc processInfo;
+ size_t bufsize = sizeof(processInfo);
+ if (sysctl(mib, (unsigned)(sizeof(mib)/sizeof(int)), &processInfo, &bufsize, NULL, (size_t)0) == 0 && bufsize > 0) {
+ this_task_streams->task_is_64_bit = processInfo.kp_proc.p_flag & P_LP64;
+ } else {
+ this_task_streams->task_is_64_bit = 0;
+ }
+
+ // otherwise set vars and go
+ this_task_streams->in_use_count = 1;
+ this_task_streams->remote_task = task;
+ this_task_streams->remote_pid = pid;
+ next_remote_task_fd++;
+ if (next_remote_task_fd == STACK_LOGGING_MAX_SIMUL_REMOTE_TASKS_INSPECTED) next_remote_task_fd = 0;
+ remote_task_fd_count = MIN(remote_task_fd_count + 1, STACK_LOGGING_MAX_SIMUL_REMOTE_TASKS_INSPECTED);
+
+ OSSpinLockUnlock(&remote_fd_list_lock);
+ return this_task_streams;
+}
+
+static void
+release_file_streams_for_task(task_t task)
+{
+ OSSpinLockLock(&remote_fd_list_lock);
+
+ // decrement in-use count
+ uint32_t i = 0;
+ for (i = 0; i < remote_task_fd_count; i++) {
+ if (remote_fds[i].remote_task == task) {
+ remote_fds[i].in_use_count--;
+ break;
+ }
+ }
+
+ OSSpinLockUnlock(&remote_fd_list_lock);
+}
+
+#pragma mark - extern
+
+kern_return_t
+__mach_stack_logging_get_frames(task_t task, mach_vm_address_t address, mach_vm_address_t *stack_frames_buffer, uint32_t max_stack_frames, uint32_t *count)
+{
+ remote_task_file_streams *remote_fd = retain_file_streams_for_task(task);
+ if (remote_fd == NULL) {
+ return KERN_FAILURE;
+ }
+
+ update_cache_for_file_streams(remote_fd);
+
+ uint32_t collisions = 0;
+ uint64_t located_file_position = 0;
+ bool found = false;
+ size_t hash = 0;
+ if (remote_fd->task_is_64_bit) {
+ hash = hash_index_64(address, remote_fd->cache->cache_node_capacity);
+ do {
+ if (remote_fd->cache->casted_table64[hash].address == address) { // hit!
+ located_file_position = remote_fd->cache->casted_table64[hash].last_link->index_file_offset;
+ found = true;
+ break;
+ } else if (remote_fd->cache->casted_table64[hash].address == 0) { // failure!
+ break;
+ }
+ hash++;
+ if (hash >= remote_fd->cache->cache_node_capacity) hash = 0;
+ } while (collisions <= remote_fd->cache->collision_allowance);
+ } else {
+ hash = hash_index_32((uint32_t)address, remote_fd->cache->cache_node_capacity);
+ do {
+ if (remote_fd->cache->casted_table32[hash].address == (uint32_t)address) { // hit!
+ located_file_position = remote_fd->cache->casted_table32[hash].last_link->index_file_offset;
+ found = true;
+ break;
+ } else if (remote_fd->cache->casted_table32[hash].address == 0) { // failure!
+ break;
+ }
+ hash++;
+ if (hash >= remote_fd->cache->cache_node_capacity) hash = 0;
+ } while (collisions <= remote_fd->cache->collision_allowance);
+ }
+
+ if (found) {
+ // prepare for the read; target process could be 32 or 64 bit.
+ stack_logging_index_event32 *target_32_index = NULL;
+ stack_logging_index_event64 *target_64_index = NULL;
+
+ if (located_file_position >= remote_fd->cache->last_index_file_offset) {
+ // must be in shared memory
+ if (remote_fd->cache->shmem) {
+ if (remote_fd->task_is_64_bit) {
+ target_64_index = (stack_logging_index_event64*)(remote_fd->cache->snapshot.index_buffer + (located_file_position - remote_fd->cache->snapshot.start_index_offset));
+ located_file_position = STACK_LOGGING_OFFSET(target_64_index->offset_and_flags);
+ } else {
+ target_32_index = (stack_logging_index_event32*)(remote_fd->cache->snapshot.index_buffer + (located_file_position - remote_fd->cache->snapshot.start_index_offset));
+ located_file_position = STACK_LOGGING_OFFSET(target_32_index->offset_and_flags);
+ }
+ } else {
+ found = false;
+ }
+
+ } else {
+ // it's written to disk
+ char bufferSpace[128];
+
+ size_t read_size = (remote_fd->task_is_64_bit ? sizeof(stack_logging_index_event64) : sizeof(stack_logging_index_event32));
+ fseeko(remote_fd->index_file_stream, (off_t)located_file_position, SEEK_SET);
+ size_t read_count = fread(bufferSpace, read_size, (size_t)1, remote_fd->index_file_stream);
+ if (read_count) {
+ if (remote_fd->task_is_64_bit) {
+ target_64_index = (stack_logging_index_event64*)bufferSpace;
+ located_file_position = STACK_LOGGING_OFFSET(target_64_index->offset_and_flags);
+ } else {
+ target_32_index = (stack_logging_index_event32*)bufferSpace;
+ located_file_position = STACK_LOGGING_OFFSET(target_32_index->offset_and_flags);
+ }
+ } else {
+ found = false;
+ }
+ }
+ }
+
+ release_file_streams_for_task(task);
+
+ if (!found) {
+ return KERN_FAILURE;
+ }
+
+ return __mach_stack_logging_frames_for_uniqued_stack(task, located_file_position, stack_frames_buffer, max_stack_frames, count);
+}
+
+
+kern_return_t
+__mach_stack_logging_enumerate_records(task_t task, mach_vm_address_t address, void enumerator(mach_stack_logging_record_t, void *), void *context)
+{
+ remote_task_file_streams *remote_fd = retain_file_streams_for_task(task);
+ if (remote_fd == NULL) {
+ return KERN_FAILURE;
+ }
+
+ bool reading_all_addresses = (address == 0 ? true : false);
+ mach_stack_logging_record_t pass_record;
+ kern_return_t err = KERN_SUCCESS;
+
+ if (reading_all_addresses) { // just stupidly read the index file from disk
+
+ // update (read index file once and only once)
+ update_cache_for_file_streams(remote_fd);
+
+ FILE *the_index = (remote_fd->index_file_stream);
+
+ // prepare for the read; target process could be 32 or 64 bit.
+ char bufferSpace[2048]; // 2 kb
+ stack_logging_index_event32 *target_32_index = (stack_logging_index_event32*)bufferSpace;
+ stack_logging_index_event64 *target_64_index = (stack_logging_index_event64*)bufferSpace;
+ uint32_t target_addr_32 = (uint32_t)STACK_LOGGING_DISGUISE((uint32_t)address);
+ uint64_t target_addr_64 = STACK_LOGGING_DISGUISE((uint64_t)address);
+ size_t read_size = (remote_fd->task_is_64_bit ? sizeof(stack_logging_index_event64) : sizeof(stack_logging_index_event32));
+ size_t number_slots = (size_t)(2048/read_size);
+ uint64_t total_slots = remote_fd->cache->last_index_file_offset / read_size;
+
+ // perform the search
+ size_t read_count = 0;
+ int64_t current_file_offset = 0;
+ uint32_t i;
+ do {
+ // at this point, we need to read index events; read them from the file until it's necessary to grab them from the shared memory snapshot
+ // and crop file reading to the point where we last scanned
+ number_slots = (size_t)MIN(number_slots, total_slots);
+
+ // if out of file to read (as of the time we entered this function), try to use shared memory snapshot
+ if (number_slots == 0) {
+ if (remote_fd->cache->shmem && remote_fd->cache->snapshot.start_index_offset + remote_fd->cache->snapshot.next_free_index_buffer_offset > (uint64_t)current_file_offset) {
+ // use shared memory
+ target_32_index = (stack_logging_index_event32*)remote_fd->cache->snapshot.index_buffer;
+ target_64_index = (stack_logging_index_event64*)remote_fd->cache->snapshot.index_buffer;
+ read_count = (uint32_t)(remote_fd->cache->snapshot.start_index_offset + remote_fd->cache->snapshot.next_free_index_buffer_offset - current_file_offset) / read_size;
+ current_file_offset += read_count * read_size;
+ } else {
+ break;
+ }
+ } else {
+ // get and save index (enumerator could modify)
+ fseeko(the_index, current_file_offset, SEEK_SET);
+ read_count = fread(bufferSpace, read_size, number_slots, the_index);
+ current_file_offset = ftello(the_index);
+ total_slots -= read_count;
+ }
+
+ if (remote_fd->task_is_64_bit) {
+ for (i = 0; i < read_count; i++) {
+ if (reading_all_addresses || target_64_index[i].address == target_addr_64) {
+ pass_record.address = STACK_LOGGING_DISGUISE(target_64_index[i].address);
+ pass_record.argument = target_64_index[i].argument;
+ pass_record.stack_identifier = STACK_LOGGING_OFFSET(target_64_index[i].offset_and_flags);
+ pass_record.type_flags = STACK_LOGGING_FLAGS(target_64_index[i].offset_and_flags);
+ enumerator(pass_record, context);
+ }
+ }
+ } else {
+ for (i = 0; i < read_count; i++) {
+ if (reading_all_addresses || target_32_index[i].address == target_addr_32) {
+ pass_record.address = STACK_LOGGING_DISGUISE(target_32_index[i].address);
+ pass_record.argument = target_32_index[i].argument;
+ pass_record.stack_identifier = STACK_LOGGING_OFFSET(target_32_index[i].offset_and_flags);
+ pass_record.type_flags = STACK_LOGGING_FLAGS(target_32_index[i].offset_and_flags);
+ enumerator(pass_record, context);
+ }
+ }
+ }
+ } while (read_count);
+
+ } else { // searching for a single address' history
+
+ // update (read index file once and only once)
+ update_cache_for_file_streams(remote_fd);
+
+ // get linked-list of events
+ uint32_t collisions = 0;
+ uint64_t located_file_position = 0;
+ size_t hash = 0;
+ index_ll_node *index_position_linked_list = NULL;
+ if (remote_fd->task_is_64_bit) {
+ hash = hash_index_64(address, remote_fd->cache->cache_node_capacity);
+ do {
+ if (remote_fd->cache->casted_table64[hash].address == address) { // hit!
+ index_position_linked_list = remote_fd->cache->casted_table64[hash].linked_list;
+ break;
+ } else if (remote_fd->cache->casted_table64[hash].address == 0) { // failure!
+ break;
+ }
+ hash++;
+ if (hash >= remote_fd->cache->cache_node_capacity) hash = 0;
+ } while (collisions <= remote_fd->cache->collision_allowance);
+ } else {
+ hash = hash_index_32((uint32_t)address, remote_fd->cache->cache_node_capacity);
+ do {
+ if (remote_fd->cache->casted_table32[hash].address == (uint32_t)address) { // hit!
+ index_position_linked_list = remote_fd->cache->casted_table32[hash].linked_list;
+ break;
+ } else if (remote_fd->cache->casted_table32[hash].address == 0) { // failure!
+ break;
+ }
+ hash++;
+ if (hash >= remote_fd->cache->cache_node_capacity) hash = 0;
+ } while (collisions <= remote_fd->cache->collision_allowance);
+ }
+
+ // if we got something, run it
+ char bufferSpace[128];
+ size_t read_count = 0;
+ stack_logging_index_event32 *target_32_index = (stack_logging_index_event32*)bufferSpace;
+ stack_logging_index_event64 *target_64_index = (stack_logging_index_event64*)bufferSpace;
+ size_t read_size = (remote_fd->task_is_64_bit ? sizeof(stack_logging_index_event64) : sizeof(stack_logging_index_event32));
+ while (index_position_linked_list) {
+ located_file_position = index_position_linked_list->index_file_offset;
+
+ if (located_file_position >= remote_fd->cache->snapshot.start_index_offset) {
+ if (remote_fd->cache->shmem && located_file_position >= remote_fd->cache->snapshot.start_index_offset && remote_fd->cache->snapshot.start_index_offset + remote_fd->cache->snapshot.next_free_index_buffer_offset > (uint64_t)located_file_position) {
+ // use shared memory
+ target_32_index = (stack_logging_index_event32*)(remote_fd->cache->snapshot.index_buffer + located_file_position - remote_fd->cache->snapshot.start_index_offset);
+ target_64_index = (stack_logging_index_event64*)target_32_index;
+ read_count = 1;
+ } else {
+ err = KERN_FAILURE;
+ break;
+ }
+ } else {
+ fseeko(remote_fd->index_file_stream, (off_t)located_file_position, SEEK_SET);
+ read_count = fread(bufferSpace, read_size, (size_t)1, remote_fd->index_file_stream);
+ if (!read_count) {
+ err = KERN_FAILURE;
+ break;
+ }
+ }
+ if (remote_fd->task_is_64_bit) {
+ pass_record.address = STACK_LOGGING_DISGUISE(target_64_index[0].address);
+ pass_record.argument = target_64_index[0].argument;
+ pass_record.stack_identifier = STACK_LOGGING_OFFSET(target_64_index[0].offset_and_flags);
+ pass_record.type_flags = STACK_LOGGING_FLAGS(target_64_index[0].offset_and_flags);
+ enumerator(pass_record, context);
+ } else {
+ pass_record.address = STACK_LOGGING_DISGUISE(target_32_index[0].address);
+ pass_record.argument = target_32_index[0].argument;
+ pass_record.stack_identifier = STACK_LOGGING_OFFSET(target_32_index[0].offset_and_flags);
+ pass_record.type_flags = STACK_LOGGING_FLAGS(target_32_index[0].offset_and_flags);
+ enumerator(pass_record, context);
+ }
+ index_position_linked_list = index_position_linked_list->next;
+ }
+
+ }
+
+ release_file_streams_for_task(task);
+ return err;
+}
+
+
+kern_return_t
+__mach_stack_logging_frames_for_uniqued_stack(task_t task, uint64_t stack_identifier, mach_vm_address_t *stack_frames_buffer, uint32_t max_stack_frames, uint32_t *count)
+{
+ remote_task_file_streams *remote_fd = retain_file_streams_for_task(task);
+ if (remote_fd == NULL) {
+ return KERN_FAILURE;
+ }
+
+ // prepare for initial read
+ FILE *stack_fd;
+ stack_fd = (remote_fd->stack_file_stream);
+ char bytes_buffer[16];
+ stack_logging_backtrace_event *target_stack_event = (stack_logging_backtrace_event*)bytes_buffer;
+ size_t read_size = sizeof(stack_logging_backtrace_event);
+ size_t read_count = 0;
+ off_t reading_offset = (off_t)stack_identifier;
+
+ // get a temporary spot for the backtrace frames to go and reference the stack space such that the reference
+ // can be later pointed at the shared memory snapshot and data read from there.
+ uint64_t temp_frames_buffer[STACK_LOGGING_MAX_STACK_SIZE];
+ uint64_t *big_frames = (uint64_t*)temp_frames_buffer;
+ uint32_t *small_frames = (uint32_t*)temp_frames_buffer;
+ size_t target_frame_size = (remote_fd->task_is_64_bit ? sizeof(uint64_t) : sizeof(uint32_t));
+ char *snapshot_backtrace_location = NULL;
+
+ int done = 0;
+ int32_t total_frames = -1;
+ int32_t hot_frames_read = 0;
+ size_t new_hot_frames = 0;
+ int32_t number_needed_hot_frames_in_event;
+ size_t number_hot_frames_to_skip;
+ int32_t i;
+ bool skip_file_read;
+
+ while (!done) {
+
+ // not in cache; read record Ð from disk if possible, shared memory snapshot if necessary.
+ if (remote_fd->cache->shmem && reading_offset >= (off_t)(remote_fd->cache->snapshot.start_stack_offset)) {
+ // must read from shared memory; the record isn't on disk yet
+ snapshot_backtrace_location = (remote_fd->cache->snapshot.stack_buffer + (reading_offset - remote_fd->cache->snapshot.start_stack_offset));
+ *target_stack_event = *(stack_logging_backtrace_event*)snapshot_backtrace_location;
+ big_frames = (uint64_t*)(snapshot_backtrace_location + sizeof(stack_logging_backtrace_event));
+ small_frames = (uint32_t*)big_frames;
+ skip_file_read = true;
+ } else {
+ // the record's on disk
+ i = fseeko(stack_fd, reading_offset, SEEK_SET);
+ if (i != 0) break; // unable to seek to the target position
+ read_count = fread(target_stack_event, read_size, (size_t)1, stack_fd);
+ if (read_count == 0) break;
+
+ big_frames = (uint64_t*)temp_frames_buffer;
+ small_frames = (uint32_t*)temp_frames_buffer;
+ skip_file_read = false;
+ }
+
+ if (total_frames < 0) {
+ total_frames = target_stack_event->num_new_hot_frames + target_stack_event->num_identical_frames;
+ if (total_frames > (int32_t)max_stack_frames) break; // don't know what to do with this; we'll just KERN_FAILURE.
+ }
+
+ // do the math to find how many frames to apply from previous event
+ new_hot_frames = target_stack_event->num_new_hot_frames;
+ number_needed_hot_frames_in_event = total_frames - hot_frames_read - target_stack_event->num_identical_frames;
+ number_hot_frames_to_skip = new_hot_frames - number_needed_hot_frames_in_event;
+
+ // read and apply the important frames of this one
+ if (number_needed_hot_frames_in_event > 0) {
+ if (!skip_file_read) {
+ read_count = fread(temp_frames_buffer, target_frame_size, new_hot_frames, stack_fd);
+ if (read_count < new_hot_frames) break;
+ }
+
+ if (remote_fd->task_is_64_bit) {
+ for (i = 0; i < number_needed_hot_frames_in_event; i++) {
+ stack_frames_buffer[hot_frames_read++] = big_frames[i+number_hot_frames_to_skip];
+ }
+ } else {
+ for (i = 0; i < number_needed_hot_frames_in_event; i++) {
+ stack_frames_buffer[hot_frames_read++] = small_frames[i+number_hot_frames_to_skip];
+ }
+ }
+ }
+
+ reading_offset += target_stack_event->offset_delta;
+
+ if (hot_frames_read == total_frames) done = 1;
+ else if (target_stack_event->offset_delta == 0) {
+ fprintf(stderr, "incomplete stack record (identifier: 0x%qx)\n", reading_offset);
+ break;
+ }
+ }
+
+ release_file_streams_for_task(task);
+
+ if (done) {
+ *count = hot_frames_read;
+ return KERN_SUCCESS;
+ } else {
+ return KERN_FAILURE;
+ }
+}
+
+
+#ifdef TEST_DISK_STACK_LOGGING
+
+// cc -o stack_logging_disk stack_logging_disk.c -DTEST_DISK_STACK_LOGGING
+
+#include <sys/wait.h>
+
+main()
+{
+ int status;
+ int i;
+
+ fprintf(stderr, "master test process is %d\n", getpid());
+ fprintf(stderr, "sizeof stack_buffer: %d\n", sizeof(stack_buffer));
+ fprintf(stderr, "sizeof thread_buffer: %d\n", sizeof(thread_buffer));
+ fprintf(stderr, "sizeof stack_logs_directory: %d\n", sizeof(stack_logs_directory));
+ fprintf(stderr, "sizeof remote_fds: %d\n", sizeof(remote_fds));
+ fprintf(stderr, "address of pre_write_backtrace_event_buffer: %p\n", &pre_write_backtrace_event_buffer);
+ fprintf(stderr, "address of logging_use_compaction: %p\n", &logging_use_compaction);
+ // fprintf(stderr, "size of all global data: %d\n", (logging_use_compaction) - (pre_write_backtrace_event_buffer) + sizeof(logging_use_compaction));
+
+ create_log_files();
+
+ // create a few child processes and exit them cleanly so their logs should get cleaned up
+ fprintf(stderr, "\ncreating child processes and exiting cleanly\n");
+ for (i = 0; i < 3; i++) {
+ if (fork() == 0) {
+ fprintf(stderr, "\nin child processes %d\n", getpid());
+ create_log_files();
+ fprintf(stderr, "exiting child processes %d\n", getpid());
+ exit(1);
+ }
+ wait(&status);
+ }
+
+ // create a few child processes and abruptly _exit them, leaving their logs around
+ fprintf(stderr, "\ncreating child processes and exiting abruptly, leaving logs around\n");
+ for (i = 0; i < 3; i++) {
+ if (fork() == 0) {
+ fprintf(stderr, "\nin child processes %d\n", getpid());
+ create_log_files();
+ fprintf(stderr, "exiting child processes %d\n", getpid());
+ _exit(1);
+ }
+ wait(&status);
+ }
+
+ // this should reap any remaining logs
+ fprintf(stderr, "\nexiting master test process %d\n", getpid());
+ delete_log_files();
+}
+
+#endif
projects / apple / libc.git / blobdiff