/*
- * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2000-2008 Apple Inc. All rights reserved.
*
- * @APPLE_LICENSE_OSREFERENCE_HEADER_START@
+ * @APPLE_OSREFERENCE_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. The rights granted to you under the
- * License may not be used to create, or enable the creation or
- * redistribution of, unlawful or unlicensed copies of an Apple operating
- * system, or to circumvent, violate, or enable the circumvention or
- * violation of, any terms of an Apple operating system software license
- * agreement.
- *
- * 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
+ * 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. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.
+ *
+ * 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_OSREFERENCE_HEADER_END@
+ *
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@
*/
+
/*
* Copyright (c) 1982, 1986, 1993
* The Regents of the University of California. All rights reserved.
#include <mach/exception_types.h>
#include <kern/cpu_data.h>
#include <kern/debug.h>
+#include <kern/clock.h>
#include <kdp/kdp_core.h>
#include <kdp/kdp_internal.h>
#include <kdp/kdp_en_debugger.h>
+#include <kdp/kdp_callout.h>
#include <kdp/kdp_udp.h>
+#if CONFIG_SERIAL_KDP
+#include <kdp/kdp_serial.h>
+#endif
#include <vm/vm_map.h>
#include <vm/vm_protos.h>
extern int kdp_getc(void);
extern int reattach_wait;
+extern int serial_getc(void);
+extern void serial_putc(char);
+extern int serial_init(void);
+
static u_short ip_id; /* ip packet ctr, for ids */
/* @(#)udp_usrreq.c 2.2 88/05/23 4.0NFSSRC SMI; from UCB 7.1 6/5/86 */
volatile int kdp_flag = 0;
-static kdp_send_t kdp_en_send_pkt = 0;
-static kdp_receive_t kdp_en_recv_pkt = 0;
+static kdp_send_t kdp_en_send_pkt;
+static kdp_receive_t kdp_en_recv_pkt;
static u_long kdp_current_ip_address = 0;
static struct ether_addr kdp_current_mac_address = {{0, 0, 0, 0, 0, 0}};
-static void *kdp_current_ifp = 0;
+static void *kdp_current_ifp;
static void kdp_handler( void *);
static boolean_t router_specified = FALSE;
static unsigned int panicd_port = CORE_REMOTE_PORT;
-/* As in bsd/net/ether_if_module.c */
static struct ether_addr etherbroadcastaddr = {{0xff, 0xff, 0xff, 0xff, 0xff, 0xff}};
static struct ether_addr router_mac = {{0, 0, 0 , 0, 0, 0}};
static char router_ip_str[20];
static unsigned int panic_block = 0;
-static volatile unsigned int kdp_trigger_core_dump = 0;
-static volatile unsigned int flag_kdp_trigger_reboot = 0;
+volatile unsigned int kdp_trigger_core_dump = 0;
+__private_extern__ volatile unsigned int flag_kdp_trigger_reboot = 0;
extern unsigned int not_in_kdp;
-extern unsigned long panic_caller;
extern unsigned int disableConsoleOutput;
extern int kdp_vm_read( caddr_t, caddr_t, unsigned int);
static void kdp_process_arp_reply(struct ether_arp *);
static boolean_t kdp_arp_resolve(uint32_t, struct ether_addr *);
+static volatile unsigned kdp_reentry_deadline;
+
static boolean_t gKDPDebug = FALSE;
#define KDP_DEBUG(...) if (gKDPDebug) printf(__VA_ARGS__);
static int stack_snapshot_pid;
static uint32_t stack_snapshot_options;
+static unsigned int old_debugger;
+
void
kdp_snapshot_preflight(int pid, void * tracebuf, uint32_t tracebuf_size,
uint32_t options);
kdp_snapshot_postflight(void);
extern int
-kdp_stackshot(int pid, uint32_t tracebuf, uint32_t tracebuf_size,
+kdp_stackshot(int pid, void *tracebuf, uint32_t tracebuf_size,
unsigned trace_options, uint32_t *pbytesTraced);
int
int
kdp_stack_snapshot_bytes_traced(void);
+static thread_call_t
+kdp_timer_call;
+
+static void
+kdp_ml_enter_debugger_wrapper(__unused void *param0, __unused void *param1) {
+ kdp_ml_enter_debugger();
+}
+
+static void
+kdp_timer_callout_init(void) {
+ kdp_timer_call = thread_call_allocate(kdp_ml_enter_debugger_wrapper, NULL);
+}
+
+
void
kdp_register_send_receive(
kdp_send_t send,
kdp_receive_t receive)
{
- unsigned int debug=0;
-
- kdp_en_send_pkt = send;
- kdp_en_recv_pkt = receive;
+ unsigned int debug = 0;
debug_log_init();
- PE_parse_boot_arg("debug", &debug);
+ kdp_timer_callout_init();
+
+ PE_parse_boot_argn("debug", &debug, sizeof (debug));
+
+
+ if (!debug)
+ return;
+
+ kdp_en_send_pkt = send;
+ kdp_en_recv_pkt = receive;
if (debug & DB_KDP_BP_DIS)
kdp_flag |= KDP_BP_DIS;
if (debug & DB_KDP_GETC_ENA)
kdp_flag |= KDP_GETC_ENA;
if (debug & DB_ARP)
- kdp_flag |= KDP_ARP;
+ kdp_flag |= KDP_ARP;
if (debug & DB_KERN_DUMP_ON_PANIC)
- kdp_flag |= KDP_PANIC_DUMP_ENABLED;
+ kdp_flag |= KDP_PANIC_DUMP_ENABLED;
if (debug & DB_KERN_DUMP_ON_NMI)
- kdp_flag |= PANIC_CORE_ON_NMI;
-
+ kdp_flag |= PANIC_CORE_ON_NMI;
+
if (debug & DB_DBG_POST_CORE)
- kdp_flag |= DBG_POST_CORE;
-
+ kdp_flag |= DBG_POST_CORE;
+
if (debug & DB_PANICLOG_DUMP)
- kdp_flag |= PANIC_LOG_DUMP;
-
- if (PE_parse_boot_arg ("_panicd_ip", panicd_ip_str))
- panicd_specified = TRUE;
+ kdp_flag |= PANIC_LOG_DUMP;
+
+ if (PE_parse_boot_argn("_panicd_ip", panicd_ip_str, sizeof (panicd_ip_str)))
+ panicd_specified = TRUE;
- if (PE_parse_boot_arg ("_router_ip", router_ip_str))
- router_specified = TRUE;
+ if (PE_parse_boot_argn("_router_ip", router_ip_str, sizeof (router_ip_str)))
+ router_specified = TRUE;
- if (!PE_parse_boot_arg ("panicd_port", &panicd_port))
+ if (!PE_parse_boot_argn("panicd_port", &panicd_port, sizeof (panicd_port)))
panicd_port = CORE_REMOTE_PORT;
kdp_flag |= KDP_READY;
if (current_debugger == NO_CUR_DB)
current_debugger = KDP_CUR_DB;
- if (halt_in_debugger) {
+ if ((kdp_current_ip_address != 0) && halt_in_debugger) {
kdp_call();
halt_in_debugger=0;
}
stack_snapshot_bufsize = tracebuf_size;
stack_snapshot_options = options;
kdp_snapshot++;
+ /* Mark this debugger as active, since the polled mode driver that
+ * ordinarily does this may not be enabled (yet), or since KDB may be
+ * the primary debugger.
+ */
+ old_debugger = current_debugger;
+ if (old_debugger != KDP_CUR_DB) {
+ current_debugger = KDP_CUR_DB;
+ }
}
void
kdp_snapshot_postflight(void)
{
kdp_snapshot--;
+ if ((kdp_en_send_pkt == NULL) || (old_debugger == KDB_CUR_DB))
+ current_debugger = old_debugger;
}
int
return stack_snapshot_bytes_traced;
}
+static void
+kdp_schedule_debugger_reentry(unsigned interval) {
+ uint64_t deadline;;
+
+ clock_interval_to_deadline(interval, 1000 * 1000, &deadline);
+ thread_call_enter_delayed(kdp_timer_call, deadline);
+}
+
static void
enaddr_copy(
void *src,
#else
ui = (struct udpiphdr *)&pkt.data[pkt.off];
#endif
- ui->ui_next = ui->ui_prev = 0;
+ ui->ui_next = ui->ui_prev = NULL;
ui->ui_x1 = 0;
ui->ui_pr = IPPROTO_UDP;
ui->ui_len = htons((u_short)pkt.len + sizeof (struct udphdr));
#else
ui = (struct udpiphdr *)&pkt.data[pkt.off];
#endif
- ui->ui_next = ui->ui_prev = 0;
+ ui->ui_next = ui->ui_prev = NULL;
ui->ui_x1 = 0;
ui->ui_pr = IPPROTO_UDP;
ui->ui_len = htons((u_short)pkt.len + sizeof (struct udphdr));
}
void *
-kdp_get_interface()
+kdp_get_interface(void)
{
return kdp_current_ifp;
}
{
kdp_current_ip_address = ipaddr->s_addr;
kdp_current_mac_address = *macaddr;
+ if ((current_debugger == KDP_CUR_DB) && halt_in_debugger) {
+ kdp_call();
+ halt_in_debugger=0;
+ }
}
void
printf("\nWaiting for remote debugger connection.\n");
+
if (reattach_wait == 0) {
if((kdp_flag & KDP_GETC_ENA) && (0 != kdp_getc()))
{
{
int index;
+ /* Was a system trace requested ? */
+ if (kdp_snapshot && (!panic_active()) && (panic_caller == 0)) {
+ stack_snapshot_ret = kdp_stackshot(stack_snapshot_pid,
+ stack_snapshot_buf, stack_snapshot_bufsize,
+ stack_snapshot_options, &stack_snapshot_bytes_traced);
+ return;
+ }
+
disable_preemption();
if (saved_state == 0)
* do this. I think the client and the host can get out of sync.
*/
kdp.saved_state = saved_state;
-
+ kdp.kdp_cpu = cpu_number();
+ kdp.kdp_thread = current_thread();
+
if (pkt.input)
kdp_panic("kdp_raise_exception");
- /* Was a system trace requested ? */
- if (kdp_snapshot && (panicstr == ((char *) 0)) && (panic_caller == 0) && !kdp.is_conn) {
- /* XXX This should be reworked to take a pointer to the buffer */
- stack_snapshot_ret = kdp_stackshot(stack_snapshot_pid,
- (uint32_t) stack_snapshot_buf, stack_snapshot_bufsize,
- stack_snapshot_options, &stack_snapshot_bytes_traced);
- goto exit_raise_exception;
- }
if (((kdp_flag & KDP_PANIC_DUMP_ENABLED) || (kdp_flag & PANIC_LOG_DUMP))
&& (panicstr != (char *) 0)) {
if ((kdp_flag & PANIC_CORE_ON_NMI) && (panicstr == (char *) 0) &&
!kdp.is_conn) {
- disableDebugOuput = disableConsoleOutput = FALSE;
+ disable_debug_output = disableConsoleOutput = FALSE;
kdp_panic_dump();
if (!(kdp_flag & DBG_POST_CORE))
kdp_flag &= ~PANIC_LOG_DUMP;
kdp_flag |= KDP_PANIC_DUMP_ENABLED;
kdp_panic_dump();
+ kdp_trigger_core_dump = 0;
}
/* Trigger a reboot if the user has set this flag through the
/* If we're still around, reset the flag */
flag_kdp_trigger_reboot = 0;
}
-
+
+ if (kdp_reentry_deadline) {
+ kdp_schedule_debugger_reentry(kdp_reentry_deadline);
+ printf("Debugger re-entry scheduled in %d milliseconds\n", kdp_reentry_deadline);
+ kdp_reentry_deadline = 0;
+ }
+
kdp_sync_cache();
if (reattach_wait == 1)
#else
ui = (struct udpiphdr *)&pkt.data[pkt.off];
#endif
- ui->ui_next = ui->ui_prev = 0;
+ ui->ui_next = ui->ui_prev = NULL;
ui->ui_x1 = 0;
ui->ui_pr = IPPROTO_UDP;
ui->ui_len = htons((u_short)pkt.len + sizeof (struct udphdr));
if (request == KDP_WRQ)
{
- register char *cp;
+ char *cp;
cp = coreh->th_u.tu_rpl;
- strcpy (cp, corename);
- cp += strlen(corename);
+ cp += strlcpy (cp, corename, KDP_MAXPACKET);
*cp++ = '\0';
- strcpy (cp, mode);
- cp+= modelen;
+ cp += strlcpy (cp, mode, KDP_MAXPACKET - strlen(corename));
*cp++ = '\0';
}
else
} while (strncmp(s, find, len) != 0);
s--;
}
- return ((char *)s);
+ return (s);
}
extern char version[];
static int
kdp_get_xnu_version(char *versionbuf)
{
-
char *versionpos;
char vstr[20];
int retval = -1;
char *vptr;
- strcpy(vstr, "custom");
- if (version) {
- if (kdp_vm_read(version, versionbuf, 95)) {
- versionbuf[94] = '\0';
- versionpos = strnstr(versionbuf, "xnu-", 90);
- if (versionpos) {
- strncpy(vstr, versionpos, sizeof(vstr));
- vstr[sizeof(vstr)-1] = '\0';
- vptr = vstr + 4; /* Begin after "xnu-" */
- while (*vptr && (isdigit(*vptr) || *vptr == '.'))
- vptr++;
+ strlcpy(vstr, "custom", 10);
+ if (strlcpy(versionbuf, version, 95) < 95) {
+ versionpos = strnstr(versionbuf, "xnu-", 90);
+ if (versionpos) {
+ strncpy(vstr, versionpos, sizeof(vstr));
+ vstr[sizeof(vstr)-1] = '\0';
+ vptr = vstr + 4; /* Begin after "xnu-" */
+ while (*vptr && (isdigit(*vptr) || *vptr == '.'))
+ vptr++;
+ *vptr = '\0';
+ /* Remove trailing period, if any */
+ if (*(--vptr) == '.')
*vptr = '\0';
- /* Remove trailing period, if any */
- if (*(--vptr) == '.')
- *vptr = '\0';
- retval = 0;
- }
+ retval = 0;
}
}
- strcpy(versionbuf, vstr);
+ strlcpy(versionbuf, vstr, KDP_MAXPACKET);
return retval;
}
extern char *inet_aton(const char *cp, struct in_addr *pin);
-extern int snprintf(char *str, size_t size, const char *format, ...);
/* Primary dispatch routine for the system dump */
void
-kdp_panic_dump()
+kdp_panic_dump(void)
{
char corename[50];
char coreprefix[10];
goto panic_dump_exit;
}
- if (current_ip == 0) {
- printf("System dump failed: An IP address isn't assigned to this machine.\n");
- return;
- }
-
flag_panic_dump_in_progress = TRUE;
not_in_kdp = 0;
not_in_kdp = 1;
panic_block = 0;
}
+
+#if CONFIG_SERIAL_KDP
+
+static boolean_t needs_serial_init = TRUE;
+
+static void
+kdp_serial_send(void *rpkt, unsigned int rpkt_len)
+{
+ if (needs_serial_init)
+ {
+ serial_init();
+ needs_serial_init = FALSE;
+ }
+
+ // printf("tx\n");
+ kdp_serialize_packet((unsigned char *)rpkt, rpkt_len, serial_putc);
+}
+
+static void
+kdp_serial_receive(void *rpkt, unsigned int *rpkt_len, unsigned int timeout)
+{
+ int readkar;
+ uint64_t now, deadline;
+
+ if (needs_serial_init)
+ {
+ serial_init();
+ needs_serial_init = FALSE;
+ }
+
+ clock_interval_to_deadline(timeout, 1000 * 1000 /* milliseconds */, &deadline);
+
+// printf("rx\n");
+ for(clock_get_uptime(&now); now < deadline; clock_get_uptime(&now))
+ {
+ readkar = serial_getc();
+ if(readkar >= 0)
+ {
+ unsigned char *packet;
+ // printf("got char %02x\n", readkar);
+ if((packet = kdp_unserialize_packet(readkar,rpkt_len)))
+ {
+ memcpy(rpkt, packet, *rpkt_len);
+ return;
+ }
+ }
+ }
+ *rpkt_len = 0;
+}
+
+static void kdp_serial_callout(__unused void *arg, kdp_event_t event)
+{
+ /* When we stop KDP, set the bit to re-initialize the console serial port
+ * the next time we send/receive a KDP packet. We don't do it on
+ * KDP_EVENT_ENTER directly because it also gets called when we trap to KDP
+ * for non-external debugging, i.e., stackshot or core dumps.
+ *
+ * Set needs_serial_init on exit (and initialization, see above) and not
+ * enter because enter is sent multiple times and causes excess reinitialization.
+ */
+
+ switch (event)
+ {
+ case KDP_EVENT_PANICLOG:
+ case KDP_EVENT_ENTER:
+ break;
+ case KDP_EVENT_EXIT:
+ needs_serial_init = TRUE;
+ break;
+ }
+}
+
+#endif /* CONFIG_SERIAL_KDP */
+
+void
+kdp_init(void)
+{
+#if CONFIG_SERIAL_KDP
+ char kdpname[80];
+ struct in_addr ipaddr;
+ struct ether_addr macaddr;
+
+#if CONFIG_EMBEDDED
+ //serial will be the debugger, unless match name is explicitly provided, and it's not "serial"
+ if(PE_parse_boot_argn("kdp_match_name", kdpname, sizeof(kdpname)) && strncmp(kdpname, "serial", sizeof(kdpname)) != 0)
+ return;
+#else
+ // serial must be explicitly requested
+ if(!PE_parse_boot_argn("kdp_match_name", kdpname, sizeof(kdpname)) || strncmp(kdpname, "serial", sizeof(kdpname)) != 0)
+ return;
+#endif
+
+ kprintf("Intializing serial KDP\n");
+
+ kdp_register_callout(kdp_serial_callout, NULL);
+ kdp_register_send_receive(kdp_serial_send, kdp_serial_receive);
+
+ /* fake up an ip and mac for early serial debugging */
+ macaddr.ether_addr_octet[0] = 's';
+ macaddr.ether_addr_octet[1] = 'e';
+ macaddr.ether_addr_octet[2] = 'r';
+ macaddr.ether_addr_octet[3] = 'i';
+ macaddr.ether_addr_octet[4] = 'a';
+ macaddr.ether_addr_octet[5] = 'l';
+ ipaddr.s_addr = 0xABADBABE;
+ kdp_set_ip_and_mac_addresses(&ipaddr, &macaddr);
+#endif /* CONFIG_SERIAL_KDP */
+}
projects / apple / xnu.git / blobdiff