void start(unsigned long a1, unsigned long a2, void *promptr, void *sp)
{
kernel_entry_t kentry;
char cmdline[COMMAND_LINE_SIZE];
unsigned long ft_addr = 0;
memset(__bss_start, 0, _end - __bss_start);
memset(&platform_ops, 0, sizeof(platform_ops));
memset(&dt_ops, 0, sizeof(dt_ops));
memset(&console_ops, 0, sizeof(console_ops));
if (platform_init(promptr, _dtb_start, _dtb_end))
exit();
if (console_ops.open && (console_ops.open() < 0))
exit();
if (platform_ops.fixups)
platform_ops.fixups();
printf("\n\rzImage starting: loaded at 0x%p (sp: 0x%p)\n\r",
_start, sp);
prep_kernel(a1, a2);
/* If cmdline came from zimage wrapper or if we can edit the one
* in the dt, print it out and edit it, if possible.
*/
if ((strlen(builtin_cmdline) > 0) || console_ops.edit_cmdline) {
get_cmdline(cmdline, COMMAND_LINE_SIZE);
printf("\n\rLinux/PowerPC load: %s", cmdline);
if (console_ops.edit_cmdline)
console_ops.edit_cmdline(cmdline, COMMAND_LINE_SIZE);
printf("\n\r");
set_cmdline(cmdline);
}
printf("Finalizing device tree...");
if (dt_ops.finalize)
ft_addr = dt_ops.finalize();
if (ft_addr)
printf(" flat tree at 0x%lx\n\r", ft_addr);
else
printf(" using OF tree (promptr=%p)\n\r", promptr);
if (console_ops.close)
console_ops.close();
kentry = (kernel_entry_t) vmlinux.addr;
if (ft_addr)
kentry(ft_addr, 0, NULL);
else
/* XXX initrd addr/size should be passed in properties */
kentry(initrd.addr, initrd.size, promptr);
/* console closed so printf below may not work */
printf("Error: Linux kernel returned to zImage boot wrapper!\n\r");
exit();
}
ulg
decompress_kernel(ulg output_start, ulg free_mem_ptr_p, ulg free_mem_ptr_end_p)
{
output_data = (uch *) output_start;
free_mem_ptr = free_mem_ptr_p;
free_mem_ptr_end = free_mem_ptr_end_p;
disable_watchdog();
arch_decomp_setup();
/* initialize clock */
HAL_CLOCK_INITIALIZE(RTC_PERIOD);
printf("MicroRedBoot v1.4, (c) 2009 DD-WRT.COM (%s REVISION %s)\n", __DATE__,SVN_REVISION);
printf("keep the reset button pushed to enter redboot!\n");
printf("CPU Type: Atheros AR%s\n",get_system_type());
printf("CPU Clock: %dMhz\n", cpu_frequency() / 1000000);
nvram_init();
char *ddboard = nvram_get("DD_BOARD");
if (ddboard)
printf("Board: %s\n", ddboard);
char *resetbutton = nvram_get("resetbutton_enable");
if (resetbutton && !strcmp(resetbutton, "0"))
puts("reset button manual override detected! (nvram var resetbutton_enable=0)\n");
if (resetTouched() || (resetbutton && !strcmp(resetbutton, "0"))) {
puts("Reset Button triggered\nBooting Recovery RedBoot\n");
int count = 5;
while (count--) {
if (!resetTouched()) // check if reset button is unpressed again
break;
udelay(1000000);
}
if (count <= 0) {
puts("reset button 5 seconds pushed, erasing nvram\n");
if (!flashdetect())
flash_erase_nvram(flashsize, NVRAM_SPACE);
}
bootoffset = 0x800004bc;
resettrigger = 0;
puts("loading");
lzma_unzip();
puts("\n\n\n");
return output_ptr;
} else {
flashdetect();
linuxaddr = getLinux();
puts("Booting Linux\n");
resettrigger = 1;
/* important, enable ethernet bus, if the following lines are not initialized linux will not be able to use the ethernet mac, taken from redboot source */
enable_ethernet();
puts("loading");
lzma_unzip();
set_cmdline();
}
}
static int execve1(char *file, char **argv, char **env)
{
int error;
error = do_execve(file, argv, env, ¤t->thread.regs);
if (error == 0){
current->ptrace &= ~PT_DTRACE;
set_cmdline(current_cmd());
}
return(error);
}
static int signal_tramp(void *arg)
{
int (*proc)(void *);
if(honeypot && munmap((void *) (host_task_size - 0x10000000),
0x10000000))
panic("Unmapping stack failed");
if(ptrace(PTRACE_TRACEME, 0, 0, 0) < 0)
panic("ptrace PTRACE_TRACEME failed");
os_stop_process(os_getpid());
change_sig(SIGWINCH, 0);
signal(SIGUSR1, SIG_IGN);
change_sig(SIGCHLD, 0);
signal(SIGSEGV, (__sighandler_t) sig_handler);
set_cmdline("(idle thread)");
set_init_pid(os_getpid());
proc = arg;
return((*proc)(NULL));
}
static void new_thread_handler(int sig)
{
unsigned long disable;
int (*fn)(void *);
void *arg;
fn = current->thread.request.u.thread.proc;
arg = current->thread.request.u.thread.arg;
UPT_SC(¤t->thread.regs.regs) = (void *) (&sig + 1);
disable = (1 << (SIGVTALRM - 1)) | (1 << (SIGALRM - 1)) |
(1 << (SIGIO - 1)) | (1 << (SIGPROF - 1));
SC_SIGMASK(UPT_SC(¤t->thread.regs.regs)) &= ~disable;
suspend_new_thread(current->thread.mode.tt.switch_pipe[0]);
force_flush_all();
if(current->thread.prev_sched != NULL)
schedule_tail(current->thread.prev_sched);
current->thread.prev_sched = NULL;
init_new_thread_signals(1);
enable_timer();
free_page(current->thread.temp_stack);
set_cmdline("(kernel thread)");
change_sig(SIGUSR1, 1);
change_sig(SIGVTALRM, 1);
change_sig(SIGPROF, 1);
local_irq_enable();
if(!run_kernel_thread(fn, arg, ¤t->thread.exec_buf))
do_exit(0);
/* XXX No set_user_mode here because a newly execed process will
* immediately segfault on its non-existent IP, coming straight back
* to the signal handler, which will call set_user_mode on its way
* out. This should probably change since it's confusing.
*/
}
int tracer(int (*init_proc)(void *), void *sp)
{
void *task = NULL;
unsigned long eip = 0;
int status, pid = 0, sig = 0, cont_type, tracing = 0, op = 0;
int last_index, proc_id = 0, n, err, old_tracing = 0, strace = 0;
capture_signal_stack();
signal(SIGPIPE, SIG_IGN);
setup_tracer_winch();
tracing_pid = os_getpid();
printf("tracing thread pid = %d\n", tracing_pid);
pid = clone(signal_tramp, sp, CLONE_FILES | SIGCHLD, init_proc);
CATCH_EINTR(n = waitpid(pid, &status, WUNTRACED));
if(n < 0){
printf("waitpid on idle thread failed, errno = %d\n", errno);
exit(1);
}
if((ptrace(PTRACE_CONT, pid, 0, 0) < 0)){
printf("Failed to continue idle thread, errno = %d\n", errno);
exit(1);
}
signal(SIGSEGV, (sighandler_t) tracer_segv);
signal(SIGUSR1, signal_usr1);
if(debug_trace){
printf("Tracing thread pausing to be attached\n");
stop();
}
if(debug){
if(gdb_pid != -1)
debugger_pid = attach_debugger(pid, gdb_pid, 1);
else debugger_pid = init_ptrace_proxy(pid, 1, debug_stop);
if(debug_parent){
debugger_parent = os_process_parent(debugger_pid);
init_parent_proxy(debugger_parent);
err = attach(debugger_parent);
if(err){
printf("Failed to attach debugger parent %d, "
"errno = %d\n", debugger_parent, -err);
debugger_parent = -1;
}
else {
if(ptrace(PTRACE_SYSCALL, debugger_parent,
0, 0) < 0){
printf("Failed to continue debugger "
"parent, errno = %d\n", errno);
debugger_parent = -1;
}
}
}
}
set_cmdline("(tracing thread)");
while(1){
CATCH_EINTR(pid = waitpid(-1, &status, WUNTRACED));
if(pid <= 0){
if(errno != ECHILD){
printf("wait failed - errno = %d\n", errno);
}
continue;
}
if(pid == debugger_pid){
int cont = 0;
if(WIFEXITED(status) || WIFSIGNALED(status))
debugger_pid = -1;
/* XXX Figure out how to deal with gdb and SMP */
else cont = debugger_signal(status, cpu_tasks[0].pid);
if(cont == PTRACE_SYSCALL) strace = 1;
continue;
}
else if(pid == debugger_parent){
debugger_parent_signal(status, pid);
continue;
}
nsignals++;
if(WIFEXITED(status)) ;
#ifdef notdef
{
printf("Child %d exited with status %d\n", pid,
WEXITSTATUS(status));
}
#endif
else if(WIFSIGNALED(status)){
sig = WTERMSIG(status);
if(sig != 9){
printf("Child %d exited with signal %d\n", pid,
sig);
}
}
else if(WIFSTOPPED(status)){
proc_id = pid_to_processor_id(pid);
sig = WSTOPSIG(status);
if(signal_index[proc_id] == 1024){
signal_index[proc_id] = 0;
last_index = 1023;
}
else last_index = signal_index[proc_id] - 1;
if(((sig == SIGPROF) || (sig == SIGVTALRM) ||
(sig == SIGALRM)) &&
(signal_record[proc_id][last_index].signal == sig)&&
(signal_record[proc_id][last_index].pid == pid))
signal_index[proc_id] = last_index;
signal_record[proc_id][signal_index[proc_id]].pid = pid;
gettimeofday(&signal_record[proc_id][signal_index[proc_id]].time, NULL);
eip = ptrace(PTRACE_PEEKUSER, pid, PT_IP_OFFSET, 0);
signal_record[proc_id][signal_index[proc_id]].addr = eip;
signal_record[proc_id][signal_index[proc_id]++].signal = sig;
if(proc_id == -1){
sleeping_process_signal(pid, sig);
continue;
}
task = cpu_tasks[proc_id].task;
tracing = is_tracing(task);
old_tracing = tracing;
switch(sig){
case SIGUSR1:
sig = 0;
op = do_proc_op(task, proc_id);
switch(op){
case OP_TRACE_ON:
arch_leave_kernel(task, pid);
tracing = 1;
break;
case OP_REBOOT:
case OP_HALT:
unmap_physmem();
kmalloc_ok = 0;
ptrace(PTRACE_KILL, pid, 0, 0);
return(op == OP_REBOOT);
case OP_NONE:
printf("Detaching pid %d\n", pid);
detach(pid, SIGSTOP);
continue;
default:
break;
}
/* OP_EXEC switches host processes on us,
* we want to continue the new one.
*/
pid = cpu_tasks[proc_id].pid;
break;
case SIGTRAP:
if(!tracing && (debugger_pid != -1)){
child_signal(pid, status);
continue;
}
tracing = 0;
if(do_syscall(task, pid))
sig = SIGUSR2;
else clear_singlestep(task);
break;
case SIGPROF:
if(tracing) sig = 0;
break;
case SIGCHLD:
case SIGHUP:
sig = 0;
break;
case SIGSEGV:
case SIGIO:
case SIGALRM:
case SIGVTALRM:
case SIGFPE:
case SIGBUS:
case SIGILL:
case SIGWINCH:
default:
tracing = 0;
break;
}
set_tracing(task, tracing);
if(!tracing && old_tracing)
arch_enter_kernel(task, pid);
if(!tracing && (debugger_pid != -1) && (sig != 0) &&
(sig != SIGALRM) && (sig != SIGVTALRM) &&
(sig != SIGSEGV) && (sig != SIGTRAP) &&
(sig != SIGUSR2) && (sig != SIGIO) &&
(sig != SIGFPE)){
child_signal(pid, status);
continue;
}
if(tracing){
if(singlestepping_tt(task))
cont_type = PTRACE_SINGLESTEP;
else cont_type = PTRACE_SYSCALL;
}
else cont_type = PTRACE_CONT;
if((cont_type == PTRACE_CONT) &&
(debugger_pid != -1) && strace)
cont_type = PTRACE_SYSCALL;
if(ptrace(cont_type, pid, 0, sig) != 0){
tracer_panic("ptrace failed to continue "
"process - errno = %d\n",
errno);
}
}
}