1#ifndef _LINUX_SCHED_H
2#define _LINUX_SCHED_H
3
4
5
6
7#define CSIGNAL 0x000000ff
8#define CLONE_VM 0x00000100
9#define CLONE_FS 0x00000200
10#define CLONE_FILES 0x00000400
11#define CLONE_SIGHAND 0x00000800
12#define CLONE_PTRACE 0x00002000
13#define CLONE_VFORK 0x00004000
14#define CLONE_PARENT 0x00008000
15#define CLONE_THREAD 0x00010000
16#define CLONE_NEWNS 0x00020000
17#define CLONE_SYSVSEM 0x00040000
18#define CLONE_SETTLS 0x00080000
19#define CLONE_PARENT_SETTID 0x00100000
20#define CLONE_CHILD_CLEARTID 0x00200000
21#define CLONE_DETACHED 0x00400000
22#define CLONE_UNTRACED 0x00800000
23#define CLONE_CHILD_SETTID 0x01000000
24#define CLONE_STOPPED 0x02000000
25#define CLONE_NEWUTS 0x04000000
26#define CLONE_NEWIPC 0x08000000
27#define CLONE_NEWUSER 0x10000000
28#define CLONE_NEWPID 0x20000000
29#define CLONE_NEWNET 0x40000000
30
31
32
33
34#define SCHED_NORMAL 0
35#define SCHED_FIFO 1
36#define SCHED_RR 2
37#define SCHED_BATCH 3
38
39#define SCHED_IDLE 5
40
41#ifdef __KERNEL__
42
43struct sched_param {
44 int sched_priority;
45};
46
47#include <asm/param.h>
48
49#include <linux/capability.h>
50#include <linux/threads.h>
51#include <linux/kernel.h>
52#include <linux/types.h>
53#include <linux/timex.h>
54#include <linux/jiffies.h>
55#include <linux/rbtree.h>
56#include <linux/thread_info.h>
57#include <linux/cpumask.h>
58#include <linux/errno.h>
59#include <linux/nodemask.h>
60#include <linux/mm_types.h>
61
62#include <asm/system.h>
63#include <asm/semaphore.h>
64#include <asm/page.h>
65#include <asm/ptrace.h>
66#include <asm/cputime.h>
67
68#include <linux/smp.h>
69#include <linux/sem.h>
70#include <linux/signal.h>
71#include <linux/securebits.h>
72#include <linux/fs_struct.h>
73#include <linux/compiler.h>
74#include <linux/completion.h>
75#include <linux/pid.h>
76#include <linux/percpu.h>
77#include <linux/topology.h>
78#include <linux/proportions.h>
79#include <linux/seccomp.h>
80#include <linux/rcupdate.h>
81#include <linux/futex.h>
82#include <linux/rtmutex.h>
83
84#include <linux/time.h>
85#include <linux/param.h>
86#include <linux/resource.h>
87#include <linux/timer.h>
88#include <linux/hrtimer.h>
89#include <linux/task_io_accounting.h>
90#include <linux/kobject.h>
91
92#include <asm/processor.h>
93
94struct exec_domain;
95struct futex_pi_state;
96struct bio;
97
98
99
100
101
102#define CLONE_KERNEL (CLONE_FS | CLONE_FILES | CLONE_SIGHAND)
103
104
105
106
107
108
109
110
111
112
113
114extern unsigned long avenrun[];
115
116#define FSHIFT 11
117#define FIXED_1 (1<<FSHIFT)
118#define LOAD_FREQ (5*HZ+1)
119#define EXP_1 1884
120#define EXP_5 2014
121#define EXP_15 2037
122
123#define CALC_LOAD(load,exp,n) \
124 load *= exp; \
125 load += n*(FIXED_1-exp); \
126 load >>= FSHIFT;
127
128extern unsigned long total_forks;
129extern int nr_threads;
130DECLARE_PER_CPU(unsigned long, process_counts);
131extern int nr_processes(void);
132extern unsigned long nr_running(void);
133extern unsigned long nr_uninterruptible(void);
134extern unsigned long nr_active(void);
135extern unsigned long nr_iowait(void);
136extern unsigned long weighted_cpuload(const int cpu);
137
138struct seq_file;
139struct cfs_rq;
140struct task_group;
141#ifdef CONFIG_SCHED_DEBUG
142extern void proc_sched_show_task(struct task_struct *p, struct seq_file *m);
143extern void proc_sched_set_task(struct task_struct *p);
144extern void
145print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq);
146#else
147static inline void
148proc_sched_show_task(struct task_struct *p, struct seq_file *m)
149{
150}
151static inline void proc_sched_set_task(struct task_struct *p)
152{
153}
154static inline void
155print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
156{
157}
158#endif
159
160
161
162
163
164
165
166
167
168
169
170#define TASK_RUNNING 0
171#define TASK_INTERRUPTIBLE 1
172#define TASK_UNINTERRUPTIBLE 2
173#define TASK_STOPPED 4
174#define TASK_TRACED 8
175
176#define EXIT_ZOMBIE 16
177#define EXIT_DEAD 32
178
179#define TASK_DEAD 64
180
181#define __set_task_state(tsk, state_value) \
182 do { (tsk)->state = (state_value); } while (0)
183#define set_task_state(tsk, state_value) \
184 set_mb((tsk)->state, (state_value))
185
186
187
188
189
190
191
192
193
194
195
196
197#define __set_current_state(state_value) \
198 do { current->state = (state_value); } while (0)
199#define set_current_state(state_value) \
200 set_mb(current->state, (state_value))
201
202
203#define TASK_COMM_LEN 16
204
205#include <linux/spinlock.h>
206
207
208
209
210
211
212
213extern rwlock_t tasklist_lock;
214extern spinlock_t mmlist_lock;
215
216struct task_struct;
217
218extern void sched_init(void);
219extern void sched_init_smp(void);
220extern void init_idle(struct task_struct *idle, int cpu);
221extern void init_idle_bootup_task(struct task_struct *idle);
222
223extern cpumask_t nohz_cpu_mask;
224#if defined(CONFIG_SMP) && defined(CONFIG_NO_HZ)
225extern int select_nohz_load_balancer(int cpu);
226#else
227static inline int select_nohz_load_balancer(int cpu)
228{
229 return 0;
230}
231#endif
232
233
234
235
236extern void show_state_filter(unsigned long state_filter);
237
238static inline void show_state(void)
239{
240 show_state_filter(0);
241}
242
243extern void show_regs(struct pt_regs *);
244
245
246
247
248
249
250extern void show_stack(struct task_struct *task, unsigned long *sp);
251
252void io_schedule(void);
253long io_schedule_timeout(long timeout);
254
255extern void cpu_init (void);
256extern void trap_init(void);
257extern void account_process_tick(struct task_struct *task, int user);
258extern void update_process_times(int user);
259extern void scheduler_tick(void);
260
261#ifdef CONFIG_DETECT_SOFTLOCKUP
262extern void softlockup_tick(void);
263extern void spawn_softlockup_task(void);
264extern void touch_softlockup_watchdog(void);
265extern void touch_all_softlockup_watchdogs(void);
266extern int softlockup_thresh;
267#else
268static inline void softlockup_tick(void)
269{
270}
271static inline void spawn_softlockup_task(void)
272{
273}
274static inline void touch_softlockup_watchdog(void)
275{
276}
277static inline void touch_all_softlockup_watchdogs(void)
278{
279}
280#endif
281
282
283
284#define __sched __attribute__((__section__(".sched.text")))
285
286
287extern char __sched_text_start[], __sched_text_end[];
288
289
290extern int in_sched_functions(unsigned long addr);
291
292#define MAX_SCHEDULE_TIMEOUT LONG_MAX
293extern signed long FASTCALL(schedule_timeout(signed long timeout));
294extern signed long schedule_timeout_interruptible(signed long timeout);
295extern signed long schedule_timeout_uninterruptible(signed long timeout);
296asmlinkage void schedule(void);
297
298struct nsproxy;
299struct user_namespace;
300
301
302#define DEFAULT_MAX_MAP_COUNT 65536
303
304extern int sysctl_max_map_count;
305
306#include <linux/aio.h>
307
308extern unsigned long
309arch_get_unmapped_area(struct file *, unsigned long, unsigned long,
310 unsigned long, unsigned long);
311extern unsigned long
312arch_get_unmapped_area_topdown(struct file *filp, unsigned long addr,
313 unsigned long len, unsigned long pgoff,
314 unsigned long flags);
315extern void arch_unmap_area(struct mm_struct *, unsigned long);
316extern void arch_unmap_area_topdown(struct mm_struct *, unsigned long);
317
318#if NR_CPUS >= CONFIG_SPLIT_PTLOCK_CPUS
319
320
321
322
323#define set_mm_counter(mm, member, value) atomic_long_set(&(mm)->_##member, value)
324#define get_mm_counter(mm, member) ((unsigned long)atomic_long_read(&(mm)->_##member))
325#define add_mm_counter(mm, member, value) atomic_long_add(value, &(mm)->_##member)
326#define inc_mm_counter(mm, member) atomic_long_inc(&(mm)->_##member)
327#define dec_mm_counter(mm, member) atomic_long_dec(&(mm)->_##member)
328
329#else
330
331
332
333
334#define set_mm_counter(mm, member, value) (mm)->_##member = (value)
335#define get_mm_counter(mm, member) ((mm)->_##member)
336#define add_mm_counter(mm, member, value) (mm)->_##member += (value)
337#define inc_mm_counter(mm, member) (mm)->_##member++
338#define dec_mm_counter(mm, member) (mm)->_##member--
339
340#endif
341
342#define get_mm_rss(mm) \
343 (get_mm_counter(mm, file_rss) + get_mm_counter(mm, anon_rss))
344#define update_hiwater_rss(mm) do { \
345 unsigned long _rss = get_mm_rss(mm); \
346 if ((mm)->hiwater_rss < _rss) \
347 (mm)->hiwater_rss = _rss; \
348} while (0)
349#define update_hiwater_vm(mm) do { \
350 if ((mm)->hiwater_vm < (mm)->total_vm) \
351 (mm)->hiwater_vm = (mm)->total_vm; \
352} while (0)
353
354extern void set_dumpable(struct mm_struct *mm, int value);
355extern int get_dumpable(struct mm_struct *mm);
356
357
358
359#define MMF_DUMPABLE 0
360#define MMF_DUMP_SECURELY 1
361#define MMF_DUMPABLE_BITS 2
362
363
364#define MMF_DUMP_ANON_PRIVATE 2
365#define MMF_DUMP_ANON_SHARED 3
366#define MMF_DUMP_MAPPED_PRIVATE 4
367#define MMF_DUMP_MAPPED_SHARED 5
368#define MMF_DUMP_ELF_HEADERS 6
369#define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS
370#define MMF_DUMP_FILTER_BITS 5
371#define MMF_DUMP_FILTER_MASK \
372 (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)
373#define MMF_DUMP_FILTER_DEFAULT \
374 ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED))
375
376struct sighand_struct {
377 atomic_t count;
378 struct k_sigaction action[_NSIG];
379 spinlock_t siglock;
380 wait_queue_head_t signalfd_wqh;
381};
382
383struct pacct_struct {
384 int ac_flag;
385 long ac_exitcode;
386 unsigned long ac_mem;
387 cputime_t ac_utime, ac_stime;
388 unsigned long ac_minflt, ac_majflt;
389};
390
391
392
393
394
395
396
397
398struct signal_struct {
399 atomic_t count;
400 atomic_t live;
401
402 wait_queue_head_t wait_chldexit;
403
404
405 struct task_struct *curr_target;
406
407
408 struct sigpending shared_pending;
409
410
411 int group_exit_code;
412
413
414
415
416
417 struct task_struct *group_exit_task;
418 int notify_count;
419
420
421 int group_stop_count;
422 unsigned int flags;
423
424
425 struct list_head posix_timers;
426
427
428 struct hrtimer real_timer;
429 struct task_struct *tsk;
430 ktime_t it_real_incr;
431
432
433 cputime_t it_prof_expires, it_virt_expires;
434 cputime_t it_prof_incr, it_virt_incr;
435
436
437
438
439
440
441
442
443 union {
444 pid_t pgrp __deprecated;
445 pid_t __pgrp;
446 };
447
448 struct pid *tty_old_pgrp;
449
450 union {
451 pid_t session __deprecated;
452 pid_t __session;
453 };
454
455
456 int leader;
457
458 struct tty_struct *tty;
459
460
461
462
463
464
465
466 cputime_t utime, stime, cutime, cstime;
467 cputime_t gtime;
468 cputime_t cgtime;
469 unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
470 unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
471 unsigned long inblock, oublock, cinblock, coublock;
472
473
474
475
476
477
478
479 unsigned long long sum_sched_runtime;
480
481
482
483
484
485
486
487
488
489
490 struct rlimit rlim[RLIM_NLIMITS];
491
492 struct list_head cpu_timers[3];
493
494
495
496#ifdef CONFIG_KEYS
497 struct key *session_keyring;
498 struct key *process_keyring;
499#endif
500#ifdef CONFIG_BSD_PROCESS_ACCT
501 struct pacct_struct pacct;
502#endif
503#ifdef CONFIG_TASKSTATS
504 struct taskstats *stats;
505#endif
506#ifdef CONFIG_AUDIT
507 unsigned audit_tty;
508 struct tty_audit_buf *tty_audit_buf;
509#endif
510};
511
512
513#ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW
514# define __ARCH_WANT_UNLOCKED_CTXSW
515#endif
516
517
518
519
520#define SIGNAL_STOP_STOPPED 0x00000001
521#define SIGNAL_STOP_DEQUEUED 0x00000002
522#define SIGNAL_STOP_CONTINUED 0x00000004
523#define SIGNAL_GROUP_EXIT 0x00000008
524
525
526
527
528struct user_struct {
529 atomic_t __count;
530 atomic_t processes;
531 atomic_t files;
532 atomic_t sigpending;
533#ifdef CONFIG_INOTIFY_USER
534 atomic_t inotify_watches;
535 atomic_t inotify_devs;
536#endif
537#ifdef CONFIG_POSIX_MQUEUE
538
539 unsigned long mq_bytes;
540#endif
541 unsigned long locked_shm;
542
543#ifdef CONFIG_KEYS
544 struct key *uid_keyring;
545 struct key *session_keyring;
546#endif
547
548
549 struct hlist_node uidhash_node;
550 uid_t uid;
551
552#ifdef CONFIG_FAIR_USER_SCHED
553 struct task_group *tg;
554#ifdef CONFIG_SYSFS
555 struct kset kset;
556 struct subsys_attribute user_attr;
557 struct work_struct work;
558#endif
559#endif
560};
561
562#ifdef CONFIG_FAIR_USER_SCHED
563extern int uids_kobject_init(void);
564#else
565static inline int uids_kobject_init(void) { return 0; }
566#endif
567
568extern struct user_struct *find_user(uid_t);
569
570extern struct user_struct root_user;
571#define INIT_USER (&root_user)
572
573struct backing_dev_info;
574struct reclaim_state;
575
576#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
577struct sched_info {
578
579 unsigned long pcount;
580 unsigned long long cpu_time,
581 run_delay;
582
583
584 unsigned long long last_arrival,
585 last_queued;
586#ifdef CONFIG_SCHEDSTATS
587
588 unsigned int bkl_count;
589#endif
590};
591#endif
592
593#ifdef CONFIG_SCHEDSTATS
594extern const struct file_operations proc_schedstat_operations;
595#endif
596
597#ifdef CONFIG_TASK_DELAY_ACCT
598struct task_delay_info {
599 spinlock_t lock;
600 unsigned int flags;
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617 struct timespec blkio_start, blkio_end;
618 u64 blkio_delay;
619 u64 swapin_delay;
620 u32 blkio_count;
621
622 u32 swapin_count;
623
624};
625#endif
626
627static inline int sched_info_on(void)
628{
629#ifdef CONFIG_SCHEDSTATS
630 return 1;
631#elif defined(CONFIG_TASK_DELAY_ACCT)
632 extern int delayacct_on;
633 return delayacct_on;
634#else
635 return 0;
636#endif
637}
638
639enum cpu_idle_type {
640 CPU_IDLE,
641 CPU_NOT_IDLE,
642 CPU_NEWLY_IDLE,
643 CPU_MAX_IDLE_TYPES
644};
645
646
647
648
649
650
651
652
653#define SCHED_LOAD_SHIFT 10
654#define SCHED_LOAD_SCALE (1L << SCHED_LOAD_SHIFT)
655
656#define SCHED_LOAD_SCALE_FUZZ SCHED_LOAD_SCALE
657
658#ifdef CONFIG_SMP
659#define SD_LOAD_BALANCE 1
660#define SD_BALANCE_NEWIDLE 2
661#define SD_BALANCE_EXEC 4
662#define SD_BALANCE_FORK 8
663#define SD_WAKE_IDLE 16
664#define SD_WAKE_AFFINE 32
665#define SD_WAKE_BALANCE 64
666#define SD_SHARE_CPUPOWER 128
667#define SD_POWERSAVINGS_BALANCE 256
668#define SD_SHARE_PKG_RESOURCES 512
669#define SD_SERIALIZE 1024
670
671#define BALANCE_FOR_MC_POWER \
672 (sched_smt_power_savings ? SD_POWERSAVINGS_BALANCE : 0)
673
674#define BALANCE_FOR_PKG_POWER \
675 ((sched_mc_power_savings || sched_smt_power_savings) ? \
676 SD_POWERSAVINGS_BALANCE : 0)
677
678#define test_sd_parent(sd, flag) ((sd->parent && \
679 (sd->parent->flags & flag)) ? 1 : 0)
680
681
682struct sched_group {
683 struct sched_group *next;
684 cpumask_t cpumask;
685
686
687
688
689
690
691 unsigned int __cpu_power;
692
693
694
695
696 u32 reciprocal_cpu_power;
697};
698
699struct sched_domain {
700
701 struct sched_domain *parent;
702 struct sched_domain *child;
703 struct sched_group *groups;
704 cpumask_t span;
705 unsigned long min_interval;
706 unsigned long max_interval;
707 unsigned int busy_factor;
708 unsigned int imbalance_pct;
709 unsigned int cache_nice_tries;
710 unsigned int busy_idx;
711 unsigned int idle_idx;
712 unsigned int newidle_idx;
713 unsigned int wake_idx;
714 unsigned int forkexec_idx;
715 int flags;
716
717
718 unsigned long last_balance;
719 unsigned int balance_interval;
720 unsigned int nr_balance_failed;
721
722#ifdef CONFIG_SCHEDSTATS
723
724 unsigned int lb_count[CPU_MAX_IDLE_TYPES];
725 unsigned int lb_failed[CPU_MAX_IDLE_TYPES];
726 unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];
727 unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];
728 unsigned int lb_gained[CPU_MAX_IDLE_TYPES];
729 unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];
730 unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];
731 unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];
732
733
734 unsigned int alb_count;
735 unsigned int alb_failed;
736 unsigned int alb_pushed;
737
738
739 unsigned int sbe_count;
740 unsigned int sbe_balanced;
741 unsigned int sbe_pushed;
742
743
744 unsigned int sbf_count;
745 unsigned int sbf_balanced;
746 unsigned int sbf_pushed;
747
748
749 unsigned int ttwu_wake_remote;
750 unsigned int ttwu_move_affine;
751 unsigned int ttwu_move_balance;
752#endif
753};
754
755extern void partition_sched_domains(int ndoms_new, cpumask_t *doms_new);
756
757#endif
758
759
760
761
762
763
764
765static inline int above_background_load(void)
766{
767 unsigned long cpu;
768
769 for_each_online_cpu(cpu) {
770 if (weighted_cpuload(cpu) >= SCHED_LOAD_SCALE)
771 return 1;
772 }
773 return 0;
774}
775
776struct io_context;
777#define NGROUPS_SMALL 32
778#define NGROUPS_PER_BLOCK ((int)(PAGE_SIZE / sizeof(gid_t)))
779struct group_info {
780 int ngroups;
781 atomic_t usage;
782 gid_t small_block[NGROUPS_SMALL];
783 int nblocks;
784 gid_t *blocks[0];
785};
786
787
788
789
790
791
792
793#define get_group_info(group_info) do { \
794 atomic_inc(&(group_info)->usage); \
795} while (0)
796
797#define put_group_info(group_info) do { \
798 if (atomic_dec_and_test(&(group_info)->usage)) \
799 groups_free(group_info); \
800} while (0)
801
802extern struct group_info *groups_alloc(int gidsetsize);
803extern void groups_free(struct group_info *group_info);
804extern int set_current_groups(struct group_info *group_info);
805extern int groups_search(struct group_info *group_info, gid_t grp);
806
807#define GROUP_AT(gi, i) \
808 ((gi)->blocks[(i)/NGROUPS_PER_BLOCK][(i)%NGROUPS_PER_BLOCK])
809
810#ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
811extern void prefetch_stack(struct task_struct *t);
812#else
813static inline void prefetch_stack(struct task_struct *t) { }
814#endif
815
816struct audit_context;
817struct mempolicy;
818struct pipe_inode_info;
819struct uts_namespace;
820
821struct rq;
822struct sched_domain;
823
824struct sched_class {
825 const struct sched_class *next;
826
827 void (*enqueue_task) (struct rq *rq, struct task_struct *p, int wakeup);
828 void (*dequeue_task) (struct rq *rq, struct task_struct *p, int sleep);
829 void (*yield_task) (struct rq *rq);
830
831 void (*check_preempt_curr) (struct rq *rq, struct task_struct *p);
832
833 struct task_struct * (*pick_next_task) (struct rq *rq);
834 void (*put_prev_task) (struct rq *rq, struct task_struct *p);
835
836#ifdef CONFIG_SMP
837 unsigned long (*load_balance) (struct rq *this_rq, int this_cpu,
838 struct rq *busiest, unsigned long max_load_move,
839 struct sched_domain *sd, enum cpu_idle_type idle,
840 int *all_pinned, int *this_best_prio);
841
842 int (*move_one_task) (struct rq *this_rq, int this_cpu,
843 struct rq *busiest, struct sched_domain *sd,
844 enum cpu_idle_type idle);
845#endif
846
847 void (*set_curr_task) (struct rq *rq);
848 void (*task_tick) (struct rq *rq, struct task_struct *p);
849 void (*task_new) (struct rq *rq, struct task_struct *p);
850};
851
852struct load_weight {
853 unsigned long weight, inv_weight;
854};
855
856
857
858
859
860
861
862
863
864
865
866struct sched_entity {
867 struct load_weight load;
868 struct rb_node run_node;
869 unsigned int on_rq;
870
871 u64 exec_start;
872 u64 sum_exec_runtime;
873 u64 vruntime;
874 u64 prev_sum_exec_runtime;
875
876#ifdef CONFIG_SCHEDSTATS
877 u64 wait_start;
878 u64 wait_max;
879
880 u64 sleep_start;
881 u64 sleep_max;
882 s64 sum_sleep_runtime;
883
884 u64 block_start;
885 u64 block_max;
886 u64 exec_max;
887 u64 slice_max;
888
889 u64 nr_migrations;
890 u64 nr_migrations_cold;
891 u64 nr_failed_migrations_affine;
892 u64 nr_failed_migrations_running;
893 u64 nr_failed_migrations_hot;
894 u64 nr_forced_migrations;
895 u64 nr_forced2_migrations;
896
897 u64 nr_wakeups;
898 u64 nr_wakeups_sync;
899 u64 nr_wakeups_migrate;
900 u64 nr_wakeups_local;
901 u64 nr_wakeups_remote;
902 u64 nr_wakeups_affine;
903 u64 nr_wakeups_affine_attempts;
904 u64 nr_wakeups_passive;
905 u64 nr_wakeups_idle;
906#endif
907
908#ifdef CONFIG_FAIR_GROUP_SCHED
909 struct sched_entity *parent;
910
911 struct cfs_rq *cfs_rq;
912
913 struct cfs_rq *my_q;
914#endif
915};
916
917struct task_struct {
918 volatile long state;
919 void *stack;
920 atomic_t usage;
921 unsigned int flags;
922 unsigned int ptrace;
923
924 int lock_depth;
925
926#ifdef CONFIG_SMP
927#ifdef __ARCH_WANT_UNLOCKED_CTXSW
928 int oncpu;
929#endif
930#endif
931
932 int prio, static_prio, normal_prio;
933 struct list_head run_list;
934 const struct sched_class *sched_class;
935 struct sched_entity se;
936
937#ifdef CONFIG_PREEMPT_NOTIFIERS
938
939 struct hlist_head preempt_notifiers;
940#endif
941
942 unsigned short ioprio;
943
944
945
946
947
948
949
950
951 unsigned char fpu_counter;
952 s8 oomkilladj;
953#ifdef CONFIG_BLK_DEV_IO_TRACE
954 unsigned int btrace_seq;
955#endif
956
957 unsigned int policy;
958 cpumask_t cpus_allowed;
959 unsigned int time_slice;
960
961#if defined(CONFIG_SCHEDSTATS) || defined(CONFIG_TASK_DELAY_ACCT)
962 struct sched_info sched_info;
963#endif
964
965 struct list_head tasks;
966
967
968
969
970 struct list_head ptrace_children;
971 struct list_head ptrace_list;
972
973 struct mm_struct *mm, *active_mm;
974
975
976 struct linux_binfmt *binfmt;
977 int exit_state;
978 int exit_code, exit_signal;
979 int pdeath_signal;
980
981 unsigned int personality;
982 unsigned did_exec:1;
983 pid_t pid;
984 pid_t tgid;
985
986#ifdef CONFIG_CC_STACKPROTECTOR
987
988 unsigned long stack_canary;
989#endif
990
991
992
993
994
995 struct task_struct *real_parent;
996 struct task_struct *parent;
997
998
999
1000
1001 struct list_head children;
1002 struct list_head sibling;
1003 struct task_struct *group_leader;
1004
1005
1006 struct pid_link pids[PIDTYPE_MAX];
1007 struct list_head thread_group;
1008
1009 struct completion *vfork_done;
1010 int __user *set_child_tid;
1011 int __user *clear_child_tid;
1012
1013 unsigned int rt_priority;
1014 cputime_t utime, stime, utimescaled, stimescaled;
1015 cputime_t gtime;
1016 cputime_t prev_utime, prev_stime;
1017 unsigned long nvcsw, nivcsw;
1018 struct timespec start_time;
1019 struct timespec real_start_time;
1020
1021 unsigned long min_flt, maj_flt;
1022
1023 cputime_t it_prof_expires, it_virt_expires;
1024 unsigned long long it_sched_expires;
1025 struct list_head cpu_timers[3];
1026
1027
1028 uid_t uid,euid,suid,fsuid;
1029 gid_t gid,egid,sgid,fsgid;
1030 struct group_info *group_info;
1031 kernel_cap_t cap_effective, cap_inheritable, cap_permitted;
1032 unsigned keep_capabilities:1;
1033 struct user_struct *user;
1034#ifdef CONFIG_KEYS
1035 struct key *request_key_auth;
1036 struct key *thread_keyring;
1037 unsigned char jit_keyring;
1038#endif
1039 char comm[TASK_COMM_LEN];
1040
1041
1042
1043
1044 int link_count, total_link_count;
1045#ifdef CONFIG_SYSVIPC
1046
1047 struct sysv_sem sysvsem;
1048#endif
1049
1050 struct thread_struct thread;
1051
1052 struct fs_struct *fs;
1053
1054 struct files_struct *files;
1055
1056 struct nsproxy *nsproxy;
1057
1058 struct signal_struct *signal;
1059 struct sighand_struct *sighand;
1060
1061 sigset_t blocked, real_blocked;
1062 sigset_t saved_sigmask;
1063 struct sigpending pending;
1064
1065 unsigned long sas_ss_sp;
1066 size_t sas_ss_size;
1067 int (*notifier)(void *priv);
1068 void *notifier_data;
1069 sigset_t *notifier_mask;
1070#ifdef CONFIG_SECURITY
1071 void *security;
1072#endif
1073 struct audit_context *audit_context;
1074 seccomp_t seccomp;
1075
1076
1077 u32 parent_exec_id;
1078 u32 self_exec_id;
1079
1080 spinlock_t alloc_lock;
1081
1082
1083 spinlock_t pi_lock;
1084
1085#ifdef CONFIG_RT_MUTEXES
1086
1087 struct plist_head pi_waiters;
1088
1089 struct rt_mutex_waiter *pi_blocked_on;
1090#endif
1091
1092#ifdef CONFIG_DEBUG_MUTEXES
1093
1094 struct mutex_waiter *blocked_on;
1095#endif
1096#ifdef CONFIG_TRACE_IRQFLAGS
1097 unsigned int irq_events;
1098 int hardirqs_enabled;
1099 unsigned long hardirq_enable_ip;
1100 unsigned int hardirq_enable_event;
1101 unsigned long hardirq_disable_ip;
1102 unsigned int hardirq_disable_event;
1103 int softirqs_enabled;
1104 unsigned long softirq_disable_ip;
1105 unsigned int softirq_disable_event;
1106 unsigned long softirq_enable_ip;
1107 unsigned int softirq_enable_event;
1108 int hardirq_context;
1109 int softirq_context;
1110#endif
1111#ifdef CONFIG_LOCKDEP
1112# define MAX_LOCK_DEPTH 30UL
1113 u64 curr_chain_key;
1114 int lockdep_depth;
1115 struct held_lock held_locks[MAX_LOCK_DEPTH];
1116 unsigned int lockdep_recursion;
1117#endif
1118
1119
1120 void *journal_info;
1121
1122
1123 struct bio *bio_list, **bio_tail;
1124
1125
1126 struct reclaim_state *reclaim_state;
1127
1128 struct backing_dev_info *backing_dev_info;
1129
1130 struct io_context *io_context;
1131
1132 unsigned long ptrace_message;
1133 siginfo_t *last_siginfo;
1134#ifdef CONFIG_TASK_XACCT
1135
1136 u64 rchar, wchar, syscr, syscw;
1137#endif
1138 struct task_io_accounting ioac;
1139#if defined(CONFIG_TASK_XACCT)
1140 u64 acct_rss_mem1;
1141 u64 acct_vm_mem1;
1142 cputime_t acct_stimexpd;
1143#endif
1144#ifdef CONFIG_NUMA
1145 struct mempolicy *mempolicy;
1146 short il_next;
1147#endif
1148#ifdef CONFIG_CPUSETS
1149 nodemask_t mems_allowed;
1150 int cpuset_mems_generation;
1151 int cpuset_mem_spread_rotor;
1152#endif
1153#ifdef CONFIG_CGROUPS
1154
1155 struct css_set *cgroups;
1156
1157 struct list_head cg_list;
1158#endif
1159#ifdef CONFIG_FUTEX
1160 struct robust_list_head __user *robust_list;
1161#ifdef CONFIG_COMPAT
1162 struct compat_robust_list_head __user *compat_robust_list;
1163#endif
1164 struct list_head pi_state_list;
1165 struct futex_pi_state *pi_state_cache;
1166#endif
1167 atomic_t fs_excl;
1168 struct rcu_head rcu;
1169
1170
1171
1172
1173 struct pipe_inode_info *splice_pipe;
1174#ifdef CONFIG_TASK_DELAY_ACCT
1175 struct task_delay_info *delays;
1176#endif
1177#ifdef CONFIG_FAULT_INJECTION
1178 int make_it_fail;
1179#endif
1180 struct prop_local_single dirties;
1181};
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196#define MAX_USER_RT_PRIO 100
1197#define MAX_RT_PRIO MAX_USER_RT_PRIO
1198
1199#define MAX_PRIO (MAX_RT_PRIO + 40)
1200#define DEFAULT_PRIO (MAX_RT_PRIO + 20)
1201
1202static inline int rt_prio(int prio)
1203{
1204 if (unlikely(prio < MAX_RT_PRIO))
1205 return 1;
1206 return 0;
1207}
1208
1209static inline int rt_task(struct task_struct *p)
1210{
1211 return rt_prio(p->prio);
1212}
1213
1214static inline void set_task_session(struct task_struct *tsk, pid_t session)
1215{
1216 tsk->signal->__session = session;
1217}
1218
1219static inline void set_task_pgrp(struct task_struct *tsk, pid_t pgrp)
1220{
1221 tsk->signal->__pgrp = pgrp;
1222}
1223
1224static inline struct pid *task_pid(struct task_struct *task)
1225{
1226 return task->pids[PIDTYPE_PID].pid;
1227}
1228
1229static inline struct pid *task_tgid(struct task_struct *task)
1230{
1231 return task->group_leader->pids[PIDTYPE_PID].pid;
1232}
1233
1234static inline struct pid *task_pgrp(struct task_struct *task)
1235{
1236 return task->group_leader->pids[PIDTYPE_PGID].pid;
1237}
1238
1239static inline struct pid *task_session(struct task_struct *task)
1240{
1241 return task->group_leader->pids[PIDTYPE_SID].pid;
1242}
1243
1244struct pid_namespace;
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261static inline pid_t task_pid_nr(struct task_struct *tsk)
1262{
1263 return tsk->pid;
1264}
1265
1266pid_t task_pid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
1267
1268static inline pid_t task_pid_vnr(struct task_struct *tsk)
1269{
1270 return pid_vnr(task_pid(tsk));
1271}
1272
1273
1274static inline pid_t task_tgid_nr(struct task_struct *tsk)
1275{
1276 return tsk->tgid;
1277}
1278
1279pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
1280
1281static inline pid_t task_tgid_vnr(struct task_struct *tsk)
1282{
1283 return pid_vnr(task_tgid(tsk));
1284}
1285
1286
1287static inline pid_t task_pgrp_nr(struct task_struct *tsk)
1288{
1289 return tsk->signal->__pgrp;
1290}
1291
1292pid_t task_pgrp_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
1293
1294static inline pid_t task_pgrp_vnr(struct task_struct *tsk)
1295{
1296 return pid_vnr(task_pgrp(tsk));
1297}
1298
1299
1300static inline pid_t task_session_nr(struct task_struct *tsk)
1301{
1302 return tsk->signal->__session;
1303}
1304
1305pid_t task_session_nr_ns(struct task_struct *tsk, struct pid_namespace *ns);
1306
1307static inline pid_t task_session_vnr(struct task_struct *tsk)
1308{
1309 return pid_vnr(task_session(tsk));
1310}
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321static inline int pid_alive(struct task_struct *p)
1322{
1323 return p->pids[PIDTYPE_PID].pid != NULL;
1324}
1325
1326
1327
1328
1329
1330
1331
1332static inline int is_global_init(struct task_struct *tsk)
1333{
1334 return tsk->pid == 1;
1335}
1336
1337
1338
1339
1340
1341extern int is_container_init(struct task_struct *tsk);
1342
1343extern struct pid *cad_pid;
1344
1345extern void free_task(struct task_struct *tsk);
1346#define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
1347
1348extern void __put_task_struct(struct task_struct *t);
1349
1350static inline void put_task_struct(struct task_struct *t)
1351{
1352 if (atomic_dec_and_test(&t->usage))
1353 __put_task_struct(t);
1354}
1355
1356
1357
1358
1359#define PF_ALIGNWARN 0x00000001
1360
1361#define PF_STARTING 0x00000002
1362#define PF_EXITING 0x00000004
1363#define PF_EXITPIDONE 0x00000008
1364#define PF_VCPU 0x00000010
1365#define PF_FORKNOEXEC 0x00000040
1366#define PF_SUPERPRIV 0x00000100
1367#define PF_DUMPCORE 0x00000200
1368#define PF_SIGNALED 0x00000400
1369#define PF_MEMALLOC 0x00000800
1370#define PF_FLUSHER 0x00001000
1371#define PF_USED_MATH 0x00002000
1372#define PF_NOFREEZE 0x00008000
1373#define PF_FROZEN 0x00010000
1374#define PF_FSTRANS 0x00020000
1375#define PF_KSWAPD 0x00040000
1376#define PF_SWAPOFF 0x00080000
1377#define PF_LESS_THROTTLE 0x00100000
1378#define PF_BORROWED_MM 0x00200000
1379#define PF_RANDOMIZE 0x00400000
1380#define PF_SWAPWRITE 0x00800000
1381#define PF_SPREAD_PAGE 0x01000000
1382#define PF_SPREAD_SLAB 0x02000000
1383#define PF_MEMPOLICY 0x10000000
1384#define PF_MUTEX_TESTER 0x20000000
1385#define PF_FREEZER_SKIP 0x40000000
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398#define clear_stopped_child_used_math(child) do { (child)->flags &= ~PF_USED_MATH; } while (0)
1399#define set_stopped_child_used_math(child) do { (child)->flags |= PF_USED_MATH; } while (0)
1400#define clear_used_math() clear_stopped_child_used_math(current)
1401#define set_used_math() set_stopped_child_used_math(current)
1402#define conditional_stopped_child_used_math(condition, child) \
1403 do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= (condition) ? PF_USED_MATH : 0; } while (0)
1404#define conditional_used_math(condition) \
1405 conditional_stopped_child_used_math(condition, current)
1406#define copy_to_stopped_child_used_math(child) \
1407 do { (child)->flags &= ~PF_USED_MATH, (child)->flags |= current->flags & PF_USED_MATH; } while (0)
1408
1409#define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
1410#define used_math() tsk_used_math(current)
1411
1412#ifdef CONFIG_SMP
1413extern int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask);
1414#else
1415static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
1416{
1417 if (!cpu_isset(0, new_mask))
1418 return -EINVAL;
1419 return 0;
1420}
1421#endif
1422
1423extern unsigned long long sched_clock(void);
1424
1425
1426
1427
1428
1429extern unsigned long long cpu_clock(int cpu);
1430
1431extern unsigned long long
1432task_sched_runtime(struct task_struct *task);
1433
1434
1435#ifdef CONFIG_SMP
1436extern void sched_exec(void);
1437#else
1438#define sched_exec() {}
1439#endif
1440
1441extern void sched_clock_idle_sleep_event(void);
1442extern void sched_clock_idle_wakeup_event(u64 delta_ns);
1443
1444#ifdef CONFIG_HOTPLUG_CPU
1445extern void idle_task_exit(void);
1446#else
1447static inline void idle_task_exit(void) {}
1448#endif
1449
1450extern void sched_idle_next(void);
1451
1452#ifdef CONFIG_SCHED_DEBUG
1453extern unsigned int sysctl_sched_latency;
1454extern unsigned int sysctl_sched_min_granularity;
1455extern unsigned int sysctl_sched_wakeup_granularity;
1456extern unsigned int sysctl_sched_batch_wakeup_granularity;
1457extern unsigned int sysctl_sched_child_runs_first;
1458extern unsigned int sysctl_sched_features;
1459extern unsigned int sysctl_sched_migration_cost;
1460extern unsigned int sysctl_sched_nr_migrate;
1461
1462int sched_nr_latency_handler(struct ctl_table *table, int write,
1463 struct file *file, void __user *buffer, size_t *length,
1464 loff_t *ppos);
1465#endif
1466
1467extern unsigned int sysctl_sched_compat_yield;
1468
1469#ifdef CONFIG_RT_MUTEXES
1470extern int rt_mutex_getprio(struct task_struct *p);
1471extern void rt_mutex_setprio(struct task_struct *p, int prio);
1472extern void rt_mutex_adjust_pi(struct task_struct *p);
1473#else
1474static inline int rt_mutex_getprio(struct task_struct *p)
1475{
1476 return p->normal_prio;
1477}
1478# define rt_mutex_adjust_pi(p) do { } while (0)
1479#endif
1480
1481extern void set_user_nice(struct task_struct *p, long nice);
1482extern int task_prio(const struct task_struct *p);
1483extern int task_nice(const struct task_struct *p);
1484extern int can_nice(const struct task_struct *p, const int nice);
1485extern int task_curr(const struct task_struct *p);
1486extern int idle_cpu(int cpu);
1487extern int sched_setscheduler(struct task_struct *, int, struct sched_param *);
1488extern struct task_struct *idle_task(int cpu);
1489extern struct task_struct *curr_task(int cpu);
1490extern void set_curr_task(int cpu, struct task_struct *p);
1491
1492void yield(void);
1493
1494
1495
1496
1497extern struct exec_domain default_exec_domain;
1498
1499union thread_union {
1500 struct thread_info thread_info;
1501 unsigned long stack[THREAD_SIZE/sizeof(long)];
1502};
1503
1504#ifndef __HAVE_ARCH_KSTACK_END
1505static inline int kstack_end(void *addr)
1506{
1507
1508
1509
1510 return !(((unsigned long)addr+sizeof(void*)-1) & (THREAD_SIZE-sizeof(void*)));
1511}
1512#endif
1513
1514extern union thread_union init_thread_union;
1515extern struct task_struct init_task;
1516
1517extern struct mm_struct init_mm;
1518
1519extern struct pid_namespace init_pid_ns;
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537extern struct task_struct *find_task_by_pid_type_ns(int type, int pid,
1538 struct pid_namespace *ns);
1539
1540extern struct task_struct *find_task_by_pid(pid_t nr);
1541extern struct task_struct *find_task_by_vpid(pid_t nr);
1542extern struct task_struct *find_task_by_pid_ns(pid_t nr,
1543 struct pid_namespace *ns);
1544
1545extern void __set_special_pids(pid_t session, pid_t pgrp);
1546
1547
1548extern struct user_struct * alloc_uid(struct user_namespace *, uid_t);
1549static inline struct user_struct *get_uid(struct user_struct *u)
1550{
1551 atomic_inc(&u->__count);
1552 return u;
1553}
1554extern void free_uid(struct user_struct *);
1555extern void switch_uid(struct user_struct *);
1556extern void release_uids(struct user_namespace *ns);
1557
1558#include <asm/current.h>
1559
1560extern void do_timer(unsigned long ticks);
1561
1562extern int FASTCALL(wake_up_state(struct task_struct * tsk, unsigned int state));
1563extern int FASTCALL(wake_up_process(struct task_struct * tsk));
1564extern void FASTCALL(wake_up_new_task(struct task_struct * tsk,
1565 unsigned long clone_flags));
1566#ifdef CONFIG_SMP
1567 extern void kick_process(struct task_struct *tsk);
1568#else
1569 static inline void kick_process(struct task_struct *tsk) { }
1570#endif
1571extern void sched_fork(struct task_struct *p, int clone_flags);
1572extern void sched_dead(struct task_struct *p);
1573
1574extern int in_group_p(gid_t);
1575extern int in_egroup_p(gid_t);
1576
1577extern void proc_caches_init(void);
1578extern void flush_signals(struct task_struct *);
1579extern void ignore_signals(struct task_struct *);
1580extern void flush_signal_handlers(struct task_struct *, int force_default);
1581extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
1582
1583static inline int dequeue_signal_lock(struct task_struct *tsk, sigset_t *mask, siginfo_t *info)
1584{
1585 unsigned long flags;
1586 int ret;
1587
1588 spin_lock_irqsave(&tsk->sighand->siglock, flags);
1589 ret = dequeue_signal(tsk, mask, info);
1590 spin_unlock_irqrestore(&tsk->sighand->siglock, flags);
1591
1592 return ret;
1593}
1594
1595extern void block_all_signals(int (*notifier)(void *priv), void *priv,
1596 sigset_t *mask);
1597extern void unblock_all_signals(void);
1598extern void release_task(struct task_struct * p);
1599extern int send_sig_info(int, struct siginfo *, struct task_struct *);
1600extern int send_group_sig_info(int, struct siginfo *, struct task_struct *);
1601extern int force_sigsegv(int, struct task_struct *);
1602extern int force_sig_info(int, struct siginfo *, struct task_struct *);
1603extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
1604extern int kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
1605extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
1606extern int kill_pid_info_as_uid(int, struct siginfo *, struct pid *, uid_t, uid_t, u32);
1607extern int kill_pgrp(struct pid *pid, int sig, int priv);
1608extern int kill_pid(struct pid *pid, int sig, int priv);
1609extern int kill_proc_info(int, struct siginfo *, pid_t);
1610extern void do_notify_parent(struct task_struct *, int);
1611extern void force_sig(int, struct task_struct *);
1612extern void force_sig_specific(int, struct task_struct *);
1613extern int send_sig(int, struct task_struct *, int);
1614extern void zap_other_threads(struct task_struct *p);
1615extern int kill_proc(pid_t, int, int);
1616extern struct sigqueue *sigqueue_alloc(void);
1617extern void sigqueue_free(struct sigqueue *);
1618extern int send_sigqueue(int, struct sigqueue *, struct task_struct *);
1619extern int send_group_sigqueue(int, struct sigqueue *, struct task_struct *);
1620extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
1621extern int do_sigaltstack(const stack_t __user *, stack_t __user *, unsigned long);
1622
1623static inline int kill_cad_pid(int sig, int priv)
1624{
1625 return kill_pid(cad_pid, sig, priv);
1626}
1627
1628
1629#define SEND_SIG_NOINFO ((struct siginfo *) 0)
1630#define SEND_SIG_PRIV ((struct siginfo *) 1)
1631#define SEND_SIG_FORCED ((struct siginfo *) 2)
1632
1633static inline int is_si_special(const struct siginfo *info)
1634{
1635 return info <= SEND_SIG_FORCED;
1636}
1637
1638
1639
1640static inline int on_sig_stack(unsigned long sp)
1641{
1642 return (sp - current->sas_ss_sp < current->sas_ss_size);
1643}
1644
1645static inline int sas_ss_flags(unsigned long sp)
1646{
1647 return (current->sas_ss_size == 0 ? SS_DISABLE
1648 : on_sig_stack(sp) ? SS_ONSTACK : 0);
1649}
1650
1651
1652
1653
1654extern struct mm_struct * mm_alloc(void);
1655
1656
1657extern void FASTCALL(__mmdrop(struct mm_struct *));
1658static inline void mmdrop(struct mm_struct * mm)
1659{
1660 if (unlikely(atomic_dec_and_test(&mm->mm_count)))
1661 __mmdrop(mm);
1662}
1663
1664
1665extern void mmput(struct mm_struct *);
1666
1667extern struct mm_struct *get_task_mm(struct task_struct *task);
1668
1669extern void mm_release(struct task_struct *, struct mm_struct *);
1670
1671extern int copy_thread(int, unsigned long, unsigned long, unsigned long, struct task_struct *, struct pt_regs *);
1672extern void flush_thread(void);
1673extern void exit_thread(void);
1674
1675extern void exit_files(struct task_struct *);
1676extern void __cleanup_signal(struct signal_struct *);
1677extern void __cleanup_sighand(struct sighand_struct *);
1678extern void exit_itimers(struct signal_struct *);
1679
1680extern NORET_TYPE void do_group_exit(int);
1681
1682extern void daemonize(const char *, ...);
1683extern int allow_signal(int);
1684extern int disallow_signal(int);
1685
1686extern int do_execve(char *, char __user * __user *, char __user * __user *, struct pt_regs *);
1687extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *);
1688struct task_struct *fork_idle(int);
1689
1690extern void set_task_comm(struct task_struct *tsk, char *from);
1691extern void get_task_comm(char *to, struct task_struct *tsk);
1692
1693#ifdef CONFIG_SMP
1694extern void wait_task_inactive(struct task_struct * p);
1695#else
1696#define wait_task_inactive(p) do { } while (0)
1697#endif
1698
1699#define remove_parent(p) list_del_init(&(p)->sibling)
1700#define add_parent(p) list_add_tail(&(p)->sibling,&(p)->parent->children)
1701
1702#define next_task(p) list_entry(rcu_dereference((p)->tasks.next), struct task_struct, tasks)
1703
1704#define for_each_process(p) \
1705 for (p = &init_task ; (p = next_task(p)) != &init_task ; )
1706
1707
1708
1709
1710
1711#define do_each_thread(g, t) \
1712 for (g = t = &init_task ; (g = t = next_task(g)) != &init_task ; ) do
1713
1714#define while_each_thread(g, t) \
1715 while ((t = next_thread(t)) != g)
1716
1717
1718#define thread_group_leader(p) (p == p->group_leader)
1719
1720
1721
1722
1723
1724
1725
1726static inline int has_group_leader_pid(struct task_struct *p)
1727{
1728 return p->pid == p->tgid;
1729}
1730
1731static inline
1732int same_thread_group(struct task_struct *p1, struct task_struct *p2)
1733{
1734 return p1->tgid == p2->tgid;
1735}
1736
1737static inline struct task_struct *next_thread(const struct task_struct *p)
1738{
1739 return list_entry(rcu_dereference(p->thread_group.next),
1740 struct task_struct, thread_group);
1741}
1742
1743static inline int thread_group_empty(struct task_struct *p)
1744{
1745 return list_empty(&p->thread_group);
1746}
1747
1748#define delay_group_leader(p) \
1749 (thread_group_leader(p) && !thread_group_empty(p))
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761static inline void task_lock(struct task_struct *p)
1762{
1763 spin_lock(&p->alloc_lock);
1764}
1765
1766static inline void task_unlock(struct task_struct *p)
1767{
1768 spin_unlock(&p->alloc_lock);
1769}
1770
1771extern struct sighand_struct *lock_task_sighand(struct task_struct *tsk,
1772 unsigned long *flags);
1773
1774static inline void unlock_task_sighand(struct task_struct *tsk,
1775 unsigned long *flags)
1776{
1777 spin_unlock_irqrestore(&tsk->sighand->siglock, *flags);
1778}
1779
1780#ifndef __HAVE_THREAD_FUNCTIONS
1781
1782#define task_thread_info(task) ((struct thread_info *)(task)->stack)
1783#define task_stack_page(task) ((task)->stack)
1784
1785static inline void setup_thread_stack(struct task_struct *p, struct task_struct *org)
1786{
1787 *task_thread_info(p) = *task_thread_info(org);
1788 task_thread_info(p)->task = p;
1789}
1790
1791static inline unsigned long *end_of_stack(struct task_struct *p)
1792{
1793 return (unsigned long *)(task_thread_info(p) + 1);
1794}
1795
1796#endif
1797
1798
1799
1800
1801static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
1802{
1803 set_ti_thread_flag(task_thread_info(tsk), flag);
1804}
1805
1806static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
1807{
1808 clear_ti_thread_flag(task_thread_info(tsk), flag);
1809}
1810
1811static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
1812{
1813 return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
1814}
1815
1816static inline int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
1817{
1818 return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
1819}
1820
1821static inline int test_tsk_thread_flag(struct task_struct *tsk, int flag)
1822{
1823 return test_ti_thread_flag(task_thread_info(tsk), flag);
1824}
1825
1826static inline void set_tsk_need_resched(struct task_struct *tsk)
1827{
1828 set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
1829}
1830
1831static inline void clear_tsk_need_resched(struct task_struct *tsk)
1832{
1833 clear_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
1834}
1835
1836static inline int signal_pending(struct task_struct *p)
1837{
1838 return unlikely(test_tsk_thread_flag(p,TIF_SIGPENDING));
1839}
1840
1841static inline int need_resched(void)
1842{
1843 return unlikely(test_thread_flag(TIF_NEED_RESCHED));
1844}
1845
1846
1847
1848
1849
1850
1851
1852
1853extern int cond_resched(void);
1854extern int cond_resched_lock(spinlock_t * lock);
1855extern int cond_resched_softirq(void);
1856
1857
1858
1859
1860
1861#if defined(CONFIG_PREEMPT) && defined(CONFIG_SMP)
1862# define need_lockbreak(lock) ((lock)->break_lock)
1863#else
1864# define need_lockbreak(lock) 0
1865#endif
1866
1867
1868
1869
1870
1871static inline int lock_need_resched(spinlock_t *lock)
1872{
1873 if (need_lockbreak(lock) || need_resched())
1874 return 1;
1875 return 0;
1876}
1877
1878
1879
1880
1881
1882
1883
1884extern void recalc_sigpending_and_wake(struct task_struct *t);
1885extern void recalc_sigpending(void);
1886
1887extern void signal_wake_up(struct task_struct *t, int resume_stopped);
1888
1889
1890
1891
1892#ifdef CONFIG_SMP
1893
1894static inline unsigned int task_cpu(const struct task_struct *p)
1895{
1896 return task_thread_info(p)->cpu;
1897}
1898
1899extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
1900
1901#else
1902
1903static inline unsigned int task_cpu(const struct task_struct *p)
1904{
1905 return 0;
1906}
1907
1908static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
1909{
1910}
1911
1912#endif
1913
1914#ifdef HAVE_ARCH_PICK_MMAP_LAYOUT
1915extern void arch_pick_mmap_layout(struct mm_struct *mm);
1916#else
1917static inline void arch_pick_mmap_layout(struct mm_struct *mm)
1918{
1919 mm->mmap_base = TASK_UNMAPPED_BASE;
1920 mm->get_unmapped_area = arch_get_unmapped_area;
1921 mm->unmap_area = arch_unmap_area;
1922}
1923#endif
1924
1925extern long sched_setaffinity(pid_t pid, cpumask_t new_mask);
1926extern long sched_getaffinity(pid_t pid, cpumask_t *mask);
1927
1928extern int sched_mc_power_savings, sched_smt_power_savings;
1929
1930extern void normalize_rt_tasks(void);
1931
1932#ifdef CONFIG_FAIR_GROUP_SCHED
1933
1934extern struct task_group init_task_group;
1935
1936extern struct task_group *sched_create_group(void);
1937extern void sched_destroy_group(struct task_group *tg);
1938extern void sched_move_task(struct task_struct *tsk);
1939extern int sched_group_set_shares(struct task_group *tg, unsigned long shares);
1940extern unsigned long sched_group_shares(struct task_group *tg);
1941
1942#endif
1943
1944#ifdef CONFIG_TASK_XACCT
1945static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
1946{
1947 tsk->rchar += amt;
1948}
1949
1950static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
1951{
1952 tsk->wchar += amt;
1953}
1954
1955static inline void inc_syscr(struct task_struct *tsk)
1956{
1957 tsk->syscr++;
1958}
1959
1960static inline void inc_syscw(struct task_struct *tsk)
1961{
1962 tsk->syscw++;
1963}
1964#else
1965static inline void add_rchar(struct task_struct *tsk, ssize_t amt)
1966{
1967}
1968
1969static inline void add_wchar(struct task_struct *tsk, ssize_t amt)
1970{
1971}
1972
1973static inline void inc_syscr(struct task_struct *tsk)
1974{
1975}
1976
1977static inline void inc_syscw(struct task_struct *tsk)
1978{
1979}
1980#endif
1981
1982#ifdef CONFIG_SMP
1983void migration_init(void);
1984#else
1985static inline void migration_init(void)
1986{
1987}
1988#endif
1989
1990#endif
1991
1992#endif
1993