This source file includes following definitions.
- add_wait_queue
- remove_wait_queue
- select_wait
- down
- up
1 #ifndef _LINUX_SCHED_H
2 #define _LINUX_SCHED_H
3
4
5
6
7
8
9
10
11
12 #include <asm/param.h>
13
14 extern unsigned long intr_count;
15 extern unsigned long event;
16
17 #include <linux/binfmts.h>
18 #include <linux/personality.h>
19 #include <linux/tasks.h>
20 #include <linux/kernel.h>
21 #include <asm/system.h>
22
23
24
25
26
27
28
29
30
31
32
33 extern unsigned long avenrun[];
34
35 #define FSHIFT 11
36 #define FIXED_1 (1<<FSHIFT)
37 #define LOAD_FREQ (5*HZ)
38 #define EXP_1 1884
39 #define EXP_5 2014
40 #define EXP_15 2037
41
42 #define CALC_LOAD(load,exp,n) \
43 load *= exp; \
44 load += n*(FIXED_1-exp); \
45 load >>= FSHIFT;
46
47 #define CT_TO_SECS(x) ((x) / HZ)
48 #define CT_TO_USECS(x) (((x) % HZ) * 1000000/HZ)
49
50 extern int nr_running, nr_tasks;
51
52 #define FIRST_TASK task[0]
53 #define LAST_TASK task[NR_TASKS-1]
54
55 #include <linux/head.h>
56 #include <linux/fs.h>
57 #include <linux/signal.h>
58 #include <linux/time.h>
59 #include <linux/param.h>
60 #include <linux/resource.h>
61 #include <linux/vm86.h>
62 #include <linux/math_emu.h>
63 #include <linux/ptrace.h>
64 #include <linux/timer.h>
65
66 #include <asm/processor.h>
67
68 #define TASK_RUNNING 0
69 #define TASK_INTERRUPTIBLE 1
70 #define TASK_UNINTERRUPTIBLE 2
71 #define TASK_ZOMBIE 3
72 #define TASK_STOPPED 4
73 #define TASK_SWAPPING 5
74
75 #ifndef NULL
76 #define NULL ((void *) 0)
77 #endif
78
79 #ifdef __KERNEL__
80
81 #define barrier() __asm__("": : :"memory")
82
83 extern void sched_init(void);
84 extern void show_state(void);
85 extern void trap_init(void);
86
87 asmlinkage void schedule(void);
88
89 #endif
90
91 struct files_struct {
92 int count;
93 fd_set close_on_exec;
94 struct file * fd[NR_OPEN];
95 };
96
97 #define INIT_FILES { \
98 1, \
99 { { 0, } }, \
100 { NULL, } \
101 }
102
103 struct fs_struct {
104 int count;
105 unsigned short umask;
106 struct inode * root, * pwd;
107 };
108
109 #define INIT_FS { \
110 1, \
111 0022, \
112 NULL, NULL \
113 }
114
115 struct mm_struct {
116 int count;
117 unsigned long start_code, end_code, start_data, end_data;
118 unsigned long start_brk, brk, start_stack, start_mmap;
119 unsigned long arg_start, arg_end, env_start, env_end;
120 unsigned long rss;
121 unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
122 int swappable:1;
123 unsigned long swap_address;
124 unsigned long old_maj_flt;
125 unsigned long dec_flt;
126 unsigned long swap_cnt;
127 struct vm_area_struct * mmap;
128 struct vm_area_struct * mmap_avl;
129 };
130
131 #define INIT_MM { \
132 1, \
133 0, 0, 0, 0, \
134 0, 0, 0, 0, \
135 0, 0, 0, 0, \
136 0, \
137 0, 0, 0, 0, \
138 0, \
139 0, 0, 0, 0, \
140 &init_mmap, &init_mmap }
141
142 struct task_struct {
143
144 volatile long state;
145 long counter;
146 long priority;
147 unsigned long signal;
148 unsigned long blocked;
149 unsigned long flags;
150 int errno;
151 long debugreg[8];
152 struct exec_domain *exec_domain;
153
154 struct linux_binfmt *binfmt;
155 struct task_struct *next_task, *prev_task;
156 struct task_struct *next_run, *prev_run;
157 struct sigaction *sigaction;
158 unsigned long saved_kernel_stack;
159 unsigned long kernel_stack_page;
160 int exit_code, exit_signal;
161 unsigned long personality;
162 int dumpable:1;
163 int did_exec:1;
164 int pid,pgrp,tty_old_pgrp,session,leader;
165 int groups[NGROUPS];
166
167
168
169
170
171 struct task_struct *p_opptr, *p_pptr, *p_cptr, *p_ysptr, *p_osptr;
172 struct wait_queue *wait_chldexit;
173 unsigned short uid,euid,suid,fsuid;
174 unsigned short gid,egid,sgid,fsgid;
175 unsigned long timeout;
176 unsigned long it_real_value, it_prof_value, it_virt_value;
177 unsigned long it_real_incr, it_prof_incr, it_virt_incr;
178 struct timer_list real_timer;
179 long utime, stime, cutime, cstime, start_time;
180 struct rlimit rlim[RLIM_NLIMITS];
181 unsigned short used_math;
182 char comm[16];
183
184 int link_count;
185 struct tty_struct *tty;
186
187 struct sem_undo *semundo;
188 struct sem_queue *semsleeping;
189
190 struct desc_struct *ldt;
191
192 struct thread_struct tss;
193
194 struct fs_struct *fs;
195
196 struct files_struct *files;
197
198 struct mm_struct *mm;
199 };
200
201
202
203
204 #define PF_ALIGNWARN 0x00000001
205
206 #define PF_PTRACED 0x00000010
207 #define PF_TRACESYS 0x00000020
208
209 #define PF_STARTING 0x00000100
210 #define PF_EXITING 0x00000200
211
212
213
214
215 #define CSIGNAL 0x000000ff
216 #define CLONE_VM 0x00000100
217 #define CLONE_FS 0x00000200
218 #define CLONE_FILES 0x00000400
219 #define CLONE_SIGHAND 0x00000800
220
221
222
223
224
225 #define _STK_LIM (8*1024*1024)
226
227
228
229
230
231 #define INIT_TASK \
232 { 0,15*HZ/100,15*HZ/100,0,0,0,0, \
233 { 0, }, \
234 &default_exec_domain, \
235 NULL, \
236 &init_task,&init_task, &init_task, &init_task, \
237 init_sigaction, \
238 0,(unsigned long) &init_kernel_stack, \
239 0,0,0,0,0, \
240 0,0,0,0,0, \
241 {NOGROUP,}, \
242 &init_task,&init_task,NULL,NULL,NULL,NULL, \
243 0,0,0,0,0,0,0,0, \
244 0,0,0,0,0,0,0, \
245 { NULL, NULL, 0, 0, it_real_fn }, \
246 0,0,0,0,0, \
247 { {LONG_MAX, LONG_MAX}, {LONG_MAX, LONG_MAX}, \
248 {LONG_MAX, LONG_MAX}, {_STK_LIM, _STK_LIM}, \
249 { 0, LONG_MAX}, {LONG_MAX, LONG_MAX}, \
250 {MAX_TASKS_PER_USER, MAX_TASKS_PER_USER}, {NR_OPEN, NR_OPEN}}, \
251 0, \
252 "swapper", \
253 0,NULL, \
254 NULL, NULL, \
255 NULL, \
256 INIT_TSS, \
257 &init_fs, \
258 &init_files, \
259 &init_mm \
260 }
261
262 #ifdef __KERNEL__
263
264 extern struct task_struct init_task;
265 extern struct task_struct *task[NR_TASKS];
266 extern struct task_struct *last_task_used_math;
267 extern struct task_struct *current;
268 extern unsigned long volatile jiffies;
269 extern unsigned long itimer_ticks;
270 extern unsigned long itimer_next;
271 extern struct timeval xtime;
272 extern int need_resched;
273
274 #define CURRENT_TIME (xtime.tv_sec)
275
276 extern void sleep_on(struct wait_queue ** p);
277 extern void interruptible_sleep_on(struct wait_queue ** p);
278 extern void wake_up(struct wait_queue ** p);
279 extern void wake_up_interruptible(struct wait_queue ** p);
280 extern void wake_up_process(struct task_struct * tsk);
281
282 extern void notify_parent(struct task_struct * tsk);
283 extern int send_sig(unsigned long sig,struct task_struct * p,int priv);
284 extern int in_group_p(gid_t grp);
285
286 extern int request_irq(unsigned int irq,void (*handler)(int, struct pt_regs *),
287 unsigned long flags, const char *device);
288 extern void free_irq(unsigned int irq);
289
290 extern void copy_thread(int, unsigned long, unsigned long, struct task_struct *, struct pt_regs *);
291 extern void flush_thread(void);
292 extern void exit_thread(void);
293
294 extern int do_execve(char *, char **, char **, struct pt_regs *);
295 extern int do_fork(unsigned long, unsigned long, struct pt_regs *);
296
297
298
299
300
301
302 extern inline void add_wait_queue(struct wait_queue ** p, struct wait_queue * wait)
303 {
304 unsigned long flags;
305
306 #ifdef DEBUG
307 if (wait->next) {
308 __label__ here;
309 unsigned long pc;
310 pc = (unsigned long) &&here;
311 here:
312 printk("add_wait_queue (%08lx): wait->next = %08lx\n",pc,(unsigned long) wait->next);
313 }
314 #endif
315 save_flags(flags);
316 cli();
317 if (!*p) {
318 wait->next = wait;
319 *p = wait;
320 } else {
321 wait->next = (*p)->next;
322 (*p)->next = wait;
323 }
324 restore_flags(flags);
325 }
326
327 extern inline void remove_wait_queue(struct wait_queue ** p, struct wait_queue * wait)
328 {
329 unsigned long flags;
330 struct wait_queue * tmp;
331 #ifdef DEBUG
332 unsigned long ok = 0;
333 #endif
334
335 save_flags(flags);
336 cli();
337 if ((*p == wait) &&
338 #ifdef DEBUG
339 (ok = 1) &&
340 #endif
341 ((*p = wait->next) == wait)) {
342 *p = NULL;
343 } else {
344 tmp = wait;
345 while (tmp->next != wait) {
346 tmp = tmp->next;
347 #ifdef DEBUG
348 if (tmp == *p)
349 ok = 1;
350 #endif
351 }
352 tmp->next = wait->next;
353 }
354 wait->next = NULL;
355 restore_flags(flags);
356 #ifdef DEBUG
357 if (!ok) {
358 __label__ here;
359 ok = (unsigned long) &&here;
360 printk("removed wait_queue not on list.\n");
361 printk("list = %08lx, queue = %08lx\n",(unsigned long) p, (unsigned long) wait);
362 here:
363 printk("eip = %08lx\n",ok);
364 }
365 #endif
366 }
367
368 extern inline void select_wait(struct wait_queue ** wait_address, select_table * p)
369 {
370 struct select_table_entry * entry;
371
372 if (!p || !wait_address)
373 return;
374 if (p->nr >= __MAX_SELECT_TABLE_ENTRIES)
375 return;
376 entry = p->entry + p->nr;
377 entry->wait_address = wait_address;
378 entry->wait.task = current;
379 entry->wait.next = NULL;
380 add_wait_queue(wait_address,&entry->wait);
381 p->nr++;
382 }
383
384 extern void __down(struct semaphore * sem);
385
386
387
388
389 extern inline void down(struct semaphore * sem)
390 {
391 if (sem->count <= 0)
392 __down(sem);
393 sem->count--;
394 }
395
396 extern inline void up(struct semaphore * sem)
397 {
398 sem->count++;
399 wake_up(&sem->wait);
400 }
401
402 #define REMOVE_LINKS(p) do { unsigned long flags; \
403 save_flags(flags) ; cli(); \
404 (p)->next_task->prev_task = (p)->prev_task; \
405 (p)->prev_task->next_task = (p)->next_task; \
406 restore_flags(flags); \
407 if ((p)->p_osptr) \
408 (p)->p_osptr->p_ysptr = (p)->p_ysptr; \
409 if ((p)->p_ysptr) \
410 (p)->p_ysptr->p_osptr = (p)->p_osptr; \
411 else \
412 (p)->p_pptr->p_cptr = (p)->p_osptr; \
413 } while (0)
414
415 #define SET_LINKS(p) do { unsigned long flags; \
416 save_flags(flags); cli(); \
417 (p)->next_task = &init_task; \
418 (p)->prev_task = init_task.prev_task; \
419 init_task.prev_task->next_task = (p); \
420 init_task.prev_task = (p); \
421 restore_flags(flags); \
422 (p)->p_ysptr = NULL; \
423 if (((p)->p_osptr = (p)->p_pptr->p_cptr) != NULL) \
424 (p)->p_osptr->p_ysptr = p; \
425 (p)->p_pptr->p_cptr = p; \
426 } while (0)
427
428 #define for_each_task(p) \
429 for (p = &init_task ; (p = p->next_task) != &init_task ; )
430
431 #endif
432
433 #endif