- pre2

[davej-history.git] / include / linux / sched.h

#ifndef _LINUX_SCHED_H
#define _LINUX_SCHED_H

#include <asm/param.h>/* for HZ */

externunsigned long event;

#include <linux/config.h>
#include <linux/binfmts.h>
#include <linux/personality.h>
#include <linux/threads.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/times.h>
#include <linux/timex.h>

#include <asm/system.h>
#include <asm/semaphore.h>
#include <asm/page.h>
#include <asm/ptrace.h>

#include <linux/smp.h>
#include <linux/tty.h>
#include <linux/sem.h>
#include <linux/signal.h>
#include <linux/securebits.h>
#include <linux/fs_struct.h>

/*
 * cloning flags:
 */
#define CSIGNAL 0x000000ff/* signal mask to be sent at exit */
#define CLONE_VM 0x00000100/* set if VM shared between processes */
#define CLONE_FS 0x00000200/* set if fs info shared between processes */
#define CLONE_FILES 0x00000400/* set if open files shared between processes */
#define CLONE_SIGNAL 0x00000800/* set if signal handlers and blocked signals shared */
#define CLONE_PID 0x00001000/* set if pid shared */
#define CLONE_PTRACE 0x00002000/* set if we want to let tracing continue on the child too */
#define CLONE_VFORK 0x00004000/* set if the parent wants the child to wake it up on mm_release */
#define CLONE_PARENT 0x00008000/* set if we want to have the same parent as the cloner */

#define CLONE_SIGHAND CLONE_SIGNAL/* Old name */

/*
 * These are the constant used to fake the fixed-point load-average
 * counting. Some notes:
 * - 11 bit fractions expand to 22 bits by the multiplies: this gives
 * a load-average precision of 10 bits integer + 11 bits fractional
 * - if you want to count load-averages more often, you need more
 * precision, or rounding will get you. With 2-second counting freq,
 * the EXP_n values would be 1981, 2034 and 2043 if still using only
 * 11 bit fractions.
 */
externunsigned long avenrun[];/* Load averages */

#define FSHIFT 11/* nr of bits of precision */
#define FIXED_1 (1<<FSHIFT)/* 1.0 as fixed-point */
#define LOAD_FREQ (5*HZ)/* 5 sec intervals */
#define EXP_1 1884/* 1/exp(5sec/1min) as fixed-point */
#define EXP_5 2014/* 1/exp(5sec/5min) */
#define EXP_15 2037/* 1/exp(5sec/15min) */

#define CALC_LOAD(load,exp,n) \
 load *= exp; \
 load += n*(FIXED_1-exp); \
 load >>= FSHIFT;

#define CT_TO_SECS(x) ((x) / HZ)
#define CT_TO_USECS(x) (((x) % HZ) * 1000000/HZ)

externint nr_running, nr_threads;
externint last_pid;

#include <linux/fs.h>
#include <linux/time.h>
#include <linux/param.h>
#include <linux/resource.h>
#include <linux/timer.h>

#include <asm/processor.h>

#define TASK_RUNNING 0
#define TASK_INTERRUPTIBLE 1
#define TASK_UNINTERRUPTIBLE 2
#define TASK_ZOMBIE 4
#define TASK_STOPPED 8
#define TASK_EXCLUSIVE 32

#define __set_task_state(tsk, state_value) \
 do { (tsk)->state = (state_value); } while (0)
#ifdef CONFIG_SMP
#define set_task_state(tsk, state_value) \
 set_mb((tsk)->state, (state_value))
#else
#define set_task_state(tsk, state_value) \
 __set_task_state((tsk), (state_value))
#endif

#define __set_current_state(state_value) \
 do { current->state = (state_value); } while (0)
#ifdef CONFIG_SMP
#define set_current_state(state_value) \
 set_mb(current->state, (state_value))
#else
#define set_current_state(state_value) \
 __set_current_state(state_value)
#endif

/*
 * Scheduling policies
 */
#define SCHED_OTHER 0
#define SCHED_FIFO 1
#define SCHED_RR 2

/*
 * This is an additional bit set when we want to
 * yield the CPU for one re-schedule..
 */
#define SCHED_YIELD 0x10

struct sched_param {
int sched_priority;
};

#ifdef __KERNEL__

#include <linux/spinlock.h>

/*
 * This serializes "schedule()" and also protects
 * the run-queue from deletions/modifications (but
 * _adding_ to the beginning of the run-queue has
 * a separate lock).
 */
extern rwlock_t tasklist_lock;
extern spinlock_t runqueue_lock;

externvoidsched_init(void);
externvoidinit_idle(void);
externvoidshow_state(void);
externvoidcpu_init(void);
externvoidtrap_init(void);
externvoidupdate_process_times(int user);
externvoidupdate_one_process(struct task_struct *p,unsigned long user,
unsigned long system,int cpu);

#define MAX_SCHEDULE_TIMEOUT LONG_MAX
externsigned longFASTCALL(schedule_timeout(signed long timeout));
asmlinkage voidschedule(void);

/*
 * The default fd array needs to be at least BITS_PER_LONG,
 * as this is the granularity returned by copy_fdset().
 */
#define NR_OPEN_DEFAULT BITS_PER_LONG

/*
 * Open file table structure
 */
struct files_struct {
 atomic_t count;
 rwlock_t file_lock;
int max_fds;
int max_fdset;
int next_fd;
struct file ** fd;/* current fd array */
 fd_set *close_on_exec;
 fd_set *open_fds;
 fd_set close_on_exec_init;
 fd_set open_fds_init;
struct file * fd_array[NR_OPEN_DEFAULT];
};

#define INIT_FILES { \
 ATOMIC_INIT(1), \
 RW_LOCK_UNLOCKED, \
 NR_OPEN_DEFAULT, \
 __FD_SETSIZE, \
 0, \
 &init_files.fd_array[0], \
 &init_files.close_on_exec_init, \
 &init_files.open_fds_init, \
 { { 0, } }, \
 { { 0, } }, \
 { NULL, } \
}

/* Maximum number of active map areas.. This is a random (large) number */
#define MAX_MAP_COUNT (65536)

/* Number of map areas at which the AVL tree is activated. This is arbitrary. */
#define AVL_MIN_MAP_COUNT 32

struct mm_struct {
struct vm_area_struct * mmap;/* list of VMAs */
struct vm_area_struct * mmap_avl;/* tree of VMAs */
struct vm_area_struct * mmap_cache;/* last find_vma result */
 pgd_t * pgd;
 atomic_t mm_users;/* How many users with user space? */
 atomic_t mm_count;/* How many references to "struct mm_struct" (users count as 1) */
int map_count;/* number of VMAs */
struct semaphore mmap_sem;
 spinlock_t page_table_lock;
unsigned long context;
unsigned long start_code, end_code, start_data, end_data;
unsigned long start_brk, brk, start_stack;
unsigned long arg_start, arg_end, env_start, env_end;
unsigned long rss, total_vm, locked_vm;
unsigned long def_flags;
unsigned long cpu_vm_mask;
unsigned long swap_cnt;/* number of pages to swap on next pass */
unsigned long swap_address;
/*
 * This is an architecture-specific pointer: the portable
 * part of Linux does not know about any segments.
 */
void* segments;
};

#define INIT_MM(name) { \
 &init_mmap, NULL, NULL, \
 swapper_pg_dir, \
 ATOMIC_INIT(2), ATOMIC_INIT(1), 1, \
 __MUTEX_INITIALIZER(name.mmap_sem), \
 SPIN_LOCK_UNLOCKED, \
 0, \
 0, 0, 0, 0, \
 0, 0, 0, \
 0, 0, 0, 0, \
 0, 0, 0, \
 0, 0, 0, 0, NULL }

struct signal_struct {
 atomic_t count;
struct k_sigaction action[_NSIG];
struct sigpending pending;
 spinlock_t siglock;
};


#define INIT_SIGNALS { \
 ATOMIC_INIT(1), \
 { {{0,}}, }, \
 { NULL, &init_signals.pending.head, }, \
 SPIN_LOCK_UNLOCKED }

/*
 * Some day this will be a full-fledged user tracking system..
 */
struct user_struct {
 atomic_t __count;/* reference count */
 atomic_t processes;/* How many processes does this user have? */
 atomic_t files;/* How many open files does this user have? */

/* Hash table maintenance information */
struct user_struct *next, **pprev;
unsigned int uid;
};

#define get_current_user() ({ \
 struct user_struct *__user = current->user; \
 atomic_inc(&__user->__count); \
 __user; })

externstruct user_struct root_user;
#define INIT_USER (&root_user)

struct task_struct {
/*
 * offsets of these are hardcoded elsewhere - touch with care
 */
volatilelong state;/* -1 unrunnable, 0 runnable, >0 stopped */
unsigned long flags;/* per process flags, defined below */
int sigpending;
 mm_segment_t addr_limit;/* thread address space:
 0-0xBFFFFFFF for user-thead
 0-0xFFFFFFFF for kernel-thread
 */
struct exec_domain *exec_domain;
volatilelong need_resched;
unsigned long ptrace;

int lock_depth;/* Lock depth */

/*
 * offset 32 begins here on 32-bit platforms. We keep
 * all fields in a single cacheline that are needed for
 * the goodness() loop in schedule().
 */
long counter;
long nice;
unsigned long policy;
struct mm_struct *mm;
int has_cpu, processor;
unsigned long cpus_allowed;
/*
 * (only the 'next' pointer fits into the cacheline, but
 * that's just fine.)
 */
struct list_head run_list;

struct task_struct *next_task, *prev_task;
struct mm_struct *active_mm;

/* task state */
struct linux_binfmt *binfmt;
int exit_code, exit_signal;
int pdeath_signal;/* The signal sent when the parent dies */
/* ??? */
unsigned long personality;
int dumpable:1;
int did_exec:1;
 pid_t pid;
 pid_t pgrp;
 pid_t tty_old_pgrp;
 pid_t session;
 pid_t tgid;
/* boolean value for session group leader */
int leader;
/* 
 * pointers to (original) parent process, youngest child, younger sibling,
 * older sibling, respectively. (p->father can be replaced with 
 * p->p_pptr->pid)
 */
struct task_struct *p_opptr, *p_pptr, *p_cptr, *p_ysptr, *p_osptr;
struct list_head thread_group;

/* PID hash table linkage. */
struct task_struct *pidhash_next;
struct task_struct **pidhash_pprev;

 wait_queue_head_t wait_chldexit;/* for wait4() */
struct semaphore *vfork_sem;/* for vfork() */
unsigned long rt_priority;
unsigned long it_real_value, it_prof_value, it_virt_value;
unsigned long it_real_incr, it_prof_incr, it_virt_incr;
struct timer_list real_timer;
struct tms times;
unsigned long start_time;
long per_cpu_utime[NR_CPUS], per_cpu_stime[NR_CPUS];
/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
unsigned long min_flt, maj_flt, nswap, cmin_flt, cmaj_flt, cnswap;
int swappable:1;
/* process credentials */
 uid_t uid,euid,suid,fsuid;
 gid_t gid,egid,sgid,fsgid;
int ngroups;
 gid_t groups[NGROUPS];
 kernel_cap_t cap_effective, cap_inheritable, cap_permitted;
int keep_capabilities:1;
struct user_struct *user;
/* limits */
struct rlimit rlim[RLIM_NLIMITS];
unsigned short used_math;
char comm[16];
/* file system info */
int link_count;
struct tty_struct *tty;/* NULL if no tty */
/* ipc stuff */
struct sem_undo *semundo;
struct sem_queue *semsleeping;
/* CPU-specific state of this task */
struct thread_struct thread;
/* filesystem information */
struct fs_struct *fs;
/* open file information */
struct files_struct *files;
/* signal handlers */
 spinlock_t sigmask_lock;/* Protects signal and blocked */
struct signal_struct *sig;

 sigset_t blocked;
struct sigpending pending;

unsigned long sas_ss_sp;
size_t sas_ss_size;
int(*notifier)(void*priv);
void*notifier_data;
 sigset_t *notifier_mask;

/* Thread group tracking */
 u32 parent_exec_id;
 u32 self_exec_id;
/* Protection of (de-)allocation: mm, files, fs, tty */
 spinlock_t alloc_lock;
};

/*
 * Per process flags
 */
#define PF_ALIGNWARN 0x00000001/* Print alignment warning msgs */
/* Not implemented yet, only for 486*/
#define PF_STARTING 0x00000002/* being created */
#define PF_EXITING 0x00000004/* getting shut down */
#define PF_FORKNOEXEC 0x00000040/* forked but didn't exec */
#define PF_SUPERPRIV 0x00000100/* used super-user privileges */
#define PF_DUMPCORE 0x00000200/* dumped core */
#define PF_SIGNALED 0x00000400/* killed by a signal */
#define PF_MEMALLOC 0x00000800/* Allocating memory */
#define PF_VFORK 0x00001000/* Wake up parent in mm_release */

#define PF_USEDFPU 0x00100000/* task used FPU this quantum (SMP) */

/*
 * Ptrace flags
 */

#define PT_PTRACED 0x00000001
#define PT_TRACESYS 0x00000002
#define PT_DTRACE 0x00000004/* delayed trace (used on m68k, i386) */

/*
 * Limit the stack by to some sane default: root can always
 * increase this limit if needed.. 8MB seems reasonable.
 */
#define _STK_LIM (8*1024*1024)

#define DEF_COUNTER (10*HZ/100)/* 100 ms time slice */
#define MAX_COUNTER (20*HZ/100)
#define DEF_NICE (0)

/*
 * INIT_TASK is used to set up the first task table, touch at
 * your own risk!. Base=0, limit=0x1fffff (=2MB)
 */
#define INIT_TASK(tsk) \
{ \
 state: 0, \
 flags: 0, \
 sigpending: 0, \
 addr_limit: KERNEL_DS, \
 exec_domain: &default_exec_domain, \
 lock_depth: -1, \
 counter: DEF_COUNTER, \
 nice: DEF_NICE, \
 policy: SCHED_OTHER, \
 mm: NULL, \
 active_mm: &init_mm, \
 cpus_allowed: -1, \
 run_list: LIST_HEAD_INIT(tsk.run_list), \
 next_task: &tsk, \
 prev_task: &tsk, \
 p_opptr: &tsk, \
 p_pptr: &tsk, \
 thread_group: LIST_HEAD_INIT(tsk.thread_group), \
 wait_chldexit: __WAIT_QUEUE_HEAD_INITIALIZER(tsk.wait_chldexit),\
 real_timer: { \
 function: it_real_fn \
 }, \
 cap_effective: CAP_INIT_EFF_SET, \
 cap_inheritable: CAP_INIT_INH_SET, \
 cap_permitted: CAP_FULL_SET, \
 keep_capabilities: 0, \
 rlim: INIT_RLIMITS, \
 user: INIT_USER, \
 comm:"swapper", \
 thread: INIT_THREAD, \
 fs: &init_fs, \
 files: &init_files, \
 sigmask_lock: SPIN_LOCK_UNLOCKED, \
 sig: &init_signals, \
 pending: { NULL, &tsk.pending.head, {{0}}}, \
 blocked: {{0}}, \
 alloc_lock: SPIN_LOCK_UNLOCKED \
}


#ifndef INIT_TASK_SIZE
# define INIT_TASK_SIZE 2048*sizeof(long)
#endif

union task_union {
struct task_struct task;
unsigned long stack[INIT_TASK_SIZE/sizeof(long)];
};

externunion task_union init_task_union;

externstruct mm_struct init_mm;
externstruct task_struct *init_tasks[NR_CPUS];

/* PID hashing. (shouldnt this be dynamic?) */
#define PIDHASH_SZ (4096 >> 2)
externstruct task_struct *pidhash[PIDHASH_SZ];

#define pid_hashfn(x) ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))

staticinlinevoidhash_pid(struct task_struct *p)
{
struct task_struct **htable = &pidhash[pid_hashfn(p->pid)];

if((p->pidhash_next = *htable) != NULL)
(*htable)->pidhash_pprev = &p->pidhash_next;
*htable = p;
 p->pidhash_pprev = htable;
}

staticinlinevoidunhash_pid(struct task_struct *p)
{
if(p->pidhash_next)
 p->pidhash_next->pidhash_pprev = p->pidhash_pprev;
*p->pidhash_pprev = p->pidhash_next;
}

staticinlinestruct task_struct *find_task_by_pid(int pid)
{
struct task_struct *p, **htable = &pidhash[pid_hashfn(pid)];

for(p = *htable; p && p->pid != pid; p = p->pidhash_next)
;

return p;
}

/* per-UID process charging. */
externstruct user_struct *alloc_uid(uid_t);
externvoidfree_uid(struct user_struct *);

#include <asm/current.h>

externunsigned longvolatile jiffies;
externunsigned long itimer_ticks;
externunsigned long itimer_next;
externstruct timeval xtime;
externvoiddo_timer(struct pt_regs *);

externunsigned int* prof_buffer;
externunsigned long prof_len;
externunsigned long prof_shift;

#define CURRENT_TIME (xtime.tv_sec)

externvoidFASTCALL(__wake_up(wait_queue_head_t *q,unsigned int mode));
externvoidFASTCALL(__wake_up_sync(wait_queue_head_t *q,unsigned int mode));
externvoidFASTCALL(sleep_on(wait_queue_head_t *q));
externlongFASTCALL(sleep_on_timeout(wait_queue_head_t *q,
signed long timeout));
externvoidFASTCALL(interruptible_sleep_on(wait_queue_head_t *q));
externlongFASTCALL(interruptible_sleep_on_timeout(wait_queue_head_t *q,
signed long timeout));
externvoidFASTCALL(wake_up_process(struct task_struct * tsk));

#define wake_up(x) __wake_up((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE | TASK_EXCLUSIVE)
#define wake_up_all(x) __wake_up((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE)
#define wake_up_sync(x) __wake_up_sync((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE | TASK_EXCLUSIVE)
#define wake_up_interruptible(x) __wake_up((x),TASK_INTERRUPTIBLE | TASK_EXCLUSIVE)
#define wake_up_interruptible_all(x) __wake_up((x),TASK_INTERRUPTIBLE)
#define wake_up_interruptible_sync(x) __wake_up_sync((x),TASK_INTERRUPTIBLE | TASK_EXCLUSIVE)

externintin_group_p(gid_t);
externintin_egroup_p(gid_t);

externvoidproc_caches_init(void);
externvoidflush_signals(struct task_struct *);
externvoidflush_signal_handlers(struct task_struct *);
externintdequeue_signal(sigset_t *, siginfo_t *);
externvoidblock_all_signals(int(*notifier)(void*priv),void*priv,
 sigset_t *mask);
externvoidunblock_all_signals(void);
externintsend_sig_info(int,struct siginfo *,struct task_struct *);
externintforce_sig_info(int,struct siginfo *,struct task_struct *);
externintkill_pg_info(int,struct siginfo *, pid_t);
externintkill_sl_info(int,struct siginfo *, pid_t);
externintkill_proc_info(int,struct siginfo *, pid_t);
externvoidnotify_parent(struct task_struct *,int);
externvoiddo_notify_parent(struct task_struct *,int);
externvoidforce_sig(int,struct task_struct *);
externintsend_sig(int,struct task_struct *,int);
externintkill_pg(pid_t,int,int);
externintkill_sl(pid_t,int,int);
externintkill_proc(pid_t,int,int);
externintdo_sigaction(int,const struct k_sigaction *,struct k_sigaction *);
externintdo_sigaltstack(const stack_t *, stack_t *,unsigned long);

staticinlineintsignal_pending(struct task_struct *p)
{
return(p->sigpending !=0);
}

/*
 * Re-calculate pending state from the set of locally pending
 * signals, globally pending signals, and blocked signals.
 */
staticinlineinthas_pending_signals(sigset_t *p1, sigset_t *p2, sigset_t *blocked)
{
unsigned long ready;
long i;

switch(_NSIG_WORDS) {
default:
for(i = _NSIG_WORDS, ready =0; --i >=0;)
 ready |= (p1->sig[i] | p2->sig[i]) &~ blocked->sig[i];
break;

case4: ready = (p1->sig[3] | p2->sig[3]) &~ blocked->sig[3];
 ready |= (p1->sig[2] | p2->sig[2]) &~ blocked->sig[2];
 ready |= (p1->sig[1] | p2->sig[1]) &~ blocked->sig[1];
 ready |= (p1->sig[0] | p2->sig[0]) &~ blocked->sig[0];
break;

case2: ready = (p1->sig[1] | p2->sig[1]) &~ blocked->sig[1];
 ready |= (p1->sig[0] | p2->sig[0]) &~ blocked->sig[0];
break;

case1: ready = (p1->sig[0] | p2->sig[0]) &~ blocked->sig[0];
}
return ready !=0;
}

/* Reevaluate whether the task has signals pending delivery.
 This is required every time the blocked sigset_t changes.
 All callers should have t->sigmask_lock. */

staticinlinevoidrecalc_sigpending(struct task_struct *t)
{
 t->sigpending =has_pending_signals(&t->pending.signal, &t->sig->pending.signal, &t->blocked);
}

/* True if we are on the alternate signal stack. */

staticinlineinton_sig_stack(unsigned long sp)
{
return(sp - current->sas_ss_sp < current->sas_ss_size);
}

staticinlineintsas_ss_flags(unsigned long sp)
{
return(current->sas_ss_size ==0? SS_DISABLE
:on_sig_stack(sp) ? SS_ONSTACK :0);
}

externintrequest_irq(unsigned int,
void(*handler)(int,void*,struct pt_regs *),
unsigned long,const char*,void*);
externvoidfree_irq(unsigned int,void*);

/*
 * This has now become a routine instead of a macro, it sets a flag if
 * it returns true (to do BSD-style accounting where the process is flagged
 * if it uses root privs). The implication of this is that you should do
 * normal permissions checks first, and check suser() last.
 *
 * [Dec 1997 -- Chris Evans]
 * For correctness, the above considerations need to be extended to
 * fsuser(). This is done, along with moving fsuser() checks to be
 * last.
 *
 * These will be removed, but in the mean time, when the SECURE_NOROOT 
 * flag is set, uids don't grant privilege.
 */
staticinlineintsuser(void)
{
if(!issecure(SECURE_NOROOT) && current->euid ==0) {
 current->flags |= PF_SUPERPRIV;
return1;
}
return0;
}

staticinlineintfsuser(void)
{
if(!issecure(SECURE_NOROOT) && current->fsuid ==0) {
 current->flags |= PF_SUPERPRIV;
return1;
}
return0;
}

/*
 * capable() checks for a particular capability. 
 * New privilege checks should use this interface, rather than suser() or
 * fsuser(). See include/linux/capability.h for defined capabilities.
 */

staticinlineintcapable(int cap)
{
#if 1/* ok now */
if(cap_raised(current->cap_effective, cap))
#else
if(cap_is_fs_cap(cap) ? current->fsuid ==0: current->euid ==0)
#endif
{
 current->flags |= PF_SUPERPRIV;
return1;
}
return0;
}

/*
 * Routines for handling mm_structs
 */
externstruct mm_struct *mm_alloc(void);

externstruct mm_struct *start_lazy_tlb(void);
externvoidend_lazy_tlb(struct mm_struct *mm);

/* mmdrop drops the mm and the page tables */
extern inlinevoidFASTCALL(__mmdrop(struct mm_struct *));
staticinlinevoidmmdrop(struct mm_struct * mm)
{
if(atomic_dec_and_test(&mm->mm_count))
__mmdrop(mm);
}

/* mmput gets rid of the mappings and all user-space */
externvoidmmput(struct mm_struct *);
/* Remove the current tasks stale references to the old mm_struct */
externvoidmm_release(void);

/*
 * Routines for handling the fd arrays
 */
externstruct file **alloc_fd_array(int);
externintexpand_fd_array(struct files_struct *,int nr);
externvoidfree_fd_array(struct file **,int);

extern fd_set *alloc_fdset(int);
externintexpand_fdset(struct files_struct *,int nr);
externvoidfree_fdset(fd_set *,int);

externintcopy_thread(int,unsigned long,unsigned long,struct task_struct *,struct pt_regs *);
externvoidflush_thread(void);
externvoidexit_thread(void);

externvoidexit_mm(struct task_struct *);
externvoidexit_files(struct task_struct *);
externvoidexit_sighand(struct task_struct *);

externvoiddaemonize(void);

externintdo_execve(char*,char**,char**,struct pt_regs *);
externintdo_fork(unsigned long,unsigned long,struct pt_regs *);

externvoidFASTCALL(add_wait_queue(wait_queue_head_t *q, wait_queue_t * wait));
externvoidFASTCALL(add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t * wait));
externvoidFASTCALL(remove_wait_queue(wait_queue_head_t *q, wait_queue_t * wait));

#define __wait_event(wq, condition) \
do { \
 wait_queue_t __wait; \
 init_waitqueue_entry(&__wait, current); \
 \
 add_wait_queue(&wq, &__wait); \
 for (;;) { \
 set_current_state(TASK_UNINTERRUPTIBLE); \
 if (condition) \
 break; \
 schedule(); \
 } \
 current->state = TASK_RUNNING; \
 remove_wait_queue(&wq, &__wait); \
} while (0)

#define wait_event(wq, condition) \
do { \
 if (condition) \
 break; \
 __wait_event(wq, condition); \
} while (0)

#define __wait_event_interruptible(wq, condition, ret) \
do { \
 wait_queue_t __wait; \
 init_waitqueue_entry(&__wait, current); \
 \
 add_wait_queue(&wq, &__wait); \
 for (;;) { \
 set_current_state(TASK_INTERRUPTIBLE); \
 if (condition) \
 break; \
 if (!signal_pending(current)) { \
 schedule(); \
 continue; \
 } \
 ret = -ERESTARTSYS; \
 break; \
 } \
 current->state = TASK_RUNNING; \
 remove_wait_queue(&wq, &__wait); \
} while (0)

#define wait_event_interruptible(wq, condition) \
({ \
 int __ret = 0; \
 if (!(condition)) \
 __wait_event_interruptible(wq, condition, __ret); \
 __ret; \
})

#define REMOVE_LINKS(p) do { \
 (p)->next_task->prev_task = (p)->prev_task; \
 (p)->prev_task->next_task = (p)->next_task; \
 if ((p)->p_osptr) \
 (p)->p_osptr->p_ysptr = (p)->p_ysptr; \
 if ((p)->p_ysptr) \
 (p)->p_ysptr->p_osptr = (p)->p_osptr; \
 else \
 (p)->p_pptr->p_cptr = (p)->p_osptr; \
 } while (0)

#define SET_LINKS(p) do { \
 (p)->next_task = &init_task; \
 (p)->prev_task = init_task.prev_task; \
 init_task.prev_task->next_task = (p); \
 init_task.prev_task = (p); \
 (p)->p_ysptr = NULL; \
 if (((p)->p_osptr = (p)->p_pptr->p_cptr) != NULL) \
 (p)->p_osptr->p_ysptr = p; \
 (p)->p_pptr->p_cptr = p; \
 } while (0)

#define for_each_task(p) \
 for (p = &init_task ; (p = p->next_task) != &init_task ; )

#define next_thread(p) \
 list_entry((p)->thread_group.next, struct task_struct, thread_group)

staticinlinevoiddel_from_runqueue(struct task_struct * p)
{
 nr_running--;
list_del(&p->run_list);
 p->run_list.next = NULL;
}

staticinlineinttask_on_runqueue(struct task_struct *p)
{
return(p->run_list.next != NULL);
}

staticinlinevoidunhash_process(struct task_struct *p)
{
if(task_on_runqueue(p))BUG();
write_lock_irq(&tasklist_lock);
 nr_threads--;
unhash_pid(p);
REMOVE_LINKS(p);
list_del(&p->thread_group);
write_unlock_irq(&tasklist_lock);
}

staticinlinevoidtask_lock(struct task_struct *p)
{
spin_lock(&p->alloc_lock);
}

staticinlinevoidtask_unlock(struct task_struct *p)
{
spin_unlock(&p->alloc_lock);
}

/* write full pathname into buffer and return start of pathname */
staticinlinechar*d_path(struct dentry *dentry,struct vfsmount *vfsmnt,
char*buf,int buflen)
{
char*res;
struct vfsmount *rootmnt;
struct dentry *root;
read_lock(&current->fs->lock);
 rootmnt =mntget(current->fs->rootmnt);
 root =dget(current->fs->root);
read_unlock(&current->fs->lock);
spin_lock(&dcache_lock);
 res =__d_path(dentry, vfsmnt, root, rootmnt, buf, buflen);
spin_unlock(&dcache_lock);
dput(root);
mntput(rootmnt);
return res;
}

#endif/* __KERNEL__ */

#endif