[mirror_ubuntu-zesty-kernel.git] / arch / parisc / kernel / process.c

/*
 *    PARISC Architecture-dependent parts of process handling
 *    based on the work for i386
 *
 *    Copyright (C) 1999-2003 Matthew Wilcox <willy at parisc-linux.org>
 *    Copyright (C) 2000 Martin K Petersen <mkp at mkp.net>
 *    Copyright (C) 2000 John Marvin <jsm at parisc-linux.org>
 *    Copyright (C) 2000 David Huggins-Daines <dhd with pobox.org>
 *    Copyright (C) 2000-2003 Paul Bame <bame at parisc-linux.org>
 *    Copyright (C) 2000 Philipp Rumpf <prumpf with tux.org>
 *    Copyright (C) 2000 David Kennedy <dkennedy with linuxcare.com>
 *    Copyright (C) 2000 Richard Hirst <rhirst with parisc-linux.org>
 *    Copyright (C) 2000 Grant Grundler <grundler with parisc-linux.org>
 *    Copyright (C) 2001 Alan Modra <amodra at parisc-linux.org>
 *    Copyright (C) 2001-2002 Ryan Bradetich <rbrad at parisc-linux.org>
 *    Copyright (C) 2001-2002 Helge Deller <deller at parisc-linux.org>
 *    Copyright (C) 2002 Randolph Chung <tausq with parisc-linux.org>
 *
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <stdarg.h>

#include <linux/elf.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/personality.h>
#include <linux/ptrace.h>
#include <linux/sched.h>
#include <linux/stddef.h>
#include <linux/unistd.h>
#include <linux/kallsyms.h>

#include <asm/io.h>
#include <asm/asm-offsets.h>
#include <asm/pdc.h>
#include <asm/pdc_chassis.h>
#include <asm/pgalloc.h>
#include <asm/uaccess.h>
#include <asm/unwind.h>

/*
 * Power off function, if any
 */ 
void (*pm_power_off)(void);
EXPORT_SYMBOL(pm_power_off);

void default_idle(void)
{
	barrier();
}

/*
 * The idle thread. There's no useful work to be
 * done, so just try to conserve power and have a
 * low exit latency (ie sit in a loop waiting for
 * somebody to say that they'd like to reschedule)
 */
void cpu_idle(void)
{
	set_thread_flag(TIF_POLLING_NRFLAG);

	/* endless idle loop with no priority at all */
	while (1) {
		while (!need_resched())
			barrier();
		preempt_enable_no_resched();
		schedule();
		preempt_disable();
		check_pgt_cache();
	}
}


#define COMMAND_GLOBAL  F_EXTEND(0xfffe0030)
#define CMD_RESET       5       /* reset any module */

/*
** The Wright Brothers and Gecko systems have a H/W problem
** (Lasi...'nuf said) may cause a broadcast reset to lockup
** the system. An HVERSION dependent PDC call was developed
** to perform a "safe", platform specific broadcast reset instead
** of kludging up all the code.
**
** Older machines which do not implement PDC_BROADCAST_RESET will
** return (with an error) and the regular broadcast reset can be
** issued. Obviously, if the PDC does implement PDC_BROADCAST_RESET
** the PDC call will not return (the system will be reset).
*/
void machine_restart(char *cmd)
{
#ifdef FASTBOOT_SELFTEST_SUPPORT
	/*
	 ** If user has modified the Firmware Selftest Bitmap,
	 ** run the tests specified in the bitmap after the
	 ** system is rebooted w/PDC_DO_RESET.
	 **
	 ** ftc_bitmap = 0x1AUL "Skip destructive memory tests"
	 **
	 ** Using "directed resets" at each processor with the MEM_TOC
	 ** vector cleared will also avoid running destructive
	 ** memory self tests. (Not implemented yet)
	 */
	if (ftc_bitmap) {
		pdc_do_firm_test_reset(ftc_bitmap);
	}
#endif
	/* set up a new led state on systems shipped with a LED State panel */
	pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN);
	
	/* "Normal" system reset */
	pdc_do_reset();

	/* Nope...box should reset with just CMD_RESET now */
	gsc_writel(CMD_RESET, COMMAND_GLOBAL);

	/* Wait for RESET to lay us to rest. */
	while (1) ;

}

void machine_halt(void)
{
	/*
	** The LED/ChassisCodes are updated by the led_halt()
	** function, called by the reboot notifier chain.
	*/
}


/*
 * This routine is called from sys_reboot to actually turn off the
 * machine 
 */
void machine_power_off(void)
{
	/* If there is a registered power off handler, call it. */
	if(pm_power_off)
		pm_power_off();

	/* Put the soft power button back under hardware control.
	 * If the user had already pressed the power button, the
	 * following call will immediately power off. */
	pdc_soft_power_button(0);
	
	pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN);
		
	/* It seems we have no way to power the system off via
	 * software. The user has to press the button himself. */

	printk(KERN_EMERG "System shut down completed.\n"
	       KERN_EMERG "Please power this system off now.");
}


/*
 * Create a kernel thread
 */

extern pid_t __kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
{

	/*
	 * FIXME: Once we are sure we don't need any debug here,
	 *	  kernel_thread can become a #define.
	 */

	return __kernel_thread(fn, arg, flags);
}
EXPORT_SYMBOL(kernel_thread);

/*
 * Free current thread data structures etc..
 */
void exit_thread(void)
{
}

void flush_thread(void)
{
	/* Only needs to handle fpu stuff or perf monitors.
	** REVISIT: several arches implement a "lazy fpu state".
	*/
	set_fs(USER_DS);
}

void release_thread(struct task_struct *dead_task)
{
}

/*
 * Fill in the FPU structure for a core dump.
 */

int dump_fpu (struct pt_regs * regs, elf_fpregset_t *r)
{
	if (regs == NULL)
		return 0;

	memcpy(r, regs->fr, sizeof *r);
	return 1;
}

int dump_task_fpu (struct task_struct *tsk, elf_fpregset_t *r)
{
	memcpy(r, tsk->thread.regs.fr, sizeof(*r));
	return 1;
}

/* Note that "fork()" is implemented in terms of clone, with
   parameters (SIGCHLD, regs->gr[30], regs). */
int
sys_clone(unsigned long clone_flags, unsigned long usp,
	  struct pt_regs *regs)
{
  	/* Arugments from userspace are:
	   r26 = Clone flags.
	   r25 = Child stack.
	   r24 = parent_tidptr.
	   r23 = Is the TLS storage descriptor 
	   r22 = child_tidptr 
	   
	   However, these last 3 args are only examined
	   if the proper flags are set. */
	int __user *child_tidptr;
	int __user *parent_tidptr;

	/* usp must be word aligned.  This also prevents users from
	 * passing in the value 1 (which is the signal for a special
	 * return for a kernel thread) */
	usp = ALIGN(usp, 4);

	/* A zero value for usp means use the current stack */
	if (usp == 0)
	  usp = regs->gr[30];

	if (clone_flags & CLONE_PARENT_SETTID)
	  parent_tidptr = (int __user *)regs->gr[24];
	else
	  parent_tidptr = NULL;
	
	if (clone_flags & (CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID))
	  child_tidptr = (int __user *)regs->gr[22];
	else
	  child_tidptr = NULL;

	return do_fork(clone_flags, usp, regs, 0, parent_tidptr, child_tidptr);
}

int
sys_vfork(struct pt_regs *regs)
{
	return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, regs->gr[30], regs, 0, NULL, NULL);
}

int
copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
	    unsigned long unused,	/* in ia64 this is "user_stack_size" */
	    struct task_struct * p, struct pt_regs * pregs)
{
	struct pt_regs * cregs = &(p->thread.regs);
	void *stack = task_stack_page(p);
	
	/* We have to use void * instead of a function pointer, because
	 * function pointers aren't a pointer to the function on 64-bit.
	 * Make them const so the compiler knows they live in .text */
	extern void * const ret_from_kernel_thread;
	extern void * const child_return;
#ifdef CONFIG_HPUX
	extern void * const hpux_child_return;
#endif

	*cregs = *pregs;

	/* Set the return value for the child.  Note that this is not
           actually restored by the syscall exit path, but we put it
           here for consistency in case of signals. */
	cregs->gr[28] = 0; /* child */

	/*
	 * We need to differentiate between a user fork and a
	 * kernel fork. We can't use user_mode, because the
	 * the syscall path doesn't save iaoq. Right now
	 * We rely on the fact that kernel_thread passes
	 * in zero for usp.
	 */
	if (usp == 1) {
		/* kernel thread */
		cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN;
		/* Must exit via ret_from_kernel_thread in order
		 * to call schedule_tail()
		 */
		cregs->kpc = (unsigned long) &ret_from_kernel_thread;
		/*
		 * Copy function and argument to be called from
		 * ret_from_kernel_thread.
		 */
#ifdef __LP64__
		cregs->gr[27] = pregs->gr[27];
#endif
		cregs->gr[26] = pregs->gr[26];
		cregs->gr[25] = pregs->gr[25];
	} else {
		/* user thread */
		/*
		 * Note that the fork wrappers are responsible
		 * for setting gr[21].
		 */

		/* Use same stack depth as parent */
		cregs->ksp = (unsigned long)stack
			+ (pregs->gr[21] & (THREAD_SIZE - 1));
		cregs->gr[30] = usp;
		if (p->personality == PER_HPUX) {
#ifdef CONFIG_HPUX
			cregs->kpc = (unsigned long) &hpux_child_return;
#else
			BUG();
#endif
		} else {
			cregs->kpc = (unsigned long) &child_return;
		}
		/* Setup thread TLS area from the 4th parameter in clone */
		if (clone_flags & CLONE_SETTLS)
		  cregs->cr27 = pregs->gr[23];
	
	}

	return 0;
}

unsigned long thread_saved_pc(struct task_struct *t)
{
	return t->thread.regs.kpc;
}

/*
 * sys_execve() executes a new program.
 */

asmlinkage int sys_execve(struct pt_regs *regs)
{
	int error;
	char *filename;

	filename = getname((const char __user *) regs->gr[26]);
	error = PTR_ERR(filename);
	if (IS_ERR(filename))
		goto out;
	error = do_execve(filename, (char __user **) regs->gr[25],
		(char __user **) regs->gr[24], regs);
	if (error == 0) {
		task_lock(current);
		current->ptrace &= ~PT_DTRACE;
		task_unlock(current);
	}
	putname(filename);
out:

	return error;
}

unsigned long 
get_wchan(struct task_struct *p)
{
	struct unwind_frame_info info;
	unsigned long ip;
	int count = 0;
	/*
	 * These bracket the sleeping functions..
	 */

	unwind_frame_init_from_blocked_task(&info, p);
	do {
		if (unwind_once(&info) < 0)
			return 0;
		ip = info.ip;
		if (!in_sched_functions(ip))
			return ip;
	} while (count++ < 16);
	return 0;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* PARISC Architecture-dependent parts of process handling
	3	* based on the work for i386
	4	*
	5	* Copyright (C) 1999-2003 Matthew Wilcox <willy at parisc-linux.org>
	6	* Copyright (C) 2000 Martin K Petersen <mkp at mkp.net>
	7	* Copyright (C) 2000 John Marvin <jsm at parisc-linux.org>
	8	* Copyright (C) 2000 David Huggins-Daines <dhd with pobox.org>
	9	* Copyright (C) 2000-2003 Paul Bame <bame at parisc-linux.org>
	10	* Copyright (C) 2000 Philipp Rumpf <prumpf with tux.org>
	11	* Copyright (C) 2000 David Kennedy <dkennedy with linuxcare.com>
b2450cc1	12	* Copyright (C) 2000 Richard Hirst <rhirst with parisc-linux.org>
1da177e4 LT	13	* Copyright (C) 2000 Grant Grundler <grundler with parisc-linux.org>
	14	* Copyright (C) 2001 Alan Modra <amodra at parisc-linux.org>
	15	* Copyright (C) 2001-2002 Ryan Bradetich <rbrad at parisc-linux.org>
	16	* Copyright (C) 2001-2002 Helge Deller <deller at parisc-linux.org>
	17	* Copyright (C) 2002 Randolph Chung <tausq with parisc-linux.org>
	18	*
	19	*
	20	* This program is free software; you can redistribute it and/or modify
	21	* it under the terms of the GNU General Public License as published by
	22	* the Free Software Foundation; either version 2 of the License, or
	23	* (at your option) any later version.
	24	*
	25	* This program is distributed in the hope that it will be useful,
	26	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	27	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	28	* GNU General Public License for more details.
	29	*
	30	* You should have received a copy of the GNU General Public License
	31	* along with this program; if not, write to the Free Software
	32	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	33	*/
	34
	35	#include <stdarg.h>
	36
	37	#include <linux/elf.h>
	38	#include <linux/errno.h>
	39	#include <linux/kernel.h>
	40	#include <linux/mm.h>
	41	#include <linux/module.h>
	42	#include <linux/personality.h>
	43	#include <linux/ptrace.h>
	44	#include <linux/sched.h>
	45	#include <linux/stddef.h>
	46	#include <linux/unistd.h>
	47	#include <linux/kallsyms.h>
	48
	49	#include <asm/io.h>
0013a854	50	#include <asm/asm-offsets.h>
1da177e4 LT	51	#include <asm/pdc.h>
	52	#include <asm/pdc_chassis.h>
	53	#include <asm/pgalloc.h>
	54	#include <asm/uaccess.h>
	55	#include <asm/unwind.h>
	56
1da177e4 LT	57	/*
	58	* Power off function, if any
	59	*/
	60	void (*pm_power_off)(void);
9073315b	61	EXPORT_SYMBOL(pm_power_off);
1da177e4	62
1da177e4 LT	63	void default_idle(void)
	64	{
	65	barrier();
	66	}
	67
	68	/*
	69	* The idle thread. There's no useful work to be
	70	* done, so just try to conserve power and have a
	71	* low exit latency (ie sit in a loop waiting for
	72	* somebody to say that they'd like to reschedule)
	73	*/
	74	void cpu_idle(void)
	75	{
64c7c8f8 NP	76	set_thread_flag(TIF_POLLING_NRFLAG);
64c7c8f8 NP	77
1da177e4 LT	78	/* endless idle loop with no priority at all */
	79	while (1) {
	80	while (!need_resched())
	81	barrier();
5bfb5d69	82	preempt_enable_no_resched();
1da177e4	83	schedule();
5bfb5d69	84	preempt_disable();
1da177e4 LT	85	check_pgt_cache();
	86	}
	87	}
	88
	89
10992092	90	#define COMMAND_GLOBAL F_EXTEND(0xfffe0030)
1da177e4 LT	91	#define CMD_RESET 5 /* reset any module */
	92
	93	/*
	94	** The Wright Brothers and Gecko systems have a H/W problem
	95	** (Lasi...'nuf said) may cause a broadcast reset to lockup
	96	** the system. An HVERSION dependent PDC call was developed
	97	** to perform a "safe", platform specific broadcast reset instead
	98	** of kludging up all the code.
	99	**
	100	** Older machines which do not implement PDC_BROADCAST_RESET will
	101	** return (with an error) and the regular broadcast reset can be
	102	** issued. Obviously, if the PDC does implement PDC_BROADCAST_RESET
	103	** the PDC call will not return (the system will be reset).
	104	*/
	105	void machine_restart(char *cmd)
	106	{
	107	#ifdef FASTBOOT_SELFTEST_SUPPORT
	108	/*
	109	** If user has modified the Firmware Selftest Bitmap,
	110	** run the tests specified in the bitmap after the
	111	** system is rebooted w/PDC_DO_RESET.
	112	**
	113	** ftc_bitmap = 0x1AUL "Skip destructive memory tests"
	114	**
	115	** Using "directed resets" at each processor with the MEM_TOC
	116	** vector cleared will also avoid running destructive
	117	** memory self tests. (Not implemented yet)
	118	*/
	119	if (ftc_bitmap) {
	120	pdc_do_firm_test_reset(ftc_bitmap);
	121	}
	122	#endif
	123	/* set up a new led state on systems shipped with a LED State panel */
	124	pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN);
	125
	126	/* "Normal" system reset */
	127	pdc_do_reset();
	128
	129	/* Nope...box should reset with just CMD_RESET now */
	130	gsc_writel(CMD_RESET, COMMAND_GLOBAL);
	131
	132	/* Wait for RESET to lay us to rest. */
	133	while (1) ;
	134
	135	}
	136
1da177e4 LT	137	void machine_halt(void)
	138	{
	139	/*
	140	** The LED/ChassisCodes are updated by the led_halt()
	141	** function, called by the reboot notifier chain.
	142	*/
	143	}
	144
1da177e4 LT	145
	146	/*
	147	* This routine is called from sys_reboot to actually turn off the
	148	* machine
	149	*/
	150	void machine_power_off(void)
	151	{
	152	/* If there is a registered power off handler, call it. */
	153	if(pm_power_off)
	154	pm_power_off();
	155
	156	/* Put the soft power button back under hardware control.
	157	* If the user had already pressed the power button, the
	158	* following call will immediately power off. */
	159	pdc_soft_power_button(0);
	160
	161	pdc_chassis_send_status(PDC_CHASSIS_DIRECT_SHUTDOWN);
	162
	163	/* It seems we have no way to power the system off via
	164	* software. The user has to press the button himself. */
	165
	166	printk(KERN_EMERG "System shut down completed.\n"
	167	KERN_EMERG "Please power this system off now.");
	168	}
	169
1da177e4 LT	170
	171	/*
	172	* Create a kernel thread
	173	*/
	174
	175	extern pid_t __kernel_thread(int (fn)(void ), void *arg, unsigned long flags);
	176	pid_t kernel_thread(int (fn)(void ), void *arg, unsigned long flags)
	177	{
	178
	179	/*
	180	* FIXME: Once we are sure we don't need any debug here,
	181	* kernel_thread can become a #define.
	182	*/
	183
	184	return __kernel_thread(fn, arg, flags);
	185	}
	186	EXPORT_SYMBOL(kernel_thread);
	187
	188	/*
	189	* Free current thread data structures etc..
	190	*/
	191	void exit_thread(void)
	192	{
	193	}
	194
	195	void flush_thread(void)
	196	{
	197	/* Only needs to handle fpu stuff or perf monitors.
	198	** REVISIT: several arches implement a "lazy fpu state".
	199	*/
	200	set_fs(USER_DS);
	201	}
	202
	203	void release_thread(struct task_struct *dead_task)
	204	{
	205	}
	206
	207	/*
	208	* Fill in the FPU structure for a core dump.
	209	*/
	210
	211	int dump_fpu (struct pt_regs * regs, elf_fpregset_t *r)
	212	{
	213	if (regs == NULL)
	214	return 0;
	215
	216	memcpy(r, regs->fr, sizeof *r);
	217	return 1;
	218	}
	219
	220	int dump_task_fpu (struct task_struct tsk, elf_fpregset_t r)
	221	{
	222	memcpy(r, tsk->thread.regs.fr, sizeof(*r));
	223	return 1;
	224	}
	225
	226	/* Note that "fork()" is implemented in terms of clone, with
	227	parameters (SIGCHLD, regs->gr[30], regs). */
	228	int
	229	sys_clone(unsigned long clone_flags, unsigned long usp,
	230	struct pt_regs *regs)
	231	{
b2450cc1 CD	232	/* Arugments from userspace are:
	233	r26 = Clone flags.
	234	r25 = Child stack.
	235	r24 = parent_tidptr.
	236	r23 = Is the TLS storage descriptor
	237	r22 = child_tidptr
	238
	239	However, these last 3 args are only examined
	240	if the proper flags are set. */
	241	int __user *child_tidptr;
	242	int __user *parent_tidptr;
1da177e4 LT	243
	244	/* usp must be word aligned. This also prevents users from
	245	* passing in the value 1 (which is the signal for a special
	246	* return for a kernel thread) */
	247	usp = ALIGN(usp, 4);
	248
	249	/* A zero value for usp means use the current stack */
b2450cc1 CD	250	if (usp == 0)
b2450cc1 CD	251	usp = regs->gr[30];
1da177e4	252
b2450cc1 CD	253	if (clone_flags & CLONE_PARENT_SETTID)
	254	parent_tidptr = (int __user *)regs->gr[24];
	255	else
	256	parent_tidptr = NULL;
	257
	258	if (clone_flags & (CLONE_CHILD_SETTID \| CLONE_CHILD_CLEARTID))
	259	child_tidptr = (int __user *)regs->gr[22];
	260	else
	261	child_tidptr = NULL;
	262
	263	return do_fork(clone_flags, usp, regs, 0, parent_tidptr, child_tidptr);
1da177e4 LT	264	}
	265
	266	int
	267	sys_vfork(struct pt_regs *regs)
	268	{
	269	return do_fork(CLONE_VFORK \| CLONE_VM \| SIGCHLD, regs->gr[30], regs, 0, NULL, NULL);
	270	}
	271
	272	int
	273	copy_thread(int nr, unsigned long clone_flags, unsigned long usp,
	274	unsigned long unused, /* in ia64 this is "user_stack_size" */
	275	struct task_struct * p, struct pt_regs * pregs)
	276	{
	277	struct pt_regs * cregs = &(p->thread.regs);
40f1f0de	278	void *stack = task_stack_page(p);
1da177e4 LT	279
	280	/* We have to use void * instead of a function pointer, because
	281	* function pointers aren't a pointer to the function on 64-bit.
	282	* Make them const so the compiler knows they live in .text */
	283	extern void * const ret_from_kernel_thread;
	284	extern void * const child_return;
	285	#ifdef CONFIG_HPUX
	286	extern void * const hpux_child_return;
	287	#endif
	288
	289	cregs = pregs;
	290
	291	/* Set the return value for the child. Note that this is not
	292	actually restored by the syscall exit path, but we put it
	293	here for consistency in case of signals. */
	294	cregs->gr[28] = 0; /* child */
	295
	296	/*
	297	* We need to differentiate between a user fork and a
	298	* kernel fork. We can't use user_mode, because the
	299	* the syscall path doesn't save iaoq. Right now
	300	* We rely on the fact that kernel_thread passes
	301	* in zero for usp.
	302	*/
	303	if (usp == 1) {
	304	/* kernel thread */
40f1f0de	305	cregs->ksp = (unsigned long)stack + THREAD_SZ_ALGN;
1da177e4 LT	306	/* Must exit via ret_from_kernel_thread in order
	307	* to call schedule_tail()
	308	*/
	309	cregs->kpc = (unsigned long) &ret_from_kernel_thread;
	310	/*
	311	* Copy function and argument to be called from
	312	* ret_from_kernel_thread.
	313	*/
	314	#ifdef __LP64__
	315	cregs->gr[27] = pregs->gr[27];
	316	#endif
	317	cregs->gr[26] = pregs->gr[26];
	318	cregs->gr[25] = pregs->gr[25];
	319	} else {
	320	/* user thread */
	321	/*
	322	* Note that the fork wrappers are responsible
	323	* for setting gr[21].
	324	*/
	325
	326	/* Use same stack depth as parent */
40f1f0de	327	cregs->ksp = (unsigned long)stack
1da177e4 LT	328	+ (pregs->gr[21] & (THREAD_SIZE - 1));
	329	cregs->gr[30] = usp;
	330	if (p->personality == PER_HPUX) {
	331	#ifdef CONFIG_HPUX
	332	cregs->kpc = (unsigned long) &hpux_child_return;
	333	#else
	334	BUG();
	335	#endif
	336	} else {
	337	cregs->kpc = (unsigned long) &child_return;
	338	}
b2450cc1 CD	339	/* Setup thread TLS area from the 4th parameter in clone */
	340	if (clone_flags & CLONE_SETTLS)
	341	cregs->cr27 = pregs->gr[23];
	342
1da177e4 LT	343	}
	344
	345	return 0;
	346	}
	347
	348	unsigned long thread_saved_pc(struct task_struct *t)
	349	{
	350	return t->thread.regs.kpc;
	351	}
	352
	353	/*
	354	* sys_execve() executes a new program.
	355	*/
	356
	357	asmlinkage int sys_execve(struct pt_regs *regs)
	358	{
	359	int error;
	360	char *filename;
	361
	362	filename = getname((const char __user *) regs->gr[26]);
	363	error = PTR_ERR(filename);
	364	if (IS_ERR(filename))
	365	goto out;
	366	error = do_execve(filename, (char __user **) regs->gr[25],
	367	(char __user **) regs->gr[24], regs);
	368	if (error == 0) {
	369	task_lock(current);
	370	current->ptrace &= ~PT_DTRACE;
	371	task_unlock(current);
	372	}
	373	putname(filename);
	374	out:
	375
	376	return error;
	377	}
	378
	379	unsigned long
	380	get_wchan(struct task_struct *p)
	381	{
	382	struct unwind_frame_info info;
	383	unsigned long ip;
	384	int count = 0;
	385	/*
	386	* These bracket the sleeping functions..
	387	*/
	388
	389	unwind_frame_init_from_blocked_task(&info, p);
	390	do {
	391	if (unwind_once(&info) < 0)
	392	return 0;
	393	ip = info.ip;
	394	if (!in_sched_functions(ip))
	395	return ip;
	396	} while (count++ < 16);
	397	return 0;
	398	}