 return(current->thread.prev_sched); 
void *switch_to_tt(void *prev, void *next, void *last){	struct task_struct *from, *to, *prev_sched;	unsigned long flags;	int err, vtalrm, alrm, prof, cpu;	char c;	from = prev;	to = next;	to->thread.prev_sched = from;	cpu = from->thread_info->cpu;	if(cpu == 0)		forward_interrupts(to->thread.mode.tt.extern_pid);#ifdef CONFIG_SMP	forward_ipi(cpu_data[cpu].ipi_pipe[0], to->thread.mode.tt.extern_pid);#endif	local_irq_save(flags);	vtalrm = change_sig(SIGVTALRM, 0);	alrm = change_sig(SIGALRM, 0);	prof = change_sig(SIGPROF, 0);	forward_pending_sigio(to->thread.mode.tt.extern_pid);	c = 0;	set_current(to);	err = os_write_file(to->thread.mode.tt.switch_pipe[1], &c, sizeof(c));	if(err != sizeof(c))		panic("write of switch_pipe failed, err = %d", -err);	if(from->thread.mode.tt.switch_pipe[0] == -1)		os_kill_process(os_getpid(), 0);	err = os_read_file(from->thread.mode.tt.switch_pipe[0], &c, sizeof(c));	if(err != sizeof(c))		panic("read of switch_pipe failed, errno = %d", -err);	/* If the process that we have just scheduled away from has exited,	 * then it needs to be killed here.  The reason is that, even though	 * it will kill itself when it next runs, that may be too late.  Its	 * stack will be freed, possibly before then, and if that happens,	 * we have a use-after-free situation.  So, it gets killed here	 * in case it has not already killed itself.	 */	prev_sched = current->thread.prev_sched;        if(prev_sched->thread.mode.tt.switch_pipe[0] == -1)		os_kill_process(prev_sched->thread.mode.tt.extern_pid, 1);	change_sig(SIGVTALRM, vtalrm);	change_sig(SIGALRM, alrm);	change_sig(SIGPROF, prof);	arch_switch();	flush_tlb_all();	local_irq_restore(flags);	return(current->thread.prev_sched);}
10457	/local/tlutelli/issta_data/temp/c/2005_temp/2005/10457/f6e34c6af6f18bd6c66bfb1c6a7c57068412aa73/process_kern.c/clean/arch/um/kernel/tt/process_kern.c