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