unchanged: --- vanilla-linux-2.6.7-SKAS/include/linux/mm.h~Add_generic_proc_mm_support 2004-08-10 19:58:46.098926064 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/include/linux/mm.h 2004-08-10 19:58:46.105925000 +0200 @@ -574,6 +574,9 @@ struct shrinker; extern struct shrinker *set_shrinker(int, shrinker_t); extern void remove_shrinker(struct shrinker *shrinker); +extern long do_mprotect(struct mm_struct *mm, unsigned long start, + size_t len, unsigned long prot); + /* * On a two-level page table, this ends up being trivial. Thus the * inlining and the symmetry break with pte_alloc_map() that does all @@ -632,9 +635,15 @@ extern void exit_mmap(struct mm_struct * extern unsigned long get_unmapped_area(struct file *, unsigned long, unsigned long, unsigned long, unsigned long); -extern unsigned long do_mmap_pgoff(struct file *file, unsigned long addr, +extern unsigned long __do_mmap_pgoff(struct mm_struct *mm, struct file *file, + unsigned long addr, unsigned long len, + unsigned long prot, unsigned long flag, + unsigned long pgoff); +static inline unsigned long do_mmap_pgoff(struct file *file, unsigned long addr, unsigned long len, unsigned long prot, - unsigned long flag, unsigned long pgoff); + unsigned long flag, unsigned long pgoff) { + return __do_mmap_pgoff(current->mm, file, addr, len, prot, flag, pgoff); +} static inline unsigned long do_mmap(struct file *file, unsigned long addr, unsigned long len, unsigned long prot, unchanged: --- vanilla-linux-2.6.7-SKAS/include/linux/proc_mm.h~Add_generic_proc_mm_support 2004-08-10 19:58:46.099925912 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/include/linux/proc_mm.h 2004-08-10 19:58:46.105925000 +0200 @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2002 Jeff Dike (jdike@karaya.com) + * Licensed under the GPL + */ + +#ifndef __PROC_MM_H +#define __PROC_MM_H + +#include "linux/sched.h" + +#define MM_MMAP 54 +#define MM_MUNMAP 55 +#define MM_MPROTECT 56 +#define MM_COPY_SEGMENTS 57 + +struct mm_mmap { + unsigned long addr; + unsigned long len; + unsigned long prot; + unsigned long flags; + unsigned long fd; + unsigned long offset; +}; + +struct mm_munmap { + unsigned long addr; + unsigned long len; +}; + +struct mm_mprotect { + unsigned long addr; + unsigned long len; + unsigned int prot; +}; + +struct proc_mm_op { + int op; + union { + struct mm_mmap mmap; + struct mm_munmap munmap; + struct mm_mprotect mprotect; + int copy_segments; + } u; +}; + +extern struct mm_struct *proc_mm_get_mm(int fd); + +#endif unchanged: --- vanilla-linux-2.6.7-SKAS/mm/Makefile~Add_generic_proc_mm_support 2004-08-10 19:58:46.100925760 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/mm/Makefile 2004-08-10 19:58:46.105925000 +0200 @@ -15,3 +15,4 @@ obj-y := bootmem.o filemap.o mempool.o obj-$(CONFIG_SWAP) += page_io.o swap_state.o swapfile.o obj-$(CONFIG_HUGETLBFS) += hugetlb.o obj-$(CONFIG_NUMA) += mempolicy.o +obj-$(CONFIG_PROC_MM) += proc_mm.o unchanged: --- vanilla-linux-2.6.7-SKAS/mm/mmap.c~Add_generic_proc_mm_support 2004-08-10 19:58:46.101925608 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/mm/mmap.c 2004-08-10 19:58:46.106924848 +0200 @@ -725,11 +725,11 @@ none: * The caller must hold down_write(current->mm->mmap_sem). */ -unsigned long do_mmap_pgoff(struct file * file, unsigned long addr, - unsigned long len, unsigned long prot, - unsigned long flags, unsigned long pgoff) +unsigned long __do_mmap_pgoff(struct mm_struct *mm, struct file * file, + unsigned long addr, unsigned long len, + unsigned long prot, unsigned long flags, + unsigned long pgoff) { - struct mm_struct * mm = current->mm; struct vm_area_struct * vma, * prev; struct inode *inode; unsigned int vm_flags; @@ -988,7 +988,7 @@ unacct_error: return error; } -EXPORT_SYMBOL(do_mmap_pgoff); +EXPORT_SYMBOL(__do_mmap_pgoff); /* Get an address range which is currently unmapped. * For shmat() with addr=0. unchanged: --- vanilla-linux-2.6.7-SKAS/mm/mprotect.c~Add_generic_proc_mm_support 2004-08-10 19:58:46.102925456 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/mm/mprotect.c 2004-08-10 19:58:46.106924848 +0200 @@ -185,8 +185,9 @@ fail: return error; } -asmlinkage long -sys_mprotect(unsigned long start, size_t len, unsigned long prot) +long +do_mprotect(struct mm_struct *mm, unsigned long start, size_t len, + unsigned long prot) { unsigned long vm_flags, nstart, end, tmp; struct vm_area_struct *vma, *prev; @@ -209,9 +210,9 @@ sys_mprotect(unsigned long start, size_t vm_flags = calc_vm_prot_bits(prot); - down_write(¤t->mm->mmap_sem); + down_write(&mm->mmap_sem); - vma = find_vma_prev(current->mm, start, &prev); + vma = find_vma_prev(mm, start, &prev); error = -ENOMEM; if (!vma) goto out; @@ -277,6 +278,11 @@ sys_mprotect(unsigned long start, size_t } } out: - up_write(¤t->mm->mmap_sem); + up_write(&mm->mmap_sem); return error; } + +asmlinkage long sys_mprotect(unsigned long start, size_t len, unsigned long prot) +{ + return(do_mprotect(current->mm, start, len, prot)); +} unchanged: --- vanilla-linux-2.6.7-SKAS-paolo/mm/proc_mm.c 2004-08-04 18:27:55.676323624 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/mm/proc_mm.c 2004-08-05 18:30:48.000000000 +0200 @@ -0,0 +1,172 @@ +/* + * Copyright (C) 2002 Jeff Dike (jdike@karaya.com) + * Licensed under the GPL + */ + +#include "linux/mm.h" +#include "linux/init.h" +#include "linux/proc_fs.h" +#include "linux/proc_mm.h" +#include "linux/file.h" +#include "asm/uaccess.h" +#include "asm/mmu_context.h" + +static struct file_operations proc_mm_fops; + +struct mm_struct *proc_mm_get_mm(int fd) +{ + struct mm_struct *ret = ERR_PTR(-EBADF); + struct file *file; + + file = fget(fd); + if (!file) + goto out; + + ret = ERR_PTR(-EINVAL); + if(file->f_op != &proc_mm_fops) + goto out_fput; + + ret = file->private_data; + out_fput: + fput(file); + out: + return(ret); +} + +extern long do_mmap2(struct mm_struct *mm, unsigned long addr, + unsigned long len, unsigned long prot, + unsigned long flags, unsigned long fd, + unsigned long pgoff); + +static ssize_t write_proc_mm(struct file *file, const char *buffer, + size_t count, loff_t *ppos) +{ + struct mm_struct *mm = file->private_data; + struct proc_mm_op req; + int n, ret; + + if(count > sizeof(req)) + return(-EINVAL); + + n = copy_from_user(&req, buffer, count); + if(n != 0) + return(-EFAULT); + + ret = count; + switch(req.op){ + case MM_MMAP: { + struct mm_mmap *map = &req.u.mmap; + + ret = do_mmap2(mm, map->addr, map->len, map->prot, + map->flags, map->fd, map->offset >> PAGE_SHIFT); + if((ret & ~PAGE_MASK) == 0) + ret = count; + + break; + } + case MM_MUNMAP: { + struct mm_munmap *unmap = &req.u.munmap; + + down_write(&mm->mmap_sem); + ret = do_munmap(mm, unmap->addr, unmap->len); + up_write(&mm->mmap_sem); + + if(ret == 0) + ret = count; + break; + } + case MM_MPROTECT: { + struct mm_mprotect *protect = &req.u.mprotect; + + ret = do_mprotect(mm, protect->addr, protect->len, + protect->prot); + if(ret == 0) + ret = count; + break; + } + + case MM_COPY_SEGMENTS: { + struct mm_struct *from = proc_mm_get_mm(req.u.copy_segments); + + if(IS_ERR(from)){ + ret = PTR_ERR(from); + break; + } + + ret = copy_context(mm, from); + if(ret == 0) + ret = count; + break; + } + default: + ret = -EINVAL; + break; + } + + return(ret); +} + +static int open_proc_mm(struct inode *inode, struct file *file) +{ + struct mm_struct *mm = mm_alloc(); + int ret; + + ret = -ENOMEM; + if(mm == NULL) + goto out_mem; + + init_new_empty_context(mm); + + spin_lock(&mmlist_lock); + list_add(&mm->mmlist, ¤t->mm->mmlist); + mmlist_nr++; + spin_unlock(&mmlist_lock); + + file->private_data = mm; + + return(0); + + out_mem: + return(ret); +} + +static int release_proc_mm(struct inode *inode, struct file *file) +{ + struct mm_struct *mm = file->private_data; + + mmput(mm); + return(0); +} + +static struct file_operations proc_mm_fops = { + .open = open_proc_mm, + .release = release_proc_mm, + .write = write_proc_mm, +}; + +static int make_proc_mm(void) +{ + struct proc_dir_entry *ent; + + ent = create_proc_entry("mm", 0222, &proc_root); + if(ent == NULL){ + printk("make_proc_mm : Failed to register /proc/mm\n"); + return(0); + } + ent->proc_fops = &proc_mm_fops; + + return(0); +} + +__initcall(make_proc_mm); + +/* + * Overrides for Emacs so that we follow Linus's tabbing style. + * Emacs will notice this stuff at the end of the file and automatically + * adjust the settings for this buffer only. This must remain at the end + * of the file. + * --------------------------------------------------------------------------- + * Local variables: + * c-file-style: "linux" + * End: + */ unchanged: --- vanilla-linux-2.6.7-SKAS/arch/i386/Kconfig~i386-specific 2004-08-10 19:58:47.339737432 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/arch/i386/Kconfig 2004-08-10 19:58:47.367733176 +0200 @@ -720,6 +720,10 @@ config X86_PAE depends on HIGHMEM64G default y +config PROC_MM + bool "/proc/mm support" + default y + # Common NUMA Features config NUMA bool "Numa Memory Allocation and Scheduler Support" unchanged: --- vanilla-linux-2.6.7-SKAS-paolo/arch/i386/kernel/ldt.c 2004-08-04 19:01:54.081438944 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/arch/i386/kernel/ldt.c 2004-08-05 18:30:36.000000000 +0200 @@ -18,6 +18,7 @@ #include #include #include +#include #ifdef CONFIG_SMP /* avoids "defined but not used" warnig */ static void flush_ldt(void *null) @@ -54,7 +55,7 @@ pc->size = mincount; wmb(); - if (reload) { + if (reload && (¤t->active_mm->context == pc)) { #ifdef CONFIG_SMP cpumask_t mask; preempt_disable(); @@ -89,6 +90,12 @@ * we do not have to muck with descriptors here, that is * done in switch_mm() as needed. */ +void init_new_empty_context(struct mm_struct *mm) +{ + init_MUTEX(&mm->context.sem); + mm->context.size = 0; +} + int init_new_context(struct task_struct *tsk, struct mm_struct *mm) { struct mm_struct * old_mm; @@ -105,6 +112,23 @@ return retval; } +int copy_context(struct mm_struct *mm, struct mm_struct *old_mm) +{ + mm_context_t *new_c = &mm->context; + mm_context_t *old_c = &old_mm->context; + int err = 0; + if (old_mm && old_c->size > 0) { + down(&old_c->sem); + err = alloc_ldt(new_c, old_c->size, 0); + if (err < 0) + goto out; + memcpy(new_c->ldt, old_c->ldt, old_c->size*LDT_ENTRY_SIZE); + up(&old_c->sem); + } +out: + return err; +} + /* * No need to lock the MM as we are the last user */ @@ -121,11 +145,11 @@ } } -static int read_ldt(void __user * ptr, unsigned long bytecount) +static int read_ldt(struct mm_struct * mm, void __user * ptr, + unsigned long bytecount) { int err; unsigned long size; - struct mm_struct * mm = current->mm; if (!mm->context.size) return 0; @@ -169,9 +193,8 @@ return err; } -static int write_ldt(void __user * ptr, unsigned long bytecount, int oldmode) +static int write_ldt(struct mm_struct * mm, void __user * ptr, unsigned long bytecount, int oldmode) { - struct mm_struct * mm = current->mm; __u32 entry_1, entry_2, *lp; int error; struct user_desc ldt_info; @@ -195,7 +218,7 @@ down(&mm->context.sem); if (ldt_info.entry_number >= mm->context.size) { - error = alloc_ldt(¤t->mm->context, ldt_info.entry_number+1, 1); + error = alloc_ldt(&mm->context, ldt_info.entry_number+1, 1); if (error < 0) goto out_unlock; } @@ -231,20 +254,26 @@ -asmlinkage int sys_modify_ldt(int func, void __user *ptr, unsigned long bytecount) +int modify_ldt(struct mm_struct * mm, int func, void __user *ptr, + unsigned long bytecount) { int ret = -ENOSYS; switch (func) { case 0: - ret = read_ldt(ptr, bytecount); + ret = read_ldt(mm, ptr, bytecount); break; case 1: - ret = write_ldt(ptr, bytecount, 1); + ret = write_ldt(mm, ptr, bytecount, 1); break; case 2: ret = read_default_ldt(ptr, bytecount); break; case 0x11: - ret = write_ldt(ptr, bytecount, 0); + ret = write_ldt(mm, ptr, bytecount, 0); break; } return ret; } + +asmlinkage int sys_modify_ldt(int func, void __user *ptr, unsigned long bytecount) +{ + return modify_ldt(current->mm, func, ptr, bytecount); +} diff -u vanilla-linux-2.6.7-SKAS-paolo/arch/i386/kernel/ptrace.c vanilla-linux-2.6.7-SKAS-paolo/arch/i386/kernel/ptrace.c --- vanilla-linux-2.6.7-SKAS-paolo/arch/i386/kernel/ptrace.c 2004-08-10 19:58:50.364277632 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/arch/i386/kernel/ptrace.c 2004-08-10 19:59:17.385169832 +0200 @@ -15,6 +15,7 @@ #include #include #include +#include #include #include @@ -357,6 +358,7 @@ } break; + case PTRACE_SYSEMU: /* continue and replace next syscall */ case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */ case PTRACE_CONT: { /* restart after signal. */ long tmp; @@ -364,6 +366,12 @@ ret = -EIO; if ((unsigned long) data > _NSIG) break; + if (request == PTRACE_SYSEMU) { + set_tsk_thread_flag(child, TIF_SYSCALL_EMU); + } + else { + clear_tsk_thread_flag(child, TIF_SYSCALL_EMU); + } if (request == PTRACE_SYSCALL) { set_tsk_thread_flag(child, TIF_SYSCALL_TRACE); } @@ -404,7 +412,7 @@ ret = -EIO; if ((unsigned long) data > _NSIG) break; - clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE); + clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE|TIF_SYSCALL_EMU); if ((child->ptrace & PT_DTRACE) == 0) { /* Spurious delayed TF traps may occur */ child->ptrace |= PT_DTRACE; @@ -509,6 +517,56 @@ (struct user_desc __user *) data); break; +#ifdef CONFIG_PROC_MM + case PTRACE_FAULTINFO: { + struct ptrace_faultinfo fault; + + fault = ((struct ptrace_faultinfo) + { .is_write = child->thread.error_code, + .addr = child->thread.cr2 }); + ret = copy_to_user((unsigned long *) data, &fault, + sizeof(fault)); + if(ret) + break; + break; + } + + case PTRACE_SIGPENDING: + ret = copy_to_user((unsigned long *) data, + &child->pending.signal, + sizeof(child->pending.signal)); + break; + + case PTRACE_LDT: { + struct ptrace_ldt ldt; + + if(copy_from_user(&ldt, (unsigned long *) data, + sizeof(ldt))){ + ret = -EIO; + break; + } + ret = modify_ldt(child->mm, ldt.func, ldt.ptr, ldt.bytecount); + break; + } + + case PTRACE_SWITCH_MM: { + struct mm_struct *old = child->mm; + struct mm_struct *new = proc_mm_get_mm(data); + + if(IS_ERR(new)){ + ret = PTR_ERR(new); + break; + } + + atomic_inc(&new->mm_users); + child->mm = new; + child->active_mm = new; + mmput(old); + ret = 0; + break; + } +#endif + default: ret = ptrace_request(child, request, addr, data); break; @@ -556,0 +615,22 @@ + +void do_syscall_emu(void) +{ + if (!test_thread_flag(TIF_SYSCALL_EMU)) + return; + if (!(current->ptrace & PT_PTRACED)) + return; + /* the 0x80 provides a way for the tracing parent to distinguish + between a syscall stop and SIGTRAP delivery */ + ptrace_notify(SIGTRAP | ((current->ptrace & PT_TRACESYSGOOD) + ? 0x80 : 0)); + + /* + * this isn't the same as continuing with a signal, but it will do + * for normal use. strace only continues with a signal if the + * stopping signal is not SIGTRAP. -brl + */ + if (current->exit_code) { + send_sig(current->exit_code, current, 1); + current->exit_code = 0; + } +} unchanged: --- vanilla-linux-2.6.7-SKAS/arch/i386/kernel/sys_i386.c~i386-specific 2004-08-10 19:58:47.342736976 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/arch/i386/kernel/sys_i386.c 2004-08-10 19:58:47.369732872 +0200 @@ -41,7 +41,7 @@ asmlinkage int sys_pipe(unsigned long __ } /* common code for old and new mmaps */ -static inline long do_mmap2( +long do_mmap2(struct mm_struct *mm, unsigned long addr, unsigned long len, unsigned long prot, unsigned long flags, unsigned long fd, unsigned long pgoff) @@ -56,9 +56,9 @@ static inline long do_mmap2( goto out; } - down_write(¤t->mm->mmap_sem); - error = do_mmap_pgoff(file, addr, len, prot, flags, pgoff); - up_write(¤t->mm->mmap_sem); + down_write(&mm->mmap_sem); + error = __do_mmap_pgoff(mm, file, addr, len, prot, flags, pgoff); + up_write(&mm->mmap_sem); if (file) fput(file); @@ -70,7 +70,7 @@ asmlinkage long sys_mmap2(unsigned long unsigned long prot, unsigned long flags, unsigned long fd, unsigned long pgoff) { - return do_mmap2(addr, len, prot, flags, fd, pgoff); + return do_mmap2(current->mm, addr, len, prot, flags, fd, pgoff); } /* @@ -101,7 +101,7 @@ asmlinkage int old_mmap(struct mmap_arg_ if (a.offset & ~PAGE_MASK) goto out; - err = do_mmap2(a.addr, a.len, a.prot, a.flags, a.fd, a.offset >> PAGE_SHIFT); + err = do_mmap2(current->mm, a.addr, a.len, a.prot, a.flags, a.fd, a.offset >> PAGE_SHIFT); out: return err; } unchanged: --- vanilla-linux-2.6.7-SKAS/include/asm-i386/desc.h~i386-specific 2004-08-10 19:58:47.343736824 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/include/asm-i386/desc.h 2004-08-10 19:58:47.369732872 +0200 @@ -123,6 +123,9 @@ static inline void load_LDT(mm_context_t put_cpu(); } +extern int modify_ldt(struct mm_struct * mm, int func, void __user *ptr, + unsigned long bytecount); + #endif /* !__ASSEMBLY__ */ #endif unchanged: --- vanilla-linux-2.6.7-SKAS/include/asm-i386/processor.h~i386-specific 2004-08-10 19:58:47.344736672 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/include/asm-i386/processor.h 2004-08-10 19:58:47.369732872 +0200 @@ -649,6 +649,8 @@ extern inline void prefetchw(const void extern void select_idle_routine(const struct cpuinfo_x86 *c); +extern int __init_new_context(struct mm_struct *mm, struct mm_struct *old_mm); + #define cache_line_size() (boot_cpu_data.x86_cache_alignment) #ifdef CONFIG_SCHED_SMT unchanged: --- vanilla-linux-2.6.7-SKAS/include/asm-i386/ptrace.h~i386-specific 2004-08-10 19:58:47.345736520 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/include/asm-i386/ptrace.h 2004-08-10 19:58:47.370732720 +0200 @@ -59,4 +59,26 @@ struct pt_regs { #define instruction_pointer(regs) ((regs)->eip) #endif +/*For SKAS3 support.*/ +#ifndef _LINUX_PTRACE_STRUCT_DEF +#define _LINUX_PTRACE_STRUCT_DEF + +#define PTRACE_FAULTINFO 52 +#define PTRACE_SIGPENDING 53 +#define PTRACE_LDT 54 +#define PTRACE_SWITCH_MM 55 + +struct ptrace_faultinfo { + int is_write; + unsigned long addr; +}; + +struct ptrace_ldt { + int func; + void *ptr; + unsigned long bytecount; +}; + +#endif /*ifndef _LINUX_PTRACE_STRUCT_DEF*/ + #endif unchanged: --- vanilla-linux-2.6.7-SKAS-paolo/include/asm-i386/mmu_context.h 2004-08-10 19:58:48.522557616 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/include/asm-i386/mmu_context.h 2004-08-05 18:30:44.000000000 +0200 @@ -12,6 +12,8 @@ */ int init_new_context(struct task_struct *tsk, struct mm_struct *mm); void destroy_context(struct mm_struct *mm); +int copy_context(struct mm_struct *mm, struct mm_struct *old_mm); +void init_new_empty_context(struct mm_struct *mm); static inline void enter_lazy_tlb(struct mm_struct *mm, struct task_struct *tsk) @@ -29,6 +31,10 @@ { int cpu = smp_processor_id(); +#ifdef CONFIG_SMP + prev = cpu_tlbstate[cpu].active_mm; +#endif + if (likely(prev != next)) { /* stop flush ipis for the previous mm */ cpu_clear(cpu, prev->cpu_vm_mask); @@ -50,7 +56,6 @@ #ifdef CONFIG_SMP else { cpu_tlbstate[cpu].state = TLBSTATE_OK; - BUG_ON(cpu_tlbstate[cpu].active_mm != next); if (!cpu_test_and_set(cpu, next->cpu_vm_mask)) { /* We were in lazy tlb mode and leave_mm disabled unchanged: --- vanilla-linux-2.6.7-SKAS/arch/i386/kernel/entry.S~host-sysemu-2.6.7-1 2004-08-10 19:58:50.330282800 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/arch/i386/kernel/entry.S 2004-08-10 19:58:50.364277632 +0200 @@ -280,6 +280,9 @@ ENTRY(system_call) GET_THREAD_INFO(%ebp) cmpl $(nr_syscalls), %eax jae syscall_badsys + # system call emulation + testb $(_TIF_SYSCALL_EMU),TI_flags(%ebp) + jnz syscall_emu_entry # system call tracing in operation testb $(_TIF_SYSCALL_TRACE|_TIF_SYSCALL_AUDIT),TI_flags(%ebp) jnz syscall_trace_entry @@ -333,6 +336,10 @@ work_notifysig_v86: call do_notify_resume jmp restore_all + # perform syscall emulation +syscall_emu_entry: + call do_syscall_emu + jmp syscall_exit # perform syscall exit tracing ALIGN syscall_trace_entry: unchanged: --- vanilla-linux-2.6.7-SKAS/include/asm-i386/thread_info.h~host-sysemu-2.6.7-1 2004-08-10 19:58:50.360278240 +0200 +++ vanilla-linux-2.6.7-SKAS-paolo/include/asm-i386/thread_info.h 2004-08-10 19:58:50.364277632 +0200 @@ -143,6 +143,7 @@ static inline unsigned long current_stac #define TIF_NEED_RESCHED 3 /* rescheduling necessary */ #define TIF_SINGLESTEP 4 /* restore singlestep on return to user mode */ #define TIF_IRET 5 /* return with iret */ +#define TIF_SYSCALL_EMU 6 /* syscall emulation active */ #define TIF_SYSCALL_AUDIT 7 /* syscall auditing active */ #define TIF_POLLING_NRFLAG 16 /* true if poll_idle() is polling TIF_NEED_RESCHED */ @@ -152,6 +153,7 @@ static inline unsigned long current_stac #define _TIF_NEED_RESCHED (1<