First steps to our own task switch
[projects/modsched/linux.git] / kernel / sched.new / sched.h
1 #include <linux/sched.h>
2 #include <linux/sched/sysctl.h>
3 #include <linux/sched/rt.h>
4
5
6 struct task_group {
7 };
8
9 struct rq {
10         /* runqueue lock: */
11         raw_spinlock_t lock;
12
13         /*
14          * nr_running and cpu_load should be in the same cacheline because
15          * remote CPUs use both these fields when doing load calculation.
16          */
17         unsigned int nr_running;
18         #define CPU_LOAD_IDX_MAX 5
19         unsigned long cpu_load[CPU_LOAD_IDX_MAX];
20         unsigned long last_load_update_tick;
21         int skip_clock_update;
22
23         /* capture load from *all* tasks on this cpu: */
24         struct load_weight load;
25         unsigned long nr_load_updates;
26         u64 nr_switches;
27
28         /*
29          * This is part of a global counter where only the total sum
30          * over all CPUs matters. A task can increase this counter on
31          * one CPU and if it got migrated afterwards it may decrease
32          * it on another CPU. Always updated under the runqueue lock:
33          */
34         unsigned long nr_uninterruptible;
35
36         struct task_struct *curr, *idle, *stop;
37         struct task_struct *next;
38         unsigned long next_balance;
39         struct mm_struct *prev_mm;
40
41         u64 clock;
42         u64 clock_task;
43
44         atomic_t nr_iowait;
45
46         /* calc_load related fields */
47         unsigned long calc_load_update;
48         long calc_load_active;
49
50         struct sched_avg avg;
51 };
52
53 DECLARE_PER_CPU(struct rq, runqueues);
54
55 #define cpu_rq(cpu)             (&per_cpu(runqueues, (cpu)))
56
57 void account_idle_ticks(unsigned long ticks);
58
59 void account_process_tick(struct task_struct *p, int user_tick);
60
61 void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
62
63 void calc_global_load(unsigned long ticks);
64
65 //void calc_load_enter_idle(void);
66
67 //void calc_load_exit_idle(void);
68
69 int can_nice(const struct task_struct *p, const int nice);
70
71 int idle_cpu(int cpu);
72
73 void __cpuinit init_idle(struct task_struct *idle, int cpu);
74
75 void __cpuinit init_idle_bootup_task(struct task_struct *idle);
76
77 void normalize_rt_tasks(void);
78
79 unsigned long nr_running(void);
80
81 unsigned long long nr_context_switches(void);
82
83 unsigned long nr_iowait(void);
84
85 void rt_mutex_setprio(struct task_struct *p, int prio);
86
87 u64 sched_clock_cpu(int cpu);
88
89 void sched_clock_init(void);;
90
91 void sched_fork(struct task_struct *p);
92
93 long sched_getaffinity(pid_t pid, struct cpumask *mask);
94
95 void sched_init(void);
96
97 void sched_init_smp(void);
98
99 int sched_rr_handler(struct ctl_table *table, int write, void __user *buffer, size_t *lenp, loff_t *ppos);
100
101 long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
102
103 int sched_setscheduler(struct task_struct *p, int policy, const struct sched_param *param);
104
105 void sched_show_task(struct task_struct *p);
106
107 void schedule_tail(struct task_struct *prev);
108
109 void scheduler_tick(void);
110
111 long sys_nice(int increment);
112
113 long sys_sched_getaffinity(pid_t pid, unsigned int len, unsigned long __user *user_mask_ptr);
114
115 long sys_sched_setaffinity(pid_t pid, unsigned int len, unsigned long __user *user_mask_ptr);
116
117 unsigned long long task_delta_exec(struct task_struct *);
118
119 int task_prio(const struct task_struct *p);
120
121 unsigned long long task_sched_runtime(struct task_struct *task);
122
123 unsigned long this_cpu_load(void);
124
125 void update_cpu_load_nohz(void);
126
127 void wake_up_new_task(struct task_struct *tsk);
128
129
130 int __sched _cond_resched(void);
131
132 asmlinkage void __sched schedule(void);
133
134 void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr_exclusive, void *key);
135
136 int wake_up_process(struct task_struct *p);
137
138 void __sched wait_for_completion(struct completion *x);
139
140 void complete(struct completion *x);
141
142 void __sched schedule_preempt_disabled(void);
143
144 int in_sched_functions(unsigned long addr);
145
146 void sched_clock_idle_sleep_event(void);
147
148 void sched_clock_idle_wakeup_event(u64 delta_ns);
149
150 int __cond_resched_lock(spinlock_t *lock);
151
152 u64 local_clock(void);
153
154 int default_wake_function(wait_queue_t *curr, unsigned mode, int wake_flags,
155                           void *key);
156
157 int __sched wait_for_completion_killable(struct completion *x);
158
159 void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode,
160                         int nr_exclusive, void *key);
161
162 int wake_up_state(struct task_struct *p, unsigned int state);
163
164 void __sched yield(void);
165
166 inline int task_curr(const struct task_struct *p);
167
168 int task_nice(const struct task_struct *p);
169
170 void set_user_nice(struct task_struct *p, long nice);
171
172 void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key);
173
174 void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive);
175
176 void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr);
177