#ifndef _LINUX_SCHED_H #define _LINUX_SCHED_H /* * define DEBUG if you want the wait-queues to have some extra * debugging code. It's not normally used, but might catch some * wait-queue coding errors. * * #define DEBUG */ #include /* for HZ */ extern unsigned long intr_count; extern unsigned long event; #include #include #include #include #include /* * 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. */ extern unsigned long avenrun[]; /* Load averages */ #define FSHIFT 11 /* nr of bits of precision */ #define FIXED_1 (1<>= FSHIFT; #define CT_TO_SECS(x) ((x) / HZ) #define CT_TO_USECS(x) (((x) % HZ) * 1000000/HZ) extern int nr_running, nr_tasks; #define FIRST_TASK task[0] #define LAST_TASK task[NR_TASKS-1] #include #include #include #include #include #include #include #include #include #include #define TASK_RUNNING 0 #define TASK_INTERRUPTIBLE 1 #define TASK_UNINTERRUPTIBLE 2 #define TASK_ZOMBIE 3 #define TASK_STOPPED 4 #define TASK_SWAPPING 5 #ifndef NULL #define NULL ((void *) 0) #endif #ifdef __KERNEL__ #define barrier() __asm__("": : :"memory") extern void sched_init(void); extern void show_state(void); extern void trap_init(void); asmlinkage void schedule(void); #endif /* __KERNEL__ */ struct files_struct { int count; fd_set close_on_exec; struct file * fd[NR_OPEN]; }; #define INIT_FILES { \ 0, \ { { 0, } }, \ { NULL, } \ } struct fs_struct { int count; unsigned short umask; struct inode * root, * pwd; }; #define INIT_FS { \ 0, \ 0022, \ NULL, NULL \ } struct mm_struct { int count; unsigned long start_code, end_code, end_data; unsigned long start_brk, brk, start_stack, start_mmap; unsigned long arg_start, arg_end, env_start, env_end; unsigned long rss; unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt; int swappable:1; unsigned long swap_address; unsigned long old_maj_flt; /* old value of maj_flt */ unsigned long dec_flt; /* page fault count of the last time */ unsigned long swap_cnt; /* number of pages to swap on next pass */ struct vm_area_struct * mmap; struct vm_area_struct * mmap_avl; }; #define INIT_MM { \ 0, \ 0, 0, 0, \ 0, 0, 0, 0, \ 0, 0, 0, 0, \ 0, \ /* ?_flt */ 0, 0, 0, 0, \ 0, \ /* swap */ 0, 0, 0, 0, \ &init_mmap, &init_mmap } struct task_struct { /* these are hardcoded - don't touch */ volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */ long counter; long priority; unsigned long signal; unsigned long blocked; /* bitmap of masked signals */ unsigned long flags; /* per process flags, defined below */ int errno; int debugreg[8]; /* Hardware debugging registers */ struct exec_domain *exec_domain; /* various fields */ struct linux_binfmt *binfmt; struct task_struct *next_task, *prev_task; struct sigaction sigaction[32]; unsigned long saved_kernel_stack; unsigned long kernel_stack_page; int exit_code, exit_signal; unsigned long personality; int dumpable:1; int did_exec:1; int pid,pgrp,tty_old_pgrp,session,leader; int groups[NGROUPS]; /* * 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 wait_queue *wait_chldexit; /* for wait4() */ unsigned short uid,euid,suid,fsuid; unsigned short gid,egid,sgid,fsgid; unsigned long timeout; unsigned long it_real_value, it_prof_value, it_virt_value; unsigned long it_real_incr, it_prof_incr, it_virt_incr; long utime, stime, cutime, cstime, start_time; 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; /* ldt for this task - used by Wine. If NULL, default_ldt is used */ struct desc_struct *ldt; /* tss for this task */ struct thread_struct tss; /* filesystem information */ struct fs_struct fs[1]; /* open file information */ struct files_struct files[1]; /* memory management info */ struct mm_struct mm[1]; }; /* * Per process flags */ #define PF_ALIGNWARN 0x00000001 /* Print alignment warning msgs */ /* Not implemented yet, only for 486*/ #define PF_PTRACED 0x00000010 /* set if ptrace (0) has been called. */ #define PF_TRACESYS 0x00000020 /* tracing system calls */ #define PF_STARTING 0x00000100 /* being created */ #define PF_EXITING 0x00000200 /* getting shut down */ /* * cloning flags: */ #define CSIGNAL 0x000000ff /* signal mask to be sent at exit */ #define COPYVM 0x00000100 /* set if VM copy desired (like normal fork()) */ #define COPYFD 0x00000200 /* set if fd's should be copied, not shared (NI) */ /* * INIT_TASK is used to set up the first task table, touch at * your own risk!. Base=0, limit=0x1fffff (=2MB) */ #define INIT_TASK \ /* state etc */ { 0,15,15,0,0,0,0, \ /* debugregs */ { 0, }, \ /* exec domain */&default_exec_domain, \ /* binfmt */ NULL, \ /* schedlink */ &init_task,&init_task, \ /* signals */ {{ 0, },}, \ /* stack */ 0,(unsigned long) &init_kernel_stack, \ /* ec,brk... */ 0,0,0,0,0, \ /* pid etc.. */ 0,0,0,0,0, \ /* suppl grps*/ {NOGROUP,}, \ /* proc links*/ &init_task,&init_task,NULL,NULL,NULL,NULL, \ /* uid etc */ 0,0,0,0,0,0,0,0, \ /* timeout */ 0,0,0,0,0,0,0,0,0,0,0,0, \ /* rlimits */ { {LONG_MAX, LONG_MAX}, {LONG_MAX, LONG_MAX}, \ {LONG_MAX, LONG_MAX}, {LONG_MAX, LONG_MAX}, \ { 0, LONG_MAX}, {LONG_MAX, LONG_MAX}, \ {MAX_TASKS_PER_USER, MAX_TASKS_PER_USER}, {NR_OPEN, NR_OPEN}}, \ /* math */ 0, \ /* comm */ "swapper", \ /* fs info */ 0,NULL, \ /* ipc */ NULL, NULL, \ /* ldt */ NULL, \ /* tss */ INIT_TSS, \ /* fs */ { INIT_FS }, \ /* files */ { INIT_FILES }, \ /* mm */ { INIT_MM } \ } #ifdef __KERNEL__ extern struct task_struct init_task; extern struct task_struct *task[NR_TASKS]; extern struct task_struct *last_task_used_math; extern struct task_struct *current; extern unsigned long volatile jiffies; extern unsigned long itimer_ticks; extern unsigned long itimer_next; extern struct timeval xtime; extern int need_resched; #define CURRENT_TIME (xtime.tv_sec) extern void sleep_on(struct wait_queue ** p); extern void interruptible_sleep_on(struct wait_queue ** p); extern void wake_up(struct wait_queue ** p); extern void wake_up_interruptible(struct wait_queue ** p); extern void notify_parent(struct task_struct * tsk); extern int send_sig(unsigned long sig,struct task_struct * p,int priv); extern int in_group_p(gid_t grp); extern int request_irq(unsigned int irq,void (*handler)(int, struct pt_regs *), unsigned long flags, const char *device); extern void free_irq(unsigned int irq); extern void copy_thread(int, unsigned long, unsigned long, struct task_struct *, struct pt_regs *); extern void flush_thread(void); extern void exit_thread(void); extern int do_execve(char *, char **, char **, struct pt_regs *); extern int do_fork(unsigned long, unsigned long, struct pt_regs *); asmlinkage int do_signal(unsigned long, struct pt_regs *); /* * The wait-queues are circular lists, and you have to be *very* sure * to keep them correct. Use only these two functions to add/remove * entries in the queues. */ extern inline void add_wait_queue(struct wait_queue ** p, struct wait_queue * wait) { unsigned long flags; #ifdef DEBUG if (wait->next) { unsigned long pc; __asm__ __volatile__("call 1f\n" "1:\tpopl %0":"=r" (pc)); printk("add_wait_queue (%08x): wait->next = %08x\n",pc,(unsigned long) wait->next); } #endif save_flags(flags); cli(); if (!*p) { wait->next = wait; *p = wait; } else { wait->next = (*p)->next; (*p)->next = wait; } restore_flags(flags); } extern inline void remove_wait_queue(struct wait_queue ** p, struct wait_queue * wait) { unsigned long flags; struct wait_queue * tmp; #ifdef DEBUG unsigned long ok = 0; #endif save_flags(flags); cli(); if ((*p == wait) && #ifdef DEBUG (ok = 1) && #endif ((*p = wait->next) == wait)) { *p = NULL; } else { tmp = wait; while (tmp->next != wait) { tmp = tmp->next; #ifdef DEBUG if (tmp == *p) ok = 1; #endif } tmp->next = wait->next; } wait->next = NULL; restore_flags(flags); #ifdef DEBUG if (!ok) { printk("removed wait_queue not on list.\n"); printk("list = %08x, queue = %08x\n",(unsigned long) p, (unsigned long) wait); __asm__("call 1f\n1:\tpopl %0":"=r" (ok)); printk("eip = %08x\n",ok); } #endif } extern inline void select_wait(struct wait_queue ** wait_address, select_table * p) { struct select_table_entry * entry; if (!p || !wait_address) return; if (p->nr >= __MAX_SELECT_TABLE_ENTRIES) return; entry = p->entry + p->nr; entry->wait_address = wait_address; entry->wait.task = current; entry->wait.next = NULL; add_wait_queue(wait_address,&entry->wait); p->nr++; } extern void __down(struct semaphore * sem); /* * These are not yet interrupt-safe */ extern inline void down(struct semaphore * sem) { if (sem->count <= 0) __down(sem); sem->count--; } extern inline void up(struct semaphore * sem) { sem->count++; wake_up(&sem->wait); } #define REMOVE_LINKS(p) do { unsigned long flags; \ save_flags(flags) ; cli(); \ (p)->next_task->prev_task = (p)->prev_task; \ (p)->prev_task->next_task = (p)->next_task; \ restore_flags(flags); \ 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 { unsigned long flags; \ save_flags(flags); cli(); \ (p)->next_task = &init_task; \ (p)->prev_task = init_task.prev_task; \ init_task.prev_task->next_task = (p); \ init_task.prev_task = (p); \ restore_flags(flags); \ (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 ; ) #endif /* __KERNEL__ */ #endif