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