]> git.saurik.com Git - apple/xnu.git/blobdiff - osfmk/kdp/processor_core.c
projects / apple / xnu.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
xnu-4903.270.47.tar.gz
[apple/xnu.git] / osfmk / kdp / processor_core.c
diff --git a/osfmk/kdp/processor_core.c b/osfmk/kdp/processor_core.c
index e6ebc85a21000e016dd4ee25bc01ff10a8823396..6050ad502ae8ccb6c55b2936564ff00b5549c9d7 100644 (file)
--- a/osfmk/kdp/processor_core.c
+++ b/osfmk/kdp/processor_core.c
@@ -37,8 +37,8 @@
 
 #ifdef CONFIG_KDP_INTERACTIVE_DEBUGGING
 
 
 #ifdef CONFIG_KDP_INTERACTIVE_DEBUGGING
 
-#define        roundup(x, y)   ((((x) % (y)) == 0) ? \
-                       (x) : ((x) + ((y) - ((x) % (y)))))
+#define roundup(x, y)   ((((x) % (y)) == 0) ? \
+                       (x) : ((x) + ((y) - ((x) % (y)))))
 
 /*
  * The processor_core_context structure describes the current
 
 /*
  * The processor_core_context structure describes the current
@@ -95,30 +95,36 @@ struct kern_coredump_core *kernel_helper = NULL;
 
 static struct kern_coredump_core *
 kern_register_coredump_helper_internal(int kern_coredump_config_vers, kern_coredump_callback_config *kc_callbacks,
 
 static struct kern_coredump_core *
 kern_register_coredump_helper_internal(int kern_coredump_config_vers, kern_coredump_callback_config *kc_callbacks,
-                               void *refcon, const char *core_description, boolean_t xnu_callback, boolean_t is64bit,
-                               uint32_t mh_magic, cpu_type_t cpu_type, cpu_subtype_t cpu_subtype)
+    void *refcon, const char *core_description, boolean_t xnu_callback, boolean_t is64bit,
+    uint32_t mh_magic, cpu_type_t cpu_type, cpu_subtype_t cpu_subtype)
 {
        struct kern_coredump_core *core_helper = NULL;
        kern_coredump_callback_config *core_callbacks = NULL;
 
 {
        struct kern_coredump_core *core_helper = NULL;
        kern_coredump_callback_config *core_callbacks = NULL;
 
-       if (kern_coredump_config_vers < KERN_COREDUMP_MIN_CONFIG_VERSION)
+       if (kern_coredump_config_vers < KERN_COREDUMP_MIN_CONFIG_VERSION) {
                return NULL;
                return NULL;
-       if (kc_callbacks == NULL)
-               return NULL;;
-       if (core_description == NULL)
+       }
+       if (kc_callbacks == NULL) {
+               return NULL;
+       }
+       ;
+       if (core_description == NULL) {
                return NULL;
                return NULL;
+       }
 
        if (kc_callbacks->kcc_coredump_get_summary == NULL ||
 
        if (kc_callbacks->kcc_coredump_get_summary == NULL ||
-                       kc_callbacks->kcc_coredump_save_segment_descriptions == NULL ||
-                       kc_callbacks->kcc_coredump_save_segment_data == NULL ||
-                       kc_callbacks->kcc_coredump_save_thread_state == NULL ||
-                       kc_callbacks->kcc_coredump_save_sw_vers == NULL)
+           kc_callbacks->kcc_coredump_save_segment_descriptions == NULL ||
+           kc_callbacks->kcc_coredump_save_segment_data == NULL ||
+           kc_callbacks->kcc_coredump_save_thread_state == NULL ||
+           kc_callbacks->kcc_coredump_save_sw_vers == NULL) {
                return NULL;
                return NULL;
+       }
 
 #if !defined(__LP64__)
        /* We don't support generating 64-bit cores on 32-bit platforms */
 
 #if !defined(__LP64__)
        /* We don't support generating 64-bit cores on 32-bit platforms */
-       if (is64bit)
+       if (is64bit) {
                return NULL;
                return NULL;
+       }
 #endif
 
        core_helper = kalloc(sizeof(*core_helper));
 #endif
 
        core_helper = kalloc(sizeof(*core_helper));
@@ -161,15 +167,17 @@ kern_register_coredump_helper_internal(int kern_coredump_config_vers, kern_cored
 
 kern_return_t
 kern_register_coredump_helper(int kern_coredump_config_vers, kern_coredump_callback_config *kc_callbacks,
 
 kern_return_t
 kern_register_coredump_helper(int kern_coredump_config_vers, kern_coredump_callback_config *kc_callbacks,
-                               void *refcon, const char *core_description, boolean_t is64bit, uint32_t mh_magic,
-                               cpu_type_t cpu_type, cpu_subtype_t cpu_subtype)
+    void *refcon, const char *core_description, boolean_t is64bit, uint32_t mh_magic,
+    cpu_type_t cpu_type, cpu_subtype_t cpu_subtype)
 {
 {
-       if (coredump_registered_count >= KERN_COREDUMP_MAX_CORES)
+       if (coredump_registered_count >= KERN_COREDUMP_MAX_CORES) {
                return KERN_RESOURCE_SHORTAGE;
                return KERN_RESOURCE_SHORTAGE;
+       }
 
        if (kern_register_coredump_helper_internal(kern_coredump_config_vers, kc_callbacks, refcon, core_description, FALSE,
 
        if (kern_register_coredump_helper_internal(kern_coredump_config_vers, kc_callbacks, refcon, core_description, FALSE,
-                               is64bit, mh_magic, cpu_type, cpu_subtype) == NULL)
+           is64bit, mh_magic, cpu_type, cpu_subtype) == NULL) {
                return KERN_INVALID_ARGUMENT;
                return KERN_INVALID_ARGUMENT;
+       }
 
        return KERN_SUCCESS;
 }
 
        return KERN_SUCCESS;
 }
@@ -184,8 +192,9 @@ kern_register_xnu_coredump_helper(kern_coredump_callback_config *kc_callbacks)
 #endif
 
        if (kern_register_coredump_helper_internal(KERN_COREDUMP_CONFIG_VERSION, kc_callbacks, NULL, "kernel", TRUE, is64bit,
 #endif
 
        if (kern_register_coredump_helper_internal(KERN_COREDUMP_CONFIG_VERSION, kc_callbacks, NULL, "kernel", TRUE, is64bit,
-               _mh_execute_header.magic, _mh_execute_header.cputype, _mh_execute_header.cpusubtype) == NULL)
+           _mh_execute_header.magic, _mh_execute_header.cputype, _mh_execute_header.cpusubtype) == NULL) {
                return KERN_FAILURE;
                return KERN_FAILURE;
+       }
 
        return KERN_SUCCESS;
 }
 
        return KERN_SUCCESS;
 }
@@ -195,16 +204,17 @@ kern_register_xnu_coredump_helper(kern_coredump_callback_config *kc_callbacks)
  */
 static int
 coredump_save_summary(uint64_t core_segment_count, uint64_t core_byte_count,
  */
 static int
 coredump_save_summary(uint64_t core_segment_count, uint64_t core_byte_count,
-                                    uint64_t thread_count, uint64_t thread_state_size,
-                                    uint64_t misc_bytes_count, void *context)
+    uint64_t thread_count, uint64_t thread_state_size,
+    uint64_t misc_bytes_count, void *context)
 {
        processor_core_context *core_context = (processor_core_context *)context;
        uint32_t sizeofcmds = 0, numcmds = 0;
        int ret = 0;
 
        if (!core_segment_count || !core_byte_count || !thread_count || !thread_state_size
 {
        processor_core_context *core_context = (processor_core_context *)context;
        uint32_t sizeofcmds = 0, numcmds = 0;
        int ret = 0;
 
        if (!core_segment_count || !core_byte_count || !thread_count || !thread_state_size
-                       || (thread_state_size > KERN_COREDUMP_THREADSIZE_MAX))
+           || (thread_state_size > KERN_COREDUMP_THREADSIZE_MAX)) {
                return KERN_INVALID_ARGUMENT;
                return KERN_INVALID_ARGUMENT;
+       }
 
        /* Initialize core_context */
        core_context->core_segments_remaining = core_context->core_segment_count = core_segment_count;
 
        /* Initialize core_context */
        core_context->core_segments_remaining = core_context->core_segment_count = core_segment_count;
@@ -217,15 +227,15 @@ coredump_save_summary(uint64_t core_segment_count, uint64_t core_byte_count,
 #if defined(__LP64__)
        if (core_context->core_is64bit) {
                sizeofcmds = (uint32_t)(core_context->core_segment_count * sizeof(struct segment_command_64) +
 #if defined(__LP64__)
        if (core_context->core_is64bit) {
                sizeofcmds = (uint32_t)(core_context->core_segment_count * sizeof(struct segment_command_64) +
-                       (core_context->core_threads_remaining * core_context->core_thread_state_size) +
-                       /* TODO: LC_NOTE */ 0 + sizeof(struct ident_command) + KERN_COREDUMP_VERSIONSTRINGMAXSIZE);
+                   (core_context->core_threads_remaining * core_context->core_thread_state_size) +
+                   /* TODO: LC_NOTE */ 0 + sizeof(struct ident_command) + KERN_COREDUMP_VERSIONSTRINGMAXSIZE);
                core_context->core_header_size = sizeofcmds + sizeof(struct mach_header_64);
        } else
 #endif /* defined(__LP64__) */
        {
                sizeofcmds = (uint32_t)(core_context->core_segment_count * sizeof(struct segment_command) +
                core_context->core_header_size = sizeofcmds + sizeof(struct mach_header_64);
        } else
 #endif /* defined(__LP64__) */
        {
                sizeofcmds = (uint32_t)(core_context->core_segment_count * sizeof(struct segment_command) +
-                       (core_context->core_threads_remaining * core_context->core_thread_state_size) +
-                       /* TODO: LC_NOTE */ 0 + sizeof(struct ident_command) + KERN_COREDUMP_VERSIONSTRINGMAXSIZE);
+                   (core_context->core_threads_remaining * core_context->core_thread_state_size) +
+                   /* TODO: LC_NOTE */ 0 + sizeof(struct ident_command) + KERN_COREDUMP_VERSIONSTRINGMAXSIZE);
                core_context->core_header_size = sizeofcmds + sizeof(struct mach_header);
        }
 
                core_context->core_header_size = sizeofcmds + sizeof(struct mach_header);
        }
 
@@ -234,7 +244,7 @@ coredump_save_summary(uint64_t core_segment_count, uint64_t core_byte_count,
        core_context->core_cur_foffset = round_page(core_context->core_header_size);
 
        numcmds = (uint32_t)(core_context->core_segment_count + core_context->core_thread_count + /* TODO: LC_NOTE */ 0 +
        core_context->core_cur_foffset = round_page(core_context->core_header_size);
 
        numcmds = (uint32_t)(core_context->core_segment_count + core_context->core_thread_count + /* TODO: LC_NOTE */ 0 +
-                       1 /* ident command */);
+           1 /* ident command */);
 
        /*
         * Reset the zstream and other output context before writing any data out. We do this here
 
        /*
         * Reset the zstream and other output context before writing any data out. We do this here
@@ -258,8 +268,8 @@ coredump_save_summary(uint64_t core_segment_count, uint64_t core_byte_count,
                /* Send the core_header to the output procedure */
                ret =  kdp_core_output(core_context->core_outvars, sizeof(core_header), (caddr_t)&core_header);
                if (ret != KERN_SUCCESS) {
                /* Send the core_header to the output procedure */
                ret =  kdp_core_output(core_context->core_outvars, sizeof(core_header), (caddr_t)&core_header);
                if (ret != KERN_SUCCESS) {
-                       kern_coredump_log(context, "coredump_save_summary() : failed to write mach header : kdp_core_output(0x%p, %lu, 0x%p) returned error 0x%x\n",
-                                       core_context->core_outvars, sizeof(core_header), &core_header, ret);
+                       kern_coredump_log(context, "coredump_save_summary() : failed to write mach header : kdp_core_output(%p, %lu, %p) returned error 0x%x\n",
+                           core_context->core_outvars, sizeof(core_header), &core_header, ret);
                        return ret;
                }
 
                        return ret;
                }
 
@@ -280,8 +290,8 @@ coredump_save_summary(uint64_t core_segment_count, uint64_t core_byte_count,
                /* Send the core_header to the output procedure */
                ret =  kdp_core_output(core_context->core_outvars, sizeof(core_header), (caddr_t)&core_header);
                if (ret != KERN_SUCCESS) {
                /* Send the core_header to the output procedure */
                ret =  kdp_core_output(core_context->core_outvars, sizeof(core_header), (caddr_t)&core_header);
                if (ret != KERN_SUCCESS) {
-                       kern_coredump_log(context, "coredump_save_summary() : failed to write mach header : kdp_core_output(0x%p, %lu, 0x%p) returned error 0x%x\n",
-                                       core_context->core_outvars, sizeof(core_header), &core_header, ret);
+                       kern_coredump_log(context, "coredump_save_summary() : failed to write mach header : kdp_core_output(%p, %lu, %p) returned error 0x%x\n",
+                           core_context->core_outvars, sizeof(core_header), &core_header, ret);
                        return ret;
                }
 
                        return ret;
                }
 
@@ -296,21 +306,21 @@ coredump_save_summary(uint64_t core_segment_count, uint64_t core_byte_count,
  */
 static int
 coredump_save_segment_descriptions(uint64_t seg_start, uint64_t seg_end,
  */
 static int
 coredump_save_segment_descriptions(uint64_t seg_start, uint64_t seg_end,
-                                                 void *context)
+    void *context)
 {
        processor_core_context *core_context = (processor_core_context *)context;
        int ret;
        uint64_t size = seg_end - seg_start;
 
        if (seg_end <= seg_start) {
 {
        processor_core_context *core_context = (processor_core_context *)context;
        int ret;
        uint64_t size = seg_end - seg_start;
 
        if (seg_end <= seg_start) {
-               kern_coredump_log(context, "coredump_save_segment_descriptions(0x%llx, 0x%llx, 0x%p) : called with invalid addresses : start 0x%llx >= end 0x%llx\n",
-                               seg_start, seg_end, context, seg_start, seg_end);
+               kern_coredump_log(context, "coredump_save_segment_descriptions(0x%llx, 0x%llx, %p) : called with invalid addresses : start 0x%llx >= end 0x%llx\n",
+                   seg_start, seg_end, context, seg_start, seg_end);
                return KERN_INVALID_ARGUMENT;
        }
 
        if (core_context->core_segments_remaining == 0) {
                return KERN_INVALID_ARGUMENT;
        }
 
        if (core_context->core_segments_remaining == 0) {
-               kern_coredump_log(context, "coredump_save_segment_descriptions(0x%llx, 0x%llx, 0x%p) : coredump_save_segment_descriptions() called too many times, %llu segment descriptions already recorded\n",
-                               seg_start, seg_end, context, core_context->core_segment_count);
+               kern_coredump_log(context, "coredump_save_segment_descriptions(0x%llx, 0x%llx, %p) : coredump_save_segment_descriptions() called too many times, %llu segment descriptions already recorded\n",
+                   seg_start, seg_end, context, core_context->core_segment_count);
                return KERN_INVALID_ARGUMENT;
        }
 
                return KERN_INVALID_ARGUMENT;
        }
 
@@ -320,8 +330,8 @@ coredump_save_segment_descriptions(uint64_t seg_start, uint64_t seg_end,
                struct segment_command_64 seg_command = { };
 
                if (core_context->core_cur_hoffset + sizeof(seg_command) > core_context->core_header_size) {
                struct segment_command_64 seg_command = { };
 
                if (core_context->core_cur_hoffset + sizeof(seg_command) > core_context->core_header_size) {
-                       kern_coredump_log(context, "coredump_save_segment_descriptions(0x%llx, 0x%llx, 0x%p) : ran out of space to save commands with %llu of %llu remaining\n",
-                               seg_start, seg_end, context, core_context->core_segments_remaining, core_context->core_segment_count);
+                       kern_coredump_log(context, "coredump_save_segment_descriptions(0x%llx, 0x%llx, %p) : ran out of space to save commands with %llu of %llu remaining\n",
+                           seg_start, seg_end, context, core_context->core_segments_remaining, core_context->core_segment_count);
                        return KERN_NO_SPACE;
                }
 
                        return KERN_NO_SPACE;
                }
 
@@ -338,9 +348,9 @@ coredump_save_segment_descriptions(uint64_t seg_start, uint64_t seg_end,
                /* Flush new command to output */
                ret = kdp_core_output(core_context->core_outvars, sizeof(seg_command), (caddr_t)&seg_command);
                if (ret != KERN_SUCCESS) {
                /* Flush new command to output */
                ret = kdp_core_output(core_context->core_outvars, sizeof(seg_command), (caddr_t)&seg_command);
                if (ret != KERN_SUCCESS) {
-                       kern_coredump_log(context, "coredump_save_segment_descriptions(0x%llx, 0x%llx, 0x%p) : failed to write segment %llu of %llu. kdp_core_output(0x%p, %lu, 0x%p) returned error %d\n",
-                                       seg_start, seg_end, context, core_context->core_segment_count - core_context->core_segments_remaining,
-                                       core_context->core_segment_count, core_context->core_outvars, sizeof(seg_command), &seg_command, ret);
+                       kern_coredump_log(context, "coredump_save_segment_descriptions(0x%llx, 0x%llx, %p) : failed to write segment %llu of %llu. kdp_core_output(%p, %lu, %p) returned error %d\n",
+                           seg_start, seg_end, context, core_context->core_segment_count - core_context->core_segments_remaining,
+                           core_context->core_segment_count, core_context->core_outvars, sizeof(seg_command), &seg_command, ret);
                        return ret;
                }
 
                        return ret;
                }
 
@@ -351,14 +361,14 @@ coredump_save_segment_descriptions(uint64_t seg_start, uint64_t seg_end,
                struct segment_command seg_command = { };
 
                if (seg_start > UINT32_MAX || seg_end > UINT32_MAX) {
                struct segment_command seg_command = { };
 
                if (seg_start > UINT32_MAX || seg_end > UINT32_MAX) {
-                       kern_coredump_log(context, "coredump_save_segment_descriptions(0x%llx, 0x%llx, 0x%p) : called with invalid addresses for 32-bit : start 0x%llx, end 0x%llx\n",
-                               seg_start, seg_end, context, seg_start, seg_end);
+                       kern_coredump_log(context, "coredump_save_segment_descriptions(0x%llx, 0x%llx, %p) : called with invalid addresses for 32-bit : start 0x%llx, end 0x%llx\n",
+                           seg_start, seg_end, context, seg_start, seg_end);
                        return KERN_INVALID_ARGUMENT;
                }
 
                if (core_context->core_cur_hoffset + sizeof(seg_command) > core_context->core_header_size) {
                        return KERN_INVALID_ARGUMENT;
                }
 
                if (core_context->core_cur_hoffset + sizeof(seg_command) > core_context->core_header_size) {
-                       kern_coredump_log(context, "coredump_save_segment_descriptions(0x%llx, 0x%llx, 0x%p) : ran out of space to save commands with %llu of %llu remaining\n",
-                               seg_start, seg_end, context, core_context->core_segments_remaining, core_context->core_segment_count);
+                       kern_coredump_log(context, "coredump_save_segment_descriptions(0x%llx, 0x%llx, %p) : ran out of space to save commands with %llu of %llu remaining\n",
+                           seg_start, seg_end, context, core_context->core_segments_remaining, core_context->core_segment_count);
                        return KERN_NO_SPACE;
                }
 
                        return KERN_NO_SPACE;
                }
 
@@ -375,9 +385,9 @@ coredump_save_segment_descriptions(uint64_t seg_start, uint64_t seg_end,
                /* Flush new command to output */
                ret = kdp_core_output(core_context->core_outvars, sizeof(seg_command), (caddr_t)&seg_command);
                if (ret != KERN_SUCCESS) {
                /* Flush new command to output */
                ret = kdp_core_output(core_context->core_outvars, sizeof(seg_command), (caddr_t)&seg_command);
                if (ret != KERN_SUCCESS) {
-                       kern_coredump_log(context, "coredump_save_segment_descriptions(0x%llx, 0x%llx, 0x%p) : failed to write segment %llu of %llu : kdp_core_output(0x%p, %lu, 0x%p) returned  error 0x%x\n",
-                                       seg_start, seg_end, context, core_context->core_segment_count - core_context->core_segments_remaining,
-                                       core_context->core_segment_count, core_context->core_outvars, sizeof(seg_command), &seg_command, ret);
+                       kern_coredump_log(context, "coredump_save_segment_descriptions(0x%llx, 0x%llx, %p) : failed to write segment %llu of %llu : kdp_core_output(%p, %lu, %p) returned  error 0x%x\n",
+                           seg_start, seg_end, context, core_context->core_segment_count - core_context->core_segments_remaining,
+                           core_context->core_segment_count, core_context->core_outvars, sizeof(seg_command), &seg_command, ret);
                        return ret;
                }
 
                        return ret;
                }
 
@@ -404,21 +414,21 @@ coredump_save_thread_state(void *thread_state, void *context)
        int ret;
 
        if (tc->cmd != LC_THREAD) {
        int ret;
 
        if (tc->cmd != LC_THREAD) {
-               kern_coredump_log(context, "coredump_save_thread_state(0x%p, 0x%p) : found %d expected LC_THREAD (%d)\n",
-                               thread_state, context, tc->cmd, LC_THREAD);
+               kern_coredump_log(context, "coredump_save_thread_state(%p, %p) : found %d expected LC_THREAD (%d)\n",
+                   thread_state, context, tc->cmd, LC_THREAD);
                return KERN_INVALID_ARGUMENT;
        }
 
        if (core_context->core_cur_hoffset + core_context->core_thread_state_size > core_context->core_header_size) {
                return KERN_INVALID_ARGUMENT;
        }
 
        if (core_context->core_cur_hoffset + core_context->core_thread_state_size > core_context->core_header_size) {
-               kern_coredump_log(context, "coredump_save_thread_state(0x%p, 0x%p) : ran out of space to save threads with %llu of %llu remaining\n",
-                               thread_state, context, core_context->core_threads_remaining, core_context->core_thread_count);
+               kern_coredump_log(context, "coredump_save_thread_state(%p, %p) : ran out of space to save threads with %llu of %llu remaining\n",
+                   thread_state, context, core_context->core_threads_remaining, core_context->core_thread_count);
                return KERN_NO_SPACE;
        }
 
        ret = kdp_core_output(core_context->core_outvars, core_context->core_thread_state_size, (caddr_t)thread_state);
        if (ret != KERN_SUCCESS) {
                return KERN_NO_SPACE;
        }
 
        ret = kdp_core_output(core_context->core_outvars, core_context->core_thread_state_size, (caddr_t)thread_state);
        if (ret != KERN_SUCCESS) {
-               kern_coredump_log(context, "coredump_save_thread_state(0x%p, 0x%p) : failed to write thread data : kdp_core_output(0x%p, %llu, 0x%p) returned 0x%x\n",
-                               thread_state, context, core_context->core_outvars, core_context->core_thread_state_size, thread_state, ret);
+               kern_coredump_log(context, "coredump_save_thread_state(%p, %p) : failed to write thread data : kdp_core_output(%p, %llu, %p) returned 0x%x\n",
+                   thread_state, context, core_context->core_outvars, core_context->core_thread_state_size, thread_state, ret);
                return ret;
        }
 
                return ret;
        }
 
@@ -436,14 +446,14 @@ coredump_save_sw_vers(void *sw_vers, uint64_t length, void *context)
        int ret;
 
        if (length > KERN_COREDUMP_VERSIONSTRINGMAXSIZE || !length) {
        int ret;
 
        if (length > KERN_COREDUMP_VERSIONSTRINGMAXSIZE || !length) {
-               kern_coredump_log(context, "coredump_save_sw_vers(0x%p, %llu, 0x%p) : called with invalid length %llu\n",
-                               sw_vers, length, context, length);
+               kern_coredump_log(context, "coredump_save_sw_vers(%p, %llu, %p) : called with invalid length %llu\n",
+                   sw_vers, length, context, length);
                return KERN_INVALID_ARGUMENT;
        }
 
        if (core_context->core_cur_hoffset + sizeof(struct ident_command) + length > core_context->core_header_size) {
                return KERN_INVALID_ARGUMENT;
        }
 
        if (core_context->core_cur_hoffset + sizeof(struct ident_command) + length > core_context->core_header_size) {
-               kern_coredump_log(context, "coredump_save_sw_vers(0x%p, %llu, 0x%p) : ran out of space to save data\n",
-                               sw_vers, length, context);
+               kern_coredump_log(context, "coredump_save_sw_vers(%p, %llu, %p) : ran out of space to save data\n",
+                   sw_vers, length, context);
                return KERN_NO_SPACE;
        }
 
                return KERN_NO_SPACE;
        }
 
@@ -451,15 +461,15 @@ coredump_save_sw_vers(void *sw_vers, uint64_t length, void *context)
        ident.cmdsize = (uint32_t)(sizeof(struct ident_command) + KERN_COREDUMP_VERSIONSTRINGMAXSIZE);
        ret = kdp_core_output(core_context->core_outvars, sizeof(struct ident_command), (caddr_t)&ident);
        if (ret != KERN_SUCCESS) {
        ident.cmdsize = (uint32_t)(sizeof(struct ident_command) + KERN_COREDUMP_VERSIONSTRINGMAXSIZE);
        ret = kdp_core_output(core_context->core_outvars, sizeof(struct ident_command), (caddr_t)&ident);
        if (ret != KERN_SUCCESS) {
-               kern_coredump_log(context, "coredump_save_sw_vers(0x%p, %llu, 0x%p) : failed to write ident command : kdp_core_output(0x%p, %lu, 0x%p) returned 0x%x\n",
-                               sw_vers, length, context, core_context->core_outvars, sizeof(struct ident_command), &ident, ret);
+               kern_coredump_log(context, "coredump_save_sw_vers(%p, %llu, %p) : failed to write ident command : kdp_core_output(%p, %lu, %p) returned 0x%x\n",
+                   sw_vers, length, context, core_context->core_outvars, sizeof(struct ident_command), &ident, ret);
                return ret;
        }
 
        ret = kdp_core_output(core_context->core_outvars, length, (caddr_t)sw_vers);
        if (ret != KERN_SUCCESS) {
                return ret;
        }
 
        ret = kdp_core_output(core_context->core_outvars, length, (caddr_t)sw_vers);
        if (ret != KERN_SUCCESS) {
-               kern_coredump_log(context, "coredump_save_sw_vers(0x%p, %llu, 0x%p) : failed to write version string : kdp_core_output(0x%p, %llu, 0x%p) returned 0x%x\n",
-                               sw_vers, length, context, core_context->core_outvars, length, sw_vers, ret);
+               kern_coredump_log(context, "coredump_save_sw_vers(%p, %llu, %p) : failed to write version string : kdp_core_output(%p, %llu, %p) returned 0x%x\n",
+                   sw_vers, length, context, core_context->core_outvars, length, sw_vers, ret);
                return ret;
        }
 
                return ret;
        }
 
@@ -467,8 +477,8 @@ coredump_save_sw_vers(void *sw_vers, uint64_t length, void *context)
                /* Zero fill to the full command size */
                ret = kdp_core_output(core_context->core_outvars, (KERN_COREDUMP_VERSIONSTRINGMAXSIZE - length), NULL);
                if (ret != KERN_SUCCESS) {
                /* Zero fill to the full command size */
                ret = kdp_core_output(core_context->core_outvars, (KERN_COREDUMP_VERSIONSTRINGMAXSIZE - length), NULL);
                if (ret != KERN_SUCCESS) {
-                       kern_coredump_log(context, "coredump_save_sw_vers(0x%p, %llu, 0x%p) : failed to write zero fill padding : kdp_core_output(0x%p, %llu, NULL) returned 0x%x\n",
-                                       sw_vers, length, context, core_context->core_outvars, (KERN_COREDUMP_VERSIONSTRINGMAXSIZE - length), ret);
+                       kern_coredump_log(context, "coredump_save_sw_vers(%p, %llu, %p) : failed to write zero fill padding : kdp_core_output(%p, %llu, NULL) returned 0x%x\n",
+                           sw_vers, length, context, core_context->core_outvars, (KERN_COREDUMP_VERSIONSTRINGMAXSIZE - length), ret);
                        return ret;
                }
        }
                        return ret;
                }
        }
@@ -485,16 +495,16 @@ coredump_save_segment_data(void *seg_data, uint64_t length, void *context)
        processor_core_context *core_context = (processor_core_context *)context;
 
        if (length > core_context->core_segment_bytes_remaining) {
        processor_core_context *core_context = (processor_core_context *)context;
 
        if (length > core_context->core_segment_bytes_remaining) {
-               kern_coredump_log(context, "coredump_save_segment_data(0x%p, %llu, 0x%p) : called with too much data, %llu written, %llu left\n",
-                               seg_data, length, context, core_context->core_segment_byte_total - core_context->core_segment_bytes_remaining,
-                               core_context->core_segment_bytes_remaining);
+               kern_coredump_log(context, "coredump_save_segment_data(%p, %llu, %p) : called with too much data, %llu written, %llu left\n",
+                   seg_data, length, context, core_context->core_segment_byte_total - core_context->core_segment_bytes_remaining,
+                   core_context->core_segment_bytes_remaining);
                return KERN_INVALID_ARGUMENT;
        }
 
        ret = kdp_core_output(core_context->core_outvars, length, (caddr_t)seg_data);
        if (ret != KERN_SUCCESS) {
                return KERN_INVALID_ARGUMENT;
        }
 
        ret = kdp_core_output(core_context->core_outvars, length, (caddr_t)seg_data);
        if (ret != KERN_SUCCESS) {
-               kern_coredump_log(context, "coredump_save_segment_data(0x%p, %llu, 0x%p) : failed to write data (%llu bytes remaining) :%d\n",
-                               seg_data, length, context, core_context->core_segment_bytes_remaining, ret);
+               kern_coredump_log(context, "coredump_save_segment_data(%p, %llu, %p) : failed to write data (%llu bytes remaining) :%d\n",
+                   seg_data, length, context, core_context->core_segment_bytes_remaining, ret);
                return ret;
        }
 
                return ret;
        }
 
@@ -528,7 +538,7 @@ kern_coredump_routine(void *core_outvars, struct kern_coredump_core *current_cor
                if (ret == KERN_NODE_DOWN) {
                        kern_coredump_log(&context, "coredump_init returned KERN_NODE_DOWN, skipping this core\n");
                        return KERN_SUCCESS;
                if (ret == KERN_NODE_DOWN) {
                        kern_coredump_log(&context, "coredump_init returned KERN_NODE_DOWN, skipping this core\n");
                        return KERN_SUCCESS;
-               } else  if (ret != KERN_SUCCESS) {
+               } else if (ret != KERN_SUCCESS) {
                        kern_coredump_log(&context, "(kern_coredump_routine) : coredump_init failed with %d\n", ret);
                        return ret;
                }
                        kern_coredump_log(&context, "(kern_coredump_routine) : coredump_init failed with %d\n", ret);
                        return ret;
                }
@@ -548,7 +558,7 @@ kern_coredump_routine(void *core_outvars, struct kern_coredump_core *current_cor
 
        /* Save the segment descriptions for the segments to be included */
        ret = current_core->kcc_cb.kcc_coredump_save_segment_descriptions(context.core_refcon, coredump_save_segment_descriptions,
 
        /* Save the segment descriptions for the segments to be included */
        ret = current_core->kcc_cb.kcc_coredump_save_segment_descriptions(context.core_refcon, coredump_save_segment_descriptions,
-                       &context);
+           &context);
        if (ret != KERN_SUCCESS) {
                kern_coredump_log(&context, "(kern_coredump_routine) : save_segment_descriptions failed with %d\n", ret);
                return ret;
        if (ret != KERN_SUCCESS) {
                kern_coredump_log(&context, "(kern_coredump_routine) : save_segment_descriptions failed with %d\n", ret);
                return ret;
@@ -556,7 +566,7 @@ kern_coredump_routine(void *core_outvars, struct kern_coredump_core *current_cor
 
        if (context.core_segments_remaining != 0) {
                kern_coredump_log(&context, "(kern_coredump_routine) : save_segment_descriptions returned without all segment descriptions written, %llu of %llu remaining\n",
 
        if (context.core_segments_remaining != 0) {
                kern_coredump_log(&context, "(kern_coredump_routine) : save_segment_descriptions returned without all segment descriptions written, %llu of %llu remaining\n",
-                               context.core_segments_remaining, context.core_segment_count);
+                   context.core_segments_remaining, context.core_segment_count);
                return KERN_FAILURE;
        }
 
                return KERN_FAILURE;
        }
 
@@ -570,7 +580,7 @@ kern_coredump_routine(void *core_outvars, struct kern_coredump_core *current_cor
        if (context.core_thread_state_size) {
                char threadstatebuf[context.core_thread_state_size];
                ret = current_core->kcc_cb.kcc_coredump_save_thread_state(context.core_refcon, &threadstatebuf, coredump_save_thread_state,
        if (context.core_thread_state_size) {
                char threadstatebuf[context.core_thread_state_size];
                ret = current_core->kcc_cb.kcc_coredump_save_thread_state(context.core_refcon, &threadstatebuf, coredump_save_thread_state,
-                               &context);
+                   &context);
                if (ret != KERN_SUCCESS) {
                        kern_coredump_log(&context, "(kern_coredump_routine) : save_thread_state failed with %d\n", ret);
                        return ret;
                if (ret != KERN_SUCCESS) {
                        kern_coredump_log(&context, "(kern_coredump_routine) : save_thread_state failed with %d\n", ret);
                        return ret;
@@ -579,7 +589,7 @@ kern_coredump_routine(void *core_outvars, struct kern_coredump_core *current_cor
 
        if (context.core_threads_remaining != 0) {
                kern_coredump_log(&context, "(kern_coredump_routine) : save_thread_state returned without all thread descriptions written, %llu of %llu remaining\n",
 
        if (context.core_threads_remaining != 0) {
                kern_coredump_log(&context, "(kern_coredump_routine) : save_thread_state returned without all thread descriptions written, %llu of %llu remaining\n",
-                               context.core_threads_remaining, context.core_thread_count);
+                   context.core_threads_remaining, context.core_thread_count);
                return KERN_FAILURE;
        }
 
                return KERN_FAILURE;
        }
 
@@ -595,8 +605,8 @@ kern_coredump_routine(void *core_outvars, struct kern_coredump_core *current_cor
        /* Zero fill between the end of the header and the beginning of the segment data file offset */
        ret = kdp_core_output(context.core_outvars, (round_page(context.core_header_size) - context.core_header_size), NULL);
        if (ret != KERN_SUCCESS) {
        /* Zero fill between the end of the header and the beginning of the segment data file offset */
        ret = kdp_core_output(context.core_outvars, (round_page(context.core_header_size) - context.core_header_size), NULL);
        if (ret != KERN_SUCCESS) {
-               kern_coredump_log(&context, "(kern_coredump_routine) : failed to write zero fill padding (%llu bytes remaining) : kdp_core_output(0x%p, %llu, NULL) returned 0x%x\n",
-                               context.core_segment_bytes_remaining, context.core_outvars, (round_page(context.core_header_size) - context.core_header_size), ret);
+               kern_coredump_log(&context, "(kern_coredump_routine) : failed to write zero fill padding (%llu bytes remaining) : kdp_core_output(%p, %llu, NULL) returned 0x%x\n",
+                   context.core_segment_bytes_remaining, context.core_outvars, (round_page(context.core_header_size) - context.core_header_size), ret);
                return ret;
        }
 
                return ret;
        }
 
@@ -609,7 +619,7 @@ kern_coredump_routine(void *core_outvars, struct kern_coredump_core *current_cor
 
        if (context.core_segment_bytes_remaining != 0) {
                kern_coredump_log(&context, "(kern_coredump_routine) : save_segment_data returned without all segment data written, %llu of %llu remaining\n",
 
        if (context.core_segment_bytes_remaining != 0) {
                kern_coredump_log(&context, "(kern_coredump_routine) : save_segment_data returned without all segment data written, %llu of %llu remaining\n",
-                               context.core_segment_bytes_remaining, context.core_segment_byte_total);
+                   context.core_segment_bytes_remaining, context.core_segment_byte_total);
                return KERN_FAILURE;
        }
 
                return KERN_FAILURE;
        }
 
@@ -618,14 +628,14 @@ kern_coredump_routine(void *core_outvars, struct kern_coredump_core *current_cor
        /* Flush the last data out */
        ret = kdp_core_output(context.core_outvars, 0, NULL);
        if (ret != KERN_SUCCESS) {
        /* Flush the last data out */
        ret = kdp_core_output(context.core_outvars, 0, NULL);
        if (ret != KERN_SUCCESS) {
-               kern_coredump_log(&context, "(kern_coredump_routine) : failed to flush final core data : kdp_core_output(0x%p, 0, NULL) returned 0x%x\n",
-                               context.core_outvars, ret);
+               kern_coredump_log(&context, "(kern_coredump_routine) : failed to flush final core data : kdp_core_output(%p, 0, NULL) returned 0x%x\n",
+                   context.core_outvars, ret);
                return ret;
        }
 
        kern_coredump_log(&context, "Done\nCoredump complete of %s, dumped %llu segments (%llu bytes), %llu threads (%llu bytes) overall uncompressed file length %llu bytes.",
                return ret;
        }
 
        kern_coredump_log(&context, "Done\nCoredump complete of %s, dumped %llu segments (%llu bytes), %llu threads (%llu bytes) overall uncompressed file length %llu bytes.",
-                       current_core->kcc_corename, context.core_segment_count, context.core_segment_byte_total, context.core_thread_count,
-                       (context.core_thread_count * context.core_thread_state_size), context.core_file_length);
+           current_core->kcc_corename, context.core_segment_count, context.core_segment_byte_total, context.core_thread_count,
+           (context.core_thread_count * context.core_thread_state_size), context.core_file_length);
 
        if (core_begin_offset) {
                /* If we're writing to disk (we have a begin offset, we need to update the header */
 
        if (core_begin_offset) {
                /* If we're writing to disk (we have a begin offset, we need to update the header */
@@ -678,13 +688,13 @@ kern_do_coredump(void *core_outvars, boolean_t kernel_only, uint64_t first_file_
        current_core = kern_coredump_core_list;
        while (current_core) {
                /* Seek to the beginning of the next file */
        current_core = kern_coredump_core_list;
        while (current_core) {
                /* Seek to the beginning of the next file */
-               ret = kern_dump_seek_to_next_file(core_outvars, *last_file_offset);
-               if (ret != KERN_SUCCESS) {
+               cur_ret = kern_dump_seek_to_next_file(core_outvars, *last_file_offset);
+               if (cur_ret != KERN_SUCCESS) {
                        kern_coredump_log(NULL, "Failed to seek to beginning of next core\n");
                        return KERN_FAILURE;
                }
 
                        kern_coredump_log(NULL, "Failed to seek to beginning of next core\n");
                        return KERN_FAILURE;
                }
 
-               cur_ret = kern_coredump_routine(core_outvars, current_core, *last_file_offset , &prev_core_length, &header_update_failed);
+               cur_ret = kern_coredump_routine(core_outvars, current_core, *last_file_offset, &prev_core_length, &header_update_failed);
                if (cur_ret != KERN_SUCCESS) {
                        // As long as we didn't fail while updating the header for the raw file, we should be able to try
                        // to capture other corefiles.
                if (cur_ret != KERN_SUCCESS) {
                        // As long as we didn't fail while updating the header for the raw file, we should be able to try
                        // to capture other corefiles.
@@ -711,8 +721,8 @@ kern_do_coredump(void *core_outvars, boolean_t kernel_only, uint64_t first_file_
 
 kern_return_t
 kern_register_coredump_helper(int kern_coredump_config_vers, kern_coredump_callback_config *kc_callbacks, void* refcon,
 
 kern_return_t
 kern_register_coredump_helper(int kern_coredump_config_vers, kern_coredump_callback_config *kc_callbacks, void* refcon,
-                               const char *core_description, boolean_t is64bit, uint32_t mh_magic,
-                               cpu_type_t cpu_type, cpu_subtype_t cpu_subtype)
+    const char *core_description, boolean_t is64bit, uint32_t mh_magic,
+    cpu_type_t cpu_type, cpu_subtype_t cpu_subtype)
 {
 #pragma unused(kern_coredump_config_vers, kc_callbacks, refcon, core_description, is64bit, mh_magic, cpu_type, cpu_subtype)
        return KERN_NOT_SUPPORTED;
 {
 #pragma unused(kern_coredump_config_vers, kc_callbacks, refcon, core_description, is64bit, mh_magic, cpu_type, cpu_subtype)
        return KERN_NOT_SUPPORTED;
mirror of XNU