2006-09-27 08:50:40 +00:00
|
|
|
/*
|
2005-04-16 22:20:36 +00:00
|
|
|
* Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
|
|
|
|
* Copyright 2003 PathScale, Inc.
|
|
|
|
* Licensed under the GPL
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "linux/kernel.h"
|
|
|
|
#include "linux/sched.h"
|
|
|
|
#include "linux/interrupt.h"
|
2005-06-23 07:09:04 +00:00
|
|
|
#include "linux/string.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "linux/mm.h"
|
|
|
|
#include "linux/slab.h"
|
|
|
|
#include "linux/utsname.h"
|
|
|
|
#include "linux/fs.h"
|
|
|
|
#include "linux/utime.h"
|
|
|
|
#include "linux/smp_lock.h"
|
|
|
|
#include "linux/module.h"
|
|
|
|
#include "linux/init.h"
|
|
|
|
#include "linux/capability.h"
|
|
|
|
#include "linux/vmalloc.h"
|
|
|
|
#include "linux/spinlock.h"
|
|
|
|
#include "linux/proc_fs.h"
|
|
|
|
#include "linux/ptrace.h"
|
|
|
|
#include "linux/random.h"
|
2006-09-26 06:33:01 +00:00
|
|
|
#include "linux/personality.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "asm/unistd.h"
|
|
|
|
#include "asm/mman.h"
|
|
|
|
#include "asm/segment.h"
|
|
|
|
#include "asm/stat.h"
|
|
|
|
#include "asm/pgtable.h"
|
|
|
|
#include "asm/processor.h"
|
|
|
|
#include "asm/tlbflush.h"
|
|
|
|
#include "asm/uaccess.h"
|
|
|
|
#include "asm/user.h"
|
|
|
|
#include "kern_util.h"
|
2007-05-06 21:51:08 +00:00
|
|
|
#include "as-layout.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
#include "kern.h"
|
|
|
|
#include "signal_kern.h"
|
|
|
|
#include "init.h"
|
|
|
|
#include "irq_user.h"
|
|
|
|
#include "mem_user.h"
|
|
|
|
#include "tlb.h"
|
|
|
|
#include "frame_kern.h"
|
|
|
|
#include "sigcontext.h"
|
|
|
|
#include "os.h"
|
|
|
|
#include "mode.h"
|
|
|
|
#include "mode_kern.h"
|
|
|
|
#include "choose-mode.h"
|
2006-10-20 06:28:20 +00:00
|
|
|
#include "um_malloc.h"
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* This is a per-cpu array. A processor only modifies its entry and it only
|
|
|
|
* cares about its entry, so it's OK if another processor is modifying its
|
|
|
|
* entry.
|
|
|
|
*/
|
|
|
|
struct cpu_task cpu_tasks[NR_CPUS] = { [0 ... NR_CPUS - 1] = { -1, NULL } };
|
|
|
|
|
2007-05-06 21:51:21 +00:00
|
|
|
static inline int external_pid(struct task_struct *task)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-05-06 21:51:21 +00:00
|
|
|
return CHOOSE_MODE_PROC(external_pid_tt, external_pid_skas, task);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int pid_to_processor_id(int pid)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for(i = 0; i < ncpus; i++){
|
2007-05-06 21:51:21 +00:00
|
|
|
if(cpu_tasks[i].pid == pid)
|
|
|
|
return i;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-05-06 21:51:21 +00:00
|
|
|
return -1;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void free_stack(unsigned long stack, int order)
|
|
|
|
{
|
|
|
|
free_pages(stack, order);
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned long alloc_stack(int order, int atomic)
|
|
|
|
{
|
|
|
|
unsigned long page;
|
2005-10-21 07:22:24 +00:00
|
|
|
gfp_t flags = GFP_KERNEL;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2005-09-23 04:44:20 +00:00
|
|
|
if (atomic)
|
|
|
|
flags = GFP_ATOMIC;
|
2005-04-16 22:20:36 +00:00
|
|
|
page = __get_free_pages(flags, order);
|
|
|
|
if(page == 0)
|
2007-05-06 21:51:21 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
stack_protections(page);
|
2007-05-06 21:51:21 +00:00
|
|
|
return page;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
|
|
|
|
{
|
|
|
|
int pid;
|
|
|
|
|
|
|
|
current->thread.request.u.thread.proc = fn;
|
|
|
|
current->thread.request.u.thread.arg = arg;
|
2005-06-25 21:55:21 +00:00
|
|
|
pid = do_fork(CLONE_VM | CLONE_UNTRACED | flags, 0,
|
|
|
|
¤t->thread.regs, 0, NULL, NULL);
|
2007-05-06 21:51:21 +00:00
|
|
|
return pid;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-05-06 21:51:21 +00:00
|
|
|
static inline void set_current(struct task_struct *task)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2006-01-12 09:05:48 +00:00
|
|
|
cpu_tasks[task_thread_info(task)->cpu] = ((struct cpu_task)
|
2005-04-16 22:20:36 +00:00
|
|
|
{ external_pid(task), task });
|
|
|
|
}
|
|
|
|
|
|
|
|
void *_switch_to(void *prev, void *next, void *last)
|
|
|
|
{
|
2006-09-27 08:50:40 +00:00
|
|
|
struct task_struct *from = prev;
|
|
|
|
struct task_struct *to= next;
|
2005-09-17 02:27:43 +00:00
|
|
|
|
2006-09-27 08:50:40 +00:00
|
|
|
to->thread.prev_sched = from;
|
|
|
|
set_current(to);
|
2005-09-17 02:27:43 +00:00
|
|
|
|
[PATCH] uml: breakpoint an arbitrary thread
This patch implements a stack trace for a thread, not unlike sysrq-t does.
The advantage to this is that a break point can be placed on showreqs, so that
upon showing the stack, you jump immediately into the debugger. While sysrq-t
does the same thing, sysrq-t shows *all* threads stacks. It also doesn't work
right now. In the future, I thought it might be acceptable to make this show
all pids stacks, but perhaps leaving well enough alone and just using sysrq-t
would be okay. For now, upon receiving the stack command, UML switches
context to that thread, dumps its registers, and then switches context back to
the original thread. Since UML compacts all threads into one of 4 host
threads, this sort of mechanism could be expanded in the future to include
other debugging helpers that sysrq does not cover.
Note by jdike - The main benefit to this is that it brings an arbitrary thread
back into context, where it can be examined by gdb. The fact that it dumps it
stack is secondary. This provides the capability to examine a sleeping
thread, which has existed in tt mode, but not in skas mode until now.
Also, the other threads, that sysrq doesn't cover, can be gdb-ed directly
anyway.
Signed-off-by: Allan Graves<allan.graves@gmail.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Cc: Paolo Giarrusso <blaisorblade@yahoo.it>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-09-17 02:27:46 +00:00
|
|
|
do {
|
|
|
|
current->thread.saved_task = NULL ;
|
|
|
|
CHOOSE_MODE_PROC(switch_to_tt, switch_to_skas, prev, next);
|
|
|
|
if(current->thread.saved_task)
|
|
|
|
show_regs(&(current->thread.regs));
|
|
|
|
next= current->thread.saved_task;
|
|
|
|
prev= current;
|
|
|
|
} while(current->thread.saved_task);
|
2005-09-17 02:27:43 +00:00
|
|
|
|
2007-05-06 21:51:21 +00:00
|
|
|
return current->thread.prev_sched;
|
2005-09-17 02:27:43 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void interrupt_end(void)
|
|
|
|
{
|
2007-05-06 21:51:21 +00:00
|
|
|
if(need_resched())
|
|
|
|
schedule();
|
|
|
|
if(test_tsk_thread_flag(current, TIF_SIGPENDING))
|
|
|
|
do_signal();
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void release_thread(struct task_struct *task)
|
|
|
|
{
|
|
|
|
CHOOSE_MODE(release_thread_tt(task), release_thread_skas(task));
|
|
|
|
}
|
2006-09-27 08:50:40 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
void exit_thread(void)
|
|
|
|
{
|
|
|
|
unprotect_stack((unsigned long) current_thread);
|
|
|
|
}
|
2006-09-27 08:50:40 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
void *get_current(void)
|
|
|
|
{
|
2007-05-06 21:51:21 +00:00
|
|
|
return current;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
|
2006-09-27 08:50:40 +00:00
|
|
|
unsigned long stack_top, struct task_struct * p,
|
2005-04-16 22:20:36 +00:00
|
|
|
struct pt_regs *regs)
|
|
|
|
{
|
2006-03-31 10:30:22 +00:00
|
|
|
int ret;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
p->thread = (struct thread_struct) INIT_THREAD;
|
2006-03-31 10:30:22 +00:00
|
|
|
ret = CHOOSE_MODE_PROC(copy_thread_tt, copy_thread_skas, nr,
|
|
|
|
clone_flags, sp, stack_top, p, regs);
|
|
|
|
|
|
|
|
if (ret || !current->thread.forking)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
clear_flushed_tls(p);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set a new TLS for the child thread?
|
|
|
|
*/
|
|
|
|
if (clone_flags & CLONE_SETTLS)
|
|
|
|
ret = arch_copy_tls(p);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void initial_thread_cb(void (*proc)(void *), void *arg)
|
|
|
|
{
|
|
|
|
int save_kmalloc_ok = kmalloc_ok;
|
|
|
|
|
|
|
|
kmalloc_ok = 0;
|
2006-09-27 08:50:40 +00:00
|
|
|
CHOOSE_MODE_PROC(initial_thread_cb_tt, initial_thread_cb_skas, proc,
|
2005-04-16 22:20:36 +00:00
|
|
|
arg);
|
|
|
|
kmalloc_ok = save_kmalloc_ok;
|
|
|
|
}
|
2006-09-27 08:50:40 +00:00
|
|
|
|
2007-05-06 21:51:21 +00:00
|
|
|
#ifdef CONFIG_MODE_TT
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long stack_sp(unsigned long page)
|
|
|
|
{
|
2007-05-06 21:51:21 +00:00
|
|
|
return page + PAGE_SIZE - sizeof(void *);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2007-05-06 21:51:21 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
void default_idle(void)
|
|
|
|
{
|
2005-06-25 21:55:22 +00:00
|
|
|
CHOOSE_MODE(uml_idle_timer(), (void) 0);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
while(1){
|
|
|
|
/* endless idle loop with no priority at all */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* although we are an idle CPU, we do not want to
|
|
|
|
* get into the scheduler unnecessarily.
|
|
|
|
*/
|
|
|
|
if(need_resched())
|
|
|
|
schedule();
|
2006-09-27 08:50:40 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
idle_sleep(10);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void cpu_idle(void)
|
|
|
|
{
|
|
|
|
CHOOSE_MODE(init_idle_tt(), init_idle_skas());
|
|
|
|
}
|
|
|
|
|
2006-09-27 08:50:40 +00:00
|
|
|
void *um_virt_to_phys(struct task_struct *task, unsigned long addr,
|
2005-04-16 22:20:36 +00:00
|
|
|
pte_t *pte_out)
|
|
|
|
{
|
|
|
|
pgd_t *pgd;
|
|
|
|
pud_t *pud;
|
|
|
|
pmd_t *pmd;
|
|
|
|
pte_t *pte;
|
2005-10-30 01:16:38 +00:00
|
|
|
pte_t ptent;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2006-09-27 08:50:40 +00:00
|
|
|
if(task->mm == NULL)
|
2007-05-06 21:51:21 +00:00
|
|
|
return ERR_PTR(-EINVAL);
|
2005-04-16 22:20:36 +00:00
|
|
|
pgd = pgd_offset(task->mm, addr);
|
|
|
|
if(!pgd_present(*pgd))
|
2007-05-06 21:51:21 +00:00
|
|
|
return ERR_PTR(-EINVAL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
pud = pud_offset(pgd, addr);
|
|
|
|
if(!pud_present(*pud))
|
2007-05-06 21:51:21 +00:00
|
|
|
return ERR_PTR(-EINVAL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
pmd = pmd_offset(pud, addr);
|
2006-09-27 08:50:40 +00:00
|
|
|
if(!pmd_present(*pmd))
|
2007-05-06 21:51:21 +00:00
|
|
|
return ERR_PTR(-EINVAL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
pte = pte_offset_kernel(pmd, addr);
|
2005-10-30 01:16:38 +00:00
|
|
|
ptent = *pte;
|
|
|
|
if(!pte_present(ptent))
|
2007-05-06 21:51:21 +00:00
|
|
|
return ERR_PTR(-EINVAL);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
if(pte_out != NULL)
|
2005-10-30 01:16:38 +00:00
|
|
|
*pte_out = ptent;
|
2007-05-06 21:51:21 +00:00
|
|
|
return (void *) (pte_val(ptent) & PAGE_MASK) + (addr & ~PAGE_MASK);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
char *current_cmd(void)
|
|
|
|
{
|
|
|
|
#if defined(CONFIG_SMP) || defined(CONFIG_HIGHMEM)
|
2007-05-06 21:51:21 +00:00
|
|
|
return "(Unknown)";
|
2005-04-16 22:20:36 +00:00
|
|
|
#else
|
|
|
|
void *addr = um_virt_to_phys(current, current->mm->arg_start, NULL);
|
|
|
|
return IS_ERR(addr) ? "(Unknown)": __va((unsigned long) addr);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void dump_thread(struct pt_regs *regs, struct user *u)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
void *um_kmalloc(int size)
|
|
|
|
{
|
2006-01-19 01:42:58 +00:00
|
|
|
return kmalloc(size, GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void *um_kmalloc_atomic(int size)
|
|
|
|
{
|
2006-01-19 01:42:58 +00:00
|
|
|
return kmalloc(size, GFP_ATOMIC);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void *um_vmalloc(int size)
|
|
|
|
{
|
2006-01-19 01:42:58 +00:00
|
|
|
return vmalloc(size);
|
|
|
|
}
|
|
|
|
|
|
|
|
int __cant_sleep(void) {
|
|
|
|
return in_atomic() || irqs_disabled() || in_interrupt();
|
|
|
|
/* Is in_interrupt() really needed? */
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int user_context(unsigned long sp)
|
|
|
|
{
|
|
|
|
unsigned long stack;
|
|
|
|
|
|
|
|
stack = sp & (PAGE_MASK << CONFIG_KERNEL_STACK_ORDER);
|
2007-05-06 21:51:21 +00:00
|
|
|
return stack != (unsigned long) current_thread;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
extern exitcall_t __uml_exitcall_begin, __uml_exitcall_end;
|
|
|
|
|
|
|
|
void do_uml_exitcalls(void)
|
|
|
|
{
|
|
|
|
exitcall_t *call;
|
|
|
|
|
|
|
|
call = &__uml_exitcall_end;
|
|
|
|
while (--call >= &__uml_exitcall_begin)
|
|
|
|
(*call)();
|
|
|
|
}
|
|
|
|
|
|
|
|
char *uml_strdup(char *string)
|
|
|
|
{
|
2005-06-23 07:09:04 +00:00
|
|
|
return kstrdup(string, GFP_KERNEL);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int copy_to_user_proc(void __user *to, void *from, int size)
|
|
|
|
{
|
2007-05-06 21:51:21 +00:00
|
|
|
return copy_to_user(to, from, size);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int copy_from_user_proc(void *to, void __user *from, int size)
|
|
|
|
{
|
2007-05-06 21:51:21 +00:00
|
|
|
return copy_from_user(to, from, size);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int clear_user_proc(void __user *buf, int size)
|
|
|
|
{
|
2007-05-06 21:51:21 +00:00
|
|
|
return clear_user(buf, size);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int strlen_user_proc(char __user *str)
|
|
|
|
{
|
2007-05-06 21:51:21 +00:00
|
|
|
return strlen_user(str);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int smp_sigio_handler(void)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_SMP
|
|
|
|
int cpu = current_thread->cpu;
|
|
|
|
IPI_handler(cpu);
|
|
|
|
if(cpu != 0)
|
2007-05-06 21:51:21 +00:00
|
|
|
return 1;
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
2007-05-06 21:51:21 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int cpu(void)
|
|
|
|
{
|
2007-05-06 21:51:21 +00:00
|
|
|
return current_thread->cpu;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static atomic_t using_sysemu = ATOMIC_INIT(0);
|
|
|
|
int sysemu_supported;
|
|
|
|
|
|
|
|
void set_using_sysemu(int value)
|
|
|
|
{
|
|
|
|
if (value > sysemu_supported)
|
|
|
|
return;
|
|
|
|
atomic_set(&using_sysemu, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_using_sysemu(void)
|
|
|
|
{
|
|
|
|
return atomic_read(&using_sysemu);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int proc_read_sysemu(char *buf, char **start, off_t offset, int size,int *eof, void *data)
|
|
|
|
{
|
|
|
|
if (snprintf(buf, size, "%d\n", get_using_sysemu()) < size) /*No overflow*/
|
|
|
|
*eof = 1;
|
|
|
|
|
|
|
|
return strlen(buf);
|
|
|
|
}
|
|
|
|
|
2006-03-31 10:30:15 +00:00
|
|
|
static int proc_write_sysemu(struct file *file,const char __user *buf, unsigned long count,void *data)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
char tmp[2];
|
|
|
|
|
|
|
|
if (copy_from_user(tmp, buf, 1))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
if (tmp[0] >= '0' && tmp[0] <= '2')
|
|
|
|
set_using_sysemu(tmp[0] - '0');
|
|
|
|
return count; /*We use the first char, but pretend to write everything*/
|
|
|
|
}
|
|
|
|
|
|
|
|
int __init make_proc_sysemu(void)
|
|
|
|
{
|
|
|
|
struct proc_dir_entry *ent;
|
|
|
|
if (!sysemu_supported)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
ent = create_proc_entry("sysemu", 0600, &proc_root);
|
|
|
|
|
|
|
|
if (ent == NULL)
|
|
|
|
{
|
2005-07-29 04:16:12 +00:00
|
|
|
printk(KERN_WARNING "Failed to register /proc/sysemu\n");
|
2007-05-06 21:51:21 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
ent->read_proc = proc_read_sysemu;
|
|
|
|
ent->write_proc = proc_write_sysemu;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
late_initcall(make_proc_sysemu);
|
|
|
|
|
|
|
|
int singlestepping(void * t)
|
|
|
|
{
|
|
|
|
struct task_struct *task = t ? t : current;
|
|
|
|
|
|
|
|
if ( ! (task->ptrace & PT_DTRACE) )
|
|
|
|
return(0);
|
|
|
|
|
|
|
|
if (task->thread.singlestep_syscall)
|
|
|
|
return(1);
|
|
|
|
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
|
2005-05-07 04:30:53 +00:00
|
|
|
/*
|
|
|
|
* Only x86 and x86_64 have an arch_align_stack().
|
|
|
|
* All other arches have "#define arch_align_stack(x) (x)"
|
|
|
|
* in their asm/system.h
|
|
|
|
* As this is included in UML from asm-um/system-generic.h,
|
|
|
|
* we can use it to behave as the subarch does.
|
|
|
|
*/
|
|
|
|
#ifndef arch_align_stack
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long arch_align_stack(unsigned long sp)
|
|
|
|
{
|
2006-09-26 06:33:01 +00:00
|
|
|
if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
|
2005-04-16 22:20:36 +00:00
|
|
|
sp -= get_random_int() % 8192;
|
|
|
|
return sp & ~0xf;
|
|
|
|
}
|
2005-05-07 04:30:53 +00:00
|
|
|
#endif
|